diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/code-frame/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/code-frame/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/code-frame/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/code-frame/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/code-frame/README.md new file mode 100644 index 0000000000000000000000000000000000000000..7160755113aaa771161a0626a7a9c7b6a99ac8d8 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/code-frame/README.md @@ -0,0 +1,19 @@ +# @babel/code-frame + +> Generate errors that contain a code frame that point to source locations. + +See our website [@babel/code-frame](https://babeljs.io/docs/babel-code-frame) for more information. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/code-frame +``` + +or using yarn: + +```sh +yarn add @babel/code-frame --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/code-frame/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/code-frame/package.json new file mode 100644 index 0000000000000000000000000000000000000000..c95c244904320beb7107f0cec175c9b45fd816b3 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/code-frame/package.json @@ -0,0 +1,31 @@ +{ + "name": "@babel/code-frame", + "version": "7.27.1", + "description": "Generate errors that contain a code frame that point to source locations.", + "author": "The Babel Team (https://babel.dev/team)", + "homepage": "https://babel.dev/docs/en/next/babel-code-frame", + "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-code-frame" + }, + "main": "./lib/index.js", + "dependencies": { + "@babel/helper-validator-identifier": "^7.27.1", + "js-tokens": "^4.0.0", + "picocolors": "^1.1.1" + }, + "devDependencies": { + "import-meta-resolve": "^4.1.0", + "strip-ansi": "^4.0.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "type": "commonjs" +} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/README.md new file mode 100644 index 0000000000000000000000000000000000000000..c19189872ec7139957f70c5f933ca0572db8d6a1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/README.md @@ -0,0 +1,19 @@ +# @babel/compat-data + +> The compat-data to determine required Babel plugins + +See our website [@babel/compat-data](https://babeljs.io/docs/babel-compat-data) for more information. + +## Install + +Using npm: + +```sh +npm install --save @babel/compat-data +``` + +or using yarn: + +```sh +yarn add @babel/compat-data +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/corejs2-built-ins.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/corejs2-built-ins.js new file mode 100644 index 0000000000000000000000000000000000000000..ed19e0b8a4ffd6bf191602c04d7c9308038f5562 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/corejs2-built-ins.js @@ -0,0 +1,2 @@ +// Todo (Babel 8): remove this file as Babel 8 drop support of core-js 2 +module.exports = require("./data/corejs2-built-ins.json"); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/corejs3-shipped-proposals.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/corejs3-shipped-proposals.js new file mode 100644 index 0000000000000000000000000000000000000000..7909b8c46d3717def2168c9a1e8cc6a068b29541 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/corejs3-shipped-proposals.js @@ -0,0 +1,2 @@ +// Todo (Babel 8): remove this file now that it is included in babel-plugin-polyfill-corejs3 +module.exports = require("./data/corejs3-shipped-proposals.json"); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/native-modules.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/native-modules.js new file mode 100644 index 0000000000000000000000000000000000000000..f8c25fa37c725bf198ca05821ec0515e377fe137 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/native-modules.js @@ -0,0 +1,2 @@ +// Todo (Babel 8): remove this file, in Babel 8 users import the .json directly +module.exports = require("./data/native-modules.json"); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/overlapping-plugins.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/overlapping-plugins.js new file mode 100644 index 0000000000000000000000000000000000000000..0dd35f1573f98ceb7d2c947e658b8bd0fcf639bb --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/overlapping-plugins.js @@ -0,0 +1,2 @@ +// Todo (Babel 8): remove this file, in Babel 8 users import the .json directly +module.exports = require("./data/overlapping-plugins.json"); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/package.json new file mode 100644 index 0000000000000000000000000000000000000000..4b84f861e07e82220ec12b48b126d20706a02105 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/package.json @@ -0,0 +1,40 @@ +{ + "name": "@babel/compat-data", + "version": "7.28.0", + "author": "The Babel Team (https://babel.dev/team)", + "license": "MIT", + "description": "The compat-data to determine required Babel plugins", + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-compat-data" + }, + "publishConfig": { + "access": "public" + }, + "exports": { + "./plugins": "./plugins.js", + "./native-modules": "./native-modules.js", + "./corejs2-built-ins": "./corejs2-built-ins.js", + "./corejs3-shipped-proposals": "./corejs3-shipped-proposals.js", + "./overlapping-plugins": "./overlapping-plugins.js", + "./plugin-bugfixes": "./plugin-bugfixes.js" + }, + "scripts": { + "build-data": "./scripts/download-compat-table.sh && node ./scripts/build-data.mjs && node ./scripts/build-modules-support.mjs && node ./scripts/build-bugfixes-targets.mjs" + }, + "keywords": [ + "babel", + "compat-table", + "compat-data" + ], + "devDependencies": { + "@mdn/browser-compat-data": "^6.0.8", + "core-js-compat": "^3.43.0", + "electron-to-chromium": "^1.5.140" + }, + "engines": { + "node": ">=6.9.0" + }, + "type": "commonjs" +} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/plugin-bugfixes.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/plugin-bugfixes.js new file mode 100644 index 0000000000000000000000000000000000000000..9aaf3641701370ff57b1a2866a0e5c811cf7ac04 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/plugin-bugfixes.js @@ -0,0 +1,2 @@ +// Todo (Babel 8): remove this file, in Babel 8 users import the .json directly +module.exports = require("./data/plugin-bugfixes.json"); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/plugins.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/plugins.js new file mode 100644 index 0000000000000000000000000000000000000000..b191017be6a865bb2760ca351d9f1e610693468c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/compat-data/plugins.js @@ -0,0 +1,2 @@ +// Todo (Babel 8): remove this file, in Babel 8 users import the .json directly +module.exports = require("./data/plugins.json"); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/core/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/core/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/core/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/core/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/core/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2903543469699795279ec0c977ee56114bd21e01 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/core/README.md @@ -0,0 +1,19 @@ +# @babel/core + +> Babel compiler core. + +See our website [@babel/core](https://babeljs.io/docs/babel-core) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20core%22+is%3Aopen) associated with this package. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/core +``` + +or using yarn: + +```sh +yarn add @babel/core --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/core/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/core/package.json new file mode 100644 index 0000000000000000000000000000000000000000..d626ef0bf8e52a36b1b316c4d0597ad1be80e566 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/core/package.json @@ -0,0 +1,82 @@ +{ + "name": "@babel/core", + "version": "7.28.3", + "description": "Babel compiler core.", + "main": "./lib/index.js", + "author": "The Babel Team (https://babel.dev/team)", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-core" + }, + "homepage": "https://babel.dev/docs/en/next/babel-core", + "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20core%22+is%3Aopen", + "keywords": [ + "6to5", + "babel", + "classes", + "const", + "es6", + "harmony", + "let", + "modules", + "transpile", + "transpiler", + "var", + "babel-core", + "compiler" + ], + "engines": { + "node": ">=6.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/babel" + }, + "browser": { + "./lib/config/files/index.js": "./lib/config/files/index-browser.js", + "./lib/config/resolve-targets.js": "./lib/config/resolve-targets-browser.js", + "./lib/transform-file.js": "./lib/transform-file-browser.js", + "./src/config/files/index.ts": "./src/config/files/index-browser.ts", + "./src/config/resolve-targets.ts": "./src/config/resolve-targets-browser.ts", + "./src/transform-file.ts": "./src/transform-file-browser.ts" + }, + "dependencies": { + "@ampproject/remapping": "^2.2.0", + "@babel/code-frame": "^7.27.1", + "@babel/generator": "^7.28.3", + "@babel/helper-compilation-targets": "^7.27.2", + "@babel/helper-module-transforms": "^7.28.3", + "@babel/helpers": "^7.28.3", + "@babel/parser": "^7.28.3", + "@babel/template": "^7.27.2", + "@babel/traverse": "^7.28.3", + "@babel/types": "^7.28.2", + "convert-source-map": "^2.0.0", + "debug": "^4.1.0", + "gensync": "^1.0.0-beta.2", + "json5": "^2.2.3", + "semver": "^6.3.1" + }, + "devDependencies": { + "@babel/helper-transform-fixture-test-runner": "^7.28.3", + "@babel/plugin-syntax-flow": "^7.27.1", + "@babel/plugin-transform-flow-strip-types": "^7.27.1", + "@babel/plugin-transform-modules-commonjs": "^7.27.1", + "@babel/preset-env": "^7.28.3", + "@babel/preset-typescript": "^7.27.1", + "@jridgewell/trace-mapping": "^0.3.28", + "@types/convert-source-map": "^2.0.0", + "@types/debug": "^4.1.0", + "@types/resolve": "^1.3.2", + "@types/semver": "^5.4.0", + "rimraf": "^3.0.0", + "ts-node": "^11.0.0-beta.1", + "tsx": "^4.20.3" + }, + "type": "commonjs" +} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d56149a837d2fb71534f3cc7edc8bf9cb36db623 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/README.md @@ -0,0 +1,19 @@ +# @babel/generator + +> Turns an AST into code. + +See our website [@babel/generator](https://babeljs.io/docs/babel-generator) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20generator%22+is%3Aopen) associated with this package. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/generator +``` + +or using yarn: + +```sh +yarn add @babel/generator --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/buffer.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/buffer.js new file mode 100644 index 0000000000000000000000000000000000000000..23bedfa742d3e5cbc56576c5c61462ea0c59ece8 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/buffer.js @@ -0,0 +1,317 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; +class Buffer { + constructor(map, indentChar) { + this._map = null; + this._buf = ""; + this._str = ""; + this._appendCount = 0; + this._last = 0; + this._queue = []; + this._queueCursor = 0; + this._canMarkIdName = true; + this._indentChar = ""; + this._fastIndentations = []; + this._position = { + line: 1, + column: 0 + }; + this._sourcePosition = { + identifierName: undefined, + identifierNamePos: undefined, + line: undefined, + column: undefined, + filename: undefined + }; + this._map = map; + this._indentChar = indentChar; + for (let i = 0; i < 64; i++) { + this._fastIndentations.push(indentChar.repeat(i)); + } + this._allocQueue(); + } + _allocQueue() { + const queue = this._queue; + for (let i = 0; i < 16; i++) { + queue.push({ + char: 0, + repeat: 1, + line: undefined, + column: undefined, + identifierName: undefined, + identifierNamePos: undefined, + filename: "" + }); + } + } + _pushQueue(char, repeat, line, column, filename) { + const cursor = this._queueCursor; + if (cursor === this._queue.length) { + this._allocQueue(); + } + const item = this._queue[cursor]; + item.char = char; + item.repeat = repeat; + item.line = line; + item.column = column; + item.filename = filename; + this._queueCursor++; + } + _popQueue() { + if (this._queueCursor === 0) { + throw new Error("Cannot pop from empty queue"); + } + return this._queue[--this._queueCursor]; + } + get() { + this._flush(); + const map = this._map; + const result = { + code: (this._buf + this._str).trimRight(), + decodedMap: map == null ? void 0 : map.getDecoded(), + get __mergedMap() { + return this.map; + }, + get map() { + const resultMap = map ? map.get() : null; + result.map = resultMap; + return resultMap; + }, + set map(value) { + Object.defineProperty(result, "map", { + value, + writable: true + }); + }, + get rawMappings() { + const mappings = map == null ? void 0 : map.getRawMappings(); + result.rawMappings = mappings; + return mappings; + }, + set rawMappings(value) { + Object.defineProperty(result, "rawMappings", { + value, + writable: true + }); + } + }; + return result; + } + append(str, maybeNewline) { + this._flush(); + this._append(str, this._sourcePosition, maybeNewline); + } + appendChar(char) { + this._flush(); + this._appendChar(char, 1, this._sourcePosition); + } + queue(char) { + if (char === 10) { + while (this._queueCursor !== 0) { + const char = this._queue[this._queueCursor - 1].char; + if (char !== 32 && char !== 9) { + break; + } + this._queueCursor--; + } + } + const sourcePosition = this._sourcePosition; + this._pushQueue(char, 1, sourcePosition.line, sourcePosition.column, sourcePosition.filename); + } + queueIndentation(repeat) { + if (repeat === 0) return; + this._pushQueue(-1, repeat, undefined, undefined, undefined); + } + _flush() { + const queueCursor = this._queueCursor; + const queue = this._queue; + for (let i = 0; i < queueCursor; i++) { + const item = queue[i]; + this._appendChar(item.char, item.repeat, item); + } + this._queueCursor = 0; + } + _appendChar(char, repeat, sourcePos) { + this._last = char; + if (char === -1) { + const fastIndentation = this._fastIndentations[repeat]; + if (fastIndentation !== undefined) { + this._str += fastIndentation; + } else { + this._str += repeat > 1 ? this._indentChar.repeat(repeat) : this._indentChar; + } + } else { + this._str += repeat > 1 ? String.fromCharCode(char).repeat(repeat) : String.fromCharCode(char); + } + if (char !== 10) { + this._mark(sourcePos.line, sourcePos.column, sourcePos.identifierName, sourcePos.identifierNamePos, sourcePos.filename); + this._position.column += repeat; + } else { + this._position.line++; + this._position.column = 0; + } + if (this._canMarkIdName) { + sourcePos.identifierName = undefined; + sourcePos.identifierNamePos = undefined; + } + } + _append(str, sourcePos, maybeNewline) { + const len = str.length; + const position = this._position; + this._last = str.charCodeAt(len - 1); + if (++this._appendCount > 4096) { + +this._str; + this._buf += this._str; + this._str = str; + this._appendCount = 0; + } else { + this._str += str; + } + if (!maybeNewline && !this._map) { + position.column += len; + return; + } + const { + column, + identifierName, + identifierNamePos, + filename + } = sourcePos; + let line = sourcePos.line; + if ((identifierName != null || identifierNamePos != null) && this._canMarkIdName) { + sourcePos.identifierName = undefined; + sourcePos.identifierNamePos = undefined; + } + let i = str.indexOf("\n"); + let last = 0; + if (i !== 0) { + this._mark(line, column, identifierName, identifierNamePos, filename); + } + while (i !== -1) { + position.line++; + position.column = 0; + last = i + 1; + if (last < len && line !== undefined) { + this._mark(++line, 0, null, null, filename); + } + i = str.indexOf("\n", last); + } + position.column += len - last; + } + _mark(line, column, identifierName, identifierNamePos, filename) { + var _this$_map; + (_this$_map = this._map) == null || _this$_map.mark(this._position, line, column, identifierName, identifierNamePos, filename); + } + removeTrailingNewline() { + const queueCursor = this._queueCursor; + if (queueCursor !== 0 && this._queue[queueCursor - 1].char === 10) { + this._queueCursor--; + } + } + removeLastSemicolon() { + const queueCursor = this._queueCursor; + if (queueCursor !== 0 && this._queue[queueCursor - 1].char === 59) { + this._queueCursor--; + } + } + getLastChar() { + const queueCursor = this._queueCursor; + return queueCursor !== 0 ? this._queue[queueCursor - 1].char : this._last; + } + getNewlineCount() { + const queueCursor = this._queueCursor; + let count = 0; + if (queueCursor === 0) return this._last === 10 ? 1 : 0; + for (let i = queueCursor - 1; i >= 0; i--) { + if (this._queue[i].char !== 10) { + break; + } + count++; + } + return count === queueCursor && this._last === 10 ? count + 1 : count; + } + endsWithCharAndNewline() { + const queue = this._queue; + const queueCursor = this._queueCursor; + if (queueCursor !== 0) { + const lastCp = queue[queueCursor - 1].char; + if (lastCp !== 10) return; + if (queueCursor > 1) { + return queue[queueCursor - 2].char; + } else { + return this._last; + } + } + } + hasContent() { + return this._queueCursor !== 0 || !!this._last; + } + exactSource(loc, cb) { + if (!this._map) { + cb(); + return; + } + this.source("start", loc); + const identifierName = loc.identifierName; + const sourcePos = this._sourcePosition; + if (identifierName) { + this._canMarkIdName = false; + sourcePos.identifierName = identifierName; + } + cb(); + if (identifierName) { + this._canMarkIdName = true; + sourcePos.identifierName = undefined; + sourcePos.identifierNamePos = undefined; + } + this.source("end", loc); + } + source(prop, loc) { + if (!this._map) return; + this._normalizePosition(prop, loc, 0); + } + sourceWithOffset(prop, loc, columnOffset) { + if (!this._map) return; + this._normalizePosition(prop, loc, columnOffset); + } + _normalizePosition(prop, loc, columnOffset) { + const pos = loc[prop]; + const target = this._sourcePosition; + if (pos) { + target.line = pos.line; + target.column = Math.max(pos.column + columnOffset, 0); + target.filename = loc.filename; + } + } + getCurrentColumn() { + const queue = this._queue; + const queueCursor = this._queueCursor; + let lastIndex = -1; + let len = 0; + for (let i = 0; i < queueCursor; i++) { + const item = queue[i]; + if (item.char === 10) { + lastIndex = len; + } + len += item.repeat; + } + return lastIndex === -1 ? this._position.column + len : len - 1 - lastIndex; + } + getCurrentLine() { + let count = 0; + const queue = this._queue; + for (let i = 0; i < this._queueCursor; i++) { + if (queue[i].char === 10) { + count++; + } + } + return this._position.line + count; + } +} +exports.default = Buffer; + +//# sourceMappingURL=buffer.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/buffer.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/buffer.js.map new file mode 100644 index 0000000000000000000000000000000000000000..d92c017dcd20ee98bd0fe811d854e3a542897c55 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/buffer.js.map @@ -0,0 +1 @@ +{"version":3,"names":["Buffer","constructor","map","indentChar","_map","_buf","_str","_appendCount","_last","_queue","_queueCursor","_canMarkIdName","_indentChar","_fastIndentations","_position","line","column","_sourcePosition","identifierName","undefined","identifierNamePos","filename","i","push","repeat","_allocQueue","queue","char","_pushQueue","cursor","length","item","_popQueue","Error","get","_flush","result","code","trimRight","decodedMap","getDecoded","__mergedMap","resultMap","value","Object","defineProperty","writable","rawMappings","mappings","getRawMappings","append","str","maybeNewline","_append","appendChar","_appendChar","sourcePosition","queueIndentation","queueCursor","sourcePos","fastIndentation","String","fromCharCode","_mark","len","position","charCodeAt","indexOf","last","_this$_map","mark","removeTrailingNewline","removeLastSemicolon","getLastChar","getNewlineCount","count","endsWithCharAndNewline","lastCp","hasContent","exactSource","loc","cb","source","prop","_normalizePosition","sourceWithOffset","columnOffset","pos","target","Math","max","getCurrentColumn","lastIndex","getCurrentLine","exports","default"],"sources":["../src/buffer.ts"],"sourcesContent":["import type SourceMap from \"./source-map.ts\";\n\n// We inline this package\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport * as charcodes from \"charcodes\";\n\nexport type Pos = {\n line: number;\n column: number;\n index: number;\n};\nexport type Loc = {\n start?: Pos;\n end?: Pos;\n filename?: string;\n};\ntype SourcePos = {\n line: number | undefined;\n column: number | undefined;\n identifierName: string | undefined;\n filename: string | undefined;\n};\ntype InternalSourcePos = SourcePos & { identifierNamePos: Pos };\n\ntype QueueItem = {\n char: number;\n repeat: number;\n line: number | undefined;\n column: number | undefined;\n identifierName: undefined; // Not used, it always undefined.\n identifierNamePos: undefined; // Not used, it always undefined.\n filename: string | undefined;\n};\n\nexport default class Buffer {\n constructor(map: SourceMap | null, indentChar: string) {\n this._map = map;\n this._indentChar = indentChar;\n\n for (let i = 0; i < 64; i++) {\n this._fastIndentations.push(indentChar.repeat(i));\n }\n\n this._allocQueue();\n }\n\n _map: SourceMap = null;\n _buf = \"\";\n _str = \"\";\n _appendCount = 0;\n _last = 0;\n _queue: QueueItem[] = [];\n _queueCursor = 0;\n _canMarkIdName = true;\n _indentChar = \"\";\n _fastIndentations: string[] = [];\n\n _position = {\n line: 1,\n column: 0,\n };\n _sourcePosition: InternalSourcePos = {\n identifierName: undefined,\n identifierNamePos: undefined,\n line: undefined,\n column: undefined,\n filename: undefined,\n };\n\n _allocQueue() {\n const queue = this._queue;\n\n for (let i = 0; i < 16; i++) {\n queue.push({\n char: 0,\n repeat: 1,\n line: undefined,\n column: undefined,\n identifierName: undefined,\n identifierNamePos: undefined,\n filename: \"\",\n });\n }\n }\n\n _pushQueue(\n char: number,\n repeat: number,\n line: number | undefined,\n column: number | undefined,\n filename: string | undefined,\n ) {\n const cursor = this._queueCursor;\n if (cursor === this._queue.length) {\n this._allocQueue();\n }\n const item = this._queue[cursor];\n item.char = char;\n item.repeat = repeat;\n item.line = line;\n item.column = column;\n item.filename = filename;\n\n this._queueCursor++;\n }\n\n _popQueue(): QueueItem {\n if (this._queueCursor === 0) {\n throw new Error(\"Cannot pop from empty queue\");\n }\n return this._queue[--this._queueCursor];\n }\n\n /**\n * Get the final string output from the buffer, along with the sourcemap if one exists.\n */\n\n get() {\n this._flush();\n\n const map = this._map;\n const result = {\n // Whatever trim is used here should not execute a regex against the\n // source string since it may be arbitrarily large after all transformations\n code: (this._buf + this._str).trimRight(),\n // Decoded sourcemap is free to generate.\n decodedMap: map?.getDecoded(),\n // Used as a marker for backwards compatibility. We moved input map merging\n // into the generator. We cannot merge the input map a second time, so the\n // presence of this field tells us we've already done the work.\n get __mergedMap() {\n return this.map;\n },\n // Encoding the sourcemap is moderately CPU expensive.\n get map() {\n const resultMap = map ? map.get() : null;\n result.map = resultMap;\n return resultMap;\n },\n set map(value) {\n Object.defineProperty(result, \"map\", { value, writable: true });\n },\n // Retrieving the raw mappings is very memory intensive.\n get rawMappings() {\n const mappings = map?.getRawMappings();\n result.rawMappings = mappings;\n return mappings;\n },\n set rawMappings(value) {\n Object.defineProperty(result, \"rawMappings\", { value, writable: true });\n },\n };\n\n return result;\n }\n\n /**\n * Add a string to the buffer that cannot be reverted.\n */\n\n append(str: string, maybeNewline: boolean): void {\n this._flush();\n\n this._append(str, this._sourcePosition, maybeNewline);\n }\n\n appendChar(char: number): void {\n this._flush();\n this._appendChar(char, 1, this._sourcePosition);\n }\n\n /**\n * Add a string to the buffer than can be reverted.\n */\n queue(char: number): void {\n // Drop trailing spaces when a newline is inserted.\n if (char === charcodes.lineFeed) {\n while (this._queueCursor !== 0) {\n const char = this._queue[this._queueCursor - 1].char;\n if (char !== charcodes.space && char !== charcodes.tab) {\n break;\n }\n\n this._queueCursor--;\n }\n }\n\n const sourcePosition = this._sourcePosition;\n this._pushQueue(\n char,\n 1,\n sourcePosition.line,\n sourcePosition.column,\n sourcePosition.filename,\n );\n }\n\n /**\n * Same as queue, but this indentation will never have a sourcemap marker.\n */\n queueIndentation(repeat: number): void {\n if (repeat === 0) return;\n this._pushQueue(-1, repeat, undefined, undefined, undefined);\n }\n\n _flush(): void {\n const queueCursor = this._queueCursor;\n const queue = this._queue;\n for (let i = 0; i < queueCursor; i++) {\n const item: QueueItem = queue[i];\n this._appendChar(item.char, item.repeat, item);\n }\n this._queueCursor = 0;\n }\n\n _appendChar(\n char: number,\n repeat: number,\n sourcePos: InternalSourcePos,\n ): void {\n this._last = char;\n\n if (char === -1) {\n const fastIndentation = this._fastIndentations[repeat];\n if (fastIndentation !== undefined) {\n this._str += fastIndentation;\n } else {\n this._str +=\n repeat > 1 ? this._indentChar.repeat(repeat) : this._indentChar;\n }\n } else {\n this._str +=\n repeat > 1\n ? String.fromCharCode(char).repeat(repeat)\n : String.fromCharCode(char);\n }\n\n if (char !== charcodes.lineFeed) {\n this._mark(\n sourcePos.line,\n sourcePos.column,\n sourcePos.identifierName,\n sourcePos.identifierNamePos,\n sourcePos.filename,\n );\n this._position.column += repeat;\n } else {\n this._position.line++;\n this._position.column = 0;\n }\n\n if (this._canMarkIdName) {\n sourcePos.identifierName = undefined;\n sourcePos.identifierNamePos = undefined;\n }\n }\n\n _append(\n str: string,\n sourcePos: InternalSourcePos,\n maybeNewline: boolean,\n ): void {\n const len = str.length;\n const position = this._position;\n\n this._last = str.charCodeAt(len - 1);\n\n if (++this._appendCount > 4096) {\n // eslint-disable-next-line @typescript-eslint/no-unused-expressions\n +this._str; // Unexplainable huge performance boost. Ref: https://github.com/davidmarkclements/flatstr License: MIT\n this._buf += this._str;\n this._str = str;\n this._appendCount = 0;\n } else {\n this._str += str;\n }\n\n if (!maybeNewline && !this._map) {\n position.column += len;\n return;\n }\n\n const { column, identifierName, identifierNamePos, filename } = sourcePos;\n let line = sourcePos.line;\n\n if (\n (identifierName != null || identifierNamePos != null) &&\n this._canMarkIdName\n ) {\n sourcePos.identifierName = undefined;\n sourcePos.identifierNamePos = undefined;\n }\n\n // Search for newline chars. We search only for `\\n`, since both `\\r` and\n // `\\r\\n` are normalized to `\\n` during parse. We exclude `\\u2028` and\n // `\\u2029` for performance reasons, they're so uncommon that it's probably\n // ok. It's also unclear how other sourcemap utilities handle them...\n let i = str.indexOf(\"\\n\");\n let last = 0;\n\n // If the string starts with a newline char, then adding a mark is redundant.\n // This catches both \"no newlines\" and \"newline after several chars\".\n if (i !== 0) {\n this._mark(line, column, identifierName, identifierNamePos, filename);\n }\n\n // Now, find each remaining newline char in the string.\n while (i !== -1) {\n position.line++;\n position.column = 0;\n last = i + 1;\n\n // We mark the start of each line, which happens directly after this newline char\n // unless this is the last char.\n // When manually adding multi-line content (such as a comment), `line` will be `undefined`.\n if (last < len && line !== undefined) {\n this._mark(++line, 0, null, null, filename);\n }\n i = str.indexOf(\"\\n\", last);\n }\n position.column += len - last;\n }\n\n _mark(\n line: number | undefined,\n column: number | undefined,\n identifierName: string | undefined,\n identifierNamePos: Pos | undefined,\n filename: string | undefined,\n ): void {\n this._map?.mark(\n this._position,\n line,\n column,\n identifierName,\n identifierNamePos,\n filename,\n );\n }\n\n removeTrailingNewline(): void {\n const queueCursor = this._queueCursor;\n if (\n queueCursor !== 0 &&\n this._queue[queueCursor - 1].char === charcodes.lineFeed\n ) {\n this._queueCursor--;\n }\n }\n\n removeLastSemicolon(): void {\n const queueCursor = this._queueCursor;\n if (\n queueCursor !== 0 &&\n this._queue[queueCursor - 1].char === charcodes.semicolon\n ) {\n this._queueCursor--;\n }\n }\n\n getLastChar(): number {\n const queueCursor = this._queueCursor;\n return queueCursor !== 0 ? this._queue[queueCursor - 1].char : this._last;\n }\n\n /**\n * This will only detect at most 1 newline after a call to `flush()`,\n * but this has not been found so far, and an accurate count can be achieved if needed later.\n */\n getNewlineCount(): number {\n const queueCursor = this._queueCursor;\n let count = 0;\n if (queueCursor === 0) return this._last === charcodes.lineFeed ? 1 : 0;\n for (let i = queueCursor - 1; i >= 0; i--) {\n if (this._queue[i].char !== charcodes.lineFeed) {\n break;\n }\n count++;\n }\n return count === queueCursor && this._last === charcodes.lineFeed\n ? count + 1\n : count;\n }\n\n /**\n * check if current _last + queue ends with newline, return the character before newline\n */\n endsWithCharAndNewline(): number {\n const queue = this._queue;\n const queueCursor = this._queueCursor;\n if (queueCursor !== 0) {\n // every element in queue is one-length whitespace string\n const lastCp = queue[queueCursor - 1].char;\n if (lastCp !== charcodes.lineFeed) return;\n if (queueCursor > 1) {\n return queue[queueCursor - 2].char;\n } else {\n return this._last;\n }\n }\n // We assume that everything being matched is at most a single token plus some whitespace,\n // which everything currently is, but otherwise we'd have to expand _last or check _buf.\n }\n\n hasContent(): boolean {\n return this._queueCursor !== 0 || !!this._last;\n }\n\n /**\n * Certain sourcemap usecases expect mappings to be more accurate than\n * Babel's generic sourcemap handling allows. For now, we special-case\n * identifiers to allow for the primary cases to work.\n * The goal of this line is to ensure that the map output from Babel will\n * have an exact range on identifiers in the output code. Without this\n * line, Babel would potentially include some number of trailing tokens\n * that are printed after the identifier, but before another location has\n * been assigned.\n * This allows tooling like Rollup and Webpack to more accurately perform\n * their own transformations. Most importantly, this allows the import/export\n * transformations performed by those tools to loose less information when\n * applying their own transformations on top of the code and map results\n * generated by Babel itself.\n *\n * The primary example of this is the snippet:\n *\n * import mod from \"mod\";\n * mod();\n *\n * With this line, there will be one mapping range over \"mod\" and another\n * over \"();\", where previously it would have been a single mapping.\n */\n exactSource(loc: Loc | undefined, cb: () => void) {\n if (!this._map) {\n cb();\n return;\n }\n\n this.source(\"start\", loc);\n // @ts-expect-error identifierName is not defined\n const identifierName = loc.identifierName;\n const sourcePos = this._sourcePosition;\n if (identifierName) {\n this._canMarkIdName = false;\n sourcePos.identifierName = identifierName;\n }\n cb();\n\n if (identifierName) {\n this._canMarkIdName = true;\n sourcePos.identifierName = undefined;\n sourcePos.identifierNamePos = undefined;\n }\n this.source(\"end\", loc);\n }\n\n /**\n * Sets a given position as the current source location so generated code after this call\n * will be given this position in the sourcemap.\n */\n\n source(prop: \"start\" | \"end\", loc: Loc | undefined): void {\n if (!this._map) return;\n\n // Since this is called extremely often, we reuse the same _sourcePosition\n // object for the whole lifetime of the buffer.\n this._normalizePosition(prop, loc, 0);\n }\n\n sourceWithOffset(\n prop: \"start\" | \"end\",\n loc: Loc | undefined,\n columnOffset: number,\n ): void {\n if (!this._map) return;\n\n this._normalizePosition(prop, loc, columnOffset);\n }\n\n _normalizePosition(prop: \"start\" | \"end\", loc: Loc, columnOffset: number) {\n const pos = loc[prop];\n const target = this._sourcePosition;\n\n if (pos) {\n target.line = pos.line;\n // TODO: Fix https://github.com/babel/babel/issues/15712 in downstream\n target.column = Math.max(pos.column + columnOffset, 0);\n target.filename = loc.filename;\n }\n }\n\n getCurrentColumn(): number {\n const queue = this._queue;\n const queueCursor = this._queueCursor;\n\n let lastIndex = -1;\n let len = 0;\n for (let i = 0; i < queueCursor; i++) {\n const item = queue[i];\n if (item.char === charcodes.lineFeed) {\n lastIndex = len;\n }\n len += item.repeat;\n }\n\n return lastIndex === -1 ? this._position.column + len : len - 1 - lastIndex;\n }\n\n getCurrentLine(): number {\n let count = 0;\n\n const queue = this._queue;\n for (let i = 0; i < this._queueCursor; i++) {\n if (queue[i].char === charcodes.lineFeed) {\n count++;\n }\n }\n\n return this._position.line + count;\n }\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/base.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/base.js new file mode 100644 index 0000000000000000000000000000000000000000..eca90770bc52d7778228c0b931dd1456ac06e7df --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/base.js @@ -0,0 +1,87 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.BlockStatement = BlockStatement; +exports.Directive = Directive; +exports.DirectiveLiteral = DirectiveLiteral; +exports.File = File; +exports.InterpreterDirective = InterpreterDirective; +exports.Placeholder = Placeholder; +exports.Program = Program; +function File(node) { + if (node.program) { + this.print(node.program.interpreter); + } + this.print(node.program); +} +function Program(node) { + var _node$directives; + this.noIndentInnerCommentsHere(); + this.printInnerComments(); + const directivesLen = (_node$directives = node.directives) == null ? void 0 : _node$directives.length; + if (directivesLen) { + var _node$directives$trai; + const newline = node.body.length ? 2 : 1; + this.printSequence(node.directives, undefined, newline); + if (!((_node$directives$trai = node.directives[directivesLen - 1].trailingComments) != null && _node$directives$trai.length)) { + this.newline(newline); + } + } + this.printSequence(node.body); +} +function BlockStatement(node) { + var _node$directives2; + this.tokenChar(123); + const exit = this.enterDelimited(); + const directivesLen = (_node$directives2 = node.directives) == null ? void 0 : _node$directives2.length; + if (directivesLen) { + var _node$directives$trai2; + const newline = node.body.length ? 2 : 1; + this.printSequence(node.directives, true, newline); + if (!((_node$directives$trai2 = node.directives[directivesLen - 1].trailingComments) != null && _node$directives$trai2.length)) { + this.newline(newline); + } + } + this.printSequence(node.body, true); + exit(); + this.rightBrace(node); +} +function Directive(node) { + this.print(node.value); + this.semicolon(); +} +const unescapedSingleQuoteRE = /(?:^|[^\\])(?:\\\\)*'/; +const unescapedDoubleQuoteRE = /(?:^|[^\\])(?:\\\\)*"/; +function DirectiveLiteral(node) { + const raw = this.getPossibleRaw(node); + if (!this.format.minified && raw !== undefined) { + this.token(raw); + return; + } + const { + value + } = node; + if (!unescapedDoubleQuoteRE.test(value)) { + this.token(`"${value}"`); + } else if (!unescapedSingleQuoteRE.test(value)) { + this.token(`'${value}'`); + } else { + throw new Error("Malformed AST: it is not possible to print a directive containing" + " both unescaped single and double quotes."); + } +} +function InterpreterDirective(node) { + this.token(`#!${node.value}`); + this.newline(1, true); +} +function Placeholder(node) { + this.token("%%"); + this.print(node.name); + this.token("%%"); + if (node.expectedNode === "Statement") { + this.semicolon(); + } +} + +//# sourceMappingURL=base.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/base.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/base.js.map new file mode 100644 index 0000000000000000000000000000000000000000..c40d63c555668b4f2f21ffadac2cc58423d293fd --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/base.js.map @@ -0,0 +1 @@ +{"version":3,"names":["File","node","program","print","interpreter","Program","_node$directives","noIndentInnerCommentsHere","printInnerComments","directivesLen","directives","length","_node$directives$trai","newline","body","printSequence","undefined","trailingComments","BlockStatement","_node$directives2","token","exit","enterDelimited","_node$directives$trai2","rightBrace","Directive","value","semicolon","unescapedSingleQuoteRE","unescapedDoubleQuoteRE","DirectiveLiteral","raw","getPossibleRaw","format","minified","test","Error","InterpreterDirective","Placeholder","name","expectedNode"],"sources":["../../src/generators/base.ts"],"sourcesContent":["import type Printer from \"../printer.ts\";\nimport type * as t from \"@babel/types\";\n\nexport function File(this: Printer, node: t.File) {\n if (node.program) {\n // Print this here to ensure that Program node 'leadingComments' still\n // get printed after the hashbang.\n this.print(node.program.interpreter);\n }\n\n this.print(node.program);\n}\n\nexport function Program(this: Printer, node: t.Program) {\n // An empty Program doesn't have any inner tokens, so\n // we must explicitly print its inner comments.\n this.noIndentInnerCommentsHere();\n this.printInnerComments();\n\n const directivesLen = node.directives?.length;\n if (directivesLen) {\n const newline = node.body.length ? 2 : 1;\n this.printSequence(node.directives, undefined, newline);\n if (!node.directives[directivesLen - 1].trailingComments?.length) {\n this.newline(newline);\n }\n }\n\n this.printSequence(node.body);\n}\n\nexport function BlockStatement(this: Printer, node: t.BlockStatement) {\n this.token(\"{\");\n const exit = this.enterDelimited();\n\n const directivesLen = node.directives?.length;\n if (directivesLen) {\n const newline = node.body.length ? 2 : 1;\n this.printSequence(node.directives, true, newline);\n if (!node.directives[directivesLen - 1].trailingComments?.length) {\n this.newline(newline);\n }\n }\n\n this.printSequence(node.body, true);\n\n exit();\n this.rightBrace(node);\n}\n\nexport function Directive(this: Printer, node: t.Directive) {\n this.print(node.value);\n this.semicolon();\n}\n\n// These regexes match an even number of \\ followed by a quote\nconst unescapedSingleQuoteRE = /(?:^|[^\\\\])(?:\\\\\\\\)*'/;\nconst unescapedDoubleQuoteRE = /(?:^|[^\\\\])(?:\\\\\\\\)*\"/;\n\nexport function DirectiveLiteral(this: Printer, node: t.DirectiveLiteral) {\n const raw = this.getPossibleRaw(node);\n if (!this.format.minified && raw !== undefined) {\n this.token(raw);\n return;\n }\n\n const { value } = node;\n\n // NOTE: In directives we can't change escapings,\n // because they change the behavior.\n // e.g. \"us\\x65 strict\" (\\x65 is e) is not a \"use strict\" directive.\n\n if (!unescapedDoubleQuoteRE.test(value)) {\n this.token(`\"${value}\"`);\n } else if (!unescapedSingleQuoteRE.test(value)) {\n this.token(`'${value}'`);\n } else {\n throw new Error(\n \"Malformed AST: it is not possible to print a directive containing\" +\n \" both unescaped single and double quotes.\",\n );\n }\n}\n\nexport function InterpreterDirective(\n this: Printer,\n node: t.InterpreterDirective,\n) {\n this.token(`#!${node.value}`);\n this.newline(1, true);\n}\n\nexport function Placeholder(this: Printer, node: t.Placeholder) {\n this.token(\"%%\");\n this.print(node.name);\n this.token(\"%%\");\n\n if (node.expectedNode === \"Statement\") {\n this.semicolon();\n }\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/classes.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/classes.js new file mode 100644 index 0000000000000000000000000000000000000000..6cdc9754186ccdd335dfe7c3024485b6cf6eb9fd --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/classes.js @@ -0,0 +1,212 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.ClassAccessorProperty = ClassAccessorProperty; +exports.ClassBody = ClassBody; +exports.ClassExpression = exports.ClassDeclaration = ClassDeclaration; +exports.ClassMethod = ClassMethod; +exports.ClassPrivateMethod = ClassPrivateMethod; +exports.ClassPrivateProperty = ClassPrivateProperty; +exports.ClassProperty = ClassProperty; +exports.StaticBlock = StaticBlock; +exports._classMethodHead = _classMethodHead; +var _t = require("@babel/types"); +const { + isExportDefaultDeclaration, + isExportNamedDeclaration +} = _t; +function ClassDeclaration(node, parent) { + const inExport = isExportDefaultDeclaration(parent) || isExportNamedDeclaration(parent); + if (!inExport || !this._shouldPrintDecoratorsBeforeExport(parent)) { + this.printJoin(node.decorators); + } + if (node.declare) { + this.word("declare"); + this.space(); + } + if (node.abstract) { + this.word("abstract"); + this.space(); + } + this.word("class"); + if (node.id) { + this.space(); + this.print(node.id); + } + this.print(node.typeParameters); + if (node.superClass) { + this.space(); + this.word("extends"); + this.space(); + this.print(node.superClass); + this.print(node.superTypeParameters); + } + if (node.implements) { + this.space(); + this.word("implements"); + this.space(); + this.printList(node.implements); + } + this.space(); + this.print(node.body); +} +function ClassBody(node) { + this.tokenChar(123); + if (node.body.length === 0) { + this.tokenChar(125); + } else { + this.newline(); + const separator = classBodyEmptySemicolonsPrinter(this, node); + separator == null || separator(-1); + const exit = this.enterDelimited(); + this.printJoin(node.body, true, true, separator, true); + exit(); + if (!this.endsWith(10)) this.newline(); + this.rightBrace(node); + } +} +function classBodyEmptySemicolonsPrinter(printer, node) { + if (!printer.tokenMap || node.start == null || node.end == null) { + return null; + } + const indexes = printer.tokenMap.getIndexes(node); + if (!indexes) return null; + let k = 1; + let occurrenceCount = 0; + let nextLocIndex = 0; + const advanceNextLocIndex = () => { + while (nextLocIndex < node.body.length && node.body[nextLocIndex].start == null) { + nextLocIndex++; + } + }; + advanceNextLocIndex(); + return i => { + if (nextLocIndex <= i) { + nextLocIndex = i + 1; + advanceNextLocIndex(); + } + const end = nextLocIndex === node.body.length ? node.end : node.body[nextLocIndex].start; + let tok; + while (k < indexes.length && printer.tokenMap.matchesOriginal(tok = printer._tokens[indexes[k]], ";") && tok.start < end) { + printer.token(";", undefined, occurrenceCount++); + k++; + } + }; +} +function ClassProperty(node) { + this.printJoin(node.decorators); + if (!node.static && !this.format.preserveFormat) { + var _node$key$loc; + const endLine = (_node$key$loc = node.key.loc) == null || (_node$key$loc = _node$key$loc.end) == null ? void 0 : _node$key$loc.line; + if (endLine) this.catchUp(endLine); + } + this.tsPrintClassMemberModifiers(node); + if (node.computed) { + this.tokenChar(91); + this.print(node.key); + this.tokenChar(93); + } else { + this._variance(node); + this.print(node.key); + } + if (node.optional) { + this.tokenChar(63); + } + if (node.definite) { + this.tokenChar(33); + } + this.print(node.typeAnnotation); + if (node.value) { + this.space(); + this.tokenChar(61); + this.space(); + this.print(node.value); + } + this.semicolon(); +} +function ClassAccessorProperty(node) { + var _node$key$loc2; + this.printJoin(node.decorators); + const endLine = (_node$key$loc2 = node.key.loc) == null || (_node$key$loc2 = _node$key$loc2.end) == null ? void 0 : _node$key$loc2.line; + if (endLine) this.catchUp(endLine); + this.tsPrintClassMemberModifiers(node); + this.word("accessor", true); + this.space(); + if (node.computed) { + this.tokenChar(91); + this.print(node.key); + this.tokenChar(93); + } else { + this._variance(node); + this.print(node.key); + } + if (node.optional) { + this.tokenChar(63); + } + if (node.definite) { + this.tokenChar(33); + } + this.print(node.typeAnnotation); + if (node.value) { + this.space(); + this.tokenChar(61); + this.space(); + this.print(node.value); + } + this.semicolon(); +} +function ClassPrivateProperty(node) { + this.printJoin(node.decorators); + this.tsPrintClassMemberModifiers(node); + this.print(node.key); + if (node.optional) { + this.tokenChar(63); + } + if (node.definite) { + this.tokenChar(33); + } + this.print(node.typeAnnotation); + if (node.value) { + this.space(); + this.tokenChar(61); + this.space(); + this.print(node.value); + } + this.semicolon(); +} +function ClassMethod(node) { + this._classMethodHead(node); + this.space(); + this.print(node.body); +} +function ClassPrivateMethod(node) { + this._classMethodHead(node); + this.space(); + this.print(node.body); +} +function _classMethodHead(node) { + this.printJoin(node.decorators); + if (!this.format.preserveFormat) { + var _node$key$loc3; + const endLine = (_node$key$loc3 = node.key.loc) == null || (_node$key$loc3 = _node$key$loc3.end) == null ? void 0 : _node$key$loc3.line; + if (endLine) this.catchUp(endLine); + } + this.tsPrintClassMemberModifiers(node); + this._methodHead(node); +} +function StaticBlock(node) { + this.word("static"); + this.space(); + this.tokenChar(123); + if (node.body.length === 0) { + this.tokenChar(125); + } else { + this.newline(); + this.printSequence(node.body, true); + this.rightBrace(node); + } +} + +//# sourceMappingURL=classes.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/classes.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/classes.js.map new file mode 100644 index 0000000000000000000000000000000000000000..8eea53ae3581a4719e6c4cee8bca184dbc8cb8c0 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/classes.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_t","require","isExportDefaultDeclaration","isExportNamedDeclaration","ClassDeclaration","node","parent","inExport","_shouldPrintDecoratorsBeforeExport","printJoin","decorators","declare","word","space","abstract","id","print","typeParameters","superClass","superTypeParameters","implements","printList","body","ClassBody","token","length","newline","separator","classBodyEmptySemicolonsPrinter","exit","enterDelimited","endsWith","rightBrace","printer","tokenMap","start","end","indexes","getIndexes","k","occurrenceCount","nextLocIndex","advanceNextLocIndex","i","tok","matchesOriginal","_tokens","undefined","ClassProperty","static","format","preserveFormat","_node$key$loc","endLine","key","loc","line","catchUp","tsPrintClassMemberModifiers","computed","_variance","optional","definite","typeAnnotation","value","semicolon","ClassAccessorProperty","_node$key$loc2","ClassPrivateProperty","ClassMethod","_classMethodHead","ClassPrivateMethod","_node$key$loc3","_methodHead","StaticBlock","printSequence"],"sources":["../../src/generators/classes.ts"],"sourcesContent":["import type Printer from \"../printer.ts\";\nimport {\n isExportDefaultDeclaration,\n isExportNamedDeclaration,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\n\n// We inline this package\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport * as charCodes from \"charcodes\";\n\nexport function ClassDeclaration(\n this: Printer,\n node: t.ClassDeclaration,\n parent: t.Node,\n) {\n const inExport =\n isExportDefaultDeclaration(parent) || isExportNamedDeclaration(parent);\n\n if (\n !inExport ||\n !this._shouldPrintDecoratorsBeforeExport(\n parent as t.ExportDeclaration & { declaration: t.ClassDeclaration },\n )\n ) {\n this.printJoin(node.decorators);\n }\n\n if (node.declare) {\n // TS\n this.word(\"declare\");\n this.space();\n }\n\n if (node.abstract) {\n // TS\n this.word(\"abstract\");\n this.space();\n }\n\n this.word(\"class\");\n\n if (node.id) {\n this.space();\n this.print(node.id);\n }\n\n this.print(node.typeParameters);\n\n if (node.superClass) {\n this.space();\n this.word(\"extends\");\n this.space();\n this.print(node.superClass);\n this.print(\n process.env.BABEL_8_BREAKING\n ? // @ts-ignore(Babel 7 vs Babel 8) Renamed\n node.superTypeArguments\n : // @ts-ignore(Babel 7 vs Babel 8) Renamed\n node.superTypeParameters,\n );\n }\n\n if (node.implements) {\n this.space();\n this.word(\"implements\");\n this.space();\n this.printList(node.implements);\n }\n\n this.space();\n this.print(node.body);\n}\n\nexport { ClassDeclaration as ClassExpression };\n\nexport function ClassBody(this: Printer, node: t.ClassBody) {\n this.token(\"{\");\n if (node.body.length === 0) {\n this.token(\"}\");\n } else {\n this.newline();\n\n const separator = classBodyEmptySemicolonsPrinter(this, node);\n separator?.(-1); // print leading semicolons in preserveFormat mode\n\n const exit = this.enterDelimited();\n this.printJoin(node.body, true, true, separator, true);\n exit();\n\n if (!this.endsWith(charCodes.lineFeed)) this.newline();\n\n this.rightBrace(node);\n }\n}\n\nfunction classBodyEmptySemicolonsPrinter(printer: Printer, node: t.ClassBody) {\n if (!printer.tokenMap || node.start == null || node.end == null) {\n return null;\n }\n\n // \"empty statements\" in class bodies are not represented in the AST.\n // Print them by checking if there are any ; tokens between the current AST\n // member and the next one.\n\n const indexes = printer.tokenMap.getIndexes(node);\n if (!indexes) return null;\n\n let k = 1; // start from 1 to skip '{'\n\n let occurrenceCount = 0;\n\n let nextLocIndex = 0;\n const advanceNextLocIndex = () => {\n while (\n nextLocIndex < node.body.length &&\n node.body[nextLocIndex].start == null\n ) {\n nextLocIndex++;\n }\n };\n advanceNextLocIndex();\n\n return (i: number) => {\n if (nextLocIndex <= i) {\n nextLocIndex = i + 1;\n advanceNextLocIndex();\n }\n\n const end =\n nextLocIndex === node.body.length\n ? node.end\n : node.body[nextLocIndex].start;\n\n let tok;\n while (\n k < indexes.length &&\n printer.tokenMap.matchesOriginal(\n (tok = printer._tokens[indexes[k]]),\n \";\",\n ) &&\n tok.start < end\n ) {\n printer.token(\";\", undefined, occurrenceCount++);\n k++;\n }\n };\n}\n\nexport function ClassProperty(this: Printer, node: t.ClassProperty) {\n this.printJoin(node.decorators);\n\n if (!node.static && !this.format.preserveFormat) {\n // catch up to property key, avoid line break\n // between member TS modifiers and the property key.\n const endLine = node.key.loc?.end?.line;\n if (endLine) this.catchUp(endLine);\n }\n\n this.tsPrintClassMemberModifiers(node);\n\n if (node.computed) {\n this.token(\"[\");\n this.print(node.key);\n this.token(\"]\");\n } else {\n this._variance(node);\n this.print(node.key);\n }\n\n // TS\n if (node.optional) {\n this.token(\"?\");\n }\n if (node.definite) {\n this.token(\"!\");\n }\n\n this.print(node.typeAnnotation);\n if (node.value) {\n this.space();\n this.token(\"=\");\n this.space();\n this.print(node.value);\n }\n this.semicolon();\n}\n\nexport function ClassAccessorProperty(\n this: Printer,\n node: t.ClassAccessorProperty,\n) {\n this.printJoin(node.decorators);\n\n // catch up to property key, avoid line break\n // between member modifiers and the property key.\n const endLine = node.key.loc?.end?.line;\n if (endLine) this.catchUp(endLine);\n\n // TS does not support class accessor property yet\n this.tsPrintClassMemberModifiers(node);\n\n this.word(\"accessor\", true);\n this.space();\n\n if (node.computed) {\n this.token(\"[\");\n this.print(node.key);\n this.token(\"]\");\n } else {\n // Todo: Flow does not support class accessor property yet.\n this._variance(node);\n this.print(node.key);\n }\n\n // TS\n if (node.optional) {\n this.token(\"?\");\n }\n if (node.definite) {\n this.token(\"!\");\n }\n\n this.print(node.typeAnnotation);\n if (node.value) {\n this.space();\n this.token(\"=\");\n this.space();\n this.print(node.value);\n }\n this.semicolon();\n}\n\nexport function ClassPrivateProperty(\n this: Printer,\n node: t.ClassPrivateProperty,\n) {\n this.printJoin(node.decorators);\n this.tsPrintClassMemberModifiers(node);\n this.print(node.key);\n // TS\n if (node.optional) {\n this.token(\"?\");\n }\n if (node.definite) {\n this.token(\"!\");\n }\n this.print(node.typeAnnotation);\n if (node.value) {\n this.space();\n this.token(\"=\");\n this.space();\n this.print(node.value);\n }\n this.semicolon();\n}\n\nexport function ClassMethod(this: Printer, node: t.ClassMethod) {\n this._classMethodHead(node);\n this.space();\n this.print(node.body);\n}\n\nexport function ClassPrivateMethod(this: Printer, node: t.ClassPrivateMethod) {\n this._classMethodHead(node);\n this.space();\n this.print(node.body);\n}\n\nexport function _classMethodHead(\n this: Printer,\n node: t.ClassMethod | t.ClassPrivateMethod | t.TSDeclareMethod,\n) {\n this.printJoin(node.decorators);\n\n if (!this.format.preserveFormat) {\n // catch up to method key, avoid line break\n // between member modifiers/method heads and the method key.\n const endLine = node.key.loc?.end?.line;\n if (endLine) this.catchUp(endLine);\n }\n\n this.tsPrintClassMemberModifiers(node);\n this._methodHead(node);\n}\n\nexport function StaticBlock(this: Printer, node: t.StaticBlock) {\n this.word(\"static\");\n this.space();\n this.token(\"{\");\n if (node.body.length === 0) {\n this.token(\"}\");\n } else {\n this.newline();\n this.printSequence(node.body, true);\n this.rightBrace(node);\n }\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/deprecated.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/deprecated.js new file mode 100644 index 0000000000000000000000000000000000000000..fc02bf96e7e1fbec652927a458debbbb4701223b --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/deprecated.js @@ -0,0 +1,28 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.addDeprecatedGenerators = addDeprecatedGenerators; +function addDeprecatedGenerators(PrinterClass) { + { + const deprecatedBabel7Generators = { + Noop() {}, + TSExpressionWithTypeArguments(node) { + this.print(node.expression); + this.print(node.typeParameters); + }, + DecimalLiteral(node) { + const raw = this.getPossibleRaw(node); + if (!this.format.minified && raw !== undefined) { + this.word(raw); + return; + } + this.word(node.value + "m"); + } + }; + Object.assign(PrinterClass.prototype, deprecatedBabel7Generators); + } +} + +//# sourceMappingURL=deprecated.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/deprecated.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/deprecated.js.map new file mode 100644 index 0000000000000000000000000000000000000000..732752647eabf58e1204b061364b9634cc80b734 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/deprecated.js.map @@ -0,0 +1 @@ +{"version":3,"names":["addDeprecatedGenerators","PrinterClass","deprecatedBabel7Generators","Noop","TSExpressionWithTypeArguments","node","print","expression","typeParameters","DecimalLiteral","raw","getPossibleRaw","format","minified","undefined","word","value","Object","assign","prototype"],"sources":["../../src/generators/deprecated.ts"],"sourcesContent":["import type Printer from \"../printer\";\nimport type * as t from \"@babel/types\";\n\nexport type DeprecatedBabel7ASTTypes =\n | \"Noop\"\n | \"TSExpressionWithTypeArguments\"\n | \"DecimalLiteral\";\n\nexport function addDeprecatedGenerators(PrinterClass: typeof Printer) {\n // Add Babel 7 generator methods that is removed in Babel 8\n if (!process.env.BABEL_8_BREAKING) {\n const deprecatedBabel7Generators = {\n Noop(this: Printer) {},\n\n TSExpressionWithTypeArguments(\n this: Printer,\n // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST\n node: t.TSExpressionWithTypeArguments,\n ) {\n this.print(node.expression);\n this.print(node.typeParameters);\n },\n\n DecimalLiteral(this: Printer, node: any) {\n const raw = this.getPossibleRaw(node);\n if (!this.format.minified && raw !== undefined) {\n this.word(raw);\n return;\n }\n this.word(node.value + \"m\");\n },\n } satisfies Record<\n DeprecatedBabel7ASTTypes,\n (this: Printer, node: any) => void\n >;\n Object.assign(PrinterClass.prototype, deprecatedBabel7Generators);\n }\n}\n"],"mappings":";;;;;;AAQO,SAASA,uBAAuBA,CAACC,YAA4B,EAAE;EAEjC;IACjC,MAAMC,0BAA0B,GAAG;MACjCC,IAAIA,CAAA,EAAgB,CAAC,CAAC;MAEtBC,6BAA6BA,CAG3BC,IAAqC,EACrC;QACA,IAAI,CAACC,KAAK,CAACD,IAAI,CAACE,UAAU,CAAC;QAC3B,IAAI,CAACD,KAAK,CAACD,IAAI,CAACG,cAAc,CAAC;MACjC,CAAC;MAEDC,cAAcA,CAAgBJ,IAAS,EAAE;QACvC,MAAMK,GAAG,GAAG,IAAI,CAACC,cAAc,CAACN,IAAI,CAAC;QACrC,IAAI,CAAC,IAAI,CAACO,MAAM,CAACC,QAAQ,IAAIH,GAAG,KAAKI,SAAS,EAAE;UAC9C,IAAI,CAACC,IAAI,CAACL,GAAG,CAAC;UACd;QACF;QACA,IAAI,CAACK,IAAI,CAACV,IAAI,CAACW,KAAK,GAAG,GAAG,CAAC;MAC7B;IACF,CAGC;IACDC,MAAM,CAACC,MAAM,CAACjB,YAAY,CAACkB,SAAS,EAAEjB,0BAA0B,CAAC;EACnE;AACF","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/expressions.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/expressions.js new file mode 100644 index 0000000000000000000000000000000000000000..5fc870e5213576896f59ecff5cc31a2e60aaf953 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/expressions.js @@ -0,0 +1,300 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.LogicalExpression = exports.BinaryExpression = exports.AssignmentExpression = AssignmentExpression; +exports.AssignmentPattern = AssignmentPattern; +exports.AwaitExpression = AwaitExpression; +exports.BindExpression = BindExpression; +exports.CallExpression = CallExpression; +exports.ConditionalExpression = ConditionalExpression; +exports.Decorator = Decorator; +exports.DoExpression = DoExpression; +exports.EmptyStatement = EmptyStatement; +exports.ExpressionStatement = ExpressionStatement; +exports.Import = Import; +exports.MemberExpression = MemberExpression; +exports.MetaProperty = MetaProperty; +exports.ModuleExpression = ModuleExpression; +exports.NewExpression = NewExpression; +exports.OptionalCallExpression = OptionalCallExpression; +exports.OptionalMemberExpression = OptionalMemberExpression; +exports.ParenthesizedExpression = ParenthesizedExpression; +exports.PrivateName = PrivateName; +exports.SequenceExpression = SequenceExpression; +exports.Super = Super; +exports.ThisExpression = ThisExpression; +exports.UnaryExpression = UnaryExpression; +exports.UpdateExpression = UpdateExpression; +exports.V8IntrinsicIdentifier = V8IntrinsicIdentifier; +exports.YieldExpression = YieldExpression; +exports._shouldPrintDecoratorsBeforeExport = _shouldPrintDecoratorsBeforeExport; +var _t = require("@babel/types"); +var _index = require("../node/index.js"); +const { + isCallExpression, + isLiteral, + isMemberExpression, + isNewExpression, + isPattern +} = _t; +function UnaryExpression(node) { + const { + operator + } = node; + if (operator === "void" || operator === "delete" || operator === "typeof" || operator === "throw") { + this.word(operator); + this.space(); + } else { + this.token(operator); + } + this.print(node.argument); +} +function DoExpression(node) { + if (node.async) { + this.word("async", true); + this.space(); + } + this.word("do"); + this.space(); + this.print(node.body); +} +function ParenthesizedExpression(node) { + this.tokenChar(40); + const exit = this.enterDelimited(); + this.print(node.expression); + exit(); + this.rightParens(node); +} +function UpdateExpression(node) { + if (node.prefix) { + this.token(node.operator); + this.print(node.argument); + } else { + this.print(node.argument, true); + this.token(node.operator); + } +} +function ConditionalExpression(node) { + this.print(node.test); + this.space(); + this.tokenChar(63); + this.space(); + this.print(node.consequent); + this.space(); + this.tokenChar(58); + this.space(); + this.print(node.alternate); +} +function NewExpression(node, parent) { + this.word("new"); + this.space(); + this.print(node.callee); + if (this.format.minified && node.arguments.length === 0 && !node.optional && !isCallExpression(parent, { + callee: node + }) && !isMemberExpression(parent) && !isNewExpression(parent)) { + return; + } + this.print(node.typeArguments); + { + this.print(node.typeParameters); + if (node.optional) { + this.token("?."); + } + } + if (node.arguments.length === 0 && this.tokenMap && !this.tokenMap.endMatches(node, ")")) { + return; + } + this.tokenChar(40); + const exit = this.enterDelimited(); + this.printList(node.arguments, this.shouldPrintTrailingComma(")")); + exit(); + this.rightParens(node); +} +function SequenceExpression(node) { + this.printList(node.expressions); +} +function ThisExpression() { + this.word("this"); +} +function Super() { + this.word("super"); +} +function _shouldPrintDecoratorsBeforeExport(node) { + if (typeof this.format.decoratorsBeforeExport === "boolean") { + return this.format.decoratorsBeforeExport; + } + return typeof node.start === "number" && node.start === node.declaration.start; +} +function Decorator(node) { + this.tokenChar(64); + this.print(node.expression); + this.newline(); +} +function OptionalMemberExpression(node) { + let { + computed + } = node; + const { + optional, + property + } = node; + this.print(node.object); + if (!computed && isMemberExpression(property)) { + throw new TypeError("Got a MemberExpression for MemberExpression property"); + } + if (isLiteral(property) && typeof property.value === "number") { + computed = true; + } + if (optional) { + this.token("?."); + } + if (computed) { + this.tokenChar(91); + this.print(property); + this.tokenChar(93); + } else { + if (!optional) { + this.tokenChar(46); + } + this.print(property); + } +} +function OptionalCallExpression(node) { + this.print(node.callee); + { + this.print(node.typeParameters); + } + if (node.optional) { + this.token("?."); + } + this.print(node.typeArguments); + this.tokenChar(40); + const exit = this.enterDelimited(); + this.printList(node.arguments); + exit(); + this.rightParens(node); +} +function CallExpression(node) { + this.print(node.callee); + this.print(node.typeArguments); + { + this.print(node.typeParameters); + } + this.tokenChar(40); + const exit = this.enterDelimited(); + this.printList(node.arguments, this.shouldPrintTrailingComma(")")); + exit(); + this.rightParens(node); +} +function Import() { + this.word("import"); +} +function AwaitExpression(node) { + this.word("await"); + this.space(); + this.print(node.argument); +} +function YieldExpression(node) { + if (node.delegate) { + this.word("yield", true); + this.tokenChar(42); + if (node.argument) { + this.space(); + this.print(node.argument); + } + } else if (node.argument) { + this.word("yield", true); + this.space(); + this.print(node.argument); + } else { + this.word("yield"); + } +} +function EmptyStatement() { + this.semicolon(true); +} +function ExpressionStatement(node) { + this.tokenContext |= _index.TokenContext.expressionStatement; + this.print(node.expression); + this.semicolon(); +} +function AssignmentPattern(node) { + this.print(node.left); + if (node.left.type === "Identifier" || isPattern(node.left)) { + if (node.left.optional) this.tokenChar(63); + this.print(node.left.typeAnnotation); + } + this.space(); + this.tokenChar(61); + this.space(); + this.print(node.right); +} +function AssignmentExpression(node) { + this.print(node.left); + this.space(); + if (node.operator === "in" || node.operator === "instanceof") { + this.word(node.operator); + } else { + this.token(node.operator); + this._endsWithDiv = node.operator === "/"; + } + this.space(); + this.print(node.right); +} +function BindExpression(node) { + this.print(node.object); + this.token("::"); + this.print(node.callee); +} +function MemberExpression(node) { + this.print(node.object); + if (!node.computed && isMemberExpression(node.property)) { + throw new TypeError("Got a MemberExpression for MemberExpression property"); + } + let computed = node.computed; + if (isLiteral(node.property) && typeof node.property.value === "number") { + computed = true; + } + if (computed) { + const exit = this.enterDelimited(); + this.tokenChar(91); + this.print(node.property); + this.tokenChar(93); + exit(); + } else { + this.tokenChar(46); + this.print(node.property); + } +} +function MetaProperty(node) { + this.print(node.meta); + this.tokenChar(46); + this.print(node.property); +} +function PrivateName(node) { + this.tokenChar(35); + this.print(node.id); +} +function V8IntrinsicIdentifier(node) { + this.tokenChar(37); + this.word(node.name); +} +function ModuleExpression(node) { + this.word("module", true); + this.space(); + this.tokenChar(123); + this.indent(); + const { + body + } = node; + if (body.body.length || body.directives.length) { + this.newline(); + } + this.print(body); + this.dedent(); + this.rightBrace(node); +} + +//# sourceMappingURL=expressions.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/expressions.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/expressions.js.map new file mode 100644 index 0000000000000000000000000000000000000000..a4abd45782dc772ca5b60d402452a442341953e3 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/expressions.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_t","require","_index","isCallExpression","isLiteral","isMemberExpression","isNewExpression","isPattern","UnaryExpression","node","operator","word","space","token","print","argument","DoExpression","async","body","ParenthesizedExpression","exit","enterDelimited","expression","rightParens","UpdateExpression","prefix","ConditionalExpression","test","consequent","alternate","NewExpression","parent","callee","format","minified","arguments","length","optional","typeArguments","typeParameters","tokenMap","endMatches","printList","shouldPrintTrailingComma","SequenceExpression","expressions","ThisExpression","Super","_shouldPrintDecoratorsBeforeExport","decoratorsBeforeExport","start","declaration","Decorator","newline","OptionalMemberExpression","computed","property","object","TypeError","value","OptionalCallExpression","CallExpression","Import","AwaitExpression","YieldExpression","delegate","EmptyStatement","semicolon","ExpressionStatement","tokenContext","TokenContext","expressionStatement","AssignmentPattern","left","type","typeAnnotation","right","AssignmentExpression","_endsWithDiv","BindExpression","MemberExpression","MetaProperty","meta","PrivateName","id","V8IntrinsicIdentifier","name","ModuleExpression","indent","directives","dedent","rightBrace"],"sources":["../../src/generators/expressions.ts"],"sourcesContent":["import type Printer from \"../printer.ts\";\nimport {\n isCallExpression,\n isLiteral,\n isMemberExpression,\n isNewExpression,\n isPattern,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\nimport { TokenContext } from \"../node/index.ts\";\n\nexport function UnaryExpression(this: Printer, node: t.UnaryExpression) {\n const { operator } = node;\n if (\n operator === \"void\" ||\n operator === \"delete\" ||\n operator === \"typeof\" ||\n // throwExpressions\n operator === \"throw\"\n ) {\n this.word(operator);\n this.space();\n } else {\n this.token(operator);\n }\n\n this.print(node.argument);\n}\n\nexport function DoExpression(this: Printer, node: t.DoExpression) {\n if (node.async) {\n this.word(\"async\", true);\n this.space();\n }\n this.word(\"do\");\n this.space();\n this.print(node.body);\n}\n\nexport function ParenthesizedExpression(\n this: Printer,\n node: t.ParenthesizedExpression,\n) {\n this.token(\"(\");\n const exit = this.enterDelimited();\n this.print(node.expression);\n exit();\n this.rightParens(node);\n}\n\nexport function UpdateExpression(this: Printer, node: t.UpdateExpression) {\n if (node.prefix) {\n this.token(node.operator);\n this.print(node.argument);\n } else {\n this.print(node.argument, true);\n this.token(node.operator);\n }\n}\n\nexport function ConditionalExpression(\n this: Printer,\n node: t.ConditionalExpression,\n) {\n this.print(node.test);\n this.space();\n this.token(\"?\");\n this.space();\n this.print(node.consequent);\n this.space();\n this.token(\":\");\n this.space();\n this.print(node.alternate);\n}\n\nexport function NewExpression(\n this: Printer,\n node: t.NewExpression,\n parent: t.Node,\n) {\n this.word(\"new\");\n this.space();\n this.print(node.callee);\n if (\n this.format.minified &&\n node.arguments.length === 0 &&\n // @ts-ignore(Babel 7 vs Babel 8) Removed in Babel 8\n !node.optional &&\n !isCallExpression(parent, { callee: node }) &&\n !isMemberExpression(parent) &&\n !isNewExpression(parent)\n ) {\n return;\n }\n\n this.print(node.typeArguments);\n if (!process.env.BABEL_8_BREAKING) {\n // @ts-ignore(Babel 7 vs Babel 8) Removed in Babel 8\n this.print(node.typeParameters); // Legacy TS AST\n // @ts-ignore(Babel 7 vs Babel 8) Removed in Babel 8\n if (node.optional) {\n this.token(\"?.\");\n }\n }\n\n if (\n node.arguments.length === 0 &&\n this.tokenMap &&\n !this.tokenMap.endMatches(node, \")\")\n ) {\n return;\n }\n\n this.token(\"(\");\n const exit = this.enterDelimited();\n this.printList(node.arguments, this.shouldPrintTrailingComma(\")\"));\n exit();\n this.rightParens(node);\n}\n\nexport function SequenceExpression(this: Printer, node: t.SequenceExpression) {\n this.printList(node.expressions);\n}\n\nexport function ThisExpression(this: Printer) {\n this.word(\"this\");\n}\n\nexport function Super(this: Printer) {\n this.word(\"super\");\n}\n\nexport function _shouldPrintDecoratorsBeforeExport(\n this: Printer,\n node: t.ExportDeclaration & { declaration: t.ClassDeclaration },\n) {\n if (typeof this.format.decoratorsBeforeExport === \"boolean\") {\n return this.format.decoratorsBeforeExport;\n }\n return (\n typeof node.start === \"number\" && node.start === node.declaration.start\n );\n}\n\nexport function Decorator(this: Printer, node: t.Decorator) {\n this.token(\"@\");\n this.print(node.expression);\n this.newline();\n}\n\nexport function OptionalMemberExpression(\n this: Printer,\n node: t.OptionalMemberExpression,\n) {\n let { computed } = node;\n const { optional, property } = node;\n\n this.print(node.object);\n\n if (!computed && isMemberExpression(property)) {\n throw new TypeError(\"Got a MemberExpression for MemberExpression property\");\n }\n\n // @ts-expect-error todo(flow->ts) maybe instead of typeof check specific literal types?\n if (isLiteral(property) && typeof property.value === \"number\") {\n computed = true;\n }\n if (optional) {\n this.token(\"?.\");\n }\n\n if (computed) {\n this.token(\"[\");\n this.print(property);\n this.token(\"]\");\n } else {\n if (!optional) {\n this.token(\".\");\n }\n this.print(property);\n }\n}\n\nexport function OptionalCallExpression(\n this: Printer,\n node: t.OptionalCallExpression,\n) {\n this.print(node.callee);\n\n if (!process.env.BABEL_8_BREAKING) {\n // @ts-ignore(Babel 7 vs Babel 8) Removed in Babel 8\n this.print(node.typeParameters); // legacy TS AST\n }\n\n if (node.optional) {\n this.token(\"?.\");\n }\n\n this.print(node.typeArguments);\n\n this.token(\"(\");\n const exit = this.enterDelimited();\n this.printList(node.arguments);\n exit();\n this.rightParens(node);\n}\n\nexport function CallExpression(this: Printer, node: t.CallExpression) {\n this.print(node.callee);\n\n this.print(node.typeArguments);\n if (!process.env.BABEL_8_BREAKING) {\n // @ts-ignore(Babel 7 vs Babel 8) Removed in Babel 8\n this.print(node.typeParameters); // legacy TS AST\n }\n this.token(\"(\");\n const exit = this.enterDelimited();\n this.printList(node.arguments, this.shouldPrintTrailingComma(\")\"));\n exit();\n this.rightParens(node);\n}\n\nexport function Import(this: Printer) {\n this.word(\"import\");\n}\n\nexport function AwaitExpression(this: Printer, node: t.AwaitExpression) {\n this.word(\"await\");\n this.space();\n this.print(node.argument);\n}\n\nexport function YieldExpression(this: Printer, node: t.YieldExpression) {\n if (node.delegate) {\n this.word(\"yield\", true);\n this.token(\"*\");\n if (node.argument) {\n this.space();\n // line terminators are allowed after yield*\n this.print(node.argument);\n }\n } else if (node.argument) {\n this.word(\"yield\", true);\n this.space();\n this.print(node.argument);\n } else {\n this.word(\"yield\");\n }\n}\n\nexport function EmptyStatement(this: Printer) {\n this.semicolon(true /* force */);\n}\n\nexport function ExpressionStatement(\n this: Printer,\n node: t.ExpressionStatement,\n) {\n this.tokenContext |= TokenContext.expressionStatement;\n this.print(node.expression);\n this.semicolon();\n}\n\nexport function AssignmentPattern(this: Printer, node: t.AssignmentPattern) {\n this.print(node.left);\n if (node.left.type === \"Identifier\" || isPattern(node.left)) {\n if (node.left.optional) this.token(\"?\");\n this.print(node.left.typeAnnotation);\n }\n this.space();\n this.token(\"=\");\n this.space();\n this.print(node.right);\n}\n\nexport function AssignmentExpression(\n this: Printer,\n node: t.AssignmentExpression | t.BinaryExpression | t.LogicalExpression,\n) {\n this.print(node.left);\n\n this.space();\n if (node.operator === \"in\" || node.operator === \"instanceof\") {\n this.word(node.operator);\n } else {\n this.token(node.operator);\n this._endsWithDiv = node.operator === \"/\";\n }\n this.space();\n\n this.print(node.right);\n}\n\nexport function BindExpression(this: Printer, node: t.BindExpression) {\n this.print(node.object);\n this.token(\"::\");\n this.print(node.callee);\n}\n\nexport {\n AssignmentExpression as BinaryExpression,\n AssignmentExpression as LogicalExpression,\n};\n\nexport function MemberExpression(this: Printer, node: t.MemberExpression) {\n this.print(node.object);\n\n if (!node.computed && isMemberExpression(node.property)) {\n throw new TypeError(\"Got a MemberExpression for MemberExpression property\");\n }\n\n let computed = node.computed;\n // @ts-expect-error todo(flow->ts) maybe use specific literal types\n if (isLiteral(node.property) && typeof node.property.value === \"number\") {\n computed = true;\n }\n\n if (computed) {\n const exit = this.enterDelimited();\n this.token(\"[\");\n this.print(node.property);\n this.token(\"]\");\n exit();\n } else {\n this.token(\".\");\n this.print(node.property);\n }\n}\n\nexport function MetaProperty(this: Printer, node: t.MetaProperty) {\n this.print(node.meta);\n this.token(\".\");\n this.print(node.property);\n}\n\nexport function PrivateName(this: Printer, node: t.PrivateName) {\n this.token(\"#\");\n this.print(node.id);\n}\n\nexport function V8IntrinsicIdentifier(\n this: Printer,\n node: t.V8IntrinsicIdentifier,\n) {\n this.token(\"%\");\n this.word(node.name);\n}\n\nexport function ModuleExpression(this: Printer, node: t.ModuleExpression) {\n this.word(\"module\", true);\n this.space();\n this.token(\"{\");\n this.indent();\n const { body } = node;\n if (body.body.length || body.directives.length) {\n this.newline();\n }\n this.print(body);\n this.dedent();\n this.rightBrace(node);\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/flow.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/flow.js new file mode 100644 index 0000000000000000000000000000000000000000..322aa3438df758d87a5d9bce8fe4f638606ce77a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/flow.js @@ -0,0 +1,660 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.AnyTypeAnnotation = AnyTypeAnnotation; +exports.ArrayTypeAnnotation = ArrayTypeAnnotation; +exports.BooleanLiteralTypeAnnotation = BooleanLiteralTypeAnnotation; +exports.BooleanTypeAnnotation = BooleanTypeAnnotation; +exports.DeclareClass = DeclareClass; +exports.DeclareExportAllDeclaration = DeclareExportAllDeclaration; +exports.DeclareExportDeclaration = DeclareExportDeclaration; +exports.DeclareFunction = DeclareFunction; +exports.DeclareInterface = DeclareInterface; +exports.DeclareModule = DeclareModule; +exports.DeclareModuleExports = DeclareModuleExports; +exports.DeclareOpaqueType = DeclareOpaqueType; +exports.DeclareTypeAlias = DeclareTypeAlias; +exports.DeclareVariable = DeclareVariable; +exports.DeclaredPredicate = DeclaredPredicate; +exports.EmptyTypeAnnotation = EmptyTypeAnnotation; +exports.EnumBooleanBody = EnumBooleanBody; +exports.EnumBooleanMember = EnumBooleanMember; +exports.EnumDeclaration = EnumDeclaration; +exports.EnumDefaultedMember = EnumDefaultedMember; +exports.EnumNumberBody = EnumNumberBody; +exports.EnumNumberMember = EnumNumberMember; +exports.EnumStringBody = EnumStringBody; +exports.EnumStringMember = EnumStringMember; +exports.EnumSymbolBody = EnumSymbolBody; +exports.ExistsTypeAnnotation = ExistsTypeAnnotation; +exports.FunctionTypeAnnotation = FunctionTypeAnnotation; +exports.FunctionTypeParam = FunctionTypeParam; +exports.IndexedAccessType = IndexedAccessType; +exports.InferredPredicate = InferredPredicate; +exports.InterfaceDeclaration = InterfaceDeclaration; +exports.GenericTypeAnnotation = exports.ClassImplements = exports.InterfaceExtends = InterfaceExtends; +exports.InterfaceTypeAnnotation = InterfaceTypeAnnotation; +exports.IntersectionTypeAnnotation = IntersectionTypeAnnotation; +exports.MixedTypeAnnotation = MixedTypeAnnotation; +exports.NullLiteralTypeAnnotation = NullLiteralTypeAnnotation; +exports.NullableTypeAnnotation = NullableTypeAnnotation; +Object.defineProperty(exports, "NumberLiteralTypeAnnotation", { + enumerable: true, + get: function () { + return _types2.NumericLiteral; + } +}); +exports.NumberTypeAnnotation = NumberTypeAnnotation; +exports.ObjectTypeAnnotation = ObjectTypeAnnotation; +exports.ObjectTypeCallProperty = ObjectTypeCallProperty; +exports.ObjectTypeIndexer = ObjectTypeIndexer; +exports.ObjectTypeInternalSlot = ObjectTypeInternalSlot; +exports.ObjectTypeProperty = ObjectTypeProperty; +exports.ObjectTypeSpreadProperty = ObjectTypeSpreadProperty; +exports.OpaqueType = OpaqueType; +exports.OptionalIndexedAccessType = OptionalIndexedAccessType; +exports.QualifiedTypeIdentifier = QualifiedTypeIdentifier; +Object.defineProperty(exports, "StringLiteralTypeAnnotation", { + enumerable: true, + get: function () { + return _types2.StringLiteral; + } +}); +exports.StringTypeAnnotation = StringTypeAnnotation; +exports.SymbolTypeAnnotation = SymbolTypeAnnotation; +exports.ThisTypeAnnotation = ThisTypeAnnotation; +exports.TupleTypeAnnotation = TupleTypeAnnotation; +exports.TypeAlias = TypeAlias; +exports.TypeAnnotation = TypeAnnotation; +exports.TypeCastExpression = TypeCastExpression; +exports.TypeParameter = TypeParameter; +exports.TypeParameterDeclaration = exports.TypeParameterInstantiation = TypeParameterInstantiation; +exports.TypeofTypeAnnotation = TypeofTypeAnnotation; +exports.UnionTypeAnnotation = UnionTypeAnnotation; +exports.Variance = Variance; +exports.VoidTypeAnnotation = VoidTypeAnnotation; +exports._interfaceish = _interfaceish; +exports._variance = _variance; +var _t = require("@babel/types"); +var _modules = require("./modules.js"); +var _index = require("../node/index.js"); +var _types2 = require("./types.js"); +const { + isDeclareExportDeclaration, + isStatement +} = _t; +function AnyTypeAnnotation() { + this.word("any"); +} +function ArrayTypeAnnotation(node) { + this.print(node.elementType, true); + this.tokenChar(91); + this.tokenChar(93); +} +function BooleanTypeAnnotation() { + this.word("boolean"); +} +function BooleanLiteralTypeAnnotation(node) { + this.word(node.value ? "true" : "false"); +} +function NullLiteralTypeAnnotation() { + this.word("null"); +} +function DeclareClass(node, parent) { + if (!isDeclareExportDeclaration(parent)) { + this.word("declare"); + this.space(); + } + this.word("class"); + this.space(); + this._interfaceish(node); +} +function DeclareFunction(node, parent) { + if (!isDeclareExportDeclaration(parent)) { + this.word("declare"); + this.space(); + } + this.word("function"); + this.space(); + this.print(node.id); + this.print(node.id.typeAnnotation.typeAnnotation); + if (node.predicate) { + this.space(); + this.print(node.predicate); + } + this.semicolon(); +} +function InferredPredicate() { + this.tokenChar(37); + this.word("checks"); +} +function DeclaredPredicate(node) { + this.tokenChar(37); + this.word("checks"); + this.tokenChar(40); + this.print(node.value); + this.tokenChar(41); +} +function DeclareInterface(node) { + this.word("declare"); + this.space(); + this.InterfaceDeclaration(node); +} +function DeclareModule(node) { + this.word("declare"); + this.space(); + this.word("module"); + this.space(); + this.print(node.id); + this.space(); + this.print(node.body); +} +function DeclareModuleExports(node) { + this.word("declare"); + this.space(); + this.word("module"); + this.tokenChar(46); + this.word("exports"); + this.print(node.typeAnnotation); +} +function DeclareTypeAlias(node) { + this.word("declare"); + this.space(); + this.TypeAlias(node); +} +function DeclareOpaqueType(node, parent) { + if (!isDeclareExportDeclaration(parent)) { + this.word("declare"); + this.space(); + } + this.OpaqueType(node); +} +function DeclareVariable(node, parent) { + if (!isDeclareExportDeclaration(parent)) { + this.word("declare"); + this.space(); + } + this.word("var"); + this.space(); + this.print(node.id); + this.print(node.id.typeAnnotation); + this.semicolon(); +} +function DeclareExportDeclaration(node) { + this.word("declare"); + this.space(); + this.word("export"); + this.space(); + if (node.default) { + this.word("default"); + this.space(); + } + FlowExportDeclaration.call(this, node); +} +function DeclareExportAllDeclaration(node) { + this.word("declare"); + this.space(); + _modules.ExportAllDeclaration.call(this, node); +} +function EnumDeclaration(node) { + const { + id, + body + } = node; + this.word("enum"); + this.space(); + this.print(id); + this.print(body); +} +function enumExplicitType(context, name, hasExplicitType) { + if (hasExplicitType) { + context.space(); + context.word("of"); + context.space(); + context.word(name); + } + context.space(); +} +function enumBody(context, node) { + const { + members + } = node; + context.token("{"); + context.indent(); + context.newline(); + for (const member of members) { + context.print(member); + context.newline(); + } + if (node.hasUnknownMembers) { + context.token("..."); + context.newline(); + } + context.dedent(); + context.token("}"); +} +function EnumBooleanBody(node) { + const { + explicitType + } = node; + enumExplicitType(this, "boolean", explicitType); + enumBody(this, node); +} +function EnumNumberBody(node) { + const { + explicitType + } = node; + enumExplicitType(this, "number", explicitType); + enumBody(this, node); +} +function EnumStringBody(node) { + const { + explicitType + } = node; + enumExplicitType(this, "string", explicitType); + enumBody(this, node); +} +function EnumSymbolBody(node) { + enumExplicitType(this, "symbol", true); + enumBody(this, node); +} +function EnumDefaultedMember(node) { + const { + id + } = node; + this.print(id); + this.tokenChar(44); +} +function enumInitializedMember(context, node) { + context.print(node.id); + context.space(); + context.token("="); + context.space(); + context.print(node.init); + context.token(","); +} +function EnumBooleanMember(node) { + enumInitializedMember(this, node); +} +function EnumNumberMember(node) { + enumInitializedMember(this, node); +} +function EnumStringMember(node) { + enumInitializedMember(this, node); +} +function FlowExportDeclaration(node) { + if (node.declaration) { + const declar = node.declaration; + this.print(declar); + if (!isStatement(declar)) this.semicolon(); + } else { + this.tokenChar(123); + if (node.specifiers.length) { + this.space(); + this.printList(node.specifiers); + this.space(); + } + this.tokenChar(125); + if (node.source) { + this.space(); + this.word("from"); + this.space(); + this.print(node.source); + } + this.semicolon(); + } +} +function ExistsTypeAnnotation() { + this.tokenChar(42); +} +function FunctionTypeAnnotation(node, parent) { + this.print(node.typeParameters); + this.tokenChar(40); + if (node.this) { + this.word("this"); + this.tokenChar(58); + this.space(); + this.print(node.this.typeAnnotation); + if (node.params.length || node.rest) { + this.tokenChar(44); + this.space(); + } + } + this.printList(node.params); + if (node.rest) { + if (node.params.length) { + this.tokenChar(44); + this.space(); + } + this.token("..."); + this.print(node.rest); + } + this.tokenChar(41); + const type = parent == null ? void 0 : parent.type; + if (type != null && (type === "ObjectTypeCallProperty" || type === "ObjectTypeInternalSlot" || type === "DeclareFunction" || type === "ObjectTypeProperty" && parent.method)) { + this.tokenChar(58); + } else { + this.space(); + this.token("=>"); + } + this.space(); + this.print(node.returnType); +} +function FunctionTypeParam(node) { + this.print(node.name); + if (node.optional) this.tokenChar(63); + if (node.name) { + this.tokenChar(58); + this.space(); + } + this.print(node.typeAnnotation); +} +function InterfaceExtends(node) { + this.print(node.id); + this.print(node.typeParameters, true); +} +function _interfaceish(node) { + var _node$extends; + this.print(node.id); + this.print(node.typeParameters); + if ((_node$extends = node.extends) != null && _node$extends.length) { + this.space(); + this.word("extends"); + this.space(); + this.printList(node.extends); + } + if (node.type === "DeclareClass") { + var _node$mixins, _node$implements; + if ((_node$mixins = node.mixins) != null && _node$mixins.length) { + this.space(); + this.word("mixins"); + this.space(); + this.printList(node.mixins); + } + if ((_node$implements = node.implements) != null && _node$implements.length) { + this.space(); + this.word("implements"); + this.space(); + this.printList(node.implements); + } + } + this.space(); + this.print(node.body); +} +function _variance(node) { + var _node$variance; + const kind = (_node$variance = node.variance) == null ? void 0 : _node$variance.kind; + if (kind != null) { + if (kind === "plus") { + this.tokenChar(43); + } else if (kind === "minus") { + this.tokenChar(45); + } + } +} +function InterfaceDeclaration(node) { + this.word("interface"); + this.space(); + this._interfaceish(node); +} +function andSeparator(occurrenceCount) { + this.space(); + this.token("&", false, occurrenceCount); + this.space(); +} +function InterfaceTypeAnnotation(node) { + var _node$extends2; + this.word("interface"); + if ((_node$extends2 = node.extends) != null && _node$extends2.length) { + this.space(); + this.word("extends"); + this.space(); + this.printList(node.extends); + } + this.space(); + this.print(node.body); +} +function IntersectionTypeAnnotation(node) { + this.printJoin(node.types, undefined, undefined, andSeparator); +} +function MixedTypeAnnotation() { + this.word("mixed"); +} +function EmptyTypeAnnotation() { + this.word("empty"); +} +function NullableTypeAnnotation(node) { + this.tokenChar(63); + this.print(node.typeAnnotation); +} +function NumberTypeAnnotation() { + this.word("number"); +} +function StringTypeAnnotation() { + this.word("string"); +} +function ThisTypeAnnotation() { + this.word("this"); +} +function TupleTypeAnnotation(node) { + this.tokenChar(91); + this.printList(node.types); + this.tokenChar(93); +} +function TypeofTypeAnnotation(node) { + this.word("typeof"); + this.space(); + this.print(node.argument); +} +function TypeAlias(node) { + this.word("type"); + this.space(); + this.print(node.id); + this.print(node.typeParameters); + this.space(); + this.tokenChar(61); + this.space(); + this.print(node.right); + this.semicolon(); +} +function TypeAnnotation(node, parent) { + this.tokenChar(58); + this.space(); + if (parent.type === "ArrowFunctionExpression") { + this.tokenContext |= _index.TokenContext.arrowFlowReturnType; + } else if (node.optional) { + this.tokenChar(63); + } + this.print(node.typeAnnotation); +} +function TypeParameterInstantiation(node) { + this.tokenChar(60); + this.printList(node.params); + this.tokenChar(62); +} +function TypeParameter(node) { + this._variance(node); + this.word(node.name); + if (node.bound) { + this.print(node.bound); + } + if (node.default) { + this.space(); + this.tokenChar(61); + this.space(); + this.print(node.default); + } +} +function OpaqueType(node) { + this.word("opaque"); + this.space(); + this.word("type"); + this.space(); + this.print(node.id); + this.print(node.typeParameters); + if (node.supertype) { + this.tokenChar(58); + this.space(); + this.print(node.supertype); + } + if (node.impltype) { + this.space(); + this.tokenChar(61); + this.space(); + this.print(node.impltype); + } + this.semicolon(); +} +function ObjectTypeAnnotation(node) { + if (node.exact) { + this.token("{|"); + } else { + this.tokenChar(123); + } + const props = [...node.properties, ...(node.callProperties || []), ...(node.indexers || []), ...(node.internalSlots || [])]; + if (props.length) { + this.newline(); + this.space(); + this.printJoin(props, true, true, undefined, undefined, function addNewlines(leading) { + if (leading && !props[0]) return 1; + }, () => { + if (props.length !== 1 || node.inexact) { + this.tokenChar(44); + this.space(); + } + }); + this.space(); + } + if (node.inexact) { + this.indent(); + this.token("..."); + if (props.length) { + this.newline(); + } + this.dedent(); + } + if (node.exact) { + this.token("|}"); + } else { + this.tokenChar(125); + } +} +function ObjectTypeInternalSlot(node) { + if (node.static) { + this.word("static"); + this.space(); + } + this.tokenChar(91); + this.tokenChar(91); + this.print(node.id); + this.tokenChar(93); + this.tokenChar(93); + if (node.optional) this.tokenChar(63); + if (!node.method) { + this.tokenChar(58); + this.space(); + } + this.print(node.value); +} +function ObjectTypeCallProperty(node) { + if (node.static) { + this.word("static"); + this.space(); + } + this.print(node.value); +} +function ObjectTypeIndexer(node) { + if (node.static) { + this.word("static"); + this.space(); + } + this._variance(node); + this.tokenChar(91); + if (node.id) { + this.print(node.id); + this.tokenChar(58); + this.space(); + } + this.print(node.key); + this.tokenChar(93); + this.tokenChar(58); + this.space(); + this.print(node.value); +} +function ObjectTypeProperty(node) { + if (node.proto) { + this.word("proto"); + this.space(); + } + if (node.static) { + this.word("static"); + this.space(); + } + if (node.kind === "get" || node.kind === "set") { + this.word(node.kind); + this.space(); + } + this._variance(node); + this.print(node.key); + if (node.optional) this.tokenChar(63); + if (!node.method) { + this.tokenChar(58); + this.space(); + } + this.print(node.value); +} +function ObjectTypeSpreadProperty(node) { + this.token("..."); + this.print(node.argument); +} +function QualifiedTypeIdentifier(node) { + this.print(node.qualification); + this.tokenChar(46); + this.print(node.id); +} +function SymbolTypeAnnotation() { + this.word("symbol"); +} +function orSeparator(occurrenceCount) { + this.space(); + this.token("|", false, occurrenceCount); + this.space(); +} +function UnionTypeAnnotation(node) { + this.printJoin(node.types, undefined, undefined, orSeparator); +} +function TypeCastExpression(node) { + this.tokenChar(40); + this.print(node.expression); + this.print(node.typeAnnotation); + this.tokenChar(41); +} +function Variance(node) { + if (node.kind === "plus") { + this.tokenChar(43); + } else { + this.tokenChar(45); + } +} +function VoidTypeAnnotation() { + this.word("void"); +} +function IndexedAccessType(node) { + this.print(node.objectType, true); + this.tokenChar(91); + this.print(node.indexType); + this.tokenChar(93); +} +function OptionalIndexedAccessType(node) { + this.print(node.objectType); + if (node.optional) { + this.token("?."); + } + this.tokenChar(91); + this.print(node.indexType); + this.tokenChar(93); +} + +//# sourceMappingURL=flow.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/flow.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/flow.js.map new file mode 100644 index 0000000000000000000000000000000000000000..a50152af7de95acf37754a3b13fc05b6a9974e11 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/flow.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_t","require","_modules","_index","_types2","isDeclareExportDeclaration","isStatement","AnyTypeAnnotation","word","ArrayTypeAnnotation","node","print","elementType","token","BooleanTypeAnnotation","BooleanLiteralTypeAnnotation","value","NullLiteralTypeAnnotation","DeclareClass","parent","space","_interfaceish","DeclareFunction","id","typeAnnotation","predicate","semicolon","InferredPredicate","DeclaredPredicate","DeclareInterface","InterfaceDeclaration","DeclareModule","body","DeclareModuleExports","DeclareTypeAlias","TypeAlias","DeclareOpaqueType","OpaqueType","DeclareVariable","DeclareExportDeclaration","default","FlowExportDeclaration","call","DeclareExportAllDeclaration","ExportAllDeclaration","EnumDeclaration","enumExplicitType","context","name","hasExplicitType","enumBody","members","indent","newline","member","hasUnknownMembers","dedent","EnumBooleanBody","explicitType","EnumNumberBody","EnumStringBody","EnumSymbolBody","EnumDefaultedMember","enumInitializedMember","init","EnumBooleanMember","EnumNumberMember","EnumStringMember","declaration","declar","specifiers","length","printList","source","ExistsTypeAnnotation","FunctionTypeAnnotation","typeParameters","this","params","rest","type","method","returnType","FunctionTypeParam","optional","InterfaceExtends","_node$extends","extends","_node$mixins","_node$implements","mixins","implements","_variance","_node$variance","kind","variance","andSeparator","occurrenceCount","InterfaceTypeAnnotation","_node$extends2","IntersectionTypeAnnotation","printJoin","types","undefined","MixedTypeAnnotation","EmptyTypeAnnotation","NullableTypeAnnotation","NumberTypeAnnotation","StringTypeAnnotation","ThisTypeAnnotation","TupleTypeAnnotation","TypeofTypeAnnotation","argument","right","TypeAnnotation","tokenContext","TokenContext","arrowFlowReturnType","TypeParameterInstantiation","TypeParameter","bound","supertype","impltype","ObjectTypeAnnotation","exact","props","properties","callProperties","indexers","internalSlots","addNewlines","leading","inexact","ObjectTypeInternalSlot","static","ObjectTypeCallProperty","ObjectTypeIndexer","key","ObjectTypeProperty","proto","ObjectTypeSpreadProperty","QualifiedTypeIdentifier","qualification","SymbolTypeAnnotation","orSeparator","UnionTypeAnnotation","TypeCastExpression","expression","Variance","VoidTypeAnnotation","IndexedAccessType","objectType","indexType","OptionalIndexedAccessType"],"sources":["../../src/generators/flow.ts"],"sourcesContent":["import type Printer from \"../printer.ts\";\nimport { isDeclareExportDeclaration, isStatement } from \"@babel/types\";\nimport type * as t from \"@babel/types\";\nimport { ExportAllDeclaration } from \"./modules.ts\";\nimport { TokenContext } from \"../node/index.ts\";\n\nexport function AnyTypeAnnotation(this: Printer) {\n this.word(\"any\");\n}\n\nexport function ArrayTypeAnnotation(\n this: Printer,\n node: t.ArrayTypeAnnotation,\n) {\n this.print(node.elementType, true);\n this.token(\"[\");\n this.token(\"]\");\n}\n\nexport function BooleanTypeAnnotation(this: Printer) {\n this.word(\"boolean\");\n}\n\nexport function BooleanLiteralTypeAnnotation(\n this: Printer,\n node: t.BooleanLiteralTypeAnnotation,\n) {\n this.word(node.value ? \"true\" : \"false\");\n}\n\nexport function NullLiteralTypeAnnotation(this: Printer) {\n this.word(\"null\");\n}\n\nexport function DeclareClass(\n this: Printer,\n node: t.DeclareClass,\n parent: t.Node,\n) {\n if (!isDeclareExportDeclaration(parent)) {\n this.word(\"declare\");\n this.space();\n }\n this.word(\"class\");\n this.space();\n this._interfaceish(node);\n}\n\nexport function DeclareFunction(\n this: Printer,\n node: t.DeclareFunction,\n parent: t.Node,\n) {\n if (!isDeclareExportDeclaration(parent)) {\n this.word(\"declare\");\n this.space();\n }\n this.word(\"function\");\n this.space();\n this.print(node.id);\n // @ts-ignore(Babel 7 vs Babel 8) TODO(Babel 8) Remove this comment, since we'll remove the Noop node\n this.print(node.id.typeAnnotation.typeAnnotation);\n\n if (node.predicate) {\n this.space();\n this.print(node.predicate);\n }\n\n this.semicolon();\n}\n\nexport function InferredPredicate(this: Printer) {\n this.token(\"%\");\n this.word(\"checks\");\n}\n\nexport function DeclaredPredicate(this: Printer, node: t.DeclaredPredicate) {\n this.token(\"%\");\n this.word(\"checks\");\n this.token(\"(\");\n this.print(node.value);\n this.token(\")\");\n}\n\nexport function DeclareInterface(this: Printer, node: t.DeclareInterface) {\n this.word(\"declare\");\n this.space();\n this.InterfaceDeclaration(node);\n}\n\nexport function DeclareModule(this: Printer, node: t.DeclareModule) {\n this.word(\"declare\");\n this.space();\n this.word(\"module\");\n this.space();\n this.print(node.id);\n this.space();\n this.print(node.body);\n}\n\nexport function DeclareModuleExports(\n this: Printer,\n node: t.DeclareModuleExports,\n) {\n this.word(\"declare\");\n this.space();\n this.word(\"module\");\n this.token(\".\");\n this.word(\"exports\");\n this.print(node.typeAnnotation);\n}\n\nexport function DeclareTypeAlias(this: Printer, node: t.DeclareTypeAlias) {\n this.word(\"declare\");\n this.space();\n this.TypeAlias(node);\n}\n\nexport function DeclareOpaqueType(\n this: Printer,\n node: t.DeclareOpaqueType,\n parent: t.Node,\n) {\n if (!isDeclareExportDeclaration(parent)) {\n this.word(\"declare\");\n this.space();\n }\n this.OpaqueType(node);\n}\n\nexport function DeclareVariable(\n this: Printer,\n node: t.DeclareVariable,\n parent: t.Node,\n) {\n if (!isDeclareExportDeclaration(parent)) {\n this.word(\"declare\");\n this.space();\n }\n this.word(\"var\");\n this.space();\n this.print(node.id);\n this.print(node.id.typeAnnotation);\n this.semicolon();\n}\n\nexport function DeclareExportDeclaration(\n this: Printer,\n node: t.DeclareExportDeclaration,\n) {\n this.word(\"declare\");\n this.space();\n this.word(\"export\");\n this.space();\n if (node.default) {\n this.word(\"default\");\n this.space();\n }\n\n FlowExportDeclaration.call(this, node);\n}\n\nexport function DeclareExportAllDeclaration(\n this: Printer,\n node: t.DeclareExportAllDeclaration,\n) {\n this.word(\"declare\");\n this.space();\n ExportAllDeclaration.call(this, node);\n}\n\nexport function EnumDeclaration(this: Printer, node: t.EnumDeclaration) {\n const { id, body } = node;\n this.word(\"enum\");\n this.space();\n this.print(id);\n this.print(body);\n}\n\nfunction enumExplicitType(\n context: Printer,\n name: string,\n hasExplicitType: boolean,\n) {\n if (hasExplicitType) {\n context.space();\n context.word(\"of\");\n context.space();\n context.word(name);\n }\n context.space();\n}\n\nfunction enumBody(context: Printer, node: t.EnumBody) {\n const { members } = node;\n context.token(\"{\");\n context.indent();\n context.newline();\n for (const member of members) {\n context.print(member);\n context.newline();\n }\n if (node.hasUnknownMembers) {\n context.token(\"...\");\n context.newline();\n }\n context.dedent();\n context.token(\"}\");\n}\n\nexport function EnumBooleanBody(this: Printer, node: t.EnumBooleanBody) {\n const { explicitType } = node;\n enumExplicitType(this, \"boolean\", explicitType);\n enumBody(this, node);\n}\n\nexport function EnumNumberBody(this: Printer, node: t.EnumNumberBody) {\n const { explicitType } = node;\n enumExplicitType(this, \"number\", explicitType);\n enumBody(this, node);\n}\n\nexport function EnumStringBody(this: Printer, node: t.EnumStringBody) {\n const { explicitType } = node;\n enumExplicitType(this, \"string\", explicitType);\n enumBody(this, node);\n}\n\nexport function EnumSymbolBody(this: Printer, node: t.EnumSymbolBody) {\n enumExplicitType(this, \"symbol\", true);\n enumBody(this, node);\n}\n\nexport function EnumDefaultedMember(\n this: Printer,\n node: t.EnumDefaultedMember,\n) {\n const { id } = node;\n this.print(id);\n this.token(\",\");\n}\n\nfunction enumInitializedMember(\n context: Printer,\n node: t.EnumBooleanMember | t.EnumNumberMember | t.EnumStringMember,\n) {\n context.print(node.id);\n context.space();\n context.token(\"=\");\n context.space();\n context.print(node.init);\n context.token(\",\");\n}\n\nexport function EnumBooleanMember(this: Printer, node: t.EnumBooleanMember) {\n enumInitializedMember(this, node);\n}\n\nexport function EnumNumberMember(this: Printer, node: t.EnumNumberMember) {\n enumInitializedMember(this, node);\n}\n\nexport function EnumStringMember(this: Printer, node: t.EnumStringMember) {\n enumInitializedMember(this, node);\n}\n\nfunction FlowExportDeclaration(\n this: Printer,\n node: t.DeclareExportDeclaration,\n) {\n if (node.declaration) {\n const declar = node.declaration;\n this.print(declar);\n if (!isStatement(declar)) this.semicolon();\n } else {\n this.token(\"{\");\n if (node.specifiers.length) {\n this.space();\n this.printList(node.specifiers);\n this.space();\n }\n this.token(\"}\");\n\n if (node.source) {\n this.space();\n this.word(\"from\");\n this.space();\n this.print(node.source);\n }\n\n this.semicolon();\n }\n}\n\nexport function ExistsTypeAnnotation(this: Printer) {\n this.token(\"*\");\n}\n\nexport function FunctionTypeAnnotation(\n this: Printer,\n node: t.FunctionTypeAnnotation,\n parent?: t.Node,\n) {\n this.print(node.typeParameters);\n this.token(\"(\");\n\n if (node.this) {\n this.word(\"this\");\n this.token(\":\");\n this.space();\n this.print(node.this.typeAnnotation);\n if (node.params.length || node.rest) {\n this.token(\",\");\n this.space();\n }\n }\n\n this.printList(node.params);\n\n if (node.rest) {\n if (node.params.length) {\n this.token(\",\");\n this.space();\n }\n this.token(\"...\");\n this.print(node.rest);\n }\n\n this.token(\")\");\n\n // this node type is overloaded, not sure why but it makes it EXTREMELY annoying\n\n const type = parent?.type;\n if (\n type != null &&\n (type === \"ObjectTypeCallProperty\" ||\n type === \"ObjectTypeInternalSlot\" ||\n type === \"DeclareFunction\" ||\n (type === \"ObjectTypeProperty\" && parent.method))\n ) {\n this.token(\":\");\n } else {\n this.space();\n this.token(\"=>\");\n }\n\n this.space();\n this.print(node.returnType);\n}\n\nexport function FunctionTypeParam(this: Printer, node: t.FunctionTypeParam) {\n this.print(node.name);\n if (node.optional) this.token(\"?\");\n if (node.name) {\n this.token(\":\");\n this.space();\n }\n this.print(node.typeAnnotation);\n}\n\nexport function InterfaceExtends(this: Printer, node: t.InterfaceExtends) {\n this.print(node.id);\n this.print(node.typeParameters, true);\n}\n\nexport {\n InterfaceExtends as ClassImplements,\n InterfaceExtends as GenericTypeAnnotation,\n};\n\nexport function _interfaceish(\n this: Printer,\n node: t.InterfaceDeclaration | t.DeclareInterface | t.DeclareClass,\n) {\n this.print(node.id);\n this.print(node.typeParameters);\n if (node.extends?.length) {\n this.space();\n this.word(\"extends\");\n this.space();\n this.printList(node.extends);\n }\n if (node.type === \"DeclareClass\") {\n if (node.mixins?.length) {\n this.space();\n this.word(\"mixins\");\n this.space();\n this.printList(node.mixins);\n }\n if (node.implements?.length) {\n this.space();\n this.word(\"implements\");\n this.space();\n this.printList(node.implements);\n }\n }\n this.space();\n this.print(node.body);\n}\n\nexport function _variance(\n this: Printer,\n node:\n | t.TypeParameter\n | t.ObjectTypeIndexer\n | t.ObjectTypeProperty\n | t.ClassProperty\n | t.ClassPrivateProperty\n | t.ClassAccessorProperty,\n) {\n const kind = node.variance?.kind;\n if (kind != null) {\n if (kind === \"plus\") {\n this.token(\"+\");\n } else if (kind === \"minus\") {\n this.token(\"-\");\n }\n }\n}\n\nexport function InterfaceDeclaration(\n this: Printer,\n node: t.InterfaceDeclaration | t.DeclareInterface,\n) {\n this.word(\"interface\");\n this.space();\n this._interfaceish(node);\n}\n\nfunction andSeparator(this: Printer, occurrenceCount: number) {\n this.space();\n this.token(\"&\", false, occurrenceCount);\n this.space();\n}\n\nexport function InterfaceTypeAnnotation(\n this: Printer,\n node: t.InterfaceTypeAnnotation,\n) {\n this.word(\"interface\");\n if (node.extends?.length) {\n this.space();\n this.word(\"extends\");\n this.space();\n this.printList(node.extends);\n }\n this.space();\n this.print(node.body);\n}\n\nexport function IntersectionTypeAnnotation(\n this: Printer,\n node: t.IntersectionTypeAnnotation,\n) {\n this.printJoin(node.types, undefined, undefined, andSeparator);\n}\n\nexport function MixedTypeAnnotation(this: Printer) {\n this.word(\"mixed\");\n}\n\nexport function EmptyTypeAnnotation(this: Printer) {\n this.word(\"empty\");\n}\n\nexport function NullableTypeAnnotation(\n this: Printer,\n node: t.NullableTypeAnnotation,\n) {\n this.token(\"?\");\n this.print(node.typeAnnotation);\n}\n\nexport {\n NumericLiteral as NumberLiteralTypeAnnotation,\n StringLiteral as StringLiteralTypeAnnotation,\n} from \"./types.ts\";\n\nexport function NumberTypeAnnotation(this: Printer) {\n this.word(\"number\");\n}\n\nexport function StringTypeAnnotation(this: Printer) {\n this.word(\"string\");\n}\n\nexport function ThisTypeAnnotation(this: Printer) {\n this.word(\"this\");\n}\n\nexport function TupleTypeAnnotation(\n this: Printer,\n node: t.TupleTypeAnnotation,\n) {\n this.token(\"[\");\n this.printList(node.types);\n this.token(\"]\");\n}\n\nexport function TypeofTypeAnnotation(\n this: Printer,\n node: t.TypeofTypeAnnotation,\n) {\n this.word(\"typeof\");\n this.space();\n this.print(node.argument);\n}\n\nexport function TypeAlias(\n this: Printer,\n node: t.TypeAlias | t.DeclareTypeAlias,\n) {\n this.word(\"type\");\n this.space();\n this.print(node.id);\n this.print(node.typeParameters);\n this.space();\n this.token(\"=\");\n this.space();\n this.print(node.right);\n this.semicolon();\n}\n\nexport function TypeAnnotation(\n this: Printer,\n node: t.TypeAnnotation,\n parent: t.Node,\n) {\n this.token(\":\");\n this.space();\n if (parent.type === \"ArrowFunctionExpression\") {\n this.tokenContext |= TokenContext.arrowFlowReturnType;\n } else if (\n // @ts-expect-error todo(flow->ts) can this be removed? `.optional` looks to be not existing property\n node.optional\n ) {\n this.token(\"?\");\n }\n this.print(node.typeAnnotation);\n}\n\nexport function TypeParameterInstantiation(\n this: Printer,\n node: t.TypeParameterInstantiation,\n): void {\n this.token(\"<\");\n this.printList(node.params);\n this.token(\">\");\n}\n\nexport { TypeParameterInstantiation as TypeParameterDeclaration };\n\nexport function TypeParameter(this: Printer, node: t.TypeParameter) {\n this._variance(node);\n\n this.word(node.name);\n\n if (node.bound) {\n this.print(node.bound);\n }\n\n if (node.default) {\n this.space();\n this.token(\"=\");\n this.space();\n this.print(node.default);\n }\n}\n\nexport function OpaqueType(\n this: Printer,\n node: t.OpaqueType | t.DeclareOpaqueType,\n) {\n this.word(\"opaque\");\n this.space();\n this.word(\"type\");\n this.space();\n this.print(node.id);\n this.print(node.typeParameters);\n if (node.supertype) {\n this.token(\":\");\n this.space();\n this.print(node.supertype);\n }\n\n if (node.impltype) {\n this.space();\n this.token(\"=\");\n this.space();\n this.print(node.impltype);\n }\n this.semicolon();\n}\n\nexport function ObjectTypeAnnotation(\n this: Printer,\n node: t.ObjectTypeAnnotation,\n) {\n if (node.exact) {\n this.token(\"{|\");\n } else {\n this.token(\"{\");\n }\n\n // TODO: remove the array fallbacks and instead enforce the types to require an array\n const props = [\n ...node.properties,\n ...(node.callProperties || []),\n ...(node.indexers || []),\n ...(node.internalSlots || []),\n ];\n\n if (props.length) {\n this.newline();\n\n this.space();\n\n this.printJoin(\n props,\n true,\n true,\n undefined,\n undefined,\n function addNewlines(leading) {\n if (leading && !props[0]) return 1;\n },\n () => {\n if (props.length !== 1 || node.inexact) {\n this.token(\",\");\n this.space();\n }\n },\n );\n\n this.space();\n }\n\n if (node.inexact) {\n this.indent();\n this.token(\"...\");\n if (props.length) {\n this.newline();\n }\n this.dedent();\n }\n\n if (node.exact) {\n this.token(\"|}\");\n } else {\n this.token(\"}\");\n }\n}\n\nexport function ObjectTypeInternalSlot(\n this: Printer,\n node: t.ObjectTypeInternalSlot,\n) {\n if (node.static) {\n this.word(\"static\");\n this.space();\n }\n this.token(\"[\");\n this.token(\"[\");\n this.print(node.id);\n this.token(\"]\");\n this.token(\"]\");\n if (node.optional) this.token(\"?\");\n if (!node.method) {\n this.token(\":\");\n this.space();\n }\n this.print(node.value);\n}\n\nexport function ObjectTypeCallProperty(\n this: Printer,\n node: t.ObjectTypeCallProperty,\n) {\n if (node.static) {\n this.word(\"static\");\n this.space();\n }\n this.print(node.value);\n}\n\nexport function ObjectTypeIndexer(this: Printer, node: t.ObjectTypeIndexer) {\n if (node.static) {\n this.word(\"static\");\n this.space();\n }\n this._variance(node);\n this.token(\"[\");\n if (node.id) {\n this.print(node.id);\n this.token(\":\");\n this.space();\n }\n this.print(node.key);\n this.token(\"]\");\n this.token(\":\");\n this.space();\n this.print(node.value);\n}\n\nexport function ObjectTypeProperty(this: Printer, node: t.ObjectTypeProperty) {\n if (node.proto) {\n this.word(\"proto\");\n this.space();\n }\n if (node.static) {\n this.word(\"static\");\n this.space();\n }\n if (node.kind === \"get\" || node.kind === \"set\") {\n this.word(node.kind);\n this.space();\n }\n this._variance(node);\n this.print(node.key);\n if (node.optional) this.token(\"?\");\n if (!node.method) {\n this.token(\":\");\n this.space();\n }\n this.print(node.value);\n}\n\nexport function ObjectTypeSpreadProperty(\n this: Printer,\n node: t.ObjectTypeSpreadProperty,\n) {\n this.token(\"...\");\n this.print(node.argument);\n}\n\nexport function QualifiedTypeIdentifier(\n this: Printer,\n node: t.QualifiedTypeIdentifier,\n) {\n this.print(node.qualification);\n this.token(\".\");\n this.print(node.id);\n}\n\nexport function SymbolTypeAnnotation(this: Printer) {\n this.word(\"symbol\");\n}\n\nfunction orSeparator(this: Printer, occurrenceCount: number) {\n this.space();\n this.token(\"|\", false, occurrenceCount);\n this.space();\n}\n\nexport function UnionTypeAnnotation(\n this: Printer,\n node: t.UnionTypeAnnotation,\n) {\n this.printJoin(node.types, undefined, undefined, orSeparator);\n}\n\nexport function TypeCastExpression(this: Printer, node: t.TypeCastExpression) {\n this.token(\"(\");\n this.print(node.expression);\n this.print(node.typeAnnotation);\n this.token(\")\");\n}\n\nexport function Variance(this: Printer, node: t.Variance) {\n if (node.kind === \"plus\") {\n this.token(\"+\");\n } else {\n this.token(\"-\");\n }\n}\n\nexport function VoidTypeAnnotation(this: Printer) {\n this.word(\"void\");\n}\n\nexport function IndexedAccessType(this: Printer, node: t.IndexedAccessType) {\n this.print(node.objectType, true);\n this.token(\"[\");\n this.print(node.indexType);\n this.token(\"]\");\n}\n\nexport function OptionalIndexedAccessType(\n this: Printer,\n node: t.OptionalIndexedAccessType,\n) {\n this.print(node.objectType);\n if (node.optional) {\n this.token(\"?.\");\n }\n this.token(\"[\");\n this.print(node.indexType);\n this.token(\"]\");\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/index.js new file mode 100644 index 0000000000000000000000000000000000000000..331c73f7e6a07ada1a19bf13ef6113b6f38188ac --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/index.js @@ -0,0 +1,128 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +var _templateLiterals = require("./template-literals.js"); +Object.keys(_templateLiterals).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (key in exports && exports[key] === _templateLiterals[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _templateLiterals[key]; + } + }); +}); +var _expressions = require("./expressions.js"); +Object.keys(_expressions).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (key in exports && exports[key] === _expressions[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _expressions[key]; + } + }); +}); +var _statements = require("./statements.js"); +Object.keys(_statements).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (key in exports && exports[key] === _statements[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _statements[key]; + } + }); +}); +var _classes = require("./classes.js"); +Object.keys(_classes).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (key in exports && exports[key] === _classes[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _classes[key]; + } + }); +}); +var _methods = require("./methods.js"); +Object.keys(_methods).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (key in exports && exports[key] === _methods[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _methods[key]; + } + }); +}); +var _modules = require("./modules.js"); +Object.keys(_modules).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (key in exports && exports[key] === _modules[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _modules[key]; + } + }); +}); +var _types = require("./types.js"); +Object.keys(_types).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (key in exports && exports[key] === _types[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _types[key]; + } + }); +}); +var _flow = require("./flow.js"); +Object.keys(_flow).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (key in exports && exports[key] === _flow[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _flow[key]; + } + }); +}); +var _base = require("./base.js"); +Object.keys(_base).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (key in exports && exports[key] === _base[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _base[key]; + } + }); +}); +var _jsx = require("./jsx.js"); +Object.keys(_jsx).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (key in exports && exports[key] === _jsx[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _jsx[key]; + } + }); +}); +var _typescript = require("./typescript.js"); +Object.keys(_typescript).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (key in exports && exports[key] === _typescript[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _typescript[key]; + } + }); +}); + +//# sourceMappingURL=index.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/index.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/index.js.map new file mode 100644 index 0000000000000000000000000000000000000000..e8b0341b9abe0f470fbdb6e32458c363f2ea8866 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/index.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_templateLiterals","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get","_expressions","_statements","_classes","_methods","_modules","_types","_flow","_base","_jsx","_typescript"],"sources":["../../src/generators/index.ts"],"sourcesContent":["export * from \"./template-literals.ts\";\nexport * from \"./expressions.ts\";\nexport * from \"./statements.ts\";\nexport * from \"./classes.ts\";\nexport * from \"./methods.ts\";\nexport * from \"./modules.ts\";\nexport * from \"./types.ts\";\nexport * from \"./flow.ts\";\nexport * from \"./base.ts\";\nexport * from \"./jsx.ts\";\nexport * from \"./typescript.ts\";\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/jsx.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/jsx.js new file mode 100644 index 0000000000000000000000000000000000000000..2650ec1e3046cd0a11375ae876195f57d256dea0 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/jsx.js @@ -0,0 +1,126 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.JSXAttribute = JSXAttribute; +exports.JSXClosingElement = JSXClosingElement; +exports.JSXClosingFragment = JSXClosingFragment; +exports.JSXElement = JSXElement; +exports.JSXEmptyExpression = JSXEmptyExpression; +exports.JSXExpressionContainer = JSXExpressionContainer; +exports.JSXFragment = JSXFragment; +exports.JSXIdentifier = JSXIdentifier; +exports.JSXMemberExpression = JSXMemberExpression; +exports.JSXNamespacedName = JSXNamespacedName; +exports.JSXOpeningElement = JSXOpeningElement; +exports.JSXOpeningFragment = JSXOpeningFragment; +exports.JSXSpreadAttribute = JSXSpreadAttribute; +exports.JSXSpreadChild = JSXSpreadChild; +exports.JSXText = JSXText; +function JSXAttribute(node) { + this.print(node.name); + if (node.value) { + this.tokenChar(61); + this.print(node.value); + } +} +function JSXIdentifier(node) { + this.word(node.name); +} +function JSXNamespacedName(node) { + this.print(node.namespace); + this.tokenChar(58); + this.print(node.name); +} +function JSXMemberExpression(node) { + this.print(node.object); + this.tokenChar(46); + this.print(node.property); +} +function JSXSpreadAttribute(node) { + this.tokenChar(123); + this.token("..."); + this.print(node.argument); + this.rightBrace(node); +} +function JSXExpressionContainer(node) { + this.tokenChar(123); + this.print(node.expression); + this.rightBrace(node); +} +function JSXSpreadChild(node) { + this.tokenChar(123); + this.token("..."); + this.print(node.expression); + this.rightBrace(node); +} +function JSXText(node) { + const raw = this.getPossibleRaw(node); + if (raw !== undefined) { + this.token(raw, true); + } else { + this.token(node.value, true); + } +} +function JSXElement(node) { + const open = node.openingElement; + this.print(open); + if (open.selfClosing) return; + this.indent(); + for (const child of node.children) { + this.print(child); + } + this.dedent(); + this.print(node.closingElement); +} +function spaceSeparator() { + this.space(); +} +function JSXOpeningElement(node) { + this.tokenChar(60); + this.print(node.name); + { + if (node.typeArguments) { + this.print(node.typeArguments); + } + this.print(node.typeParameters); + } + if (node.attributes.length > 0) { + this.space(); + this.printJoin(node.attributes, undefined, undefined, spaceSeparator); + } + if (node.selfClosing) { + this.space(); + this.tokenChar(47); + } + this.tokenChar(62); +} +function JSXClosingElement(node) { + this.tokenChar(60); + this.tokenChar(47); + this.print(node.name); + this.tokenChar(62); +} +function JSXEmptyExpression() { + this.printInnerComments(); +} +function JSXFragment(node) { + this.print(node.openingFragment); + this.indent(); + for (const child of node.children) { + this.print(child); + } + this.dedent(); + this.print(node.closingFragment); +} +function JSXOpeningFragment() { + this.tokenChar(60); + this.tokenChar(62); +} +function JSXClosingFragment() { + this.token(" 0) {\n this.space();\n this.printJoin(node.attributes, undefined, undefined, spaceSeparator);\n }\n if (node.selfClosing) {\n this.space();\n this.token(\"/\");\n }\n this.token(\">\");\n}\n\nexport function JSXClosingElement(this: Printer, node: t.JSXClosingElement) {\n this.token(\"<\");\n this.token(\"/\");\n this.print(node.name);\n this.token(\">\");\n}\n\nexport function JSXEmptyExpression(this: Printer) {\n // This node is empty, so forcefully print its inner comments.\n this.printInnerComments();\n}\n\nexport function JSXFragment(this: Printer, node: t.JSXFragment) {\n this.print(node.openingFragment);\n\n this.indent();\n for (const child of node.children) {\n this.print(child);\n }\n this.dedent();\n\n this.print(node.closingFragment);\n}\n\nexport function JSXOpeningFragment(this: Printer) {\n this.token(\"<\");\n this.token(\">\");\n}\n\nexport function JSXClosingFragment(this: Printer) {\n this.token(\"\");\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/methods.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/methods.js new file mode 100644 index 0000000000000000000000000000000000000000..eabb16d1ae2ac7e26c3ecbe0a0677247387cb102 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/methods.js @@ -0,0 +1,198 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.ArrowFunctionExpression = ArrowFunctionExpression; +exports.FunctionDeclaration = exports.FunctionExpression = FunctionExpression; +exports._functionHead = _functionHead; +exports._methodHead = _methodHead; +exports._param = _param; +exports._parameters = _parameters; +exports._params = _params; +exports._predicate = _predicate; +exports._shouldPrintArrowParamsParens = _shouldPrintArrowParamsParens; +var _t = require("@babel/types"); +var _index = require("../node/index.js"); +const { + isIdentifier +} = _t; +function _params(node, idNode, parentNode) { + this.print(node.typeParameters); + const nameInfo = _getFuncIdName.call(this, idNode, parentNode); + if (nameInfo) { + this.sourceIdentifierName(nameInfo.name, nameInfo.pos); + } + this.tokenChar(40); + this._parameters(node.params, ")"); + const noLineTerminator = node.type === "ArrowFunctionExpression"; + this.print(node.returnType, noLineTerminator); + this._noLineTerminator = noLineTerminator; +} +function _parameters(parameters, endToken) { + const exit = this.enterDelimited(); + const trailingComma = this.shouldPrintTrailingComma(endToken); + const paramLength = parameters.length; + for (let i = 0; i < paramLength; i++) { + this._param(parameters[i]); + if (trailingComma || i < paramLength - 1) { + this.token(",", null, i); + this.space(); + } + } + this.token(endToken); + exit(); +} +function _param(parameter) { + this.printJoin(parameter.decorators); + this.print(parameter); + if (parameter.optional) { + this.tokenChar(63); + } + this.print(parameter.typeAnnotation); +} +function _methodHead(node) { + const kind = node.kind; + const key = node.key; + if (kind === "get" || kind === "set") { + this.word(kind); + this.space(); + } + if (node.async) { + this.word("async", true); + this.space(); + } + if (kind === "method" || kind === "init") { + if (node.generator) { + this.tokenChar(42); + } + } + if (node.computed) { + this.tokenChar(91); + this.print(key); + this.tokenChar(93); + } else { + this.print(key); + } + if (node.optional) { + this.tokenChar(63); + } + this._params(node, node.computed && node.key.type !== "StringLiteral" ? undefined : node.key, undefined); +} +function _predicate(node, noLineTerminatorAfter) { + if (node.predicate) { + if (!node.returnType) { + this.tokenChar(58); + } + this.space(); + this.print(node.predicate, noLineTerminatorAfter); + } +} +function _functionHead(node, parent) { + if (node.async) { + this.word("async"); + if (!this.format.preserveFormat) { + this._endsWithInnerRaw = false; + } + this.space(); + } + this.word("function"); + if (node.generator) { + if (!this.format.preserveFormat) { + this._endsWithInnerRaw = false; + } + this.tokenChar(42); + } + this.space(); + if (node.id) { + this.print(node.id); + } + this._params(node, node.id, parent); + if (node.type !== "TSDeclareFunction") { + this._predicate(node); + } +} +function FunctionExpression(node, parent) { + this._functionHead(node, parent); + this.space(); + this.print(node.body); +} +function ArrowFunctionExpression(node, parent) { + if (node.async) { + this.word("async", true); + this.space(); + } + if (this._shouldPrintArrowParamsParens(node)) { + this._params(node, undefined, parent); + } else { + this.print(node.params[0], true); + } + this._predicate(node, true); + this.space(); + this.printInnerComments(); + this.token("=>"); + this.space(); + this.tokenContext |= _index.TokenContext.arrowBody; + this.print(node.body); +} +function _shouldPrintArrowParamsParens(node) { + var _firstParam$leadingCo, _firstParam$trailingC; + if (node.params.length !== 1) return true; + if (node.typeParameters || node.returnType || node.predicate) { + return true; + } + const firstParam = node.params[0]; + if (!isIdentifier(firstParam) || firstParam.typeAnnotation || firstParam.optional || (_firstParam$leadingCo = firstParam.leadingComments) != null && _firstParam$leadingCo.length || (_firstParam$trailingC = firstParam.trailingComments) != null && _firstParam$trailingC.length) { + return true; + } + if (this.tokenMap) { + if (node.loc == null) return true; + if (this.tokenMap.findMatching(node, "(") !== null) return true; + const arrowToken = this.tokenMap.findMatching(node, "=>"); + if ((arrowToken == null ? void 0 : arrowToken.loc) == null) return true; + return arrowToken.loc.start.line !== node.loc.start.line; + } + if (this.format.retainLines) return true; + return false; +} +function _getFuncIdName(idNode, parent) { + let id = idNode; + if (!id && parent) { + const parentType = parent.type; + if (parentType === "VariableDeclarator") { + id = parent.id; + } else if (parentType === "AssignmentExpression" || parentType === "AssignmentPattern") { + id = parent.left; + } else if (parentType === "ObjectProperty" || parentType === "ClassProperty") { + if (!parent.computed || parent.key.type === "StringLiteral") { + id = parent.key; + } + } else if (parentType === "ClassPrivateProperty" || parentType === "ClassAccessorProperty") { + id = parent.key; + } + } + if (!id) return; + let nameInfo; + if (id.type === "Identifier") { + var _id$loc, _id$loc2; + nameInfo = { + pos: (_id$loc = id.loc) == null ? void 0 : _id$loc.start, + name: ((_id$loc2 = id.loc) == null ? void 0 : _id$loc2.identifierName) || id.name + }; + } else if (id.type === "PrivateName") { + var _id$loc3; + nameInfo = { + pos: (_id$loc3 = id.loc) == null ? void 0 : _id$loc3.start, + name: "#" + id.id.name + }; + } else if (id.type === "StringLiteral") { + var _id$loc4; + nameInfo = { + pos: (_id$loc4 = id.loc) == null ? void 0 : _id$loc4.start, + name: id.value + }; + } + return nameInfo; +} + +//# sourceMappingURL=methods.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/methods.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/methods.js.map new file mode 100644 index 0000000000000000000000000000000000000000..a0f221fe69f29a022303ab7fc7b8988bab588038 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/methods.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_t","require","_index","isIdentifier","_params","node","idNode","parentNode","print","typeParameters","nameInfo","_getFuncIdName","call","sourceIdentifierName","name","pos","token","_parameters","params","noLineTerminator","type","returnType","_noLineTerminator","parameters","endToken","exit","enterDelimited","trailingComma","shouldPrintTrailingComma","paramLength","length","i","_param","space","parameter","printJoin","decorators","optional","typeAnnotation","_methodHead","kind","key","word","async","generator","computed","undefined","_predicate","noLineTerminatorAfter","predicate","_functionHead","parent","format","preserveFormat","_endsWithInnerRaw","id","FunctionExpression","body","ArrowFunctionExpression","_shouldPrintArrowParamsParens","printInnerComments","tokenContext","TokenContext","arrowBody","_firstParam$leadingCo","_firstParam$trailingC","firstParam","leadingComments","trailingComments","tokenMap","loc","findMatching","arrowToken","start","line","retainLines","parentType","left","_id$loc","_id$loc2","identifierName","_id$loc3","_id$loc4","value"],"sources":["../../src/generators/methods.ts"],"sourcesContent":["import type Printer from \"../printer.ts\";\nimport type * as t from \"@babel/types\";\nimport { isIdentifier, type ParentMaps } from \"@babel/types\";\nimport { TokenContext } from \"../node/index.ts\";\n\ntype ParentsOf = ParentMaps[T[\"type\"]];\n\nexport function _params(\n this: Printer,\n node: t.Function | t.TSDeclareMethod | t.TSDeclareFunction,\n idNode: t.Expression | t.PrivateName,\n parentNode: ParentsOf,\n) {\n this.print(node.typeParameters);\n\n const nameInfo = _getFuncIdName.call(this, idNode, parentNode);\n if (nameInfo) {\n this.sourceIdentifierName(nameInfo.name, nameInfo.pos);\n }\n\n this.token(\"(\");\n this._parameters(node.params, \")\");\n\n const noLineTerminator = node.type === \"ArrowFunctionExpression\";\n this.print(node.returnType, noLineTerminator);\n\n this._noLineTerminator = noLineTerminator;\n}\n\nexport function _parameters(\n this: Printer,\n parameters: t.Function[\"params\"],\n endToken: string,\n) {\n const exit = this.enterDelimited();\n\n const trailingComma = this.shouldPrintTrailingComma(endToken);\n\n const paramLength = parameters.length;\n for (let i = 0; i < paramLength; i++) {\n this._param(parameters[i]);\n\n if (trailingComma || i < paramLength - 1) {\n this.token(\",\", null, i);\n this.space();\n }\n }\n\n this.token(endToken);\n exit();\n}\n\nexport function _param(\n this: Printer,\n parameter: t.Identifier | t.RestElement | t.Pattern | t.TSParameterProperty,\n) {\n // @ts-expect-error decorators is not in VoidPattern\n this.printJoin(parameter.decorators);\n this.print(parameter);\n if (\n // @ts-expect-error optional is not in TSParameterProperty\n parameter.optional\n ) {\n this.token(\"?\"); // TS / flow\n }\n\n this.print(\n // @ts-expect-error typeAnnotation is not in TSParameterProperty\n parameter.typeAnnotation,\n ); // TS / flow\n}\n\nexport function _methodHead(this: Printer, node: t.Method | t.TSDeclareMethod) {\n const kind = node.kind;\n const key = node.key;\n\n if (kind === \"get\" || kind === \"set\") {\n this.word(kind);\n this.space();\n }\n\n if (node.async) {\n this.word(\"async\", true);\n this.space();\n }\n\n if (\n kind === \"method\" ||\n // @ts-expect-error Fixme: kind: \"init\" is not defined\n kind === \"init\"\n ) {\n if (node.generator) {\n this.token(\"*\");\n }\n }\n\n if (node.computed) {\n this.token(\"[\");\n this.print(key);\n this.token(\"]\");\n } else {\n this.print(key);\n }\n\n if (\n // @ts-expect-error optional is not in ObjectMethod\n node.optional\n ) {\n // TS\n this.token(\"?\");\n }\n\n this._params(\n node,\n node.computed && node.key.type !== \"StringLiteral\" ? undefined : node.key,\n undefined,\n );\n}\n\nexport function _predicate(\n this: Printer,\n node:\n | t.FunctionDeclaration\n | t.FunctionExpression\n | t.ArrowFunctionExpression,\n noLineTerminatorAfter?: boolean,\n) {\n if (node.predicate) {\n if (!node.returnType) {\n this.token(\":\");\n }\n this.space();\n this.print(node.predicate, noLineTerminatorAfter);\n }\n}\n\nexport function _functionHead(\n this: Printer,\n node: t.FunctionDeclaration | t.FunctionExpression | t.TSDeclareFunction,\n parent: ParentsOf,\n) {\n if (node.async) {\n this.word(\"async\");\n if (!this.format.preserveFormat) {\n // We prevent inner comments from being printed here,\n // so that they are always consistently printed in the\n // same place regardless of the function type.\n this._endsWithInnerRaw = false;\n }\n this.space();\n }\n this.word(\"function\");\n if (node.generator) {\n if (!this.format.preserveFormat) {\n // We prevent inner comments from being printed here,\n // so that they are always consistently printed in the\n // same place regardless of the function type.\n this._endsWithInnerRaw = false;\n }\n this.token(\"*\");\n }\n\n this.space();\n if (node.id) {\n this.print(node.id);\n }\n\n this._params(node, node.id, parent);\n if (node.type !== \"TSDeclareFunction\") {\n this._predicate(node);\n }\n}\n\nexport function FunctionExpression(\n this: Printer,\n node: t.FunctionExpression,\n parent: ParentsOf,\n) {\n this._functionHead(node, parent);\n this.space();\n this.print(node.body);\n}\n\nexport { FunctionExpression as FunctionDeclaration };\n\nexport function ArrowFunctionExpression(\n this: Printer,\n node: t.ArrowFunctionExpression,\n parent: ParentsOf,\n) {\n if (node.async) {\n this.word(\"async\", true);\n this.space();\n }\n\n if (this._shouldPrintArrowParamsParens(node)) {\n this._params(node, undefined, parent);\n } else {\n this.print(node.params[0], true);\n }\n\n this._predicate(node, true);\n this.space();\n // When printing (x)/*1*/=>{}, we remove the parentheses\n // and thus there aren't two contiguous inner tokens.\n // We forcefully print inner comments here.\n this.printInnerComments();\n this.token(\"=>\");\n\n this.space();\n\n this.tokenContext |= TokenContext.arrowBody;\n this.print(node.body);\n}\n\n// Try to avoid printing parens in simple cases, but only if we're pretty\n// sure that they aren't needed by type annotations or potential newlines.\nexport function _shouldPrintArrowParamsParens(\n this: Printer,\n node: t.ArrowFunctionExpression,\n): boolean {\n if (node.params.length !== 1) return true;\n\n if (node.typeParameters || node.returnType || node.predicate) {\n return true;\n }\n\n const firstParam = node.params[0];\n if (\n !isIdentifier(firstParam) ||\n firstParam.typeAnnotation ||\n firstParam.optional ||\n // Flow does not support `foo /*: string*/ => {};`\n firstParam.leadingComments?.length ||\n firstParam.trailingComments?.length\n ) {\n return true;\n }\n\n if (this.tokenMap) {\n if (node.loc == null) return true;\n if (this.tokenMap.findMatching(node, \"(\") !== null) return true;\n const arrowToken = this.tokenMap.findMatching(node, \"=>\");\n if (arrowToken?.loc == null) return true;\n return arrowToken.loc.start.line !== node.loc.start.line;\n }\n\n if (this.format.retainLines) return true;\n\n return false;\n}\n\nfunction _getFuncIdName(\n this: Printer,\n idNode: t.Expression | t.PrivateName,\n parent: ParentsOf,\n) {\n let id: t.Expression | t.PrivateName | t.LVal | t.VoidPattern = idNode;\n\n if (!id && parent) {\n const parentType = parent.type;\n\n if (parentType === \"VariableDeclarator\") {\n id = parent.id;\n } else if (\n parentType === \"AssignmentExpression\" ||\n parentType === \"AssignmentPattern\"\n ) {\n id = parent.left;\n } else if (\n parentType === \"ObjectProperty\" ||\n parentType === \"ClassProperty\"\n ) {\n if (!parent.computed || parent.key.type === \"StringLiteral\") {\n id = parent.key;\n }\n } else if (\n parentType === \"ClassPrivateProperty\" ||\n parentType === \"ClassAccessorProperty\"\n ) {\n id = parent.key;\n }\n }\n\n if (!id) return;\n\n let nameInfo;\n\n if (id.type === \"Identifier\") {\n nameInfo = {\n pos: id.loc?.start,\n name: id.loc?.identifierName || id.name,\n };\n } else if (id.type === \"PrivateName\") {\n nameInfo = {\n pos: id.loc?.start,\n name: \"#\" + id.id.name,\n };\n } else if (id.type === \"StringLiteral\") {\n nameInfo = {\n pos: id.loc?.start,\n name: id.value,\n };\n }\n\n return nameInfo;\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/modules.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/modules.js new file mode 100644 index 0000000000000000000000000000000000000000..8b536d90c7bf8023fe740853cb900601d9e59b47 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/modules.js @@ -0,0 +1,287 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.ExportAllDeclaration = ExportAllDeclaration; +exports.ExportDefaultDeclaration = ExportDefaultDeclaration; +exports.ExportDefaultSpecifier = ExportDefaultSpecifier; +exports.ExportNamedDeclaration = ExportNamedDeclaration; +exports.ExportNamespaceSpecifier = ExportNamespaceSpecifier; +exports.ExportSpecifier = ExportSpecifier; +exports.ImportAttribute = ImportAttribute; +exports.ImportDeclaration = ImportDeclaration; +exports.ImportDefaultSpecifier = ImportDefaultSpecifier; +exports.ImportExpression = ImportExpression; +exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier; +exports.ImportSpecifier = ImportSpecifier; +exports._printAttributes = _printAttributes; +var _t = require("@babel/types"); +var _index = require("../node/index.js"); +const { + isClassDeclaration, + isExportDefaultSpecifier, + isExportNamespaceSpecifier, + isImportDefaultSpecifier, + isImportNamespaceSpecifier, + isStatement +} = _t; +function ImportSpecifier(node) { + if (node.importKind === "type" || node.importKind === "typeof") { + this.word(node.importKind); + this.space(); + } + this.print(node.imported); + if (node.local && node.local.name !== node.imported.name) { + this.space(); + this.word("as"); + this.space(); + this.print(node.local); + } +} +function ImportDefaultSpecifier(node) { + this.print(node.local); +} +function ExportDefaultSpecifier(node) { + this.print(node.exported); +} +function ExportSpecifier(node) { + if (node.exportKind === "type") { + this.word("type"); + this.space(); + } + this.print(node.local); + if (node.exported && node.local.name !== node.exported.name) { + this.space(); + this.word("as"); + this.space(); + this.print(node.exported); + } +} +function ExportNamespaceSpecifier(node) { + this.tokenChar(42); + this.space(); + this.word("as"); + this.space(); + this.print(node.exported); +} +let warningShown = false; +function _printAttributes(node, hasPreviousBrace) { + var _node$extra; + const { + importAttributesKeyword + } = this.format; + const { + attributes, + assertions + } = node; + if (attributes && !importAttributesKeyword && node.extra && (node.extra.deprecatedAssertSyntax || node.extra.deprecatedWithLegacySyntax) && !warningShown) { + warningShown = true; + console.warn(`\ +You are using import attributes, without specifying the desired output syntax. +Please specify the "importAttributesKeyword" generator option, whose value can be one of: + - "with" : \`import { a } from "b" with { type: "json" };\` + - "assert" : \`import { a } from "b" assert { type: "json" };\` + - "with-legacy" : \`import { a } from "b" with type: "json";\` +`); + } + const useAssertKeyword = importAttributesKeyword === "assert" || !importAttributesKeyword && assertions; + this.word(useAssertKeyword ? "assert" : "with"); + this.space(); + if (!useAssertKeyword && (importAttributesKeyword === "with-legacy" || !importAttributesKeyword && (_node$extra = node.extra) != null && _node$extra.deprecatedWithLegacySyntax)) { + this.printList(attributes || assertions); + return; + } + const occurrenceCount = hasPreviousBrace ? 1 : 0; + this.token("{", null, occurrenceCount); + this.space(); + this.printList(attributes || assertions, this.shouldPrintTrailingComma("}")); + this.space(); + this.token("}", null, occurrenceCount); +} +function ExportAllDeclaration(node) { + var _node$attributes, _node$assertions; + this.word("export"); + this.space(); + if (node.exportKind === "type") { + this.word("type"); + this.space(); + } + this.tokenChar(42); + this.space(); + this.word("from"); + this.space(); + if ((_node$attributes = node.attributes) != null && _node$attributes.length || (_node$assertions = node.assertions) != null && _node$assertions.length) { + this.print(node.source, true); + this.space(); + this._printAttributes(node, false); + } else { + this.print(node.source); + } + this.semicolon(); +} +function maybePrintDecoratorsBeforeExport(printer, node) { + if (isClassDeclaration(node.declaration) && printer._shouldPrintDecoratorsBeforeExport(node)) { + printer.printJoin(node.declaration.decorators); + } +} +function ExportNamedDeclaration(node) { + maybePrintDecoratorsBeforeExport(this, node); + this.word("export"); + this.space(); + if (node.declaration) { + const declar = node.declaration; + this.print(declar); + if (!isStatement(declar)) this.semicolon(); + } else { + if (node.exportKind === "type") { + this.word("type"); + this.space(); + } + const specifiers = node.specifiers.slice(0); + let hasSpecial = false; + for (;;) { + const first = specifiers[0]; + if (isExportDefaultSpecifier(first) || isExportNamespaceSpecifier(first)) { + hasSpecial = true; + this.print(specifiers.shift()); + if (specifiers.length) { + this.tokenChar(44); + this.space(); + } + } else { + break; + } + } + let hasBrace = false; + if (specifiers.length || !specifiers.length && !hasSpecial) { + hasBrace = true; + this.tokenChar(123); + if (specifiers.length) { + this.space(); + this.printList(specifiers, this.shouldPrintTrailingComma("}")); + this.space(); + } + this.tokenChar(125); + } + if (node.source) { + var _node$attributes2, _node$assertions2; + this.space(); + this.word("from"); + this.space(); + if ((_node$attributes2 = node.attributes) != null && _node$attributes2.length || (_node$assertions2 = node.assertions) != null && _node$assertions2.length) { + this.print(node.source, true); + this.space(); + this._printAttributes(node, hasBrace); + } else { + this.print(node.source); + } + } + this.semicolon(); + } +} +function ExportDefaultDeclaration(node) { + maybePrintDecoratorsBeforeExport(this, node); + this.word("export"); + this.noIndentInnerCommentsHere(); + this.space(); + this.word("default"); + this.space(); + this.tokenContext |= _index.TokenContext.exportDefault; + const declar = node.declaration; + this.print(declar); + if (!isStatement(declar)) this.semicolon(); +} +function ImportDeclaration(node) { + var _node$attributes3, _node$assertions3; + this.word("import"); + this.space(); + const isTypeKind = node.importKind === "type" || node.importKind === "typeof"; + if (isTypeKind) { + this.noIndentInnerCommentsHere(); + this.word(node.importKind); + this.space(); + } else if (node.module) { + this.noIndentInnerCommentsHere(); + this.word("module"); + this.space(); + } else if (node.phase) { + this.noIndentInnerCommentsHere(); + this.word(node.phase); + this.space(); + } + const specifiers = node.specifiers.slice(0); + const hasSpecifiers = !!specifiers.length; + while (hasSpecifiers) { + const first = specifiers[0]; + if (isImportDefaultSpecifier(first) || isImportNamespaceSpecifier(first)) { + this.print(specifiers.shift()); + if (specifiers.length) { + this.tokenChar(44); + this.space(); + } + } else { + break; + } + } + let hasBrace = false; + if (specifiers.length) { + hasBrace = true; + this.tokenChar(123); + this.space(); + this.printList(specifiers, this.shouldPrintTrailingComma("}")); + this.space(); + this.tokenChar(125); + } else if (isTypeKind && !hasSpecifiers) { + hasBrace = true; + this.tokenChar(123); + this.tokenChar(125); + } + if (hasSpecifiers || isTypeKind) { + this.space(); + this.word("from"); + this.space(); + } + if ((_node$attributes3 = node.attributes) != null && _node$attributes3.length || (_node$assertions3 = node.assertions) != null && _node$assertions3.length) { + this.print(node.source, true); + this.space(); + this._printAttributes(node, hasBrace); + } else { + this.print(node.source); + } + this.semicolon(); +} +function ImportAttribute(node) { + this.print(node.key); + this.tokenChar(58); + this.space(); + this.print(node.value); +} +function ImportNamespaceSpecifier(node) { + this.tokenChar(42); + this.space(); + this.word("as"); + this.space(); + this.print(node.local); +} +function ImportExpression(node) { + this.word("import"); + if (node.phase) { + this.tokenChar(46); + this.word(node.phase); + } + this.tokenChar(40); + const shouldPrintTrailingComma = this.shouldPrintTrailingComma(")"); + this.print(node.source); + if (node.options != null) { + this.tokenChar(44); + this.space(); + this.print(node.options); + } + if (shouldPrintTrailingComma) { + this.tokenChar(44); + } + this.rightParens(node); +} + +//# sourceMappingURL=modules.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/modules.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/modules.js.map new file mode 100644 index 0000000000000000000000000000000000000000..66a2d4def5f19d4c3aa4b70923273213c1a5f49a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/modules.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_t","require","_index","isClassDeclaration","isExportDefaultSpecifier","isExportNamespaceSpecifier","isImportDefaultSpecifier","isImportNamespaceSpecifier","isStatement","ImportSpecifier","node","importKind","word","space","print","imported","local","name","ImportDefaultSpecifier","ExportDefaultSpecifier","exported","ExportSpecifier","exportKind","ExportNamespaceSpecifier","token","warningShown","_printAttributes","hasPreviousBrace","_node$extra","importAttributesKeyword","format","attributes","assertions","extra","deprecatedAssertSyntax","deprecatedWithLegacySyntax","console","warn","useAssertKeyword","printList","occurrenceCount","shouldPrintTrailingComma","ExportAllDeclaration","_node$attributes","_node$assertions","length","source","semicolon","maybePrintDecoratorsBeforeExport","printer","declaration","_shouldPrintDecoratorsBeforeExport","printJoin","decorators","ExportNamedDeclaration","declar","specifiers","slice","hasSpecial","first","shift","hasBrace","_node$attributes2","_node$assertions2","ExportDefaultDeclaration","noIndentInnerCommentsHere","tokenContext","TokenContext","exportDefault","ImportDeclaration","_node$attributes3","_node$assertions3","isTypeKind","module","phase","hasSpecifiers","ImportAttribute","key","value","ImportNamespaceSpecifier","ImportExpression","options","rightParens"],"sources":["../../src/generators/modules.ts"],"sourcesContent":["import type Printer from \"../printer.ts\";\nimport {\n isClassDeclaration,\n isExportDefaultSpecifier,\n isExportNamespaceSpecifier,\n isImportDefaultSpecifier,\n isImportNamespaceSpecifier,\n isStatement,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\nimport { TokenContext } from \"../node/index.ts\";\n\nexport function ImportSpecifier(this: Printer, node: t.ImportSpecifier) {\n if (node.importKind === \"type\" || node.importKind === \"typeof\") {\n this.word(node.importKind);\n this.space();\n }\n\n this.print(node.imported);\n // @ts-expect-error todo(flow-ts) maybe check node type instead of relying on name to be undefined on t.StringLiteral\n if (node.local && node.local.name !== node.imported.name) {\n this.space();\n this.word(\"as\");\n this.space();\n this.print(node.local);\n }\n}\n\nexport function ImportDefaultSpecifier(\n this: Printer,\n node: t.ImportDefaultSpecifier,\n) {\n this.print(node.local);\n}\n\nexport function ExportDefaultSpecifier(\n this: Printer,\n node: t.ExportDefaultSpecifier,\n) {\n this.print(node.exported);\n}\n\nexport function ExportSpecifier(this: Printer, node: t.ExportSpecifier) {\n if (node.exportKind === \"type\") {\n this.word(\"type\");\n this.space();\n }\n\n this.print(node.local);\n // @ts-expect-error todo(flow-ts) maybe check node type instead of relying on name to be undefined on t.StringLiteral\n if (node.exported && node.local.name !== node.exported.name) {\n this.space();\n this.word(\"as\");\n this.space();\n this.print(node.exported);\n }\n}\n\nexport function ExportNamespaceSpecifier(\n this: Printer,\n node: t.ExportNamespaceSpecifier,\n) {\n this.token(\"*\");\n this.space();\n this.word(\"as\");\n this.space();\n this.print(node.exported);\n}\n\nlet warningShown = false;\n\nexport function _printAttributes(\n this: Printer,\n node: Extract,\n hasPreviousBrace: boolean,\n) {\n const { importAttributesKeyword } = this.format;\n const { attributes, assertions } = node;\n\n if (\n !process.env.BABEL_8_BREAKING &&\n attributes &&\n !importAttributesKeyword &&\n node.extra &&\n (node.extra.deprecatedAssertSyntax ||\n node.extra.deprecatedWithLegacySyntax) &&\n // In the production build only show the warning once.\n // We want to show it per-usage locally for tests.\n (!process.env.IS_PUBLISH || !warningShown)\n ) {\n warningShown = true;\n console.warn(`\\\nYou are using import attributes, without specifying the desired output syntax.\nPlease specify the \"importAttributesKeyword\" generator option, whose value can be one of:\n - \"with\" : \\`import { a } from \"b\" with { type: \"json\" };\\`\n - \"assert\" : \\`import { a } from \"b\" assert { type: \"json\" };\\`\n - \"with-legacy\" : \\`import { a } from \"b\" with type: \"json\";\\`\n`);\n }\n\n const useAssertKeyword =\n importAttributesKeyword === \"assert\" ||\n (!importAttributesKeyword && assertions);\n\n this.word(useAssertKeyword ? \"assert\" : \"with\");\n this.space();\n\n if (\n !process.env.BABEL_8_BREAKING &&\n !useAssertKeyword &&\n (importAttributesKeyword === \"with-legacy\" ||\n (!importAttributesKeyword && node.extra?.deprecatedWithLegacySyntax))\n ) {\n // with-legacy\n this.printList(attributes || assertions);\n return;\n }\n\n const occurrenceCount = hasPreviousBrace ? 1 : 0;\n\n this.token(\"{\", null, occurrenceCount);\n this.space();\n this.printList(attributes || assertions, this.shouldPrintTrailingComma(\"}\"));\n this.space();\n this.token(\"}\", null, occurrenceCount);\n}\n\nexport function ExportAllDeclaration(\n this: Printer,\n node: t.ExportAllDeclaration | t.DeclareExportAllDeclaration,\n) {\n this.word(\"export\");\n this.space();\n if (node.exportKind === \"type\") {\n this.word(\"type\");\n this.space();\n }\n this.token(\"*\");\n this.space();\n this.word(\"from\");\n this.space();\n if (node.attributes?.length || node.assertions?.length) {\n this.print(node.source, true);\n this.space();\n this._printAttributes(node, false);\n } else {\n this.print(node.source);\n }\n\n this.semicolon();\n}\n\nfunction maybePrintDecoratorsBeforeExport(\n printer: Printer,\n node: t.ExportNamedDeclaration | t.ExportDefaultDeclaration,\n) {\n if (\n isClassDeclaration(node.declaration) &&\n printer._shouldPrintDecoratorsBeforeExport(\n node as t.ExportNamedDeclaration & { declaration: t.ClassDeclaration },\n )\n ) {\n printer.printJoin(node.declaration.decorators);\n }\n}\n\nexport function ExportNamedDeclaration(\n this: Printer,\n node: t.ExportNamedDeclaration,\n) {\n maybePrintDecoratorsBeforeExport(this, node);\n\n this.word(\"export\");\n this.space();\n if (node.declaration) {\n const declar = node.declaration;\n this.print(declar);\n if (!isStatement(declar)) this.semicolon();\n } else {\n if (node.exportKind === \"type\") {\n this.word(\"type\");\n this.space();\n }\n\n const specifiers = node.specifiers.slice(0);\n\n // print \"special\" specifiers first\n let hasSpecial = false;\n for (;;) {\n const first = specifiers[0];\n if (\n isExportDefaultSpecifier(first) ||\n isExportNamespaceSpecifier(first)\n ) {\n hasSpecial = true;\n this.print(specifiers.shift());\n if (specifiers.length) {\n this.token(\",\");\n this.space();\n }\n } else {\n break;\n }\n }\n\n let hasBrace = false;\n if (specifiers.length || (!specifiers.length && !hasSpecial)) {\n hasBrace = true;\n this.token(\"{\");\n if (specifiers.length) {\n this.space();\n this.printList(specifiers, this.shouldPrintTrailingComma(\"}\"));\n this.space();\n }\n this.token(\"}\");\n }\n\n if (node.source) {\n this.space();\n this.word(\"from\");\n this.space();\n if (node.attributes?.length || node.assertions?.length) {\n this.print(node.source, true);\n this.space();\n this._printAttributes(node, hasBrace);\n } else {\n this.print(node.source);\n }\n }\n\n this.semicolon();\n }\n}\n\nexport function ExportDefaultDeclaration(\n this: Printer,\n node: t.ExportDefaultDeclaration,\n) {\n maybePrintDecoratorsBeforeExport(this, node);\n\n this.word(\"export\");\n this.noIndentInnerCommentsHere();\n this.space();\n this.word(\"default\");\n this.space();\n this.tokenContext |= TokenContext.exportDefault;\n const declar = node.declaration;\n this.print(declar);\n if (!isStatement(declar)) this.semicolon();\n}\n\nexport function ImportDeclaration(this: Printer, node: t.ImportDeclaration) {\n this.word(\"import\");\n this.space();\n\n const isTypeKind = node.importKind === \"type\" || node.importKind === \"typeof\";\n if (isTypeKind) {\n this.noIndentInnerCommentsHere();\n this.word(node.importKind);\n this.space();\n } else if (node.module) {\n this.noIndentInnerCommentsHere();\n this.word(\"module\");\n this.space();\n } else if (node.phase) {\n this.noIndentInnerCommentsHere();\n this.word(node.phase);\n this.space();\n }\n\n const specifiers = node.specifiers.slice(0);\n const hasSpecifiers = !!specifiers.length;\n // print \"special\" specifiers first. The loop condition is constant,\n // but there is a \"break\" in the body.\n while (hasSpecifiers) {\n const first = specifiers[0];\n if (isImportDefaultSpecifier(first) || isImportNamespaceSpecifier(first)) {\n this.print(specifiers.shift());\n if (specifiers.length) {\n this.token(\",\");\n this.space();\n }\n } else {\n break;\n }\n }\n\n let hasBrace = false;\n if (specifiers.length) {\n hasBrace = true;\n this.token(\"{\");\n this.space();\n this.printList(specifiers, this.shouldPrintTrailingComma(\"}\"));\n this.space();\n this.token(\"}\");\n } else if (isTypeKind && !hasSpecifiers) {\n hasBrace = true;\n this.token(\"{\");\n this.token(\"}\");\n }\n\n if (hasSpecifiers || isTypeKind) {\n this.space();\n this.word(\"from\");\n this.space();\n }\n\n if (node.attributes?.length || node.assertions?.length) {\n this.print(node.source, true);\n this.space();\n this._printAttributes(node, hasBrace);\n } else {\n this.print(node.source);\n }\n\n this.semicolon();\n}\n\nexport function ImportAttribute(this: Printer, node: t.ImportAttribute) {\n this.print(node.key);\n this.token(\":\");\n this.space();\n this.print(node.value);\n}\n\nexport function ImportNamespaceSpecifier(\n this: Printer,\n node: t.ImportNamespaceSpecifier,\n) {\n this.token(\"*\");\n this.space();\n this.word(\"as\");\n this.space();\n this.print(node.local);\n}\n\nexport function ImportExpression(this: Printer, node: t.ImportExpression) {\n this.word(\"import\");\n if (node.phase) {\n this.token(\".\");\n this.word(node.phase);\n }\n this.token(\"(\");\n const shouldPrintTrailingComma = this.shouldPrintTrailingComma(\")\");\n this.print(node.source);\n if (node.options != null) {\n this.token(\",\");\n this.space();\n this.print(node.options);\n }\n if (shouldPrintTrailingComma) {\n this.token(\",\");\n }\n this.rightParens(node);\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/statements.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/statements.js new file mode 100644 index 0000000000000000000000000000000000000000..b4c72581844f71bbe47d61c5e661719d7a66b3a7 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/statements.js @@ -0,0 +1,279 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.BreakStatement = BreakStatement; +exports.CatchClause = CatchClause; +exports.ContinueStatement = ContinueStatement; +exports.DebuggerStatement = DebuggerStatement; +exports.DoWhileStatement = DoWhileStatement; +exports.ForOfStatement = exports.ForInStatement = void 0; +exports.ForStatement = ForStatement; +exports.IfStatement = IfStatement; +exports.LabeledStatement = LabeledStatement; +exports.ReturnStatement = ReturnStatement; +exports.SwitchCase = SwitchCase; +exports.SwitchStatement = SwitchStatement; +exports.ThrowStatement = ThrowStatement; +exports.TryStatement = TryStatement; +exports.VariableDeclaration = VariableDeclaration; +exports.VariableDeclarator = VariableDeclarator; +exports.WhileStatement = WhileStatement; +exports.WithStatement = WithStatement; +var _t = require("@babel/types"); +const { + isFor, + isForStatement, + isIfStatement, + isStatement +} = _t; +function WithStatement(node) { + this.word("with"); + this.space(); + this.tokenChar(40); + this.print(node.object); + this.tokenChar(41); + this.printBlock(node); +} +function IfStatement(node) { + this.word("if"); + this.space(); + this.tokenChar(40); + this.print(node.test); + this.tokenChar(41); + this.space(); + const needsBlock = node.alternate && isIfStatement(getLastStatement(node.consequent)); + if (needsBlock) { + this.tokenChar(123); + this.newline(); + this.indent(); + } + this.printAndIndentOnComments(node.consequent); + if (needsBlock) { + this.dedent(); + this.newline(); + this.tokenChar(125); + } + if (node.alternate) { + if (this.endsWith(125)) this.space(); + this.word("else"); + this.space(); + this.printAndIndentOnComments(node.alternate); + } +} +function getLastStatement(statement) { + const { + body + } = statement; + if (isStatement(body) === false) { + return statement; + } + return getLastStatement(body); +} +function ForStatement(node) { + this.word("for"); + this.space(); + this.tokenChar(40); + { + const exit = this.enterForStatementInit(); + this.print(node.init); + exit(); + } + this.tokenChar(59); + if (node.test) { + this.space(); + this.print(node.test); + } + this.token(";", false, 1); + if (node.update) { + this.space(); + this.print(node.update); + } + this.tokenChar(41); + this.printBlock(node); +} +function WhileStatement(node) { + this.word("while"); + this.space(); + this.tokenChar(40); + this.print(node.test); + this.tokenChar(41); + this.printBlock(node); +} +function ForXStatement(node) { + this.word("for"); + this.space(); + const isForOf = node.type === "ForOfStatement"; + if (isForOf && node.await) { + this.word("await"); + this.space(); + } + this.noIndentInnerCommentsHere(); + this.tokenChar(40); + { + const exit = this.enterForXStatementInit(isForOf); + this.print(node.left); + exit == null || exit(); + } + this.space(); + this.word(isForOf ? "of" : "in"); + this.space(); + this.print(node.right); + this.tokenChar(41); + this.printBlock(node); +} +const ForInStatement = exports.ForInStatement = ForXStatement; +const ForOfStatement = exports.ForOfStatement = ForXStatement; +function DoWhileStatement(node) { + this.word("do"); + this.space(); + this.print(node.body); + this.space(); + this.word("while"); + this.space(); + this.tokenChar(40); + this.print(node.test); + this.tokenChar(41); + this.semicolon(); +} +function printStatementAfterKeyword(printer, node) { + if (node) { + printer.space(); + printer.printTerminatorless(node); + } + printer.semicolon(); +} +function BreakStatement(node) { + this.word("break"); + printStatementAfterKeyword(this, node.label); +} +function ContinueStatement(node) { + this.word("continue"); + printStatementAfterKeyword(this, node.label); +} +function ReturnStatement(node) { + this.word("return"); + printStatementAfterKeyword(this, node.argument); +} +function ThrowStatement(node) { + this.word("throw"); + printStatementAfterKeyword(this, node.argument); +} +function LabeledStatement(node) { + this.print(node.label); + this.tokenChar(58); + this.space(); + this.print(node.body); +} +function TryStatement(node) { + this.word("try"); + this.space(); + this.print(node.block); + this.space(); + if (node.handlers) { + this.print(node.handlers[0]); + } else { + this.print(node.handler); + } + if (node.finalizer) { + this.space(); + this.word("finally"); + this.space(); + this.print(node.finalizer); + } +} +function CatchClause(node) { + this.word("catch"); + this.space(); + if (node.param) { + this.tokenChar(40); + this.print(node.param); + this.print(node.param.typeAnnotation); + this.tokenChar(41); + this.space(); + } + this.print(node.body); +} +function SwitchStatement(node) { + this.word("switch"); + this.space(); + this.tokenChar(40); + this.print(node.discriminant); + this.tokenChar(41); + this.space(); + this.tokenChar(123); + this.printSequence(node.cases, true, undefined, function addNewlines(leading, cas) { + if (!leading && node.cases[node.cases.length - 1] === cas) return -1; + }); + this.rightBrace(node); +} +function SwitchCase(node) { + if (node.test) { + this.word("case"); + this.space(); + this.print(node.test); + this.tokenChar(58); + } else { + this.word("default"); + this.tokenChar(58); + } + if (node.consequent.length) { + this.newline(); + this.printSequence(node.consequent, true); + } +} +function DebuggerStatement() { + this.word("debugger"); + this.semicolon(); +} +function VariableDeclaration(node, parent) { + if (node.declare) { + this.word("declare"); + this.space(); + } + const { + kind + } = node; + if (kind === "await using") { + this.word("await"); + this.space(); + this.word("using", true); + } else { + this.word(kind, kind === "using"); + } + this.space(); + let hasInits = false; + if (!isFor(parent)) { + for (const declar of node.declarations) { + if (declar.init) { + hasInits = true; + } + } + } + this.printList(node.declarations, undefined, undefined, node.declarations.length > 1, hasInits ? function (occurrenceCount) { + this.token(",", false, occurrenceCount); + this.newline(); + } : undefined); + if (isFor(parent)) { + if (isForStatement(parent)) { + if (parent.init === node) return; + } else { + if (parent.left === node) return; + } + } + this.semicolon(); +} +function VariableDeclarator(node) { + this.print(node.id); + if (node.definite) this.tokenChar(33); + this.print(node.id.typeAnnotation); + if (node.init) { + this.space(); + this.tokenChar(61); + this.space(); + this.print(node.init); + } +} + +//# sourceMappingURL=statements.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/statements.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/statements.js.map new file mode 100644 index 0000000000000000000000000000000000000000..c977cc98fd62d84112722ce2bad22dab893aaaed --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/statements.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_t","require","isFor","isForStatement","isIfStatement","isStatement","WithStatement","node","word","space","token","print","object","printBlock","IfStatement","test","needsBlock","alternate","getLastStatement","consequent","newline","indent","printAndIndentOnComments","dedent","endsWith","statement","body","ForStatement","exit","enterForStatementInit","init","update","WhileStatement","ForXStatement","isForOf","type","await","noIndentInnerCommentsHere","enterForXStatementInit","left","right","ForInStatement","exports","ForOfStatement","DoWhileStatement","semicolon","printStatementAfterKeyword","printer","printTerminatorless","BreakStatement","label","ContinueStatement","ReturnStatement","argument","ThrowStatement","LabeledStatement","TryStatement","block","handlers","handler","finalizer","CatchClause","param","typeAnnotation","SwitchStatement","discriminant","printSequence","cases","undefined","addNewlines","leading","cas","length","rightBrace","SwitchCase","DebuggerStatement","VariableDeclaration","parent","declare","kind","hasInits","declar","declarations","printList","occurrenceCount","VariableDeclarator","id","definite"],"sources":["../../src/generators/statements.ts"],"sourcesContent":["import type Printer from \"../printer.ts\";\nimport {\n isFor,\n isForStatement,\n isIfStatement,\n isStatement,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\n\n// We inline this package\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport * as charCodes from \"charcodes\";\n\nexport function WithStatement(this: Printer, node: t.WithStatement) {\n this.word(\"with\");\n this.space();\n this.token(\"(\");\n this.print(node.object);\n this.token(\")\");\n this.printBlock(node);\n}\n\nexport function IfStatement(this: Printer, node: t.IfStatement) {\n this.word(\"if\");\n this.space();\n this.token(\"(\");\n this.print(node.test);\n this.token(\")\");\n this.space();\n\n const needsBlock =\n node.alternate && isIfStatement(getLastStatement(node.consequent));\n if (needsBlock) {\n this.token(\"{\");\n this.newline();\n this.indent();\n }\n\n this.printAndIndentOnComments(node.consequent);\n\n if (needsBlock) {\n this.dedent();\n this.newline();\n this.token(\"}\");\n }\n\n if (node.alternate) {\n if (this.endsWith(charCodes.rightCurlyBrace)) this.space();\n this.word(\"else\");\n this.space();\n this.printAndIndentOnComments(node.alternate);\n }\n}\n\n// Recursively get the last statement.\nfunction getLastStatement(statement: t.Statement): t.Statement {\n // @ts-expect-error: If statement.body is empty or not a Node, isStatement will return false\n const { body } = statement;\n if (isStatement(body) === false) {\n return statement;\n }\n\n return getLastStatement(body);\n}\n\nexport function ForStatement(this: Printer, node: t.ForStatement) {\n this.word(\"for\");\n this.space();\n this.token(\"(\");\n\n {\n const exit = this.enterForStatementInit();\n this.print(node.init);\n exit();\n }\n\n this.token(\";\");\n\n if (node.test) {\n this.space();\n this.print(node.test);\n }\n this.token(\";\", false, 1);\n\n if (node.update) {\n this.space();\n this.print(node.update);\n }\n\n this.token(\")\");\n this.printBlock(node);\n}\n\nexport function WhileStatement(this: Printer, node: t.WhileStatement) {\n this.word(\"while\");\n this.space();\n this.token(\"(\");\n this.print(node.test);\n this.token(\")\");\n this.printBlock(node);\n}\n\nfunction ForXStatement(this: Printer, node: t.ForXStatement) {\n this.word(\"for\");\n this.space();\n const isForOf = node.type === \"ForOfStatement\";\n if (isForOf && node.await) {\n this.word(\"await\");\n this.space();\n }\n this.noIndentInnerCommentsHere();\n this.token(\"(\");\n {\n const exit = this.enterForXStatementInit(isForOf);\n this.print(node.left);\n exit?.();\n }\n this.space();\n this.word(isForOf ? \"of\" : \"in\");\n this.space();\n this.print(node.right);\n this.token(\")\");\n this.printBlock(node);\n}\n\nexport const ForInStatement = ForXStatement;\nexport const ForOfStatement = ForXStatement;\n\nexport function DoWhileStatement(this: Printer, node: t.DoWhileStatement) {\n this.word(\"do\");\n this.space();\n this.print(node.body);\n this.space();\n this.word(\"while\");\n this.space();\n this.token(\"(\");\n this.print(node.test);\n this.token(\")\");\n this.semicolon();\n}\n\nfunction printStatementAfterKeyword(printer: Printer, node: t.Node) {\n if (node) {\n printer.space();\n printer.printTerminatorless(node);\n }\n\n printer.semicolon();\n}\n\nexport function BreakStatement(this: Printer, node: t.ContinueStatement) {\n this.word(\"break\");\n printStatementAfterKeyword(this, node.label);\n}\n\nexport function ContinueStatement(this: Printer, node: t.ContinueStatement) {\n this.word(\"continue\");\n printStatementAfterKeyword(this, node.label);\n}\n\nexport function ReturnStatement(this: Printer, node: t.ReturnStatement) {\n this.word(\"return\");\n printStatementAfterKeyword(this, node.argument);\n}\n\nexport function ThrowStatement(this: Printer, node: t.ThrowStatement) {\n this.word(\"throw\");\n printStatementAfterKeyword(this, node.argument);\n}\n\nexport function LabeledStatement(this: Printer, node: t.LabeledStatement) {\n this.print(node.label);\n this.token(\":\");\n this.space();\n this.print(node.body);\n}\n\nexport function TryStatement(this: Printer, node: t.TryStatement) {\n this.word(\"try\");\n this.space();\n this.print(node.block);\n this.space();\n\n // Esprima bug puts the catch clause in a `handlers` array.\n // see https://code.google.com/p/esprima/issues/detail?id=433\n // We run into this from regenerator generated ast.\n // @ts-expect-error todo(flow->ts) should ast node type be updated to support this?\n if (node.handlers) {\n // @ts-expect-error todo(flow->ts) should ast node type be updated to support this?\n this.print(node.handlers[0]);\n } else {\n this.print(node.handler);\n }\n\n if (node.finalizer) {\n this.space();\n this.word(\"finally\");\n this.space();\n this.print(node.finalizer);\n }\n}\n\nexport function CatchClause(this: Printer, node: t.CatchClause) {\n this.word(\"catch\");\n this.space();\n if (node.param) {\n this.token(\"(\");\n this.print(node.param);\n this.print(node.param.typeAnnotation);\n this.token(\")\");\n this.space();\n }\n this.print(node.body);\n}\n\nexport function SwitchStatement(this: Printer, node: t.SwitchStatement) {\n this.word(\"switch\");\n this.space();\n this.token(\"(\");\n this.print(node.discriminant);\n this.token(\")\");\n this.space();\n this.token(\"{\");\n\n this.printSequence(\n node.cases,\n true,\n undefined,\n function addNewlines(leading, cas) {\n if (!leading && node.cases[node.cases.length - 1] === cas) return -1;\n },\n );\n\n this.rightBrace(node);\n}\n\nexport function SwitchCase(this: Printer, node: t.SwitchCase) {\n if (node.test) {\n this.word(\"case\");\n this.space();\n this.print(node.test);\n this.token(\":\");\n } else {\n this.word(\"default\");\n this.token(\":\");\n }\n\n if (node.consequent.length) {\n this.newline();\n this.printSequence(node.consequent, true);\n }\n}\n\nexport function DebuggerStatement(this: Printer) {\n this.word(\"debugger\");\n this.semicolon();\n}\n\nexport function VariableDeclaration(\n this: Printer,\n node: t.VariableDeclaration,\n parent: t.Node,\n) {\n if (node.declare) {\n // TS\n this.word(\"declare\");\n this.space();\n }\n\n const { kind } = node;\n if (kind === \"await using\") {\n this.word(\"await\");\n this.space();\n this.word(\"using\", true);\n } else {\n this.word(kind, kind === \"using\");\n }\n this.space();\n\n let hasInits = false;\n // don't add whitespace to loop heads\n if (!isFor(parent)) {\n for (const declar of node.declarations) {\n if (declar.init) {\n // has an init so let's split it up over multiple lines\n hasInits = true;\n }\n }\n }\n\n //\n // use a pretty separator when we aren't in compact mode, have initializers and don't have retainLines on\n // this will format declarations like:\n //\n // let foo = \"bar\", bar = \"foo\";\n //\n // into\n //\n // let foo = \"bar\",\n // bar = \"foo\";\n //\n\n this.printList(\n node.declarations,\n undefined,\n undefined,\n node.declarations.length > 1,\n hasInits\n ? function (this: Printer, occurrenceCount: number) {\n this.token(\",\", false, occurrenceCount);\n this.newline();\n }\n : undefined,\n );\n\n if (isFor(parent)) {\n // don't give semicolons to these nodes since they'll be inserted in the parent generator\n if (isForStatement(parent)) {\n if (parent.init === node) return;\n } else {\n if (parent.left === node) return;\n }\n }\n\n this.semicolon();\n}\n\nexport function VariableDeclarator(this: Printer, node: t.VariableDeclarator) {\n this.print(node.id);\n if (node.definite) this.token(\"!\"); // TS\n // @ts-ignore(Babel 7 vs Babel 8) Property 'typeAnnotation' does not exist on type 'MemberExpression'.\n this.print(node.id.typeAnnotation);\n if (node.init) {\n this.space();\n this.token(\"=\");\n this.space();\n this.print(node.init);\n }\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/template-literals.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/template-literals.js new file mode 100644 index 0000000000000000000000000000000000000000..0e4b6a91a804a3dd5189934054c3c900d3fc4f08 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/template-literals.js @@ -0,0 +1,40 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.TaggedTemplateExpression = TaggedTemplateExpression; +exports.TemplateElement = TemplateElement; +exports.TemplateLiteral = TemplateLiteral; +exports._printTemplate = _printTemplate; +function TaggedTemplateExpression(node) { + this.print(node.tag); + { + this.print(node.typeParameters); + } + this.print(node.quasi); +} +function TemplateElement() { + throw new Error("TemplateElement printing is handled in TemplateLiteral"); +} +function _printTemplate(node, substitutions) { + const quasis = node.quasis; + let partRaw = "`"; + for (let i = 0; i < quasis.length - 1; i++) { + partRaw += quasis[i].value.raw; + this.token(partRaw + "${", true); + this.print(substitutions[i]); + partRaw = "}"; + if (this.tokenMap) { + const token = this.tokenMap.findMatching(node, "}", i); + if (token) this._catchUpTo(token.loc.start); + } + } + partRaw += quasis[quasis.length - 1].value.raw; + this.token(partRaw + "`", true); +} +function TemplateLiteral(node) { + this._printTemplate(node, node.expressions); +} + +//# sourceMappingURL=template-literals.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/template-literals.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/template-literals.js.map new file mode 100644 index 0000000000000000000000000000000000000000..26bd4e943ef0d72af3638be6d30e89d9e8728243 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/template-literals.js.map @@ -0,0 +1 @@ +{"version":3,"names":["TaggedTemplateExpression","node","print","tag","typeParameters","quasi","TemplateElement","Error","_printTemplate","substitutions","quasis","partRaw","i","length","value","raw","token","tokenMap","findMatching","_catchUpTo","loc","start","TemplateLiteral","expressions"],"sources":["../../src/generators/template-literals.ts"],"sourcesContent":["import type Printer from \"../printer.ts\";\nimport type * as t from \"@babel/types\";\n\nexport function TaggedTemplateExpression(\n this: Printer,\n node: t.TaggedTemplateExpression,\n) {\n this.print(node.tag);\n if (process.env.BABEL_8_BREAKING) {\n // @ts-ignore(Babel 7 vs Babel 8) Babel 8 AST\n this.print(node.typeArguments);\n } else {\n // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST\n this.print(node.typeParameters);\n }\n this.print(node.quasi);\n}\n\nexport function TemplateElement(this: Printer) {\n throw new Error(\"TemplateElement printing is handled in TemplateLiteral\");\n}\n\nexport type TemplateLiteralBase = t.Node & {\n quasis: t.TemplateElement[];\n};\n\nexport function _printTemplate(\n this: Printer,\n node: TemplateLiteralBase,\n substitutions: T[],\n) {\n const quasis = node.quasis;\n let partRaw = \"`\";\n for (let i = 0; i < quasis.length - 1; i++) {\n partRaw += quasis[i].value.raw;\n this.token(partRaw + \"${\", true);\n this.print(substitutions[i]);\n partRaw = \"}\";\n\n // In Babel 7 we have individual tokens for ${ and }, so the automatic\n // catchup logic does not work. Manually look for those tokens.\n if (!process.env.BABEL_8_BREAKING && this.tokenMap) {\n const token = this.tokenMap.findMatching(node, \"}\", i);\n if (token) this._catchUpTo(token.loc.start);\n }\n }\n partRaw += quasis[quasis.length - 1].value.raw;\n this.token(partRaw + \"`\", true);\n}\n\nexport function TemplateLiteral(this: Printer, node: t.TemplateLiteral) {\n this._printTemplate(node, node.expressions);\n}\n"],"mappings":";;;;;;;;;AAGO,SAASA,wBAAwBA,CAEtCC,IAAgC,EAChC;EACA,IAAI,CAACC,KAAK,CAACD,IAAI,CAACE,GAAG,CAAC;EAIb;IAEL,IAAI,CAACD,KAAK,CAACD,IAAI,CAACG,cAAc,CAAC;EACjC;EACA,IAAI,CAACF,KAAK,CAACD,IAAI,CAACI,KAAK,CAAC;AACxB;AAEO,SAASC,eAAeA,CAAA,EAAgB;EAC7C,MAAM,IAAIC,KAAK,CAAC,wDAAwD,CAAC;AAC3E;AAMO,SAASC,cAAcA,CAE5BP,IAAyB,EACzBQ,aAAkB,EAClB;EACA,MAAMC,MAAM,GAAGT,IAAI,CAACS,MAAM;EAC1B,IAAIC,OAAO,GAAG,GAAG;EACjB,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,MAAM,CAACG,MAAM,GAAG,CAAC,EAAED,CAAC,EAAE,EAAE;IAC1CD,OAAO,IAAID,MAAM,CAACE,CAAC,CAAC,CAACE,KAAK,CAACC,GAAG;IAC9B,IAAI,CAACC,KAAK,CAACL,OAAO,GAAG,IAAI,EAAE,IAAI,CAAC;IAChC,IAAI,CAACT,KAAK,CAACO,aAAa,CAACG,CAAC,CAAC,CAAC;IAC5BD,OAAO,GAAG,GAAG;IAIb,IAAqC,IAAI,CAACM,QAAQ,EAAE;MAClD,MAAMD,KAAK,GAAG,IAAI,CAACC,QAAQ,CAACC,YAAY,CAACjB,IAAI,EAAE,GAAG,EAAEW,CAAC,CAAC;MACtD,IAAII,KAAK,EAAE,IAAI,CAACG,UAAU,CAACH,KAAK,CAACI,GAAG,CAACC,KAAK,CAAC;IAC7C;EACF;EACAV,OAAO,IAAID,MAAM,CAACA,MAAM,CAACG,MAAM,GAAG,CAAC,CAAC,CAACC,KAAK,CAACC,GAAG;EAC9C,IAAI,CAACC,KAAK,CAACL,OAAO,GAAG,GAAG,EAAE,IAAI,CAAC;AACjC;AAEO,SAASW,eAAeA,CAAgBrB,IAAuB,EAAE;EACtE,IAAI,CAACO,cAAc,CAACP,IAAI,EAAEA,IAAI,CAACsB,WAAW,CAAC;AAC7C","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/types.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/types.js new file mode 100644 index 0000000000000000000000000000000000000000..7b93067e045fd3ba87bbedb0f8de775ef83ebaea --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/types.js @@ -0,0 +1,238 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.ArgumentPlaceholder = ArgumentPlaceholder; +exports.ArrayPattern = exports.ArrayExpression = ArrayExpression; +exports.BigIntLiteral = BigIntLiteral; +exports.BooleanLiteral = BooleanLiteral; +exports.Identifier = Identifier; +exports.NullLiteral = NullLiteral; +exports.NumericLiteral = NumericLiteral; +exports.ObjectPattern = exports.ObjectExpression = ObjectExpression; +exports.ObjectMethod = ObjectMethod; +exports.ObjectProperty = ObjectProperty; +exports.PipelineBareFunction = PipelineBareFunction; +exports.PipelinePrimaryTopicReference = PipelinePrimaryTopicReference; +exports.PipelineTopicExpression = PipelineTopicExpression; +exports.RecordExpression = RecordExpression; +exports.RegExpLiteral = RegExpLiteral; +exports.SpreadElement = exports.RestElement = RestElement; +exports.StringLiteral = StringLiteral; +exports.TopicReference = TopicReference; +exports.TupleExpression = TupleExpression; +exports.VoidPattern = VoidPattern; +exports._getRawIdentifier = _getRawIdentifier; +var _t = require("@babel/types"); +var _jsesc = require("jsesc"); +const { + isAssignmentPattern, + isIdentifier +} = _t; +let lastRawIdentNode = null; +let lastRawIdentResult = ""; +function _getRawIdentifier(node) { + if (node === lastRawIdentNode) return lastRawIdentResult; + lastRawIdentNode = node; + const { + name + } = node; + const token = this.tokenMap.find(node, tok => tok.value === name); + if (token) { + lastRawIdentResult = this._originalCode.slice(token.start, token.end); + return lastRawIdentResult; + } + return lastRawIdentResult = node.name; +} +function Identifier(node) { + var _node$loc; + this.sourceIdentifierName(((_node$loc = node.loc) == null ? void 0 : _node$loc.identifierName) || node.name); + this.word(this.tokenMap ? this._getRawIdentifier(node) : node.name); +} +function ArgumentPlaceholder() { + this.tokenChar(63); +} +function RestElement(node) { + this.token("..."); + this.print(node.argument); +} +function ObjectExpression(node) { + const props = node.properties; + this.tokenChar(123); + if (props.length) { + const exit = this.enterDelimited(); + this.space(); + this.printList(props, this.shouldPrintTrailingComma("}"), true, true); + this.space(); + exit(); + } + this.sourceWithOffset("end", node.loc, -1); + this.tokenChar(125); +} +function ObjectMethod(node) { + this.printJoin(node.decorators); + this._methodHead(node); + this.space(); + this.print(node.body); +} +function ObjectProperty(node) { + this.printJoin(node.decorators); + if (node.computed) { + this.tokenChar(91); + this.print(node.key); + this.tokenChar(93); + } else { + if (isAssignmentPattern(node.value) && isIdentifier(node.key) && node.key.name === node.value.left.name) { + this.print(node.value); + return; + } + this.print(node.key); + if (node.shorthand && isIdentifier(node.key) && isIdentifier(node.value) && node.key.name === node.value.name) { + return; + } + } + this.tokenChar(58); + this.space(); + this.print(node.value); +} +function ArrayExpression(node) { + const elems = node.elements; + const len = elems.length; + this.tokenChar(91); + const exit = this.enterDelimited(); + for (let i = 0; i < elems.length; i++) { + const elem = elems[i]; + if (elem) { + if (i > 0) this.space(); + this.print(elem); + if (i < len - 1 || this.shouldPrintTrailingComma("]")) { + this.token(",", false, i); + } + } else { + this.token(",", false, i); + } + } + exit(); + this.tokenChar(93); +} +function RecordExpression(node) { + const props = node.properties; + let startToken; + let endToken; + { + if (this.format.recordAndTupleSyntaxType === "bar") { + startToken = "{|"; + endToken = "|}"; + } else if (this.format.recordAndTupleSyntaxType !== "hash" && this.format.recordAndTupleSyntaxType != null) { + throw new Error(`The "recordAndTupleSyntaxType" generator option must be "bar" or "hash" (${JSON.stringify(this.format.recordAndTupleSyntaxType)} received).`); + } else { + startToken = "#{"; + endToken = "}"; + } + } + this.token(startToken); + if (props.length) { + this.space(); + this.printList(props, this.shouldPrintTrailingComma(endToken), true, true); + this.space(); + } + this.token(endToken); +} +function TupleExpression(node) { + const elems = node.elements; + const len = elems.length; + let startToken; + let endToken; + { + if (this.format.recordAndTupleSyntaxType === "bar") { + startToken = "[|"; + endToken = "|]"; + } else if (this.format.recordAndTupleSyntaxType === "hash") { + startToken = "#["; + endToken = "]"; + } else { + throw new Error(`${this.format.recordAndTupleSyntaxType} is not a valid recordAndTuple syntax type`); + } + } + this.token(startToken); + for (let i = 0; i < elems.length; i++) { + const elem = elems[i]; + if (elem) { + if (i > 0) this.space(); + this.print(elem); + if (i < len - 1 || this.shouldPrintTrailingComma(endToken)) { + this.token(",", false, i); + } + } + } + this.token(endToken); +} +function RegExpLiteral(node) { + this.word(`/${node.pattern}/${node.flags}`); +} +function BooleanLiteral(node) { + this.word(node.value ? "true" : "false"); +} +function NullLiteral() { + this.word("null"); +} +function NumericLiteral(node) { + const raw = this.getPossibleRaw(node); + const opts = this.format.jsescOption; + const value = node.value; + const str = value + ""; + if (opts.numbers) { + this.number(_jsesc(value, opts), value); + } else if (raw == null) { + this.number(str, value); + } else if (this.format.minified) { + this.number(raw.length < str.length ? raw : str, value); + } else { + this.number(raw, value); + } +} +function StringLiteral(node) { + const raw = this.getPossibleRaw(node); + if (!this.format.minified && raw !== undefined) { + this.token(raw); + return; + } + const val = _jsesc(node.value, this.format.jsescOption); + this.token(val); +} +function BigIntLiteral(node) { + const raw = this.getPossibleRaw(node); + if (!this.format.minified && raw !== undefined) { + this.word(raw); + return; + } + this.word(node.value + "n"); +} +const validTopicTokenSet = new Set(["^^", "@@", "^", "%", "#"]); +function TopicReference() { + const { + topicToken + } = this.format; + if (validTopicTokenSet.has(topicToken)) { + this.token(topicToken); + } else { + const givenTopicTokenJSON = JSON.stringify(topicToken); + const validTopics = Array.from(validTopicTokenSet, v => JSON.stringify(v)); + throw new Error(`The "topicToken" generator option must be one of ` + `${validTopics.join(", ")} (${givenTopicTokenJSON} received instead).`); + } +} +function PipelineTopicExpression(node) { + this.print(node.expression); +} +function PipelineBareFunction(node) { + this.print(node.callee); +} +function PipelinePrimaryTopicReference() { + this.tokenChar(35); +} +function VoidPattern() { + this.word("void"); +} + +//# sourceMappingURL=types.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/types.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/types.js.map new file mode 100644 index 0000000000000000000000000000000000000000..4dce1203580491c54442a3d3d515f38a742957e4 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/types.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_t","require","_jsesc","isAssignmentPattern","isIdentifier","lastRawIdentNode","lastRawIdentResult","_getRawIdentifier","node","name","token","tokenMap","find","tok","value","_originalCode","slice","start","end","Identifier","_node$loc","sourceIdentifierName","loc","identifierName","word","ArgumentPlaceholder","RestElement","print","argument","ObjectExpression","props","properties","length","exit","enterDelimited","space","printList","shouldPrintTrailingComma","sourceWithOffset","ObjectMethod","printJoin","decorators","_methodHead","body","ObjectProperty","computed","key","left","shorthand","ArrayExpression","elems","elements","len","i","elem","RecordExpression","startToken","endToken","format","recordAndTupleSyntaxType","Error","JSON","stringify","TupleExpression","RegExpLiteral","pattern","flags","BooleanLiteral","NullLiteral","NumericLiteral","raw","getPossibleRaw","opts","jsescOption","str","numbers","number","jsesc","minified","StringLiteral","undefined","val","BigIntLiteral","validTopicTokenSet","Set","TopicReference","topicToken","has","givenTopicTokenJSON","validTopics","Array","from","v","join","PipelineTopicExpression","expression","PipelineBareFunction","callee","PipelinePrimaryTopicReference","VoidPattern"],"sources":["../../src/generators/types.ts"],"sourcesContent":["import type Printer from \"../printer.ts\";\nimport { isAssignmentPattern, isIdentifier } from \"@babel/types\";\nimport type * as t from \"@babel/types\";\nimport jsesc from \"jsesc\";\n\nlet lastRawIdentNode: t.Identifier | null = null;\nlet lastRawIdentResult: string = \"\";\nexport function _getRawIdentifier(this: Printer, node: t.Identifier) {\n if (node === lastRawIdentNode) return lastRawIdentResult;\n lastRawIdentNode = node;\n\n const { name } = node;\n const token = this.tokenMap.find(node, tok => tok.value === name);\n if (token) {\n lastRawIdentResult = this._originalCode.slice(token.start, token.end);\n return lastRawIdentResult;\n }\n return (lastRawIdentResult = node.name);\n}\n\nexport function Identifier(this: Printer, node: t.Identifier) {\n this.sourceIdentifierName(node.loc?.identifierName || node.name);\n\n this.word(this.tokenMap ? this._getRawIdentifier(node) : node.name);\n}\n\nexport function ArgumentPlaceholder(this: Printer) {\n this.token(\"?\");\n}\n\nexport function RestElement(this: Printer, node: t.RestElement) {\n this.token(\"...\");\n this.print(node.argument);\n}\n\nexport { RestElement as SpreadElement };\n\nexport function ObjectExpression(this: Printer, node: t.ObjectExpression) {\n const props = node.properties;\n\n this.token(\"{\");\n\n if (props.length) {\n const exit = this.enterDelimited();\n this.space();\n this.printList(props, this.shouldPrintTrailingComma(\"}\"), true, true);\n this.space();\n exit();\n }\n\n this.sourceWithOffset(\"end\", node.loc, -1);\n\n this.token(\"}\");\n}\n\nexport { ObjectExpression as ObjectPattern };\n\nexport function ObjectMethod(this: Printer, node: t.ObjectMethod) {\n this.printJoin(node.decorators);\n this._methodHead(node);\n this.space();\n this.print(node.body);\n}\n\nexport function ObjectProperty(this: Printer, node: t.ObjectProperty) {\n this.printJoin(node.decorators);\n\n if (node.computed) {\n this.token(\"[\");\n this.print(node.key);\n this.token(\"]\");\n } else {\n // print `({ foo: foo = 5 } = {})` as `({ foo = 5 } = {});`\n if (\n isAssignmentPattern(node.value) &&\n isIdentifier(node.key) &&\n // @ts-expect-error todo(flow->ts) `.name` does not exist on some types in union\n node.key.name === node.value.left.name\n ) {\n this.print(node.value);\n return;\n }\n\n this.print(node.key);\n\n // shorthand!\n if (\n node.shorthand &&\n isIdentifier(node.key) &&\n isIdentifier(node.value) &&\n node.key.name === node.value.name\n ) {\n return;\n }\n }\n\n this.token(\":\");\n this.space();\n this.print(node.value);\n}\n\nexport function ArrayExpression(this: Printer, node: t.ArrayExpression) {\n const elems = node.elements;\n const len = elems.length;\n\n this.token(\"[\");\n\n const exit = this.enterDelimited();\n\n for (let i = 0; i < elems.length; i++) {\n const elem = elems[i];\n if (elem) {\n if (i > 0) this.space();\n this.print(elem);\n if (i < len - 1 || this.shouldPrintTrailingComma(\"]\")) {\n this.token(\",\", false, i);\n }\n } else {\n // If the array expression ends with a hole, that hole\n // will be ignored by the interpreter, but if it ends with\n // two (or more) holes, we need to write out two (or more)\n // commas so that the resulting code is interpreted with\n // both (all) of the holes.\n this.token(\",\", false, i);\n }\n }\n\n exit();\n\n this.token(\"]\");\n}\n\nexport { ArrayExpression as ArrayPattern };\n\nexport function RecordExpression(this: Printer, node: t.RecordExpression) {\n const props = node.properties;\n\n let startToken;\n let endToken;\n if (process.env.BABEL_8_BREAKING) {\n startToken = \"#{\";\n endToken = \"}\";\n } else {\n if (this.format.recordAndTupleSyntaxType === \"bar\") {\n startToken = \"{|\";\n endToken = \"|}\";\n } else if (\n this.format.recordAndTupleSyntaxType !== \"hash\" &&\n this.format.recordAndTupleSyntaxType != null\n ) {\n throw new Error(\n `The \"recordAndTupleSyntaxType\" generator option must be \"bar\" or \"hash\" (${JSON.stringify(\n this.format.recordAndTupleSyntaxType,\n )} received).`,\n );\n } else {\n startToken = \"#{\";\n endToken = \"}\";\n }\n }\n\n this.token(startToken);\n\n if (props.length) {\n this.space();\n this.printList(props, this.shouldPrintTrailingComma(endToken), true, true);\n this.space();\n }\n this.token(endToken);\n}\n\nexport function TupleExpression(this: Printer, node: t.TupleExpression) {\n const elems = node.elements;\n const len = elems.length;\n\n let startToken;\n let endToken;\n if (process.env.BABEL_8_BREAKING) {\n startToken = \"#[\";\n endToken = \"]\";\n } else {\n if (this.format.recordAndTupleSyntaxType === \"bar\") {\n startToken = \"[|\";\n endToken = \"|]\";\n } else if (this.format.recordAndTupleSyntaxType === \"hash\") {\n startToken = \"#[\";\n endToken = \"]\";\n } else {\n throw new Error(\n `${this.format.recordAndTupleSyntaxType} is not a valid recordAndTuple syntax type`,\n );\n }\n }\n\n this.token(startToken);\n\n for (let i = 0; i < elems.length; i++) {\n const elem = elems[i];\n if (elem) {\n if (i > 0) this.space();\n this.print(elem);\n if (i < len - 1 || this.shouldPrintTrailingComma(endToken)) {\n this.token(\",\", false, i);\n }\n }\n }\n\n this.token(endToken);\n}\n\nexport function RegExpLiteral(this: Printer, node: t.RegExpLiteral) {\n this.word(`/${node.pattern}/${node.flags}`);\n}\n\nexport function BooleanLiteral(this: Printer, node: t.BooleanLiteral) {\n this.word(node.value ? \"true\" : \"false\");\n}\n\nexport function NullLiteral(this: Printer) {\n this.word(\"null\");\n}\n\nexport function NumericLiteral(this: Printer, node: t.NumericLiteral) {\n const raw = this.getPossibleRaw(node);\n const opts = this.format.jsescOption;\n const value = node.value;\n const str = value + \"\";\n if (opts.numbers) {\n this.number(jsesc(value, opts), value);\n } else if (raw == null) {\n this.number(str, value); // normalize\n } else if (this.format.minified) {\n this.number(raw.length < str.length ? raw : str, value);\n } else {\n this.number(raw, value);\n }\n}\n\nexport function StringLiteral(this: Printer, node: t.StringLiteral) {\n const raw = this.getPossibleRaw(node);\n if (!this.format.minified && raw !== undefined) {\n this.token(raw);\n return;\n }\n\n const val = jsesc(node.value, this.format.jsescOption);\n\n this.token(val);\n}\n\nexport function BigIntLiteral(this: Printer, node: t.BigIntLiteral) {\n const raw = this.getPossibleRaw(node);\n if (!this.format.minified && raw !== undefined) {\n this.word(raw);\n return;\n }\n this.word(node.value + \"n\");\n}\n\n// Hack pipe operator\nconst validTopicTokenSet = new Set([\"^^\", \"@@\", \"^\", \"%\", \"#\"]);\nexport function TopicReference(this: Printer) {\n const { topicToken } = this.format;\n\n if (validTopicTokenSet.has(topicToken)) {\n this.token(topicToken);\n } else {\n const givenTopicTokenJSON = JSON.stringify(topicToken);\n const validTopics = Array.from(validTopicTokenSet, v => JSON.stringify(v));\n throw new Error(\n `The \"topicToken\" generator option must be one of ` +\n `${validTopics.join(\", \")} (${givenTopicTokenJSON} received instead).`,\n );\n }\n}\n\n// Smart-mix pipe operator\nexport function PipelineTopicExpression(\n this: Printer,\n node: t.PipelineTopicExpression,\n) {\n this.print(node.expression);\n}\n\nexport function PipelineBareFunction(\n this: Printer,\n node: t.PipelineBareFunction,\n) {\n this.print(node.callee);\n}\n\nexport function PipelinePrimaryTopicReference(this: Printer) {\n this.token(\"#\");\n}\n\n// discard binding\nexport function VoidPattern(this: Printer) {\n this.word(\"void\");\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/typescript.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/typescript.js new file mode 100644 index 0000000000000000000000000000000000000000..6ebc10782d4f8e33ad4c3e9fd683b41731b34664 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/typescript.js @@ -0,0 +1,724 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.TSAnyKeyword = TSAnyKeyword; +exports.TSArrayType = TSArrayType; +exports.TSSatisfiesExpression = exports.TSAsExpression = TSTypeExpression; +exports.TSBigIntKeyword = TSBigIntKeyword; +exports.TSBooleanKeyword = TSBooleanKeyword; +exports.TSCallSignatureDeclaration = TSCallSignatureDeclaration; +exports.TSInterfaceHeritage = exports.TSClassImplements = TSClassImplements; +exports.TSConditionalType = TSConditionalType; +exports.TSConstructSignatureDeclaration = TSConstructSignatureDeclaration; +exports.TSConstructorType = TSConstructorType; +exports.TSDeclareFunction = TSDeclareFunction; +exports.TSDeclareMethod = TSDeclareMethod; +exports.TSEnumBody = TSEnumBody; +exports.TSEnumDeclaration = TSEnumDeclaration; +exports.TSEnumMember = TSEnumMember; +exports.TSExportAssignment = TSExportAssignment; +exports.TSExternalModuleReference = TSExternalModuleReference; +exports.TSFunctionType = TSFunctionType; +exports.TSImportEqualsDeclaration = TSImportEqualsDeclaration; +exports.TSImportType = TSImportType; +exports.TSIndexSignature = TSIndexSignature; +exports.TSIndexedAccessType = TSIndexedAccessType; +exports.TSInferType = TSInferType; +exports.TSInstantiationExpression = TSInstantiationExpression; +exports.TSInterfaceBody = TSInterfaceBody; +exports.TSInterfaceDeclaration = TSInterfaceDeclaration; +exports.TSIntersectionType = TSIntersectionType; +exports.TSIntrinsicKeyword = TSIntrinsicKeyword; +exports.TSLiteralType = TSLiteralType; +exports.TSMappedType = TSMappedType; +exports.TSMethodSignature = TSMethodSignature; +exports.TSModuleBlock = TSModuleBlock; +exports.TSModuleDeclaration = TSModuleDeclaration; +exports.TSNamedTupleMember = TSNamedTupleMember; +exports.TSNamespaceExportDeclaration = TSNamespaceExportDeclaration; +exports.TSNeverKeyword = TSNeverKeyword; +exports.TSNonNullExpression = TSNonNullExpression; +exports.TSNullKeyword = TSNullKeyword; +exports.TSNumberKeyword = TSNumberKeyword; +exports.TSObjectKeyword = TSObjectKeyword; +exports.TSOptionalType = TSOptionalType; +exports.TSParameterProperty = TSParameterProperty; +exports.TSParenthesizedType = TSParenthesizedType; +exports.TSPropertySignature = TSPropertySignature; +exports.TSQualifiedName = TSQualifiedName; +exports.TSRestType = TSRestType; +exports.TSStringKeyword = TSStringKeyword; +exports.TSSymbolKeyword = TSSymbolKeyword; +exports.TSTemplateLiteralType = TSTemplateLiteralType; +exports.TSThisType = TSThisType; +exports.TSTupleType = TSTupleType; +exports.TSTypeAliasDeclaration = TSTypeAliasDeclaration; +exports.TSTypeAnnotation = TSTypeAnnotation; +exports.TSTypeAssertion = TSTypeAssertion; +exports.TSTypeLiteral = TSTypeLiteral; +exports.TSTypeOperator = TSTypeOperator; +exports.TSTypeParameter = TSTypeParameter; +exports.TSTypeParameterDeclaration = exports.TSTypeParameterInstantiation = TSTypeParameterInstantiation; +exports.TSTypePredicate = TSTypePredicate; +exports.TSTypeQuery = TSTypeQuery; +exports.TSTypeReference = TSTypeReference; +exports.TSUndefinedKeyword = TSUndefinedKeyword; +exports.TSUnionType = TSUnionType; +exports.TSUnknownKeyword = TSUnknownKeyword; +exports.TSVoidKeyword = TSVoidKeyword; +exports.tsPrintClassMemberModifiers = tsPrintClassMemberModifiers; +exports.tsPrintFunctionOrConstructorType = tsPrintFunctionOrConstructorType; +exports.tsPrintPropertyOrMethodName = tsPrintPropertyOrMethodName; +exports.tsPrintSignatureDeclarationBase = tsPrintSignatureDeclarationBase; +function TSTypeAnnotation(node, parent) { + this.token((parent.type === "TSFunctionType" || parent.type === "TSConstructorType") && parent.typeAnnotation === node ? "=>" : ":"); + this.space(); + if (node.optional) this.tokenChar(63); + this.print(node.typeAnnotation); +} +function TSTypeParameterInstantiation(node, parent) { + this.tokenChar(60); + let printTrailingSeparator = parent.type === "ArrowFunctionExpression" && node.params.length === 1; + if (this.tokenMap && node.start != null && node.end != null) { + printTrailingSeparator && (printTrailingSeparator = !!this.tokenMap.find(node, t => this.tokenMap.matchesOriginal(t, ","))); + printTrailingSeparator || (printTrailingSeparator = this.shouldPrintTrailingComma(">")); + } + this.printList(node.params, printTrailingSeparator); + this.tokenChar(62); +} +function TSTypeParameter(node) { + if (node.const) { + this.word("const"); + this.space(); + } + if (node.in) { + this.word("in"); + this.space(); + } + if (node.out) { + this.word("out"); + this.space(); + } + this.word(node.name); + if (node.constraint) { + this.space(); + this.word("extends"); + this.space(); + this.print(node.constraint); + } + if (node.default) { + this.space(); + this.tokenChar(61); + this.space(); + this.print(node.default); + } +} +function TSParameterProperty(node) { + if (node.accessibility) { + this.word(node.accessibility); + this.space(); + } + if (node.readonly) { + this.word("readonly"); + this.space(); + } + this._param(node.parameter); +} +function TSDeclareFunction(node, parent) { + if (node.declare) { + this.word("declare"); + this.space(); + } + this._functionHead(node, parent); + this.semicolon(); +} +function TSDeclareMethod(node) { + this._classMethodHead(node); + this.semicolon(); +} +function TSQualifiedName(node) { + this.print(node.left); + this.tokenChar(46); + this.print(node.right); +} +function TSCallSignatureDeclaration(node) { + this.tsPrintSignatureDeclarationBase(node); + maybePrintTrailingCommaOrSemicolon(this, node); +} +function maybePrintTrailingCommaOrSemicolon(printer, node) { + if (!printer.tokenMap || !node.start || !node.end) { + printer.semicolon(); + return; + } + if (printer.tokenMap.endMatches(node, ",")) { + printer.token(","); + } else if (printer.tokenMap.endMatches(node, ";")) { + printer.semicolon(); + } +} +function TSConstructSignatureDeclaration(node) { + this.word("new"); + this.space(); + this.tsPrintSignatureDeclarationBase(node); + maybePrintTrailingCommaOrSemicolon(this, node); +} +function TSPropertySignature(node) { + const { + readonly + } = node; + if (readonly) { + this.word("readonly"); + this.space(); + } + this.tsPrintPropertyOrMethodName(node); + this.print(node.typeAnnotation); + maybePrintTrailingCommaOrSemicolon(this, node); +} +function tsPrintPropertyOrMethodName(node) { + if (node.computed) { + this.tokenChar(91); + } + this.print(node.key); + if (node.computed) { + this.tokenChar(93); + } + if (node.optional) { + this.tokenChar(63); + } +} +function TSMethodSignature(node) { + const { + kind + } = node; + if (kind === "set" || kind === "get") { + this.word(kind); + this.space(); + } + this.tsPrintPropertyOrMethodName(node); + this.tsPrintSignatureDeclarationBase(node); + maybePrintTrailingCommaOrSemicolon(this, node); +} +function TSIndexSignature(node) { + const { + readonly, + static: isStatic + } = node; + if (isStatic) { + this.word("static"); + this.space(); + } + if (readonly) { + this.word("readonly"); + this.space(); + } + this.tokenChar(91); + this._parameters(node.parameters, "]"); + this.print(node.typeAnnotation); + maybePrintTrailingCommaOrSemicolon(this, node); +} +function TSAnyKeyword() { + this.word("any"); +} +function TSBigIntKeyword() { + this.word("bigint"); +} +function TSUnknownKeyword() { + this.word("unknown"); +} +function TSNumberKeyword() { + this.word("number"); +} +function TSObjectKeyword() { + this.word("object"); +} +function TSBooleanKeyword() { + this.word("boolean"); +} +function TSStringKeyword() { + this.word("string"); +} +function TSSymbolKeyword() { + this.word("symbol"); +} +function TSVoidKeyword() { + this.word("void"); +} +function TSUndefinedKeyword() { + this.word("undefined"); +} +function TSNullKeyword() { + this.word("null"); +} +function TSNeverKeyword() { + this.word("never"); +} +function TSIntrinsicKeyword() { + this.word("intrinsic"); +} +function TSThisType() { + this.word("this"); +} +function TSFunctionType(node) { + this.tsPrintFunctionOrConstructorType(node); +} +function TSConstructorType(node) { + if (node.abstract) { + this.word("abstract"); + this.space(); + } + this.word("new"); + this.space(); + this.tsPrintFunctionOrConstructorType(node); +} +function tsPrintFunctionOrConstructorType(node) { + const { + typeParameters + } = node; + const parameters = node.parameters; + this.print(typeParameters); + this.tokenChar(40); + this._parameters(parameters, ")"); + this.space(); + const returnType = node.typeAnnotation; + this.print(returnType); +} +function TSTypeReference(node) { + const typeArguments = node.typeParameters; + this.print(node.typeName, !!typeArguments); + this.print(typeArguments); +} +function TSTypePredicate(node) { + if (node.asserts) { + this.word("asserts"); + this.space(); + } + this.print(node.parameterName); + if (node.typeAnnotation) { + this.space(); + this.word("is"); + this.space(); + this.print(node.typeAnnotation.typeAnnotation); + } +} +function TSTypeQuery(node) { + this.word("typeof"); + this.space(); + this.print(node.exprName); + const typeArguments = node.typeParameters; + if (typeArguments) { + this.print(typeArguments); + } +} +function TSTypeLiteral(node) { + printBraced(this, node, () => this.printJoin(node.members, true, true)); +} +function TSArrayType(node) { + this.print(node.elementType, true); + this.tokenChar(91); + this.tokenChar(93); +} +function TSTupleType(node) { + this.tokenChar(91); + this.printList(node.elementTypes, this.shouldPrintTrailingComma("]")); + this.tokenChar(93); +} +function TSOptionalType(node) { + this.print(node.typeAnnotation); + this.tokenChar(63); +} +function TSRestType(node) { + this.token("..."); + this.print(node.typeAnnotation); +} +function TSNamedTupleMember(node) { + this.print(node.label); + if (node.optional) this.tokenChar(63); + this.tokenChar(58); + this.space(); + this.print(node.elementType); +} +function TSUnionType(node) { + tsPrintUnionOrIntersectionType(this, node, "|"); +} +function TSIntersectionType(node) { + tsPrintUnionOrIntersectionType(this, node, "&"); +} +function tsPrintUnionOrIntersectionType(printer, node, sep) { + var _printer$tokenMap; + let hasLeadingToken = 0; + if ((_printer$tokenMap = printer.tokenMap) != null && _printer$tokenMap.startMatches(node, sep)) { + hasLeadingToken = 1; + printer.token(sep); + } + printer.printJoin(node.types, undefined, undefined, function (i) { + this.space(); + this.token(sep, null, i + hasLeadingToken); + this.space(); + }); +} +function TSConditionalType(node) { + this.print(node.checkType); + this.space(); + this.word("extends"); + this.space(); + this.print(node.extendsType); + this.space(); + this.tokenChar(63); + this.space(); + this.print(node.trueType); + this.space(); + this.tokenChar(58); + this.space(); + this.print(node.falseType); +} +function TSInferType(node) { + this.word("infer"); + this.print(node.typeParameter); +} +function TSParenthesizedType(node) { + this.tokenChar(40); + this.print(node.typeAnnotation); + this.tokenChar(41); +} +function TSTypeOperator(node) { + this.word(node.operator); + this.space(); + this.print(node.typeAnnotation); +} +function TSIndexedAccessType(node) { + this.print(node.objectType, true); + this.tokenChar(91); + this.print(node.indexType); + this.tokenChar(93); +} +function TSMappedType(node) { + const { + nameType, + optional, + readonly, + typeAnnotation + } = node; + this.tokenChar(123); + const exit = this.enterDelimited(); + this.space(); + if (readonly) { + tokenIfPlusMinus(this, readonly); + this.word("readonly"); + this.space(); + } + this.tokenChar(91); + { + this.word(node.typeParameter.name); + } + this.space(); + this.word("in"); + this.space(); + { + this.print(node.typeParameter.constraint); + } + if (nameType) { + this.space(); + this.word("as"); + this.space(); + this.print(nameType); + } + this.tokenChar(93); + if (optional) { + tokenIfPlusMinus(this, optional); + this.tokenChar(63); + } + if (typeAnnotation) { + this.tokenChar(58); + this.space(); + this.print(typeAnnotation); + } + this.space(); + exit(); + this.tokenChar(125); +} +function tokenIfPlusMinus(self, tok) { + if (tok !== true) { + self.token(tok); + } +} +function TSTemplateLiteralType(node) { + this._printTemplate(node, node.types); +} +function TSLiteralType(node) { + this.print(node.literal); +} +function TSClassImplements(node) { + this.print(node.expression); + this.print(node.typeArguments); +} +function TSInterfaceDeclaration(node) { + const { + declare, + id, + typeParameters, + extends: extendz, + body + } = node; + if (declare) { + this.word("declare"); + this.space(); + } + this.word("interface"); + this.space(); + this.print(id); + this.print(typeParameters); + if (extendz != null && extendz.length) { + this.space(); + this.word("extends"); + this.space(); + this.printList(extendz); + } + this.space(); + this.print(body); +} +function TSInterfaceBody(node) { + printBraced(this, node, () => this.printJoin(node.body, true, true)); +} +function TSTypeAliasDeclaration(node) { + const { + declare, + id, + typeParameters, + typeAnnotation + } = node; + if (declare) { + this.word("declare"); + this.space(); + } + this.word("type"); + this.space(); + this.print(id); + this.print(typeParameters); + this.space(); + this.tokenChar(61); + this.space(); + this.print(typeAnnotation); + this.semicolon(); +} +function TSTypeExpression(node) { + const { + type, + expression, + typeAnnotation + } = node; + this.print(expression, true); + this.space(); + this.word(type === "TSAsExpression" ? "as" : "satisfies"); + this.space(); + this.print(typeAnnotation); +} +function TSTypeAssertion(node) { + const { + typeAnnotation, + expression + } = node; + this.tokenChar(60); + this.print(typeAnnotation); + this.tokenChar(62); + this.space(); + this.print(expression); +} +function TSInstantiationExpression(node) { + this.print(node.expression); + { + this.print(node.typeParameters); + } +} +function TSEnumDeclaration(node) { + const { + declare, + const: isConst, + id + } = node; + if (declare) { + this.word("declare"); + this.space(); + } + if (isConst) { + this.word("const"); + this.space(); + } + this.word("enum"); + this.space(); + this.print(id); + this.space(); + { + TSEnumBody.call(this, node); + } +} +function TSEnumBody(node) { + printBraced(this, node, () => { + var _this$shouldPrintTrai; + return this.printList(node.members, (_this$shouldPrintTrai = this.shouldPrintTrailingComma("}")) != null ? _this$shouldPrintTrai : true, true, true); + }); +} +function TSEnumMember(node) { + const { + id, + initializer + } = node; + this.print(id); + if (initializer) { + this.space(); + this.tokenChar(61); + this.space(); + this.print(initializer); + } +} +function TSModuleDeclaration(node) { + const { + declare, + id, + kind + } = node; + if (declare) { + this.word("declare"); + this.space(); + } + { + if (!node.global) { + this.word(kind != null ? kind : id.type === "Identifier" ? "namespace" : "module"); + this.space(); + } + this.print(id); + if (!node.body) { + this.semicolon(); + return; + } + let body = node.body; + while (body.type === "TSModuleDeclaration") { + this.tokenChar(46); + this.print(body.id); + body = body.body; + } + this.space(); + this.print(body); + } +} +function TSModuleBlock(node) { + printBraced(this, node, () => this.printSequence(node.body, true)); +} +function TSImportType(node) { + const { + argument, + qualifier, + options + } = node; + this.word("import"); + this.tokenChar(40); + this.print(argument); + if (options) { + this.tokenChar(44); + this.print(options); + } + this.tokenChar(41); + if (qualifier) { + this.tokenChar(46); + this.print(qualifier); + } + const typeArguments = node.typeParameters; + if (typeArguments) { + this.print(typeArguments); + } +} +function TSImportEqualsDeclaration(node) { + const { + id, + moduleReference + } = node; + if (node.isExport) { + this.word("export"); + this.space(); + } + this.word("import"); + this.space(); + this.print(id); + this.space(); + this.tokenChar(61); + this.space(); + this.print(moduleReference); + this.semicolon(); +} +function TSExternalModuleReference(node) { + this.token("require("); + this.print(node.expression); + this.tokenChar(41); +} +function TSNonNullExpression(node) { + this.print(node.expression); + this.tokenChar(33); +} +function TSExportAssignment(node) { + this.word("export"); + this.space(); + this.tokenChar(61); + this.space(); + this.print(node.expression); + this.semicolon(); +} +function TSNamespaceExportDeclaration(node) { + this.word("export"); + this.space(); + this.word("as"); + this.space(); + this.word("namespace"); + this.space(); + this.print(node.id); + this.semicolon(); +} +function tsPrintSignatureDeclarationBase(node) { + const { + typeParameters + } = node; + const parameters = node.parameters; + this.print(typeParameters); + this.tokenChar(40); + this._parameters(parameters, ")"); + const returnType = node.typeAnnotation; + this.print(returnType); +} +function tsPrintClassMemberModifiers(node) { + const isPrivateField = node.type === "ClassPrivateProperty"; + const isPublicField = node.type === "ClassAccessorProperty" || node.type === "ClassProperty"; + printModifiersList(this, node, [isPublicField && node.declare && "declare", !isPrivateField && node.accessibility]); + if (node.static) { + this.word("static"); + this.space(); + } + printModifiersList(this, node, [!isPrivateField && node.abstract && "abstract", !isPrivateField && node.override && "override", (isPublicField || isPrivateField) && node.readonly && "readonly"]); +} +function printBraced(printer, node, cb) { + printer.token("{"); + const exit = printer.enterDelimited(); + cb(); + exit(); + printer.rightBrace(node); +} +function printModifiersList(printer, node, modifiers) { + var _printer$tokenMap2; + const modifiersSet = new Set(); + for (const modifier of modifiers) { + if (modifier) modifiersSet.add(modifier); + } + (_printer$tokenMap2 = printer.tokenMap) == null || _printer$tokenMap2.find(node, tok => { + if (modifiersSet.has(tok.value)) { + printer.token(tok.value); + printer.space(); + modifiersSet.delete(tok.value); + return modifiersSet.size === 0; + } + }); + for (const modifier of modifiersSet) { + printer.word(modifier); + printer.space(); + } +} + +//# sourceMappingURL=typescript.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/typescript.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/typescript.js.map new file mode 100644 index 0000000000000000000000000000000000000000..81caf47bb13fd8ea3be0e58c653e58575f7a404d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/generators/typescript.js.map @@ -0,0 +1 @@ +{"version":3,"names":["TSTypeAnnotation","node","parent","token","type","typeAnnotation","space","optional","print","TSTypeParameterInstantiation","printTrailingSeparator","params","length","tokenMap","start","end","find","t","matchesOriginal","shouldPrintTrailingComma","printList","TSTypeParameter","const","word","in","out","name","constraint","default","TSParameterProperty","accessibility","readonly","_param","parameter","TSDeclareFunction","declare","_functionHead","semicolon","TSDeclareMethod","_classMethodHead","TSQualifiedName","left","right","TSCallSignatureDeclaration","tsPrintSignatureDeclarationBase","maybePrintTrailingCommaOrSemicolon","printer","endMatches","TSConstructSignatureDeclaration","TSPropertySignature","tsPrintPropertyOrMethodName","computed","key","TSMethodSignature","kind","TSIndexSignature","static","isStatic","_parameters","parameters","TSAnyKeyword","TSBigIntKeyword","TSUnknownKeyword","TSNumberKeyword","TSObjectKeyword","TSBooleanKeyword","TSStringKeyword","TSSymbolKeyword","TSVoidKeyword","TSUndefinedKeyword","TSNullKeyword","TSNeverKeyword","TSIntrinsicKeyword","TSThisType","TSFunctionType","tsPrintFunctionOrConstructorType","TSConstructorType","abstract","typeParameters","returnType","TSTypeReference","typeArguments","typeName","TSTypePredicate","asserts","parameterName","TSTypeQuery","exprName","TSTypeLiteral","printBraced","printJoin","members","TSArrayType","elementType","TSTupleType","elementTypes","TSOptionalType","TSRestType","TSNamedTupleMember","label","TSUnionType","tsPrintUnionOrIntersectionType","TSIntersectionType","sep","_printer$tokenMap","hasLeadingToken","startMatches","types","undefined","i","TSConditionalType","checkType","extendsType","trueType","falseType","TSInferType","typeParameter","TSParenthesizedType","TSTypeOperator","operator","TSIndexedAccessType","objectType","indexType","TSMappedType","nameType","exit","enterDelimited","tokenIfPlusMinus","self","tok","TSTemplateLiteralType","_printTemplate","TSLiteralType","literal","TSClassImplements","expression","TSInterfaceDeclaration","id","extends","extendz","body","TSInterfaceBody","TSTypeAliasDeclaration","TSTypeExpression","TSTypeAssertion","TSInstantiationExpression","TSEnumDeclaration","isConst","TSEnumBody","call","_this$shouldPrintTrai","TSEnumMember","initializer","TSModuleDeclaration","global","TSModuleBlock","printSequence","TSImportType","argument","qualifier","options","TSImportEqualsDeclaration","moduleReference","isExport","TSExternalModuleReference","TSNonNullExpression","TSExportAssignment","TSNamespaceExportDeclaration","tsPrintClassMemberModifiers","isPrivateField","isPublicField","printModifiersList","override","cb","rightBrace","modifiers","_printer$tokenMap2","modifiersSet","Set","modifier","add","has","value","delete","size"],"sources":["../../src/generators/typescript.ts"],"sourcesContent":["import type Printer from \"../printer.ts\";\nimport type * as t from \"@babel/types\";\n\nexport function TSTypeAnnotation(\n this: Printer,\n node: t.TSTypeAnnotation,\n parent: t.Node,\n) {\n // TODO(@nicolo-ribaudo): investigate not including => in the range\n // of the return type of an arrow function type\n this.token(\n (parent.type === \"TSFunctionType\" || parent.type === \"TSConstructorType\") &&\n (process.env.BABEL_8_BREAKING\n ? // @ts-ignore(Babel 7 vs Babel 8) Babel 8 AST shape\n parent.returnType\n : // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST shape\n parent.typeAnnotation) === node\n ? \"=>\"\n : \":\",\n );\n this.space();\n // @ts-expect-error todo(flow->ts) can this be removed? `.optional` looks to be not existing property\n if (node.optional) this.token(\"?\");\n this.print(node.typeAnnotation);\n}\n\nexport function TSTypeParameterInstantiation(\n this: Printer,\n node: t.TSTypeParameterInstantiation,\n parent: t.Node,\n): void {\n this.token(\"<\");\n\n let printTrailingSeparator =\n parent.type === \"ArrowFunctionExpression\" && node.params.length === 1;\n if (this.tokenMap && node.start != null && node.end != null) {\n // Only force the trailing comma for pre-existing nodes if they\n // already had a comma (either because they were multi-param, or\n // because they had a trailing comma)\n printTrailingSeparator &&= !!this.tokenMap.find(node, t =>\n this.tokenMap.matchesOriginal(t, \",\"),\n );\n // Preserve the trailing comma if it was there before\n printTrailingSeparator ||= this.shouldPrintTrailingComma(\">\");\n }\n\n this.printList(node.params, printTrailingSeparator);\n this.token(\">\");\n}\n\nexport { TSTypeParameterInstantiation as TSTypeParameterDeclaration };\n\nexport function TSTypeParameter(this: Printer, node: t.TSTypeParameter) {\n if (node.const) {\n this.word(\"const\");\n this.space();\n }\n\n if (node.in) {\n this.word(\"in\");\n this.space();\n }\n\n if (node.out) {\n this.word(\"out\");\n this.space();\n }\n\n this.word(\n !process.env.BABEL_8_BREAKING\n ? (node.name as unknown as string)\n : (node.name as unknown as t.Identifier).name,\n );\n\n if (node.constraint) {\n this.space();\n this.word(\"extends\");\n this.space();\n this.print(node.constraint);\n }\n\n if (node.default) {\n this.space();\n this.token(\"=\");\n this.space();\n this.print(node.default);\n }\n}\n\nexport function TSParameterProperty(\n this: Printer,\n node: t.TSParameterProperty,\n) {\n if (node.accessibility) {\n this.word(node.accessibility);\n this.space();\n }\n\n if (node.readonly) {\n this.word(\"readonly\");\n this.space();\n }\n\n this._param(node.parameter);\n}\n\nexport function TSDeclareFunction(\n this: Printer,\n node: t.TSDeclareFunction,\n parent: t.ParentMaps[\"TSDeclareFunction\"],\n) {\n if (node.declare) {\n this.word(\"declare\");\n this.space();\n }\n this._functionHead(node, parent);\n this.semicolon();\n}\n\nexport function TSDeclareMethod(this: Printer, node: t.TSDeclareMethod) {\n this._classMethodHead(node);\n this.semicolon();\n}\n\nexport function TSQualifiedName(this: Printer, node: t.TSQualifiedName) {\n this.print(node.left);\n this.token(\".\");\n this.print(node.right);\n}\n\nexport function TSCallSignatureDeclaration(\n this: Printer,\n node: t.TSCallSignatureDeclaration,\n) {\n this.tsPrintSignatureDeclarationBase(node);\n maybePrintTrailingCommaOrSemicolon(this, node);\n}\n\nfunction maybePrintTrailingCommaOrSemicolon(printer: Printer, node: t.Node) {\n if (!printer.tokenMap || !node.start || !node.end) {\n printer.semicolon();\n return;\n }\n\n if (printer.tokenMap.endMatches(node, \",\")) {\n printer.token(\",\");\n } else if (printer.tokenMap.endMatches(node, \";\")) {\n printer.semicolon();\n }\n}\n\nexport function TSConstructSignatureDeclaration(\n this: Printer,\n node: t.TSConstructSignatureDeclaration,\n) {\n this.word(\"new\");\n this.space();\n this.tsPrintSignatureDeclarationBase(node);\n maybePrintTrailingCommaOrSemicolon(this, node);\n}\n\nexport function TSPropertySignature(\n this: Printer,\n node: t.TSPropertySignature,\n) {\n const { readonly } = node;\n if (readonly) {\n this.word(\"readonly\");\n this.space();\n }\n this.tsPrintPropertyOrMethodName(node);\n this.print(node.typeAnnotation);\n maybePrintTrailingCommaOrSemicolon(this, node);\n}\n\nexport function tsPrintPropertyOrMethodName(\n this: Printer,\n node: t.TSPropertySignature | t.TSMethodSignature,\n) {\n if (node.computed) {\n this.token(\"[\");\n }\n this.print(node.key);\n if (node.computed) {\n this.token(\"]\");\n }\n if (node.optional) {\n this.token(\"?\");\n }\n}\n\nexport function TSMethodSignature(this: Printer, node: t.TSMethodSignature) {\n const { kind } = node;\n if (kind === \"set\" || kind === \"get\") {\n this.word(kind);\n this.space();\n }\n this.tsPrintPropertyOrMethodName(node);\n this.tsPrintSignatureDeclarationBase(node);\n maybePrintTrailingCommaOrSemicolon(this, node);\n}\n\nexport function TSIndexSignature(this: Printer, node: t.TSIndexSignature) {\n const { readonly, static: isStatic } = node;\n if (isStatic) {\n this.word(\"static\");\n this.space();\n }\n if (readonly) {\n this.word(\"readonly\");\n this.space();\n }\n this.token(\"[\");\n this._parameters(node.parameters, \"]\");\n this.print(node.typeAnnotation);\n maybePrintTrailingCommaOrSemicolon(this, node);\n}\n\nexport function TSAnyKeyword(this: Printer) {\n this.word(\"any\");\n}\nexport function TSBigIntKeyword(this: Printer) {\n this.word(\"bigint\");\n}\nexport function TSUnknownKeyword(this: Printer) {\n this.word(\"unknown\");\n}\nexport function TSNumberKeyword(this: Printer) {\n this.word(\"number\");\n}\nexport function TSObjectKeyword(this: Printer) {\n this.word(\"object\");\n}\nexport function TSBooleanKeyword(this: Printer) {\n this.word(\"boolean\");\n}\nexport function TSStringKeyword(this: Printer) {\n this.word(\"string\");\n}\nexport function TSSymbolKeyword(this: Printer) {\n this.word(\"symbol\");\n}\nexport function TSVoidKeyword(this: Printer) {\n this.word(\"void\");\n}\nexport function TSUndefinedKeyword(this: Printer) {\n this.word(\"undefined\");\n}\nexport function TSNullKeyword(this: Printer) {\n this.word(\"null\");\n}\nexport function TSNeverKeyword(this: Printer) {\n this.word(\"never\");\n}\nexport function TSIntrinsicKeyword(this: Printer) {\n this.word(\"intrinsic\");\n}\n\nexport function TSThisType(this: Printer) {\n this.word(\"this\");\n}\n\nexport function TSFunctionType(this: Printer, node: t.TSFunctionType) {\n this.tsPrintFunctionOrConstructorType(node);\n}\n\nexport function TSConstructorType(this: Printer, node: t.TSConstructorType) {\n if (node.abstract) {\n this.word(\"abstract\");\n this.space();\n }\n this.word(\"new\");\n this.space();\n this.tsPrintFunctionOrConstructorType(node);\n}\n\nexport function tsPrintFunctionOrConstructorType(\n this: Printer,\n node: t.TSFunctionType | t.TSConstructorType,\n) {\n const { typeParameters } = node;\n const parameters = process.env.BABEL_8_BREAKING\n ? // @ts-ignore(Babel 7 vs Babel 8) Babel 8 AST shape\n node.params\n : // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST shape\n node.parameters;\n this.print(typeParameters);\n this.token(\"(\");\n this._parameters(parameters, \")\");\n this.space();\n const returnType = process.env.BABEL_8_BREAKING\n ? // @ts-ignore(Babel 7 vs Babel 8) Babel 8 AST shape\n node.returnType\n : // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST shape\n node.typeAnnotation;\n this.print(returnType);\n}\n\nexport function TSTypeReference(this: Printer, node: t.TSTypeReference) {\n const typeArguments = process.env.BABEL_8_BREAKING\n ? // @ts-ignore(Babel 7 vs Babel 8) Babel 8 AST shape\n node.typeArguments\n : // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST shape\n node.typeParameters;\n this.print(node.typeName, !!typeArguments);\n this.print(typeArguments);\n}\n\nexport function TSTypePredicate(this: Printer, node: t.TSTypePredicate) {\n if (node.asserts) {\n this.word(\"asserts\");\n this.space();\n }\n this.print(node.parameterName);\n if (node.typeAnnotation) {\n this.space();\n this.word(\"is\");\n this.space();\n this.print(node.typeAnnotation.typeAnnotation);\n }\n}\n\nexport function TSTypeQuery(this: Printer, node: t.TSTypeQuery) {\n this.word(\"typeof\");\n this.space();\n this.print(node.exprName);\n\n const typeArguments = process.env.BABEL_8_BREAKING\n ? //@ts-ignore(Babel 7 vs Babel 8) Babel 8 AST\n node.typeArguments\n : //@ts-ignore(Babel 7 vs Babel 8) Babel 7 AST\n node.typeParameters;\n if (typeArguments) {\n this.print(typeArguments);\n }\n}\n\nexport function TSTypeLiteral(this: Printer, node: t.TSTypeLiteral) {\n printBraced(this, node, () => this.printJoin(node.members, true, true));\n}\n\nexport function TSArrayType(this: Printer, node: t.TSArrayType) {\n this.print(node.elementType, true);\n\n this.token(\"[\");\n this.token(\"]\");\n}\n\nexport function TSTupleType(this: Printer, node: t.TSTupleType) {\n this.token(\"[\");\n this.printList(node.elementTypes, this.shouldPrintTrailingComma(\"]\"));\n this.token(\"]\");\n}\n\nexport function TSOptionalType(this: Printer, node: t.TSOptionalType) {\n this.print(node.typeAnnotation);\n this.token(\"?\");\n}\n\nexport function TSRestType(this: Printer, node: t.TSRestType) {\n this.token(\"...\");\n this.print(node.typeAnnotation);\n}\n\nexport function TSNamedTupleMember(this: Printer, node: t.TSNamedTupleMember) {\n this.print(node.label);\n if (node.optional) this.token(\"?\");\n this.token(\":\");\n this.space();\n this.print(node.elementType);\n}\n\nexport function TSUnionType(this: Printer, node: t.TSUnionType) {\n tsPrintUnionOrIntersectionType(this, node, \"|\");\n}\n\nexport function TSIntersectionType(this: Printer, node: t.TSIntersectionType) {\n tsPrintUnionOrIntersectionType(this, node, \"&\");\n}\n\nfunction tsPrintUnionOrIntersectionType(\n printer: Printer,\n node: t.TSUnionType | t.TSIntersectionType,\n sep: \"|\" | \"&\",\n) {\n let hasLeadingToken = 0;\n if (printer.tokenMap?.startMatches(node, sep)) {\n hasLeadingToken = 1;\n printer.token(sep);\n }\n\n printer.printJoin(node.types, undefined, undefined, function (i) {\n this.space();\n this.token(sep, null, i + hasLeadingToken);\n this.space();\n });\n}\n\nexport function TSConditionalType(this: Printer, node: t.TSConditionalType) {\n this.print(node.checkType);\n this.space();\n this.word(\"extends\");\n this.space();\n this.print(node.extendsType);\n this.space();\n this.token(\"?\");\n this.space();\n this.print(node.trueType);\n this.space();\n this.token(\":\");\n this.space();\n this.print(node.falseType);\n}\n\nexport function TSInferType(this: Printer, node: t.TSInferType) {\n this.word(\"infer\");\n this.print(node.typeParameter);\n}\n\nexport function TSParenthesizedType(\n this: Printer,\n node: t.TSParenthesizedType,\n) {\n this.token(\"(\");\n this.print(node.typeAnnotation);\n this.token(\")\");\n}\n\nexport function TSTypeOperator(this: Printer, node: t.TSTypeOperator) {\n this.word(node.operator);\n this.space();\n this.print(node.typeAnnotation);\n}\n\nexport function TSIndexedAccessType(\n this: Printer,\n node: t.TSIndexedAccessType,\n) {\n this.print(node.objectType, true);\n this.token(\"[\");\n this.print(node.indexType);\n this.token(\"]\");\n}\n\nexport function TSMappedType(this: Printer, node: t.TSMappedType) {\n const { nameType, optional, readonly, typeAnnotation } = node;\n this.token(\"{\");\n const exit = this.enterDelimited();\n this.space();\n if (readonly) {\n tokenIfPlusMinus(this, readonly);\n this.word(\"readonly\");\n this.space();\n }\n\n this.token(\"[\");\n if (process.env.BABEL_8_BREAKING) {\n // @ts-ignore(Babel 7 vs Babel 8) Babel 8 AST shape\n this.word(node.key.name);\n } else {\n // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST shape\n this.word(node.typeParameter.name);\n }\n\n this.space();\n this.word(\"in\");\n this.space();\n if (process.env.BABEL_8_BREAKING) {\n // @ts-ignore(Babel 7 vs Babel 8) Babel 8 AST shape\n this.print(node.constraint);\n } else {\n // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST shape\n this.print(node.typeParameter.constraint);\n }\n\n if (nameType) {\n this.space();\n this.word(\"as\");\n this.space();\n this.print(nameType);\n }\n\n this.token(\"]\");\n\n if (optional) {\n tokenIfPlusMinus(this, optional);\n this.token(\"?\");\n }\n\n if (typeAnnotation) {\n this.token(\":\");\n this.space();\n this.print(typeAnnotation);\n }\n this.space();\n exit();\n this.token(\"}\");\n}\n\nfunction tokenIfPlusMinus(self: Printer, tok: true | \"+\" | \"-\") {\n if (tok !== true) {\n self.token(tok);\n }\n}\n\nexport function TSTemplateLiteralType(\n this: Printer,\n node: t.TSTemplateLiteralType,\n) {\n this._printTemplate(node, node.types);\n}\n\nexport function TSLiteralType(this: Printer, node: t.TSLiteralType) {\n this.print(node.literal);\n}\n\nexport function TSClassImplements(\n this: Printer,\n // TODO(Babel 8): Just use t.TSClassImplements\n node: t.Node & {\n expression: t.TSEntityName;\n typeArguments?: t.TSTypeParameterInstantiation;\n },\n) {\n this.print(node.expression);\n this.print(node.typeArguments);\n}\n\nexport { TSClassImplements as TSInterfaceHeritage };\n\nexport function TSInterfaceDeclaration(\n this: Printer,\n node: t.TSInterfaceDeclaration,\n) {\n const { declare, id, typeParameters, extends: extendz, body } = node;\n if (declare) {\n this.word(\"declare\");\n this.space();\n }\n this.word(\"interface\");\n this.space();\n this.print(id);\n this.print(typeParameters);\n if (extendz?.length) {\n this.space();\n this.word(\"extends\");\n this.space();\n this.printList(extendz);\n }\n this.space();\n this.print(body);\n}\n\nexport function TSInterfaceBody(this: Printer, node: t.TSInterfaceBody) {\n printBraced(this, node, () => this.printJoin(node.body, true, true));\n}\n\nexport function TSTypeAliasDeclaration(\n this: Printer,\n node: t.TSTypeAliasDeclaration,\n) {\n const { declare, id, typeParameters, typeAnnotation } = node;\n if (declare) {\n this.word(\"declare\");\n this.space();\n }\n this.word(\"type\");\n this.space();\n this.print(id);\n this.print(typeParameters);\n this.space();\n this.token(\"=\");\n this.space();\n this.print(typeAnnotation);\n this.semicolon();\n}\n\nfunction TSTypeExpression(\n this: Printer,\n node: t.TSAsExpression | t.TSSatisfiesExpression,\n) {\n const { type, expression, typeAnnotation } = node;\n this.print(expression, true);\n this.space();\n this.word(type === \"TSAsExpression\" ? \"as\" : \"satisfies\");\n this.space();\n this.print(typeAnnotation);\n}\n\nexport {\n TSTypeExpression as TSAsExpression,\n TSTypeExpression as TSSatisfiesExpression,\n};\n\nexport function TSTypeAssertion(this: Printer, node: t.TSTypeAssertion) {\n const { typeAnnotation, expression } = node;\n this.token(\"<\");\n this.print(typeAnnotation);\n this.token(\">\");\n this.space();\n this.print(expression);\n}\n\nexport function TSInstantiationExpression(\n this: Printer,\n node: t.TSInstantiationExpression,\n) {\n this.print(node.expression);\n if (process.env.BABEL_8_BREAKING) {\n // @ts-ignore(Babel 7 vs Babel 8) Babel 8 AST\n this.print(node.typeArguments);\n } else {\n // @ts-ignore(Babel 7 vs Babel 8) Removed in Babel 8\n this.print(node.typeParameters);\n }\n}\n\nexport function TSEnumDeclaration(this: Printer, node: t.TSEnumDeclaration) {\n const { declare, const: isConst, id } = node;\n if (declare) {\n this.word(\"declare\");\n this.space();\n }\n if (isConst) {\n this.word(\"const\");\n this.space();\n }\n this.word(\"enum\");\n this.space();\n this.print(id);\n this.space();\n\n if (process.env.BABEL_8_BREAKING) {\n // @ts-ignore(Babel 7 vs Babel 8) Babel 8 AST\n this.print(node.body);\n } else {\n // cast to TSEnumBody for Babel 7 AST\n TSEnumBody.call(this, node as unknown as t.TSEnumBody);\n }\n}\n\nexport function TSEnumBody(this: Printer, node: t.TSEnumBody) {\n printBraced(this, node, () =>\n this.printList(\n node.members,\n this.shouldPrintTrailingComma(\"}\") ??\n (process.env.BABEL_8_BREAKING ? false : true),\n true,\n true,\n ),\n );\n}\n\nexport function TSEnumMember(this: Printer, node: t.TSEnumMember) {\n const { id, initializer } = node;\n this.print(id);\n if (initializer) {\n this.space();\n this.token(\"=\");\n this.space();\n this.print(initializer);\n }\n}\n\nexport function TSModuleDeclaration(\n this: Printer,\n node: t.TSModuleDeclaration,\n) {\n const { declare, id, kind } = node;\n\n if (declare) {\n this.word(\"declare\");\n this.space();\n }\n\n if (process.env.BABEL_8_BREAKING) {\n if (kind !== \"global\") {\n this.word(kind);\n this.space();\n }\n\n this.print(node.id);\n if (!node.body) {\n this.semicolon();\n return;\n }\n this.space();\n this.print(node.body);\n } else {\n // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST shape\n if (!node.global) {\n this.word(kind ?? (id.type === \"Identifier\" ? \"namespace\" : \"module\"));\n this.space();\n }\n\n this.print(id);\n\n if (!node.body) {\n this.semicolon();\n return;\n }\n\n let body = node.body;\n // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST shape\n while (body.type === \"TSModuleDeclaration\") {\n this.token(\".\");\n // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST shape\n this.print(body.id);\n // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST shape\n body = body.body;\n }\n\n this.space();\n this.print(body);\n }\n}\n\nexport function TSModuleBlock(this: Printer, node: t.TSModuleBlock) {\n printBraced(this, node, () => this.printSequence(node.body, true));\n}\n\nexport function TSImportType(this: Printer, node: t.TSImportType) {\n const { argument, qualifier, options } = node;\n this.word(\"import\");\n this.token(\"(\");\n this.print(argument);\n if (options) {\n this.token(\",\");\n this.print(options);\n }\n this.token(\")\");\n if (qualifier) {\n this.token(\".\");\n this.print(qualifier);\n }\n const typeArguments = process.env.BABEL_8_BREAKING\n ? //@ts-ignore(Babel 7 vs Babel 8) Babel 8 AST\n node.typeArguments\n : //@ts-ignore(Babel 7 vs Babel 8) Babel 7 AST\n node.typeParameters;\n if (typeArguments) {\n this.print(typeArguments);\n }\n}\n\nexport function TSImportEqualsDeclaration(\n this: Printer,\n node: t.TSImportEqualsDeclaration,\n) {\n const { id, moduleReference } = node;\n if (\n !process.env.BABEL_8_BREAKING &&\n // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST\n node.isExport\n ) {\n this.word(\"export\");\n this.space();\n }\n this.word(\"import\");\n this.space();\n this.print(id);\n this.space();\n this.token(\"=\");\n this.space();\n this.print(moduleReference);\n this.semicolon();\n}\n\nexport function TSExternalModuleReference(\n this: Printer,\n node: t.TSExternalModuleReference,\n) {\n this.token(\"require(\");\n this.print(node.expression);\n this.token(\")\");\n}\n\nexport function TSNonNullExpression(\n this: Printer,\n node: t.TSNonNullExpression,\n) {\n this.print(node.expression);\n this.token(\"!\");\n}\n\nexport function TSExportAssignment(this: Printer, node: t.TSExportAssignment) {\n this.word(\"export\");\n this.space();\n this.token(\"=\");\n this.space();\n this.print(node.expression);\n this.semicolon();\n}\n\nexport function TSNamespaceExportDeclaration(\n this: Printer,\n node: t.TSNamespaceExportDeclaration,\n) {\n this.word(\"export\");\n this.space();\n this.word(\"as\");\n this.space();\n this.word(\"namespace\");\n this.space();\n this.print(node.id);\n this.semicolon();\n}\n\nexport function tsPrintSignatureDeclarationBase(this: Printer, node: any) {\n const { typeParameters } = node;\n const parameters = process.env.BABEL_8_BREAKING\n ? node.params\n : node.parameters;\n this.print(typeParameters);\n this.token(\"(\");\n this._parameters(parameters, \")\");\n const returnType = process.env.BABEL_8_BREAKING\n ? node.returnType\n : node.typeAnnotation;\n this.print(returnType);\n}\n\nexport function tsPrintClassMemberModifiers(\n this: Printer,\n node:\n | t.ClassProperty\n | t.ClassAccessorProperty\n | t.ClassPrivateProperty\n | t.ClassMethod\n | t.ClassPrivateMethod\n | t.TSDeclareMethod,\n) {\n const isPrivateField = node.type === \"ClassPrivateProperty\";\n const isPublicField =\n node.type === \"ClassAccessorProperty\" || node.type === \"ClassProperty\";\n printModifiersList(this, node, [\n isPublicField && node.declare && \"declare\",\n !isPrivateField && node.accessibility,\n ]);\n if (node.static) {\n this.word(\"static\");\n this.space();\n }\n printModifiersList(this, node, [\n !isPrivateField && node.abstract && \"abstract\",\n !isPrivateField && node.override && \"override\",\n (isPublicField || isPrivateField) && node.readonly && \"readonly\",\n ]);\n}\n\nfunction printBraced(printer: Printer, node: t.Node, cb: () => void) {\n printer.token(\"{\");\n const exit = printer.enterDelimited();\n cb();\n exit();\n printer.rightBrace(node);\n}\n\nfunction printModifiersList(\n printer: Printer,\n node: t.Node,\n modifiers: (string | false | null)[],\n) {\n const modifiersSet = new Set();\n for (const modifier of modifiers) {\n if (modifier) modifiersSet.add(modifier);\n }\n\n printer.tokenMap?.find(node, tok => {\n if (modifiersSet.has(tok.value)) {\n printer.token(tok.value);\n printer.space();\n modifiersSet.delete(tok.value);\n return modifiersSet.size === 0;\n }\n });\n\n for (const modifier of modifiersSet) {\n printer.word(modifier);\n printer.space();\n }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGO,SAASA,gBAAgBA,CAE9BC,IAAwB,EACxBC,MAAc,EACd;EAGA,IAAI,CAACC,KAAK,CACR,CAACD,MAAM,CAACE,IAAI,KAAK,gBAAgB,IAAIF,MAAM,CAACE,IAAI,KAAK,mBAAmB,KAKlEF,MAAM,CAACG,cAAc,KAAMJ,IAAI,GACjC,IAAI,GACJ,GACN,CAAC;EACD,IAAI,CAACK,KAAK,CAAC,CAAC;EAEZ,IAAIL,IAAI,CAACM,QAAQ,EAAE,IAAI,CAACJ,SAAK,GAAI,CAAC;EAClC,IAAI,CAACK,KAAK,CAACP,IAAI,CAACI,cAAc,CAAC;AACjC;AAEO,SAASI,4BAA4BA,CAE1CR,IAAoC,EACpCC,MAAc,EACR;EACN,IAAI,CAACC,SAAK,GAAI,CAAC;EAEf,IAAIO,sBAAsB,GACxBR,MAAM,CAACE,IAAI,KAAK,yBAAyB,IAAIH,IAAI,CAACU,MAAM,CAACC,MAAM,KAAK,CAAC;EACvE,IAAI,IAAI,CAACC,QAAQ,IAAIZ,IAAI,CAACa,KAAK,IAAI,IAAI,IAAIb,IAAI,CAACc,GAAG,IAAI,IAAI,EAAE;IAI3DL,sBAAsB,KAAtBA,sBAAsB,GAAK,CAAC,CAAC,IAAI,CAACG,QAAQ,CAACG,IAAI,CAACf,IAAI,EAAEgB,CAAC,IACrD,IAAI,CAACJ,QAAQ,CAACK,eAAe,CAACD,CAAC,EAAE,GAAG,CACtC,CAAC;IAEDP,sBAAsB,KAAtBA,sBAAsB,GAAK,IAAI,CAACS,wBAAwB,CAAC,GAAG,CAAC;EAC/D;EAEA,IAAI,CAACC,SAAS,CAACnB,IAAI,CAACU,MAAM,EAAED,sBAAsB,CAAC;EACnD,IAAI,CAACP,SAAK,GAAI,CAAC;AACjB;AAIO,SAASkB,eAAeA,CAAgBpB,IAAuB,EAAE;EACtE,IAAIA,IAAI,CAACqB,KAAK,EAAE;IACd,IAAI,CAACC,IAAI,CAAC,OAAO,CAAC;IAClB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACd;EAEA,IAAIL,IAAI,CAACuB,EAAE,EAAE;IACX,IAAI,CAACD,IAAI,CAAC,IAAI,CAAC;IACf,IAAI,CAACjB,KAAK,CAAC,CAAC;EACd;EAEA,IAAIL,IAAI,CAACwB,GAAG,EAAE;IACZ,IAAI,CAACF,IAAI,CAAC,KAAK,CAAC;IAChB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACd;EAEA,IAAI,CAACiB,IAAI,CAEFtB,IAAI,CAACyB,IAEZ,CAAC;EAED,IAAIzB,IAAI,CAAC0B,UAAU,EAAE;IACnB,IAAI,CAACrB,KAAK,CAAC,CAAC;IACZ,IAAI,CAACiB,IAAI,CAAC,SAAS,CAAC;IACpB,IAAI,CAACjB,KAAK,CAAC,CAAC;IACZ,IAAI,CAACE,KAAK,CAACP,IAAI,CAAC0B,UAAU,CAAC;EAC7B;EAEA,IAAI1B,IAAI,CAAC2B,OAAO,EAAE;IAChB,IAAI,CAACtB,KAAK,CAAC,CAAC;IACZ,IAAI,CAACH,SAAK,GAAI,CAAC;IACf,IAAI,CAACG,KAAK,CAAC,CAAC;IACZ,IAAI,CAACE,KAAK,CAACP,IAAI,CAAC2B,OAAO,CAAC;EAC1B;AACF;AAEO,SAASC,mBAAmBA,CAEjC5B,IAA2B,EAC3B;EACA,IAAIA,IAAI,CAAC6B,aAAa,EAAE;IACtB,IAAI,CAACP,IAAI,CAACtB,IAAI,CAAC6B,aAAa,CAAC;IAC7B,IAAI,CAACxB,KAAK,CAAC,CAAC;EACd;EAEA,IAAIL,IAAI,CAAC8B,QAAQ,EAAE;IACjB,IAAI,CAACR,IAAI,CAAC,UAAU,CAAC;IACrB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACd;EAEA,IAAI,CAAC0B,MAAM,CAAC/B,IAAI,CAACgC,SAAS,CAAC;AAC7B;AAEO,SAASC,iBAAiBA,CAE/BjC,IAAyB,EACzBC,MAAyC,EACzC;EACA,IAAID,IAAI,CAACkC,OAAO,EAAE;IAChB,IAAI,CAACZ,IAAI,CAAC,SAAS,CAAC;IACpB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACd;EACA,IAAI,CAAC8B,aAAa,CAACnC,IAAI,EAAEC,MAAM,CAAC;EAChC,IAAI,CAACmC,SAAS,CAAC,CAAC;AAClB;AAEO,SAASC,eAAeA,CAAgBrC,IAAuB,EAAE;EACtE,IAAI,CAACsC,gBAAgB,CAACtC,IAAI,CAAC;EAC3B,IAAI,CAACoC,SAAS,CAAC,CAAC;AAClB;AAEO,SAASG,eAAeA,CAAgBvC,IAAuB,EAAE;EACtE,IAAI,CAACO,KAAK,CAACP,IAAI,CAACwC,IAAI,CAAC;EACrB,IAAI,CAACtC,SAAK,GAAI,CAAC;EACf,IAAI,CAACK,KAAK,CAACP,IAAI,CAACyC,KAAK,CAAC;AACxB;AAEO,SAASC,0BAA0BA,CAExC1C,IAAkC,EAClC;EACA,IAAI,CAAC2C,+BAA+B,CAAC3C,IAAI,CAAC;EAC1C4C,kCAAkC,CAAC,IAAI,EAAE5C,IAAI,CAAC;AAChD;AAEA,SAAS4C,kCAAkCA,CAACC,OAAgB,EAAE7C,IAAY,EAAE;EAC1E,IAAI,CAAC6C,OAAO,CAACjC,QAAQ,IAAI,CAACZ,IAAI,CAACa,KAAK,IAAI,CAACb,IAAI,CAACc,GAAG,EAAE;IACjD+B,OAAO,CAACT,SAAS,CAAC,CAAC;IACnB;EACF;EAEA,IAAIS,OAAO,CAACjC,QAAQ,CAACkC,UAAU,CAAC9C,IAAI,EAAE,GAAG,CAAC,EAAE;IAC1C6C,OAAO,CAAC3C,KAAK,CAAC,GAAG,CAAC;EACpB,CAAC,MAAM,IAAI2C,OAAO,CAACjC,QAAQ,CAACkC,UAAU,CAAC9C,IAAI,EAAE,GAAG,CAAC,EAAE;IACjD6C,OAAO,CAACT,SAAS,CAAC,CAAC;EACrB;AACF;AAEO,SAASW,+BAA+BA,CAE7C/C,IAAuC,EACvC;EACA,IAAI,CAACsB,IAAI,CAAC,KAAK,CAAC;EAChB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACZ,IAAI,CAACsC,+BAA+B,CAAC3C,IAAI,CAAC;EAC1C4C,kCAAkC,CAAC,IAAI,EAAE5C,IAAI,CAAC;AAChD;AAEO,SAASgD,mBAAmBA,CAEjChD,IAA2B,EAC3B;EACA,MAAM;IAAE8B;EAAS,CAAC,GAAG9B,IAAI;EACzB,IAAI8B,QAAQ,EAAE;IACZ,IAAI,CAACR,IAAI,CAAC,UAAU,CAAC;IACrB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACd;EACA,IAAI,CAAC4C,2BAA2B,CAACjD,IAAI,CAAC;EACtC,IAAI,CAACO,KAAK,CAACP,IAAI,CAACI,cAAc,CAAC;EAC/BwC,kCAAkC,CAAC,IAAI,EAAE5C,IAAI,CAAC;AAChD;AAEO,SAASiD,2BAA2BA,CAEzCjD,IAAiD,EACjD;EACA,IAAIA,IAAI,CAACkD,QAAQ,EAAE;IACjB,IAAI,CAAChD,SAAK,GAAI,CAAC;EACjB;EACA,IAAI,CAACK,KAAK,CAACP,IAAI,CAACmD,GAAG,CAAC;EACpB,IAAInD,IAAI,CAACkD,QAAQ,EAAE;IACjB,IAAI,CAAChD,SAAK,GAAI,CAAC;EACjB;EACA,IAAIF,IAAI,CAACM,QAAQ,EAAE;IACjB,IAAI,CAACJ,SAAK,GAAI,CAAC;EACjB;AACF;AAEO,SAASkD,iBAAiBA,CAAgBpD,IAAyB,EAAE;EAC1E,MAAM;IAAEqD;EAAK,CAAC,GAAGrD,IAAI;EACrB,IAAIqD,IAAI,KAAK,KAAK,IAAIA,IAAI,KAAK,KAAK,EAAE;IACpC,IAAI,CAAC/B,IAAI,CAAC+B,IAAI,CAAC;IACf,IAAI,CAAChD,KAAK,CAAC,CAAC;EACd;EACA,IAAI,CAAC4C,2BAA2B,CAACjD,IAAI,CAAC;EACtC,IAAI,CAAC2C,+BAA+B,CAAC3C,IAAI,CAAC;EAC1C4C,kCAAkC,CAAC,IAAI,EAAE5C,IAAI,CAAC;AAChD;AAEO,SAASsD,gBAAgBA,CAAgBtD,IAAwB,EAAE;EACxE,MAAM;IAAE8B,QAAQ;IAAEyB,MAAM,EAAEC;EAAS,CAAC,GAAGxD,IAAI;EAC3C,IAAIwD,QAAQ,EAAE;IACZ,IAAI,CAAClC,IAAI,CAAC,QAAQ,CAAC;IACnB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACd;EACA,IAAIyB,QAAQ,EAAE;IACZ,IAAI,CAACR,IAAI,CAAC,UAAU,CAAC;IACrB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACd;EACA,IAAI,CAACH,SAAK,GAAI,CAAC;EACf,IAAI,CAACuD,WAAW,CAACzD,IAAI,CAAC0D,UAAU,EAAE,GAAG,CAAC;EACtC,IAAI,CAACnD,KAAK,CAACP,IAAI,CAACI,cAAc,CAAC;EAC/BwC,kCAAkC,CAAC,IAAI,EAAE5C,IAAI,CAAC;AAChD;AAEO,SAAS2D,YAAYA,CAAA,EAAgB;EAC1C,IAAI,CAACrC,IAAI,CAAC,KAAK,CAAC;AAClB;AACO,SAASsC,eAAeA,CAAA,EAAgB;EAC7C,IAAI,CAACtC,IAAI,CAAC,QAAQ,CAAC;AACrB;AACO,SAASuC,gBAAgBA,CAAA,EAAgB;EAC9C,IAAI,CAACvC,IAAI,CAAC,SAAS,CAAC;AACtB;AACO,SAASwC,eAAeA,CAAA,EAAgB;EAC7C,IAAI,CAACxC,IAAI,CAAC,QAAQ,CAAC;AACrB;AACO,SAASyC,eAAeA,CAAA,EAAgB;EAC7C,IAAI,CAACzC,IAAI,CAAC,QAAQ,CAAC;AACrB;AACO,SAAS0C,gBAAgBA,CAAA,EAAgB;EAC9C,IAAI,CAAC1C,IAAI,CAAC,SAAS,CAAC;AACtB;AACO,SAAS2C,eAAeA,CAAA,EAAgB;EAC7C,IAAI,CAAC3C,IAAI,CAAC,QAAQ,CAAC;AACrB;AACO,SAAS4C,eAAeA,CAAA,EAAgB;EAC7C,IAAI,CAAC5C,IAAI,CAAC,QAAQ,CAAC;AACrB;AACO,SAAS6C,aAAaA,CAAA,EAAgB;EAC3C,IAAI,CAAC7C,IAAI,CAAC,MAAM,CAAC;AACnB;AACO,SAAS8C,kBAAkBA,CAAA,EAAgB;EAChD,IAAI,CAAC9C,IAAI,CAAC,WAAW,CAAC;AACxB;AACO,SAAS+C,aAAaA,CAAA,EAAgB;EAC3C,IAAI,CAAC/C,IAAI,CAAC,MAAM,CAAC;AACnB;AACO,SAASgD,cAAcA,CAAA,EAAgB;EAC5C,IAAI,CAAChD,IAAI,CAAC,OAAO,CAAC;AACpB;AACO,SAASiD,kBAAkBA,CAAA,EAAgB;EAChD,IAAI,CAACjD,IAAI,CAAC,WAAW,CAAC;AACxB;AAEO,SAASkD,UAAUA,CAAA,EAAgB;EACxC,IAAI,CAAClD,IAAI,CAAC,MAAM,CAAC;AACnB;AAEO,SAASmD,cAAcA,CAAgBzE,IAAsB,EAAE;EACpE,IAAI,CAAC0E,gCAAgC,CAAC1E,IAAI,CAAC;AAC7C;AAEO,SAAS2E,iBAAiBA,CAAgB3E,IAAyB,EAAE;EAC1E,IAAIA,IAAI,CAAC4E,QAAQ,EAAE;IACjB,IAAI,CAACtD,IAAI,CAAC,UAAU,CAAC;IACrB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACd;EACA,IAAI,CAACiB,IAAI,CAAC,KAAK,CAAC;EAChB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACZ,IAAI,CAACqE,gCAAgC,CAAC1E,IAAI,CAAC;AAC7C;AAEO,SAAS0E,gCAAgCA,CAE9C1E,IAA4C,EAC5C;EACA,MAAM;IAAE6E;EAAe,CAAC,GAAG7E,IAAI;EAC/B,MAAM0D,UAAU,GAIZ1D,IAAI,CAAC0D,UAAU;EACnB,IAAI,CAACnD,KAAK,CAACsE,cAAc,CAAC;EAC1B,IAAI,CAAC3E,SAAK,GAAI,CAAC;EACf,IAAI,CAACuD,WAAW,CAACC,UAAU,EAAE,GAAG,CAAC;EACjC,IAAI,CAACrD,KAAK,CAAC,CAAC;EACZ,MAAMyE,UAAU,GAIZ9E,IAAI,CAACI,cAAc;EACvB,IAAI,CAACG,KAAK,CAACuE,UAAU,CAAC;AACxB;AAEO,SAASC,eAAeA,CAAgB/E,IAAuB,EAAE;EACtE,MAAMgF,aAAa,GAIfhF,IAAI,CAAC6E,cAAc;EACvB,IAAI,CAACtE,KAAK,CAACP,IAAI,CAACiF,QAAQ,EAAE,CAAC,CAACD,aAAa,CAAC;EAC1C,IAAI,CAACzE,KAAK,CAACyE,aAAa,CAAC;AAC3B;AAEO,SAASE,eAAeA,CAAgBlF,IAAuB,EAAE;EACtE,IAAIA,IAAI,CAACmF,OAAO,EAAE;IAChB,IAAI,CAAC7D,IAAI,CAAC,SAAS,CAAC;IACpB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACd;EACA,IAAI,CAACE,KAAK,CAACP,IAAI,CAACoF,aAAa,CAAC;EAC9B,IAAIpF,IAAI,CAACI,cAAc,EAAE;IACvB,IAAI,CAACC,KAAK,CAAC,CAAC;IACZ,IAAI,CAACiB,IAAI,CAAC,IAAI,CAAC;IACf,IAAI,CAACjB,KAAK,CAAC,CAAC;IACZ,IAAI,CAACE,KAAK,CAACP,IAAI,CAACI,cAAc,CAACA,cAAc,CAAC;EAChD;AACF;AAEO,SAASiF,WAAWA,CAAgBrF,IAAmB,EAAE;EAC9D,IAAI,CAACsB,IAAI,CAAC,QAAQ,CAAC;EACnB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACZ,IAAI,CAACE,KAAK,CAACP,IAAI,CAACsF,QAAQ,CAAC;EAEzB,MAAMN,aAAa,GAIfhF,IAAI,CAAC6E,cAAc;EACvB,IAAIG,aAAa,EAAE;IACjB,IAAI,CAACzE,KAAK,CAACyE,aAAa,CAAC;EAC3B;AACF;AAEO,SAASO,aAAaA,CAAgBvF,IAAqB,EAAE;EAClEwF,WAAW,CAAC,IAAI,EAAExF,IAAI,EAAE,MAAM,IAAI,CAACyF,SAAS,CAACzF,IAAI,CAAC0F,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;AACzE;AAEO,SAASC,WAAWA,CAAgB3F,IAAmB,EAAE;EAC9D,IAAI,CAACO,KAAK,CAACP,IAAI,CAAC4F,WAAW,EAAE,IAAI,CAAC;EAElC,IAAI,CAAC1F,SAAK,GAAI,CAAC;EACf,IAAI,CAACA,SAAK,GAAI,CAAC;AACjB;AAEO,SAAS2F,WAAWA,CAAgB7F,IAAmB,EAAE;EAC9D,IAAI,CAACE,SAAK,GAAI,CAAC;EACf,IAAI,CAACiB,SAAS,CAACnB,IAAI,CAAC8F,YAAY,EAAE,IAAI,CAAC5E,wBAAwB,CAAC,GAAG,CAAC,CAAC;EACrE,IAAI,CAAChB,SAAK,GAAI,CAAC;AACjB;AAEO,SAAS6F,cAAcA,CAAgB/F,IAAsB,EAAE;EACpE,IAAI,CAACO,KAAK,CAACP,IAAI,CAACI,cAAc,CAAC;EAC/B,IAAI,CAACF,SAAK,GAAI,CAAC;AACjB;AAEO,SAAS8F,UAAUA,CAAgBhG,IAAkB,EAAE;EAC5D,IAAI,CAACE,KAAK,CAAC,KAAK,CAAC;EACjB,IAAI,CAACK,KAAK,CAACP,IAAI,CAACI,cAAc,CAAC;AACjC;AAEO,SAAS6F,kBAAkBA,CAAgBjG,IAA0B,EAAE;EAC5E,IAAI,CAACO,KAAK,CAACP,IAAI,CAACkG,KAAK,CAAC;EACtB,IAAIlG,IAAI,CAACM,QAAQ,EAAE,IAAI,CAACJ,SAAK,GAAI,CAAC;EAClC,IAAI,CAACA,SAAK,GAAI,CAAC;EACf,IAAI,CAACG,KAAK,CAAC,CAAC;EACZ,IAAI,CAACE,KAAK,CAACP,IAAI,CAAC4F,WAAW,CAAC;AAC9B;AAEO,SAASO,WAAWA,CAAgBnG,IAAmB,EAAE;EAC9DoG,8BAA8B,CAAC,IAAI,EAAEpG,IAAI,EAAE,GAAG,CAAC;AACjD;AAEO,SAASqG,kBAAkBA,CAAgBrG,IAA0B,EAAE;EAC5EoG,8BAA8B,CAAC,IAAI,EAAEpG,IAAI,EAAE,GAAG,CAAC;AACjD;AAEA,SAASoG,8BAA8BA,CACrCvD,OAAgB,EAChB7C,IAA0C,EAC1CsG,GAAc,EACd;EAAA,IAAAC,iBAAA;EACA,IAAIC,eAAe,GAAG,CAAC;EACvB,KAAAD,iBAAA,GAAI1D,OAAO,CAACjC,QAAQ,aAAhB2F,iBAAA,CAAkBE,YAAY,CAACzG,IAAI,EAAEsG,GAAG,CAAC,EAAE;IAC7CE,eAAe,GAAG,CAAC;IACnB3D,OAAO,CAAC3C,KAAK,CAACoG,GAAG,CAAC;EACpB;EAEAzD,OAAO,CAAC4C,SAAS,CAACzF,IAAI,CAAC0G,KAAK,EAAEC,SAAS,EAAEA,SAAS,EAAE,UAAUC,CAAC,EAAE;IAC/D,IAAI,CAACvG,KAAK,CAAC,CAAC;IACZ,IAAI,CAACH,KAAK,CAACoG,GAAG,EAAE,IAAI,EAAEM,CAAC,GAAGJ,eAAe,CAAC;IAC1C,IAAI,CAACnG,KAAK,CAAC,CAAC;EACd,CAAC,CAAC;AACJ;AAEO,SAASwG,iBAAiBA,CAAgB7G,IAAyB,EAAE;EAC1E,IAAI,CAACO,KAAK,CAACP,IAAI,CAAC8G,SAAS,CAAC;EAC1B,IAAI,CAACzG,KAAK,CAAC,CAAC;EACZ,IAAI,CAACiB,IAAI,CAAC,SAAS,CAAC;EACpB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACZ,IAAI,CAACE,KAAK,CAACP,IAAI,CAAC+G,WAAW,CAAC;EAC5B,IAAI,CAAC1G,KAAK,CAAC,CAAC;EACZ,IAAI,CAACH,SAAK,GAAI,CAAC;EACf,IAAI,CAACG,KAAK,CAAC,CAAC;EACZ,IAAI,CAACE,KAAK,CAACP,IAAI,CAACgH,QAAQ,CAAC;EACzB,IAAI,CAAC3G,KAAK,CAAC,CAAC;EACZ,IAAI,CAACH,SAAK,GAAI,CAAC;EACf,IAAI,CAACG,KAAK,CAAC,CAAC;EACZ,IAAI,CAACE,KAAK,CAACP,IAAI,CAACiH,SAAS,CAAC;AAC5B;AAEO,SAASC,WAAWA,CAAgBlH,IAAmB,EAAE;EAC9D,IAAI,CAACsB,IAAI,CAAC,OAAO,CAAC;EAClB,IAAI,CAACf,KAAK,CAACP,IAAI,CAACmH,aAAa,CAAC;AAChC;AAEO,SAASC,mBAAmBA,CAEjCpH,IAA2B,EAC3B;EACA,IAAI,CAACE,SAAK,GAAI,CAAC;EACf,IAAI,CAACK,KAAK,CAACP,IAAI,CAACI,cAAc,CAAC;EAC/B,IAAI,CAACF,SAAK,GAAI,CAAC;AACjB;AAEO,SAASmH,cAAcA,CAAgBrH,IAAsB,EAAE;EACpE,IAAI,CAACsB,IAAI,CAACtB,IAAI,CAACsH,QAAQ,CAAC;EACxB,IAAI,CAACjH,KAAK,CAAC,CAAC;EACZ,IAAI,CAACE,KAAK,CAACP,IAAI,CAACI,cAAc,CAAC;AACjC;AAEO,SAASmH,mBAAmBA,CAEjCvH,IAA2B,EAC3B;EACA,IAAI,CAACO,KAAK,CAACP,IAAI,CAACwH,UAAU,EAAE,IAAI,CAAC;EACjC,IAAI,CAACtH,SAAK,GAAI,CAAC;EACf,IAAI,CAACK,KAAK,CAACP,IAAI,CAACyH,SAAS,CAAC;EAC1B,IAAI,CAACvH,SAAK,GAAI,CAAC;AACjB;AAEO,SAASwH,YAAYA,CAAgB1H,IAAoB,EAAE;EAChE,MAAM;IAAE2H,QAAQ;IAAErH,QAAQ;IAAEwB,QAAQ;IAAE1B;EAAe,CAAC,GAAGJ,IAAI;EAC7D,IAAI,CAACE,SAAK,IAAI,CAAC;EACf,MAAM0H,IAAI,GAAG,IAAI,CAACC,cAAc,CAAC,CAAC;EAClC,IAAI,CAACxH,KAAK,CAAC,CAAC;EACZ,IAAIyB,QAAQ,EAAE;IACZgG,gBAAgB,CAAC,IAAI,EAAEhG,QAAQ,CAAC;IAChC,IAAI,CAACR,IAAI,CAAC,UAAU,CAAC;IACrB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACd;EAEA,IAAI,CAACH,SAAK,GAAI,CAAC;EAIR;IAEL,IAAI,CAACoB,IAAI,CAACtB,IAAI,CAACmH,aAAa,CAAC1F,IAAI,CAAC;EACpC;EAEA,IAAI,CAACpB,KAAK,CAAC,CAAC;EACZ,IAAI,CAACiB,IAAI,CAAC,IAAI,CAAC;EACf,IAAI,CAACjB,KAAK,CAAC,CAAC;EAIL;IAEL,IAAI,CAACE,KAAK,CAACP,IAAI,CAACmH,aAAa,CAACzF,UAAU,CAAC;EAC3C;EAEA,IAAIiG,QAAQ,EAAE;IACZ,IAAI,CAACtH,KAAK,CAAC,CAAC;IACZ,IAAI,CAACiB,IAAI,CAAC,IAAI,CAAC;IACf,IAAI,CAACjB,KAAK,CAAC,CAAC;IACZ,IAAI,CAACE,KAAK,CAACoH,QAAQ,CAAC;EACtB;EAEA,IAAI,CAACzH,SAAK,GAAI,CAAC;EAEf,IAAII,QAAQ,EAAE;IACZwH,gBAAgB,CAAC,IAAI,EAAExH,QAAQ,CAAC;IAChC,IAAI,CAACJ,SAAK,GAAI,CAAC;EACjB;EAEA,IAAIE,cAAc,EAAE;IAClB,IAAI,CAACF,SAAK,GAAI,CAAC;IACf,IAAI,CAACG,KAAK,CAAC,CAAC;IACZ,IAAI,CAACE,KAAK,CAACH,cAAc,CAAC;EAC5B;EACA,IAAI,CAACC,KAAK,CAAC,CAAC;EACZuH,IAAI,CAAC,CAAC;EACN,IAAI,CAAC1H,SAAK,IAAI,CAAC;AACjB;AAEA,SAAS4H,gBAAgBA,CAACC,IAAa,EAAEC,GAAqB,EAAE;EAC9D,IAAIA,GAAG,KAAK,IAAI,EAAE;IAChBD,IAAI,CAAC7H,KAAK,CAAC8H,GAAG,CAAC;EACjB;AACF;AAEO,SAASC,qBAAqBA,CAEnCjI,IAA6B,EAC7B;EACA,IAAI,CAACkI,cAAc,CAAClI,IAAI,EAAEA,IAAI,CAAC0G,KAAK,CAAC;AACvC;AAEO,SAASyB,aAAaA,CAAgBnI,IAAqB,EAAE;EAClE,IAAI,CAACO,KAAK,CAACP,IAAI,CAACoI,OAAO,CAAC;AAC1B;AAEO,SAASC,iBAAiBA,CAG/BrI,IAGC,EACD;EACA,IAAI,CAACO,KAAK,CAACP,IAAI,CAACsI,UAAU,CAAC;EAC3B,IAAI,CAAC/H,KAAK,CAACP,IAAI,CAACgF,aAAa,CAAC;AAChC;AAIO,SAASuD,sBAAsBA,CAEpCvI,IAA8B,EAC9B;EACA,MAAM;IAAEkC,OAAO;IAAEsG,EAAE;IAAE3D,cAAc;IAAE4D,OAAO,EAAEC,OAAO;IAAEC;EAAK,CAAC,GAAG3I,IAAI;EACpE,IAAIkC,OAAO,EAAE;IACX,IAAI,CAACZ,IAAI,CAAC,SAAS,CAAC;IACpB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACd;EACA,IAAI,CAACiB,IAAI,CAAC,WAAW,CAAC;EACtB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACZ,IAAI,CAACE,KAAK,CAACiI,EAAE,CAAC;EACd,IAAI,CAACjI,KAAK,CAACsE,cAAc,CAAC;EAC1B,IAAI6D,OAAO,YAAPA,OAAO,CAAE/H,MAAM,EAAE;IACnB,IAAI,CAACN,KAAK,CAAC,CAAC;IACZ,IAAI,CAACiB,IAAI,CAAC,SAAS,CAAC;IACpB,IAAI,CAACjB,KAAK,CAAC,CAAC;IACZ,IAAI,CAACc,SAAS,CAACuH,OAAO,CAAC;EACzB;EACA,IAAI,CAACrI,KAAK,CAAC,CAAC;EACZ,IAAI,CAACE,KAAK,CAACoI,IAAI,CAAC;AAClB;AAEO,SAASC,eAAeA,CAAgB5I,IAAuB,EAAE;EACtEwF,WAAW,CAAC,IAAI,EAAExF,IAAI,EAAE,MAAM,IAAI,CAACyF,SAAS,CAACzF,IAAI,CAAC2I,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;AACtE;AAEO,SAASE,sBAAsBA,CAEpC7I,IAA8B,EAC9B;EACA,MAAM;IAAEkC,OAAO;IAAEsG,EAAE;IAAE3D,cAAc;IAAEzE;EAAe,CAAC,GAAGJ,IAAI;EAC5D,IAAIkC,OAAO,EAAE;IACX,IAAI,CAACZ,IAAI,CAAC,SAAS,CAAC;IACpB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACd;EACA,IAAI,CAACiB,IAAI,CAAC,MAAM,CAAC;EACjB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACZ,IAAI,CAACE,KAAK,CAACiI,EAAE,CAAC;EACd,IAAI,CAACjI,KAAK,CAACsE,cAAc,CAAC;EAC1B,IAAI,CAACxE,KAAK,CAAC,CAAC;EACZ,IAAI,CAACH,SAAK,GAAI,CAAC;EACf,IAAI,CAACG,KAAK,CAAC,CAAC;EACZ,IAAI,CAACE,KAAK,CAACH,cAAc,CAAC;EAC1B,IAAI,CAACgC,SAAS,CAAC,CAAC;AAClB;AAEA,SAAS0G,gBAAgBA,CAEvB9I,IAAgD,EAChD;EACA,MAAM;IAAEG,IAAI;IAAEmI,UAAU;IAAElI;EAAe,CAAC,GAAGJ,IAAI;EACjD,IAAI,CAACO,KAAK,CAAC+H,UAAU,EAAE,IAAI,CAAC;EAC5B,IAAI,CAACjI,KAAK,CAAC,CAAC;EACZ,IAAI,CAACiB,IAAI,CAACnB,IAAI,KAAK,gBAAgB,GAAG,IAAI,GAAG,WAAW,CAAC;EACzD,IAAI,CAACE,KAAK,CAAC,CAAC;EACZ,IAAI,CAACE,KAAK,CAACH,cAAc,CAAC;AAC5B;AAOO,SAAS2I,eAAeA,CAAgB/I,IAAuB,EAAE;EACtE,MAAM;IAAEI,cAAc;IAAEkI;EAAW,CAAC,GAAGtI,IAAI;EAC3C,IAAI,CAACE,SAAK,GAAI,CAAC;EACf,IAAI,CAACK,KAAK,CAACH,cAAc,CAAC;EAC1B,IAAI,CAACF,SAAK,GAAI,CAAC;EACf,IAAI,CAACG,KAAK,CAAC,CAAC;EACZ,IAAI,CAACE,KAAK,CAAC+H,UAAU,CAAC;AACxB;AAEO,SAASU,yBAAyBA,CAEvChJ,IAAiC,EACjC;EACA,IAAI,CAACO,KAAK,CAACP,IAAI,CAACsI,UAAU,CAAC;EAIpB;IAEL,IAAI,CAAC/H,KAAK,CAACP,IAAI,CAAC6E,cAAc,CAAC;EACjC;AACF;AAEO,SAASoE,iBAAiBA,CAAgBjJ,IAAyB,EAAE;EAC1E,MAAM;IAAEkC,OAAO;IAAEb,KAAK,EAAE6H,OAAO;IAAEV;EAAG,CAAC,GAAGxI,IAAI;EAC5C,IAAIkC,OAAO,EAAE;IACX,IAAI,CAACZ,IAAI,CAAC,SAAS,CAAC;IACpB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACd;EACA,IAAI6I,OAAO,EAAE;IACX,IAAI,CAAC5H,IAAI,CAAC,OAAO,CAAC;IAClB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACd;EACA,IAAI,CAACiB,IAAI,CAAC,MAAM,CAAC;EACjB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACZ,IAAI,CAACE,KAAK,CAACiI,EAAE,CAAC;EACd,IAAI,CAACnI,KAAK,CAAC,CAAC;EAKL;IAEL8I,UAAU,CAACC,IAAI,CAAC,IAAI,EAAEpJ,IAA+B,CAAC;EACxD;AACF;AAEO,SAASmJ,UAAUA,CAAgBnJ,IAAkB,EAAE;EAC5DwF,WAAW,CAAC,IAAI,EAAExF,IAAI,EAAE;IAAA,IAAAqJ,qBAAA;IAAA,OACtB,IAAI,CAAClI,SAAS,CACZnB,IAAI,CAAC0F,OAAO,GAAA2D,qBAAA,GACZ,IAAI,CAACnI,wBAAwB,CAAC,GAAG,CAAC,YAAAmI,qBAAA,GACQ,IAAI,EAC9C,IAAI,EACJ,IACF,CAAC;EAAA,CACH,CAAC;AACH;AAEO,SAASC,YAAYA,CAAgBtJ,IAAoB,EAAE;EAChE,MAAM;IAAEwI,EAAE;IAAEe;EAAY,CAAC,GAAGvJ,IAAI;EAChC,IAAI,CAACO,KAAK,CAACiI,EAAE,CAAC;EACd,IAAIe,WAAW,EAAE;IACf,IAAI,CAAClJ,KAAK,CAAC,CAAC;IACZ,IAAI,CAACH,SAAK,GAAI,CAAC;IACf,IAAI,CAACG,KAAK,CAAC,CAAC;IACZ,IAAI,CAACE,KAAK,CAACgJ,WAAW,CAAC;EACzB;AACF;AAEO,SAASC,mBAAmBA,CAEjCxJ,IAA2B,EAC3B;EACA,MAAM;IAAEkC,OAAO;IAAEsG,EAAE;IAAEnF;EAAK,CAAC,GAAGrD,IAAI;EAElC,IAAIkC,OAAO,EAAE;IACX,IAAI,CAACZ,IAAI,CAAC,SAAS,CAAC;IACpB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACd;EAeO;IAEL,IAAI,CAACL,IAAI,CAACyJ,MAAM,EAAE;MAChB,IAAI,CAACnI,IAAI,CAAC+B,IAAI,WAAJA,IAAI,GAAKmF,EAAE,CAACrI,IAAI,KAAK,YAAY,GAAG,WAAW,GAAG,QAAS,CAAC;MACtE,IAAI,CAACE,KAAK,CAAC,CAAC;IACd;IAEA,IAAI,CAACE,KAAK,CAACiI,EAAE,CAAC;IAEd,IAAI,CAACxI,IAAI,CAAC2I,IAAI,EAAE;MACd,IAAI,CAACvG,SAAS,CAAC,CAAC;MAChB;IACF;IAEA,IAAIuG,IAAI,GAAG3I,IAAI,CAAC2I,IAAI;IAEpB,OAAOA,IAAI,CAACxI,IAAI,KAAK,qBAAqB,EAAE;MAC1C,IAAI,CAACD,SAAK,GAAI,CAAC;MAEf,IAAI,CAACK,KAAK,CAACoI,IAAI,CAACH,EAAE,CAAC;MAEnBG,IAAI,GAAGA,IAAI,CAACA,IAAI;IAClB;IAEA,IAAI,CAACtI,KAAK,CAAC,CAAC;IACZ,IAAI,CAACE,KAAK,CAACoI,IAAI,CAAC;EAClB;AACF;AAEO,SAASe,aAAaA,CAAgB1J,IAAqB,EAAE;EAClEwF,WAAW,CAAC,IAAI,EAAExF,IAAI,EAAE,MAAM,IAAI,CAAC2J,aAAa,CAAC3J,IAAI,CAAC2I,IAAI,EAAE,IAAI,CAAC,CAAC;AACpE;AAEO,SAASiB,YAAYA,CAAgB5J,IAAoB,EAAE;EAChE,MAAM;IAAE6J,QAAQ;IAAEC,SAAS;IAAEC;EAAQ,CAAC,GAAG/J,IAAI;EAC7C,IAAI,CAACsB,IAAI,CAAC,QAAQ,CAAC;EACnB,IAAI,CAACpB,SAAK,GAAI,CAAC;EACf,IAAI,CAACK,KAAK,CAACsJ,QAAQ,CAAC;EACpB,IAAIE,OAAO,EAAE;IACX,IAAI,CAAC7J,SAAK,GAAI,CAAC;IACf,IAAI,CAACK,KAAK,CAACwJ,OAAO,CAAC;EACrB;EACA,IAAI,CAAC7J,SAAK,GAAI,CAAC;EACf,IAAI4J,SAAS,EAAE;IACb,IAAI,CAAC5J,SAAK,GAAI,CAAC;IACf,IAAI,CAACK,KAAK,CAACuJ,SAAS,CAAC;EACvB;EACA,MAAM9E,aAAa,GAIfhF,IAAI,CAAC6E,cAAc;EACvB,IAAIG,aAAa,EAAE;IACjB,IAAI,CAACzE,KAAK,CAACyE,aAAa,CAAC;EAC3B;AACF;AAEO,SAASgF,yBAAyBA,CAEvChK,IAAiC,EACjC;EACA,MAAM;IAAEwI,EAAE;IAAEyB;EAAgB,CAAC,GAAGjK,IAAI;EACpC,IAGEA,IAAI,CAACkK,QAAQ,EACb;IACA,IAAI,CAAC5I,IAAI,CAAC,QAAQ,CAAC;IACnB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACd;EACA,IAAI,CAACiB,IAAI,CAAC,QAAQ,CAAC;EACnB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACZ,IAAI,CAACE,KAAK,CAACiI,EAAE,CAAC;EACd,IAAI,CAACnI,KAAK,CAAC,CAAC;EACZ,IAAI,CAACH,SAAK,GAAI,CAAC;EACf,IAAI,CAACG,KAAK,CAAC,CAAC;EACZ,IAAI,CAACE,KAAK,CAAC0J,eAAe,CAAC;EAC3B,IAAI,CAAC7H,SAAS,CAAC,CAAC;AAClB;AAEO,SAAS+H,yBAAyBA,CAEvCnK,IAAiC,EACjC;EACA,IAAI,CAACE,KAAK,CAAC,UAAU,CAAC;EACtB,IAAI,CAACK,KAAK,CAACP,IAAI,CAACsI,UAAU,CAAC;EAC3B,IAAI,CAACpI,SAAK,GAAI,CAAC;AACjB;AAEO,SAASkK,mBAAmBA,CAEjCpK,IAA2B,EAC3B;EACA,IAAI,CAACO,KAAK,CAACP,IAAI,CAACsI,UAAU,CAAC;EAC3B,IAAI,CAACpI,SAAK,GAAI,CAAC;AACjB;AAEO,SAASmK,kBAAkBA,CAAgBrK,IAA0B,EAAE;EAC5E,IAAI,CAACsB,IAAI,CAAC,QAAQ,CAAC;EACnB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACZ,IAAI,CAACH,SAAK,GAAI,CAAC;EACf,IAAI,CAACG,KAAK,CAAC,CAAC;EACZ,IAAI,CAACE,KAAK,CAACP,IAAI,CAACsI,UAAU,CAAC;EAC3B,IAAI,CAAClG,SAAS,CAAC,CAAC;AAClB;AAEO,SAASkI,4BAA4BA,CAE1CtK,IAAoC,EACpC;EACA,IAAI,CAACsB,IAAI,CAAC,QAAQ,CAAC;EACnB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACZ,IAAI,CAACiB,IAAI,CAAC,IAAI,CAAC;EACf,IAAI,CAACjB,KAAK,CAAC,CAAC;EACZ,IAAI,CAACiB,IAAI,CAAC,WAAW,CAAC;EACtB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACZ,IAAI,CAACE,KAAK,CAACP,IAAI,CAACwI,EAAE,CAAC;EACnB,IAAI,CAACpG,SAAS,CAAC,CAAC;AAClB;AAEO,SAASO,+BAA+BA,CAAgB3C,IAAS,EAAE;EACxE,MAAM;IAAE6E;EAAe,CAAC,GAAG7E,IAAI;EAC/B,MAAM0D,UAAU,GAEZ1D,IAAI,CAAC0D,UAAU;EACnB,IAAI,CAACnD,KAAK,CAACsE,cAAc,CAAC;EAC1B,IAAI,CAAC3E,SAAK,GAAI,CAAC;EACf,IAAI,CAACuD,WAAW,CAACC,UAAU,EAAE,GAAG,CAAC;EACjC,MAAMoB,UAAU,GAEZ9E,IAAI,CAACI,cAAc;EACvB,IAAI,CAACG,KAAK,CAACuE,UAAU,CAAC;AACxB;AAEO,SAASyF,2BAA2BA,CAEzCvK,IAMqB,EACrB;EACA,MAAMwK,cAAc,GAAGxK,IAAI,CAACG,IAAI,KAAK,sBAAsB;EAC3D,MAAMsK,aAAa,GACjBzK,IAAI,CAACG,IAAI,KAAK,uBAAuB,IAAIH,IAAI,CAACG,IAAI,KAAK,eAAe;EACxEuK,kBAAkB,CAAC,IAAI,EAAE1K,IAAI,EAAE,CAC7ByK,aAAa,IAAIzK,IAAI,CAACkC,OAAO,IAAI,SAAS,EAC1C,CAACsI,cAAc,IAAIxK,IAAI,CAAC6B,aAAa,CACtC,CAAC;EACF,IAAI7B,IAAI,CAACuD,MAAM,EAAE;IACf,IAAI,CAACjC,IAAI,CAAC,QAAQ,CAAC;IACnB,IAAI,CAACjB,KAAK,CAAC,CAAC;EACd;EACAqK,kBAAkB,CAAC,IAAI,EAAE1K,IAAI,EAAE,CAC7B,CAACwK,cAAc,IAAIxK,IAAI,CAAC4E,QAAQ,IAAI,UAAU,EAC9C,CAAC4F,cAAc,IAAIxK,IAAI,CAAC2K,QAAQ,IAAI,UAAU,EAC9C,CAACF,aAAa,IAAID,cAAc,KAAKxK,IAAI,CAAC8B,QAAQ,IAAI,UAAU,CACjE,CAAC;AACJ;AAEA,SAAS0D,WAAWA,CAAC3C,OAAgB,EAAE7C,IAAY,EAAE4K,EAAc,EAAE;EACnE/H,OAAO,CAAC3C,KAAK,CAAC,GAAG,CAAC;EAClB,MAAM0H,IAAI,GAAG/E,OAAO,CAACgF,cAAc,CAAC,CAAC;EACrC+C,EAAE,CAAC,CAAC;EACJhD,IAAI,CAAC,CAAC;EACN/E,OAAO,CAACgI,UAAU,CAAC7K,IAAI,CAAC;AAC1B;AAEA,SAAS0K,kBAAkBA,CACzB7H,OAAgB,EAChB7C,IAAY,EACZ8K,SAAoC,EACpC;EAAA,IAAAC,kBAAA;EACA,MAAMC,YAAY,GAAG,IAAIC,GAAG,CAAS,CAAC;EACtC,KAAK,MAAMC,QAAQ,IAAIJ,SAAS,EAAE;IAChC,IAAII,QAAQ,EAAEF,YAAY,CAACG,GAAG,CAACD,QAAQ,CAAC;EAC1C;EAEA,CAAAH,kBAAA,GAAAlI,OAAO,CAACjC,QAAQ,aAAhBmK,kBAAA,CAAkBhK,IAAI,CAACf,IAAI,EAAEgI,GAAG,IAAI;IAClC,IAAIgD,YAAY,CAACI,GAAG,CAACpD,GAAG,CAACqD,KAAK,CAAC,EAAE;MAC/BxI,OAAO,CAAC3C,KAAK,CAAC8H,GAAG,CAACqD,KAAK,CAAC;MACxBxI,OAAO,CAACxC,KAAK,CAAC,CAAC;MACf2K,YAAY,CAACM,MAAM,CAACtD,GAAG,CAACqD,KAAK,CAAC;MAC9B,OAAOL,YAAY,CAACO,IAAI,KAAK,CAAC;IAChC;EACF,CAAC,CAAC;EAEF,KAAK,MAAML,QAAQ,IAAIF,YAAY,EAAE;IACnCnI,OAAO,CAACvB,IAAI,CAAC4J,QAAQ,CAAC;IACtBrI,OAAO,CAACxC,KAAK,CAAC,CAAC;EACjB;AACF","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/index.js new file mode 100644 index 0000000000000000000000000000000000000000..2e32510b89b4b1836ddcc1e4fd0bdf4297a43299 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/index.js @@ -0,0 +1,112 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; +exports.generate = generate; +var _sourceMap = require("./source-map.js"); +var _printer = require("./printer.js"); +function normalizeOptions(code, opts, ast) { + if (opts.experimental_preserveFormat) { + if (typeof code !== "string") { + throw new Error("`experimental_preserveFormat` requires the original `code` to be passed to @babel/generator as a string"); + } + if (!opts.retainLines) { + throw new Error("`experimental_preserveFormat` requires `retainLines` to be set to `true`"); + } + if (opts.compact && opts.compact !== "auto") { + throw new Error("`experimental_preserveFormat` is not compatible with the `compact` option"); + } + if (opts.minified) { + throw new Error("`experimental_preserveFormat` is not compatible with the `minified` option"); + } + if (opts.jsescOption) { + throw new Error("`experimental_preserveFormat` is not compatible with the `jsescOption` option"); + } + if (!Array.isArray(ast.tokens)) { + throw new Error("`experimental_preserveFormat` requires the AST to have attached the token of the input code. Make sure to enable the `tokens: true` parser option."); + } + } + const format = { + auxiliaryCommentBefore: opts.auxiliaryCommentBefore, + auxiliaryCommentAfter: opts.auxiliaryCommentAfter, + shouldPrintComment: opts.shouldPrintComment, + preserveFormat: opts.experimental_preserveFormat, + retainLines: opts.retainLines, + retainFunctionParens: opts.retainFunctionParens, + comments: opts.comments == null || opts.comments, + compact: opts.compact, + minified: opts.minified, + concise: opts.concise, + indent: { + adjustMultilineComment: true, + style: " " + }, + jsescOption: Object.assign({ + quotes: "double", + wrap: true, + minimal: false + }, opts.jsescOption), + topicToken: opts.topicToken, + importAttributesKeyword: opts.importAttributesKeyword + }; + { + var _opts$recordAndTupleS; + format.decoratorsBeforeExport = opts.decoratorsBeforeExport; + format.jsescOption.json = opts.jsonCompatibleStrings; + format.recordAndTupleSyntaxType = (_opts$recordAndTupleS = opts.recordAndTupleSyntaxType) != null ? _opts$recordAndTupleS : "hash"; + } + if (format.minified) { + format.compact = true; + format.shouldPrintComment = format.shouldPrintComment || (() => format.comments); + } else { + format.shouldPrintComment = format.shouldPrintComment || (value => format.comments || value.includes("@license") || value.includes("@preserve")); + } + if (format.compact === "auto") { + format.compact = typeof code === "string" && code.length > 500000; + if (format.compact) { + console.error("[BABEL] Note: The code generator has deoptimised the styling of " + `${opts.filename} as it exceeds the max of ${"500KB"}.`); + } + } + if (format.compact || format.preserveFormat) { + format.indent.adjustMultilineComment = false; + } + const { + auxiliaryCommentBefore, + auxiliaryCommentAfter, + shouldPrintComment + } = format; + if (auxiliaryCommentBefore && !shouldPrintComment(auxiliaryCommentBefore)) { + format.auxiliaryCommentBefore = undefined; + } + if (auxiliaryCommentAfter && !shouldPrintComment(auxiliaryCommentAfter)) { + format.auxiliaryCommentAfter = undefined; + } + return format; +} +{ + exports.CodeGenerator = class CodeGenerator { + constructor(ast, opts = {}, code) { + this._ast = void 0; + this._format = void 0; + this._map = void 0; + this._ast = ast; + this._format = normalizeOptions(code, opts, ast); + this._map = opts.sourceMaps ? new _sourceMap.default(opts, code) : null; + } + generate() { + const printer = new _printer.default(this._format, this._map); + return printer.generate(this._ast); + } + }; +} +function generate(ast, opts = {}, code) { + const format = normalizeOptions(code, opts, ast); + const map = opts.sourceMaps ? new _sourceMap.default(opts, code) : null; + const printer = new _printer.default(format, map, ast.tokens, typeof code === "string" ? code : null); + return printer.generate(ast); +} +var _default = exports.default = generate; + +//# sourceMappingURL=index.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/index.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/index.js.map new file mode 100644 index 0000000000000000000000000000000000000000..32a9492819ffe6f555b467a6ad062a2beb70e29d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/index.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_sourceMap","require","_printer","normalizeOptions","code","opts","ast","experimental_preserveFormat","Error","retainLines","compact","minified","jsescOption","Array","isArray","tokens","format","auxiliaryCommentBefore","auxiliaryCommentAfter","shouldPrintComment","preserveFormat","retainFunctionParens","comments","concise","indent","adjustMultilineComment","style","Object","assign","quotes","wrap","minimal","topicToken","importAttributesKeyword","_opts$recordAndTupleS","decoratorsBeforeExport","json","jsonCompatibleStrings","recordAndTupleSyntaxType","value","includes","length","console","error","filename","undefined","exports","CodeGenerator","constructor","_ast","_format","_map","sourceMaps","SourceMap","generate","printer","Printer","map","_default","default"],"sources":["../src/index.ts"],"sourcesContent":["import SourceMap from \"./source-map.ts\";\nimport Printer from \"./printer.ts\";\nimport type * as t from \"@babel/types\";\nimport type { Opts as jsescOptions } from \"jsesc\";\nimport type { Format } from \"./printer.ts\";\nimport type {\n EncodedSourceMap,\n DecodedSourceMap,\n Mapping,\n} from \"@jridgewell/gen-mapping\";\n\n/**\n * Normalize generator options, setting defaults.\n *\n * - Detects code indentation.\n * - If `opts.compact = \"auto\"` and the code is over 500KB, `compact` will be set to `true`.\n */\n\nfunction normalizeOptions(\n code: string | { [filename: string]: string },\n opts: GeneratorOptions,\n ast: t.Node,\n): Format {\n if (opts.experimental_preserveFormat) {\n if (typeof code !== \"string\") {\n throw new Error(\n \"`experimental_preserveFormat` requires the original `code` to be passed to @babel/generator as a string\",\n );\n }\n if (!opts.retainLines) {\n throw new Error(\n \"`experimental_preserveFormat` requires `retainLines` to be set to `true`\",\n );\n }\n if (opts.compact && opts.compact !== \"auto\") {\n throw new Error(\n \"`experimental_preserveFormat` is not compatible with the `compact` option\",\n );\n }\n if (opts.minified) {\n throw new Error(\n \"`experimental_preserveFormat` is not compatible with the `minified` option\",\n );\n }\n if (opts.jsescOption) {\n throw new Error(\n \"`experimental_preserveFormat` is not compatible with the `jsescOption` option\",\n );\n }\n if (!Array.isArray((ast as any).tokens)) {\n throw new Error(\n \"`experimental_preserveFormat` requires the AST to have attached the token of the input code. Make sure to enable the `tokens: true` parser option.\",\n );\n }\n }\n\n const format: Format = {\n auxiliaryCommentBefore: opts.auxiliaryCommentBefore,\n auxiliaryCommentAfter: opts.auxiliaryCommentAfter,\n shouldPrintComment: opts.shouldPrintComment,\n preserveFormat: opts.experimental_preserveFormat,\n retainLines: opts.retainLines,\n retainFunctionParens: opts.retainFunctionParens,\n comments: opts.comments == null || opts.comments,\n compact: opts.compact,\n minified: opts.minified,\n concise: opts.concise,\n indent: {\n adjustMultilineComment: true,\n style: \" \",\n },\n jsescOption: {\n quotes: \"double\",\n wrap: true,\n minimal: process.env.BABEL_8_BREAKING ? true : false,\n ...opts.jsescOption,\n },\n topicToken: opts.topicToken,\n importAttributesKeyword: opts.importAttributesKeyword,\n };\n\n if (!process.env.BABEL_8_BREAKING) {\n format.decoratorsBeforeExport = opts.decoratorsBeforeExport;\n format.jsescOption.json = opts.jsonCompatibleStrings;\n format.recordAndTupleSyntaxType = opts.recordAndTupleSyntaxType ?? \"hash\";\n }\n\n if (format.minified) {\n format.compact = true;\n\n format.shouldPrintComment =\n format.shouldPrintComment || (() => format.comments);\n } else {\n format.shouldPrintComment =\n format.shouldPrintComment ||\n (value =>\n format.comments ||\n value.includes(\"@license\") ||\n value.includes(\"@preserve\"));\n }\n\n if (format.compact === \"auto\") {\n format.compact = typeof code === \"string\" && code.length > 500_000; // 500KB\n\n if (format.compact) {\n console.error(\n \"[BABEL] Note: The code generator has deoptimised the styling of \" +\n `${opts.filename} as it exceeds the max of ${\"500KB\"}.`,\n );\n }\n }\n\n if (format.compact || format.preserveFormat) {\n format.indent.adjustMultilineComment = false;\n }\n\n const { auxiliaryCommentBefore, auxiliaryCommentAfter, shouldPrintComment } =\n format;\n\n if (auxiliaryCommentBefore && !shouldPrintComment(auxiliaryCommentBefore)) {\n format.auxiliaryCommentBefore = undefined;\n }\n if (auxiliaryCommentAfter && !shouldPrintComment(auxiliaryCommentAfter)) {\n format.auxiliaryCommentAfter = undefined;\n }\n\n return format;\n}\n\nexport interface GeneratorOptions {\n /**\n * Optional string to add as a block comment at the start of the output file.\n */\n auxiliaryCommentBefore?: string;\n\n /**\n * Optional string to add as a block comment at the end of the output file.\n */\n auxiliaryCommentAfter?: string;\n\n /**\n * Function that takes a comment (as a string) and returns true if the comment should be included in the output.\n * By default, comments are included if `opts.comments` is `true` or if `opts.minified` is `false` and the comment\n * contains `@preserve` or `@license`.\n */\n shouldPrintComment?(comment: string): boolean;\n\n /**\n * Preserve the input code format while printing the transformed code.\n * This is experimental, and may have breaking changes in future\n * patch releases. It will be removed in a future minor release,\n * when it will graduate to stable.\n */\n experimental_preserveFormat?: boolean;\n\n /**\n * Attempt to use the same line numbers in the output code as in the source code (helps preserve stack traces).\n * Defaults to `false`.\n */\n retainLines?: boolean;\n\n /**\n * Retain parens around function expressions (could be used to change engine parsing behavior)\n * Defaults to `false`.\n */\n retainFunctionParens?: boolean;\n\n /**\n * Should comments be included in output? Defaults to `true`.\n */\n comments?: boolean;\n\n /**\n * Set to true to avoid adding whitespace for formatting. Defaults to the value of `opts.minified`.\n */\n compact?: boolean | \"auto\";\n\n /**\n * Should the output be minified. Defaults to `false`.\n */\n minified?: boolean;\n\n /**\n * Set to true to reduce whitespace (but not as much as opts.compact). Defaults to `false`.\n */\n concise?: boolean;\n\n /**\n * Used in warning messages\n */\n filename?: string;\n\n /**\n * Enable generating source maps. Defaults to `false`.\n */\n sourceMaps?: boolean;\n\n inputSourceMap?: any;\n\n /**\n * A root for all relative URLs in the source map.\n */\n sourceRoot?: string;\n\n /**\n * The filename for the source code (i.e. the code in the `code` argument).\n * This will only be used if `code` is a string.\n */\n sourceFileName?: string;\n\n /**\n * Set to true to run jsesc with \"json\": true to print \"\\u00A9\" vs. \"©\";\n * @deprecated use `jsescOptions: { json: true }` instead\n */\n jsonCompatibleStrings?: boolean;\n\n /**\n * Set to true to enable support for experimental decorators syntax before\n * module exports. If not specified, decorators will be printed in the same\n * position as they were in the input source code.\n * @deprecated Removed in Babel 8\n */\n decoratorsBeforeExport?: boolean;\n\n /**\n * Options for outputting jsesc representation.\n */\n jsescOption?: jsescOptions;\n\n /**\n * For use with the recordAndTuple token.\n * @deprecated It will be removed in Babel 8.\n */\n recordAndTupleSyntaxType?: \"bar\" | \"hash\";\n\n /**\n * For use with the Hack-style pipe operator.\n * Changes what token is used for pipe bodies’ topic references.\n */\n topicToken?: \"%\" | \"#\" | \"@@\" | \"^^\" | \"^\";\n\n /**\n * The import attributes syntax style:\n * - \"with\" : `import { a } from \"b\" with { type: \"json\" };`\n * - \"assert\" : `import { a } from \"b\" assert { type: \"json\" };`\n * - \"with-legacy\" : `import { a } from \"b\" with type: \"json\";`\n */\n importAttributesKeyword?: \"with\" | \"assert\" | \"with-legacy\";\n}\n\nexport interface GeneratorResult {\n code: string;\n map: EncodedSourceMap | null;\n decodedMap: DecodedSourceMap | undefined;\n rawMappings: Mapping[] | undefined;\n}\n\nif (!process.env.BABEL_8_BREAKING && !USE_ESM) {\n /**\n * We originally exported the Generator class above, but to make it extra clear that it is a private API,\n * we have moved that to an internal class instance and simplified the interface to the two public methods\n * that we wish to support.\n */\n\n // eslint-disable-next-line no-restricted-globals\n exports.CodeGenerator = class CodeGenerator {\n private _ast: t.Node;\n private _format: Format | undefined;\n private _map: SourceMap | null;\n constructor(ast: t.Node, opts: GeneratorOptions = {}, code?: string) {\n this._ast = ast;\n this._format = normalizeOptions(code, opts, ast);\n this._map = opts.sourceMaps ? new SourceMap(opts, code) : null;\n }\n generate(): GeneratorResult {\n const printer = new Printer(this._format, this._map);\n\n return printer.generate(this._ast);\n }\n };\n}\n\n/**\n * Turns an AST into code, maintaining sourcemaps, user preferences, and valid output.\n * @param ast - the abstract syntax tree from which to generate output code.\n * @param opts - used for specifying options for code generation.\n * @param code - the original source code, used for source maps.\n * @returns - an object containing the output code and source map.\n */\nexport function generate(\n ast: t.Node,\n opts: GeneratorOptions = {},\n code?: string | { [filename: string]: string },\n): GeneratorResult {\n const format = normalizeOptions(code, opts, ast);\n const map = opts.sourceMaps ? new SourceMap(opts, code) : null;\n\n const printer = new Printer(\n format,\n map,\n (ast as any).tokens,\n typeof code === \"string\" ? code : null,\n );\n\n return printer.generate(ast);\n}\n\nexport default generate;\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/node/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/node/index.js new file mode 100644 index 0000000000000000000000000000000000000000..d6120627734da23ce41aaafe662d16faf02b31f3 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/node/index.js @@ -0,0 +1,122 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.TokenContext = void 0; +exports.isLastChild = isLastChild; +exports.needsParens = needsParens; +exports.needsWhitespace = needsWhitespace; +exports.needsWhitespaceAfter = needsWhitespaceAfter; +exports.needsWhitespaceBefore = needsWhitespaceBefore; +var whitespace = require("./whitespace.js"); +var parens = require("./parentheses.js"); +var _t = require("@babel/types"); +const { + FLIPPED_ALIAS_KEYS, + VISITOR_KEYS, + isCallExpression, + isDecorator, + isExpressionStatement, + isMemberExpression, + isNewExpression, + isParenthesizedExpression +} = _t; +const TokenContext = exports.TokenContext = { + normal: 0, + expressionStatement: 1, + arrowBody: 2, + exportDefault: 4, + arrowFlowReturnType: 8, + forInitHead: 16, + forInHead: 32, + forOfHead: 64, + forInOrInitHeadAccumulate: 128, + forInOrInitHeadAccumulatePassThroughMask: 128 +}; +function expandAliases(obj) { + const map = new Map(); + function add(type, func) { + const fn = map.get(type); + map.set(type, fn ? function (node, parent, stack, getRawIdentifier) { + var _fn; + return (_fn = fn(node, parent, stack, getRawIdentifier)) != null ? _fn : func(node, parent, stack, getRawIdentifier); + } : func); + } + for (const type of Object.keys(obj)) { + const aliases = FLIPPED_ALIAS_KEYS[type]; + if (aliases) { + for (const alias of aliases) { + add(alias, obj[type]); + } + } else { + add(type, obj[type]); + } + } + return map; +} +const expandedParens = expandAliases(parens); +const expandedWhitespaceNodes = expandAliases(whitespace.nodes); +function isOrHasCallExpression(node) { + if (isCallExpression(node)) { + return true; + } + return isMemberExpression(node) && isOrHasCallExpression(node.object); +} +function needsWhitespace(node, parent, type) { + var _expandedWhitespaceNo; + if (!node) return false; + if (isExpressionStatement(node)) { + node = node.expression; + } + const flag = (_expandedWhitespaceNo = expandedWhitespaceNodes.get(node.type)) == null ? void 0 : _expandedWhitespaceNo(node, parent); + if (typeof flag === "number") { + return (flag & type) !== 0; + } + return false; +} +function needsWhitespaceBefore(node, parent) { + return needsWhitespace(node, parent, 1); +} +function needsWhitespaceAfter(node, parent) { + return needsWhitespace(node, parent, 2); +} +function needsParens(node, parent, tokenContext, getRawIdentifier) { + var _expandedParens$get; + if (!parent) return false; + if (isNewExpression(parent) && parent.callee === node) { + if (isOrHasCallExpression(node)) return true; + } + if (isDecorator(parent)) { + return !isDecoratorMemberExpression(node) && !(isCallExpression(node) && isDecoratorMemberExpression(node.callee)) && !isParenthesizedExpression(node); + } + return (_expandedParens$get = expandedParens.get(node.type)) == null ? void 0 : _expandedParens$get(node, parent, tokenContext, getRawIdentifier); +} +function isDecoratorMemberExpression(node) { + switch (node.type) { + case "Identifier": + return true; + case "MemberExpression": + return !node.computed && node.property.type === "Identifier" && isDecoratorMemberExpression(node.object); + default: + return false; + } +} +function isLastChild(parent, child) { + const visitorKeys = VISITOR_KEYS[parent.type]; + for (let i = visitorKeys.length - 1; i >= 0; i--) { + const val = parent[visitorKeys[i]]; + if (val === child) { + return true; + } else if (Array.isArray(val)) { + let j = val.length - 1; + while (j >= 0 && val[j] === null) j--; + return j >= 0 && val[j] === child; + } else if (val) { + return false; + } + } + return false; +} + +//# sourceMappingURL=index.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/node/index.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/node/index.js.map new file mode 100644 index 0000000000000000000000000000000000000000..2fbb9049638ef4557555fab48cd639a997481c26 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/node/index.js.map @@ -0,0 +1 @@ +{"version":3,"names":["whitespace","require","parens","_t","FLIPPED_ALIAS_KEYS","VISITOR_KEYS","isCallExpression","isDecorator","isExpressionStatement","isMemberExpression","isNewExpression","isParenthesizedExpression","TokenContext","exports","normal","expressionStatement","arrowBody","exportDefault","arrowFlowReturnType","forInitHead","forInHead","forOfHead","forInOrInitHeadAccumulate","forInOrInitHeadAccumulatePassThroughMask","expandAliases","obj","map","Map","add","type","func","fn","get","set","node","parent","stack","getRawIdentifier","_fn","Object","keys","aliases","alias","expandedParens","expandedWhitespaceNodes","nodes","isOrHasCallExpression","object","needsWhitespace","_expandedWhitespaceNo","expression","flag","needsWhitespaceBefore","needsWhitespaceAfter","needsParens","tokenContext","_expandedParens$get","callee","isDecoratorMemberExpression","computed","property","isLastChild","child","visitorKeys","i","length","val","Array","isArray","j"],"sources":["../../src/node/index.ts"],"sourcesContent":["import * as whitespace from \"./whitespace.ts\";\nimport * as parens from \"./parentheses.ts\";\nimport {\n FLIPPED_ALIAS_KEYS,\n VISITOR_KEYS,\n isCallExpression,\n isDecorator,\n isExpressionStatement,\n isMemberExpression,\n isNewExpression,\n isParenthesizedExpression,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\n\nimport type { WhitespaceFlag } from \"./whitespace.ts\";\n\nexport const enum TokenContext {\n normal = 0,\n expressionStatement = 1 << 0,\n arrowBody = 1 << 1,\n exportDefault = 1 << 2,\n arrowFlowReturnType = 1 << 3,\n forInitHead = 1 << 4,\n forInHead = 1 << 5,\n forOfHead = 1 << 6,\n // This flag lives across the token boundary, and will\n // be reset after forIn or forInit head is printed\n forInOrInitHeadAccumulate = 1 << 7,\n forInOrInitHeadAccumulatePassThroughMask = 0x80,\n}\n\ntype NodeHandler = (\n node: t.Node,\n // todo:\n // node: K extends keyof typeof t\n // ? Extract\n // : t.Node,\n parent: t.Node,\n tokenContext?: number,\n getRawIdentifier?: (node: t.Identifier) => string,\n) => R;\n\nexport type NodeHandlers = {\n [K in string]?: NodeHandler;\n};\n\nfunction expandAliases(obj: NodeHandlers) {\n const map = new Map>();\n\n function add(type: string, func: NodeHandler) {\n const fn = map.get(type);\n map.set(\n type,\n fn\n ? function (node, parent, stack, getRawIdentifier) {\n return (\n fn(node, parent, stack, getRawIdentifier) ??\n func(node, parent, stack, getRawIdentifier)\n );\n }\n : func,\n );\n }\n\n for (const type of Object.keys(obj)) {\n const aliases = FLIPPED_ALIAS_KEYS[type];\n if (aliases) {\n for (const alias of aliases) {\n add(alias, obj[type]);\n }\n } else {\n add(type, obj[type]);\n }\n }\n\n return map;\n}\n\n// Rather than using `t.is` on each object property, we pre-expand any type aliases\n// into concrete types so that the 'find' call below can be as fast as possible.\nconst expandedParens = expandAliases(parens);\nconst expandedWhitespaceNodes = expandAliases(whitespace.nodes);\n\nfunction isOrHasCallExpression(node: t.Node): boolean {\n if (isCallExpression(node)) {\n return true;\n }\n\n return isMemberExpression(node) && isOrHasCallExpression(node.object);\n}\n\nexport function needsWhitespace(\n node: t.Node,\n parent: t.Node,\n type: WhitespaceFlag,\n): boolean {\n if (!node) return false;\n\n if (isExpressionStatement(node)) {\n node = node.expression;\n }\n\n const flag = expandedWhitespaceNodes.get(node.type)?.(node, parent);\n\n if (typeof flag === \"number\") {\n return (flag & type) !== 0;\n }\n\n return false;\n}\n\nexport function needsWhitespaceBefore(node: t.Node, parent: t.Node) {\n return needsWhitespace(node, parent, 1);\n}\n\nexport function needsWhitespaceAfter(node: t.Node, parent: t.Node) {\n return needsWhitespace(node, parent, 2);\n}\n\nexport function needsParens(\n node: t.Node,\n parent: t.Node,\n tokenContext?: number,\n getRawIdentifier?: (node: t.Identifier) => string,\n) {\n if (!parent) return false;\n\n if (isNewExpression(parent) && parent.callee === node) {\n if (isOrHasCallExpression(node)) return true;\n }\n\n if (isDecorator(parent)) {\n return (\n !isDecoratorMemberExpression(node) &&\n !(isCallExpression(node) && isDecoratorMemberExpression(node.callee)) &&\n !isParenthesizedExpression(node)\n );\n }\n\n return expandedParens.get(node.type)?.(\n node,\n parent,\n tokenContext,\n getRawIdentifier,\n );\n}\n\nfunction isDecoratorMemberExpression(node: t.Node): boolean {\n switch (node.type) {\n case \"Identifier\":\n return true;\n case \"MemberExpression\":\n return (\n !node.computed &&\n node.property.type === \"Identifier\" &&\n isDecoratorMemberExpression(node.object)\n );\n default:\n return false;\n }\n}\n\nexport function isLastChild(parent: t.Node, child: t.Node) {\n const visitorKeys = VISITOR_KEYS[parent.type];\n for (let i = visitorKeys.length - 1; i >= 0; i--) {\n const val = (parent as any)[visitorKeys[i]] as t.Node | t.Node[] | null;\n if (val === child) {\n return true;\n } else if (Array.isArray(val)) {\n let j = val.length - 1;\n while (j >= 0 && val[j] === null) j--;\n return j >= 0 && val[j] === child;\n } else if (val) {\n return false;\n }\n }\n return false;\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/node/parentheses.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/node/parentheses.js new file mode 100644 index 0000000000000000000000000000000000000000..66eb16b537b126e6711164106b265186caf715dc --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/node/parentheses.js @@ -0,0 +1,262 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.AssignmentExpression = AssignmentExpression; +exports.Binary = Binary; +exports.BinaryExpression = BinaryExpression; +exports.ClassExpression = ClassExpression; +exports.ArrowFunctionExpression = exports.ConditionalExpression = ConditionalExpression; +exports.DoExpression = DoExpression; +exports.FunctionExpression = FunctionExpression; +exports.FunctionTypeAnnotation = FunctionTypeAnnotation; +exports.Identifier = Identifier; +exports.LogicalExpression = LogicalExpression; +exports.NullableTypeAnnotation = NullableTypeAnnotation; +exports.ObjectExpression = ObjectExpression; +exports.OptionalIndexedAccessType = OptionalIndexedAccessType; +exports.OptionalCallExpression = exports.OptionalMemberExpression = OptionalMemberExpression; +exports.SequenceExpression = SequenceExpression; +exports.TSSatisfiesExpression = exports.TSAsExpression = TSAsExpression; +exports.TSConditionalType = TSConditionalType; +exports.TSConstructorType = exports.TSFunctionType = TSFunctionType; +exports.TSInferType = TSInferType; +exports.TSInstantiationExpression = TSInstantiationExpression; +exports.TSIntersectionType = TSIntersectionType; +exports.UnaryLike = exports.TSTypeAssertion = UnaryLike; +exports.TSTypeOperator = TSTypeOperator; +exports.TSUnionType = TSUnionType; +exports.IntersectionTypeAnnotation = exports.UnionTypeAnnotation = UnionTypeAnnotation; +exports.UpdateExpression = UpdateExpression; +exports.AwaitExpression = exports.YieldExpression = YieldExpression; +var _t = require("@babel/types"); +var _index = require("./index.js"); +const { + isArrayTypeAnnotation, + isBinaryExpression, + isCallExpression, + isForOfStatement, + isIndexedAccessType, + isMemberExpression, + isObjectPattern, + isOptionalMemberExpression, + isYieldExpression, + isStatement +} = _t; +const PRECEDENCE = new Map([["||", 0], ["??", 0], ["|>", 0], ["&&", 1], ["|", 2], ["^", 3], ["&", 4], ["==", 5], ["===", 5], ["!=", 5], ["!==", 5], ["<", 6], [">", 6], ["<=", 6], [">=", 6], ["in", 6], ["instanceof", 6], [">>", 7], ["<<", 7], [">>>", 7], ["+", 8], ["-", 8], ["*", 9], ["/", 9], ["%", 9], ["**", 10]]); +function getBinaryPrecedence(node, nodeType) { + if (nodeType === "BinaryExpression" || nodeType === "LogicalExpression") { + return PRECEDENCE.get(node.operator); + } + if (nodeType === "TSAsExpression" || nodeType === "TSSatisfiesExpression") { + return PRECEDENCE.get("in"); + } +} +function isTSTypeExpression(nodeType) { + return nodeType === "TSAsExpression" || nodeType === "TSSatisfiesExpression" || nodeType === "TSTypeAssertion"; +} +const isClassExtendsClause = (node, parent) => { + const parentType = parent.type; + return (parentType === "ClassDeclaration" || parentType === "ClassExpression") && parent.superClass === node; +}; +const hasPostfixPart = (node, parent) => { + const parentType = parent.type; + return (parentType === "MemberExpression" || parentType === "OptionalMemberExpression") && parent.object === node || (parentType === "CallExpression" || parentType === "OptionalCallExpression" || parentType === "NewExpression") && parent.callee === node || parentType === "TaggedTemplateExpression" && parent.tag === node || parentType === "TSNonNullExpression"; +}; +function NullableTypeAnnotation(node, parent) { + return isArrayTypeAnnotation(parent); +} +function FunctionTypeAnnotation(node, parent, tokenContext) { + const parentType = parent.type; + return (parentType === "UnionTypeAnnotation" || parentType === "IntersectionTypeAnnotation" || parentType === "ArrayTypeAnnotation" || Boolean(tokenContext & _index.TokenContext.arrowFlowReturnType) + ); +} +function UpdateExpression(node, parent) { + return hasPostfixPart(node, parent) || isClassExtendsClause(node, parent); +} +function needsParenBeforeExpressionBrace(tokenContext) { + return Boolean(tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.arrowBody)); +} +function ObjectExpression(node, parent, tokenContext) { + return needsParenBeforeExpressionBrace(tokenContext); +} +function DoExpression(node, parent, tokenContext) { + return !node.async && Boolean(tokenContext & _index.TokenContext.expressionStatement); +} +function Binary(node, parent) { + const parentType = parent.type; + if (node.type === "BinaryExpression" && node.operator === "**" && parentType === "BinaryExpression" && parent.operator === "**") { + return parent.left === node; + } + if (isClassExtendsClause(node, parent)) { + return true; + } + if (hasPostfixPart(node, parent) || parentType === "UnaryExpression" || parentType === "SpreadElement" || parentType === "AwaitExpression") { + return true; + } + const parentPos = getBinaryPrecedence(parent, parentType); + if (parentPos != null) { + const nodePos = getBinaryPrecedence(node, node.type); + if (parentPos === nodePos && parentType === "BinaryExpression" && parent.right === node || parentPos > nodePos) { + return true; + } + } + return undefined; +} +function UnionTypeAnnotation(node, parent) { + const parentType = parent.type; + return parentType === "ArrayTypeAnnotation" || parentType === "NullableTypeAnnotation" || parentType === "IntersectionTypeAnnotation" || parentType === "UnionTypeAnnotation"; +} +function OptionalIndexedAccessType(node, parent) { + return isIndexedAccessType(parent) && parent.objectType === node; +} +function TSAsExpression(node, parent) { + if ((parent.type === "AssignmentExpression" || parent.type === "AssignmentPattern") && parent.left === node) { + return true; + } + if (parent.type === "BinaryExpression" && (parent.operator === "|" || parent.operator === "&") && node === parent.left) { + return true; + } + return Binary(node, parent); +} +function TSConditionalType(node, parent) { + const parentType = parent.type; + if (parentType === "TSArrayType" || parentType === "TSIndexedAccessType" && parent.objectType === node || parentType === "TSOptionalType" || parentType === "TSTypeOperator" || parentType === "TSTypeParameter") { + return true; + } + if ((parentType === "TSIntersectionType" || parentType === "TSUnionType") && parent.types[0] === node) { + return true; + } + if (parentType === "TSConditionalType" && (parent.checkType === node || parent.extendsType === node)) { + return true; + } + return false; +} +function TSUnionType(node, parent) { + const parentType = parent.type; + return parentType === "TSIntersectionType" || parentType === "TSTypeOperator" || parentType === "TSArrayType" || parentType === "TSIndexedAccessType" && parent.objectType === node || parentType === "TSOptionalType"; +} +function TSIntersectionType(node, parent) { + const parentType = parent.type; + return parentType === "TSTypeOperator" || parentType === "TSArrayType" || parentType === "TSIndexedAccessType" && parent.objectType === node || parentType === "TSOptionalType"; +} +function TSInferType(node, parent) { + const parentType = parent.type; + if (parentType === "TSArrayType" || parentType === "TSIndexedAccessType" && parent.objectType === node || parentType === "TSOptionalType") { + return true; + } + if (node.typeParameter.constraint) { + if ((parentType === "TSIntersectionType" || parentType === "TSUnionType") && parent.types[0] === node) { + return true; + } + } + return false; +} +function TSTypeOperator(node, parent) { + const parentType = parent.type; + return parentType === "TSArrayType" || parentType === "TSIndexedAccessType" && parent.objectType === node || parentType === "TSOptionalType"; +} +function TSInstantiationExpression(node, parent) { + const parentType = parent.type; + return (parentType === "CallExpression" || parentType === "OptionalCallExpression" || parentType === "NewExpression" || parentType === "TSInstantiationExpression") && !!parent.typeParameters; +} +function TSFunctionType(node, parent) { + const parentType = parent.type; + return parentType === "TSIntersectionType" || parentType === "TSUnionType" || parentType === "TSTypeOperator" || parentType === "TSOptionalType" || parentType === "TSArrayType" || parentType === "TSIndexedAccessType" && parent.objectType === node || parentType === "TSConditionalType" && (parent.checkType === node || parent.extendsType === node); +} +function BinaryExpression(node, parent, tokenContext) { + return node.operator === "in" && Boolean(tokenContext & _index.TokenContext.forInOrInitHeadAccumulate); +} +function SequenceExpression(node, parent) { + const parentType = parent.type; + if (parentType === "SequenceExpression" || parentType === "ParenthesizedExpression" || parentType === "MemberExpression" && parent.property === node || parentType === "OptionalMemberExpression" && parent.property === node || parentType === "TemplateLiteral") { + return false; + } + if (parentType === "ClassDeclaration") { + return true; + } + if (parentType === "ForOfStatement") { + return parent.right === node; + } + if (parentType === "ExportDefaultDeclaration") { + return true; + } + return !isStatement(parent); +} +function YieldExpression(node, parent) { + const parentType = parent.type; + return parentType === "BinaryExpression" || parentType === "LogicalExpression" || parentType === "UnaryExpression" || parentType === "SpreadElement" || hasPostfixPart(node, parent) || parentType === "AwaitExpression" && isYieldExpression(node) || parentType === "ConditionalExpression" && node === parent.test || isClassExtendsClause(node, parent) || isTSTypeExpression(parentType); +} +function ClassExpression(node, parent, tokenContext) { + return Boolean(tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.exportDefault)); +} +function UnaryLike(node, parent) { + return hasPostfixPart(node, parent) || isBinaryExpression(parent) && parent.operator === "**" && parent.left === node || isClassExtendsClause(node, parent); +} +function FunctionExpression(node, parent, tokenContext) { + return Boolean(tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.exportDefault)); +} +function ConditionalExpression(node, parent) { + const parentType = parent.type; + if (parentType === "UnaryExpression" || parentType === "SpreadElement" || parentType === "BinaryExpression" || parentType === "LogicalExpression" || parentType === "ConditionalExpression" && parent.test === node || parentType === "AwaitExpression" || isTSTypeExpression(parentType)) { + return true; + } + return UnaryLike(node, parent); +} +function OptionalMemberExpression(node, parent) { + return isCallExpression(parent) && parent.callee === node || isMemberExpression(parent) && parent.object === node; +} +function AssignmentExpression(node, parent, tokenContext) { + if (needsParenBeforeExpressionBrace(tokenContext) && isObjectPattern(node.left)) { + return true; + } else { + return ConditionalExpression(node, parent); + } +} +function LogicalExpression(node, parent) { + const parentType = parent.type; + if (isTSTypeExpression(parentType)) return true; + if (parentType !== "LogicalExpression") return false; + switch (node.operator) { + case "||": + return parent.operator === "??" || parent.operator === "&&"; + case "&&": + return parent.operator === "??"; + case "??": + return parent.operator !== "??"; + } +} +function Identifier(node, parent, tokenContext, getRawIdentifier) { + var _node$extra; + const parentType = parent.type; + if ((_node$extra = node.extra) != null && _node$extra.parenthesized && parentType === "AssignmentExpression" && parent.left === node) { + const rightType = parent.right.type; + if ((rightType === "FunctionExpression" || rightType === "ClassExpression") && parent.right.id == null) { + return true; + } + } + if (getRawIdentifier && getRawIdentifier(node) !== node.name) { + return false; + } + if (node.name === "let") { + const isFollowedByBracket = isMemberExpression(parent, { + object: node, + computed: true + }) || isOptionalMemberExpression(parent, { + object: node, + computed: true, + optional: false + }); + if (isFollowedByBracket && tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.forInitHead | _index.TokenContext.forInHead)) { + return true; + } + return Boolean(tokenContext & _index.TokenContext.forOfHead); + } + return node.name === "async" && isForOfStatement(parent, { + left: node, + await: false + }); +} + +//# sourceMappingURL=parentheses.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/node/parentheses.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/node/parentheses.js.map new file mode 100644 index 0000000000000000000000000000000000000000..2f6f18c45f512215e9a3705c01505f918135642c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/node/parentheses.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_t","require","_index","isArrayTypeAnnotation","isBinaryExpression","isCallExpression","isForOfStatement","isIndexedAccessType","isMemberExpression","isObjectPattern","isOptionalMemberExpression","isYieldExpression","isStatement","PRECEDENCE","Map","getBinaryPrecedence","node","nodeType","get","operator","isTSTypeExpression","isClassExtendsClause","parent","parentType","type","superClass","hasPostfixPart","object","callee","tag","NullableTypeAnnotation","FunctionTypeAnnotation","tokenContext","Boolean","TokenContext","arrowFlowReturnType","UpdateExpression","needsParenBeforeExpressionBrace","expressionStatement","arrowBody","ObjectExpression","DoExpression","async","Binary","left","parentPos","nodePos","right","undefined","UnionTypeAnnotation","OptionalIndexedAccessType","objectType","TSAsExpression","TSConditionalType","types","checkType","extendsType","TSUnionType","TSIntersectionType","TSInferType","typeParameter","constraint","TSTypeOperator","TSInstantiationExpression","typeParameters","TSFunctionType","BinaryExpression","forInOrInitHeadAccumulate","SequenceExpression","property","YieldExpression","test","ClassExpression","exportDefault","UnaryLike","FunctionExpression","ConditionalExpression","OptionalMemberExpression","AssignmentExpression","LogicalExpression","Identifier","getRawIdentifier","_node$extra","extra","parenthesized","rightType","id","name","isFollowedByBracket","computed","optional","forInitHead","forInHead","forOfHead","await"],"sources":["../../src/node/parentheses.ts"],"sourcesContent":["import {\n isArrayTypeAnnotation,\n isBinaryExpression,\n isCallExpression,\n isForOfStatement,\n isIndexedAccessType,\n isMemberExpression,\n isObjectPattern,\n isOptionalMemberExpression,\n isYieldExpression,\n isStatement,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\n\nimport { TokenContext } from \"./index.ts\";\n\nconst PRECEDENCE = new Map([\n [\"||\", 0],\n [\"??\", 0],\n [\"|>\", 0],\n [\"&&\", 1],\n [\"|\", 2],\n [\"^\", 3],\n [\"&\", 4],\n [\"==\", 5],\n [\"===\", 5],\n [\"!=\", 5],\n [\"!==\", 5],\n [\"<\", 6],\n [\">\", 6],\n [\"<=\", 6],\n [\">=\", 6],\n [\"in\", 6],\n [\"instanceof\", 6],\n [\">>\", 7],\n [\"<<\", 7],\n [\">>>\", 7],\n [\"+\", 8],\n [\"-\", 8],\n [\"*\", 9],\n [\"/\", 9],\n [\"%\", 9],\n [\"**\", 10],\n]);\n\nfunction getBinaryPrecedence(\n node: t.Binary | t.TSAsExpression | t.TSSatisfiesExpression,\n nodeType: string,\n): number;\nfunction getBinaryPrecedence(\n node: t.Node,\n nodeType: string,\n): number | undefined;\nfunction getBinaryPrecedence(node: t.Node, nodeType: string) {\n if (nodeType === \"BinaryExpression\" || nodeType === \"LogicalExpression\") {\n return PRECEDENCE.get((node as t.Binary).operator);\n }\n if (nodeType === \"TSAsExpression\" || nodeType === \"TSSatisfiesExpression\") {\n return PRECEDENCE.get(\"in\");\n }\n}\n\nfunction isTSTypeExpression(nodeType: string) {\n return (\n nodeType === \"TSAsExpression\" ||\n nodeType === \"TSSatisfiesExpression\" ||\n nodeType === \"TSTypeAssertion\"\n );\n}\n\nconst isClassExtendsClause = (\n node: t.Node,\n parent: t.Node,\n): parent is t.Class => {\n const parentType = parent.type;\n return (\n (parentType === \"ClassDeclaration\" || parentType === \"ClassExpression\") &&\n parent.superClass === node\n );\n};\n\nconst hasPostfixPart = (node: t.Node, parent: t.Node) => {\n const parentType = parent.type;\n return (\n ((parentType === \"MemberExpression\" ||\n parentType === \"OptionalMemberExpression\") &&\n parent.object === node) ||\n ((parentType === \"CallExpression\" ||\n parentType === \"OptionalCallExpression\" ||\n parentType === \"NewExpression\") &&\n parent.callee === node) ||\n (parentType === \"TaggedTemplateExpression\" && parent.tag === node) ||\n parentType === \"TSNonNullExpression\"\n );\n};\n\nexport function NullableTypeAnnotation(\n node: t.NullableTypeAnnotation,\n parent: t.Node,\n): boolean {\n return isArrayTypeAnnotation(parent);\n}\n\nexport function FunctionTypeAnnotation(\n node: t.FunctionTypeAnnotation,\n parent: t.Node,\n tokenContext: number,\n): boolean {\n const parentType = parent.type;\n return (\n // (() => A) | (() => B)\n parentType === \"UnionTypeAnnotation\" ||\n // (() => A) & (() => B)\n parentType === \"IntersectionTypeAnnotation\" ||\n // (() => A)[]\n parentType === \"ArrayTypeAnnotation\" ||\n Boolean(tokenContext & TokenContext.arrowFlowReturnType)\n );\n}\n\nexport function UpdateExpression(\n node: t.UpdateExpression,\n parent: t.Node,\n): boolean {\n return hasPostfixPart(node, parent) || isClassExtendsClause(node, parent);\n}\n\nfunction needsParenBeforeExpressionBrace(tokenContext: number) {\n return Boolean(\n tokenContext & (TokenContext.expressionStatement | TokenContext.arrowBody),\n );\n}\n\nexport function ObjectExpression(\n node: t.ObjectExpression,\n parent: t.Node,\n tokenContext: number,\n): boolean {\n return needsParenBeforeExpressionBrace(tokenContext);\n}\n\nexport function DoExpression(\n node: t.DoExpression,\n parent: t.Node,\n tokenContext: number,\n): boolean {\n // `async do` can start an expression statement\n return (\n !node.async && Boolean(tokenContext & TokenContext.expressionStatement)\n );\n}\n\nexport function Binary(\n node: t.Binary | t.TSAsExpression | t.TSSatisfiesExpression,\n parent: t.Node,\n): boolean | undefined {\n const parentType = parent.type;\n if (\n node.type === \"BinaryExpression\" &&\n node.operator === \"**\" &&\n parentType === \"BinaryExpression\" &&\n parent.operator === \"**\"\n ) {\n return parent.left === node;\n }\n\n if (isClassExtendsClause(node, parent)) {\n return true;\n }\n\n if (\n hasPostfixPart(node, parent) ||\n parentType === \"UnaryExpression\" ||\n parentType === \"SpreadElement\" ||\n parentType === \"AwaitExpression\"\n ) {\n return true;\n }\n\n const parentPos = getBinaryPrecedence(parent, parentType);\n if (parentPos != null) {\n const nodePos = getBinaryPrecedence(node, node.type);\n if (\n // Logical expressions with the same precedence don't need parens.\n (parentPos === nodePos &&\n parentType === \"BinaryExpression\" &&\n parent.right === node) ||\n parentPos > nodePos\n ) {\n return true;\n }\n }\n\n return undefined;\n}\n\nexport function UnionTypeAnnotation(\n node: t.UnionTypeAnnotation,\n parent: t.Node,\n): boolean {\n const parentType = parent.type;\n return (\n parentType === \"ArrayTypeAnnotation\" ||\n parentType === \"NullableTypeAnnotation\" ||\n parentType === \"IntersectionTypeAnnotation\" ||\n parentType === \"UnionTypeAnnotation\"\n );\n}\n\nexport { UnionTypeAnnotation as IntersectionTypeAnnotation };\n\nexport function OptionalIndexedAccessType(\n node: t.OptionalIndexedAccessType,\n parent: t.Node,\n): boolean {\n return isIndexedAccessType(parent) && parent.objectType === node;\n}\n\nexport function TSAsExpression(\n node: t.TSAsExpression | t.TSSatisfiesExpression,\n parent: t.Node,\n): boolean {\n if (\n (parent.type === \"AssignmentExpression\" ||\n parent.type === \"AssignmentPattern\") &&\n parent.left === node\n ) {\n return true;\n }\n if (\n parent.type === \"BinaryExpression\" &&\n (parent.operator === \"|\" || parent.operator === \"&\") &&\n node === parent.left\n ) {\n return true;\n }\n return Binary(node, parent);\n}\n\nexport { TSAsExpression as TSSatisfiesExpression };\n\nexport { UnaryLike as TSTypeAssertion };\n\nexport function TSConditionalType(\n node: t.TSConditionalType,\n parent: t.Node,\n): boolean {\n const parentType = parent.type;\n if (\n parentType === \"TSArrayType\" ||\n (parentType === \"TSIndexedAccessType\" && parent.objectType === node) ||\n parentType === \"TSOptionalType\" ||\n parentType === \"TSTypeOperator\" ||\n // for `infer K extends (L extends M ? M : ...)`\n parentType === \"TSTypeParameter\"\n ) {\n return true;\n }\n if (\n (parentType === \"TSIntersectionType\" || parentType === \"TSUnionType\") &&\n parent.types[0] === node\n ) {\n return true;\n }\n if (\n parentType === \"TSConditionalType\" &&\n (parent.checkType === node || parent.extendsType === node)\n ) {\n return true;\n }\n return false;\n}\n\nexport function TSUnionType(node: t.TSUnionType, parent: t.Node): boolean {\n const parentType = parent.type;\n return (\n parentType === \"TSIntersectionType\" ||\n parentType === \"TSTypeOperator\" ||\n parentType === \"TSArrayType\" ||\n (parentType === \"TSIndexedAccessType\" && parent.objectType === node) ||\n parentType === \"TSOptionalType\"\n );\n}\n\nexport function TSIntersectionType(\n node: t.TSUnionType,\n parent: t.Node,\n): boolean {\n const parentType = parent.type;\n return (\n parentType === \"TSTypeOperator\" ||\n parentType === \"TSArrayType\" ||\n (parentType === \"TSIndexedAccessType\" && parent.objectType === node) ||\n parentType === \"TSOptionalType\"\n );\n}\n\nexport function TSInferType(node: t.TSInferType, parent: t.Node): boolean {\n const parentType = parent.type;\n if (\n parentType === \"TSArrayType\" ||\n (parentType === \"TSIndexedAccessType\" && parent.objectType === node) ||\n parentType === \"TSOptionalType\"\n ) {\n return true;\n }\n if (node.typeParameter.constraint) {\n if (\n (parentType === \"TSIntersectionType\" || parentType === \"TSUnionType\") &&\n parent.types[0] === node\n ) {\n return true;\n }\n }\n return false;\n}\n\nexport function TSTypeOperator(\n node: t.TSTypeOperator,\n parent: t.Node,\n): boolean {\n const parentType = parent.type;\n return (\n parentType === \"TSArrayType\" ||\n (parentType === \"TSIndexedAccessType\" && parent.objectType === node) ||\n parentType === \"TSOptionalType\"\n );\n}\n\nexport function TSInstantiationExpression(\n node: t.TSInstantiationExpression,\n parent: t.Node,\n) {\n const parentType = parent.type;\n return (\n (parentType === \"CallExpression\" ||\n parentType === \"OptionalCallExpression\" ||\n parentType === \"NewExpression\" ||\n parentType === \"TSInstantiationExpression\") &&\n !!(process.env.BABEL_8_BREAKING\n ? // @ts-ignore(Babel 7 vs Babel 8) Babel 8 AST\n parent.typeArguments\n : // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST\n parent.typeParameters)\n );\n}\n\nexport function TSFunctionType(\n node: t.TSFunctionType,\n parent: t.Node,\n): boolean {\n const parentType = parent.type;\n return (\n parentType === \"TSIntersectionType\" ||\n parentType === \"TSUnionType\" ||\n parentType === \"TSTypeOperator\" ||\n parentType === \"TSOptionalType\" ||\n parentType === \"TSArrayType\" ||\n (parentType === \"TSIndexedAccessType\" && parent.objectType === node) ||\n (parentType === \"TSConditionalType\" &&\n (parent.checkType === node || parent.extendsType === node))\n );\n}\n\nexport { TSFunctionType as TSConstructorType };\n\nexport function BinaryExpression(\n node: t.BinaryExpression,\n parent: t.Node,\n tokenContext: number,\n): boolean {\n // for ((1 in []);;);\n // for (var x = (1 in []) in 2);\n return (\n node.operator === \"in\" &&\n Boolean(tokenContext & TokenContext.forInOrInitHeadAccumulate)\n );\n}\n\nexport function SequenceExpression(\n node: t.SequenceExpression,\n parent: t.Node,\n): boolean {\n const parentType = parent.type;\n if (\n parentType === \"SequenceExpression\" ||\n parentType === \"ParenthesizedExpression\" ||\n (parentType === \"MemberExpression\" && parent.property === node) ||\n (parentType === \"OptionalMemberExpression\" && parent.property === node) ||\n parentType === \"TemplateLiteral\"\n ) {\n return false;\n }\n if (parentType === \"ClassDeclaration\") {\n return true;\n }\n if (parentType === \"ForOfStatement\") {\n return parent.right === node;\n }\n if (parentType === \"ExportDefaultDeclaration\") {\n return true;\n }\n\n return !isStatement(parent);\n}\n\nexport function YieldExpression(\n node: t.YieldExpression,\n parent: t.Node,\n): boolean {\n const parentType = parent.type;\n return (\n parentType === \"BinaryExpression\" ||\n parentType === \"LogicalExpression\" ||\n parentType === \"UnaryExpression\" ||\n parentType === \"SpreadElement\" ||\n hasPostfixPart(node, parent) ||\n (parentType === \"AwaitExpression\" && isYieldExpression(node)) ||\n (parentType === \"ConditionalExpression\" && node === parent.test) ||\n isClassExtendsClause(node, parent) ||\n isTSTypeExpression(parentType)\n );\n}\n\nexport { YieldExpression as AwaitExpression };\n\nexport function ClassExpression(\n node: t.ClassExpression,\n parent: t.Node,\n tokenContext: number,\n): boolean {\n return Boolean(\n tokenContext &\n (TokenContext.expressionStatement | TokenContext.exportDefault),\n );\n}\n\nexport function UnaryLike(\n node:\n | t.UnaryLike\n | t.TSTypeAssertion\n | t.ArrowFunctionExpression\n | t.ConditionalExpression\n | t.AssignmentExpression,\n parent: t.Node,\n): boolean {\n return (\n hasPostfixPart(node, parent) ||\n (isBinaryExpression(parent) &&\n parent.operator === \"**\" &&\n parent.left === node) ||\n isClassExtendsClause(node, parent)\n );\n}\n\nexport function FunctionExpression(\n node: t.FunctionExpression,\n parent: t.Node,\n tokenContext: number,\n): boolean {\n return Boolean(\n tokenContext &\n (TokenContext.expressionStatement | TokenContext.exportDefault),\n );\n}\n\nexport function ConditionalExpression(\n node:\n | t.ConditionalExpression\n | t.ArrowFunctionExpression\n | t.AssignmentExpression,\n parent?: t.Node,\n): boolean {\n const parentType = parent.type;\n if (\n parentType === \"UnaryExpression\" ||\n parentType === \"SpreadElement\" ||\n parentType === \"BinaryExpression\" ||\n parentType === \"LogicalExpression\" ||\n (parentType === \"ConditionalExpression\" && parent.test === node) ||\n parentType === \"AwaitExpression\" ||\n isTSTypeExpression(parentType)\n ) {\n return true;\n }\n\n return UnaryLike(node, parent);\n}\n\nexport { ConditionalExpression as ArrowFunctionExpression };\n\nexport function OptionalMemberExpression(\n node: t.OptionalMemberExpression,\n parent: t.Node,\n): boolean {\n return (\n (isCallExpression(parent) && parent.callee === node) ||\n (isMemberExpression(parent) && parent.object === node)\n );\n}\n\nexport { OptionalMemberExpression as OptionalCallExpression };\n\nexport function AssignmentExpression(\n node: t.AssignmentExpression,\n parent: t.Node,\n tokenContext: number,\n): boolean {\n if (\n needsParenBeforeExpressionBrace(tokenContext) &&\n isObjectPattern(node.left)\n ) {\n return true;\n } else {\n return ConditionalExpression(node, parent);\n }\n}\n\nexport function LogicalExpression(\n node: t.LogicalExpression,\n parent: t.Node,\n): boolean {\n const parentType = parent.type;\n if (isTSTypeExpression(parentType)) return true;\n if (parentType !== \"LogicalExpression\") return false;\n switch (node.operator) {\n case \"||\":\n return parent.operator === \"??\" || parent.operator === \"&&\";\n case \"&&\":\n return parent.operator === \"??\";\n case \"??\":\n return parent.operator !== \"??\";\n }\n}\n\nexport function Identifier(\n node: t.Identifier,\n parent: t.Node,\n tokenContext: number,\n getRawIdentifier: (node: t.Identifier) => string,\n): boolean {\n const parentType = parent.type;\n // 13.15.2 AssignmentExpression RS: Evaluation\n // (fn) = function () {};\n if (\n node.extra?.parenthesized &&\n parentType === \"AssignmentExpression\" &&\n parent.left === node\n ) {\n const rightType = parent.right.type;\n if (\n (rightType === \"FunctionExpression\" || rightType === \"ClassExpression\") &&\n parent.right.id == null\n ) {\n return true;\n }\n }\n\n if (getRawIdentifier && getRawIdentifier(node) !== node.name) {\n return false;\n }\n\n // Non-strict code allows the identifier `let`, but it cannot occur as-is in\n // certain contexts to avoid ambiguity with contextual keyword `let`.\n if (node.name === \"let\") {\n // Some contexts only forbid `let [`, so check if the next token would\n // be the left bracket of a computed member expression.\n const isFollowedByBracket =\n isMemberExpression(parent, {\n object: node,\n computed: true,\n }) ||\n isOptionalMemberExpression(parent, {\n object: node,\n computed: true,\n optional: false,\n });\n if (\n isFollowedByBracket &&\n tokenContext &\n (TokenContext.expressionStatement |\n TokenContext.forInitHead |\n TokenContext.forInHead)\n ) {\n return true;\n }\n return Boolean(tokenContext & TokenContext.forOfHead);\n }\n\n // ECMAScript specifically forbids a for-of loop from starting with the\n // token sequence `for (async of`, because it would be ambiguous with\n // `for (async of => {};;)`, so we need to add extra parentheses.\n return (\n node.name === \"async\" &&\n isForOfStatement(parent, { left: node, await: false })\n );\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/node/whitespace.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/node/whitespace.js new file mode 100644 index 0000000000000000000000000000000000000000..181b9566099e1346ef049b2055496fcef0af46b8 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/node/whitespace.js @@ -0,0 +1,145 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.nodes = void 0; +var _t = require("@babel/types"); +const { + FLIPPED_ALIAS_KEYS, + isArrayExpression, + isAssignmentExpression, + isBinary, + isBlockStatement, + isCallExpression, + isFunction, + isIdentifier, + isLiteral, + isMemberExpression, + isObjectExpression, + isOptionalCallExpression, + isOptionalMemberExpression, + isStringLiteral +} = _t; +function crawlInternal(node, state) { + if (!node) return state; + if (isMemberExpression(node) || isOptionalMemberExpression(node)) { + crawlInternal(node.object, state); + if (node.computed) crawlInternal(node.property, state); + } else if (isBinary(node) || isAssignmentExpression(node)) { + crawlInternal(node.left, state); + crawlInternal(node.right, state); + } else if (isCallExpression(node) || isOptionalCallExpression(node)) { + state.hasCall = true; + crawlInternal(node.callee, state); + } else if (isFunction(node)) { + state.hasFunction = true; + } else if (isIdentifier(node)) { + state.hasHelper = state.hasHelper || node.callee && isHelper(node.callee); + } + return state; +} +function crawl(node) { + return crawlInternal(node, { + hasCall: false, + hasFunction: false, + hasHelper: false + }); +} +function isHelper(node) { + if (!node) return false; + if (isMemberExpression(node)) { + return isHelper(node.object) || isHelper(node.property); + } else if (isIdentifier(node)) { + return node.name === "require" || node.name.charCodeAt(0) === 95; + } else if (isCallExpression(node)) { + return isHelper(node.callee); + } else if (isBinary(node) || isAssignmentExpression(node)) { + return isIdentifier(node.left) && isHelper(node.left) || isHelper(node.right); + } else { + return false; + } +} +function isType(node) { + return isLiteral(node) || isObjectExpression(node) || isArrayExpression(node) || isIdentifier(node) || isMemberExpression(node); +} +const nodes = exports.nodes = { + AssignmentExpression(node) { + const state = crawl(node.right); + if (state.hasCall && state.hasHelper || state.hasFunction) { + return state.hasFunction ? 1 | 2 : 2; + } + }, + SwitchCase(node, parent) { + return (!!node.consequent.length || parent.cases[0] === node ? 1 : 0) | (!node.consequent.length && parent.cases[parent.cases.length - 1] === node ? 2 : 0); + }, + LogicalExpression(node) { + if (isFunction(node.left) || isFunction(node.right)) { + return 2; + } + }, + Literal(node) { + if (isStringLiteral(node) && node.value === "use strict") { + return 2; + } + }, + CallExpression(node) { + if (isFunction(node.callee) || isHelper(node)) { + return 1 | 2; + } + }, + OptionalCallExpression(node) { + if (isFunction(node.callee)) { + return 1 | 2; + } + }, + VariableDeclaration(node) { + for (let i = 0; i < node.declarations.length; i++) { + const declar = node.declarations[i]; + let enabled = isHelper(declar.id) && !isType(declar.init); + if (!enabled && declar.init) { + const state = crawl(declar.init); + enabled = isHelper(declar.init) && state.hasCall || state.hasFunction; + } + if (enabled) { + return 1 | 2; + } + } + }, + IfStatement(node) { + if (isBlockStatement(node.consequent)) { + return 1 | 2; + } + } +}; +nodes.ObjectProperty = nodes.ObjectTypeProperty = nodes.ObjectMethod = function (node, parent) { + if (parent.properties[0] === node) { + return 1; + } +}; +nodes.ObjectTypeCallProperty = function (node, parent) { + var _parent$properties; + if (parent.callProperties[0] === node && !((_parent$properties = parent.properties) != null && _parent$properties.length)) { + return 1; + } +}; +nodes.ObjectTypeIndexer = function (node, parent) { + var _parent$properties2, _parent$callPropertie; + if (parent.indexers[0] === node && !((_parent$properties2 = parent.properties) != null && _parent$properties2.length) && !((_parent$callPropertie = parent.callProperties) != null && _parent$callPropertie.length)) { + return 1; + } +}; +nodes.ObjectTypeInternalSlot = function (node, parent) { + var _parent$properties3, _parent$callPropertie2, _parent$indexers; + if (parent.internalSlots[0] === node && !((_parent$properties3 = parent.properties) != null && _parent$properties3.length) && !((_parent$callPropertie2 = parent.callProperties) != null && _parent$callPropertie2.length) && !((_parent$indexers = parent.indexers) != null && _parent$indexers.length)) { + return 1; + } +}; +[["Function", true], ["Class", true], ["Loop", true], ["LabeledStatement", true], ["SwitchStatement", true], ["TryStatement", true]].forEach(function ([type, amounts]) { + [type].concat(FLIPPED_ALIAS_KEYS[type] || []).forEach(function (type) { + const ret = amounts ? 1 | 2 : 0; + nodes[type] = () => ret; + }); +}); + +//# sourceMappingURL=whitespace.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/node/whitespace.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/node/whitespace.js.map new file mode 100644 index 0000000000000000000000000000000000000000..dea7ddc6eee8ae7f98541e60d787f64593cd19f5 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/node/whitespace.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_t","require","FLIPPED_ALIAS_KEYS","isArrayExpression","isAssignmentExpression","isBinary","isBlockStatement","isCallExpression","isFunction","isIdentifier","isLiteral","isMemberExpression","isObjectExpression","isOptionalCallExpression","isOptionalMemberExpression","isStringLiteral","crawlInternal","node","state","object","computed","property","left","right","hasCall","callee","hasFunction","hasHelper","isHelper","crawl","name","charCodeAt","isType","nodes","exports","AssignmentExpression","SwitchCase","parent","consequent","length","cases","LogicalExpression","Literal","value","CallExpression","OptionalCallExpression","VariableDeclaration","i","declarations","declar","enabled","id","init","IfStatement","ObjectProperty","ObjectTypeProperty","ObjectMethod","properties","ObjectTypeCallProperty","_parent$properties","callProperties","ObjectTypeIndexer","_parent$properties2","_parent$callPropertie","indexers","ObjectTypeInternalSlot","_parent$properties3","_parent$callPropertie2","_parent$indexers","internalSlots","forEach","type","amounts","concat","ret"],"sources":["../../src/node/whitespace.ts"],"sourcesContent":["import {\n FLIPPED_ALIAS_KEYS,\n isArrayExpression,\n isAssignmentExpression,\n isBinary,\n isBlockStatement,\n isCallExpression,\n isFunction,\n isIdentifier,\n isLiteral,\n isMemberExpression,\n isObjectExpression,\n isOptionalCallExpression,\n isOptionalMemberExpression,\n isStringLiteral,\n} from \"@babel/types\";\n\n// We inline this package\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport * as charCodes from \"charcodes\";\n\nimport type { NodeHandlers } from \"./index.ts\";\n\nimport type * as t from \"@babel/types\";\n\nconst enum WhitespaceFlag {\n before = 1 << 0,\n after = 1 << 1,\n}\n\nexport type { WhitespaceFlag };\n\nfunction crawlInternal(\n node: t.Node,\n state: { hasCall: boolean; hasFunction: boolean; hasHelper: boolean },\n) {\n if (!node) return state;\n\n if (isMemberExpression(node) || isOptionalMemberExpression(node)) {\n crawlInternal(node.object, state);\n if (node.computed) crawlInternal(node.property, state);\n } else if (isBinary(node) || isAssignmentExpression(node)) {\n crawlInternal(node.left, state);\n crawlInternal(node.right, state);\n } else if (isCallExpression(node) || isOptionalCallExpression(node)) {\n state.hasCall = true;\n crawlInternal(node.callee, state);\n } else if (isFunction(node)) {\n state.hasFunction = true;\n } else if (isIdentifier(node)) {\n state.hasHelper =\n // @ts-expect-error todo(flow->ts): node.callee is not really expected here…\n state.hasHelper || (node.callee && isHelper(node.callee));\n }\n\n return state;\n}\n\n/**\n * Crawl a node to test if it contains a CallExpression, a Function, or a Helper.\n *\n * @example\n * crawl(node)\n * // { hasCall: false, hasFunction: true, hasHelper: false }\n */\n\nfunction crawl(node: t.Node) {\n return crawlInternal(node, {\n hasCall: false,\n hasFunction: false,\n hasHelper: false,\n });\n}\n\n/**\n * Test if a node is or has a helper.\n */\n\nfunction isHelper(node: t.Node): boolean {\n if (!node) return false;\n\n if (isMemberExpression(node)) {\n return isHelper(node.object) || isHelper(node.property);\n } else if (isIdentifier(node)) {\n return (\n node.name === \"require\" ||\n node.name.charCodeAt(0) === charCodes.underscore\n );\n } else if (isCallExpression(node)) {\n return isHelper(node.callee);\n } else if (isBinary(node) || isAssignmentExpression(node)) {\n return (\n (isIdentifier(node.left) && isHelper(node.left)) || isHelper(node.right)\n );\n } else {\n return false;\n }\n}\n\nfunction isType(node: t.Node) {\n return (\n isLiteral(node) ||\n isObjectExpression(node) ||\n isArrayExpression(node) ||\n isIdentifier(node) ||\n isMemberExpression(node)\n );\n}\n\n/**\n * Tests for node types that need whitespace.\n */\n\nexport const nodes: NodeHandlers = {\n /**\n * Test if AssignmentExpression needs whitespace.\n */\n\n AssignmentExpression(node: t.AssignmentExpression): WhitespaceFlag {\n const state = crawl(node.right);\n if ((state.hasCall && state.hasHelper) || state.hasFunction) {\n return state.hasFunction\n ? WhitespaceFlag.before | WhitespaceFlag.after\n : WhitespaceFlag.after;\n }\n },\n\n /**\n * Test if SwitchCase needs whitespace.\n */\n\n SwitchCase(node: t.SwitchCase, parent: t.SwitchStatement): WhitespaceFlag {\n return (\n (!!node.consequent.length || parent.cases[0] === node\n ? WhitespaceFlag.before\n : 0) |\n (!node.consequent.length && parent.cases[parent.cases.length - 1] === node\n ? WhitespaceFlag.after\n : 0)\n );\n },\n\n /**\n * Test if LogicalExpression needs whitespace.\n */\n\n LogicalExpression(node: t.LogicalExpression): WhitespaceFlag {\n if (isFunction(node.left) || isFunction(node.right)) {\n return WhitespaceFlag.after;\n }\n },\n\n /**\n * Test if Literal needs whitespace.\n */\n\n Literal(node: t.Literal): WhitespaceFlag {\n if (isStringLiteral(node) && node.value === \"use strict\") {\n return WhitespaceFlag.after;\n }\n },\n\n /**\n * Test if CallExpressionish needs whitespace.\n */\n\n CallExpression(node: t.CallExpression): WhitespaceFlag {\n if (isFunction(node.callee) || isHelper(node)) {\n return WhitespaceFlag.before | WhitespaceFlag.after;\n }\n },\n\n OptionalCallExpression(node: t.OptionalCallExpression): WhitespaceFlag {\n if (isFunction(node.callee)) {\n return WhitespaceFlag.before | WhitespaceFlag.after;\n }\n },\n\n /**\n * Test if VariableDeclaration needs whitespace.\n */\n\n VariableDeclaration(node: t.VariableDeclaration): WhitespaceFlag {\n for (let i = 0; i < node.declarations.length; i++) {\n const declar = node.declarations[i];\n\n let enabled = isHelper(declar.id) && !isType(declar.init);\n if (!enabled && declar.init) {\n const state = crawl(declar.init);\n enabled = (isHelper(declar.init) && state.hasCall) || state.hasFunction;\n }\n\n if (enabled) {\n return WhitespaceFlag.before | WhitespaceFlag.after;\n }\n }\n },\n\n /**\n * Test if IfStatement needs whitespace.\n */\n\n IfStatement(node: t.IfStatement): WhitespaceFlag {\n if (isBlockStatement(node.consequent)) {\n return WhitespaceFlag.before | WhitespaceFlag.after;\n }\n },\n};\n\n/**\n * Test if Property needs whitespace.\n */\n\nnodes.ObjectProperty =\n nodes.ObjectTypeProperty =\n nodes.ObjectMethod =\n function (\n node: t.ObjectProperty | t.ObjectTypeProperty | t.ObjectMethod,\n parent: t.ObjectExpression,\n ): WhitespaceFlag {\n if (parent.properties[0] === node) {\n return WhitespaceFlag.before;\n }\n };\n\nnodes.ObjectTypeCallProperty = function (\n node: t.ObjectTypeCallProperty,\n parent: t.ObjectTypeAnnotation,\n): WhitespaceFlag {\n if (parent.callProperties[0] === node && !parent.properties?.length) {\n return WhitespaceFlag.before;\n }\n};\n\nnodes.ObjectTypeIndexer = function (\n node: t.ObjectTypeIndexer,\n parent: t.ObjectTypeAnnotation,\n): WhitespaceFlag {\n if (\n parent.indexers[0] === node &&\n !parent.properties?.length &&\n !parent.callProperties?.length\n ) {\n return WhitespaceFlag.before;\n }\n};\n\nnodes.ObjectTypeInternalSlot = function (\n node: t.ObjectTypeInternalSlot,\n parent: t.ObjectTypeAnnotation,\n): WhitespaceFlag {\n if (\n parent.internalSlots[0] === node &&\n !parent.properties?.length &&\n !parent.callProperties?.length &&\n !parent.indexers?.length\n ) {\n return WhitespaceFlag.before;\n }\n};\n\n/**\n * Add whitespace tests for nodes and their aliases.\n */\n\n(\n [\n [\"Function\", true],\n [\"Class\", true],\n [\"Loop\", true],\n [\"LabeledStatement\", true],\n [\"SwitchStatement\", true],\n [\"TryStatement\", true],\n ] as const\n).forEach(function ([type, amounts]) {\n [type as string]\n .concat(FLIPPED_ALIAS_KEYS[type] || [])\n .forEach(function (type) {\n const ret = amounts ? WhitespaceFlag.before | WhitespaceFlag.after : 0;\n nodes[type] = () => ret;\n });\n});\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/printer.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/printer.js new file mode 100644 index 0000000000000000000000000000000000000000..2977e633d254f8d71fdea9f628ef5451de299633 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/printer.js @@ -0,0 +1,781 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; +var _buffer = require("./buffer.js"); +var _index = require("./node/index.js"); +var n = _index; +var _t = require("@babel/types"); +var _tokenMap = require("./token-map.js"); +var generatorFunctions = require("./generators/index.js"); +var _deprecated = require("./generators/deprecated.js"); +const { + isExpression, + isFunction, + isStatement, + isClassBody, + isTSInterfaceBody, + isTSEnumMember +} = _t; +const SCIENTIFIC_NOTATION = /e/i; +const ZERO_DECIMAL_INTEGER = /\.0+$/; +const HAS_NEWLINE = /[\n\r\u2028\u2029]/; +const HAS_NEWLINE_OR_BlOCK_COMMENT_END = /[\n\r\u2028\u2029]|\*\//; +function commentIsNewline(c) { + return c.type === "CommentLine" || HAS_NEWLINE.test(c.value); +} +const { + needsParens +} = n; +class Printer { + constructor(format, map, tokens, originalCode) { + this.tokenContext = _index.TokenContext.normal; + this._tokens = null; + this._originalCode = null; + this._currentNode = null; + this._indent = 0; + this._indentRepeat = 0; + this._insideAux = false; + this._noLineTerminator = false; + this._noLineTerminatorAfterNode = null; + this._printAuxAfterOnNextUserNode = false; + this._printedComments = new Set(); + this._endsWithInteger = false; + this._endsWithWord = false; + this._endsWithDiv = false; + this._lastCommentLine = 0; + this._endsWithInnerRaw = false; + this._indentInnerComments = true; + this.tokenMap = null; + this._boundGetRawIdentifier = this._getRawIdentifier.bind(this); + this._printSemicolonBeforeNextNode = -1; + this._printSemicolonBeforeNextToken = -1; + this.format = format; + this._tokens = tokens; + this._originalCode = originalCode; + this._indentRepeat = format.indent.style.length; + this._inputMap = map == null ? void 0 : map._inputMap; + this._buf = new _buffer.default(map, format.indent.style[0]); + } + enterForStatementInit() { + this.tokenContext |= _index.TokenContext.forInitHead | _index.TokenContext.forInOrInitHeadAccumulate; + return () => this.tokenContext = _index.TokenContext.normal; + } + enterForXStatementInit(isForOf) { + if (isForOf) { + this.tokenContext |= _index.TokenContext.forOfHead; + return null; + } else { + this.tokenContext |= _index.TokenContext.forInHead | _index.TokenContext.forInOrInitHeadAccumulate; + return () => this.tokenContext = _index.TokenContext.normal; + } + } + enterDelimited() { + const oldTokenContext = this.tokenContext; + const oldNoLineTerminatorAfterNode = this._noLineTerminatorAfterNode; + if (!(oldTokenContext & _index.TokenContext.forInOrInitHeadAccumulate) && oldNoLineTerminatorAfterNode === null) { + return () => {}; + } + this._noLineTerminatorAfterNode = null; + this.tokenContext = _index.TokenContext.normal; + return () => { + this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode; + this.tokenContext = oldTokenContext; + }; + } + generate(ast) { + if (this.format.preserveFormat) { + this.tokenMap = new _tokenMap.TokenMap(ast, this._tokens, this._originalCode); + } + this.print(ast); + this._maybeAddAuxComment(); + return this._buf.get(); + } + indent() { + const { + format + } = this; + if (format.preserveFormat || format.compact || format.concise) { + return; + } + this._indent++; + } + dedent() { + const { + format + } = this; + if (format.preserveFormat || format.compact || format.concise) { + return; + } + this._indent--; + } + semicolon(force = false) { + this._maybeAddAuxComment(); + if (force) { + this._appendChar(59); + this._noLineTerminator = false; + return; + } + if (this.tokenMap) { + const node = this._currentNode; + if (node.start != null && node.end != null) { + if (!this.tokenMap.endMatches(node, ";")) { + this._printSemicolonBeforeNextNode = this._buf.getCurrentLine(); + return; + } + const indexes = this.tokenMap.getIndexes(this._currentNode); + this._catchUpTo(this._tokens[indexes[indexes.length - 1]].loc.start); + } + } + this._queue(59); + this._noLineTerminator = false; + } + rightBrace(node) { + if (this.format.minified) { + this._buf.removeLastSemicolon(); + } + this.sourceWithOffset("end", node.loc, -1); + this.tokenChar(125); + } + rightParens(node) { + this.sourceWithOffset("end", node.loc, -1); + this.tokenChar(41); + } + space(force = false) { + const { + format + } = this; + if (format.compact || format.preserveFormat) return; + if (force) { + this._space(); + } else if (this._buf.hasContent()) { + const lastCp = this.getLastChar(); + if (lastCp !== 32 && lastCp !== 10) { + this._space(); + } + } + } + word(str, noLineTerminatorAfter = false) { + this.tokenContext &= _index.TokenContext.forInOrInitHeadAccumulatePassThroughMask; + this._maybePrintInnerComments(str); + this._maybeAddAuxComment(); + if (this.tokenMap) this._catchUpToCurrentToken(str); + if (this._endsWithWord || this._endsWithDiv && str.charCodeAt(0) === 47) { + this._space(); + } + this._append(str, false); + this._endsWithWord = true; + this._noLineTerminator = noLineTerminatorAfter; + } + number(str, number) { + function isNonDecimalLiteral(str) { + if (str.length > 2 && str.charCodeAt(0) === 48) { + const secondChar = str.charCodeAt(1); + return secondChar === 98 || secondChar === 111 || secondChar === 120; + } + return false; + } + this.word(str); + this._endsWithInteger = Number.isInteger(number) && !isNonDecimalLiteral(str) && !SCIENTIFIC_NOTATION.test(str) && !ZERO_DECIMAL_INTEGER.test(str) && str.charCodeAt(str.length - 1) !== 46; + } + token(str, maybeNewline = false, occurrenceCount = 0) { + this.tokenContext &= _index.TokenContext.forInOrInitHeadAccumulatePassThroughMask; + this._maybePrintInnerComments(str, occurrenceCount); + this._maybeAddAuxComment(); + if (this.tokenMap) this._catchUpToCurrentToken(str, occurrenceCount); + const lastChar = this.getLastChar(); + const strFirst = str.charCodeAt(0); + if (lastChar === 33 && (str === "--" || strFirst === 61) || strFirst === 43 && lastChar === 43 || strFirst === 45 && lastChar === 45 || strFirst === 46 && this._endsWithInteger) { + this._space(); + } + this._append(str, maybeNewline); + this._noLineTerminator = false; + } + tokenChar(char) { + this.tokenContext &= _index.TokenContext.forInOrInitHeadAccumulatePassThroughMask; + const str = String.fromCharCode(char); + this._maybePrintInnerComments(str); + this._maybeAddAuxComment(); + if (this.tokenMap) this._catchUpToCurrentToken(str); + const lastChar = this.getLastChar(); + if (char === 43 && lastChar === 43 || char === 45 && lastChar === 45 || char === 46 && this._endsWithInteger) { + this._space(); + } + this._appendChar(char); + this._noLineTerminator = false; + } + newline(i = 1, force) { + if (i <= 0) return; + if (!force) { + if (this.format.retainLines || this.format.compact) return; + if (this.format.concise) { + this.space(); + return; + } + } + if (i > 2) i = 2; + i -= this._buf.getNewlineCount(); + for (let j = 0; j < i; j++) { + this._newline(); + } + return; + } + endsWith(char) { + return this.getLastChar() === char; + } + getLastChar() { + return this._buf.getLastChar(); + } + endsWithCharAndNewline() { + return this._buf.endsWithCharAndNewline(); + } + removeTrailingNewline() { + this._buf.removeTrailingNewline(); + } + exactSource(loc, cb) { + if (!loc) { + cb(); + return; + } + this._catchUp("start", loc); + this._buf.exactSource(loc, cb); + } + source(prop, loc) { + if (!loc) return; + this._catchUp(prop, loc); + this._buf.source(prop, loc); + } + sourceWithOffset(prop, loc, columnOffset) { + if (!loc || this.format.preserveFormat) return; + this._catchUp(prop, loc); + this._buf.sourceWithOffset(prop, loc, columnOffset); + } + sourceIdentifierName(identifierName, pos) { + if (!this._buf._canMarkIdName) return; + const sourcePosition = this._buf._sourcePosition; + sourcePosition.identifierNamePos = pos; + sourcePosition.identifierName = identifierName; + } + _space() { + this._queue(32); + } + _newline() { + this._queue(10); + } + _catchUpToCurrentToken(str, occurrenceCount = 0) { + const token = this.tokenMap.findMatching(this._currentNode, str, occurrenceCount); + if (token) this._catchUpTo(token.loc.start); + if (this._printSemicolonBeforeNextToken !== -1 && this._printSemicolonBeforeNextToken === this._buf.getCurrentLine()) { + this._buf.appendChar(59); + this._endsWithWord = false; + this._endsWithInteger = false; + this._endsWithDiv = false; + } + this._printSemicolonBeforeNextToken = -1; + this._printSemicolonBeforeNextNode = -1; + } + _append(str, maybeNewline) { + this._maybeIndent(str.charCodeAt(0)); + this._buf.append(str, maybeNewline); + this._endsWithWord = false; + this._endsWithInteger = false; + this._endsWithDiv = false; + } + _appendChar(char) { + this._maybeIndent(char); + this._buf.appendChar(char); + this._endsWithWord = false; + this._endsWithInteger = false; + this._endsWithDiv = false; + } + _queue(char) { + this._maybeIndent(char); + this._buf.queue(char); + this._endsWithWord = false; + this._endsWithInteger = false; + } + _maybeIndent(firstChar) { + if (this._indent && firstChar !== 10 && this.endsWith(10)) { + this._buf.queueIndentation(this._getIndent()); + } + } + _shouldIndent(firstChar) { + if (this._indent && firstChar !== 10 && this.endsWith(10)) { + return true; + } + } + catchUp(line) { + if (!this.format.retainLines) return; + const count = line - this._buf.getCurrentLine(); + for (let i = 0; i < count; i++) { + this._newline(); + } + } + _catchUp(prop, loc) { + const { + format + } = this; + if (!format.preserveFormat) { + if (format.retainLines && loc != null && loc[prop]) { + this.catchUp(loc[prop].line); + } + return; + } + const pos = loc == null ? void 0 : loc[prop]; + if (pos != null) this._catchUpTo(pos); + } + _catchUpTo({ + line, + column, + index + }) { + const count = line - this._buf.getCurrentLine(); + if (count > 0 && this._noLineTerminator) { + return; + } + for (let i = 0; i < count; i++) { + this._newline(); + } + const spacesCount = count > 0 ? column : column - this._buf.getCurrentColumn(); + if (spacesCount > 0) { + const spaces = this._originalCode ? this._originalCode.slice(index - spacesCount, index).replace(/[^\t\x0B\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]/gu, " ") : " ".repeat(spacesCount); + this._append(spaces, false); + } + } + _getIndent() { + return this._indentRepeat * this._indent; + } + printTerminatorless(node) { + this._noLineTerminator = true; + this.print(node); + } + print(node, noLineTerminatorAfter, trailingCommentsLineOffset) { + var _node$extra, _node$leadingComments, _node$leadingComments2; + if (!node) return; + this._endsWithInnerRaw = false; + const nodeType = node.type; + const format = this.format; + const oldConcise = format.concise; + if (node._compact) { + format.concise = true; + } + const printMethod = this[nodeType]; + if (printMethod === undefined) { + throw new ReferenceError(`unknown node of type ${JSON.stringify(nodeType)} with constructor ${JSON.stringify(node.constructor.name)}`); + } + const parent = this._currentNode; + this._currentNode = node; + if (this.tokenMap) { + this._printSemicolonBeforeNextToken = this._printSemicolonBeforeNextNode; + } + const oldInAux = this._insideAux; + this._insideAux = node.loc == null; + this._maybeAddAuxComment(this._insideAux && !oldInAux); + const parenthesized = (_node$extra = node.extra) == null ? void 0 : _node$extra.parenthesized; + let shouldPrintParens = parenthesized && format.preserveFormat || parenthesized && format.retainFunctionParens && nodeType === "FunctionExpression" || needsParens(node, parent, this.tokenContext, format.preserveFormat ? this._boundGetRawIdentifier : undefined); + if (!shouldPrintParens && parenthesized && (_node$leadingComments = node.leadingComments) != null && _node$leadingComments.length && node.leadingComments[0].type === "CommentBlock") { + const parentType = parent == null ? void 0 : parent.type; + switch (parentType) { + case "ExpressionStatement": + case "VariableDeclarator": + case "AssignmentExpression": + case "ReturnStatement": + break; + case "CallExpression": + case "OptionalCallExpression": + case "NewExpression": + if (parent.callee !== node) break; + default: + shouldPrintParens = true; + } + } + let indentParenthesized = false; + if (!shouldPrintParens && this._noLineTerminator && ((_node$leadingComments2 = node.leadingComments) != null && _node$leadingComments2.some(commentIsNewline) || this.format.retainLines && node.loc && node.loc.start.line > this._buf.getCurrentLine())) { + shouldPrintParens = true; + indentParenthesized = true; + } + let oldNoLineTerminatorAfterNode; + let oldTokenContext; + if (!shouldPrintParens) { + noLineTerminatorAfter || (noLineTerminatorAfter = parent && this._noLineTerminatorAfterNode === parent && n.isLastChild(parent, node)); + if (noLineTerminatorAfter) { + var _node$trailingComment; + if ((_node$trailingComment = node.trailingComments) != null && _node$trailingComment.some(commentIsNewline)) { + if (isExpression(node)) shouldPrintParens = true; + } else { + oldNoLineTerminatorAfterNode = this._noLineTerminatorAfterNode; + this._noLineTerminatorAfterNode = node; + } + } + } + if (shouldPrintParens) { + this.tokenChar(40); + if (indentParenthesized) this.indent(); + this._endsWithInnerRaw = false; + if (this.tokenContext & _index.TokenContext.forInOrInitHeadAccumulate) { + oldTokenContext = this.tokenContext; + this.tokenContext = _index.TokenContext.normal; + } + oldNoLineTerminatorAfterNode = this._noLineTerminatorAfterNode; + this._noLineTerminatorAfterNode = null; + } + this._lastCommentLine = 0; + this._printLeadingComments(node, parent); + const loc = nodeType === "Program" || nodeType === "File" ? null : node.loc; + this.exactSource(loc, printMethod.bind(this, node, parent)); + if (shouldPrintParens) { + this._printTrailingComments(node, parent); + if (indentParenthesized) { + this.dedent(); + this.newline(); + } + this.tokenChar(41); + this._noLineTerminator = noLineTerminatorAfter; + if (oldTokenContext) this.tokenContext = oldTokenContext; + } else if (noLineTerminatorAfter && !this._noLineTerminator) { + this._noLineTerminator = true; + this._printTrailingComments(node, parent); + } else { + this._printTrailingComments(node, parent, trailingCommentsLineOffset); + } + this._currentNode = parent; + format.concise = oldConcise; + this._insideAux = oldInAux; + if (oldNoLineTerminatorAfterNode !== undefined) { + this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode; + } + this._endsWithInnerRaw = false; + } + _maybeAddAuxComment(enteredPositionlessNode) { + if (enteredPositionlessNode) this._printAuxBeforeComment(); + if (!this._insideAux) this._printAuxAfterComment(); + } + _printAuxBeforeComment() { + if (this._printAuxAfterOnNextUserNode) return; + this._printAuxAfterOnNextUserNode = true; + const comment = this.format.auxiliaryCommentBefore; + if (comment) { + this._printComment({ + type: "CommentBlock", + value: comment + }, 0); + } + } + _printAuxAfterComment() { + if (!this._printAuxAfterOnNextUserNode) return; + this._printAuxAfterOnNextUserNode = false; + const comment = this.format.auxiliaryCommentAfter; + if (comment) { + this._printComment({ + type: "CommentBlock", + value: comment + }, 0); + } + } + getPossibleRaw(node) { + const extra = node.extra; + if ((extra == null ? void 0 : extra.raw) != null && extra.rawValue != null && node.value === extra.rawValue) { + return extra.raw; + } + } + printJoin(nodes, statement, indent, separator, printTrailingSeparator, addNewlines, iterator, trailingCommentsLineOffset) { + if (!(nodes != null && nodes.length)) return; + if (indent == null && this.format.retainLines) { + var _nodes$0$loc; + const startLine = (_nodes$0$loc = nodes[0].loc) == null ? void 0 : _nodes$0$loc.start.line; + if (startLine != null && startLine !== this._buf.getCurrentLine()) { + indent = true; + } + } + if (indent) this.indent(); + const newlineOpts = { + addNewlines: addNewlines, + nextNodeStartLine: 0 + }; + const boundSeparator = separator == null ? void 0 : separator.bind(this); + const len = nodes.length; + for (let i = 0; i < len; i++) { + const node = nodes[i]; + if (!node) continue; + if (statement) this._printNewline(i === 0, newlineOpts); + this.print(node, undefined, trailingCommentsLineOffset || 0); + iterator == null || iterator(node, i); + if (boundSeparator != null) { + if (i < len - 1) boundSeparator(i, false);else if (printTrailingSeparator) boundSeparator(i, true); + } + if (statement) { + var _node$trailingComment2; + if (!((_node$trailingComment2 = node.trailingComments) != null && _node$trailingComment2.length)) { + this._lastCommentLine = 0; + } + if (i + 1 === len) { + this.newline(1); + } else { + var _nextNode$loc; + const nextNode = nodes[i + 1]; + newlineOpts.nextNodeStartLine = ((_nextNode$loc = nextNode.loc) == null ? void 0 : _nextNode$loc.start.line) || 0; + this._printNewline(true, newlineOpts); + } + } + } + if (indent) this.dedent(); + } + printAndIndentOnComments(node) { + const indent = node.leadingComments && node.leadingComments.length > 0; + if (indent) this.indent(); + this.print(node); + if (indent) this.dedent(); + } + printBlock(parent) { + const node = parent.body; + if (node.type !== "EmptyStatement") { + this.space(); + } + this.print(node); + } + _printTrailingComments(node, parent, lineOffset) { + const { + innerComments, + trailingComments + } = node; + if (innerComments != null && innerComments.length) { + this._printComments(2, innerComments, node, parent, lineOffset); + } + if (trailingComments != null && trailingComments.length) { + this._printComments(2, trailingComments, node, parent, lineOffset); + } + } + _printLeadingComments(node, parent) { + const comments = node.leadingComments; + if (!(comments != null && comments.length)) return; + this._printComments(0, comments, node, parent); + } + _maybePrintInnerComments(nextTokenStr, nextTokenOccurrenceCount) { + if (this._endsWithInnerRaw) { + var _this$tokenMap; + this.printInnerComments((_this$tokenMap = this.tokenMap) == null ? void 0 : _this$tokenMap.findMatching(this._currentNode, nextTokenStr, nextTokenOccurrenceCount)); + } + this._endsWithInnerRaw = true; + this._indentInnerComments = true; + } + printInnerComments(nextToken) { + const node = this._currentNode; + const comments = node.innerComments; + if (!(comments != null && comments.length)) return; + const hasSpace = this.endsWith(32); + const indent = this._indentInnerComments; + const printedCommentsCount = this._printedComments.size; + if (indent) this.indent(); + this._printComments(1, comments, node, undefined, undefined, nextToken); + if (hasSpace && printedCommentsCount !== this._printedComments.size) { + this.space(); + } + if (indent) this.dedent(); + } + noIndentInnerCommentsHere() { + this._indentInnerComments = false; + } + printSequence(nodes, indent, trailingCommentsLineOffset, addNewlines) { + this.printJoin(nodes, true, indent != null ? indent : false, undefined, undefined, addNewlines, undefined, trailingCommentsLineOffset); + } + printList(items, printTrailingSeparator, statement, indent, separator, iterator) { + this.printJoin(items, statement, indent, separator != null ? separator : commaSeparator, printTrailingSeparator, undefined, iterator); + } + shouldPrintTrailingComma(listEnd) { + if (!this.tokenMap) return null; + const listEndIndex = this.tokenMap.findLastIndex(this._currentNode, token => this.tokenMap.matchesOriginal(token, listEnd)); + if (listEndIndex <= 0) return null; + return this.tokenMap.matchesOriginal(this._tokens[listEndIndex - 1], ","); + } + _printNewline(newLine, opts) { + const format = this.format; + if (format.retainLines || format.compact) return; + if (format.concise) { + this.space(); + return; + } + if (!newLine) { + return; + } + const startLine = opts.nextNodeStartLine; + const lastCommentLine = this._lastCommentLine; + if (startLine > 0 && lastCommentLine > 0) { + const offset = startLine - lastCommentLine; + if (offset >= 0) { + this.newline(offset || 1); + return; + } + } + if (this._buf.hasContent()) { + this.newline(1); + } + } + _shouldPrintComment(comment, nextToken) { + if (comment.ignore) return 0; + if (this._printedComments.has(comment)) return 0; + if (this._noLineTerminator && HAS_NEWLINE_OR_BlOCK_COMMENT_END.test(comment.value)) { + return 2; + } + if (nextToken && this.tokenMap) { + const commentTok = this.tokenMap.find(this._currentNode, token => token.value === comment.value); + if (commentTok && commentTok.start > nextToken.start) { + return 2; + } + } + this._printedComments.add(comment); + if (!this.format.shouldPrintComment(comment.value)) { + return 0; + } + return 1; + } + _printComment(comment, skipNewLines) { + const noLineTerminator = this._noLineTerminator; + const isBlockComment = comment.type === "CommentBlock"; + const printNewLines = isBlockComment && skipNewLines !== 1 && !this._noLineTerminator; + if (printNewLines && this._buf.hasContent() && skipNewLines !== 2) { + this.newline(1); + } + const lastCharCode = this.getLastChar(); + if (lastCharCode !== 91 && lastCharCode !== 123 && lastCharCode !== 40) { + this.space(); + } + let val; + if (isBlockComment) { + val = `/*${comment.value}*/`; + if (this.format.indent.adjustMultilineComment) { + var _comment$loc; + const offset = (_comment$loc = comment.loc) == null ? void 0 : _comment$loc.start.column; + if (offset) { + const newlineRegex = new RegExp("\\n\\s{1," + offset + "}", "g"); + val = val.replace(newlineRegex, "\n"); + } + if (this.format.concise) { + val = val.replace(/\n(?!$)/g, `\n`); + } else { + let indentSize = this.format.retainLines ? 0 : this._buf.getCurrentColumn(); + if (this._shouldIndent(47) || this.format.retainLines) { + indentSize += this._getIndent(); + } + val = val.replace(/\n(?!$)/g, `\n${" ".repeat(indentSize)}`); + } + } + } else if (!noLineTerminator) { + val = `//${comment.value}`; + } else { + val = `/*${comment.value}*/`; + } + if (this._endsWithDiv) this._space(); + if (this.tokenMap) { + const { + _printSemicolonBeforeNextToken, + _printSemicolonBeforeNextNode + } = this; + this._printSemicolonBeforeNextToken = -1; + this._printSemicolonBeforeNextNode = -1; + this.source("start", comment.loc); + this._append(val, isBlockComment); + this._printSemicolonBeforeNextNode = _printSemicolonBeforeNextNode; + this._printSemicolonBeforeNextToken = _printSemicolonBeforeNextToken; + } else { + this.source("start", comment.loc); + this._append(val, isBlockComment); + } + if (!isBlockComment && !noLineTerminator) { + this.newline(1, true); + } + if (printNewLines && skipNewLines !== 3) { + this.newline(1); + } + } + _printComments(type, comments, node, parent, lineOffset = 0, nextToken) { + const nodeLoc = node.loc; + const len = comments.length; + let hasLoc = !!nodeLoc; + const nodeStartLine = hasLoc ? nodeLoc.start.line : 0; + const nodeEndLine = hasLoc ? nodeLoc.end.line : 0; + let lastLine = 0; + let leadingCommentNewline = 0; + const maybeNewline = this._noLineTerminator ? function () {} : this.newline.bind(this); + for (let i = 0; i < len; i++) { + const comment = comments[i]; + const shouldPrint = this._shouldPrintComment(comment, nextToken); + if (shouldPrint === 2) { + hasLoc = false; + break; + } + if (hasLoc && comment.loc && shouldPrint === 1) { + const commentStartLine = comment.loc.start.line; + const commentEndLine = comment.loc.end.line; + if (type === 0) { + let offset = 0; + if (i === 0) { + if (this._buf.hasContent() && (comment.type === "CommentLine" || commentStartLine !== commentEndLine)) { + offset = leadingCommentNewline = 1; + } + } else { + offset = commentStartLine - lastLine; + } + lastLine = commentEndLine; + maybeNewline(offset); + this._printComment(comment, 1); + if (i + 1 === len) { + maybeNewline(Math.max(nodeStartLine - lastLine, leadingCommentNewline)); + lastLine = nodeStartLine; + } + } else if (type === 1) { + const offset = commentStartLine - (i === 0 ? nodeStartLine : lastLine); + lastLine = commentEndLine; + maybeNewline(offset); + this._printComment(comment, 1); + if (i + 1 === len) { + maybeNewline(Math.min(1, nodeEndLine - lastLine)); + lastLine = nodeEndLine; + } + } else { + const offset = commentStartLine - (i === 0 ? nodeEndLine - lineOffset : lastLine); + lastLine = commentEndLine; + maybeNewline(offset); + this._printComment(comment, 1); + } + } else { + hasLoc = false; + if (shouldPrint !== 1) { + continue; + } + if (len === 1) { + const singleLine = comment.loc ? comment.loc.start.line === comment.loc.end.line : !HAS_NEWLINE.test(comment.value); + const shouldSkipNewline = singleLine && !isStatement(node) && !isClassBody(parent) && !isTSInterfaceBody(parent) && !isTSEnumMember(node); + if (type === 0) { + this._printComment(comment, shouldSkipNewline && node.type !== "ObjectExpression" || singleLine && isFunction(parent, { + body: node + }) ? 1 : 0); + } else if (shouldSkipNewline && type === 2) { + this._printComment(comment, 1); + } else { + this._printComment(comment, 0); + } + } else if (type === 1 && !(node.type === "ObjectExpression" && node.properties.length > 1) && node.type !== "ClassBody" && node.type !== "TSInterfaceBody") { + this._printComment(comment, i === 0 ? 2 : i === len - 1 ? 3 : 0); + } else { + this._printComment(comment, 0); + } + } + } + if (type === 2 && hasLoc && lastLine) { + this._lastCommentLine = lastLine; + } + } +} +Object.assign(Printer.prototype, generatorFunctions); +{ + (0, _deprecated.addDeprecatedGenerators)(Printer); +} +var _default = exports.default = Printer; +function commaSeparator(occurrenceCount, last) { + this.token(",", false, occurrenceCount); + if (!last) this.space(); +} + +//# sourceMappingURL=printer.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/printer.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/printer.js.map new file mode 100644 index 0000000000000000000000000000000000000000..de4027eed847645f2d018bf7fda2b432376c5922 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/generator/lib/printer.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_buffer","require","_index","n","_t","_tokenMap","generatorFunctions","_deprecated","isExpression","isFunction","isStatement","isClassBody","isTSInterfaceBody","isTSEnumMember","SCIENTIFIC_NOTATION","ZERO_DECIMAL_INTEGER","HAS_NEWLINE","HAS_NEWLINE_OR_BlOCK_COMMENT_END","commentIsNewline","c","type","test","value","needsParens","Printer","constructor","format","map","tokens","originalCode","tokenContext","TokenContext","normal","_tokens","_originalCode","_currentNode","_indent","_indentRepeat","_insideAux","_noLineTerminator","_noLineTerminatorAfterNode","_printAuxAfterOnNextUserNode","_printedComments","Set","_endsWithInteger","_endsWithWord","_endsWithDiv","_lastCommentLine","_endsWithInnerRaw","_indentInnerComments","tokenMap","_boundGetRawIdentifier","_getRawIdentifier","bind","_printSemicolonBeforeNextNode","_printSemicolonBeforeNextToken","indent","style","length","_inputMap","_buf","Buffer","enterForStatementInit","forInitHead","forInOrInitHeadAccumulate","enterForXStatementInit","isForOf","forOfHead","forInHead","enterDelimited","oldTokenContext","oldNoLineTerminatorAfterNode","generate","ast","preserveFormat","TokenMap","print","_maybeAddAuxComment","get","compact","concise","dedent","semicolon","force","_appendChar","node","start","end","endMatches","getCurrentLine","indexes","getIndexes","_catchUpTo","loc","_queue","rightBrace","minified","removeLastSemicolon","sourceWithOffset","token","rightParens","space","_space","hasContent","lastCp","getLastChar","word","str","noLineTerminatorAfter","forInOrInitHeadAccumulatePassThroughMask","_maybePrintInnerComments","_catchUpToCurrentToken","charCodeAt","_append","number","isNonDecimalLiteral","secondChar","Number","isInteger","maybeNewline","occurrenceCount","lastChar","strFirst","tokenChar","char","String","fromCharCode","newline","i","retainLines","getNewlineCount","j","_newline","endsWith","endsWithCharAndNewline","removeTrailingNewline","exactSource","cb","_catchUp","source","prop","columnOffset","sourceIdentifierName","identifierName","pos","_canMarkIdName","sourcePosition","_sourcePosition","identifierNamePos","findMatching","appendChar","_maybeIndent","append","queue","firstChar","queueIndentation","_getIndent","_shouldIndent","catchUp","line","count","column","index","spacesCount","getCurrentColumn","spaces","slice","replace","repeat","printTerminatorless","trailingCommentsLineOffset","_node$extra","_node$leadingComments","_node$leadingComments2","nodeType","oldConcise","_compact","printMethod","undefined","ReferenceError","JSON","stringify","name","parent","oldInAux","parenthesized","extra","shouldPrintParens","retainFunctionParens","leadingComments","parentType","callee","indentParenthesized","some","isLastChild","_node$trailingComment","trailingComments","_printLeadingComments","_printTrailingComments","enteredPositionlessNode","_printAuxBeforeComment","_printAuxAfterComment","comment","auxiliaryCommentBefore","_printComment","auxiliaryCommentAfter","getPossibleRaw","raw","rawValue","printJoin","nodes","statement","separator","printTrailingSeparator","addNewlines","iterator","_nodes$0$loc","startLine","newlineOpts","nextNodeStartLine","boundSeparator","len","_printNewline","_node$trailingComment2","_nextNode$loc","nextNode","printAndIndentOnComments","printBlock","body","lineOffset","innerComments","_printComments","comments","nextTokenStr","nextTokenOccurrenceCount","_this$tokenMap","printInnerComments","nextToken","hasSpace","printedCommentsCount","size","noIndentInnerCommentsHere","printSequence","printList","items","commaSeparator","shouldPrintTrailingComma","listEnd","listEndIndex","findLastIndex","matchesOriginal","newLine","opts","lastCommentLine","offset","_shouldPrintComment","ignore","has","commentTok","find","add","shouldPrintComment","skipNewLines","noLineTerminator","isBlockComment","printNewLines","lastCharCode","val","adjustMultilineComment","_comment$loc","newlineRegex","RegExp","indentSize","nodeLoc","hasLoc","nodeStartLine","nodeEndLine","lastLine","leadingCommentNewline","shouldPrint","commentStartLine","commentEndLine","Math","max","min","singleLine","shouldSkipNewline","properties","Object","assign","prototype","addDeprecatedGenerators","_default","exports","default","last"],"sources":["../src/printer.ts"],"sourcesContent":["import Buffer, { type Pos } from \"./buffer.ts\";\nimport type { Loc } from \"./buffer.ts\";\nimport * as n from \"./node/index.ts\";\nimport type * as t from \"@babel/types\";\nimport {\n isExpression,\n isFunction,\n isStatement,\n isClassBody,\n isTSInterfaceBody,\n isTSEnumMember,\n} from \"@babel/types\";\nimport type { Opts as jsescOptions } from \"jsesc\";\n\nimport { TokenMap } from \"./token-map.ts\";\nimport type { GeneratorOptions } from \"./index.ts\";\nimport * as generatorFunctions from \"./generators/index.ts\";\nimport {\n addDeprecatedGenerators,\n type DeprecatedBabel7ASTTypes,\n} from \"./generators/deprecated.ts\";\nimport type SourceMap from \"./source-map.ts\";\nimport type { TraceMap } from \"@jridgewell/trace-mapping\";\nimport type { Token } from \"@babel/parser\";\n\n// We inline this package\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport * as charCodes from \"charcodes\";\n\nconst SCIENTIFIC_NOTATION = /e/i;\nconst ZERO_DECIMAL_INTEGER = /\\.0+$/;\nconst HAS_NEWLINE = /[\\n\\r\\u2028\\u2029]/;\nconst HAS_NEWLINE_OR_BlOCK_COMMENT_END = /[\\n\\r\\u2028\\u2029]|\\*\\//;\n\nfunction commentIsNewline(c: t.Comment) {\n return c.type === \"CommentLine\" || HAS_NEWLINE.test(c.value);\n}\n\nconst { needsParens } = n;\n\nimport { TokenContext } from \"./node/index.ts\";\n\nconst enum COMMENT_TYPE {\n LEADING,\n INNER,\n TRAILING,\n}\n\nconst enum COMMENT_SKIP_NEWLINE {\n DEFAULT,\n ALL,\n LEADING,\n TRAILING,\n}\n\nconst enum PRINT_COMMENT_HINT {\n SKIP,\n ALLOW,\n DEFER,\n}\n\nexport type Format = {\n shouldPrintComment: (comment: string) => boolean;\n preserveFormat: boolean;\n retainLines: boolean;\n retainFunctionParens: boolean;\n comments: boolean;\n auxiliaryCommentBefore: string;\n auxiliaryCommentAfter: string;\n compact: boolean | \"auto\";\n minified: boolean;\n concise: boolean;\n indent: {\n adjustMultilineComment: boolean;\n style: string;\n };\n /**\n * @deprecated Removed in Babel 8, syntax type is always 'hash'\n */\n recordAndTupleSyntaxType?: GeneratorOptions[\"recordAndTupleSyntaxType\"];\n jsescOption: jsescOptions;\n /**\n * @deprecated Removed in Babel 8, use `jsescOption` instead\n */\n jsonCompatibleStrings?: boolean;\n /**\n * For use with the Hack-style pipe operator.\n * Changes what token is used for pipe bodies’ topic references.\n */\n topicToken?: GeneratorOptions[\"topicToken\"];\n /**\n * @deprecated Removed in Babel 8\n */\n decoratorsBeforeExport?: boolean;\n /**\n * The import attributes syntax style:\n * - \"with\" : `import { a } from \"b\" with { type: \"json\" };`\n * - \"assert\" : `import { a } from \"b\" assert { type: \"json\" };`\n * - \"with-legacy\" : `import { a } from \"b\" with type: \"json\";`\n */\n importAttributesKeyword?: \"with\" | \"assert\" | \"with-legacy\";\n};\n\ninterface AddNewlinesOptions {\n addNewlines(leading: boolean, node: t.Node): number;\n nextNodeStartLine: number;\n}\n\ninterface PrintSequenceOptions extends Partial {\n statement?: boolean;\n indent?: boolean;\n trailingCommentsLineOffset?: number;\n}\n\ninterface PrintListOptions {\n separator?: (this: Printer, occurrenceCount: number, last: boolean) => void;\n iterator?: (node: t.Node, index: number) => void;\n statement?: boolean;\n indent?: boolean;\n printTrailingSeparator?: boolean;\n}\n\nexport type PrintJoinOptions = PrintListOptions & PrintSequenceOptions;\nclass Printer {\n constructor(\n format: Format,\n map: SourceMap,\n tokens?: Token[],\n originalCode?: string,\n ) {\n this.format = format;\n\n this._tokens = tokens;\n this._originalCode = originalCode;\n\n this._indentRepeat = format.indent.style.length;\n\n this._inputMap = map?._inputMap;\n\n this._buf = new Buffer(map, format.indent.style[0]);\n }\n declare _inputMap: TraceMap;\n\n declare format: Format;\n\n enterForStatementInit() {\n this.tokenContext |=\n TokenContext.forInitHead | TokenContext.forInOrInitHeadAccumulate;\n return () => (this.tokenContext = TokenContext.normal);\n }\n\n enterForXStatementInit(isForOf: boolean) {\n if (isForOf) {\n this.tokenContext |= TokenContext.forOfHead;\n return null;\n } else {\n this.tokenContext |=\n TokenContext.forInHead | TokenContext.forInOrInitHeadAccumulate;\n return () => (this.tokenContext = TokenContext.normal);\n }\n }\n\n enterDelimited() {\n const oldTokenContext = this.tokenContext;\n const oldNoLineTerminatorAfterNode = this._noLineTerminatorAfterNode;\n if (\n !(oldTokenContext & TokenContext.forInOrInitHeadAccumulate) &&\n oldNoLineTerminatorAfterNode === null\n ) {\n return () => {};\n }\n this._noLineTerminatorAfterNode = null;\n this.tokenContext = TokenContext.normal;\n return () => {\n this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;\n this.tokenContext = oldTokenContext;\n };\n }\n\n tokenContext: number = TokenContext.normal;\n\n _tokens: Token[] = null;\n _originalCode: string | null = null;\n\n declare _buf: Buffer;\n _currentNode: t.Node = null;\n _indent: number = 0;\n _indentRepeat: number = 0;\n _insideAux: boolean = false;\n _noLineTerminator: boolean = false;\n _noLineTerminatorAfterNode: t.Node | null = null;\n _printAuxAfterOnNextUserNode: boolean = false;\n _printedComments = new Set();\n _endsWithInteger = false;\n _endsWithWord = false;\n _endsWithDiv = false;\n _lastCommentLine = 0;\n _endsWithInnerRaw: boolean = false;\n _indentInnerComments: boolean = true;\n tokenMap: TokenMap = null;\n\n _boundGetRawIdentifier = this._getRawIdentifier.bind(this);\n\n generate(ast: t.Node) {\n if (this.format.preserveFormat) {\n this.tokenMap = new TokenMap(ast, this._tokens, this._originalCode);\n }\n this.print(ast);\n this._maybeAddAuxComment();\n\n return this._buf.get();\n }\n\n /**\n * Increment indent size.\n */\n\n indent(): void {\n const { format } = this;\n if (format.preserveFormat || format.compact || format.concise) {\n return;\n }\n\n this._indent++;\n }\n\n /**\n * Decrement indent size.\n */\n\n dedent(): void {\n const { format } = this;\n if (format.preserveFormat || format.compact || format.concise) {\n return;\n }\n\n this._indent--;\n }\n\n /**\n * If the next token is on the same line, we must first print a semicolon.\n * This option is only used in `preserveFormat` node, for semicolons that\n * might have omitted due to them being absent in the original code (thanks\n * to ASI).\n *\n * We need both *NextToken and *NextNode because we only want to insert the\n * semicolon when the next token starts a new node, and not in cases like\n * foo} (where } is not starting a new node). So we first set *NextNode, and\n * then the print() method will move it to *NextToken.\n */\n _printSemicolonBeforeNextNode: number = -1;\n _printSemicolonBeforeNextToken: number = -1;\n\n /**\n * Add a semicolon to the buffer.\n */\n semicolon(force: boolean = false): void {\n this._maybeAddAuxComment();\n if (force) {\n this._appendChar(charCodes.semicolon);\n this._noLineTerminator = false;\n return;\n }\n if (this.tokenMap) {\n const node = this._currentNode;\n if (node.start != null && node.end != null) {\n if (!this.tokenMap.endMatches(node, \";\")) {\n // no semicolon\n this._printSemicolonBeforeNextNode = this._buf.getCurrentLine();\n return;\n }\n const indexes = this.tokenMap.getIndexes(this._currentNode);\n this._catchUpTo(this._tokens[indexes[indexes.length - 1]].loc.start);\n }\n }\n this._queue(charCodes.semicolon);\n this._noLineTerminator = false;\n }\n\n /**\n * Add a right brace to the buffer.\n */\n\n rightBrace(node: t.Node): void {\n if (this.format.minified) {\n this._buf.removeLastSemicolon();\n }\n this.sourceWithOffset(\"end\", node.loc, -1);\n this.token(\"}\");\n }\n\n rightParens(node: t.Node): void {\n this.sourceWithOffset(\"end\", node.loc, -1);\n this.token(\")\");\n }\n\n /**\n * Add a space to the buffer unless it is compact.\n */\n\n space(force: boolean = false): void {\n const { format } = this;\n if (format.compact || format.preserveFormat) return;\n\n if (force) {\n this._space();\n } else if (this._buf.hasContent()) {\n const lastCp = this.getLastChar();\n if (lastCp !== charCodes.space && lastCp !== charCodes.lineFeed) {\n this._space();\n }\n }\n }\n\n /**\n * Writes a token that can't be safely parsed without taking whitespace into account.\n */\n\n word(str: string, noLineTerminatorAfter: boolean = false): void {\n this.tokenContext &= TokenContext.forInOrInitHeadAccumulatePassThroughMask;\n\n this._maybePrintInnerComments(str);\n\n this._maybeAddAuxComment();\n\n if (this.tokenMap) this._catchUpToCurrentToken(str);\n\n // prevent concatenating words and creating // comment out of division and regex\n if (\n this._endsWithWord ||\n (this._endsWithDiv && str.charCodeAt(0) === charCodes.slash)\n ) {\n this._space();\n }\n this._append(str, false);\n\n this._endsWithWord = true;\n this._noLineTerminator = noLineTerminatorAfter;\n }\n\n /**\n * Writes a number token so that we can validate if it is an integer.\n */\n\n number(str: string, number?: number): void {\n // const NON_DECIMAL_LITERAL = /^0[box]/;\n function isNonDecimalLiteral(str: string) {\n if (str.length > 2 && str.charCodeAt(0) === charCodes.digit0) {\n const secondChar = str.charCodeAt(1);\n return (\n secondChar === charCodes.lowercaseB ||\n secondChar === charCodes.lowercaseO ||\n secondChar === charCodes.lowercaseX\n );\n }\n return false;\n }\n this.word(str);\n\n // Integer tokens need special handling because they cannot have '.'s inserted\n // immediately after them.\n this._endsWithInteger =\n Number.isInteger(number) &&\n !isNonDecimalLiteral(str) &&\n !SCIENTIFIC_NOTATION.test(str) &&\n !ZERO_DECIMAL_INTEGER.test(str) &&\n str.charCodeAt(str.length - 1) !== charCodes.dot;\n }\n\n /**\n * Writes a simple token.\n *\n * @param {string} str The string to append.\n * @param {boolean} [maybeNewline=false] Wether `str` might potentially\n * contain a line terminator or not.\n * @param {number} [occurrenceCount=0] The occurrence count of this token in\n * the current node. This is used when printing in `preserveFormat` mode,\n * to know which token we should map to (for example, to disambiguate the\n * commas in an array literal).\n */\n token(str: string, maybeNewline = false, occurrenceCount = 0): void {\n this.tokenContext &= TokenContext.forInOrInitHeadAccumulatePassThroughMask;\n\n this._maybePrintInnerComments(str, occurrenceCount);\n\n this._maybeAddAuxComment();\n\n if (this.tokenMap) this._catchUpToCurrentToken(str, occurrenceCount);\n\n const lastChar = this.getLastChar();\n const strFirst = str.charCodeAt(0);\n if (\n (lastChar === charCodes.exclamationMark &&\n // space is mandatory to avoid outputting * (any, kinda silly) +// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0 +// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0 +// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0 +// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0 +// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0 +function replaceTildes (comp, options) { + return comp.trim().split(/\s+/).map(function (comp) { + return replaceTilde(comp, options) + }).join(' ') +} + +function replaceTilde (comp, options) { + var r = options.loose ? safeRe[t.TILDELOOSE] : safeRe[t.TILDE] + return comp.replace(r, function (_, M, m, p, pr) { + debug('tilde', comp, _, M, m, p, pr) + var ret + + if (isX(M)) { + ret = '' + } else if (isX(m)) { + ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0' + } else if (isX(p)) { + // ~1.2 == >=1.2.0 <1.3.0 + ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0' + } else if (pr) { + debug('replaceTilde pr', pr) + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + M + '.' + (+m + 1) + '.0' + } else { + // ~1.2.3 == >=1.2.3 <1.3.0 + ret = '>=' + M + '.' + m + '.' + p + + ' <' + M + '.' + (+m + 1) + '.0' + } + + debug('tilde return', ret) + return ret + }) +} + +// ^ --> * (any, kinda silly) +// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0 +// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0 +// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0 +// ^1.2.3 --> >=1.2.3 <2.0.0 +// ^1.2.0 --> >=1.2.0 <2.0.0 +function replaceCarets (comp, options) { + return comp.trim().split(/\s+/).map(function (comp) { + return replaceCaret(comp, options) + }).join(' ') +} + +function replaceCaret (comp, options) { + debug('caret', comp, options) + var r = options.loose ? safeRe[t.CARETLOOSE] : safeRe[t.CARET] + return comp.replace(r, function (_, M, m, p, pr) { + debug('caret', comp, _, M, m, p, pr) + var ret + + if (isX(M)) { + ret = '' + } else if (isX(m)) { + ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0' + } else if (isX(p)) { + if (M === '0') { + ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0' + } else { + ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0' + } + } else if (pr) { + debug('replaceCaret pr', pr) + if (M === '0') { + if (m === '0') { + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + M + '.' + m + '.' + (+p + 1) + } else { + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + M + '.' + (+m + 1) + '.0' + } + } else { + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + (+M + 1) + '.0.0' + } + } else { + debug('no pr') + if (M === '0') { + if (m === '0') { + ret = '>=' + M + '.' + m + '.' + p + + ' <' + M + '.' + m + '.' + (+p + 1) + } else { + ret = '>=' + M + '.' + m + '.' + p + + ' <' + M + '.' + (+m + 1) + '.0' + } + } else { + ret = '>=' + M + '.' + m + '.' + p + + ' <' + (+M + 1) + '.0.0' + } + } + + debug('caret return', ret) + return ret + }) +} + +function replaceXRanges (comp, options) { + debug('replaceXRanges', comp, options) + return comp.split(/\s+/).map(function (comp) { + return replaceXRange(comp, options) + }).join(' ') +} + +function replaceXRange (comp, options) { + comp = comp.trim() + var r = options.loose ? safeRe[t.XRANGELOOSE] : safeRe[t.XRANGE] + return comp.replace(r, function (ret, gtlt, M, m, p, pr) { + debug('xRange', comp, ret, gtlt, M, m, p, pr) + var xM = isX(M) + var xm = xM || isX(m) + var xp = xm || isX(p) + var anyX = xp + + if (gtlt === '=' && anyX) { + gtlt = '' + } + + // if we're including prereleases in the match, then we need + // to fix this to -0, the lowest possible prerelease value + pr = options.includePrerelease ? '-0' : '' + + if (xM) { + if (gtlt === '>' || gtlt === '<') { + // nothing is allowed + ret = '<0.0.0-0' + } else { + // nothing is forbidden + ret = '*' + } + } else if (gtlt && anyX) { + // we know patch is an x, because we have any x at all. + // replace X with 0 + if (xm) { + m = 0 + } + p = 0 + + if (gtlt === '>') { + // >1 => >=2.0.0 + // >1.2 => >=1.3.0 + // >1.2.3 => >= 1.2.4 + gtlt = '>=' + if (xm) { + M = +M + 1 + m = 0 + p = 0 + } else { + m = +m + 1 + p = 0 + } + } else if (gtlt === '<=') { + // <=0.7.x is actually <0.8.0, since any 0.7.x should + // pass. Similarly, <=7.x is actually <8.0.0, etc. + gtlt = '<' + if (xm) { + M = +M + 1 + } else { + m = +m + 1 + } + } + + ret = gtlt + M + '.' + m + '.' + p + pr + } else if (xm) { + ret = '>=' + M + '.0.0' + pr + ' <' + (+M + 1) + '.0.0' + pr + } else if (xp) { + ret = '>=' + M + '.' + m + '.0' + pr + + ' <' + M + '.' + (+m + 1) + '.0' + pr + } + + debug('xRange return', ret) + + return ret + }) +} + +// Because * is AND-ed with everything else in the comparator, +// and '' means "any version", just remove the *s entirely. +function replaceStars (comp, options) { + debug('replaceStars', comp, options) + // Looseness is ignored here. star is always as loose as it gets! + return comp.trim().replace(safeRe[t.STAR], '') +} + +// This function is passed to string.replace(re[t.HYPHENRANGE]) +// M, m, patch, prerelease, build +// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5 +// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do +// 1.2 - 3.4 => >=1.2.0 <3.5.0 +function hyphenReplace ($0, + from, fM, fm, fp, fpr, fb, + to, tM, tm, tp, tpr, tb) { + if (isX(fM)) { + from = '' + } else if (isX(fm)) { + from = '>=' + fM + '.0.0' + } else if (isX(fp)) { + from = '>=' + fM + '.' + fm + '.0' + } else { + from = '>=' + from + } + + if (isX(tM)) { + to = '' + } else if (isX(tm)) { + to = '<' + (+tM + 1) + '.0.0' + } else if (isX(tp)) { + to = '<' + tM + '.' + (+tm + 1) + '.0' + } else if (tpr) { + to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr + } else { + to = '<=' + to + } + + return (from + ' ' + to).trim() +} + +// if ANY of the sets match ALL of its comparators, then pass +Range.prototype.test = function (version) { + if (!version) { + return false + } + + if (typeof version === 'string') { + try { + version = new SemVer(version, this.options) + } catch (er) { + return false + } + } + + for (var i = 0; i < this.set.length; i++) { + if (testSet(this.set[i], version, this.options)) { + return true + } + } + return false +} + +function testSet (set, version, options) { + for (var i = 0; i < set.length; i++) { + if (!set[i].test(version)) { + return false + } + } + + if (version.prerelease.length && !options.includePrerelease) { + // Find the set of versions that are allowed to have prereleases + // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0 + // That should allow `1.2.3-pr.2` to pass. + // However, `1.2.4-alpha.notready` should NOT be allowed, + // even though it's within the range set by the comparators. + for (i = 0; i < set.length; i++) { + debug(set[i].semver) + if (set[i].semver === ANY) { + continue + } + + if (set[i].semver.prerelease.length > 0) { + var allowed = set[i].semver + if (allowed.major === version.major && + allowed.minor === version.minor && + allowed.patch === version.patch) { + return true + } + } + } + + // Version has a -pre, but it's not one of the ones we like. + return false + } + + return true +} + +exports.satisfies = satisfies +function satisfies (version, range, options) { + try { + range = new Range(range, options) + } catch (er) { + return false + } + return range.test(version) +} + +exports.maxSatisfying = maxSatisfying +function maxSatisfying (versions, range, options) { + var max = null + var maxSV = null + try { + var rangeObj = new Range(range, options) + } catch (er) { + return null + } + versions.forEach(function (v) { + if (rangeObj.test(v)) { + // satisfies(v, range, options) + if (!max || maxSV.compare(v) === -1) { + // compare(max, v, true) + max = v + maxSV = new SemVer(max, options) + } + } + }) + return max +} + +exports.minSatisfying = minSatisfying +function minSatisfying (versions, range, options) { + var min = null + var minSV = null + try { + var rangeObj = new Range(range, options) + } catch (er) { + return null + } + versions.forEach(function (v) { + if (rangeObj.test(v)) { + // satisfies(v, range, options) + if (!min || minSV.compare(v) === 1) { + // compare(min, v, true) + min = v + minSV = new SemVer(min, options) + } + } + }) + return min +} + +exports.minVersion = minVersion +function minVersion (range, loose) { + range = new Range(range, loose) + + var minver = new SemVer('0.0.0') + if (range.test(minver)) { + return minver + } + + minver = new SemVer('0.0.0-0') + if (range.test(minver)) { + return minver + } + + minver = null + for (var i = 0; i < range.set.length; ++i) { + var comparators = range.set[i] + + comparators.forEach(function (comparator) { + // Clone to avoid manipulating the comparator's semver object. + var compver = new SemVer(comparator.semver.version) + switch (comparator.operator) { + case '>': + if (compver.prerelease.length === 0) { + compver.patch++ + } else { + compver.prerelease.push(0) + } + compver.raw = compver.format() + /* fallthrough */ + case '': + case '>=': + if (!minver || gt(minver, compver)) { + minver = compver + } + break + case '<': + case '<=': + /* Ignore maximum versions */ + break + /* istanbul ignore next */ + default: + throw new Error('Unexpected operation: ' + comparator.operator) + } + }) + } + + if (minver && range.test(minver)) { + return minver + } + + return null +} + +exports.validRange = validRange +function validRange (range, options) { + try { + // Return '*' instead of '' so that truthiness works. + // This will throw if it's invalid anyway + return new Range(range, options).range || '*' + } catch (er) { + return null + } +} + +// Determine if version is less than all the versions possible in the range +exports.ltr = ltr +function ltr (version, range, options) { + return outside(version, range, '<', options) +} + +// Determine if version is greater than all the versions possible in the range. +exports.gtr = gtr +function gtr (version, range, options) { + return outside(version, range, '>', options) +} + +exports.outside = outside +function outside (version, range, hilo, options) { + version = new SemVer(version, options) + range = new Range(range, options) + + var gtfn, ltefn, ltfn, comp, ecomp + switch (hilo) { + case '>': + gtfn = gt + ltefn = lte + ltfn = lt + comp = '>' + ecomp = '>=' + break + case '<': + gtfn = lt + ltefn = gte + ltfn = gt + comp = '<' + ecomp = '<=' + break + default: + throw new TypeError('Must provide a hilo val of "<" or ">"') + } + + // If it satisifes the range it is not outside + if (satisfies(version, range, options)) { + return false + } + + // From now on, variable terms are as if we're in "gtr" mode. + // but note that everything is flipped for the "ltr" function. + + for (var i = 0; i < range.set.length; ++i) { + var comparators = range.set[i] + + var high = null + var low = null + + comparators.forEach(function (comparator) { + if (comparator.semver === ANY) { + comparator = new Comparator('>=0.0.0') + } + high = high || comparator + low = low || comparator + if (gtfn(comparator.semver, high.semver, options)) { + high = comparator + } else if (ltfn(comparator.semver, low.semver, options)) { + low = comparator + } + }) + + // If the edge version comparator has a operator then our version + // isn't outside it + if (high.operator === comp || high.operator === ecomp) { + return false + } + + // If the lowest version comparator has an operator and our version + // is less than it then it isn't higher than the range + if ((!low.operator || low.operator === comp) && + ltefn(version, low.semver)) { + return false + } else if (low.operator === ecomp && ltfn(version, low.semver)) { + return false + } + } + return true +} + +exports.prerelease = prerelease +function prerelease (version, options) { + var parsed = parse(version, options) + return (parsed && parsed.prerelease.length) ? parsed.prerelease : null +} + +exports.intersects = intersects +function intersects (r1, r2, options) { + r1 = new Range(r1, options) + r2 = new Range(r2, options) + return r1.intersects(r2) +} + +exports.coerce = coerce +function coerce (version, options) { + if (version instanceof SemVer) { + return version + } + + if (typeof version === 'number') { + version = String(version) + } + + if (typeof version !== 'string') { + return null + } + + options = options || {} + + var match = null + if (!options.rtl) { + match = version.match(safeRe[t.COERCE]) + } else { + // Find the right-most coercible string that does not share + // a terminus with a more left-ward coercible string. + // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4' + // + // Walk through the string checking with a /g regexp + // Manually set the index so as to pick up overlapping matches. + // Stop when we get a match that ends at the string end, since no + // coercible string can be more right-ward without the same terminus. + var next + while ((next = safeRe[t.COERCERTL].exec(version)) && + (!match || match.index + match[0].length !== version.length) + ) { + if (!match || + next.index + next[0].length !== match.index + match[0].length) { + match = next + } + safeRe[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length + } + // leave it in a clean state + safeRe[t.COERCERTL].lastIndex = -1 + } + + if (match === null) { + return null + } + + return parse(match[2] + + '.' + (match[3] || '0') + + '.' + (match[4] || '0'), options) +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-compilation-targets/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-compilation-targets/package.json new file mode 100644 index 0000000000000000000000000000000000000000..79c1e2bff45f8c60265f2ae54e49b0a324047f68 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-compilation-targets/package.json @@ -0,0 +1,43 @@ +{ + "name": "@babel/helper-compilation-targets", + "version": "7.27.2", + "author": "The Babel Team (https://babel.dev/team)", + "license": "MIT", + "description": "Helper functions on Babel compilation targets", + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-helper-compilation-targets" + }, + "main": "./lib/index.js", + "exports": { + ".": { + "types": "./lib/index.d.ts", + "default": "./lib/index.js" + }, + "./package.json": "./package.json" + }, + "publishConfig": { + "access": "public" + }, + "keywords": [ + "babel", + "babel-plugin" + ], + "dependencies": { + "@babel/compat-data": "^7.27.2", + "@babel/helper-validator-option": "^7.27.1", + "browserslist": "^4.24.0", + "lru-cache": "^5.1.1", + "semver": "^6.3.1" + }, + "devDependencies": { + "@babel/helper-plugin-test-runner": "^7.27.1", + "@types/lru-cache": "^5.1.1", + "@types/semver": "^5.5.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "type": "commonjs" +} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-globals/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-globals/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-globals/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-globals/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-globals/README.md new file mode 100644 index 0000000000000000000000000000000000000000..3dc9f25252d07c0158c02aff82a3509b2c465568 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-globals/README.md @@ -0,0 +1,19 @@ +# @babel/helper-globals + +> A collection of JavaScript globals for Babel internal usage + +See our website [@babel/helper-globals](https://babeljs.io/docs/babel-helper-globals) for more information. + +## Install + +Using npm: + +```sh +npm install --save @babel/helper-globals +``` + +or using yarn: + +```sh +yarn add @babel/helper-globals +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-globals/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-globals/package.json new file mode 100644 index 0000000000000000000000000000000000000000..4d559975cb11355037a4d865b163c3cf93b08dc7 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-globals/package.json @@ -0,0 +1,32 @@ +{ + "name": "@babel/helper-globals", + "version": "7.28.0", + "author": "The Babel Team (https://babel.dev/team)", + "license": "MIT", + "description": "A collection of JavaScript globals for Babel internal usage", + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-helper-globals" + }, + "publishConfig": { + "access": "public" + }, + "exports": { + "./data/browser-upper.json": "./data/browser-upper.json", + "./data/builtin-lower.json": "./data/builtin-lower.json", + "./data/builtin-upper.json": "./data/builtin-upper.json", + "./package.json": "./package.json" + }, + "keywords": [ + "babel", + "globals" + ], + "devDependencies": { + "globals": "^16.1.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "type": "commonjs" +} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-module-imports/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-module-imports/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-module-imports/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-module-imports/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-module-imports/README.md new file mode 100644 index 0000000000000000000000000000000000000000..aa47726ffef5f9f70df30e53cb8442ad95d2b6bd --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-module-imports/README.md @@ -0,0 +1,19 @@ +# @babel/helper-module-imports + +> Babel helper functions for inserting module loads + +See our website [@babel/helper-module-imports](https://babeljs.io/docs/babel-helper-module-imports) for more information. + +## Install + +Using npm: + +```sh +npm install --save @babel/helper-module-imports +``` + +or using yarn: + +```sh +yarn add @babel/helper-module-imports +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-module-imports/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-module-imports/package.json new file mode 100644 index 0000000000000000000000000000000000000000..f9dee72b727940bfffd520d75cef9091b2cb0413 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-module-imports/package.json @@ -0,0 +1,28 @@ +{ + "name": "@babel/helper-module-imports", + "version": "7.27.1", + "description": "Babel helper functions for inserting module loads", + "author": "The Babel Team (https://babel.dev/team)", + "homepage": "https://babel.dev/docs/en/next/babel-helper-module-imports", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-helper-module-imports" + }, + "main": "./lib/index.js", + "dependencies": { + "@babel/traverse": "^7.27.1", + "@babel/types": "^7.27.1" + }, + "devDependencies": { + "@babel/core": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "type": "commonjs" +} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-module-transforms/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-module-transforms/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-module-transforms/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-module-transforms/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-module-transforms/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d0f82fe08f64e92da0a8c80f0c6a184a44890d90 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-module-transforms/README.md @@ -0,0 +1,19 @@ +# @babel/helper-module-transforms + +> Babel helper functions for implementing ES6 module transformations + +See our website [@babel/helper-module-transforms](https://babeljs.io/docs/babel-helper-module-transforms) for more information. + +## Install + +Using npm: + +```sh +npm install --save @babel/helper-module-transforms +``` + +or using yarn: + +```sh +yarn add @babel/helper-module-transforms +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-module-transforms/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-module-transforms/package.json new file mode 100644 index 0000000000000000000000000000000000000000..5c7241e17d45f16dc9390b85794607252af6fff6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-module-transforms/package.json @@ -0,0 +1,32 @@ +{ + "name": "@babel/helper-module-transforms", + "version": "7.28.3", + "description": "Babel helper functions for implementing ES6 module transformations", + "author": "The Babel Team (https://babel.dev/team)", + "homepage": "https://babel.dev/docs/en/next/babel-helper-module-transforms", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-helper-module-transforms" + }, + "main": "./lib/index.js", + "dependencies": { + "@babel/helper-module-imports": "^7.27.1", + "@babel/helper-validator-identifier": "^7.27.1", + "@babel/traverse": "^7.28.3" + }, + "devDependencies": { + "@babel/core": "^7.28.3" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "type": "commonjs" +} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-plugin-utils/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-plugin-utils/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-plugin-utils/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-plugin-utils/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-plugin-utils/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a99070f3e5f9b624fc2ad8b3b2edf3da4ea8c5e2 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-plugin-utils/README.md @@ -0,0 +1,19 @@ +# @babel/helper-plugin-utils + +> General utilities for plugins to use + +See our website [@babel/helper-plugin-utils](https://babeljs.io/docs/babel-helper-plugin-utils) for more information. + +## Install + +Using npm: + +```sh +npm install --save @babel/helper-plugin-utils +``` + +or using yarn: + +```sh +yarn add @babel/helper-plugin-utils +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-plugin-utils/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-plugin-utils/package.json new file mode 100644 index 0000000000000000000000000000000000000000..26f793fe455f57e82d15810d3eb32fdc44d3205c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-plugin-utils/package.json @@ -0,0 +1,24 @@ +{ + "name": "@babel/helper-plugin-utils", + "version": "7.27.1", + "description": "General utilities for plugins to use", + "author": "The Babel Team (https://babel.dev/team)", + "homepage": "https://babel.dev/docs/en/next/babel-helper-plugin-utils", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-helper-plugin-utils" + }, + "main": "./lib/index.js", + "engines": { + "node": ">=6.9.0" + }, + "devDependencies": { + "@babel/core": "^7.27.1" + }, + "type": "commonjs" +} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-string-parser/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-string-parser/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-string-parser/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-string-parser/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-string-parser/README.md new file mode 100644 index 0000000000000000000000000000000000000000..771b470036f8319bd96894b7d61c4e8c96e38fa6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-string-parser/README.md @@ -0,0 +1,19 @@ +# @babel/helper-string-parser + +> A utility package to parse strings + +See our website [@babel/helper-string-parser](https://babeljs.io/docs/babel-helper-string-parser) for more information. + +## Install + +Using npm: + +```sh +npm install --save @babel/helper-string-parser +``` + +or using yarn: + +```sh +yarn add @babel/helper-string-parser +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-string-parser/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-string-parser/package.json new file mode 100644 index 0000000000000000000000000000000000000000..c4c86e4f4fb0d4dee34f75940d32f85dd1404ad9 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-string-parser/package.json @@ -0,0 +1,31 @@ +{ + "name": "@babel/helper-string-parser", + "version": "7.27.1", + "description": "A utility package to parse strings", + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-helper-string-parser" + }, + "homepage": "https://babel.dev/docs/en/next/babel-helper-string-parser", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "main": "./lib/index.js", + "devDependencies": { + "charcodes": "^0.2.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "author": "The Babel Team (https://babel.dev/team)", + "exports": { + ".": { + "types": "./lib/index.d.ts", + "default": "./lib/index.js" + }, + "./package.json": "./package.json" + }, + "type": "commonjs" +} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-validator-identifier/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-validator-identifier/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-validator-identifier/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-validator-identifier/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-validator-identifier/README.md new file mode 100644 index 0000000000000000000000000000000000000000..05c19e64a16cf070017ca0e00bc20ae31f0e8e3f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-validator-identifier/README.md @@ -0,0 +1,19 @@ +# @babel/helper-validator-identifier + +> Validate identifier/keywords name + +See our website [@babel/helper-validator-identifier](https://babeljs.io/docs/babel-helper-validator-identifier) for more information. + +## Install + +Using npm: + +```sh +npm install --save @babel/helper-validator-identifier +``` + +or using yarn: + +```sh +yarn add @babel/helper-validator-identifier +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-validator-identifier/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-validator-identifier/package.json new file mode 100644 index 0000000000000000000000000000000000000000..316dff686d2650ebc9d7ea60d4ebb72fb5fdd233 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-validator-identifier/package.json @@ -0,0 +1,31 @@ +{ + "name": "@babel/helper-validator-identifier", + "version": "7.27.1", + "description": "Validate identifier/keywords name", + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-helper-validator-identifier" + }, + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "main": "./lib/index.js", + "exports": { + ".": { + "types": "./lib/index.d.ts", + "default": "./lib/index.js" + }, + "./package.json": "./package.json" + }, + "devDependencies": { + "@unicode/unicode-16.0.0": "^1.0.0", + "charcodes": "^0.2.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "author": "The Babel Team (https://babel.dev/team)", + "type": "commonjs" +} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-validator-option/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-validator-option/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-validator-option/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-validator-option/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-validator-option/README.md new file mode 100644 index 0000000000000000000000000000000000000000..c5c7b5d38abb99e0717770669f7332ebe485d588 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-validator-option/README.md @@ -0,0 +1,19 @@ +# @babel/helper-validator-option + +> Validate plugin/preset options + +See our website [@babel/helper-validator-option](https://babeljs.io/docs/babel-helper-validator-option) for more information. + +## Install + +Using npm: + +```sh +npm install --save @babel/helper-validator-option +``` + +or using yarn: + +```sh +yarn add @babel/helper-validator-option +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-validator-option/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-validator-option/package.json new file mode 100644 index 0000000000000000000000000000000000000000..1c97a903a59b16ba65182e270fa6c2365654f171 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helper-validator-option/package.json @@ -0,0 +1,27 @@ +{ + "name": "@babel/helper-validator-option", + "version": "7.27.1", + "description": "Validate plugin/preset options", + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-helper-validator-option" + }, + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "main": "./lib/index.js", + "exports": { + ".": { + "types": "./lib/index.d.ts", + "default": "./lib/index.js" + }, + "./package.json": "./package.json" + }, + "engines": { + "node": ">=6.9.0" + }, + "author": "The Babel Team (https://babel.dev/team)", + "type": "commonjs" +} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..37b2c998c41e131cfdd18e93536c73cfaf919ed4 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/LICENSE @@ -0,0 +1,23 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors +Copyright (c) 2014-present, Facebook, Inc. (ONLY ./src/helpers/regenerator* files) + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/README.md new file mode 100644 index 0000000000000000000000000000000000000000..95fcf29e5c6c34f3dfb63e08cad449cc80f27935 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/README.md @@ -0,0 +1,19 @@ +# @babel/helpers + +> Collection of helper functions used by Babel transforms. + +See our website [@babel/helpers](https://babeljs.io/docs/babel-helpers) for more information. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/helpers +``` + +or using yarn: + +```sh +yarn add @babel/helpers --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers-generated.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers-generated.js new file mode 100644 index 0000000000000000000000000000000000000000..3e2b0cccaee5db0d4795ee239f4ee0e9428912a6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers-generated.js @@ -0,0 +1,1442 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; +var _template = require("@babel/template"); +function helper(minVersion, source, metadata) { + return Object.freeze({ + minVersion, + ast: () => _template.default.program.ast(source, { + preserveComments: true + }), + metadata + }); +} +const helpers = exports.default = { + __proto__: null, + OverloadYield: helper("7.18.14", "function _OverloadYield(e,d){this.v=e,this.k=d}", { + globals: [], + locals: { + _OverloadYield: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_OverloadYield", + dependencies: {}, + internal: false + }), + applyDecoratedDescriptor: helper("7.0.0-beta.0", 'function _applyDecoratedDescriptor(i,e,r,n,l){var a={};return Object.keys(n).forEach((function(i){a[i]=n[i]})),a.enumerable=!!a.enumerable,a.configurable=!!a.configurable,("value"in a||a.initializer)&&(a.writable=!0),a=r.slice().reverse().reduce((function(r,n){return n(i,e,r)||r}),a),l&&void 0!==a.initializer&&(a.value=a.initializer?a.initializer.call(l):void 0,a.initializer=void 0),void 0===a.initializer?(Object.defineProperty(i,e,a),null):a}', { + globals: ["Object"], + locals: { + _applyDecoratedDescriptor: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_applyDecoratedDescriptor", + dependencies: {}, + internal: false + }), + applyDecs2311: helper("7.24.0", 'function applyDecs2311(e,t,n,r,o,i){var a,c,u,s,f,l,p,d=Symbol.metadata||Symbol.for("Symbol.metadata"),m=Object.defineProperty,h=Object.create,y=[h(null),h(null)],v=t.length;function g(t,n,r){return function(o,i){n&&(i=o,o=e);for(var a=0;a=0;O-=n?2:1){var T=b(h[O],"A decorator","be",!0),z=n?h[O-1]:void 0,A={},H={kind:["field","accessor","method","getter","setter","class"][o],name:r,metadata:a,addInitializer:function(e,t){if(e.v)throw new TypeError("attempted to call addInitializer after decoration was finished");b(t,"An initializer","be",!0),i.push(t)}.bind(null,A)};if(w)c=T.call(z,N,H),A.v=1,b(c,"class decorators","return")&&(N=c);else if(H.static=s,H.private=f,c=H.access={has:f?p.bind():function(e){return r in e}},j||(c.get=f?E?function(e){return d(e),P.value}:I("get",0,d):function(e){return e[r]}),E||S||(c.set=f?I("set",0,d):function(e,t){e[r]=t}),N=T.call(z,D?{get:P.get,set:P.set}:P[F],H),A.v=1,D){if("object"==typeof N&&N)(c=b(N.get,"accessor.get"))&&(P.get=c),(c=b(N.set,"accessor.set"))&&(P.set=c),(c=b(N.init,"accessor.init"))&&k.unshift(c);else if(void 0!==N)throw new TypeError("accessor decorators must return an object with get, set, or init properties or undefined")}else b(N,(l?"field":"method")+" decorators","return")&&(l?k.unshift(N):P[F]=N)}return o<2&&u.push(g(k,s,1),g(i,s,0)),l||w||(f?D?u.splice(-1,0,I("get",s),I("set",s)):u.push(E?P[F]:b.call.bind(P[F])):m(e,r,P)),N}function w(e){return m(e,d,{configurable:!0,enumerable:!0,value:a})}return void 0!==i&&(a=i[d]),a=h(null==a?null:a),f=[],l=function(e){e&&f.push(g(e))},p=function(t,r){for(var i=0;ir.length)&&(a=r.length);for(var e=0,n=Array(a);e=r.length?{done:!0}:{done:!1,value:r[n++]}},e:function(r){throw r},f:F}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var o,a=!0,u=!1;return{s:function(){t=t.call(r)},n:function(){var r=t.next();return a=r.done,r},e:function(r){u=!0,o=r},f:function(){try{a||null==t.return||t.return()}finally{if(u)throw o}}}}', { + globals: ["Symbol", "Array", "TypeError"], + locals: { + _createForOfIteratorHelper: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_createForOfIteratorHelper", + dependencies: { + unsupportedIterableToArray: ["body.0.body.body.1.consequent.body.0.test.left.right.right.callee"] + }, + internal: false + }), + createForOfIteratorHelperLoose: helper("7.9.0", 'function _createForOfIteratorHelperLoose(r,e){var t="undefined"!=typeof Symbol&&r[Symbol.iterator]||r["@@iterator"];if(t)return(t=t.call(r)).next.bind(t);if(Array.isArray(r)||(t=unsupportedIterableToArray(r))||e&&r&&"number"==typeof r.length){t&&(r=t);var o=0;return function(){return o>=r.length?{done:!0}:{done:!1,value:r[o++]}}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}', { + globals: ["Symbol", "Array", "TypeError"], + locals: { + _createForOfIteratorHelperLoose: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_createForOfIteratorHelperLoose", + dependencies: { + unsupportedIterableToArray: ["body.0.body.body.2.test.left.right.right.callee"] + }, + internal: false + }), + createSuper: helper("7.9.0", "function _createSuper(t){var r=isNativeReflectConstruct();return function(){var e,o=getPrototypeOf(t);if(r){var s=getPrototypeOf(this).constructor;e=Reflect.construct(o,arguments,s)}else e=o.apply(this,arguments);return possibleConstructorReturn(this,e)}}", { + globals: ["Reflect"], + locals: { + _createSuper: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_createSuper", + dependencies: { + getPrototypeOf: ["body.0.body.body.1.argument.body.body.0.declarations.1.init.callee", "body.0.body.body.1.argument.body.body.1.consequent.body.0.declarations.0.init.object.callee"], + isNativeReflectConstruct: ["body.0.body.body.0.declarations.0.init.callee"], + possibleConstructorReturn: ["body.0.body.body.1.argument.body.body.2.argument.callee"] + }, + internal: false + }), + decorate: helper("7.1.5", 'function _decorate(e,r,t,i){var o=_getDecoratorsApi();if(i)for(var n=0;n=0;n--){var s=r[e.placement];s.splice(s.indexOf(e.key),1);var a=this.fromElementDescriptor(e),l=this.toElementFinisherExtras((0,o[n])(a)||a);e=l.element,this.addElementPlacement(e,r),l.finisher&&i.push(l.finisher);var c=l.extras;if(c){for(var p=0;p=0;i--){var o=this.fromClassDescriptor(e),n=this.toClassDescriptor((0,r[i])(o)||o);if(void 0!==n.finisher&&t.push(n.finisher),void 0!==n.elements){e=n.elements;for(var s=0;s1){for(var t=Array(n),f=0;f3?(o=l===n)&&(u=i[(c=i[4])?5:(c=3,3)],i[4]=i[5]=e):i[0]<=d&&((o=r<2&&dn||n>l)&&(i[4]=r,i[5]=n,G.n=l,c=0))}if(o||r>1)return a;throw y=!0,n}return function(o,p,l){if(f>1)throw TypeError("Generator is already running");for(y&&1===p&&d(p,l),c=p,u=l;(t=c<2?e:u)||!y;){i||(c?c<3?(c>1&&(G.n=-1),d(c,u)):G.n=u:G.v=u);try{if(f=2,i){if(c||(o="next"),t=i[o]){if(!(t=t.call(i,u)))throw TypeError("iterator result is not an object");if(!t.done)return t;u=t.value,c<2&&(c=0)}else 1===c&&(t=i.return)&&t.call(i),c<2&&(u=TypeError("The iterator does not provide a \'"+o+"\' method"),c=1);i=e}else if((t=(y=G.n<0)?u:r.call(n,G))!==a)break}catch(t){i=e,c=1,u=t}finally{f=1}}return{value:t,done:y}}}(r,o,i),!0),u}var a={};function Generator(){}function GeneratorFunction(){}function GeneratorFunctionPrototype(){}t=Object.getPrototypeOf;var c=[][n]?t(t([][n]())):(define(t={},n,(function(){return this})),t),u=GeneratorFunctionPrototype.prototype=Generator.prototype=Object.create(c);function f(e){return Object.setPrototypeOf?Object.setPrototypeOf(e,GeneratorFunctionPrototype):(e.__proto__=GeneratorFunctionPrototype,define(e,o,"GeneratorFunction")),e.prototype=Object.create(u),e}return GeneratorFunction.prototype=GeneratorFunctionPrototype,define(u,"constructor",GeneratorFunctionPrototype),define(GeneratorFunctionPrototype,"constructor",GeneratorFunction),GeneratorFunction.displayName="GeneratorFunction",define(GeneratorFunctionPrototype,o,"GeneratorFunction"),define(u),define(u,o,"Generator"),define(u,n,(function(){return this})),define(u,"toString",(function(){return"[object Generator]"})),(_regenerator=function(){return{w:i,m:f}})()}', { + globals: ["Symbol", "Object", "TypeError"], + locals: { + _regenerator: ["body.0.id", "body.0.body.body.9.argument.expressions.9.callee.left"] + }, + exportBindingAssignments: ["body.0.body.body.9.argument.expressions.9.callee"], + exportName: "_regenerator", + dependencies: { + regeneratorDefine: ["body.0.body.body.1.body.body.1.argument.expressions.0.callee", "body.0.body.body.7.declarations.0.init.alternate.expressions.0.callee", "body.0.body.body.8.body.body.0.argument.expressions.0.alternate.expressions.1.callee", "body.0.body.body.9.argument.expressions.1.callee", "body.0.body.body.9.argument.expressions.2.callee", "body.0.body.body.9.argument.expressions.4.callee", "body.0.body.body.9.argument.expressions.5.callee", "body.0.body.body.9.argument.expressions.6.callee", "body.0.body.body.9.argument.expressions.7.callee", "body.0.body.body.9.argument.expressions.8.callee"] + }, + internal: false + }), + regeneratorAsync: helper("7.27.0", "function _regeneratorAsync(n,e,r,t,o){var a=asyncGen(n,e,r,t,o);return a.next().then((function(n){return n.done?n.value:a.next()}))}", { + globals: [], + locals: { + _regeneratorAsync: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_regeneratorAsync", + dependencies: { + regeneratorAsyncGen: ["body.0.body.body.0.declarations.0.init.callee"] + }, + internal: false + }), + regeneratorAsyncGen: helper("7.27.0", "function _regeneratorAsyncGen(r,e,t,o,n){return new regeneratorAsyncIterator(regenerator().w(r,e,t,o),n||Promise)}", { + globals: ["Promise"], + locals: { + _regeneratorAsyncGen: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_regeneratorAsyncGen", + dependencies: { + regenerator: ["body.0.body.body.0.argument.arguments.0.callee.object.callee"], + regeneratorAsyncIterator: ["body.0.body.body.0.argument.callee"] + }, + internal: false + }), + regeneratorAsyncIterator: helper("7.27.0", 'function AsyncIterator(t,e){function n(r,o,i,f){try{var c=t[r](o),u=c.value;return u instanceof OverloadYield?e.resolve(u.v).then((function(t){n("next",t,i,f)}),(function(t){n("throw",t,i,f)})):e.resolve(u).then((function(t){c.value=t,i(c)}),(function(t){return n("throw",t,i,f)}))}catch(t){f(t)}}var r;this.next||(define(AsyncIterator.prototype),define(AsyncIterator.prototype,"function"==typeof Symbol&&Symbol.asyncIterator||"@asyncIterator",(function(){return this}))),define(this,"_invoke",(function(t,o,i){function f(){return new e((function(e,r){n(t,i,e,r)}))}return r=r?r.then(f,f):f()}),!0)}', { + globals: ["Symbol"], + locals: { + AsyncIterator: ["body.0.id", "body.0.body.body.2.expression.expressions.0.right.expressions.0.arguments.0.object", "body.0.body.body.2.expression.expressions.0.right.expressions.1.arguments.0.object"] + }, + exportBindingAssignments: [], + exportName: "AsyncIterator", + dependencies: { + OverloadYield: ["body.0.body.body.0.body.body.0.block.body.1.argument.test.right"], + regeneratorDefine: ["body.0.body.body.2.expression.expressions.0.right.expressions.0.callee", "body.0.body.body.2.expression.expressions.0.right.expressions.1.callee", "body.0.body.body.2.expression.expressions.1.callee"] + }, + internal: true + }), + regeneratorDefine: helper("7.27.0", 'function regeneratorDefine(e,r,n,t){var i=Object.defineProperty;try{i({},"",{})}catch(e){i=0}regeneratorDefine=function(e,r,n,t){function o(r,n){regeneratorDefine(e,r,(function(e){return this._invoke(r,n,e)}))}r?i?i(e,r,{value:n,enumerable:!t,configurable:!t,writable:!t}):e[r]=n:(o("next",0),o("throw",1),o("return",2))},regeneratorDefine(e,r,n,t)}', { + globals: ["Object"], + locals: { + regeneratorDefine: ["body.0.id", "body.0.body.body.2.expression.expressions.0.right.body.body.0.body.body.0.expression.callee", "body.0.body.body.2.expression.expressions.1.callee", "body.0.body.body.2.expression.expressions.0.left"] + }, + exportBindingAssignments: ["body.0.body.body.2.expression.expressions.0"], + exportName: "regeneratorDefine", + dependencies: {}, + internal: true + }), + regeneratorKeys: helper("7.27.0", "function _regeneratorKeys(e){var n=Object(e),r=[];for(var t in n)r.unshift(t);return function e(){for(;r.length;)if((t=r.pop())in n)return e.value=t,e.done=!1,e;return e.done=!0,e}}", { + globals: ["Object"], + locals: { + _regeneratorKeys: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_regeneratorKeys", + dependencies: {}, + internal: false + }), + regeneratorValues: helper("7.18.0", 'function _regeneratorValues(e){if(null!=e){var t=e["function"==typeof Symbol&&Symbol.iterator||"@@iterator"],r=0;if(t)return t.call(e);if("function"==typeof e.next)return e;if(!isNaN(e.length))return{next:function(){return e&&r>=e.length&&(e=void 0),{value:e&&e[r++],done:!e}}}}throw new TypeError(typeof e+" is not iterable")}', { + globals: ["Symbol", "isNaN", "TypeError"], + locals: { + _regeneratorValues: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_regeneratorValues", + dependencies: {}, + internal: false + }), + set: helper("7.0.0-beta.0", 'function set(e,r,t,o){return set="undefined"!=typeof Reflect&&Reflect.set?Reflect.set:function(e,r,t,o){var f,i=superPropBase(e,r);if(i){if((f=Object.getOwnPropertyDescriptor(i,r)).set)return f.set.call(o,t),!0;if(!f.writable)return!1}if(f=Object.getOwnPropertyDescriptor(o,r)){if(!f.writable)return!1;f.value=t,Object.defineProperty(o,r,f)}else defineProperty(o,r,t);return!0},set(e,r,t,o)}function _set(e,r,t,o,f){if(!set(e,r,t,o||e)&&f)throw new TypeError("failed to set property");return t}', { + globals: ["Reflect", "Object", "TypeError"], + locals: { + set: ["body.0.id", "body.0.body.body.0.argument.expressions.1.callee", "body.1.body.body.0.test.left.argument.callee", "body.0.body.body.0.argument.expressions.0.left"], + _set: ["body.1.id"] + }, + exportBindingAssignments: [], + exportName: "_set", + dependencies: { + superPropBase: ["body.0.body.body.0.argument.expressions.0.right.alternate.body.body.0.declarations.1.init.callee"], + defineProperty: ["body.0.body.body.0.argument.expressions.0.right.alternate.body.body.2.alternate.expression.callee"] + }, + internal: false + }), + setFunctionName: helper("7.23.6", 'function setFunctionName(e,t,n){"symbol"==typeof t&&(t=(t=t.description)?"["+t+"]":"");try{Object.defineProperty(e,"name",{configurable:!0,value:n?n+" "+t:t})}catch(e){}return e}', { + globals: ["Object"], + locals: { + setFunctionName: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "setFunctionName", + dependencies: {}, + internal: false + }), + setPrototypeOf: helper("7.0.0-beta.0", "function _setPrototypeOf(t,e){return _setPrototypeOf=Object.setPrototypeOf?Object.setPrototypeOf.bind():function(t,e){return t.__proto__=e,t},_setPrototypeOf(t,e)}", { + globals: ["Object"], + locals: { + _setPrototypeOf: ["body.0.id", "body.0.body.body.0.argument.expressions.1.callee", "body.0.body.body.0.argument.expressions.0.left"] + }, + exportBindingAssignments: ["body.0.body.body.0.argument.expressions.0"], + exportName: "_setPrototypeOf", + dependencies: {}, + internal: false + }), + skipFirstGeneratorNext: helper("7.0.0-beta.0", "function _skipFirstGeneratorNext(t){return function(){var r=t.apply(this,arguments);return r.next(),r}}", { + globals: [], + locals: { + _skipFirstGeneratorNext: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_skipFirstGeneratorNext", + dependencies: {}, + internal: false + }), + slicedToArray: helper("7.0.0-beta.0", "function _slicedToArray(r,e){return arrayWithHoles(r)||iterableToArrayLimit(r,e)||unsupportedIterableToArray(r,e)||nonIterableRest()}", { + globals: [], + locals: { + _slicedToArray: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_slicedToArray", + dependencies: { + arrayWithHoles: ["body.0.body.body.0.argument.left.left.left.callee"], + iterableToArrayLimit: ["body.0.body.body.0.argument.left.left.right.callee"], + unsupportedIterableToArray: ["body.0.body.body.0.argument.left.right.callee"], + nonIterableRest: ["body.0.body.body.0.argument.right.callee"] + }, + internal: false + }), + superPropBase: helper("7.0.0-beta.0", "function _superPropBase(t,o){for(;!{}.hasOwnProperty.call(t,o)&&null!==(t=getPrototypeOf(t)););return t}", { + globals: [], + locals: { + _superPropBase: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_superPropBase", + dependencies: { + getPrototypeOf: ["body.0.body.body.0.test.right.right.right.callee"] + }, + internal: false + }), + superPropGet: helper("7.25.0", 'function _superPropGet(t,o,e,r){var p=get(getPrototypeOf(1&r?t.prototype:t),o,e);return 2&r&&"function"==typeof p?function(t){return p.apply(e,t)}:p}', { + globals: [], + locals: { + _superPropGet: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_superPropGet", + dependencies: { + get: ["body.0.body.body.0.declarations.0.init.callee"], + getPrototypeOf: ["body.0.body.body.0.declarations.0.init.arguments.0.callee"] + }, + internal: false + }), + superPropSet: helper("7.25.0", "function _superPropSet(t,e,o,r,p,f){return set(getPrototypeOf(f?t.prototype:t),e,o,r,p)}", { + globals: [], + locals: { + _superPropSet: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_superPropSet", + dependencies: { + set: ["body.0.body.body.0.argument.callee"], + getPrototypeOf: ["body.0.body.body.0.argument.arguments.0.callee"] + }, + internal: false + }), + taggedTemplateLiteral: helper("7.0.0-beta.0", "function _taggedTemplateLiteral(e,t){return t||(t=e.slice(0)),Object.freeze(Object.defineProperties(e,{raw:{value:Object.freeze(t)}}))}", { + globals: ["Object"], + locals: { + _taggedTemplateLiteral: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_taggedTemplateLiteral", + dependencies: {}, + internal: false + }), + taggedTemplateLiteralLoose: helper("7.0.0-beta.0", "function _taggedTemplateLiteralLoose(e,t){return t||(t=e.slice(0)),e.raw=t,e}", { + globals: [], + locals: { + _taggedTemplateLiteralLoose: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_taggedTemplateLiteralLoose", + dependencies: {}, + internal: false + }), + tdz: helper("7.5.5", 'function _tdzError(e){throw new ReferenceError(e+" is not defined - temporal dead zone")}', { + globals: ["ReferenceError"], + locals: { + _tdzError: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_tdzError", + dependencies: {}, + internal: false + }), + temporalRef: helper("7.0.0-beta.0", "function _temporalRef(r,e){return r===undef?err(e):r}", { + globals: [], + locals: { + _temporalRef: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_temporalRef", + dependencies: { + temporalUndefined: ["body.0.body.body.0.argument.test.right"], + tdz: ["body.0.body.body.0.argument.consequent.callee"] + }, + internal: false + }), + temporalUndefined: helper("7.0.0-beta.0", "function _temporalUndefined(){}", { + globals: [], + locals: { + _temporalUndefined: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_temporalUndefined", + dependencies: {}, + internal: false + }), + toArray: helper("7.0.0-beta.0", "function _toArray(r){return arrayWithHoles(r)||iterableToArray(r)||unsupportedIterableToArray(r)||nonIterableRest()}", { + globals: [], + locals: { + _toArray: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_toArray", + dependencies: { + arrayWithHoles: ["body.0.body.body.0.argument.left.left.left.callee"], + iterableToArray: ["body.0.body.body.0.argument.left.left.right.callee"], + unsupportedIterableToArray: ["body.0.body.body.0.argument.left.right.callee"], + nonIterableRest: ["body.0.body.body.0.argument.right.callee"] + }, + internal: false + }), + toConsumableArray: helper("7.0.0-beta.0", "function _toConsumableArray(r){return arrayWithoutHoles(r)||iterableToArray(r)||unsupportedIterableToArray(r)||nonIterableSpread()}", { + globals: [], + locals: { + _toConsumableArray: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_toConsumableArray", + dependencies: { + arrayWithoutHoles: ["body.0.body.body.0.argument.left.left.left.callee"], + iterableToArray: ["body.0.body.body.0.argument.left.left.right.callee"], + unsupportedIterableToArray: ["body.0.body.body.0.argument.left.right.callee"], + nonIterableSpread: ["body.0.body.body.0.argument.right.callee"] + }, + internal: false + }), + toPrimitive: helper("7.1.5", 'function toPrimitive(t,r){if("object"!=typeof t||!t)return t;var e=t[Symbol.toPrimitive];if(void 0!==e){var i=e.call(t,r||"default");if("object"!=typeof i)return i;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===r?String:Number)(t)}', { + globals: ["Symbol", "TypeError", "String", "Number"], + locals: { + toPrimitive: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "toPrimitive", + dependencies: {}, + internal: false + }), + toPropertyKey: helper("7.1.5", 'function toPropertyKey(t){var i=toPrimitive(t,"string");return"symbol"==typeof i?i:i+""}', { + globals: [], + locals: { + toPropertyKey: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "toPropertyKey", + dependencies: { + toPrimitive: ["body.0.body.body.0.declarations.0.init.callee"] + }, + internal: false + }), + toSetter: helper("7.24.0", 'function _toSetter(t,e,n){e||(e=[]);var r=e.length++;return Object.defineProperty({},"_",{set:function(o){e[r]=o,t.apply(n,e)}})}', { + globals: ["Object"], + locals: { + _toSetter: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_toSetter", + dependencies: {}, + internal: false + }), + tsRewriteRelativeImportExtensions: helper("7.27.0", 'function tsRewriteRelativeImportExtensions(t,e){return"string"==typeof t&&/^\\.\\.?\\//.test(t)?t.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+)?)\\.([cm]?)ts$/i,(function(t,s,r,n,o){return s?e?".jsx":".js":!r||n&&o?r+n+"."+o.toLowerCase()+"js":t})):t}', { + globals: [], + locals: { + tsRewriteRelativeImportExtensions: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "tsRewriteRelativeImportExtensions", + dependencies: {}, + internal: false + }), + typeof: helper("7.0.0-beta.0", 'function _typeof(o){"@babel/helpers - typeof";return _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(o){return typeof o}:function(o){return o&&"function"==typeof Symbol&&o.constructor===Symbol&&o!==Symbol.prototype?"symbol":typeof o},_typeof(o)}', { + globals: ["Symbol"], + locals: { + _typeof: ["body.0.id", "body.0.body.body.0.argument.expressions.1.callee", "body.0.body.body.0.argument.expressions.0.left"] + }, + exportBindingAssignments: ["body.0.body.body.0.argument.expressions.0"], + exportName: "_typeof", + dependencies: {}, + internal: false + }), + unsupportedIterableToArray: helper("7.9.0", 'function _unsupportedIterableToArray(r,a){if(r){if("string"==typeof r)return arrayLikeToArray(r,a);var t={}.toString.call(r).slice(8,-1);return"Object"===t&&r.constructor&&(t=r.constructor.name),"Map"===t||"Set"===t?Array.from(r):"Arguments"===t||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)?arrayLikeToArray(r,a):void 0}}', { + globals: ["Array"], + locals: { + _unsupportedIterableToArray: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_unsupportedIterableToArray", + dependencies: { + arrayLikeToArray: ["body.0.body.body.0.consequent.body.0.consequent.argument.callee", "body.0.body.body.0.consequent.body.2.argument.expressions.1.alternate.consequent.callee"] + }, + internal: false + }), + usingCtx: helper("7.23.9", 'function _usingCtx(){var r="function"==typeof SuppressedError?SuppressedError:function(r,e){var n=Error();return n.name="SuppressedError",n.error=r,n.suppressed=e,n},e={},n=[];function using(r,e){if(null!=e){if(Object(e)!==e)throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");if(r)var o=e[Symbol.asyncDispose||Symbol.for("Symbol.asyncDispose")];if(void 0===o&&(o=e[Symbol.dispose||Symbol.for("Symbol.dispose")],r))var t=o;if("function"!=typeof o)throw new TypeError("Object is not disposable.");t&&(o=function(){try{t.call(e)}catch(r){return Promise.reject(r)}}),n.push({v:e,d:o,a:r})}else r&&n.push({d:e,a:r});return e}return{e:e,u:using.bind(null,!1),a:using.bind(null,!0),d:function(){var o,t=this.e,s=0;function next(){for(;o=n.pop();)try{if(!o.a&&1===s)return s=0,n.push(o),Promise.resolve().then(next);if(o.d){var r=o.d.call(o.v);if(o.a)return s|=2,Promise.resolve(r).then(next,err)}else s|=1}catch(r){return err(r)}if(1===s)return t!==e?Promise.reject(t):Promise.resolve();if(t!==e)throw t}function err(n){return t=t!==e?new r(n,t):n,next()}return next()}}}', { + globals: ["SuppressedError", "Error", "Object", "TypeError", "Symbol", "Promise"], + locals: { + _usingCtx: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_usingCtx", + dependencies: {}, + internal: false + }), + wrapAsyncGenerator: helper("7.0.0-beta.0", 'function _wrapAsyncGenerator(e){return function(){return new AsyncGenerator(e.apply(this,arguments))}}function AsyncGenerator(e){var r,t;function resume(r,t){try{var n=e[r](t),o=n.value,u=o instanceof OverloadYield;Promise.resolve(u?o.v:o).then((function(t){if(u){var i="return"===r?"return":"next";if(!o.k||t.done)return resume(i,t);t=e[i](t).value}settle(n.done?"return":"normal",t)}),(function(e){resume("throw",e)}))}catch(e){settle("throw",e)}}function settle(e,n){switch(e){case"return":r.resolve({value:n,done:!0});break;case"throw":r.reject(n);break;default:r.resolve({value:n,done:!1})}(r=r.next)?resume(r.key,r.arg):t=null}this._invoke=function(e,n){return new Promise((function(o,u){var i={key:e,arg:n,resolve:o,reject:u,next:null};t?t=t.next=i:(r=t=i,resume(e,n))}))},"function"!=typeof e.return&&(this.return=void 0)}AsyncGenerator.prototype["function"==typeof Symbol&&Symbol.asyncIterator||"@@asyncIterator"]=function(){return this},AsyncGenerator.prototype.next=function(e){return this._invoke("next",e)},AsyncGenerator.prototype.throw=function(e){return this._invoke("throw",e)},AsyncGenerator.prototype.return=function(e){return this._invoke("return",e)};', { + globals: ["Promise", "Symbol"], + locals: { + _wrapAsyncGenerator: ["body.0.id"], + AsyncGenerator: ["body.1.id", "body.0.body.body.0.argument.body.body.0.argument.callee", "body.2.expression.expressions.0.left.object.object", "body.2.expression.expressions.1.left.object.object", "body.2.expression.expressions.2.left.object.object", "body.2.expression.expressions.3.left.object.object"] + }, + exportBindingAssignments: [], + exportName: "_wrapAsyncGenerator", + dependencies: { + OverloadYield: ["body.1.body.body.1.body.body.0.block.body.0.declarations.2.init.right"] + }, + internal: false + }), + wrapNativeSuper: helper("7.0.0-beta.0", 'function _wrapNativeSuper(t){var r="function"==typeof Map?new Map:void 0;return _wrapNativeSuper=function(t){if(null===t||!isNativeFunction(t))return t;if("function"!=typeof t)throw new TypeError("Super expression must either be null or a function");if(void 0!==r){if(r.has(t))return r.get(t);r.set(t,Wrapper)}function Wrapper(){return construct(t,arguments,getPrototypeOf(this).constructor)}return Wrapper.prototype=Object.create(t.prototype,{constructor:{value:Wrapper,enumerable:!1,writable:!0,configurable:!0}}),setPrototypeOf(Wrapper,t)},_wrapNativeSuper(t)}', { + globals: ["Map", "TypeError", "Object"], + locals: { + _wrapNativeSuper: ["body.0.id", "body.0.body.body.1.argument.expressions.1.callee", "body.0.body.body.1.argument.expressions.0.left"] + }, + exportBindingAssignments: ["body.0.body.body.1.argument.expressions.0"], + exportName: "_wrapNativeSuper", + dependencies: { + getPrototypeOf: ["body.0.body.body.1.argument.expressions.0.right.body.body.3.body.body.0.argument.arguments.2.object.callee"], + setPrototypeOf: ["body.0.body.body.1.argument.expressions.0.right.body.body.4.argument.expressions.1.callee"], + isNativeFunction: ["body.0.body.body.1.argument.expressions.0.right.body.body.0.test.right.argument.callee"], + construct: ["body.0.body.body.1.argument.expressions.0.right.body.body.3.body.body.0.argument.callee"] + }, + internal: false + }), + wrapRegExp: helper("7.19.0", 'function _wrapRegExp(){_wrapRegExp=function(e,r){return new BabelRegExp(e,void 0,r)};var e=RegExp.prototype,r=new WeakMap;function BabelRegExp(e,t,p){var o=RegExp(e,t);return r.set(o,p||r.get(e)),setPrototypeOf(o,BabelRegExp.prototype)}function buildGroups(e,t){var p=r.get(t);return Object.keys(p).reduce((function(r,t){var o=p[t];if("number"==typeof o)r[t]=e[o];else{for(var i=0;void 0===e[o[i]]&&i+1]+)(>|$)/g,(function(e,r,t){if(""===t)return e;var p=o[r];return Array.isArray(p)?"$"+p.join("$"):"number"==typeof p?"$"+p:""})))}if("function"==typeof p){var i=this;return e[Symbol.replace].call(this,t,(function(){var e=arguments;return"object"!=typeof e[e.length-1]&&(e=[].slice.call(e)).push(buildGroups(e,i)),p.apply(this,e)}))}return e[Symbol.replace].call(this,t,p)},_wrapRegExp.apply(this,arguments)}', { + globals: ["RegExp", "WeakMap", "Object", "Symbol", "Array"], + locals: { + _wrapRegExp: ["body.0.id", "body.0.body.body.4.argument.expressions.3.callee.object", "body.0.body.body.0.expression.left"] + }, + exportBindingAssignments: ["body.0.body.body.0.expression"], + exportName: "_wrapRegExp", + dependencies: { + setPrototypeOf: ["body.0.body.body.2.body.body.1.argument.expressions.1.callee"], + inherits: ["body.0.body.body.4.argument.expressions.0.callee"] + }, + internal: false + }), + writeOnlyError: helper("7.12.13", "function _writeOnlyError(r){throw new TypeError('\"'+r+'\" is write-only')}", { + globals: ["TypeError"], + locals: { + _writeOnlyError: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_writeOnlyError", + dependencies: {}, + internal: false + }) +}; +{ + Object.assign(helpers, { + AwaitValue: helper("7.0.0-beta.0", "function _AwaitValue(t){this.wrapped=t}", { + globals: [], + locals: { + _AwaitValue: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_AwaitValue", + dependencies: {}, + internal: false + }), + applyDecs: helper("7.17.8", 'function old_createMetadataMethodsForProperty(e,t,a,r){return{getMetadata:function(o){old_assertNotFinished(r,"getMetadata"),old_assertMetadataKey(o);var i=e[o];if(void 0!==i)if(1===t){var n=i.public;if(void 0!==n)return n[a]}else if(2===t){var l=i.private;if(void 0!==l)return l.get(a)}else if(Object.hasOwnProperty.call(i,"constructor"))return i.constructor},setMetadata:function(o,i){old_assertNotFinished(r,"setMetadata"),old_assertMetadataKey(o);var n=e[o];if(void 0===n&&(n=e[o]={}),1===t){var l=n.public;void 0===l&&(l=n.public={}),l[a]=i}else if(2===t){var s=n.priv;void 0===s&&(s=n.private=new Map),s.set(a,i)}else n.constructor=i}}}function old_convertMetadataMapToFinal(e,t){var a=e[Symbol.metadata||Symbol.for("Symbol.metadata")],r=Object.getOwnPropertySymbols(t);if(0!==r.length){for(var o=0;o=0;m--){var b;void 0!==(p=old_memberDec(h[m],r,c,l,s,o,i,n,f))&&(old_assertValidReturnValue(o,p),0===o?b=p:1===o?(b=old_getInit(p),v=p.get||f.get,y=p.set||f.set,f={get:v,set:y}):f=p,void 0!==b&&(void 0===d?d=b:"function"==typeof d?d=[d,b]:d.push(b)))}if(0===o||1===o){if(void 0===d)d=function(e,t){return t};else if("function"!=typeof d){var g=d;d=function(e,t){for(var a=t,r=0;r3,m=v>=5;if(m?(u=t,f=r,0!=(v-=5)&&(p=n=n||[])):(u=t.prototype,f=a,0!==v&&(p=i=i||[])),0!==v&&!h){var b=m?s:l,g=b.get(y)||0;if(!0===g||3===g&&4!==v||4===g&&3!==v)throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: "+y);!g&&v>2?b.set(y,v):b.set(y,!0)}old_applyMemberDec(e,u,d,y,v,m,h,f,p)}}old_pushInitializers(e,i),old_pushInitializers(e,n)}function old_pushInitializers(e,t){t&&e.push((function(e){for(var a=0;a0){for(var o=[],i=t,n=t.name,l=r.length-1;l>=0;l--){var s={v:!1};try{var c=Object.assign({kind:"class",name:n,addInitializer:old_createAddInitializerMethod(o,s)},old_createMetadataMethodsForProperty(a,0,n,s)),d=r[l](i,c)}finally{s.v=!0}void 0!==d&&(old_assertValidReturnValue(10,d),i=d)}e.push(i,(function(){for(var e=0;e=0;v--){var g;void 0!==(f=memberDec(h[v],a,c,o,n,i,s,u))&&(assertValidReturnValue(n,f),0===n?g=f:1===n?(g=f.init,p=f.get||u.get,d=f.set||u.set,u={get:p,set:d}):u=f,void 0!==g&&(void 0===l?l=g:"function"==typeof l?l=[l,g]:l.push(g)))}if(0===n||1===n){if(void 0===l)l=function(e,t){return t};else if("function"!=typeof l){var y=l;l=function(e,t){for(var r=t,a=0;a3,h=f>=5;if(h?(l=t,0!=(f-=5)&&(u=n=n||[])):(l=t.prototype,0!==f&&(u=a=a||[])),0!==f&&!d){var v=h?s:i,g=v.get(p)||0;if(!0===g||3===g&&4!==f||4===g&&3!==f)throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: "+p);!g&&f>2?v.set(p,f):v.set(p,!0)}applyMemberDec(e,l,c,p,f,h,d,u)}}pushInitializers(e,a),pushInitializers(e,n)}(a,e,t),function(e,t,r){if(r.length>0){for(var a=[],n=t,i=t.name,s=r.length-1;s>=0;s--){var o={v:!1};try{var c=r[s](n,{kind:"class",name:i,addInitializer:createAddInitializerMethod(a,o)})}finally{o.v=!0}void 0!==c&&(assertValidReturnValue(10,c),n=c)}e.push(n,(function(){for(var e=0;e=0;g--){var y;void 0!==(p=memberDec(v[g],n,c,s,a,i,o,f))&&(assertValidReturnValue(a,p),0===a?y=p:1===a?(y=p.init,d=p.get||f.get,h=p.set||f.set,f={get:d,set:h}):f=p,void 0!==y&&(void 0===l?l=y:"function"==typeof l?l=[l,y]:l.push(y)))}if(0===a||1===a){if(void 0===l)l=function(e,t){return t};else if("function"!=typeof l){var m=l;l=function(e,t){for(var r=t,n=0;n3,h=f>=5;if(h?(l=e,0!=(f-=5)&&(u=n=n||[])):(l=e.prototype,0!==f&&(u=r=r||[])),0!==f&&!d){var v=h?o:i,g=v.get(p)||0;if(!0===g||3===g&&4!==f||4===g&&3!==f)throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: "+p);!g&&f>2?v.set(p,f):v.set(p,!0)}applyMemberDec(a,l,c,p,f,h,d,u)}}return pushInitializers(a,r),pushInitializers(a,n),a}function pushInitializers(e,t){t&&e.push((function(e){for(var r=0;r0){for(var r=[],n=e,a=e.name,i=t.length-1;i>=0;i--){var o={v:!1};try{var s=t[i](n,{kind:"class",name:a,addInitializer:createAddInitializerMethod(r,o)})}finally{o.v=!0}void 0!==s&&(assertValidReturnValue(10,s),n=s)}return[n,function(){for(var e=0;e=0;m--){var b;void 0!==(h=memberDec(g[m],n,u,o,a,i,s,p,c))&&(assertValidReturnValue(a,h),0===a?b=h:1===a?(b=h.init,v=h.get||p.get,y=h.set||p.set,p={get:v,set:y}):p=h,void 0!==b&&(void 0===l?l=b:"function"==typeof l?l=[l,b]:l.push(b)))}if(0===a||1===a){if(void 0===l)l=function(e,t){return t};else if("function"!=typeof l){var I=l;l=function(e,t){for(var r=t,n=0;n3,y=d>=5,g=r;if(y?(f=e,0!=(d-=5)&&(p=a=a||[]),v&&!i&&(i=function(t){return checkInRHS(t)===e}),g=i):(f=e.prototype,0!==d&&(p=n=n||[])),0!==d&&!v){var m=y?c:o,b=m.get(h)||0;if(!0===b||3===b&&4!==d||4===b&&3!==d)throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: "+h);!b&&d>2?m.set(h,d):m.set(h,!0)}applyMemberDec(s,f,l,h,d,y,v,p,g)}}return pushInitializers(s,n),pushInitializers(s,a),s}function pushInitializers(e,t){t&&e.push((function(e){for(var r=0;r0){for(var r=[],n=e,a=e.name,i=t.length-1;i>=0;i--){var s={v:!1};try{var o=t[i](n,{kind:"class",name:a,addInitializer:createAddInitializerMethod(r,s)})}finally{s.v=!0}void 0!==o&&(assertValidReturnValue(10,o),n=o)}return[n,function(){for(var e=0;e=0;j-=r?2:1){var D=v[j],E=r?v[j-1]:void 0,I={},O={kind:["field","accessor","method","getter","setter","class"][o],name:n,metadata:a,addInitializer:function(e,t){if(e.v)throw Error("attempted to call addInitializer after decoration was finished");s(t,"An initializer","be",!0),c.push(t)}.bind(null,I)};try{if(b)(y=s(D.call(E,P,O),"class decorators","return"))&&(P=y);else{var k,F;O.static=l,O.private=f,f?2===o?k=function(e){return m(e),w.value}:(o<4&&(k=i(w,"get",m)),3!==o&&(F=i(w,"set",m))):(k=function(e){return e[n]},(o<2||4===o)&&(F=function(e,t){e[n]=t}));var N=O.access={has:f?h.bind():function(e){return n in e}};if(k&&(N.get=k),F&&(N.set=F),P=D.call(E,d?{get:w.get,set:w.set}:w[A],O),d){if("object"==typeof P&&P)(y=s(P.get,"accessor.get"))&&(w.get=y),(y=s(P.set,"accessor.set"))&&(w.set=y),(y=s(P.init,"accessor.init"))&&S.push(y);else if(void 0!==P)throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0")}else s(P,(p?"field":"method")+" decorators","return")&&(p?S.push(P):w[A]=P)}}finally{I.v=!0}}return(p||d)&&u.push((function(e,t){for(var r=S.length-1;r>=0;r--)t=S[r].call(e,t);return t})),p||b||(f?d?u.push(i(w,"get"),i(w,"set")):u.push(2===o?w[A]:i.call.bind(w[A])):Object.defineProperty(e,n,w)),P}function u(e,t){return Object.defineProperty(e,Symbol.metadata||Symbol.for("Symbol.metadata"),{configurable:!0,enumerable:!0,value:t})}if(arguments.length>=6)var l=a[Symbol.metadata||Symbol.for("Symbol.metadata")];var f=Object.create(null==l?null:l),p=function(e,t,r,n){var o,a,i=[],s=function(t){return checkInRHS(t)===e},u=new Map;function l(e){e&&i.push(c.bind(null,e))}for(var f=0;f3,y=16&d,v=!!(8&d),g=0==(d&=7),b=h+"/"+v;if(!g&&!m){var w=u.get(b);if(!0===w||3===w&&4!==d||4===w&&3!==d)throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: "+h);u.set(b,!(d>2)||d)}applyDec(v?e:e.prototype,p,y,m?"#"+h:toPropertyKey(h),d,n,v?a=a||[]:o=o||[],i,v,m,g,1===d,v&&m?s:r)}}return l(o),l(a),i}(e,t,o,f);return r.length||u(e,f),{e:p,get c(){var t=[];return r.length&&[u(applyDec(e,[r],n,e.name,5,f,t),f),c.bind(null,t,e)]}}}', { + globals: ["TypeError", "Array", "Object", "Error", "Symbol", "Map"], + locals: { + applyDecs2305: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "applyDecs2305", + dependencies: { + checkInRHS: ["body.0.body.body.6.declarations.1.init.callee.body.body.0.declarations.3.init.body.body.0.argument.left.callee"], + setFunctionName: ["body.0.body.body.3.body.body.2.consequent.body.2.expression.consequent.expressions.0.consequent.right.properties.0.value.callee", "body.0.body.body.3.body.body.2.consequent.body.2.expression.consequent.expressions.1.right.callee"], + toPropertyKey: ["body.0.body.body.6.declarations.1.init.callee.body.body.2.body.body.1.consequent.body.2.expression.arguments.3.alternate.callee"] + }, + internal: false + }), + classApplyDescriptorDestructureSet: helper("7.13.10", 'function _classApplyDescriptorDestructureSet(e,t){if(t.set)return"__destrObj"in t||(t.__destrObj={set value(r){t.set.call(e,r)}}),t.__destrObj;if(!t.writable)throw new TypeError("attempted to set read only private field");return t}', { + globals: ["TypeError"], + locals: { + _classApplyDescriptorDestructureSet: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_classApplyDescriptorDestructureSet", + dependencies: {}, + internal: false + }), + classApplyDescriptorGet: helper("7.13.10", "function _classApplyDescriptorGet(e,t){return t.get?t.get.call(e):t.value}", { + globals: [], + locals: { + _classApplyDescriptorGet: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_classApplyDescriptorGet", + dependencies: {}, + internal: false + }), + classApplyDescriptorSet: helper("7.13.10", 'function _classApplyDescriptorSet(e,t,l){if(t.set)t.set.call(e,l);else{if(!t.writable)throw new TypeError("attempted to set read only private field");t.value=l}}', { + globals: ["TypeError"], + locals: { + _classApplyDescriptorSet: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_classApplyDescriptorSet", + dependencies: {}, + internal: false + }), + classCheckPrivateStaticAccess: helper("7.13.10", "function _classCheckPrivateStaticAccess(s,a,r){return assertClassBrand(a,s,r)}", { + globals: [], + locals: { + _classCheckPrivateStaticAccess: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_classCheckPrivateStaticAccess", + dependencies: { + assertClassBrand: ["body.0.body.body.0.argument.callee"] + }, + internal: false + }), + classCheckPrivateStaticFieldDescriptor: helper("7.13.10", 'function _classCheckPrivateStaticFieldDescriptor(t,e){if(void 0===t)throw new TypeError("attempted to "+e+" private static field before its declaration")}', { + globals: ["TypeError"], + locals: { + _classCheckPrivateStaticFieldDescriptor: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_classCheckPrivateStaticFieldDescriptor", + dependencies: {}, + internal: false + }), + classExtractFieldDescriptor: helper("7.13.10", "function _classExtractFieldDescriptor(e,t){return classPrivateFieldGet2(t,e)}", { + globals: [], + locals: { + _classExtractFieldDescriptor: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_classExtractFieldDescriptor", + dependencies: { + classPrivateFieldGet2: ["body.0.body.body.0.argument.callee"] + }, + internal: false + }), + classPrivateFieldDestructureSet: helper("7.4.4", "function _classPrivateFieldDestructureSet(e,t){var r=classPrivateFieldGet2(t,e);return classApplyDescriptorDestructureSet(e,r)}", { + globals: [], + locals: { + _classPrivateFieldDestructureSet: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_classPrivateFieldDestructureSet", + dependencies: { + classApplyDescriptorDestructureSet: ["body.0.body.body.1.argument.callee"], + classPrivateFieldGet2: ["body.0.body.body.0.declarations.0.init.callee"] + }, + internal: false + }), + classPrivateFieldGet: helper("7.0.0-beta.0", "function _classPrivateFieldGet(e,t){var r=classPrivateFieldGet2(t,e);return classApplyDescriptorGet(e,r)}", { + globals: [], + locals: { + _classPrivateFieldGet: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_classPrivateFieldGet", + dependencies: { + classApplyDescriptorGet: ["body.0.body.body.1.argument.callee"], + classPrivateFieldGet2: ["body.0.body.body.0.declarations.0.init.callee"] + }, + internal: false + }), + classPrivateFieldSet: helper("7.0.0-beta.0", "function _classPrivateFieldSet(e,t,r){var s=classPrivateFieldGet2(t,e);return classApplyDescriptorSet(e,s,r),r}", { + globals: [], + locals: { + _classPrivateFieldSet: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_classPrivateFieldSet", + dependencies: { + classApplyDescriptorSet: ["body.0.body.body.1.argument.expressions.0.callee"], + classPrivateFieldGet2: ["body.0.body.body.0.declarations.0.init.callee"] + }, + internal: false + }), + classPrivateMethodGet: helper("7.1.6", "function _classPrivateMethodGet(s,a,r){return assertClassBrand(a,s),r}", { + globals: [], + locals: { + _classPrivateMethodGet: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_classPrivateMethodGet", + dependencies: { + assertClassBrand: ["body.0.body.body.0.argument.expressions.0.callee"] + }, + internal: false + }), + classPrivateMethodSet: helper("7.1.6", 'function _classPrivateMethodSet(){throw new TypeError("attempted to reassign private method")}', { + globals: ["TypeError"], + locals: { + _classPrivateMethodSet: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_classPrivateMethodSet", + dependencies: {}, + internal: false + }), + classStaticPrivateFieldDestructureSet: helper("7.13.10", 'function _classStaticPrivateFieldDestructureSet(t,r,s){return assertClassBrand(r,t),classCheckPrivateStaticFieldDescriptor(s,"set"),classApplyDescriptorDestructureSet(t,s)}', { + globals: [], + locals: { + _classStaticPrivateFieldDestructureSet: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_classStaticPrivateFieldDestructureSet", + dependencies: { + classApplyDescriptorDestructureSet: ["body.0.body.body.0.argument.expressions.2.callee"], + assertClassBrand: ["body.0.body.body.0.argument.expressions.0.callee"], + classCheckPrivateStaticFieldDescriptor: ["body.0.body.body.0.argument.expressions.1.callee"] + }, + internal: false + }), + classStaticPrivateFieldSpecGet: helper("7.0.2", 'function _classStaticPrivateFieldSpecGet(t,s,r){return assertClassBrand(s,t),classCheckPrivateStaticFieldDescriptor(r,"get"),classApplyDescriptorGet(t,r)}', { + globals: [], + locals: { + _classStaticPrivateFieldSpecGet: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_classStaticPrivateFieldSpecGet", + dependencies: { + classApplyDescriptorGet: ["body.0.body.body.0.argument.expressions.2.callee"], + assertClassBrand: ["body.0.body.body.0.argument.expressions.0.callee"], + classCheckPrivateStaticFieldDescriptor: ["body.0.body.body.0.argument.expressions.1.callee"] + }, + internal: false + }), + classStaticPrivateFieldSpecSet: helper("7.0.2", 'function _classStaticPrivateFieldSpecSet(s,t,r,e){return assertClassBrand(t,s),classCheckPrivateStaticFieldDescriptor(r,"set"),classApplyDescriptorSet(s,r,e),e}', { + globals: [], + locals: { + _classStaticPrivateFieldSpecSet: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_classStaticPrivateFieldSpecSet", + dependencies: { + classApplyDescriptorSet: ["body.0.body.body.0.argument.expressions.2.callee"], + assertClassBrand: ["body.0.body.body.0.argument.expressions.0.callee"], + classCheckPrivateStaticFieldDescriptor: ["body.0.body.body.0.argument.expressions.1.callee"] + }, + internal: false + }), + classStaticPrivateMethodSet: helper("7.3.2", 'function _classStaticPrivateMethodSet(){throw new TypeError("attempted to set read only static private field")}', { + globals: ["TypeError"], + locals: { + _classStaticPrivateMethodSet: ["body.0.id"] + }, + exportBindingAssignments: [], + exportName: "_classStaticPrivateMethodSet", + dependencies: {}, + internal: false + }), + defineEnumerableProperties: helper("7.0.0-beta.0", 'function _defineEnumerableProperties(e,r){for(var t in r){var n=r[t];n.configurable=n.enumerable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(e,t,n)}if(Object.getOwnPropertySymbols)for(var a=Object.getOwnPropertySymbols(r),b=0;b0;)try{var o=r.pop(),p=o.d.call(o.v);if(o.a)return Promise.resolve(p).then(next,err)}catch(r){return err(r)}if(s)throw e}function err(r){return e=s?new dispose_SuppressedError(e,r):r,s=!0,next()}return next()}', { + globals: ["SuppressedError", "Error", "Object", "Promise"], + locals: { + dispose_SuppressedError: ["body.0.id", "body.0.body.body.0.argument.expressions.0.alternate.expressions.1.left.object", "body.0.body.body.0.argument.expressions.0.alternate.expressions.1.right.arguments.1.properties.0.value.properties.0.value", "body.0.body.body.0.argument.expressions.1.callee", "body.1.body.body.1.body.body.0.argument.expressions.0.right.consequent.callee", "body.0.body.body.0.argument.expressions.0.consequent.left", "body.0.body.body.0.argument.expressions.0.alternate.expressions.0.left"], + _dispose: ["body.1.id"] + }, + exportBindingAssignments: [], + exportName: "_dispose", + dependencies: {}, + internal: false + }), + objectSpread: helper("7.0.0-beta.0", 'function _objectSpread(e){for(var r=1;r t.Program;\n metadata: HelperMetadata;\n}\n\nexport interface HelperMetadata {\n globals: string[];\n locals: { [name: string]: string[] };\n dependencies: { [name: string]: string[] };\n exportBindingAssignments: string[];\n exportName: string;\n internal: boolean;\n}\n\nfunction helper(\n minVersion: string,\n source: string,\n metadata: HelperMetadata,\n): Helper {\n return Object.freeze({\n minVersion,\n ast: () => template.program.ast(source, { preserveComments: true }),\n metadata,\n });\n}\n\nexport { helpers as default };\nconst helpers: Record = {\n __proto__: null,\n // size: 47, gzip size: 63\n OverloadYield: helper(\n \"7.18.14\",\n \"function _OverloadYield(e,d){this.v=e,this.k=d}\",\n {\n globals: [],\n locals: { _OverloadYield: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_OverloadYield\",\n dependencies: {},\n internal: false,\n },\n ),\n // size: 447, gzip size: 270\n applyDecoratedDescriptor: helper(\n \"7.0.0-beta.0\",\n 'function _applyDecoratedDescriptor(i,e,r,n,l){var a={};return Object.keys(n).forEach((function(i){a[i]=n[i]})),a.enumerable=!!a.enumerable,a.configurable=!!a.configurable,(\"value\"in a||a.initializer)&&(a.writable=!0),a=r.slice().reverse().reduce((function(r,n){return n(i,e,r)||r}),a),l&&void 0!==a.initializer&&(a.value=a.initializer?a.initializer.call(l):void 0,a.initializer=void 0),void 0===a.initializer?(Object.defineProperty(i,e,a),null):a}',\n {\n globals: [\"Object\"],\n locals: { _applyDecoratedDescriptor: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_applyDecoratedDescriptor\",\n dependencies: {},\n internal: false,\n },\n ),\n // size: 2840, gzip size: 1469\n applyDecs2311: helper(\n \"7.24.0\",\n 'function applyDecs2311(e,t,n,r,o,i){var a,c,u,s,f,l,p,d=Symbol.metadata||Symbol.for(\"Symbol.metadata\"),m=Object.defineProperty,h=Object.create,y=[h(null),h(null)],v=t.length;function g(t,n,r){return function(o,i){n&&(i=o,o=e);for(var a=0;a=0;O-=n?2:1){var T=b(h[O],\"A decorator\",\"be\",!0),z=n?h[O-1]:void 0,A={},H={kind:[\"field\",\"accessor\",\"method\",\"getter\",\"setter\",\"class\"][o],name:r,metadata:a,addInitializer:function(e,t){if(e.v)throw new TypeError(\"attempted to call addInitializer after decoration was finished\");b(t,\"An initializer\",\"be\",!0),i.push(t)}.bind(null,A)};if(w)c=T.call(z,N,H),A.v=1,b(c,\"class decorators\",\"return\")&&(N=c);else if(H.static=s,H.private=f,c=H.access={has:f?p.bind():function(e){return r in e}},j||(c.get=f?E?function(e){return d(e),P.value}:I(\"get\",0,d):function(e){return e[r]}),E||S||(c.set=f?I(\"set\",0,d):function(e,t){e[r]=t}),N=T.call(z,D?{get:P.get,set:P.set}:P[F],H),A.v=1,D){if(\"object\"==typeof N&&N)(c=b(N.get,\"accessor.get\"))&&(P.get=c),(c=b(N.set,\"accessor.set\"))&&(P.set=c),(c=b(N.init,\"accessor.init\"))&&k.unshift(c);else if(void 0!==N)throw new TypeError(\"accessor decorators must return an object with get, set, or init properties or undefined\")}else b(N,(l?\"field\":\"method\")+\" decorators\",\"return\")&&(l?k.unshift(N):P[F]=N)}return o<2&&u.push(g(k,s,1),g(i,s,0)),l||w||(f?D?u.splice(-1,0,I(\"get\",s),I(\"set\",s)):u.push(E?P[F]:b.call.bind(P[F])):m(e,r,P)),N}function w(e){return m(e,d,{configurable:!0,enumerable:!0,value:a})}return void 0!==i&&(a=i[d]),a=h(null==a?null:a),f=[],l=function(e){e&&f.push(g(e))},p=function(t,r){for(var i=0;ir.length)&&(a=r.length);for(var e=0,n=Array(a);e=r.length?{done:!0}:{done:!1,value:r[n++]}},e:function(r){throw r},f:F}}throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\")}var o,a=!0,u=!1;return{s:function(){t=t.call(r)},n:function(){var r=t.next();return a=r.done,r},e:function(r){u=!0,o=r},f:function(){try{a||null==t.return||t.return()}finally{if(u)throw o}}}}',\n {\n globals: [\"Symbol\", \"Array\", \"TypeError\"],\n locals: { _createForOfIteratorHelper: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_createForOfIteratorHelper\",\n dependencies: {\n unsupportedIterableToArray: [\n \"body.0.body.body.1.consequent.body.0.test.left.right.right.callee\",\n ],\n },\n internal: false,\n },\n ),\n // size: 488, gzip size: 335\n createForOfIteratorHelperLoose: helper(\n \"7.9.0\",\n 'function _createForOfIteratorHelperLoose(r,e){var t=\"undefined\"!=typeof Symbol&&r[Symbol.iterator]||r[\"@@iterator\"];if(t)return(t=t.call(r)).next.bind(t);if(Array.isArray(r)||(t=unsupportedIterableToArray(r))||e&&r&&\"number\"==typeof r.length){t&&(r=t);var o=0;return function(){return o>=r.length?{done:!0}:{done:!1,value:r[o++]}}}throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\")}',\n {\n globals: [\"Symbol\", \"Array\", \"TypeError\"],\n locals: { _createForOfIteratorHelperLoose: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_createForOfIteratorHelperLoose\",\n dependencies: {\n unsupportedIterableToArray: [\n \"body.0.body.body.2.test.left.right.right.callee\",\n ],\n },\n internal: false,\n },\n ),\n // size: 255, gzip size: 172\n createSuper: helper(\n \"7.9.0\",\n \"function _createSuper(t){var r=isNativeReflectConstruct();return function(){var e,o=getPrototypeOf(t);if(r){var s=getPrototypeOf(this).constructor;e=Reflect.construct(o,arguments,s)}else e=o.apply(this,arguments);return possibleConstructorReturn(this,e)}}\",\n {\n globals: [\"Reflect\"],\n locals: { _createSuper: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_createSuper\",\n dependencies: {\n getPrototypeOf: [\n \"body.0.body.body.1.argument.body.body.0.declarations.1.init.callee\",\n \"body.0.body.body.1.argument.body.body.1.consequent.body.0.declarations.0.init.object.callee\",\n ],\n isNativeReflectConstruct: [\n \"body.0.body.body.0.declarations.0.init.callee\",\n ],\n possibleConstructorReturn: [\n \"body.0.body.body.1.argument.body.body.2.argument.callee\",\n ],\n },\n internal: false,\n },\n ),\n // size: 7029, gzip size: 2057\n decorate: helper(\n \"7.1.5\",\n 'function _decorate(e,r,t,i){var o=_getDecoratorsApi();if(i)for(var n=0;n=0;n--){var s=r[e.placement];s.splice(s.indexOf(e.key),1);var a=this.fromElementDescriptor(e),l=this.toElementFinisherExtras((0,o[n])(a)||a);e=l.element,this.addElementPlacement(e,r),l.finisher&&i.push(l.finisher);var c=l.extras;if(c){for(var p=0;p=0;i--){var o=this.fromClassDescriptor(e),n=this.toClassDescriptor((0,r[i])(o)||o);if(void 0!==n.finisher&&t.push(n.finisher),void 0!==n.elements){e=n.elements;for(var s=0;s1){for(var t=Array(n),f=0;f3?(o=l===n)&&(u=i[(c=i[4])?5:(c=3,3)],i[4]=i[5]=e):i[0]<=d&&((o=r<2&&dn||n>l)&&(i[4]=r,i[5]=n,G.n=l,c=0))}if(o||r>1)return a;throw y=!0,n}return function(o,p,l){if(f>1)throw TypeError(\"Generator is already running\");for(y&&1===p&&d(p,l),c=p,u=l;(t=c<2?e:u)||!y;){i||(c?c<3?(c>1&&(G.n=-1),d(c,u)):G.n=u:G.v=u);try{if(f=2,i){if(c||(o=\"next\"),t=i[o]){if(!(t=t.call(i,u)))throw TypeError(\"iterator result is not an object\");if(!t.done)return t;u=t.value,c<2&&(c=0)}else 1===c&&(t=i.return)&&t.call(i),c<2&&(u=TypeError(\"The iterator does not provide a \\'\"+o+\"\\' method\"),c=1);i=e}else if((t=(y=G.n<0)?u:r.call(n,G))!==a)break}catch(t){i=e,c=1,u=t}finally{f=1}}return{value:t,done:y}}}(r,o,i),!0),u}var a={};function Generator(){}function GeneratorFunction(){}function GeneratorFunctionPrototype(){}t=Object.getPrototypeOf;var c=[][n]?t(t([][n]())):(define(t={},n,(function(){return this})),t),u=GeneratorFunctionPrototype.prototype=Generator.prototype=Object.create(c);function f(e){return Object.setPrototypeOf?Object.setPrototypeOf(e,GeneratorFunctionPrototype):(e.__proto__=GeneratorFunctionPrototype,define(e,o,\"GeneratorFunction\")),e.prototype=Object.create(u),e}return GeneratorFunction.prototype=GeneratorFunctionPrototype,define(u,\"constructor\",GeneratorFunctionPrototype),define(GeneratorFunctionPrototype,\"constructor\",GeneratorFunction),GeneratorFunction.displayName=\"GeneratorFunction\",define(GeneratorFunctionPrototype,o,\"GeneratorFunction\"),define(u),define(u,o,\"Generator\"),define(u,n,(function(){return this})),define(u,\"toString\",(function(){return\"[object Generator]\"})),(_regenerator=function(){return{w:i,m:f}})()}',\n {\n globals: [\"Symbol\", \"Object\", \"TypeError\"],\n locals: {\n _regenerator: [\n \"body.0.id\",\n \"body.0.body.body.9.argument.expressions.9.callee.left\",\n ],\n },\n exportBindingAssignments: [\n \"body.0.body.body.9.argument.expressions.9.callee\",\n ],\n exportName: \"_regenerator\",\n dependencies: {\n regeneratorDefine: [\n \"body.0.body.body.1.body.body.1.argument.expressions.0.callee\",\n \"body.0.body.body.7.declarations.0.init.alternate.expressions.0.callee\",\n \"body.0.body.body.8.body.body.0.argument.expressions.0.alternate.expressions.1.callee\",\n \"body.0.body.body.9.argument.expressions.1.callee\",\n \"body.0.body.body.9.argument.expressions.2.callee\",\n \"body.0.body.body.9.argument.expressions.4.callee\",\n \"body.0.body.body.9.argument.expressions.5.callee\",\n \"body.0.body.body.9.argument.expressions.6.callee\",\n \"body.0.body.body.9.argument.expressions.7.callee\",\n \"body.0.body.body.9.argument.expressions.8.callee\",\n ],\n },\n internal: false,\n },\n ),\n // size: 132, gzip size: 119\n regeneratorAsync: helper(\n \"7.27.0\",\n \"function _regeneratorAsync(n,e,r,t,o){var a=asyncGen(n,e,r,t,o);return a.next().then((function(n){return n.done?n.value:a.next()}))}\",\n {\n globals: [],\n locals: { _regeneratorAsync: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_regeneratorAsync\",\n dependencies: {\n regeneratorAsyncGen: [\"body.0.body.body.0.declarations.0.init.callee\"],\n },\n internal: false,\n },\n ),\n // size: 114, gzip size: 101\n regeneratorAsyncGen: helper(\n \"7.27.0\",\n \"function _regeneratorAsyncGen(r,e,t,o,n){return new regeneratorAsyncIterator(regenerator().w(r,e,t,o),n||Promise)}\",\n {\n globals: [\"Promise\"],\n locals: { _regeneratorAsyncGen: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_regeneratorAsyncGen\",\n dependencies: {\n regenerator: [\n \"body.0.body.body.0.argument.arguments.0.callee.object.callee\",\n ],\n regeneratorAsyncIterator: [\"body.0.body.body.0.argument.callee\"],\n },\n internal: false,\n },\n ),\n // size: 599, gzip size: 306\n regeneratorAsyncIterator: helper(\n \"7.27.0\",\n 'function AsyncIterator(t,e){function n(r,o,i,f){try{var c=t[r](o),u=c.value;return u instanceof OverloadYield?e.resolve(u.v).then((function(t){n(\"next\",t,i,f)}),(function(t){n(\"throw\",t,i,f)})):e.resolve(u).then((function(t){c.value=t,i(c)}),(function(t){return n(\"throw\",t,i,f)}))}catch(t){f(t)}}var r;this.next||(define(AsyncIterator.prototype),define(AsyncIterator.prototype,\"function\"==typeof Symbol&&Symbol.asyncIterator||\"@asyncIterator\",(function(){return this}))),define(this,\"_invoke\",(function(t,o,i){function f(){return new e((function(e,r){n(t,i,e,r)}))}return r=r?r.then(f,f):f()}),!0)}',\n {\n globals: [\"Symbol\"],\n locals: {\n AsyncIterator: [\n \"body.0.id\",\n \"body.0.body.body.2.expression.expressions.0.right.expressions.0.arguments.0.object\",\n \"body.0.body.body.2.expression.expressions.0.right.expressions.1.arguments.0.object\",\n ],\n },\n exportBindingAssignments: [],\n exportName: \"AsyncIterator\",\n dependencies: {\n OverloadYield: [\n \"body.0.body.body.0.body.body.0.block.body.1.argument.test.right\",\n ],\n regeneratorDefine: [\n \"body.0.body.body.2.expression.expressions.0.right.expressions.0.callee\",\n \"body.0.body.body.2.expression.expressions.0.right.expressions.1.callee\",\n \"body.0.body.body.2.expression.expressions.1.callee\",\n ],\n },\n internal: true,\n },\n ),\n // size: 349, gzip size: 222\n regeneratorDefine: helper(\n \"7.27.0\",\n 'function regeneratorDefine(e,r,n,t){var i=Object.defineProperty;try{i({},\"\",{})}catch(e){i=0}regeneratorDefine=function(e,r,n,t){function o(r,n){regeneratorDefine(e,r,(function(e){return this._invoke(r,n,e)}))}r?i?i(e,r,{value:n,enumerable:!t,configurable:!t,writable:!t}):e[r]=n:(o(\"next\",0),o(\"throw\",1),o(\"return\",2))},regeneratorDefine(e,r,n,t)}',\n {\n globals: [\"Object\"],\n locals: {\n regeneratorDefine: [\n \"body.0.id\",\n \"body.0.body.body.2.expression.expressions.0.right.body.body.0.body.body.0.expression.callee\",\n \"body.0.body.body.2.expression.expressions.1.callee\",\n \"body.0.body.body.2.expression.expressions.0.left\",\n ],\n },\n exportBindingAssignments: [\"body.0.body.body.2.expression.expressions.0\"],\n exportName: \"regeneratorDefine\",\n dependencies: {},\n internal: true,\n },\n ),\n // size: 181, gzip size: 152\n regeneratorKeys: helper(\n \"7.27.0\",\n \"function _regeneratorKeys(e){var n=Object(e),r=[];for(var t in n)r.unshift(t);return function e(){for(;r.length;)if((t=r.pop())in n)return e.value=t,e.done=!1,e;return e.done=!0,e}}\",\n {\n globals: [\"Object\"],\n locals: { _regeneratorKeys: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_regeneratorKeys\",\n dependencies: {},\n internal: false,\n },\n ),\n // size: 327, gzip size: 234\n regeneratorValues: helper(\n \"7.18.0\",\n 'function _regeneratorValues(e){if(null!=e){var t=e[\"function\"==typeof Symbol&&Symbol.iterator||\"@@iterator\"],r=0;if(t)return t.call(e);if(\"function\"==typeof e.next)return e;if(!isNaN(e.length))return{next:function(){return e&&r>=e.length&&(e=void 0),{value:e&&e[r++],done:!e}}}}throw new TypeError(typeof e+\" is not iterable\")}',\n {\n globals: [\"Symbol\", \"isNaN\", \"TypeError\"],\n locals: { _regeneratorValues: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_regeneratorValues\",\n dependencies: {},\n internal: false,\n },\n ),\n // size: 494, gzip size: 274\n set: helper(\n \"7.0.0-beta.0\",\n 'function set(e,r,t,o){return set=\"undefined\"!=typeof Reflect&&Reflect.set?Reflect.set:function(e,r,t,o){var f,i=superPropBase(e,r);if(i){if((f=Object.getOwnPropertyDescriptor(i,r)).set)return f.set.call(o,t),!0;if(!f.writable)return!1}if(f=Object.getOwnPropertyDescriptor(o,r)){if(!f.writable)return!1;f.value=t,Object.defineProperty(o,r,f)}else defineProperty(o,r,t);return!0},set(e,r,t,o)}function _set(e,r,t,o,f){if(!set(e,r,t,o||e)&&f)throw new TypeError(\"failed to set property\");return t}',\n {\n globals: [\"Reflect\", \"Object\", \"TypeError\"],\n locals: {\n set: [\n \"body.0.id\",\n \"body.0.body.body.0.argument.expressions.1.callee\",\n \"body.1.body.body.0.test.left.argument.callee\",\n \"body.0.body.body.0.argument.expressions.0.left\",\n ],\n _set: [\"body.1.id\"],\n },\n exportBindingAssignments: [],\n exportName: \"_set\",\n dependencies: {\n superPropBase: [\n \"body.0.body.body.0.argument.expressions.0.right.alternate.body.body.0.declarations.1.init.callee\",\n ],\n defineProperty: [\n \"body.0.body.body.0.argument.expressions.0.right.alternate.body.body.2.alternate.expression.callee\",\n ],\n },\n internal: false,\n },\n ),\n // size: 178, gzip size: 166\n setFunctionName: helper(\n \"7.23.6\",\n 'function setFunctionName(e,t,n){\"symbol\"==typeof t&&(t=(t=t.description)?\"[\"+t+\"]\":\"\");try{Object.defineProperty(e,\"name\",{configurable:!0,value:n?n+\" \"+t:t})}catch(e){}return e}',\n {\n globals: [\"Object\"],\n locals: { setFunctionName: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"setFunctionName\",\n dependencies: {},\n internal: false,\n },\n ),\n // size: 163, gzip size: 102\n setPrototypeOf: helper(\n \"7.0.0-beta.0\",\n \"function _setPrototypeOf(t,e){return _setPrototypeOf=Object.setPrototypeOf?Object.setPrototypeOf.bind():function(t,e){return t.__proto__=e,t},_setPrototypeOf(t,e)}\",\n {\n globals: [\"Object\"],\n locals: {\n _setPrototypeOf: [\n \"body.0.id\",\n \"body.0.body.body.0.argument.expressions.1.callee\",\n \"body.0.body.body.0.argument.expressions.0.left\",\n ],\n },\n exportBindingAssignments: [\"body.0.body.body.0.argument.expressions.0\"],\n exportName: \"_setPrototypeOf\",\n dependencies: {},\n internal: false,\n },\n ),\n // size: 103, gzip size: 107\n skipFirstGeneratorNext: helper(\n \"7.0.0-beta.0\",\n \"function _skipFirstGeneratorNext(t){return function(){var r=t.apply(this,arguments);return r.next(),r}}\",\n {\n globals: [],\n locals: { _skipFirstGeneratorNext: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_skipFirstGeneratorNext\",\n dependencies: {},\n internal: false,\n },\n ),\n // size: 133, gzip size: 117\n slicedToArray: helper(\n \"7.0.0-beta.0\",\n \"function _slicedToArray(r,e){return arrayWithHoles(r)||iterableToArrayLimit(r,e)||unsupportedIterableToArray(r,e)||nonIterableRest()}\",\n {\n globals: [],\n locals: { _slicedToArray: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_slicedToArray\",\n dependencies: {\n arrayWithHoles: [\"body.0.body.body.0.argument.left.left.left.callee\"],\n iterableToArrayLimit: [\n \"body.0.body.body.0.argument.left.left.right.callee\",\n ],\n unsupportedIterableToArray: [\n \"body.0.body.body.0.argument.left.right.callee\",\n ],\n nonIterableRest: [\"body.0.body.body.0.argument.right.callee\"],\n },\n internal: false,\n },\n ),\n // size: 104, gzip size: 113\n superPropBase: helper(\n \"7.0.0-beta.0\",\n \"function _superPropBase(t,o){for(;!{}.hasOwnProperty.call(t,o)&&null!==(t=getPrototypeOf(t)););return t}\",\n {\n globals: [],\n locals: { _superPropBase: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_superPropBase\",\n dependencies: {\n getPrototypeOf: [\"body.0.body.body.0.test.right.right.right.callee\"],\n },\n internal: false,\n },\n ),\n // size: 149, gzip size: 134\n superPropGet: helper(\n \"7.25.0\",\n 'function _superPropGet(t,o,e,r){var p=get(getPrototypeOf(1&r?t.prototype:t),o,e);return 2&r&&\"function\"==typeof p?function(t){return p.apply(e,t)}:p}',\n {\n globals: [],\n locals: { _superPropGet: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_superPropGet\",\n dependencies: {\n get: [\"body.0.body.body.0.declarations.0.init.callee\"],\n getPrototypeOf: [\n \"body.0.body.body.0.declarations.0.init.arguments.0.callee\",\n ],\n },\n internal: false,\n },\n ),\n // size: 88, gzip size: 95\n superPropSet: helper(\n \"7.25.0\",\n \"function _superPropSet(t,e,o,r,p,f){return set(getPrototypeOf(f?t.prototype:t),e,o,r,p)}\",\n {\n globals: [],\n locals: { _superPropSet: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_superPropSet\",\n dependencies: {\n set: [\"body.0.body.body.0.argument.callee\"],\n getPrototypeOf: [\"body.0.body.body.0.argument.arguments.0.callee\"],\n },\n internal: false,\n },\n ),\n // size: 135, gzip size: 128\n taggedTemplateLiteral: helper(\n \"7.0.0-beta.0\",\n \"function _taggedTemplateLiteral(e,t){return t||(t=e.slice(0)),Object.freeze(Object.defineProperties(e,{raw:{value:Object.freeze(t)}}))}\",\n {\n globals: [\"Object\"],\n locals: { _taggedTemplateLiteral: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_taggedTemplateLiteral\",\n dependencies: {},\n internal: false,\n },\n ),\n // size: 77, gzip size: 94\n taggedTemplateLiteralLoose: helper(\n \"7.0.0-beta.0\",\n \"function _taggedTemplateLiteralLoose(e,t){return t||(t=e.slice(0)),e.raw=t,e}\",\n {\n globals: [],\n locals: { _taggedTemplateLiteralLoose: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_taggedTemplateLiteralLoose\",\n dependencies: {},\n internal: false,\n },\n ),\n // size: 89, gzip size: 97\n tdz: helper(\n \"7.5.5\",\n 'function _tdzError(e){throw new ReferenceError(e+\" is not defined - temporal dead zone\")}',\n {\n globals: [\"ReferenceError\"],\n locals: { _tdzError: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_tdzError\",\n dependencies: {},\n internal: false,\n },\n ),\n // size: 53, gzip size: 73\n temporalRef: helper(\n \"7.0.0-beta.0\",\n \"function _temporalRef(r,e){return r===undef?err(e):r}\",\n {\n globals: [],\n locals: { _temporalRef: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_temporalRef\",\n dependencies: {\n temporalUndefined: [\"body.0.body.body.0.argument.test.right\"],\n tdz: [\"body.0.body.body.0.argument.consequent.callee\"],\n },\n internal: false,\n },\n ),\n // size: 31, gzip size: 51\n temporalUndefined: helper(\"7.0.0-beta.0\", \"function _temporalUndefined(){}\", {\n globals: [],\n locals: { _temporalUndefined: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_temporalUndefined\",\n dependencies: {},\n internal: false,\n }),\n // size: 116, gzip size: 102\n toArray: helper(\n \"7.0.0-beta.0\",\n \"function _toArray(r){return arrayWithHoles(r)||iterableToArray(r)||unsupportedIterableToArray(r)||nonIterableRest()}\",\n {\n globals: [],\n locals: { _toArray: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_toArray\",\n dependencies: {\n arrayWithHoles: [\"body.0.body.body.0.argument.left.left.left.callee\"],\n iterableToArray: [\"body.0.body.body.0.argument.left.left.right.callee\"],\n unsupportedIterableToArray: [\n \"body.0.body.body.0.argument.left.right.callee\",\n ],\n nonIterableRest: [\"body.0.body.body.0.argument.right.callee\"],\n },\n internal: false,\n },\n ),\n // size: 131, gzip size: 114\n toConsumableArray: helper(\n \"7.0.0-beta.0\",\n \"function _toConsumableArray(r){return arrayWithoutHoles(r)||iterableToArray(r)||unsupportedIterableToArray(r)||nonIterableSpread()}\",\n {\n globals: [],\n locals: { _toConsumableArray: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_toConsumableArray\",\n dependencies: {\n arrayWithoutHoles: [\n \"body.0.body.body.0.argument.left.left.left.callee\",\n ],\n iterableToArray: [\"body.0.body.body.0.argument.left.left.right.callee\"],\n unsupportedIterableToArray: [\n \"body.0.body.body.0.argument.left.right.callee\",\n ],\n nonIterableSpread: [\"body.0.body.body.0.argument.right.callee\"],\n },\n internal: false,\n },\n ),\n // size: 270, gzip size: 201\n toPrimitive: helper(\n \"7.1.5\",\n 'function toPrimitive(t,r){if(\"object\"!=typeof t||!t)return t;var e=t[Symbol.toPrimitive];if(void 0!==e){var i=e.call(t,r||\"default\");if(\"object\"!=typeof i)return i;throw new TypeError(\"@@toPrimitive must return a primitive value.\")}return(\"string\"===r?String:Number)(t)}',\n {\n globals: [\"Symbol\", \"TypeError\", \"String\", \"Number\"],\n locals: { toPrimitive: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"toPrimitive\",\n dependencies: {},\n internal: false,\n },\n ),\n // size: 88, gzip size: 102\n toPropertyKey: helper(\n \"7.1.5\",\n 'function toPropertyKey(t){var i=toPrimitive(t,\"string\");return\"symbol\"==typeof i?i:i+\"\"}',\n {\n globals: [],\n locals: { toPropertyKey: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"toPropertyKey\",\n dependencies: {\n toPrimitive: [\"body.0.body.body.0.declarations.0.init.callee\"],\n },\n internal: false,\n },\n ),\n // size: 129, gzip size: 133\n toSetter: helper(\n \"7.24.0\",\n 'function _toSetter(t,e,n){e||(e=[]);var r=e.length++;return Object.defineProperty({},\"_\",{set:function(o){e[r]=o,t.apply(n,e)}})}',\n {\n globals: [\"Object\"],\n locals: { _toSetter: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_toSetter\",\n dependencies: {},\n internal: false,\n },\n ),\n // size: 243, gzip size: 210\n tsRewriteRelativeImportExtensions: helper(\n \"7.27.0\",\n 'function tsRewriteRelativeImportExtensions(t,e){return\"string\"==typeof t&&/^\\\\.\\\\.?\\\\//.test(t)?t.replace(/\\\\.(tsx)$|((?:\\\\.d)?)((?:\\\\.[^./]+)?)\\\\.([cm]?)ts$/i,(function(t,s,r,n,o){return s?e?\".jsx\":\".js\":!r||n&&o?r+n+\".\"+o.toLowerCase()+\"js\":t})):t}',\n {\n globals: [],\n locals: { tsRewriteRelativeImportExtensions: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"tsRewriteRelativeImportExtensions\",\n dependencies: {},\n internal: false,\n },\n ),\n // size: 274, gzip size: 157\n typeof: helper(\n \"7.0.0-beta.0\",\n 'function _typeof(o){\"@babel/helpers - typeof\";return _typeof=\"function\"==typeof Symbol&&\"symbol\"==typeof Symbol.iterator?function(o){return typeof o}:function(o){return o&&\"function\"==typeof Symbol&&o.constructor===Symbol&&o!==Symbol.prototype?\"symbol\":typeof o},_typeof(o)}',\n {\n globals: [\"Symbol\"],\n locals: {\n _typeof: [\n \"body.0.id\",\n \"body.0.body.body.0.argument.expressions.1.callee\",\n \"body.0.body.body.0.argument.expressions.0.left\",\n ],\n },\n exportBindingAssignments: [\"body.0.body.body.0.argument.expressions.0\"],\n exportName: \"_typeof\",\n dependencies: {},\n internal: false,\n },\n ),\n // size: 328, gzip size: 247\n unsupportedIterableToArray: helper(\n \"7.9.0\",\n 'function _unsupportedIterableToArray(r,a){if(r){if(\"string\"==typeof r)return arrayLikeToArray(r,a);var t={}.toString.call(r).slice(8,-1);return\"Object\"===t&&r.constructor&&(t=r.constructor.name),\"Map\"===t||\"Set\"===t?Array.from(r):\"Arguments\"===t||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)?arrayLikeToArray(r,a):void 0}}',\n {\n globals: [\"Array\"],\n locals: { _unsupportedIterableToArray: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_unsupportedIterableToArray\",\n dependencies: {\n arrayLikeToArray: [\n \"body.0.body.body.0.consequent.body.0.consequent.argument.callee\",\n \"body.0.body.body.0.consequent.body.2.argument.expressions.1.alternate.consequent.callee\",\n ],\n },\n internal: false,\n },\n ),\n // size: 1117, gzip size: 548\n usingCtx: helper(\n \"7.23.9\",\n 'function _usingCtx(){var r=\"function\"==typeof SuppressedError?SuppressedError:function(r,e){var n=Error();return n.name=\"SuppressedError\",n.error=r,n.suppressed=e,n},e={},n=[];function using(r,e){if(null!=e){if(Object(e)!==e)throw new TypeError(\"using declarations can only be used with objects, functions, null, or undefined.\");if(r)var o=e[Symbol.asyncDispose||Symbol.for(\"Symbol.asyncDispose\")];if(void 0===o&&(o=e[Symbol.dispose||Symbol.for(\"Symbol.dispose\")],r))var t=o;if(\"function\"!=typeof o)throw new TypeError(\"Object is not disposable.\");t&&(o=function(){try{t.call(e)}catch(r){return Promise.reject(r)}}),n.push({v:e,d:o,a:r})}else r&&n.push({d:e,a:r});return e}return{e:e,u:using.bind(null,!1),a:using.bind(null,!0),d:function(){var o,t=this.e,s=0;function next(){for(;o=n.pop();)try{if(!o.a&&1===s)return s=0,n.push(o),Promise.resolve().then(next);if(o.d){var r=o.d.call(o.v);if(o.a)return s|=2,Promise.resolve(r).then(next,err)}else s|=1}catch(r){return err(r)}if(1===s)return t!==e?Promise.reject(t):Promise.resolve();if(t!==e)throw t}function err(n){return t=t!==e?new r(n,t):n,next()}return next()}}}',\n {\n globals: [\n \"SuppressedError\",\n \"Error\",\n \"Object\",\n \"TypeError\",\n \"Symbol\",\n \"Promise\",\n ],\n locals: { _usingCtx: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_usingCtx\",\n dependencies: {},\n internal: false,\n },\n ),\n // size: 1172, gzip size: 526\n wrapAsyncGenerator: helper(\n \"7.0.0-beta.0\",\n 'function _wrapAsyncGenerator(e){return function(){return new AsyncGenerator(e.apply(this,arguments))}}function AsyncGenerator(e){var r,t;function resume(r,t){try{var n=e[r](t),o=n.value,u=o instanceof OverloadYield;Promise.resolve(u?o.v:o).then((function(t){if(u){var i=\"return\"===r?\"return\":\"next\";if(!o.k||t.done)return resume(i,t);t=e[i](t).value}settle(n.done?\"return\":\"normal\",t)}),(function(e){resume(\"throw\",e)}))}catch(e){settle(\"throw\",e)}}function settle(e,n){switch(e){case\"return\":r.resolve({value:n,done:!0});break;case\"throw\":r.reject(n);break;default:r.resolve({value:n,done:!1})}(r=r.next)?resume(r.key,r.arg):t=null}this._invoke=function(e,n){return new Promise((function(o,u){var i={key:e,arg:n,resolve:o,reject:u,next:null};t?t=t.next=i:(r=t=i,resume(e,n))}))},\"function\"!=typeof e.return&&(this.return=void 0)}AsyncGenerator.prototype[\"function\"==typeof Symbol&&Symbol.asyncIterator||\"@@asyncIterator\"]=function(){return this},AsyncGenerator.prototype.next=function(e){return this._invoke(\"next\",e)},AsyncGenerator.prototype.throw=function(e){return this._invoke(\"throw\",e)},AsyncGenerator.prototype.return=function(e){return this._invoke(\"return\",e)};',\n {\n globals: [\"Promise\", \"Symbol\"],\n locals: {\n _wrapAsyncGenerator: [\"body.0.id\"],\n AsyncGenerator: [\n \"body.1.id\",\n \"body.0.body.body.0.argument.body.body.0.argument.callee\",\n \"body.2.expression.expressions.0.left.object.object\",\n \"body.2.expression.expressions.1.left.object.object\",\n \"body.2.expression.expressions.2.left.object.object\",\n \"body.2.expression.expressions.3.left.object.object\",\n ],\n },\n exportBindingAssignments: [],\n exportName: \"_wrapAsyncGenerator\",\n dependencies: {\n OverloadYield: [\n \"body.1.body.body.1.body.body.0.block.body.0.declarations.2.init.right\",\n ],\n },\n internal: false,\n },\n ),\n // size: 563, gzip size: 318\n wrapNativeSuper: helper(\n \"7.0.0-beta.0\",\n 'function _wrapNativeSuper(t){var r=\"function\"==typeof Map?new Map:void 0;return _wrapNativeSuper=function(t){if(null===t||!isNativeFunction(t))return t;if(\"function\"!=typeof t)throw new TypeError(\"Super expression must either be null or a function\");if(void 0!==r){if(r.has(t))return r.get(t);r.set(t,Wrapper)}function Wrapper(){return construct(t,arguments,getPrototypeOf(this).constructor)}return Wrapper.prototype=Object.create(t.prototype,{constructor:{value:Wrapper,enumerable:!1,writable:!0,configurable:!0}}),setPrototypeOf(Wrapper,t)},_wrapNativeSuper(t)}',\n {\n globals: [\"Map\", \"TypeError\", \"Object\"],\n locals: {\n _wrapNativeSuper: [\n \"body.0.id\",\n \"body.0.body.body.1.argument.expressions.1.callee\",\n \"body.0.body.body.1.argument.expressions.0.left\",\n ],\n },\n exportBindingAssignments: [\"body.0.body.body.1.argument.expressions.0\"],\n exportName: \"_wrapNativeSuper\",\n dependencies: {\n getPrototypeOf: [\n \"body.0.body.body.1.argument.expressions.0.right.body.body.3.body.body.0.argument.arguments.2.object.callee\",\n ],\n setPrototypeOf: [\n \"body.0.body.body.1.argument.expressions.0.right.body.body.4.argument.expressions.1.callee\",\n ],\n isNativeFunction: [\n \"body.0.body.body.1.argument.expressions.0.right.body.body.0.test.right.argument.callee\",\n ],\n construct: [\n \"body.0.body.body.1.argument.expressions.0.right.body.body.3.body.body.0.argument.callee\",\n ],\n },\n internal: false,\n },\n ),\n // size: 1213, gzip size: 560\n wrapRegExp: helper(\n \"7.19.0\",\n 'function _wrapRegExp(){_wrapRegExp=function(e,r){return new BabelRegExp(e,void 0,r)};var e=RegExp.prototype,r=new WeakMap;function BabelRegExp(e,t,p){var o=RegExp(e,t);return r.set(o,p||r.get(e)),setPrototypeOf(o,BabelRegExp.prototype)}function buildGroups(e,t){var p=r.get(t);return Object.keys(p).reduce((function(r,t){var o=p[t];if(\"number\"==typeof o)r[t]=e[o];else{for(var i=0;void 0===e[o[i]]&&i+1]+)(>|$)/g,(function(e,r,t){if(\"\"===t)return e;var p=o[r];return Array.isArray(p)?\"$\"+p.join(\"$\"):\"number\"==typeof p?\"$\"+p:\"\"})))}if(\"function\"==typeof p){var i=this;return e[Symbol.replace].call(this,t,(function(){var e=arguments;return\"object\"!=typeof e[e.length-1]&&(e=[].slice.call(e)).push(buildGroups(e,i)),p.apply(this,e)}))}return e[Symbol.replace].call(this,t,p)},_wrapRegExp.apply(this,arguments)}',\n {\n globals: [\"RegExp\", \"WeakMap\", \"Object\", \"Symbol\", \"Array\"],\n locals: {\n _wrapRegExp: [\n \"body.0.id\",\n \"body.0.body.body.4.argument.expressions.3.callee.object\",\n \"body.0.body.body.0.expression.left\",\n ],\n },\n exportBindingAssignments: [\"body.0.body.body.0.expression\"],\n exportName: \"_wrapRegExp\",\n dependencies: {\n setPrototypeOf: [\n \"body.0.body.body.2.body.body.1.argument.expressions.1.callee\",\n ],\n inherits: [\"body.0.body.body.4.argument.expressions.0.callee\"],\n },\n internal: false,\n },\n ),\n // size: 73, gzip size: 86\n writeOnlyError: helper(\n \"7.12.13\",\n \"function _writeOnlyError(r){throw new TypeError('\\\"'+r+'\\\" is write-only')}\",\n {\n globals: [\"TypeError\"],\n locals: { _writeOnlyError: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_writeOnlyError\",\n dependencies: {},\n internal: false,\n },\n ),\n};\n\nif (!process.env.BABEL_8_BREAKING) {\n Object.assign(helpers, {\n // size: 39, gzip size: 59\n AwaitValue: helper(\n \"7.0.0-beta.0\",\n \"function _AwaitValue(t){this.wrapped=t}\",\n {\n globals: [],\n locals: { _AwaitValue: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_AwaitValue\",\n dependencies: {},\n internal: false,\n },\n ),\n // size: 5767, gzip size: 2181\n applyDecs: helper(\n \"7.17.8\",\n 'function old_createMetadataMethodsForProperty(e,t,a,r){return{getMetadata:function(o){old_assertNotFinished(r,\"getMetadata\"),old_assertMetadataKey(o);var i=e[o];if(void 0!==i)if(1===t){var n=i.public;if(void 0!==n)return n[a]}else if(2===t){var l=i.private;if(void 0!==l)return l.get(a)}else if(Object.hasOwnProperty.call(i,\"constructor\"))return i.constructor},setMetadata:function(o,i){old_assertNotFinished(r,\"setMetadata\"),old_assertMetadataKey(o);var n=e[o];if(void 0===n&&(n=e[o]={}),1===t){var l=n.public;void 0===l&&(l=n.public={}),l[a]=i}else if(2===t){var s=n.priv;void 0===s&&(s=n.private=new Map),s.set(a,i)}else n.constructor=i}}}function old_convertMetadataMapToFinal(e,t){var a=e[Symbol.metadata||Symbol.for(\"Symbol.metadata\")],r=Object.getOwnPropertySymbols(t);if(0!==r.length){for(var o=0;o=0;m--){var b;void 0!==(p=old_memberDec(h[m],r,c,l,s,o,i,n,f))&&(old_assertValidReturnValue(o,p),0===o?b=p:1===o?(b=old_getInit(p),v=p.get||f.get,y=p.set||f.set,f={get:v,set:y}):f=p,void 0!==b&&(void 0===d?d=b:\"function\"==typeof d?d=[d,b]:d.push(b)))}if(0===o||1===o){if(void 0===d)d=function(e,t){return t};else if(\"function\"!=typeof d){var g=d;d=function(e,t){for(var a=t,r=0;r3,m=v>=5;if(m?(u=t,f=r,0!=(v-=5)&&(p=n=n||[])):(u=t.prototype,f=a,0!==v&&(p=i=i||[])),0!==v&&!h){var b=m?s:l,g=b.get(y)||0;if(!0===g||3===g&&4!==v||4===g&&3!==v)throw Error(\"Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: \"+y);!g&&v>2?b.set(y,v):b.set(y,!0)}old_applyMemberDec(e,u,d,y,v,m,h,f,p)}}old_pushInitializers(e,i),old_pushInitializers(e,n)}function old_pushInitializers(e,t){t&&e.push((function(e){for(var a=0;a0){for(var o=[],i=t,n=t.name,l=r.length-1;l>=0;l--){var s={v:!1};try{var c=Object.assign({kind:\"class\",name:n,addInitializer:old_createAddInitializerMethod(o,s)},old_createMetadataMethodsForProperty(a,0,n,s)),d=r[l](i,c)}finally{s.v=!0}void 0!==d&&(old_assertValidReturnValue(10,d),i=d)}e.push(i,(function(){for(var e=0;e=0;v--){var g;void 0!==(f=memberDec(h[v],a,c,o,n,i,s,u))&&(assertValidReturnValue(n,f),0===n?g=f:1===n?(g=f.init,p=f.get||u.get,d=f.set||u.set,u={get:p,set:d}):u=f,void 0!==g&&(void 0===l?l=g:\"function\"==typeof l?l=[l,g]:l.push(g)))}if(0===n||1===n){if(void 0===l)l=function(e,t){return t};else if(\"function\"!=typeof l){var y=l;l=function(e,t){for(var r=t,a=0;a3,h=f>=5;if(h?(l=t,0!=(f-=5)&&(u=n=n||[])):(l=t.prototype,0!==f&&(u=a=a||[])),0!==f&&!d){var v=h?s:i,g=v.get(p)||0;if(!0===g||3===g&&4!==f||4===g&&3!==f)throw Error(\"Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: \"+p);!g&&f>2?v.set(p,f):v.set(p,!0)}applyMemberDec(e,l,c,p,f,h,d,u)}}pushInitializers(e,a),pushInitializers(e,n)}(a,e,t),function(e,t,r){if(r.length>0){for(var a=[],n=t,i=t.name,s=r.length-1;s>=0;s--){var o={v:!1};try{var c=r[s](n,{kind:\"class\",name:i,addInitializer:createAddInitializerMethod(a,o)})}finally{o.v=!0}void 0!==c&&(assertValidReturnValue(10,c),n=c)}e.push(n,(function(){for(var e=0;e=0;g--){var y;void 0!==(p=memberDec(v[g],n,c,s,a,i,o,f))&&(assertValidReturnValue(a,p),0===a?y=p:1===a?(y=p.init,d=p.get||f.get,h=p.set||f.set,f={get:d,set:h}):f=p,void 0!==y&&(void 0===l?l=y:\"function\"==typeof l?l=[l,y]:l.push(y)))}if(0===a||1===a){if(void 0===l)l=function(e,t){return t};else if(\"function\"!=typeof l){var m=l;l=function(e,t){for(var r=t,n=0;n3,h=f>=5;if(h?(l=e,0!=(f-=5)&&(u=n=n||[])):(l=e.prototype,0!==f&&(u=r=r||[])),0!==f&&!d){var v=h?o:i,g=v.get(p)||0;if(!0===g||3===g&&4!==f||4===g&&3!==f)throw Error(\"Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: \"+p);!g&&f>2?v.set(p,f):v.set(p,!0)}applyMemberDec(a,l,c,p,f,h,d,u)}}return pushInitializers(a,r),pushInitializers(a,n),a}function pushInitializers(e,t){t&&e.push((function(e){for(var r=0;r0){for(var r=[],n=e,a=e.name,i=t.length-1;i>=0;i--){var o={v:!1};try{var s=t[i](n,{kind:\"class\",name:a,addInitializer:createAddInitializerMethod(r,o)})}finally{o.v=!0}void 0!==s&&(assertValidReturnValue(10,s),n=s)}return[n,function(){for(var e=0;e=0;m--){var b;void 0!==(h=memberDec(g[m],n,u,o,a,i,s,p,c))&&(assertValidReturnValue(a,h),0===a?b=h:1===a?(b=h.init,v=h.get||p.get,y=h.set||p.set,p={get:v,set:y}):p=h,void 0!==b&&(void 0===l?l=b:\"function\"==typeof l?l=[l,b]:l.push(b)))}if(0===a||1===a){if(void 0===l)l=function(e,t){return t};else if(\"function\"!=typeof l){var I=l;l=function(e,t){for(var r=t,n=0;n3,y=d>=5,g=r;if(y?(f=e,0!=(d-=5)&&(p=a=a||[]),v&&!i&&(i=function(t){return checkInRHS(t)===e}),g=i):(f=e.prototype,0!==d&&(p=n=n||[])),0!==d&&!v){var m=y?c:o,b=m.get(h)||0;if(!0===b||3===b&&4!==d||4===b&&3!==d)throw Error(\"Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: \"+h);!b&&d>2?m.set(h,d):m.set(h,!0)}applyMemberDec(s,f,l,h,d,y,v,p,g)}}return pushInitializers(s,n),pushInitializers(s,a),s}function pushInitializers(e,t){t&&e.push((function(e){for(var r=0;r0){for(var r=[],n=e,a=e.name,i=t.length-1;i>=0;i--){var s={v:!1};try{var o=t[i](n,{kind:\"class\",name:a,addInitializer:createAddInitializerMethod(r,s)})}finally{s.v=!0}void 0!==o&&(assertValidReturnValue(10,o),n=o)}return[n,function(){for(var e=0;e=0;j-=r?2:1){var D=v[j],E=r?v[j-1]:void 0,I={},O={kind:[\"field\",\"accessor\",\"method\",\"getter\",\"setter\",\"class\"][o],name:n,metadata:a,addInitializer:function(e,t){if(e.v)throw Error(\"attempted to call addInitializer after decoration was finished\");s(t,\"An initializer\",\"be\",!0),c.push(t)}.bind(null,I)};try{if(b)(y=s(D.call(E,P,O),\"class decorators\",\"return\"))&&(P=y);else{var k,F;O.static=l,O.private=f,f?2===o?k=function(e){return m(e),w.value}:(o<4&&(k=i(w,\"get\",m)),3!==o&&(F=i(w,\"set\",m))):(k=function(e){return e[n]},(o<2||4===o)&&(F=function(e,t){e[n]=t}));var N=O.access={has:f?h.bind():function(e){return n in e}};if(k&&(N.get=k),F&&(N.set=F),P=D.call(E,d?{get:w.get,set:w.set}:w[A],O),d){if(\"object\"==typeof P&&P)(y=s(P.get,\"accessor.get\"))&&(w.get=y),(y=s(P.set,\"accessor.set\"))&&(w.set=y),(y=s(P.init,\"accessor.init\"))&&S.push(y);else if(void 0!==P)throw new TypeError(\"accessor decorators must return an object with get, set, or init properties or void 0\")}else s(P,(p?\"field\":\"method\")+\" decorators\",\"return\")&&(p?S.push(P):w[A]=P)}}finally{I.v=!0}}return(p||d)&&u.push((function(e,t){for(var r=S.length-1;r>=0;r--)t=S[r].call(e,t);return t})),p||b||(f?d?u.push(i(w,\"get\"),i(w,\"set\")):u.push(2===o?w[A]:i.call.bind(w[A])):Object.defineProperty(e,n,w)),P}function u(e,t){return Object.defineProperty(e,Symbol.metadata||Symbol.for(\"Symbol.metadata\"),{configurable:!0,enumerable:!0,value:t})}if(arguments.length>=6)var l=a[Symbol.metadata||Symbol.for(\"Symbol.metadata\")];var f=Object.create(null==l?null:l),p=function(e,t,r,n){var o,a,i=[],s=function(t){return checkInRHS(t)===e},u=new Map;function l(e){e&&i.push(c.bind(null,e))}for(var f=0;f3,y=16&d,v=!!(8&d),g=0==(d&=7),b=h+\"/\"+v;if(!g&&!m){var w=u.get(b);if(!0===w||3===w&&4!==d||4===w&&3!==d)throw Error(\"Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: \"+h);u.set(b,!(d>2)||d)}applyDec(v?e:e.prototype,p,y,m?\"#\"+h:toPropertyKey(h),d,n,v?a=a||[]:o=o||[],i,v,m,g,1===d,v&&m?s:r)}}return l(o),l(a),i}(e,t,o,f);return r.length||u(e,f),{e:p,get c(){var t=[];return r.length&&[u(applyDec(e,[r],n,e.name,5,f,t),f),c.bind(null,t,e)]}}}',\n {\n globals: [\"TypeError\", \"Array\", \"Object\", \"Error\", \"Symbol\", \"Map\"],\n locals: { applyDecs2305: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"applyDecs2305\",\n dependencies: {\n checkInRHS: [\n \"body.0.body.body.6.declarations.1.init.callee.body.body.0.declarations.3.init.body.body.0.argument.left.callee\",\n ],\n setFunctionName: [\n \"body.0.body.body.3.body.body.2.consequent.body.2.expression.consequent.expressions.0.consequent.right.properties.0.value.callee\",\n \"body.0.body.body.3.body.body.2.consequent.body.2.expression.consequent.expressions.1.right.callee\",\n ],\n toPropertyKey: [\n \"body.0.body.body.6.declarations.1.init.callee.body.body.2.body.body.1.consequent.body.2.expression.arguments.3.alternate.callee\",\n ],\n },\n internal: false,\n },\n ),\n // size: 231, gzip size: 189\n classApplyDescriptorDestructureSet: helper(\n \"7.13.10\",\n 'function _classApplyDescriptorDestructureSet(e,t){if(t.set)return\"__destrObj\"in t||(t.__destrObj={set value(r){t.set.call(e,r)}}),t.__destrObj;if(!t.writable)throw new TypeError(\"attempted to set read only private field\");return t}',\n {\n globals: [\"TypeError\"],\n locals: { _classApplyDescriptorDestructureSet: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_classApplyDescriptorDestructureSet\",\n dependencies: {},\n internal: false,\n },\n ),\n // size: 74, gzip size: 90\n classApplyDescriptorGet: helper(\n \"7.13.10\",\n \"function _classApplyDescriptorGet(e,t){return t.get?t.get.call(e):t.value}\",\n {\n globals: [],\n locals: { _classApplyDescriptorGet: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_classApplyDescriptorGet\",\n dependencies: {},\n internal: false,\n },\n ),\n // size: 161, gzip size: 149\n classApplyDescriptorSet: helper(\n \"7.13.10\",\n 'function _classApplyDescriptorSet(e,t,l){if(t.set)t.set.call(e,l);else{if(!t.writable)throw new TypeError(\"attempted to set read only private field\");t.value=l}}',\n {\n globals: [\"TypeError\"],\n locals: { _classApplyDescriptorSet: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_classApplyDescriptorSet\",\n dependencies: {},\n internal: false,\n },\n ),\n // size: 78, gzip size: 93\n classCheckPrivateStaticAccess: helper(\n \"7.13.10\",\n \"function _classCheckPrivateStaticAccess(s,a,r){return assertClassBrand(a,s,r)}\",\n {\n globals: [],\n locals: { _classCheckPrivateStaticAccess: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_classCheckPrivateStaticAccess\",\n dependencies: {\n assertClassBrand: [\"body.0.body.body.0.argument.callee\"],\n },\n internal: false,\n },\n ),\n // size: 154, gzip size: 145\n classCheckPrivateStaticFieldDescriptor: helper(\n \"7.13.10\",\n 'function _classCheckPrivateStaticFieldDescriptor(t,e){if(void 0===t)throw new TypeError(\"attempted to \"+e+\" private static field before its declaration\")}',\n {\n globals: [\"TypeError\"],\n locals: { _classCheckPrivateStaticFieldDescriptor: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_classCheckPrivateStaticFieldDescriptor\",\n dependencies: {},\n internal: false,\n },\n ),\n // size: 77, gzip size: 91\n classExtractFieldDescriptor: helper(\n \"7.13.10\",\n \"function _classExtractFieldDescriptor(e,t){return classPrivateFieldGet2(t,e)}\",\n {\n globals: [],\n locals: { _classExtractFieldDescriptor: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_classExtractFieldDescriptor\",\n dependencies: {\n classPrivateFieldGet2: [\"body.0.body.body.0.argument.callee\"],\n },\n internal: false,\n },\n ),\n // size: 127, gzip size: 111\n classPrivateFieldDestructureSet: helper(\n \"7.4.4\",\n \"function _classPrivateFieldDestructureSet(e,t){var r=classPrivateFieldGet2(t,e);return classApplyDescriptorDestructureSet(e,r)}\",\n {\n globals: [],\n locals: { _classPrivateFieldDestructureSet: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_classPrivateFieldDestructureSet\",\n dependencies: {\n classApplyDescriptorDestructureSet: [\n \"body.0.body.body.1.argument.callee\",\n ],\n classPrivateFieldGet2: [\n \"body.0.body.body.0.declarations.0.init.callee\",\n ],\n },\n internal: false,\n },\n ),\n // size: 105, gzip size: 100\n classPrivateFieldGet: helper(\n \"7.0.0-beta.0\",\n \"function _classPrivateFieldGet(e,t){var r=classPrivateFieldGet2(t,e);return classApplyDescriptorGet(e,r)}\",\n {\n globals: [],\n locals: { _classPrivateFieldGet: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_classPrivateFieldGet\",\n dependencies: {\n classApplyDescriptorGet: [\"body.0.body.body.1.argument.callee\"],\n classPrivateFieldGet2: [\n \"body.0.body.body.0.declarations.0.init.callee\",\n ],\n },\n internal: false,\n },\n ),\n // size: 111, gzip size: 109\n classPrivateFieldSet: helper(\n \"7.0.0-beta.0\",\n \"function _classPrivateFieldSet(e,t,r){var s=classPrivateFieldGet2(t,e);return classApplyDescriptorSet(e,s,r),r}\",\n {\n globals: [],\n locals: { _classPrivateFieldSet: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_classPrivateFieldSet\",\n dependencies: {\n classApplyDescriptorSet: [\n \"body.0.body.body.1.argument.expressions.0.callee\",\n ],\n classPrivateFieldGet2: [\n \"body.0.body.body.0.declarations.0.init.callee\",\n ],\n },\n internal: false,\n },\n ),\n // size: 70, gzip size: 88\n classPrivateMethodGet: helper(\n \"7.1.6\",\n \"function _classPrivateMethodGet(s,a,r){return assertClassBrand(a,s),r}\",\n {\n globals: [],\n locals: { _classPrivateMethodGet: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_classPrivateMethodGet\",\n dependencies: {\n assertClassBrand: [\n \"body.0.body.body.0.argument.expressions.0.callee\",\n ],\n },\n internal: false,\n },\n ),\n // size: 94, gzip size: 102\n classPrivateMethodSet: helper(\n \"7.1.6\",\n 'function _classPrivateMethodSet(){throw new TypeError(\"attempted to reassign private method\")}',\n {\n globals: [\"TypeError\"],\n locals: { _classPrivateMethodSet: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_classPrivateMethodSet\",\n dependencies: {},\n internal: false,\n },\n ),\n // size: 172, gzip size: 135\n classStaticPrivateFieldDestructureSet: helper(\n \"7.13.10\",\n 'function _classStaticPrivateFieldDestructureSet(t,r,s){return assertClassBrand(r,t),classCheckPrivateStaticFieldDescriptor(s,\"set\"),classApplyDescriptorDestructureSet(t,s)}',\n {\n globals: [],\n locals: { _classStaticPrivateFieldDestructureSet: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_classStaticPrivateFieldDestructureSet\",\n dependencies: {\n classApplyDescriptorDestructureSet: [\n \"body.0.body.body.0.argument.expressions.2.callee\",\n ],\n assertClassBrand: [\n \"body.0.body.body.0.argument.expressions.0.callee\",\n ],\n classCheckPrivateStaticFieldDescriptor: [\n \"body.0.body.body.0.argument.expressions.1.callee\",\n ],\n },\n internal: false,\n },\n ),\n // size: 154, gzip size: 133\n classStaticPrivateFieldSpecGet: helper(\n \"7.0.2\",\n 'function _classStaticPrivateFieldSpecGet(t,s,r){return assertClassBrand(s,t),classCheckPrivateStaticFieldDescriptor(r,\"get\"),classApplyDescriptorGet(t,r)}',\n {\n globals: [],\n locals: { _classStaticPrivateFieldSpecGet: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_classStaticPrivateFieldSpecGet\",\n dependencies: {\n classApplyDescriptorGet: [\n \"body.0.body.body.0.argument.expressions.2.callee\",\n ],\n assertClassBrand: [\n \"body.0.body.body.0.argument.expressions.0.callee\",\n ],\n classCheckPrivateStaticFieldDescriptor: [\n \"body.0.body.body.0.argument.expressions.1.callee\",\n ],\n },\n internal: false,\n },\n ),\n // size: 160, gzip size: 134\n classStaticPrivateFieldSpecSet: helper(\n \"7.0.2\",\n 'function _classStaticPrivateFieldSpecSet(s,t,r,e){return assertClassBrand(t,s),classCheckPrivateStaticFieldDescriptor(r,\"set\"),classApplyDescriptorSet(s,r,e),e}',\n {\n globals: [],\n locals: { _classStaticPrivateFieldSpecSet: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_classStaticPrivateFieldSpecSet\",\n dependencies: {\n classApplyDescriptorSet: [\n \"body.0.body.body.0.argument.expressions.2.callee\",\n ],\n assertClassBrand: [\n \"body.0.body.body.0.argument.expressions.0.callee\",\n ],\n classCheckPrivateStaticFieldDescriptor: [\n \"body.0.body.body.0.argument.expressions.1.callee\",\n ],\n },\n internal: false,\n },\n ),\n // size: 111, gzip size: 114\n classStaticPrivateMethodSet: helper(\n \"7.3.2\",\n 'function _classStaticPrivateMethodSet(){throw new TypeError(\"attempted to set read only static private field\")}',\n {\n globals: [\"TypeError\"],\n locals: { _classStaticPrivateMethodSet: [\"body.0.id\"] },\n exportBindingAssignments: [],\n exportName: \"_classStaticPrivateMethodSet\",\n dependencies: {},\n internal: false,\n },\n ),\n // size: 368, gzip size: 204\n defineEnumerableProperties: helper(\n \"7.0.0-beta.0\",\n 'function _defineEnumerableProperties(e,r){for(var t in r){var n=r[t];n.configurable=n.enumerable=!0,\"value\"in n&&(n.writable=!0),Object.defineProperty(e,t,n)}if(Object.getOwnPropertySymbols)for(var a=Object.getOwnPropertySymbols(r),b=0;b0;)try{var o=r.pop(),p=o.d.call(o.v);if(o.a)return Promise.resolve(p).then(next,err)}catch(r){return err(r)}if(s)throw e}function err(r){return e=s?new dispose_SuppressedError(e,r):r,s=!0,next()}return next()}',\n {\n globals: [\"SuppressedError\", \"Error\", \"Object\", \"Promise\"],\n locals: {\n dispose_SuppressedError: [\n \"body.0.id\",\n \"body.0.body.body.0.argument.expressions.0.alternate.expressions.1.left.object\",\n \"body.0.body.body.0.argument.expressions.0.alternate.expressions.1.right.arguments.1.properties.0.value.properties.0.value\",\n \"body.0.body.body.0.argument.expressions.1.callee\",\n \"body.1.body.body.1.body.body.0.argument.expressions.0.right.consequent.callee\",\n \"body.0.body.body.0.argument.expressions.0.consequent.left\",\n \"body.0.body.body.0.argument.expressions.0.alternate.expressions.0.left\",\n ],\n _dispose: [\"body.1.id\"],\n },\n exportBindingAssignments: [],\n exportName: \"_dispose\",\n dependencies: {},\n internal: false,\n },\n ),\n // size: 363, gzip size: 237\n objectSpread: helper(\n \"7.0.0-beta.0\",\n 'function _objectSpread(e){for(var r=1;r {\n constructor(value: T, /** 0: await 1: delegate */ kind: 0 | 1);\n\n v: T;\n k: Kind;\n}\n\n// The actual implementation of _OverloadYield starts here\nfunction _OverloadYield(this: _OverloadYield, value: T, kind: Kind) {\n this.v = value;\n this.k = kind;\n}\n\nexport { _OverloadYield as default };\n"],"mappings":";;;;;;AAkBA,SAASA,cAAcA,CAA6BC,KAAQ,EAAEC,IAAU,EAAE;EACxE,IAAI,CAACC,CAAC,GAAGF,KAAK;EACd,IAAI,CAACG,CAAC,GAAGF,IAAI;AACf","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecoratedDescriptor.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecoratedDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..f6d5dd7bf5374225642dbc0fc4c7e0656b55852f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecoratedDescriptor.js @@ -0,0 +1,31 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _applyDecoratedDescriptor; +function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { + var desc = {}; + Object.keys(descriptor).forEach(function (key) { + desc[key] = descriptor[key]; + }); + desc.enumerable = !!desc.enumerable; + desc.configurable = !!desc.configurable; + if ("value" in desc || desc.initializer) { + desc.writable = true; + } + desc = decorators.slice().reverse().reduce(function (desc, decorator) { + return decorator(target, property, desc) || desc; + }, desc); + if (context && desc.initializer !== void 0) { + desc.value = desc.initializer ? desc.initializer.call(context) : void 0; + desc.initializer = void 0; + } + if (desc.initializer === void 0) { + Object.defineProperty(target, property, desc); + return null; + } + return desc; +} + +//# sourceMappingURL=applyDecoratedDescriptor.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecoratedDescriptor.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecoratedDescriptor.js.map new file mode 100644 index 0000000000000000000000000000000000000000..75c428e56cbc6073ff319addaa71e17b409f4ac2 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecoratedDescriptor.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_applyDecoratedDescriptor","target","property","decorators","descriptor","context","desc","Object","keys","forEach","key","enumerable","configurable","initializer","writable","slice","reverse","reduce","decorator","value","call","defineProperty"],"sources":["../../src/helpers/applyDecoratedDescriptor.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\ninterface DescriptorWithInitializer extends PropertyDescriptor {\n initializer?: () => any;\n}\n\ndeclare const Object: Omit & {\n keys(o: T): Array;\n};\n\nexport default function _applyDecoratedDescriptor(\n target: T,\n property: PropertyKey,\n decorators: ((\n t: T,\n p: PropertyKey,\n desc: DescriptorWithInitializer,\n ) => any)[],\n descriptor: DescriptorWithInitializer,\n context: DecoratorContext,\n) {\n var desc: DescriptorWithInitializer = {};\n Object.keys(descriptor).forEach(function (key) {\n desc[key] = descriptor[key];\n });\n desc.enumerable = !!desc.enumerable;\n desc.configurable = !!desc.configurable;\n if (\"value\" in desc || desc.initializer) {\n desc.writable = true;\n }\n\n desc = decorators\n .slice()\n .reverse()\n .reduce(function (desc, decorator) {\n return decorator(target, property, desc) || desc;\n }, desc);\n\n if (context && desc.initializer !== void 0) {\n desc.value = desc.initializer ? desc.initializer.call(context) : void 0;\n desc.initializer = void 0;\n }\n\n if (desc.initializer === void 0) {\n Object.defineProperty(target, property, desc);\n return null;\n }\n\n return desc;\n}\n"],"mappings":";;;;;;AAUe,SAASA,yBAAyBA,CAC/CC,MAAS,EACTC,QAAqB,EACrBC,UAIW,EACXC,UAAqC,EACrCC,OAAyB,EACzB;EACA,IAAIC,IAA+B,GAAG,CAAC,CAAC;EACxCC,MAAM,CAACC,IAAI,CAACJ,UAAU,CAAC,CAACK,OAAO,CAAC,UAAUC,GAAG,EAAE;IAC7CJ,IAAI,CAACI,GAAG,CAAC,GAAGN,UAAU,CAACM,GAAG,CAAC;EAC7B,CAAC,CAAC;EACFJ,IAAI,CAACK,UAAU,GAAG,CAAC,CAACL,IAAI,CAACK,UAAU;EACnCL,IAAI,CAACM,YAAY,GAAG,CAAC,CAACN,IAAI,CAACM,YAAY;EACvC,IAAI,OAAO,IAAIN,IAAI,IAAIA,IAAI,CAACO,WAAW,EAAE;IACvCP,IAAI,CAACQ,QAAQ,GAAG,IAAI;EACtB;EAEAR,IAAI,GAAGH,UAAU,CACdY,KAAK,CAAC,CAAC,CACPC,OAAO,CAAC,CAAC,CACTC,MAAM,CAAC,UAAUX,IAAI,EAAEY,SAAS,EAAE;IACjC,OAAOA,SAAS,CAACjB,MAAM,EAAEC,QAAQ,EAAEI,IAAI,CAAC,IAAIA,IAAI;EAClD,CAAC,EAAEA,IAAI,CAAC;EAEV,IAAID,OAAO,IAAIC,IAAI,CAACO,WAAW,KAAK,KAAK,CAAC,EAAE;IAC1CP,IAAI,CAACa,KAAK,GAAGb,IAAI,CAACO,WAAW,GAAGP,IAAI,CAACO,WAAW,CAACO,IAAI,CAACf,OAAO,CAAC,GAAG,KAAK,CAAC;IACvEC,IAAI,CAACO,WAAW,GAAG,KAAK,CAAC;EAC3B;EAEA,IAAIP,IAAI,CAACO,WAAW,KAAK,KAAK,CAAC,EAAE;IAC/BN,MAAM,CAACc,cAAc,CAACpB,MAAM,EAAEC,QAAQ,EAAEI,IAAI,CAAC;IAC7C,OAAO,IAAI;EACb;EAEA,OAAOA,IAAI;AACb","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs.js new file mode 100644 index 0000000000000000000000000000000000000000..3bb23ecf1c63ba1dc8866e2fd6fe8f53c420496f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs.js @@ -0,0 +1,459 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = applyDecs; +var _setFunctionName = require("setFunctionName"); +var _toPropertyKey = require("toPropertyKey"); +function old_createMetadataMethodsForProperty(metadataMap, kind, property, decoratorFinishedRef) { + return { + getMetadata: function (key) { + old_assertNotFinished(decoratorFinishedRef, "getMetadata"); + old_assertMetadataKey(key); + var metadataForKey = metadataMap[key]; + if (metadataForKey === void 0) return void 0; + if (kind === 1) { + var pub = metadataForKey.public; + if (pub !== void 0) { + return pub[property]; + } + } else if (kind === 2) { + var priv = metadataForKey.private; + if (priv !== void 0) { + return priv.get(property); + } + } else if (Object.hasOwnProperty.call(metadataForKey, "constructor")) { + return metadataForKey.constructor; + } + }, + setMetadata: function (key, value) { + old_assertNotFinished(decoratorFinishedRef, "setMetadata"); + old_assertMetadataKey(key); + var metadataForKey = metadataMap[key]; + if (metadataForKey === void 0) { + metadataForKey = metadataMap[key] = {}; + } + if (kind === 1) { + var pub = metadataForKey.public; + if (pub === void 0) { + pub = metadataForKey.public = {}; + } + pub[property] = value; + } else if (kind === 2) { + var priv = metadataForKey.priv; + if (priv === void 0) { + priv = metadataForKey.private = new Map(); + } + priv.set(property, value); + } else { + metadataForKey.constructor = value; + } + } + }; +} +function old_convertMetadataMapToFinal(obj, metadataMap) { + var parentMetadataMap = obj[Symbol.metadata || Symbol.for("Symbol.metadata")]; + var metadataKeys = Object.getOwnPropertySymbols(metadataMap); + if (metadataKeys.length === 0) return; + for (var i = 0; i < metadataKeys.length; i++) { + var key = metadataKeys[i]; + var metaForKey = metadataMap[key]; + var parentMetaForKey = parentMetadataMap ? parentMetadataMap[key] : null; + var pub = metaForKey.public; + var parentPub = parentMetaForKey ? parentMetaForKey.public : null; + if (pub && parentPub) { + Object.setPrototypeOf(pub, parentPub); + } + var priv = metaForKey.private; + if (priv) { + var privArr = Array.from(priv.values()); + var parentPriv = parentMetaForKey ? parentMetaForKey.private : null; + if (parentPriv) { + privArr = privArr.concat(parentPriv); + } + metaForKey.private = privArr; + } + if (parentMetaForKey) { + Object.setPrototypeOf(metaForKey, parentMetaForKey); + } + } + if (parentMetadataMap) { + Object.setPrototypeOf(metadataMap, parentMetadataMap); + } + obj[Symbol.metadata || Symbol.for("Symbol.metadata")] = metadataMap; +} +function old_createAddInitializerMethod(initializers, decoratorFinishedRef) { + return function addInitializer(initializer) { + old_assertNotFinished(decoratorFinishedRef, "addInitializer"); + old_assertCallable(initializer, "An initializer"); + initializers.push(initializer); + }; +} +function old_memberDec(dec, name, desc, metadataMap, initializers, kind, isStatic, isPrivate, value) { + var kindStr; + switch (kind) { + case 1: + kindStr = "accessor"; + break; + case 2: + kindStr = "method"; + break; + case 3: + kindStr = "getter"; + break; + case 4: + kindStr = "setter"; + break; + default: + kindStr = "field"; + } + var ctx = { + kind: kindStr, + name: isPrivate ? "#" + name : _toPropertyKey(name), + isStatic: isStatic, + isPrivate: isPrivate + }; + var decoratorFinishedRef = { + v: false + }; + if (kind !== 0) { + ctx.addInitializer = old_createAddInitializerMethod(initializers, decoratorFinishedRef); + } + var metadataKind, metadataName; + if (isPrivate) { + metadataKind = 2; + metadataName = Symbol(name); + var access = {}; + if (kind === 0) { + access.get = desc.get; + access.set = desc.set; + } else if (kind === 2) { + access.get = function () { + return desc.value; + }; + } else { + if (kind === 1 || kind === 3) { + access.get = function () { + return desc.get.call(this); + }; + } + if (kind === 1 || kind === 4) { + access.set = function (v) { + desc.set.call(this, v); + }; + } + } + ctx.access = access; + } else { + metadataKind = 1; + metadataName = name; + } + try { + return dec(value, Object.assign(ctx, old_createMetadataMethodsForProperty(metadataMap, metadataKind, metadataName, decoratorFinishedRef))); + } finally { + decoratorFinishedRef.v = true; + } +} +function old_assertNotFinished(decoratorFinishedRef, fnName) { + if (decoratorFinishedRef.v) { + throw new Error("attempted to call " + fnName + " after decoration was finished"); + } +} +function old_assertMetadataKey(key) { + if (typeof key !== "symbol") { + throw new TypeError("Metadata keys must be symbols, received: " + key); + } +} +function old_assertCallable(fn, hint) { + if (typeof fn !== "function") { + throw new TypeError(hint + " must be a function"); + } +} +function old_assertValidReturnValue(kind, value) { + var type = typeof value; + if (kind === 1) { + if (type !== "object" || value === null) { + throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); + } + if (value.get !== undefined) { + old_assertCallable(value.get, "accessor.get"); + } + if (value.set !== undefined) { + old_assertCallable(value.set, "accessor.set"); + } + if (value.init !== undefined) { + old_assertCallable(value.init, "accessor.init"); + } + if (value.initializer !== undefined) { + old_assertCallable(value.initializer, "accessor.initializer"); + } + } else if (type !== "function") { + var hint; + if (kind === 0) { + hint = "field"; + } else if (kind === 10) { + hint = "class"; + } else { + hint = "method"; + } + throw new TypeError(hint + " decorators must return a function or void 0"); + } +} +function old_getInit(desc) { + var initializer; + if ((initializer = desc.init) == null && (initializer = desc.initializer) && typeof console !== "undefined") { + console.warn(".initializer has been renamed to .init as of March 2022"); + } + return initializer; +} +function old_applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, metadataMap, initializers) { + var decs = decInfo[0]; + var desc, initializer, prefix, value; + if (isPrivate) { + if (kind === 0 || kind === 1) { + desc = { + get: decInfo[3], + set: decInfo[4] + }; + prefix = "get"; + } else if (kind === 3) { + desc = { + get: decInfo[3] + }; + prefix = "get"; + } else if (kind === 4) { + desc = { + set: decInfo[3] + }; + prefix = "set"; + } else { + desc = { + value: decInfo[3] + }; + } + if (kind !== 0) { + if (kind === 1) { + _setFunctionName(decInfo[4], "#" + name, "set"); + } + _setFunctionName(decInfo[3], "#" + name, prefix); + } + } else if (kind !== 0) { + desc = Object.getOwnPropertyDescriptor(base, name); + } + if (kind === 1) { + value = { + get: desc.get, + set: desc.set + }; + } else if (kind === 2) { + value = desc.value; + } else if (kind === 3) { + value = desc.get; + } else if (kind === 4) { + value = desc.set; + } + var newValue, get, set; + if (typeof decs === "function") { + newValue = old_memberDec(decs, name, desc, metadataMap, initializers, kind, isStatic, isPrivate, value); + if (newValue !== void 0) { + old_assertValidReturnValue(kind, newValue); + if (kind === 0) { + initializer = newValue; + } else if (kind === 1) { + initializer = old_getInit(newValue); + get = newValue.get || value.get; + set = newValue.set || value.set; + value = { + get: get, + set: set + }; + } else { + value = newValue; + } + } + } else { + for (var i = decs.length - 1; i >= 0; i--) { + var dec = decs[i]; + newValue = old_memberDec(dec, name, desc, metadataMap, initializers, kind, isStatic, isPrivate, value); + if (newValue !== void 0) { + old_assertValidReturnValue(kind, newValue); + var newInit; + if (kind === 0) { + newInit = newValue; + } else if (kind === 1) { + newInit = old_getInit(newValue); + get = newValue.get || value.get; + set = newValue.set || value.set; + value = { + get: get, + set: set + }; + } else { + value = newValue; + } + if (newInit !== void 0) { + if (initializer === void 0) { + initializer = newInit; + } else if (typeof initializer === "function") { + initializer = [initializer, newInit]; + } else { + initializer.push(newInit); + } + } + } + } + } + if (kind === 0 || kind === 1) { + if (initializer === void 0) { + initializer = function (instance, init) { + return init; + }; + } else if (typeof initializer !== "function") { + var ownInitializers = initializer; + initializer = function (instance, init) { + var value = init; + for (var i = 0; i < ownInitializers.length; i++) { + value = ownInitializers[i].call(instance, value); + } + return value; + }; + } else { + var originalInitializer = initializer; + initializer = function (instance, init) { + return originalInitializer.call(instance, init); + }; + } + ret.push(initializer); + } + if (kind !== 0) { + if (kind === 1) { + desc.get = value.get; + desc.set = value.set; + } else if (kind === 2) { + desc.value = value; + } else if (kind === 3) { + desc.get = value; + } else if (kind === 4) { + desc.set = value; + } + if (isPrivate) { + if (kind === 1) { + ret.push(function (instance, args) { + return value.get.call(instance, args); + }); + ret.push(function (instance, args) { + return value.set.call(instance, args); + }); + } else if (kind === 2) { + ret.push(value); + } else { + ret.push(function (instance, args) { + return value.call(instance, args); + }); + } + } else { + Object.defineProperty(base, name, desc); + } + } +} +function old_applyMemberDecs(ret, Class, protoMetadataMap, staticMetadataMap, decInfos) { + var protoInitializers; + var staticInitializers; + var existingProtoNonFields = new Map(); + var existingStaticNonFields = new Map(); + for (var i = 0; i < decInfos.length; i++) { + var decInfo = decInfos[i]; + if (!Array.isArray(decInfo)) continue; + var kind = decInfo[1]; + var name = decInfo[2]; + var isPrivate = decInfo.length > 3; + var isStatic = kind >= 5; + var base; + var metadataMap; + var initializers; + if (isStatic) { + base = Class; + metadataMap = staticMetadataMap; + kind = kind - 5; + if (kind !== 0) { + staticInitializers = staticInitializers || []; + initializers = staticInitializers; + } + } else { + base = Class.prototype; + metadataMap = protoMetadataMap; + if (kind !== 0) { + protoInitializers = protoInitializers || []; + initializers = protoInitializers; + } + } + if (kind !== 0 && !isPrivate) { + var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields; + var existingKind = existingNonFields.get(name) || 0; + if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) { + throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name); + } else if (!existingKind && kind > 2) { + existingNonFields.set(name, kind); + } else { + existingNonFields.set(name, true); + } + } + old_applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, metadataMap, initializers); + } + old_pushInitializers(ret, protoInitializers); + old_pushInitializers(ret, staticInitializers); +} +function old_pushInitializers(ret, initializers) { + if (initializers) { + ret.push(function (instance) { + for (var i = 0; i < initializers.length; i++) { + initializers[i].call(instance); + } + return instance; + }); + } +} +function old_applyClassDecs(ret, targetClass, metadataMap, classDecs) { + if (classDecs.length > 0) { + var initializers = []; + var newClass = targetClass; + var name = targetClass.name; + for (var i = classDecs.length - 1; i >= 0; i--) { + var decoratorFinishedRef = { + v: false + }; + try { + var ctx = Object.assign({ + kind: "class", + name: name, + addInitializer: old_createAddInitializerMethod(initializers, decoratorFinishedRef) + }, old_createMetadataMethodsForProperty(metadataMap, 0, name, decoratorFinishedRef)); + var nextNewClass = classDecs[i](newClass, ctx); + } finally { + decoratorFinishedRef.v = true; + } + if (nextNewClass !== undefined) { + old_assertValidReturnValue(10, nextNewClass); + newClass = nextNewClass; + } + } + ret.push(newClass, function () { + for (var i = 0; i < initializers.length; i++) { + initializers[i].call(newClass); + } + }); + } +} +function applyDecs(targetClass, memberDecs, classDecs) { + var ret = []; + var staticMetadataMap = {}; + var protoMetadataMap = {}; + old_applyMemberDecs(ret, targetClass, protoMetadataMap, staticMetadataMap, memberDecs); + old_convertMetadataMapToFinal(targetClass.prototype, protoMetadataMap); + old_applyClassDecs(ret, targetClass, staticMetadataMap, classDecs); + old_convertMetadataMapToFinal(targetClass, staticMetadataMap); + return ret; +} + +//# sourceMappingURL=applyDecs.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs.js.map new file mode 100644 index 0000000000000000000000000000000000000000..00fb11707ee2d5a684af2bd38b426a8f462a4364 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_setFunctionName","require","_toPropertyKey","old_createMetadataMethodsForProperty","metadataMap","kind","property","decoratorFinishedRef","getMetadata","key","old_assertNotFinished","old_assertMetadataKey","metadataForKey","pub","public","priv","private","get","Object","hasOwnProperty","call","constructor","setMetadata","value","Map","set","old_convertMetadataMapToFinal","obj","parentMetadataMap","Symbol","metadata","for","metadataKeys","getOwnPropertySymbols","length","i","metaForKey","parentMetaForKey","parentPub","setPrototypeOf","privArr","Array","from","values","parentPriv","concat","old_createAddInitializerMethod","initializers","addInitializer","initializer","old_assertCallable","push","old_memberDec","dec","name","desc","isStatic","isPrivate","kindStr","ctx","toPropertyKey","v","metadataKind","metadataName","access","assign","fnName","Error","TypeError","fn","hint","old_assertValidReturnValue","type","undefined","init","old_getInit","console","warn","old_applyMemberDec","ret","base","decInfo","decs","prefix","setFunctionName","getOwnPropertyDescriptor","newValue","newInit","instance","ownInitializers","originalInitializer","args","defineProperty","old_applyMemberDecs","Class","protoMetadataMap","staticMetadataMap","decInfos","protoInitializers","staticInitializers","existingProtoNonFields","existingStaticNonFields","isArray","prototype","existingNonFields","existingKind","old_pushInitializers","old_applyClassDecs","targetClass","classDecs","newClass","nextNewClass","applyDecs","memberDecs"],"sources":["../../src/helpers/applyDecs.js"],"sourcesContent":["/* @minVersion 7.17.8 */\n/* @onlyBabel7 */\n\nimport setFunctionName from \"setFunctionName\";\nimport toPropertyKey from \"toPropertyKey\";\n/**\n * NOTE: This is an old version of the helper, used for 2021-12 decorators.\n * Updates should be done in applyDecs2203R.js.\n */\n\n/**\n Enums are used in this file, but not assigned to vars to avoid non-hoistable values\n\n CONSTRUCTOR = 0;\n PUBLIC = 1;\n PRIVATE = 2;\n\n FIELD = 0;\n ACCESSOR = 1;\n METHOD = 2;\n GETTER = 3;\n SETTER = 4;\n\n STATIC = 5;\n\n CLASS = 10; // only used in assertValidReturnValue\n*/\n\nfunction old_createMetadataMethodsForProperty(\n metadataMap,\n kind,\n property,\n decoratorFinishedRef,\n) {\n return {\n getMetadata: function (key) {\n old_assertNotFinished(decoratorFinishedRef, \"getMetadata\");\n old_assertMetadataKey(key);\n\n var metadataForKey = metadataMap[key];\n\n if (metadataForKey === void 0) return void 0;\n\n if (kind === 1 /* PUBLIC */) {\n var pub = metadataForKey.public;\n if (pub !== void 0) {\n return pub[property];\n }\n } else if (kind === 2 /* PRIVATE */) {\n var priv = metadataForKey.private;\n if (priv !== void 0) {\n return priv.get(property);\n }\n } else if (Object.hasOwnProperty.call(metadataForKey, \"constructor\")) {\n return metadataForKey.constructor;\n }\n },\n setMetadata: function (key, value) {\n old_assertNotFinished(decoratorFinishedRef, \"setMetadata\");\n old_assertMetadataKey(key);\n\n var metadataForKey = metadataMap[key];\n\n if (metadataForKey === void 0) {\n metadataForKey = metadataMap[key] = {};\n }\n\n if (kind === 1 /* PUBLIC */) {\n var pub = metadataForKey.public;\n\n if (pub === void 0) {\n pub = metadataForKey.public = {};\n }\n\n pub[property] = value;\n } else if (kind === 2 /* PRIVATE */) {\n var priv = metadataForKey.priv;\n\n if (priv === void 0) {\n priv = metadataForKey.private = new Map();\n }\n\n priv.set(property, value);\n } else {\n metadataForKey.constructor = value;\n }\n },\n };\n}\n\nfunction old_convertMetadataMapToFinal(obj, metadataMap) {\n var parentMetadataMap = obj[Symbol.metadata || Symbol.for(\"Symbol.metadata\")];\n var metadataKeys = Object.getOwnPropertySymbols(metadataMap);\n\n if (metadataKeys.length === 0) return;\n\n for (var i = 0; i < metadataKeys.length; i++) {\n var key = metadataKeys[i];\n var metaForKey = metadataMap[key];\n var parentMetaForKey = parentMetadataMap ? parentMetadataMap[key] : null;\n\n var pub = metaForKey.public;\n var parentPub = parentMetaForKey ? parentMetaForKey.public : null;\n\n if (pub && parentPub) {\n Object.setPrototypeOf(pub, parentPub);\n }\n\n var priv = metaForKey.private;\n\n if (priv) {\n var privArr = Array.from(priv.values());\n var parentPriv = parentMetaForKey ? parentMetaForKey.private : null;\n\n if (parentPriv) {\n privArr = privArr.concat(parentPriv);\n }\n\n metaForKey.private = privArr;\n }\n\n if (parentMetaForKey) {\n Object.setPrototypeOf(metaForKey, parentMetaForKey);\n }\n }\n\n if (parentMetadataMap) {\n Object.setPrototypeOf(metadataMap, parentMetadataMap);\n }\n\n obj[Symbol.metadata || Symbol.for(\"Symbol.metadata\")] = metadataMap;\n}\n\nfunction old_createAddInitializerMethod(initializers, decoratorFinishedRef) {\n return function addInitializer(initializer) {\n old_assertNotFinished(decoratorFinishedRef, \"addInitializer\");\n old_assertCallable(initializer, \"An initializer\");\n initializers.push(initializer);\n };\n}\n\nfunction old_memberDec(\n dec,\n name,\n desc,\n metadataMap,\n initializers,\n kind,\n isStatic,\n isPrivate,\n value,\n) {\n var kindStr;\n\n switch (kind) {\n case 1 /* ACCESSOR */:\n kindStr = \"accessor\";\n break;\n case 2 /* METHOD */:\n kindStr = \"method\";\n break;\n case 3 /* GETTER */:\n kindStr = \"getter\";\n break;\n case 4 /* SETTER */:\n kindStr = \"setter\";\n break;\n default:\n kindStr = \"field\";\n }\n\n var ctx = {\n kind: kindStr,\n name: isPrivate ? \"#\" + name : toPropertyKey(name),\n isStatic: isStatic,\n isPrivate: isPrivate,\n };\n\n var decoratorFinishedRef = { v: false };\n\n if (kind !== 0 /* FIELD */) {\n ctx.addInitializer = old_createAddInitializerMethod(\n initializers,\n decoratorFinishedRef,\n );\n }\n\n var metadataKind, metadataName;\n\n if (isPrivate) {\n metadataKind = 2 /* PRIVATE */;\n metadataName = Symbol(name);\n\n var access = {};\n\n if (kind === 0 /* FIELD */) {\n access.get = desc.get;\n access.set = desc.set;\n } else if (kind === 2 /* METHOD */) {\n access.get = function () {\n return desc.value;\n };\n } else {\n // replace with values that will go through the final getter and setter\n if (kind === 1 /* ACCESSOR */ || kind === 3 /* GETTER */) {\n access.get = function () {\n return desc.get.call(this);\n };\n }\n\n if (kind === 1 /* ACCESSOR */ || kind === 4 /* SETTER */) {\n access.set = function (v) {\n desc.set.call(this, v);\n };\n }\n }\n\n ctx.access = access;\n } else {\n metadataKind = 1 /* PUBLIC */;\n metadataName = name;\n }\n\n try {\n return dec(\n value,\n Object.assign(\n ctx,\n old_createMetadataMethodsForProperty(\n metadataMap,\n metadataKind,\n metadataName,\n decoratorFinishedRef,\n ),\n ),\n );\n } finally {\n decoratorFinishedRef.v = true;\n }\n}\n\nfunction old_assertNotFinished(decoratorFinishedRef, fnName) {\n if (decoratorFinishedRef.v) {\n throw new Error(\n \"attempted to call \" + fnName + \" after decoration was finished\",\n );\n }\n}\n\nfunction old_assertMetadataKey(key) {\n if (typeof key !== \"symbol\") {\n throw new TypeError(\"Metadata keys must be symbols, received: \" + key);\n }\n}\n\nfunction old_assertCallable(fn, hint) {\n if (typeof fn !== \"function\") {\n throw new TypeError(hint + \" must be a function\");\n }\n}\n\nfunction old_assertValidReturnValue(kind, value) {\n var type = typeof value;\n\n if (kind === 1 /* ACCESSOR */) {\n if (type !== \"object\" || value === null) {\n throw new TypeError(\n \"accessor decorators must return an object with get, set, or init properties or void 0\",\n );\n }\n if (value.get !== undefined) {\n old_assertCallable(value.get, \"accessor.get\");\n }\n if (value.set !== undefined) {\n old_assertCallable(value.set, \"accessor.set\");\n }\n if (value.init !== undefined) {\n old_assertCallable(value.init, \"accessor.init\");\n }\n if (value.initializer !== undefined) {\n old_assertCallable(value.initializer, \"accessor.initializer\");\n }\n } else if (type !== \"function\") {\n var hint;\n if (kind === 0 /* FIELD */) {\n hint = \"field\";\n } else if (kind === 10 /* CLASS */) {\n hint = \"class\";\n } else {\n hint = \"method\";\n }\n throw new TypeError(hint + \" decorators must return a function or void 0\");\n }\n}\n\nfunction old_getInit(desc) {\n var initializer;\n if (\n (initializer = desc.init) == null &&\n (initializer = desc.initializer) &&\n typeof console !== \"undefined\"\n ) {\n console.warn(\".initializer has been renamed to .init as of March 2022\");\n }\n return initializer;\n}\n\nfunction old_applyMemberDec(\n ret,\n base,\n decInfo,\n name,\n kind,\n isStatic,\n isPrivate,\n metadataMap,\n initializers,\n) {\n var decs = decInfo[0];\n\n var desc, initializer, prefix, value;\n\n if (isPrivate) {\n if (kind === 0 /* FIELD */ || kind === 1 /* ACCESSOR */) {\n desc = {\n get: decInfo[3],\n set: decInfo[4],\n };\n prefix = \"get\";\n } else if (kind === 3 /* GETTER */) {\n desc = {\n get: decInfo[3],\n };\n prefix = \"get\";\n } else if (kind === 4 /* SETTER */) {\n desc = {\n set: decInfo[3],\n };\n prefix = \"set\";\n } else {\n desc = {\n value: decInfo[3],\n };\n }\n if (kind !== 0 /* FIELD */) {\n if (kind === 1 /* ACCESSOR */) {\n setFunctionName(decInfo[4], \"#\" + name, \"set\");\n }\n setFunctionName(decInfo[3], \"#\" + name, prefix);\n }\n } else if (kind !== 0 /* FIELD */) {\n desc = Object.getOwnPropertyDescriptor(base, name);\n }\n\n if (kind === 1 /* ACCESSOR */) {\n value = {\n get: desc.get,\n set: desc.set,\n };\n } else if (kind === 2 /* METHOD */) {\n value = desc.value;\n } else if (kind === 3 /* GETTER */) {\n value = desc.get;\n } else if (kind === 4 /* SETTER */) {\n value = desc.set;\n }\n\n var newValue, get, set;\n\n if (typeof decs === \"function\") {\n newValue = old_memberDec(\n decs,\n name,\n desc,\n metadataMap,\n initializers,\n kind,\n isStatic,\n isPrivate,\n value,\n );\n\n if (newValue !== void 0) {\n old_assertValidReturnValue(kind, newValue);\n\n if (kind === 0 /* FIELD */) {\n initializer = newValue;\n } else if (kind === 1 /* ACCESSOR */) {\n initializer = old_getInit(newValue);\n get = newValue.get || value.get;\n set = newValue.set || value.set;\n\n value = { get: get, set: set };\n } else {\n value = newValue;\n }\n }\n } else {\n for (var i = decs.length - 1; i >= 0; i--) {\n var dec = decs[i];\n\n newValue = old_memberDec(\n dec,\n name,\n desc,\n metadataMap,\n initializers,\n kind,\n isStatic,\n isPrivate,\n value,\n );\n\n if (newValue !== void 0) {\n old_assertValidReturnValue(kind, newValue);\n var newInit;\n\n if (kind === 0 /* FIELD */) {\n newInit = newValue;\n } else if (kind === 1 /* ACCESSOR */) {\n newInit = old_getInit(newValue);\n get = newValue.get || value.get;\n set = newValue.set || value.set;\n\n value = { get: get, set: set };\n } else {\n value = newValue;\n }\n\n if (newInit !== void 0) {\n if (initializer === void 0) {\n initializer = newInit;\n } else if (typeof initializer === \"function\") {\n initializer = [initializer, newInit];\n } else {\n initializer.push(newInit);\n }\n }\n }\n }\n }\n\n if (kind === 0 /* FIELD */ || kind === 1 /* ACCESSOR */) {\n if (initializer === void 0) {\n // If the initializer was void 0, sub in a dummy initializer\n initializer = function (instance, init) {\n return init;\n };\n } else if (typeof initializer !== \"function\") {\n var ownInitializers = initializer;\n\n initializer = function (instance, init) {\n var value = init;\n\n for (var i = 0; i < ownInitializers.length; i++) {\n value = ownInitializers[i].call(instance, value);\n }\n\n return value;\n };\n } else {\n var originalInitializer = initializer;\n\n initializer = function (instance, init) {\n return originalInitializer.call(instance, init);\n };\n }\n\n ret.push(initializer);\n }\n\n if (kind !== 0 /* FIELD */) {\n if (kind === 1 /* ACCESSOR */) {\n desc.get = value.get;\n desc.set = value.set;\n } else if (kind === 2 /* METHOD */) {\n desc.value = value;\n } else if (kind === 3 /* GETTER */) {\n desc.get = value;\n } else if (kind === 4 /* SETTER */) {\n desc.set = value;\n }\n\n if (isPrivate) {\n if (kind === 1 /* ACCESSOR */) {\n ret.push(function (instance, args) {\n return value.get.call(instance, args);\n });\n ret.push(function (instance, args) {\n return value.set.call(instance, args);\n });\n } else if (kind === 2 /* METHOD */) {\n ret.push(value);\n } else {\n ret.push(function (instance, args) {\n return value.call(instance, args);\n });\n }\n } else {\n Object.defineProperty(base, name, desc);\n }\n }\n}\n\nfunction old_applyMemberDecs(\n ret,\n Class,\n protoMetadataMap,\n staticMetadataMap,\n decInfos,\n) {\n var protoInitializers;\n var staticInitializers;\n\n var existingProtoNonFields = new Map();\n var existingStaticNonFields = new Map();\n\n for (var i = 0; i < decInfos.length; i++) {\n var decInfo = decInfos[i];\n\n // skip computed property names\n if (!Array.isArray(decInfo)) continue;\n\n var kind = decInfo[1];\n var name = decInfo[2];\n var isPrivate = decInfo.length > 3;\n\n var isStatic = kind >= 5; /* STATIC */\n var base;\n var metadataMap;\n var initializers;\n\n if (isStatic) {\n base = Class;\n metadataMap = staticMetadataMap;\n kind = kind - 5 /* STATIC */;\n // initialize staticInitializers when we see a non-field static member\n if (kind !== 0 /* FIELD */) {\n staticInitializers = staticInitializers || [];\n initializers = staticInitializers;\n }\n } else {\n base = Class.prototype;\n metadataMap = protoMetadataMap;\n // initialize protoInitializers when we see a non-field member\n if (kind !== 0 /* FIELD */) {\n protoInitializers = protoInitializers || [];\n initializers = protoInitializers;\n }\n }\n\n if (kind !== 0 /* FIELD */ && !isPrivate) {\n var existingNonFields = isStatic\n ? existingStaticNonFields\n : existingProtoNonFields;\n\n var existingKind = existingNonFields.get(name) || 0;\n\n if (\n existingKind === true ||\n (existingKind === 3 /* GETTER */ && kind !== 4) /* SETTER */ ||\n (existingKind === 4 /* SETTER */ && kind !== 3) /* GETTER */\n ) {\n throw new Error(\n \"Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: \" +\n name,\n );\n } else if (!existingKind && kind > 2 /* METHOD */) {\n existingNonFields.set(name, kind);\n } else {\n existingNonFields.set(name, true);\n }\n }\n\n old_applyMemberDec(\n ret,\n base,\n decInfo,\n name,\n kind,\n isStatic,\n isPrivate,\n metadataMap,\n initializers,\n );\n }\n\n old_pushInitializers(ret, protoInitializers);\n old_pushInitializers(ret, staticInitializers);\n}\n\nfunction old_pushInitializers(ret, initializers) {\n if (initializers) {\n ret.push(function (instance) {\n for (var i = 0; i < initializers.length; i++) {\n initializers[i].call(instance);\n }\n return instance;\n });\n }\n}\n\nfunction old_applyClassDecs(ret, targetClass, metadataMap, classDecs) {\n if (classDecs.length > 0) {\n var initializers = [];\n var newClass = targetClass;\n var name = targetClass.name;\n\n for (var i = classDecs.length - 1; i >= 0; i--) {\n var decoratorFinishedRef = { v: false };\n\n try {\n var ctx = Object.assign(\n {\n kind: \"class\",\n name: name,\n addInitializer: old_createAddInitializerMethod(\n initializers,\n decoratorFinishedRef,\n ),\n },\n old_createMetadataMethodsForProperty(\n metadataMap,\n 0 /* CONSTRUCTOR */,\n name,\n decoratorFinishedRef,\n ),\n );\n var nextNewClass = classDecs[i](newClass, ctx);\n } finally {\n decoratorFinishedRef.v = true;\n }\n\n if (nextNewClass !== undefined) {\n old_assertValidReturnValue(10 /* CLASS */, nextNewClass);\n newClass = nextNewClass;\n }\n }\n\n ret.push(newClass, function () {\n for (var i = 0; i < initializers.length; i++) {\n initializers[i].call(newClass);\n }\n });\n }\n}\n\n/**\n Basic usage:\n\n applyDecs(\n Class,\n [\n // member decorators\n [\n dec, // dec or array of decs\n 0, // kind of value being decorated\n 'prop', // name of public prop on class containing the value being decorated,\n '#p', // the name of the private property (if is private, void 0 otherwise),\n ]\n ],\n [\n // class decorators\n dec1, dec2\n ]\n )\n ```\n\n Fully transpiled example:\n\n ```js\n @dec\n class Class {\n @dec\n a = 123;\n\n @dec\n #a = 123;\n\n @dec\n @dec2\n accessor b = 123;\n\n @dec\n accessor #b = 123;\n\n @dec\n c() { console.log('c'); }\n\n @dec\n #c() { console.log('privC'); }\n\n @dec\n get d() { console.log('d'); }\n\n @dec\n get #d() { console.log('privD'); }\n\n @dec\n set e(v) { console.log('e'); }\n\n @dec\n set #e(v) { console.log('privE'); }\n }\n\n\n // becomes\n let initializeInstance;\n let initializeClass;\n\n let initA;\n let initPrivA;\n\n let initB;\n let initPrivB, getPrivB, setPrivB;\n\n let privC;\n let privD;\n let privE;\n\n let Class;\n class _Class {\n static {\n let ret = applyDecs(\n this,\n [\n [dec, 0, 'a'],\n [dec, 0, 'a', (i) => i.#a, (i, v) => i.#a = v],\n [[dec, dec2], 1, 'b'],\n [dec, 1, 'b', (i) => i.#privBData, (i, v) => i.#privBData = v],\n [dec, 2, 'c'],\n [dec, 2, 'c', () => console.log('privC')],\n [dec, 3, 'd'],\n [dec, 3, 'd', () => console.log('privD')],\n [dec, 4, 'e'],\n [dec, 4, 'e', () => console.log('privE')],\n ],\n [\n dec\n ]\n )\n\n initA = ret[0];\n\n initPrivA = ret[1];\n\n initB = ret[2];\n\n initPrivB = ret[3];\n getPrivB = ret[4];\n setPrivB = ret[5];\n\n privC = ret[6];\n\n privD = ret[7];\n\n privE = ret[8];\n\n initializeInstance = ret[9];\n\n Class = ret[10]\n\n initializeClass = ret[11];\n }\n\n a = (initializeInstance(this), initA(this, 123));\n\n #a = initPrivA(this, 123);\n\n #bData = initB(this, 123);\n get b() { return this.#bData }\n set b(v) { this.#bData = v }\n\n #privBData = initPrivB(this, 123);\n get #b() { return getPrivB(this); }\n set #b(v) { setPrivB(this, v); }\n\n c() { console.log('c'); }\n\n #c(...args) { return privC(this, ...args) }\n\n get d() { console.log('d'); }\n\n get #d() { return privD(this); }\n\n set e(v) { console.log('e'); }\n\n set #e(v) { privE(this, v); }\n }\n\n initializeClass(Class);\n */\nexport default function applyDecs(targetClass, memberDecs, classDecs) {\n var ret = [];\n var staticMetadataMap = {};\n\n var protoMetadataMap = {};\n\n old_applyMemberDecs(\n ret,\n targetClass,\n protoMetadataMap,\n staticMetadataMap,\n memberDecs,\n );\n\n old_convertMetadataMapToFinal(targetClass.prototype, protoMetadataMap);\n\n old_applyClassDecs(ret, targetClass, staticMetadataMap, classDecs);\n\n old_convertMetadataMapToFinal(targetClass, staticMetadataMap);\n\n return ret;\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2203.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2203.js new file mode 100644 index 0000000000000000000000000000000000000000..d61a4c42e454e9bd15be4a7bace1607ba931f475 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2203.js @@ -0,0 +1,363 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = applyDecs2203; +function applyDecs2203Factory() { + function createAddInitializerMethod(initializers, decoratorFinishedRef) { + return function addInitializer(initializer) { + assertNotFinished(decoratorFinishedRef, "addInitializer"); + assertCallable(initializer, "An initializer"); + initializers.push(initializer); + }; + } + function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, value) { + var kindStr; + switch (kind) { + case 1: + kindStr = "accessor"; + break; + case 2: + kindStr = "method"; + break; + case 3: + kindStr = "getter"; + break; + case 4: + kindStr = "setter"; + break; + default: + kindStr = "field"; + } + var ctx = { + kind: kindStr, + name: isPrivate ? "#" + name : name, + static: isStatic, + private: isPrivate + }; + var decoratorFinishedRef = { + v: false + }; + if (kind !== 0) { + ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef); + } + var get, set; + if (kind === 0) { + if (isPrivate) { + get = desc.get; + set = desc.set; + } else { + get = function () { + return this[name]; + }; + set = function (v) { + this[name] = v; + }; + } + } else if (kind === 2) { + get = function () { + return desc.value; + }; + } else { + if (kind === 1 || kind === 3) { + get = function () { + return desc.get.call(this); + }; + } + if (kind === 1 || kind === 4) { + set = function (v) { + desc.set.call(this, v); + }; + } + } + ctx.access = get && set ? { + get: get, + set: set + } : get ? { + get: get + } : { + set: set + }; + try { + return dec(value, ctx); + } finally { + decoratorFinishedRef.v = true; + } + } + function assertNotFinished(decoratorFinishedRef, fnName) { + if (decoratorFinishedRef.v) { + throw new Error("attempted to call " + fnName + " after decoration was finished"); + } + } + function assertCallable(fn, hint) { + if (typeof fn !== "function") { + throw new TypeError(hint + " must be a function"); + } + } + function assertValidReturnValue(kind, value) { + var type = typeof value; + if (kind === 1) { + if (type !== "object" || value === null) { + throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); + } + if (value.get !== undefined) { + assertCallable(value.get, "accessor.get"); + } + if (value.set !== undefined) { + assertCallable(value.set, "accessor.set"); + } + if (value.init !== undefined) { + assertCallable(value.init, "accessor.init"); + } + } else if (type !== "function") { + var hint; + if (kind === 0) { + hint = "field"; + } else if (kind === 10) { + hint = "class"; + } else { + hint = "method"; + } + throw new TypeError(hint + " decorators must return a function or void 0"); + } + } + function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers) { + var decs = decInfo[0]; + var desc, init, value; + if (isPrivate) { + if (kind === 0 || kind === 1) { + desc = { + get: decInfo[3], + set: decInfo[4] + }; + } else if (kind === 3) { + desc = { + get: decInfo[3] + }; + } else if (kind === 4) { + desc = { + set: decInfo[3] + }; + } else { + desc = { + value: decInfo[3] + }; + } + } else if (kind !== 0) { + desc = Object.getOwnPropertyDescriptor(base, name); + } + if (kind === 1) { + value = { + get: desc.get, + set: desc.set + }; + } else if (kind === 2) { + value = desc.value; + } else if (kind === 3) { + value = desc.get; + } else if (kind === 4) { + value = desc.set; + } + var newValue, get, set; + if (typeof decs === "function") { + newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, value); + if (newValue !== void 0) { + assertValidReturnValue(kind, newValue); + if (kind === 0) { + init = newValue; + } else if (kind === 1) { + init = newValue.init; + get = newValue.get || value.get; + set = newValue.set || value.set; + value = { + get: get, + set: set + }; + } else { + value = newValue; + } + } + } else { + for (var i = decs.length - 1; i >= 0; i--) { + var dec = decs[i]; + newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, value); + if (newValue !== void 0) { + assertValidReturnValue(kind, newValue); + var newInit; + if (kind === 0) { + newInit = newValue; + } else if (kind === 1) { + newInit = newValue.init; + get = newValue.get || value.get; + set = newValue.set || value.set; + value = { + get: get, + set: set + }; + } else { + value = newValue; + } + if (newInit !== void 0) { + if (init === void 0) { + init = newInit; + } else if (typeof init === "function") { + init = [init, newInit]; + } else { + init.push(newInit); + } + } + } + } + } + if (kind === 0 || kind === 1) { + if (init === void 0) { + init = function (instance, init) { + return init; + }; + } else if (typeof init !== "function") { + var ownInitializers = init; + init = function (instance, init) { + var value = init; + for (var i = 0; i < ownInitializers.length; i++) { + value = ownInitializers[i].call(instance, value); + } + return value; + }; + } else { + var originalInitializer = init; + init = function (instance, init) { + return originalInitializer.call(instance, init); + }; + } + ret.push(init); + } + if (kind !== 0) { + if (kind === 1) { + desc.get = value.get; + desc.set = value.set; + } else if (kind === 2) { + desc.value = value; + } else if (kind === 3) { + desc.get = value; + } else if (kind === 4) { + desc.set = value; + } + if (isPrivate) { + if (kind === 1) { + ret.push(function (instance, args) { + return value.get.call(instance, args); + }); + ret.push(function (instance, args) { + return value.set.call(instance, args); + }); + } else if (kind === 2) { + ret.push(value); + } else { + ret.push(function (instance, args) { + return value.call(instance, args); + }); + } + } else { + Object.defineProperty(base, name, desc); + } + } + } + function applyMemberDecs(ret, Class, decInfos) { + var protoInitializers; + var staticInitializers; + var existingProtoNonFields = new Map(); + var existingStaticNonFields = new Map(); + for (var i = 0; i < decInfos.length; i++) { + var decInfo = decInfos[i]; + if (!Array.isArray(decInfo)) continue; + var kind = decInfo[1]; + var name = decInfo[2]; + var isPrivate = decInfo.length > 3; + var isStatic = kind >= 5; + var base; + var initializers; + if (isStatic) { + base = Class; + kind = kind - 5; + if (kind !== 0) { + staticInitializers = staticInitializers || []; + initializers = staticInitializers; + } + } else { + base = Class.prototype; + if (kind !== 0) { + protoInitializers = protoInitializers || []; + initializers = protoInitializers; + } + } + if (kind !== 0 && !isPrivate) { + var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields; + var existingKind = existingNonFields.get(name) || 0; + if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) { + throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name); + } else if (!existingKind && kind > 2) { + existingNonFields.set(name, kind); + } else { + existingNonFields.set(name, true); + } + } + applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers); + } + pushInitializers(ret, protoInitializers); + pushInitializers(ret, staticInitializers); + } + function pushInitializers(ret, initializers) { + if (initializers) { + ret.push(function (instance) { + for (var i = 0; i < initializers.length; i++) { + initializers[i].call(instance); + } + return instance; + }); + } + } + function applyClassDecs(ret, targetClass, classDecs) { + if (classDecs.length > 0) { + var initializers = []; + var newClass = targetClass; + var name = targetClass.name; + for (var i = classDecs.length - 1; i >= 0; i--) { + var decoratorFinishedRef = { + v: false + }; + try { + var nextNewClass = classDecs[i](newClass, { + kind: "class", + name: name, + addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef) + }); + } finally { + decoratorFinishedRef.v = true; + } + if (nextNewClass !== undefined) { + assertValidReturnValue(10, nextNewClass); + newClass = nextNewClass; + } + } + ret.push(newClass, function () { + for (var i = 0; i < initializers.length; i++) { + initializers[i].call(newClass); + } + }); + } + } + return function applyDecs2203Impl(targetClass, memberDecs, classDecs) { + var ret = []; + applyMemberDecs(ret, targetClass, memberDecs); + applyClassDecs(ret, targetClass, classDecs); + return ret; + }; +} +var applyDecs2203Impl; +function applyDecs2203(targetClass, memberDecs, classDecs) { + applyDecs2203Impl = applyDecs2203Impl || applyDecs2203Factory(); + return applyDecs2203Impl(targetClass, memberDecs, classDecs); +} + +//# sourceMappingURL=applyDecs2203.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2203.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2203.js.map new file mode 100644 index 0000000000000000000000000000000000000000..8de137ed43610be01ef1ea260a1f831720c8b974 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2203.js.map @@ -0,0 +1 @@ +{"version":3,"names":["applyDecs2203Factory","createAddInitializerMethod","initializers","decoratorFinishedRef","addInitializer","initializer","assertNotFinished","assertCallable","push","memberDec","dec","name","desc","kind","isStatic","isPrivate","value","kindStr","ctx","static","private","v","get","set","call","access","fnName","Error","fn","hint","TypeError","assertValidReturnValue","type","undefined","init","applyMemberDec","ret","base","decInfo","decs","Object","getOwnPropertyDescriptor","newValue","i","length","newInit","instance","ownInitializers","originalInitializer","args","defineProperty","applyMemberDecs","Class","decInfos","protoInitializers","staticInitializers","existingProtoNonFields","Map","existingStaticNonFields","Array","isArray","prototype","existingNonFields","existingKind","pushInitializers","applyClassDecs","targetClass","classDecs","newClass","nextNewClass","applyDecs2203Impl","memberDecs","applyDecs2203"],"sources":["../../src/helpers/applyDecs2203.js"],"sourcesContent":["/* @minVersion 7.19.0 */\n/* @onlyBabel7 */\n\n/**\n * NOTE: This is an old version of the helper, used for 2022-03 decorators.\n * Updates should be done in applyDecs2203R.js.\n */\n\n/**\n Enums are used in this file, but not assigned to vars to avoid non-hoistable values\n\n CONSTRUCTOR = 0;\n PUBLIC = 1;\n PRIVATE = 2;\n\n FIELD = 0;\n ACCESSOR = 1;\n METHOD = 2;\n GETTER = 3;\n SETTER = 4;\n\n STATIC = 5;\n\n CLASS = 10; // only used in assertValidReturnValue\n*/\nfunction applyDecs2203Factory() {\n function createAddInitializerMethod(initializers, decoratorFinishedRef) {\n return function addInitializer(initializer) {\n assertNotFinished(decoratorFinishedRef, \"addInitializer\");\n assertCallable(initializer, \"An initializer\");\n initializers.push(initializer);\n };\n }\n\n function memberDec(\n dec,\n name,\n desc,\n initializers,\n kind,\n isStatic,\n isPrivate,\n value,\n ) {\n var kindStr;\n\n switch (kind) {\n case 1 /* ACCESSOR */:\n kindStr = \"accessor\";\n break;\n case 2 /* METHOD */:\n kindStr = \"method\";\n break;\n case 3 /* GETTER */:\n kindStr = \"getter\";\n break;\n case 4 /* SETTER */:\n kindStr = \"setter\";\n break;\n default:\n kindStr = \"field\";\n }\n\n var ctx = {\n kind: kindStr,\n name: isPrivate ? \"#\" + name : name,\n static: isStatic,\n private: isPrivate,\n };\n\n var decoratorFinishedRef = { v: false };\n\n if (kind !== 0 /* FIELD */) {\n ctx.addInitializer = createAddInitializerMethod(\n initializers,\n decoratorFinishedRef,\n );\n }\n\n var get, set;\n if (kind === 0 /* FIELD */) {\n if (isPrivate) {\n get = desc.get;\n set = desc.set;\n } else {\n get = function () {\n return this[name];\n };\n set = function (v) {\n this[name] = v;\n };\n }\n } else if (kind === 2 /* METHOD */) {\n get = function () {\n return desc.value;\n };\n } else {\n // replace with values that will go through the final getter and setter\n if (kind === 1 /* ACCESSOR */ || kind === 3 /* GETTER */) {\n get = function () {\n return desc.get.call(this);\n };\n }\n\n if (kind === 1 /* ACCESSOR */ || kind === 4 /* SETTER */) {\n set = function (v) {\n desc.set.call(this, v);\n };\n }\n }\n ctx.access =\n get && set ? { get: get, set: set } : get ? { get: get } : { set: set };\n\n try {\n return dec(value, ctx);\n } finally {\n decoratorFinishedRef.v = true;\n }\n }\n\n function assertNotFinished(decoratorFinishedRef, fnName) {\n if (decoratorFinishedRef.v) {\n throw new Error(\n \"attempted to call \" + fnName + \" after decoration was finished\",\n );\n }\n }\n\n function assertCallable(fn, hint) {\n if (typeof fn !== \"function\") {\n throw new TypeError(hint + \" must be a function\");\n }\n }\n\n function assertValidReturnValue(kind, value) {\n var type = typeof value;\n\n if (kind === 1 /* ACCESSOR */) {\n if (type !== \"object\" || value === null) {\n throw new TypeError(\n \"accessor decorators must return an object with get, set, or init properties or void 0\",\n );\n }\n if (value.get !== undefined) {\n assertCallable(value.get, \"accessor.get\");\n }\n if (value.set !== undefined) {\n assertCallable(value.set, \"accessor.set\");\n }\n if (value.init !== undefined) {\n assertCallable(value.init, \"accessor.init\");\n }\n } else if (type !== \"function\") {\n var hint;\n if (kind === 0 /* FIELD */) {\n hint = \"field\";\n } else if (kind === 10 /* CLASS */) {\n hint = \"class\";\n } else {\n hint = \"method\";\n }\n throw new TypeError(\n hint + \" decorators must return a function or void 0\",\n );\n }\n }\n\n function applyMemberDec(\n ret,\n base,\n decInfo,\n name,\n kind,\n isStatic,\n isPrivate,\n initializers,\n ) {\n var decs = decInfo[0];\n\n var desc, init, value;\n\n if (isPrivate) {\n if (kind === 0 /* FIELD */ || kind === 1 /* ACCESSOR */) {\n desc = {\n get: decInfo[3],\n set: decInfo[4],\n };\n } else if (kind === 3 /* GETTER */) {\n desc = {\n get: decInfo[3],\n };\n } else if (kind === 4 /* SETTER */) {\n desc = {\n set: decInfo[3],\n };\n } else {\n desc = {\n value: decInfo[3],\n };\n }\n } else if (kind !== 0 /* FIELD */) {\n desc = Object.getOwnPropertyDescriptor(base, name);\n }\n\n if (kind === 1 /* ACCESSOR */) {\n value = {\n get: desc.get,\n set: desc.set,\n };\n } else if (kind === 2 /* METHOD */) {\n value = desc.value;\n } else if (kind === 3 /* GETTER */) {\n value = desc.get;\n } else if (kind === 4 /* SETTER */) {\n value = desc.set;\n }\n\n var newValue, get, set;\n\n if (typeof decs === \"function\") {\n newValue = memberDec(\n decs,\n name,\n desc,\n initializers,\n kind,\n isStatic,\n isPrivate,\n value,\n );\n\n if (newValue !== void 0) {\n assertValidReturnValue(kind, newValue);\n\n if (kind === 0 /* FIELD */) {\n init = newValue;\n } else if (kind === 1 /* ACCESSOR */) {\n init = newValue.init;\n get = newValue.get || value.get;\n set = newValue.set || value.set;\n\n value = { get: get, set: set };\n } else {\n value = newValue;\n }\n }\n } else {\n for (var i = decs.length - 1; i >= 0; i--) {\n var dec = decs[i];\n\n newValue = memberDec(\n dec,\n name,\n desc,\n initializers,\n kind,\n isStatic,\n isPrivate,\n value,\n );\n\n if (newValue !== void 0) {\n assertValidReturnValue(kind, newValue);\n var newInit;\n\n if (kind === 0 /* FIELD */) {\n newInit = newValue;\n } else if (kind === 1 /* ACCESSOR */) {\n newInit = newValue.init;\n get = newValue.get || value.get;\n set = newValue.set || value.set;\n\n value = { get: get, set: set };\n } else {\n value = newValue;\n }\n\n if (newInit !== void 0) {\n if (init === void 0) {\n init = newInit;\n } else if (typeof init === \"function\") {\n init = [init, newInit];\n } else {\n init.push(newInit);\n }\n }\n }\n }\n }\n\n if (kind === 0 /* FIELD */ || kind === 1 /* ACCESSOR */) {\n if (init === void 0) {\n // If the initializer was void 0, sub in a dummy initializer\n init = function (instance, init) {\n return init;\n };\n } else if (typeof init !== \"function\") {\n var ownInitializers = init;\n\n init = function (instance, init) {\n var value = init;\n\n for (var i = 0; i < ownInitializers.length; i++) {\n value = ownInitializers[i].call(instance, value);\n }\n\n return value;\n };\n } else {\n var originalInitializer = init;\n\n init = function (instance, init) {\n return originalInitializer.call(instance, init);\n };\n }\n\n ret.push(init);\n }\n\n if (kind !== 0 /* FIELD */) {\n if (kind === 1 /* ACCESSOR */) {\n desc.get = value.get;\n desc.set = value.set;\n } else if (kind === 2 /* METHOD */) {\n desc.value = value;\n } else if (kind === 3 /* GETTER */) {\n desc.get = value;\n } else if (kind === 4 /* SETTER */) {\n desc.set = value;\n }\n\n if (isPrivate) {\n if (kind === 1 /* ACCESSOR */) {\n ret.push(function (instance, args) {\n return value.get.call(instance, args);\n });\n ret.push(function (instance, args) {\n return value.set.call(instance, args);\n });\n } else if (kind === 2 /* METHOD */) {\n ret.push(value);\n } else {\n ret.push(function (instance, args) {\n return value.call(instance, args);\n });\n }\n } else {\n Object.defineProperty(base, name, desc);\n }\n }\n }\n\n function applyMemberDecs(ret, Class, decInfos) {\n var protoInitializers;\n var staticInitializers;\n\n var existingProtoNonFields = new Map();\n var existingStaticNonFields = new Map();\n\n for (var i = 0; i < decInfos.length; i++) {\n var decInfo = decInfos[i];\n\n // skip computed property names\n if (!Array.isArray(decInfo)) continue;\n\n var kind = decInfo[1];\n var name = decInfo[2];\n var isPrivate = decInfo.length > 3;\n\n var isStatic = kind >= 5; /* STATIC */\n var base;\n var initializers;\n\n if (isStatic) {\n base = Class;\n kind = kind - 5 /* STATIC */;\n // initialize staticInitializers when we see a non-field static member\n if (kind !== 0 /* FIELD */) {\n staticInitializers = staticInitializers || [];\n initializers = staticInitializers;\n }\n } else {\n base = Class.prototype;\n // initialize protoInitializers when we see a non-field member\n if (kind !== 0 /* FIELD */) {\n protoInitializers = protoInitializers || [];\n initializers = protoInitializers;\n }\n }\n\n if (kind !== 0 /* FIELD */ && !isPrivate) {\n var existingNonFields = isStatic\n ? existingStaticNonFields\n : existingProtoNonFields;\n\n var existingKind = existingNonFields.get(name) || 0;\n\n if (\n existingKind === true ||\n (existingKind === 3 /* GETTER */ && kind !== 4) /* SETTER */ ||\n (existingKind === 4 /* SETTER */ && kind !== 3) /* GETTER */\n ) {\n throw new Error(\n \"Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: \" +\n name,\n );\n } else if (!existingKind && kind > 2 /* METHOD */) {\n existingNonFields.set(name, kind);\n } else {\n existingNonFields.set(name, true);\n }\n }\n\n applyMemberDec(\n ret,\n base,\n decInfo,\n name,\n kind,\n isStatic,\n isPrivate,\n initializers,\n );\n }\n\n pushInitializers(ret, protoInitializers);\n pushInitializers(ret, staticInitializers);\n }\n\n function pushInitializers(ret, initializers) {\n if (initializers) {\n ret.push(function (instance) {\n for (var i = 0; i < initializers.length; i++) {\n initializers[i].call(instance);\n }\n return instance;\n });\n }\n }\n\n function applyClassDecs(ret, targetClass, classDecs) {\n if (classDecs.length > 0) {\n var initializers = [];\n var newClass = targetClass;\n var name = targetClass.name;\n\n for (var i = classDecs.length - 1; i >= 0; i--) {\n var decoratorFinishedRef = { v: false };\n\n try {\n var nextNewClass = classDecs[i](newClass, {\n kind: \"class\",\n name: name,\n addInitializer: createAddInitializerMethod(\n initializers,\n decoratorFinishedRef,\n ),\n });\n } finally {\n decoratorFinishedRef.v = true;\n }\n\n if (nextNewClass !== undefined) {\n assertValidReturnValue(10 /* CLASS */, nextNewClass);\n newClass = nextNewClass;\n }\n }\n\n ret.push(newClass, function () {\n for (var i = 0; i < initializers.length; i++) {\n initializers[i].call(newClass);\n }\n });\n }\n }\n\n /**\n Basic usage:\n\n applyDecs(\n Class,\n [\n // member decorators\n [\n dec, // dec or array of decs\n 0, // kind of value being decorated\n 'prop', // name of public prop on class containing the value being decorated,\n '#p', // the name of the private property (if is private, void 0 otherwise),\n ]\n ],\n [\n // class decorators\n dec1, dec2\n ]\n )\n ```\n\n Fully transpiled example:\n\n ```js\n @dec\n class Class {\n @dec\n a = 123;\n\n @dec\n #a = 123;\n\n @dec\n @dec2\n accessor b = 123;\n\n @dec\n accessor #b = 123;\n\n @dec\n c() { console.log('c'); }\n\n @dec\n #c() { console.log('privC'); }\n\n @dec\n get d() { console.log('d'); }\n\n @dec\n get #d() { console.log('privD'); }\n\n @dec\n set e(v) { console.log('e'); }\n\n @dec\n set #e(v) { console.log('privE'); }\n }\n\n\n // becomes\n let initializeInstance;\n let initializeClass;\n\n let initA;\n let initPrivA;\n\n let initB;\n let initPrivB, getPrivB, setPrivB;\n\n let privC;\n let privD;\n let privE;\n\n let Class;\n class _Class {\n static {\n let ret = applyDecs(\n this,\n [\n [dec, 0, 'a'],\n [dec, 0, 'a', (i) => i.#a, (i, v) => i.#a = v],\n [[dec, dec2], 1, 'b'],\n [dec, 1, 'b', (i) => i.#privBData, (i, v) => i.#privBData = v],\n [dec, 2, 'c'],\n [dec, 2, 'c', () => console.log('privC')],\n [dec, 3, 'd'],\n [dec, 3, 'd', () => console.log('privD')],\n [dec, 4, 'e'],\n [dec, 4, 'e', () => console.log('privE')],\n ],\n [\n dec\n ]\n )\n\n initA = ret[0];\n\n initPrivA = ret[1];\n\n initB = ret[2];\n\n initPrivB = ret[3];\n getPrivB = ret[4];\n setPrivB = ret[5];\n\n privC = ret[6];\n\n privD = ret[7];\n\n privE = ret[8];\n\n initializeInstance = ret[9];\n\n Class = ret[10]\n\n initializeClass = ret[11];\n }\n\n a = (initializeInstance(this), initA(this, 123));\n\n #a = initPrivA(this, 123);\n\n #bData = initB(this, 123);\n get b() { return this.#bData }\n set b(v) { this.#bData = v }\n\n #privBData = initPrivB(this, 123);\n get #b() { return getPrivB(this); }\n set #b(v) { setPrivB(this, v); }\n\n c() { console.log('c'); }\n\n #c(...args) { return privC(this, ...args) }\n\n get d() { console.log('d'); }\n\n get #d() { return privD(this); }\n\n set e(v) { console.log('e'); }\n\n set #e(v) { privE(this, v); }\n }\n\n initializeClass(Class);\n */\n\n return function applyDecs2203Impl(targetClass, memberDecs, classDecs) {\n var ret = [];\n applyMemberDecs(ret, targetClass, memberDecs);\n applyClassDecs(ret, targetClass, classDecs);\n return ret;\n };\n}\n\nvar applyDecs2203Impl;\n\nexport default function applyDecs2203(targetClass, memberDecs, classDecs) {\n applyDecs2203Impl = applyDecs2203Impl || applyDecs2203Factory();\n return applyDecs2203Impl(targetClass, memberDecs, classDecs);\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2203R.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2203R.js new file mode 100644 index 0000000000000000000000000000000000000000..8f2750d4f31759143b2a90c23573275282b41c8f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2203R.js @@ -0,0 +1,376 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = applyDecs2203R; +var _setFunctionName = require("setFunctionName"); +var _toPropertyKey = require("toPropertyKey"); +function applyDecs2203RFactory() { + function createAddInitializerMethod(initializers, decoratorFinishedRef) { + return function addInitializer(initializer) { + assertNotFinished(decoratorFinishedRef, "addInitializer"); + assertCallable(initializer, "An initializer"); + initializers.push(initializer); + }; + } + function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, value) { + var kindStr; + switch (kind) { + case 1: + kindStr = "accessor"; + break; + case 2: + kindStr = "method"; + break; + case 3: + kindStr = "getter"; + break; + case 4: + kindStr = "setter"; + break; + default: + kindStr = "field"; + } + var ctx = { + kind: kindStr, + name: isPrivate ? "#" + name : _toPropertyKey(name), + static: isStatic, + private: isPrivate + }; + var decoratorFinishedRef = { + v: false + }; + if (kind !== 0) { + ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef); + } + var get, set; + if (kind === 0) { + if (isPrivate) { + get = desc.get; + set = desc.set; + } else { + get = function () { + return this[name]; + }; + set = function (v) { + this[name] = v; + }; + } + } else if (kind === 2) { + get = function () { + return desc.value; + }; + } else { + if (kind === 1 || kind === 3) { + get = function () { + return desc.get.call(this); + }; + } + if (kind === 1 || kind === 4) { + set = function (v) { + desc.set.call(this, v); + }; + } + } + ctx.access = get && set ? { + get: get, + set: set + } : get ? { + get: get + } : { + set: set + }; + try { + return dec(value, ctx); + } finally { + decoratorFinishedRef.v = true; + } + } + function assertNotFinished(decoratorFinishedRef, fnName) { + if (decoratorFinishedRef.v) { + throw new Error("attempted to call " + fnName + " after decoration was finished"); + } + } + function assertCallable(fn, hint) { + if (typeof fn !== "function") { + throw new TypeError(hint + " must be a function"); + } + } + function assertValidReturnValue(kind, value) { + var type = typeof value; + if (kind === 1) { + if (type !== "object" || value === null) { + throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); + } + if (value.get !== undefined) { + assertCallable(value.get, "accessor.get"); + } + if (value.set !== undefined) { + assertCallable(value.set, "accessor.set"); + } + if (value.init !== undefined) { + assertCallable(value.init, "accessor.init"); + } + } else if (type !== "function") { + var hint; + if (kind === 0) { + hint = "field"; + } else if (kind === 10) { + hint = "class"; + } else { + hint = "method"; + } + throw new TypeError(hint + " decorators must return a function or void 0"); + } + } + function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers) { + var decs = decInfo[0]; + var desc, init, prefix, value; + if (isPrivate) { + if (kind === 0 || kind === 1) { + desc = { + get: decInfo[3], + set: decInfo[4] + }; + prefix = "get"; + } else if (kind === 3) { + desc = { + get: decInfo[3] + }; + prefix = "get"; + } else if (kind === 4) { + desc = { + set: decInfo[3] + }; + prefix = "set"; + } else { + desc = { + value: decInfo[3] + }; + } + if (kind !== 0) { + if (kind === 1) { + _setFunctionName(decInfo[4], "#" + name, "set"); + } + _setFunctionName(decInfo[3], "#" + name, prefix); + } + } else if (kind !== 0) { + desc = Object.getOwnPropertyDescriptor(base, name); + } + if (kind === 1) { + value = { + get: desc.get, + set: desc.set + }; + } else if (kind === 2) { + value = desc.value; + } else if (kind === 3) { + value = desc.get; + } else if (kind === 4) { + value = desc.set; + } + var newValue, get, set; + if (typeof decs === "function") { + newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, value); + if (newValue !== void 0) { + assertValidReturnValue(kind, newValue); + if (kind === 0) { + init = newValue; + } else if (kind === 1) { + init = newValue.init; + get = newValue.get || value.get; + set = newValue.set || value.set; + value = { + get: get, + set: set + }; + } else { + value = newValue; + } + } + } else { + for (var i = decs.length - 1; i >= 0; i--) { + var dec = decs[i]; + newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, value); + if (newValue !== void 0) { + assertValidReturnValue(kind, newValue); + var newInit; + if (kind === 0) { + newInit = newValue; + } else if (kind === 1) { + newInit = newValue.init; + get = newValue.get || value.get; + set = newValue.set || value.set; + value = { + get: get, + set: set + }; + } else { + value = newValue; + } + if (newInit !== void 0) { + if (init === void 0) { + init = newInit; + } else if (typeof init === "function") { + init = [init, newInit]; + } else { + init.push(newInit); + } + } + } + } + } + if (kind === 0 || kind === 1) { + if (init === void 0) { + init = function (instance, init) { + return init; + }; + } else if (typeof init !== "function") { + var ownInitializers = init; + init = function (instance, init) { + var value = init; + for (var i = 0; i < ownInitializers.length; i++) { + value = ownInitializers[i].call(instance, value); + } + return value; + }; + } else { + var originalInitializer = init; + init = function (instance, init) { + return originalInitializer.call(instance, init); + }; + } + ret.push(init); + } + if (kind !== 0) { + if (kind === 1) { + desc.get = value.get; + desc.set = value.set; + } else if (kind === 2) { + desc.value = value; + } else if (kind === 3) { + desc.get = value; + } else if (kind === 4) { + desc.set = value; + } + if (isPrivate) { + if (kind === 1) { + ret.push(function (instance, args) { + return value.get.call(instance, args); + }); + ret.push(function (instance, args) { + return value.set.call(instance, args); + }); + } else if (kind === 2) { + ret.push(value); + } else { + ret.push(function (instance, args) { + return value.call(instance, args); + }); + } + } else { + Object.defineProperty(base, name, desc); + } + } + } + function applyMemberDecs(Class, decInfos) { + var ret = []; + var protoInitializers; + var staticInitializers; + var existingProtoNonFields = new Map(); + var existingStaticNonFields = new Map(); + for (var i = 0; i < decInfos.length; i++) { + var decInfo = decInfos[i]; + if (!Array.isArray(decInfo)) continue; + var kind = decInfo[1]; + var name = decInfo[2]; + var isPrivate = decInfo.length > 3; + var isStatic = kind >= 5; + var base; + var initializers; + if (isStatic) { + base = Class; + kind = kind - 5; + if (kind !== 0) { + staticInitializers = staticInitializers || []; + initializers = staticInitializers; + } + } else { + base = Class.prototype; + if (kind !== 0) { + protoInitializers = protoInitializers || []; + initializers = protoInitializers; + } + } + if (kind !== 0 && !isPrivate) { + var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields; + var existingKind = existingNonFields.get(name) || 0; + if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) { + throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name); + } else if (!existingKind && kind > 2) { + existingNonFields.set(name, kind); + } else { + existingNonFields.set(name, true); + } + } + applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers); + } + pushInitializers(ret, protoInitializers); + pushInitializers(ret, staticInitializers); + return ret; + } + function pushInitializers(ret, initializers) { + if (initializers) { + ret.push(function (instance) { + for (var i = 0; i < initializers.length; i++) { + initializers[i].call(instance); + } + return instance; + }); + } + } + function applyClassDecs(targetClass, classDecs) { + if (classDecs.length > 0) { + var initializers = []; + var newClass = targetClass; + var name = targetClass.name; + for (var i = classDecs.length - 1; i >= 0; i--) { + var decoratorFinishedRef = { + v: false + }; + try { + var nextNewClass = classDecs[i](newClass, { + kind: "class", + name: name, + addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef) + }); + } finally { + decoratorFinishedRef.v = true; + } + if (nextNewClass !== undefined) { + assertValidReturnValue(10, nextNewClass); + newClass = nextNewClass; + } + } + return [newClass, function () { + for (var i = 0; i < initializers.length; i++) { + initializers[i].call(newClass); + } + }]; + } + } + return function applyDecs2203R(targetClass, memberDecs, classDecs) { + return { + e: applyMemberDecs(targetClass, memberDecs), + get c() { + return applyClassDecs(targetClass, classDecs); + } + }; + }; +} +function applyDecs2203R(targetClass, memberDecs, classDecs) { + return (exports.default = applyDecs2203R = applyDecs2203RFactory())(targetClass, memberDecs, classDecs); +} + +//# sourceMappingURL=applyDecs2203R.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2203R.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2203R.js.map new file mode 100644 index 0000000000000000000000000000000000000000..9d3d5cdd585574b672e99aa3478542042d3ca2b2 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2203R.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_setFunctionName","require","_toPropertyKey","applyDecs2203RFactory","createAddInitializerMethod","initializers","decoratorFinishedRef","addInitializer","initializer","assertNotFinished","assertCallable","push","memberDec","dec","name","desc","kind","isStatic","isPrivate","value","kindStr","ctx","toPropertyKey","static","private","v","get","set","call","access","fnName","Error","fn","hint","TypeError","assertValidReturnValue","type","undefined","init","applyMemberDec","ret","base","decInfo","decs","prefix","setFunctionName","Object","getOwnPropertyDescriptor","newValue","i","length","newInit","instance","ownInitializers","originalInitializer","args","defineProperty","applyMemberDecs","Class","decInfos","protoInitializers","staticInitializers","existingProtoNonFields","Map","existingStaticNonFields","Array","isArray","prototype","existingNonFields","existingKind","pushInitializers","applyClassDecs","targetClass","classDecs","newClass","nextNewClass","applyDecs2203R","memberDecs","e","c","exports","default"],"sources":["../../src/helpers/applyDecs2203R.js"],"sourcesContent":["/* @minVersion 7.20.0 */\n/* @onlyBabel7 */\n\nimport setFunctionName from \"setFunctionName\";\nimport toPropertyKey from \"toPropertyKey\";\n\n/**\n Enums are used in this file, but not assigned to vars to avoid non-hoistable values\n\n CONSTRUCTOR = 0;\n PUBLIC = 1;\n PRIVATE = 2;\n\n FIELD = 0;\n ACCESSOR = 1;\n METHOD = 2;\n GETTER = 3;\n SETTER = 4;\n\n STATIC = 5;\n\n CLASS = 10; // only used in assertValidReturnValue\n*/\n\nfunction applyDecs2203RFactory() {\n function createAddInitializerMethod(initializers, decoratorFinishedRef) {\n return function addInitializer(initializer) {\n assertNotFinished(decoratorFinishedRef, \"addInitializer\");\n assertCallable(initializer, \"An initializer\");\n initializers.push(initializer);\n };\n }\n\n function memberDec(\n dec,\n name,\n desc,\n initializers,\n kind,\n isStatic,\n isPrivate,\n value,\n ) {\n var kindStr;\n\n switch (kind) {\n case 1 /* ACCESSOR */:\n kindStr = \"accessor\";\n break;\n case 2 /* METHOD */:\n kindStr = \"method\";\n break;\n case 3 /* GETTER */:\n kindStr = \"getter\";\n break;\n case 4 /* SETTER */:\n kindStr = \"setter\";\n break;\n default:\n kindStr = \"field\";\n }\n\n var ctx = {\n kind: kindStr,\n name: isPrivate ? \"#\" + name : toPropertyKey(name),\n static: isStatic,\n private: isPrivate,\n };\n\n var decoratorFinishedRef = { v: false };\n\n if (kind !== 0 /* FIELD */) {\n ctx.addInitializer = createAddInitializerMethod(\n initializers,\n decoratorFinishedRef,\n );\n }\n\n var get, set;\n if (kind === 0 /* FIELD */) {\n if (isPrivate) {\n get = desc.get;\n set = desc.set;\n } else {\n get = function () {\n return this[name];\n };\n set = function (v) {\n this[name] = v;\n };\n }\n } else if (kind === 2 /* METHOD */) {\n get = function () {\n return desc.value;\n };\n } else {\n // replace with values that will go through the final getter and setter\n if (kind === 1 /* ACCESSOR */ || kind === 3 /* GETTER */) {\n get = function () {\n return desc.get.call(this);\n };\n }\n\n if (kind === 1 /* ACCESSOR */ || kind === 4 /* SETTER */) {\n set = function (v) {\n desc.set.call(this, v);\n };\n }\n }\n ctx.access =\n get && set ? { get: get, set: set } : get ? { get: get } : { set: set };\n\n try {\n return dec(value, ctx);\n } finally {\n decoratorFinishedRef.v = true;\n }\n }\n\n function assertNotFinished(decoratorFinishedRef, fnName) {\n if (decoratorFinishedRef.v) {\n throw new Error(\n \"attempted to call \" + fnName + \" after decoration was finished\",\n );\n }\n }\n\n function assertCallable(fn, hint) {\n if (typeof fn !== \"function\") {\n throw new TypeError(hint + \" must be a function\");\n }\n }\n\n function assertValidReturnValue(kind, value) {\n var type = typeof value;\n\n if (kind === 1 /* ACCESSOR */) {\n if (type !== \"object\" || value === null) {\n throw new TypeError(\n \"accessor decorators must return an object with get, set, or init properties or void 0\",\n );\n }\n if (value.get !== undefined) {\n assertCallable(value.get, \"accessor.get\");\n }\n if (value.set !== undefined) {\n assertCallable(value.set, \"accessor.set\");\n }\n if (value.init !== undefined) {\n assertCallable(value.init, \"accessor.init\");\n }\n } else if (type !== \"function\") {\n var hint;\n if (kind === 0 /* FIELD */) {\n hint = \"field\";\n } else if (kind === 10 /* CLASS */) {\n hint = \"class\";\n } else {\n hint = \"method\";\n }\n throw new TypeError(\n hint + \" decorators must return a function or void 0\",\n );\n }\n }\n\n function applyMemberDec(\n ret,\n base,\n decInfo,\n name,\n kind,\n isStatic,\n isPrivate,\n initializers,\n ) {\n var decs = decInfo[0];\n\n var desc, init, prefix, value;\n\n if (isPrivate) {\n if (kind === 0 /* FIELD */ || kind === 1 /* ACCESSOR */) {\n desc = {\n get: decInfo[3],\n set: decInfo[4],\n };\n prefix = \"get\";\n } else if (kind === 3 /* GETTER */) {\n desc = {\n get: decInfo[3],\n };\n prefix = \"get\";\n } else if (kind === 4 /* SETTER */) {\n desc = {\n set: decInfo[3],\n };\n prefix = \"set\";\n } else {\n desc = {\n value: decInfo[3],\n };\n }\n if (kind !== 0 /* FIELD */) {\n if (kind === 1 /* ACCESSOR */) {\n setFunctionName(decInfo[4], \"#\" + name, \"set\");\n }\n setFunctionName(decInfo[3], \"#\" + name, prefix);\n }\n } else if (kind !== 0 /* FIELD */) {\n desc = Object.getOwnPropertyDescriptor(base, name);\n }\n\n if (kind === 1 /* ACCESSOR */) {\n value = {\n get: desc.get,\n set: desc.set,\n };\n } else if (kind === 2 /* METHOD */) {\n value = desc.value;\n } else if (kind === 3 /* GETTER */) {\n value = desc.get;\n } else if (kind === 4 /* SETTER */) {\n value = desc.set;\n }\n\n var newValue, get, set;\n\n if (typeof decs === \"function\") {\n newValue = memberDec(\n decs,\n name,\n desc,\n initializers,\n kind,\n isStatic,\n isPrivate,\n value,\n );\n\n if (newValue !== void 0) {\n assertValidReturnValue(kind, newValue);\n\n if (kind === 0 /* FIELD */) {\n init = newValue;\n } else if (kind === 1 /* ACCESSOR */) {\n init = newValue.init;\n get = newValue.get || value.get;\n set = newValue.set || value.set;\n\n value = { get: get, set: set };\n } else {\n value = newValue;\n }\n }\n } else {\n for (var i = decs.length - 1; i >= 0; i--) {\n var dec = decs[i];\n\n newValue = memberDec(\n dec,\n name,\n desc,\n initializers,\n kind,\n isStatic,\n isPrivate,\n value,\n );\n\n if (newValue !== void 0) {\n assertValidReturnValue(kind, newValue);\n var newInit;\n\n if (kind === 0 /* FIELD */) {\n newInit = newValue;\n } else if (kind === 1 /* ACCESSOR */) {\n newInit = newValue.init;\n get = newValue.get || value.get;\n set = newValue.set || value.set;\n\n value = { get: get, set: set };\n } else {\n value = newValue;\n }\n\n if (newInit !== void 0) {\n if (init === void 0) {\n init = newInit;\n } else if (typeof init === \"function\") {\n init = [init, newInit];\n } else {\n init.push(newInit);\n }\n }\n }\n }\n }\n\n if (kind === 0 /* FIELD */ || kind === 1 /* ACCESSOR */) {\n if (init === void 0) {\n // If the initializer was void 0, sub in a dummy initializer\n init = function (instance, init) {\n return init;\n };\n } else if (typeof init !== \"function\") {\n var ownInitializers = init;\n\n init = function (instance, init) {\n var value = init;\n\n for (var i = 0; i < ownInitializers.length; i++) {\n value = ownInitializers[i].call(instance, value);\n }\n\n return value;\n };\n } else {\n var originalInitializer = init;\n\n init = function (instance, init) {\n return originalInitializer.call(instance, init);\n };\n }\n\n ret.push(init);\n }\n\n if (kind !== 0 /* FIELD */) {\n if (kind === 1 /* ACCESSOR */) {\n desc.get = value.get;\n desc.set = value.set;\n } else if (kind === 2 /* METHOD */) {\n desc.value = value;\n } else if (kind === 3 /* GETTER */) {\n desc.get = value;\n } else if (kind === 4 /* SETTER */) {\n desc.set = value;\n }\n\n if (isPrivate) {\n if (kind === 1 /* ACCESSOR */) {\n ret.push(function (instance, args) {\n return value.get.call(instance, args);\n });\n ret.push(function (instance, args) {\n return value.set.call(instance, args);\n });\n } else if (kind === 2 /* METHOD */) {\n ret.push(value);\n } else {\n ret.push(function (instance, args) {\n return value.call(instance, args);\n });\n }\n } else {\n Object.defineProperty(base, name, desc);\n }\n }\n }\n\n function applyMemberDecs(Class, decInfos) {\n var ret = [];\n var protoInitializers;\n var staticInitializers;\n\n var existingProtoNonFields = new Map();\n var existingStaticNonFields = new Map();\n\n for (var i = 0; i < decInfos.length; i++) {\n var decInfo = decInfos[i];\n\n // skip computed property names\n if (!Array.isArray(decInfo)) continue;\n\n var kind = decInfo[1];\n var name = decInfo[2];\n var isPrivate = decInfo.length > 3;\n\n var isStatic = kind >= 5; /* STATIC */\n var base;\n var initializers;\n\n if (isStatic) {\n base = Class;\n kind = kind - 5 /* STATIC */;\n // initialize staticInitializers when we see a non-field static member\n if (kind !== 0 /* FIELD */) {\n staticInitializers = staticInitializers || [];\n initializers = staticInitializers;\n }\n } else {\n base = Class.prototype;\n // initialize protoInitializers when we see a non-field member\n if (kind !== 0 /* FIELD */) {\n protoInitializers = protoInitializers || [];\n initializers = protoInitializers;\n }\n }\n\n if (kind !== 0 /* FIELD */ && !isPrivate) {\n var existingNonFields = isStatic\n ? existingStaticNonFields\n : existingProtoNonFields;\n\n var existingKind = existingNonFields.get(name) || 0;\n\n if (\n existingKind === true ||\n (existingKind === 3 /* GETTER */ && kind !== 4) /* SETTER */ ||\n (existingKind === 4 /* SETTER */ && kind !== 3) /* GETTER */\n ) {\n throw new Error(\n \"Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: \" +\n name,\n );\n } else if (!existingKind && kind > 2 /* METHOD */) {\n existingNonFields.set(name, kind);\n } else {\n existingNonFields.set(name, true);\n }\n }\n\n applyMemberDec(\n ret,\n base,\n decInfo,\n name,\n kind,\n isStatic,\n isPrivate,\n initializers,\n );\n }\n\n pushInitializers(ret, protoInitializers);\n pushInitializers(ret, staticInitializers);\n return ret;\n }\n\n function pushInitializers(ret, initializers) {\n if (initializers) {\n ret.push(function (instance) {\n for (var i = 0; i < initializers.length; i++) {\n initializers[i].call(instance);\n }\n return instance;\n });\n }\n }\n\n function applyClassDecs(targetClass, classDecs) {\n if (classDecs.length > 0) {\n var initializers = [];\n var newClass = targetClass;\n var name = targetClass.name;\n\n for (var i = classDecs.length - 1; i >= 0; i--) {\n var decoratorFinishedRef = { v: false };\n\n try {\n var nextNewClass = classDecs[i](newClass, {\n kind: \"class\",\n name: name,\n addInitializer: createAddInitializerMethod(\n initializers,\n decoratorFinishedRef,\n ),\n });\n } finally {\n decoratorFinishedRef.v = true;\n }\n\n if (nextNewClass !== undefined) {\n assertValidReturnValue(10 /* CLASS */, nextNewClass);\n newClass = nextNewClass;\n }\n }\n\n return [\n newClass,\n function () {\n for (var i = 0; i < initializers.length; i++) {\n initializers[i].call(newClass);\n }\n },\n ];\n }\n // The transformer will not emit assignment when there are no class decorators,\n // so we don't have to return an empty array here.\n }\n\n /**\n Basic usage:\n\n applyDecs(\n Class,\n [\n // member decorators\n [\n dec, // dec or array of decs\n 0, // kind of value being decorated\n 'prop', // name of public prop on class containing the value being decorated,\n '#p', // the name of the private property (if is private, void 0 otherwise),\n ]\n ],\n [\n // class decorators\n dec1, dec2\n ]\n )\n ```\n\n Fully transpiled example:\n\n ```js\n @dec\n class Class {\n @dec\n a = 123;\n\n @dec\n #a = 123;\n\n @dec\n @dec2\n accessor b = 123;\n\n @dec\n accessor #b = 123;\n\n @dec\n c() { console.log('c'); }\n\n @dec\n #c() { console.log('privC'); }\n\n @dec\n get d() { console.log('d'); }\n\n @dec\n get #d() { console.log('privD'); }\n\n @dec\n set e(v) { console.log('e'); }\n\n @dec\n set #e(v) { console.log('privE'); }\n }\n\n\n // becomes\n let initializeInstance;\n let initializeClass;\n\n let initA;\n let initPrivA;\n\n let initB;\n let initPrivB, getPrivB, setPrivB;\n\n let privC;\n let privD;\n let privE;\n\n let Class;\n class _Class {\n static {\n let ret = applyDecs(\n this,\n [\n [dec, 0, 'a'],\n [dec, 0, 'a', (i) => i.#a, (i, v) => i.#a = v],\n [[dec, dec2], 1, 'b'],\n [dec, 1, 'b', (i) => i.#privBData, (i, v) => i.#privBData = v],\n [dec, 2, 'c'],\n [dec, 2, 'c', () => console.log('privC')],\n [dec, 3, 'd'],\n [dec, 3, 'd', () => console.log('privD')],\n [dec, 4, 'e'],\n [dec, 4, 'e', () => console.log('privE')],\n ],\n [\n dec\n ]\n )\n\n initA = ret[0];\n\n initPrivA = ret[1];\n\n initB = ret[2];\n\n initPrivB = ret[3];\n getPrivB = ret[4];\n setPrivB = ret[5];\n\n privC = ret[6];\n\n privD = ret[7];\n\n privE = ret[8];\n\n initializeInstance = ret[9];\n\n Class = ret[10]\n\n initializeClass = ret[11];\n }\n\n a = (initializeInstance(this), initA(this, 123));\n\n #a = initPrivA(this, 123);\n\n #bData = initB(this, 123);\n get b() { return this.#bData }\n set b(v) { this.#bData = v }\n\n #privBData = initPrivB(this, 123);\n get #b() { return getPrivB(this); }\n set #b(v) { setPrivB(this, v); }\n\n c() { console.log('c'); }\n\n #c(...args) { return privC(this, ...args) }\n\n get d() { console.log('d'); }\n\n get #d() { return privD(this); }\n\n set e(v) { console.log('e'); }\n\n set #e(v) { privE(this, v); }\n }\n\n initializeClass(Class);\n */\n\n return function applyDecs2203R(targetClass, memberDecs, classDecs) {\n return {\n e: applyMemberDecs(targetClass, memberDecs),\n // Lazily apply class decorations so that member init locals can be properly bound.\n get c() {\n return applyClassDecs(targetClass, classDecs);\n },\n };\n };\n}\n\nexport default function applyDecs2203R(targetClass, memberDecs, classDecs) {\n return (applyDecs2203R = applyDecs2203RFactory())(\n targetClass,\n memberDecs,\n classDecs,\n );\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2301.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2301.js new file mode 100644 index 0000000000000000000000000000000000000000..aebfbff66eb9b27a4d7e2218019c56737206c01c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2301.js @@ -0,0 +1,421 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = applyDecs2301; +var _checkInRHS = require("checkInRHS"); +var _setFunctionName = require("setFunctionName"); +var _toPropertyKey = require("toPropertyKey"); +function applyDecs2301Factory() { + function createAddInitializerMethod(initializers, decoratorFinishedRef) { + return function addInitializer(initializer) { + assertNotFinished(decoratorFinishedRef, "addInitializer"); + assertCallable(initializer, "An initializer"); + initializers.push(initializer); + }; + } + function assertInstanceIfPrivate(has, target) { + if (!has(target)) { + throw new TypeError("Attempted to access private element on non-instance"); + } + } + function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, value, hasPrivateBrand) { + var kindStr; + switch (kind) { + case 1: + kindStr = "accessor"; + break; + case 2: + kindStr = "method"; + break; + case 3: + kindStr = "getter"; + break; + case 4: + kindStr = "setter"; + break; + default: + kindStr = "field"; + } + var ctx = { + kind: kindStr, + name: isPrivate ? "#" + name : _toPropertyKey(name), + static: isStatic, + private: isPrivate + }; + var decoratorFinishedRef = { + v: false + }; + if (kind !== 0) { + ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef); + } + var get, set; + if (!isPrivate && (kind === 0 || kind === 2)) { + get = function (target) { + return target[name]; + }; + if (kind === 0) { + set = function (target, v) { + target[name] = v; + }; + } + } else if (kind === 2) { + get = function (target) { + assertInstanceIfPrivate(hasPrivateBrand, target); + return desc.value; + }; + } else { + var t = kind === 0 || kind === 1; + if (t || kind === 3) { + if (isPrivate) { + get = function (target) { + assertInstanceIfPrivate(hasPrivateBrand, target); + return desc.get.call(target); + }; + } else { + get = function (target) { + return desc.get.call(target); + }; + } + } + if (t || kind === 4) { + if (isPrivate) { + set = function (target, value) { + assertInstanceIfPrivate(hasPrivateBrand, target); + desc.set.call(target, value); + }; + } else { + set = function (target, value) { + desc.set.call(target, value); + }; + } + } + } + var has = isPrivate ? hasPrivateBrand.bind() : function (target) { + return name in target; + }; + ctx.access = get && set ? { + get: get, + set: set, + has: has + } : get ? { + get: get, + has: has + } : { + set: set, + has: has + }; + try { + return dec(value, ctx); + } finally { + decoratorFinishedRef.v = true; + } + } + function assertNotFinished(decoratorFinishedRef, fnName) { + if (decoratorFinishedRef.v) { + throw new Error("attempted to call " + fnName + " after decoration was finished"); + } + } + function assertCallable(fn, hint) { + if (typeof fn !== "function") { + throw new TypeError(hint + " must be a function"); + } + } + function assertValidReturnValue(kind, value) { + var type = typeof value; + if (kind === 1) { + if (type !== "object" || value === null) { + throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); + } + if (value.get !== undefined) { + assertCallable(value.get, "accessor.get"); + } + if (value.set !== undefined) { + assertCallable(value.set, "accessor.set"); + } + if (value.init !== undefined) { + assertCallable(value.init, "accessor.init"); + } + } else if (type !== "function") { + var hint; + if (kind === 0) { + hint = "field"; + } else if (kind === 10) { + hint = "class"; + } else { + hint = "method"; + } + throw new TypeError(hint + " decorators must return a function or void 0"); + } + } + function curryThis1(fn) { + return function () { + return fn(this); + }; + } + function curryThis2(fn) { + return function (value) { + fn(this, value); + }; + } + function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, hasPrivateBrand) { + var decs = decInfo[0]; + var desc, init, prefix, value; + if (isPrivate) { + if (kind === 0 || kind === 1) { + desc = { + get: curryThis1(decInfo[3]), + set: curryThis2(decInfo[4]) + }; + prefix = "get"; + } else { + if (kind === 3) { + desc = { + get: decInfo[3] + }; + prefix = "get"; + } else if (kind === 4) { + desc = { + set: decInfo[3] + }; + prefix = "set"; + } else { + desc = { + value: decInfo[3] + }; + } + } + if (kind !== 0) { + if (kind === 1) { + _setFunctionName(desc.set, "#" + name, "set"); + } + _setFunctionName(desc[prefix || "value"], "#" + name, prefix); + } + } else if (kind !== 0) { + desc = Object.getOwnPropertyDescriptor(base, name); + } + if (kind === 1) { + value = { + get: desc.get, + set: desc.set + }; + } else if (kind === 2) { + value = desc.value; + } else if (kind === 3) { + value = desc.get; + } else if (kind === 4) { + value = desc.set; + } + var newValue, get, set; + if (typeof decs === "function") { + newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, value, hasPrivateBrand); + if (newValue !== void 0) { + assertValidReturnValue(kind, newValue); + if (kind === 0) { + init = newValue; + } else if (kind === 1) { + init = newValue.init; + get = newValue.get || value.get; + set = newValue.set || value.set; + value = { + get: get, + set: set + }; + } else { + value = newValue; + } + } + } else { + for (var i = decs.length - 1; i >= 0; i--) { + var dec = decs[i]; + newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, value, hasPrivateBrand); + if (newValue !== void 0) { + assertValidReturnValue(kind, newValue); + var newInit; + if (kind === 0) { + newInit = newValue; + } else if (kind === 1) { + newInit = newValue.init; + get = newValue.get || value.get; + set = newValue.set || value.set; + value = { + get: get, + set: set + }; + } else { + value = newValue; + } + if (newInit !== void 0) { + if (init === void 0) { + init = newInit; + } else if (typeof init === "function") { + init = [init, newInit]; + } else { + init.push(newInit); + } + } + } + } + } + if (kind === 0 || kind === 1) { + if (init === void 0) { + init = function (instance, init) { + return init; + }; + } else if (typeof init !== "function") { + var ownInitializers = init; + init = function (instance, init) { + var value = init; + for (var i = 0; i < ownInitializers.length; i++) { + value = ownInitializers[i].call(instance, value); + } + return value; + }; + } else { + var originalInitializer = init; + init = function (instance, init) { + return originalInitializer.call(instance, init); + }; + } + ret.push(init); + } + if (kind !== 0) { + if (kind === 1) { + desc.get = value.get; + desc.set = value.set; + } else if (kind === 2) { + desc.value = value; + } else if (kind === 3) { + desc.get = value; + } else if (kind === 4) { + desc.set = value; + } + if (isPrivate) { + if (kind === 1) { + ret.push(function (instance, args) { + return value.get.call(instance, args); + }); + ret.push(function (instance, args) { + return value.set.call(instance, args); + }); + } else if (kind === 2) { + ret.push(value); + } else { + ret.push(function (instance, args) { + return value.call(instance, args); + }); + } + } else { + Object.defineProperty(base, name, desc); + } + } + } + function applyMemberDecs(Class, decInfos, instanceBrand) { + var ret = []; + var protoInitializers; + var staticInitializers; + var staticBrand; + var existingProtoNonFields = new Map(); + var existingStaticNonFields = new Map(); + for (var i = 0; i < decInfos.length; i++) { + var decInfo = decInfos[i]; + if (!Array.isArray(decInfo)) continue; + var kind = decInfo[1]; + var name = decInfo[2]; + var isPrivate = decInfo.length > 3; + var isStatic = kind >= 5; + var base; + var initializers; + var hasPrivateBrand = instanceBrand; + if (isStatic) { + base = Class; + kind = kind - 5; + if (kind !== 0) { + staticInitializers = staticInitializers || []; + initializers = staticInitializers; + } + if (isPrivate && !staticBrand) { + staticBrand = function (_) { + return _checkInRHS(_) === Class; + }; + } + hasPrivateBrand = staticBrand; + } else { + base = Class.prototype; + if (kind !== 0) { + protoInitializers = protoInitializers || []; + initializers = protoInitializers; + } + } + if (kind !== 0 && !isPrivate) { + var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields; + var existingKind = existingNonFields.get(name) || 0; + if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) { + throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name); + } else if (!existingKind && kind > 2) { + existingNonFields.set(name, kind); + } else { + existingNonFields.set(name, true); + } + } + applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, hasPrivateBrand); + } + pushInitializers(ret, protoInitializers); + pushInitializers(ret, staticInitializers); + return ret; + } + function pushInitializers(ret, initializers) { + if (initializers) { + ret.push(function (instance) { + for (var i = 0; i < initializers.length; i++) { + initializers[i].call(instance); + } + return instance; + }); + } + } + function applyClassDecs(targetClass, classDecs) { + if (classDecs.length > 0) { + var initializers = []; + var newClass = targetClass; + var name = targetClass.name; + for (var i = classDecs.length - 1; i >= 0; i--) { + var decoratorFinishedRef = { + v: false + }; + try { + var nextNewClass = classDecs[i](newClass, { + kind: "class", + name: name, + addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef) + }); + } finally { + decoratorFinishedRef.v = true; + } + if (nextNewClass !== undefined) { + assertValidReturnValue(10, nextNewClass); + newClass = nextNewClass; + } + } + return [newClass, function () { + for (var i = 0; i < initializers.length; i++) { + initializers[i].call(newClass); + } + }]; + } + } + return function applyDecs2301(targetClass, memberDecs, classDecs, instanceBrand) { + return { + e: applyMemberDecs(targetClass, memberDecs, instanceBrand), + get c() { + return applyClassDecs(targetClass, classDecs); + } + }; + }; +} +function applyDecs2301(targetClass, memberDecs, classDecs, instanceBrand) { + return (exports.default = applyDecs2301 = applyDecs2301Factory())(targetClass, memberDecs, classDecs, instanceBrand); +} + +//# sourceMappingURL=applyDecs2301.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2301.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2301.js.map new file mode 100644 index 0000000000000000000000000000000000000000..c493a71d56d879dfd229bc4aac7a60f1f685f7c8 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2301.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_checkInRHS","require","_setFunctionName","_toPropertyKey","applyDecs2301Factory","createAddInitializerMethod","initializers","decoratorFinishedRef","addInitializer","initializer","assertNotFinished","assertCallable","push","assertInstanceIfPrivate","has","target","TypeError","memberDec","dec","name","desc","kind","isStatic","isPrivate","value","hasPrivateBrand","kindStr","ctx","toPropertyKey","static","private","v","get","set","t","call","bind","access","fnName","Error","fn","hint","assertValidReturnValue","type","undefined","init","curryThis1","curryThis2","applyMemberDec","ret","base","decInfo","decs","prefix","setFunctionName","Object","getOwnPropertyDescriptor","newValue","i","length","newInit","instance","ownInitializers","originalInitializer","args","defineProperty","applyMemberDecs","Class","decInfos","instanceBrand","protoInitializers","staticInitializers","staticBrand","existingProtoNonFields","Map","existingStaticNonFields","Array","isArray","_","checkInRHS","prototype","existingNonFields","existingKind","pushInitializers","applyClassDecs","targetClass","classDecs","newClass","nextNewClass","applyDecs2301","memberDecs","e","c","exports","default"],"sources":["../../src/helpers/applyDecs2301.js"],"sourcesContent":["/* @minVersion 7.21.0 */\n/* @onlyBabel7 */\n\nimport checkInRHS from \"checkInRHS\";\nimport setFunctionName from \"setFunctionName\";\nimport toPropertyKey from \"toPropertyKey\";\n\n/**\n Enums are used in this file, but not assigned to vars to avoid non-hoistable values\n\n CONSTRUCTOR = 0;\n PUBLIC = 1;\n PRIVATE = 2;\n\n FIELD = 0;\n ACCESSOR = 1;\n METHOD = 2;\n GETTER = 3;\n SETTER = 4;\n\n STATIC = 5;\n\n CLASS = 10; // only used in assertValidReturnValue\n*/\n\nfunction applyDecs2301Factory() {\n function createAddInitializerMethod(initializers, decoratorFinishedRef) {\n return function addInitializer(initializer) {\n assertNotFinished(decoratorFinishedRef, \"addInitializer\");\n assertCallable(initializer, \"An initializer\");\n initializers.push(initializer);\n };\n }\n\n function assertInstanceIfPrivate(has, target) {\n if (!has(target)) {\n throw new TypeError(\n \"Attempted to access private element on non-instance\",\n );\n }\n }\n\n function memberDec(\n dec,\n name,\n desc,\n initializers,\n kind,\n isStatic,\n isPrivate,\n value,\n hasPrivateBrand,\n ) {\n var kindStr;\n\n switch (kind) {\n case 1 /* ACCESSOR */:\n kindStr = \"accessor\";\n break;\n case 2 /* METHOD */:\n kindStr = \"method\";\n break;\n case 3 /* GETTER */:\n kindStr = \"getter\";\n break;\n case 4 /* SETTER */:\n kindStr = \"setter\";\n break;\n default:\n kindStr = \"field\";\n }\n\n var ctx = {\n kind: kindStr,\n name: isPrivate ? \"#\" + name : toPropertyKey(name),\n static: isStatic,\n private: isPrivate,\n };\n\n var decoratorFinishedRef = { v: false };\n\n if (kind !== 0 /* FIELD */) {\n ctx.addInitializer = createAddInitializerMethod(\n initializers,\n decoratorFinishedRef,\n );\n }\n\n var get, set;\n if (!isPrivate && (kind === 0 /* FIELD */ || kind === 2) /* METHOD */) {\n get = function (target) {\n return target[name];\n };\n if (kind === 0 /* FIELD */) {\n set = function (target, v) {\n target[name] = v;\n };\n }\n } else if (kind === 2 /* METHOD */) {\n // Assert: isPrivate is true.\n get = function (target) {\n assertInstanceIfPrivate(hasPrivateBrand, target);\n return desc.value;\n };\n } else {\n // Assert: If kind === 0, then isPrivate is true.\n var t = kind === 0 /* FIELD */ || kind === 1; /* ACCESSOR */\n if (t || kind === 3 /* GETTER */) {\n if (isPrivate) {\n get = function (target) {\n assertInstanceIfPrivate(hasPrivateBrand, target);\n return desc.get.call(target);\n };\n } else {\n get = function (target) {\n return desc.get.call(target);\n };\n }\n }\n if (t || kind === 4 /* SETTER */) {\n if (isPrivate) {\n set = function (target, value) {\n assertInstanceIfPrivate(hasPrivateBrand, target);\n desc.set.call(target, value);\n };\n } else {\n set = function (target, value) {\n desc.set.call(target, value);\n };\n }\n }\n }\n var has = isPrivate\n ? hasPrivateBrand.bind()\n : function (target) {\n return name in target;\n };\n ctx.access =\n get && set\n ? { get: get, set: set, has: has }\n : get\n ? { get: get, has: has }\n : { set: set, has: has };\n\n try {\n return dec(value, ctx);\n } finally {\n decoratorFinishedRef.v = true;\n }\n }\n\n function assertNotFinished(decoratorFinishedRef, fnName) {\n if (decoratorFinishedRef.v) {\n throw new Error(\n \"attempted to call \" + fnName + \" after decoration was finished\",\n );\n }\n }\n\n function assertCallable(fn, hint) {\n if (typeof fn !== \"function\") {\n throw new TypeError(hint + \" must be a function\");\n }\n }\n\n function assertValidReturnValue(kind, value) {\n var type = typeof value;\n\n if (kind === 1 /* ACCESSOR */) {\n if (type !== \"object\" || value === null) {\n throw new TypeError(\n \"accessor decorators must return an object with get, set, or init properties or void 0\",\n );\n }\n if (value.get !== undefined) {\n assertCallable(value.get, \"accessor.get\");\n }\n if (value.set !== undefined) {\n assertCallable(value.set, \"accessor.set\");\n }\n if (value.init !== undefined) {\n assertCallable(value.init, \"accessor.init\");\n }\n } else if (type !== \"function\") {\n var hint;\n if (kind === 0 /* FIELD */) {\n hint = \"field\";\n } else if (kind === 10 /* CLASS */) {\n hint = \"class\";\n } else {\n hint = \"method\";\n }\n throw new TypeError(\n hint + \" decorators must return a function or void 0\",\n );\n }\n }\n\n function curryThis1(fn) {\n return function () {\n return fn(this);\n };\n }\n function curryThis2(fn) {\n return function (value) {\n fn(this, value);\n };\n }\n\n function applyMemberDec(\n ret,\n base,\n decInfo,\n name,\n kind,\n isStatic,\n isPrivate,\n initializers,\n hasPrivateBrand,\n ) {\n var decs = decInfo[0];\n\n var desc, init, prefix, value;\n\n if (isPrivate) {\n if (kind === 0 /* FIELD */ || kind === 1 /* ACCESSOR */) {\n desc = {\n get: curryThis1(decInfo[3]),\n set: curryThis2(decInfo[4]),\n };\n prefix = \"get\";\n } else {\n if (kind === 3 /* GETTER */) {\n desc = {\n get: decInfo[3],\n };\n prefix = \"get\";\n } else if (kind === 4 /* SETTER */) {\n desc = {\n set: decInfo[3],\n };\n prefix = \"set\";\n } else {\n desc = {\n value: decInfo[3],\n };\n }\n }\n if (kind !== 0 /* FIELD */) {\n if (kind === 1 /* ACCESSOR */) {\n setFunctionName(desc.set, \"#\" + name, \"set\");\n }\n setFunctionName(desc[prefix || \"value\"], \"#\" + name, prefix);\n }\n } else if (kind !== 0 /* FIELD */) {\n desc = Object.getOwnPropertyDescriptor(base, name);\n }\n\n if (kind === 1 /* ACCESSOR */) {\n value = {\n get: desc.get,\n set: desc.set,\n };\n } else if (kind === 2 /* METHOD */) {\n value = desc.value;\n } else if (kind === 3 /* GETTER */) {\n value = desc.get;\n } else if (kind === 4 /* SETTER */) {\n value = desc.set;\n }\n\n var newValue, get, set;\n\n if (typeof decs === \"function\") {\n newValue = memberDec(\n decs,\n name,\n desc,\n initializers,\n kind,\n isStatic,\n isPrivate,\n value,\n hasPrivateBrand,\n );\n\n if (newValue !== void 0) {\n assertValidReturnValue(kind, newValue);\n\n if (kind === 0 /* FIELD */) {\n init = newValue;\n } else if (kind === 1 /* ACCESSOR */) {\n init = newValue.init;\n get = newValue.get || value.get;\n set = newValue.set || value.set;\n\n value = { get: get, set: set };\n } else {\n value = newValue;\n }\n }\n } else {\n for (var i = decs.length - 1; i >= 0; i--) {\n var dec = decs[i];\n\n newValue = memberDec(\n dec,\n name,\n desc,\n initializers,\n kind,\n isStatic,\n isPrivate,\n value,\n hasPrivateBrand,\n );\n\n if (newValue !== void 0) {\n assertValidReturnValue(kind, newValue);\n var newInit;\n\n if (kind === 0 /* FIELD */) {\n newInit = newValue;\n } else if (kind === 1 /* ACCESSOR */) {\n newInit = newValue.init;\n get = newValue.get || value.get;\n set = newValue.set || value.set;\n\n value = { get: get, set: set };\n } else {\n value = newValue;\n }\n\n if (newInit !== void 0) {\n if (init === void 0) {\n init = newInit;\n } else if (typeof init === \"function\") {\n init = [init, newInit];\n } else {\n init.push(newInit);\n }\n }\n }\n }\n }\n\n if (kind === 0 /* FIELD */ || kind === 1 /* ACCESSOR */) {\n if (init === void 0) {\n // If the initializer was void 0, sub in a dummy initializer\n init = function (instance, init) {\n return init;\n };\n } else if (typeof init !== \"function\") {\n var ownInitializers = init;\n\n init = function (instance, init) {\n var value = init;\n\n for (var i = 0; i < ownInitializers.length; i++) {\n value = ownInitializers[i].call(instance, value);\n }\n\n return value;\n };\n } else {\n var originalInitializer = init;\n\n init = function (instance, init) {\n return originalInitializer.call(instance, init);\n };\n }\n\n ret.push(init);\n }\n\n if (kind !== 0 /* FIELD */) {\n if (kind === 1 /* ACCESSOR */) {\n desc.get = value.get;\n desc.set = value.set;\n } else if (kind === 2 /* METHOD */) {\n desc.value = value;\n } else if (kind === 3 /* GETTER */) {\n desc.get = value;\n } else if (kind === 4 /* SETTER */) {\n desc.set = value;\n }\n\n if (isPrivate) {\n if (kind === 1 /* ACCESSOR */) {\n ret.push(function (instance, args) {\n return value.get.call(instance, args);\n });\n ret.push(function (instance, args) {\n return value.set.call(instance, args);\n });\n } else if (kind === 2 /* METHOD */) {\n ret.push(value);\n } else {\n ret.push(function (instance, args) {\n return value.call(instance, args);\n });\n }\n } else {\n Object.defineProperty(base, name, desc);\n }\n }\n }\n\n function applyMemberDecs(Class, decInfos, instanceBrand) {\n var ret = [];\n var protoInitializers;\n var staticInitializers;\n var staticBrand;\n\n var existingProtoNonFields = new Map();\n var existingStaticNonFields = new Map();\n\n for (var i = 0; i < decInfos.length; i++) {\n var decInfo = decInfos[i];\n\n // skip computed property names\n if (!Array.isArray(decInfo)) continue;\n\n var kind = decInfo[1];\n var name = decInfo[2];\n var isPrivate = decInfo.length > 3;\n\n var isStatic = kind >= 5; /* STATIC */\n var base;\n var initializers;\n var hasPrivateBrand = instanceBrand;\n\n if (isStatic) {\n base = Class;\n kind = kind - 5 /* STATIC */;\n // initialize staticInitializers when we see a non-field static member\n if (kind !== 0 /* FIELD */) {\n staticInitializers = staticInitializers || [];\n initializers = staticInitializers;\n }\n if (isPrivate && !staticBrand) {\n staticBrand = function (_) {\n return checkInRHS(_) === Class;\n };\n }\n hasPrivateBrand = staticBrand;\n } else {\n base = Class.prototype;\n // initialize protoInitializers when we see a non-field member\n if (kind !== 0 /* FIELD */) {\n protoInitializers = protoInitializers || [];\n initializers = protoInitializers;\n }\n }\n\n if (kind !== 0 /* FIELD */ && !isPrivate) {\n var existingNonFields = isStatic\n ? existingStaticNonFields\n : existingProtoNonFields;\n\n var existingKind = existingNonFields.get(name) || 0;\n\n if (\n existingKind === true ||\n (existingKind === 3 /* GETTER */ && kind !== 4) /* SETTER */ ||\n (existingKind === 4 /* SETTER */ && kind !== 3) /* GETTER */\n ) {\n throw new Error(\n \"Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: \" +\n name,\n );\n } else if (!existingKind && kind > 2 /* METHOD */) {\n existingNonFields.set(name, kind);\n } else {\n existingNonFields.set(name, true);\n }\n }\n\n applyMemberDec(\n ret,\n base,\n decInfo,\n name,\n kind,\n isStatic,\n isPrivate,\n initializers,\n hasPrivateBrand,\n );\n }\n\n pushInitializers(ret, protoInitializers);\n pushInitializers(ret, staticInitializers);\n return ret;\n }\n\n function pushInitializers(ret, initializers) {\n if (initializers) {\n ret.push(function (instance) {\n for (var i = 0; i < initializers.length; i++) {\n initializers[i].call(instance);\n }\n return instance;\n });\n }\n }\n\n function applyClassDecs(targetClass, classDecs) {\n if (classDecs.length > 0) {\n var initializers = [];\n var newClass = targetClass;\n var name = targetClass.name;\n\n for (var i = classDecs.length - 1; i >= 0; i--) {\n var decoratorFinishedRef = { v: false };\n\n try {\n var nextNewClass = classDecs[i](newClass, {\n kind: \"class\",\n name: name,\n addInitializer: createAddInitializerMethod(\n initializers,\n decoratorFinishedRef,\n ),\n });\n } finally {\n decoratorFinishedRef.v = true;\n }\n\n if (nextNewClass !== undefined) {\n assertValidReturnValue(10 /* CLASS */, nextNewClass);\n newClass = nextNewClass;\n }\n }\n\n return [\n newClass,\n function () {\n for (var i = 0; i < initializers.length; i++) {\n initializers[i].call(newClass);\n }\n },\n ];\n }\n // The transformer will not emit assignment when there are no class decorators,\n // so we don't have to return an empty array here.\n }\n\n /**\n Basic usage:\n\n applyDecs(\n Class,\n [\n // member decorators\n [\n dec, // dec or array of decs\n 0, // kind of value being decorated\n 'prop', // name of public prop on class containing the value being decorated,\n '#p', // the name of the private property (if is private, void 0 otherwise),\n ]\n ],\n [\n // class decorators\n dec1, dec2\n ]\n )\n ```\n\n Fully transpiled example:\n\n ```js\n @dec\n class Class {\n @dec\n a = 123;\n\n @dec\n #a = 123;\n\n @dec\n @dec2\n accessor b = 123;\n\n @dec\n accessor #b = 123;\n\n @dec\n c() { console.log('c'); }\n\n @dec\n #c() { console.log('privC'); }\n\n @dec\n get d() { console.log('d'); }\n\n @dec\n get #d() { console.log('privD'); }\n\n @dec\n set e(v) { console.log('e'); }\n\n @dec\n set #e(v) { console.log('privE'); }\n }\n\n\n // becomes\n let initializeInstance;\n let initializeClass;\n\n let initA;\n let initPrivA;\n\n let initB;\n let initPrivB, getPrivB, setPrivB;\n\n let privC;\n let privD;\n let privE;\n\n let Class;\n class _Class {\n static {\n let ret = applyDecs(\n this,\n [\n [dec, 0, 'a'],\n [dec, 0, 'a', (i) => i.#a, (i, v) => i.#a = v],\n [[dec, dec2], 1, 'b'],\n [dec, 1, 'b', (i) => i.#privBData, (i, v) => i.#privBData = v],\n [dec, 2, 'c'],\n [dec, 2, 'c', () => console.log('privC')],\n [dec, 3, 'd'],\n [dec, 3, 'd', () => console.log('privD')],\n [dec, 4, 'e'],\n [dec, 4, 'e', () => console.log('privE')],\n ],\n [\n dec\n ]\n )\n\n initA = ret[0];\n\n initPrivA = ret[1];\n\n initB = ret[2];\n\n initPrivB = ret[3];\n getPrivB = ret[4];\n setPrivB = ret[5];\n\n privC = ret[6];\n\n privD = ret[7];\n\n privE = ret[8];\n\n initializeInstance = ret[9];\n\n Class = ret[10]\n\n initializeClass = ret[11];\n }\n\n a = (initializeInstance(this), initA(this, 123));\n\n #a = initPrivA(this, 123);\n\n #bData = initB(this, 123);\n get b() { return this.#bData }\n set b(v) { this.#bData = v }\n\n #privBData = initPrivB(this, 123);\n get #b() { return getPrivB(this); }\n set #b(v) { setPrivB(this, v); }\n\n c() { console.log('c'); }\n\n #c(...args) { return privC(this, ...args) }\n\n get d() { console.log('d'); }\n\n get #d() { return privD(this); }\n\n set e(v) { console.log('e'); }\n\n set #e(v) { privE(this, v); }\n }\n\n initializeClass(Class);\n */\n return function applyDecs2301(\n targetClass,\n memberDecs,\n classDecs,\n instanceBrand,\n ) {\n return {\n e: applyMemberDecs(targetClass, memberDecs, instanceBrand),\n // Lazily apply class decorations so that member init locals can be properly bound.\n get c() {\n return applyClassDecs(targetClass, classDecs);\n },\n };\n };\n}\n\nexport default function applyDecs2301(\n targetClass,\n memberDecs,\n classDecs,\n instanceBrand,\n) {\n return (applyDecs2301 = applyDecs2301Factory())(\n targetClass,\n memberDecs,\n classDecs,\n instanceBrand,\n );\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2305.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2305.js new file mode 100644 index 0000000000000000000000000000000000000000..d2940aebc27ea64df529836e56b5f0e3c8a1417e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2305.js @@ -0,0 +1,235 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = applyDecs2305; +var _checkInRHS = require("./checkInRHS.js"); +var _setFunctionName = require("./setFunctionName.js"); +var _toPropertyKey = require("./toPropertyKey.js"); +function applyDecs2305(targetClass, memberDecs, classDecs, classDecsHaveThis, instanceBrand, parentClass) { + function _bindPropCall(obj, name, before) { + return function (_this, value) { + if (before) { + before(_this); + } + return obj[name].call(_this, value); + }; + } + function runInitializers(initializers, value) { + for (var i = 0; i < initializers.length; i++) { + initializers[i].call(value); + } + return value; + } + function assertCallable(fn, hint1, hint2, throwUndefined) { + if (typeof fn !== "function") { + if (throwUndefined || fn !== void 0) { + throw new TypeError(hint1 + " must " + (hint2 || "be") + " a function" + (throwUndefined ? "" : " or undefined")); + } + } + return fn; + } + function applyDec(Class, decInfo, decoratorsHaveThis, name, kind, metadata, initializers, ret, isStatic, isPrivate, isField, isAccessor, hasPrivateBrand) { + function assertInstanceIfPrivate(target) { + if (!hasPrivateBrand(target)) { + throw new TypeError("Attempted to access private element on non-instance"); + } + } + var decs = decInfo[0], + decVal = decInfo[3], + _, + isClass = !ret; + if (!isClass) { + if (!decoratorsHaveThis && !Array.isArray(decs)) { + decs = [decs]; + } + var desc = {}, + init = [], + key = kind === 3 ? "get" : kind === 4 || isAccessor ? "set" : "value"; + if (isPrivate) { + if (isField || isAccessor) { + desc = { + get: (0, _setFunctionName.default)(function () { + return decVal(this); + }, name, "get"), + set: function (value) { + decInfo[4](this, value); + } + }; + } else { + desc[key] = decVal; + } + if (!isField) { + (0, _setFunctionName.default)(desc[key], name, kind === 2 ? "" : key); + } + } else if (!isField) { + desc = Object.getOwnPropertyDescriptor(Class, name); + } + } + var newValue = Class; + for (var i = decs.length - 1; i >= 0; i -= decoratorsHaveThis ? 2 : 1) { + var dec = decs[i], + decThis = decoratorsHaveThis ? decs[i - 1] : void 0; + var decoratorFinishedRef = {}; + var ctx = { + kind: ["field", "accessor", "method", "getter", "setter", "class"][kind], + name: name, + metadata: metadata, + addInitializer: function (decoratorFinishedRef, initializer) { + if (decoratorFinishedRef.v) { + throw new Error("attempted to call addInitializer after decoration was finished"); + } + assertCallable(initializer, "An initializer", "be", true); + initializers.push(initializer); + }.bind(null, decoratorFinishedRef) + }; + try { + if (isClass) { + if (_ = assertCallable(dec.call(decThis, newValue, ctx), "class decorators", "return")) { + newValue = _; + } + } else { + ctx["static"] = isStatic; + ctx["private"] = isPrivate; + var get, set; + if (!isPrivate) { + get = function (target) { + return target[name]; + }; + if (kind < 2 || kind === 4) { + set = function (target, v) { + target[name] = v; + }; + } + } else if (kind === 2) { + get = function (_this) { + assertInstanceIfPrivate(_this); + return desc.value; + }; + } else { + if (kind < 4) { + get = _bindPropCall(desc, "get", assertInstanceIfPrivate); + } + if (kind !== 3) { + set = _bindPropCall(desc, "set", assertInstanceIfPrivate); + } + } + var access = ctx.access = { + has: isPrivate ? hasPrivateBrand.bind() : function (target) { + return name in target; + } + }; + if (get) access.get = get; + if (set) access.set = set; + newValue = dec.call(decThis, isAccessor ? { + get: desc.get, + set: desc.set + } : desc[key], ctx); + if (isAccessor) { + if (typeof newValue === "object" && newValue) { + if (_ = assertCallable(newValue.get, "accessor.get")) { + desc.get = _; + } + if (_ = assertCallable(newValue.set, "accessor.set")) { + desc.set = _; + } + if (_ = assertCallable(newValue.init, "accessor.init")) { + init.push(_); + } + } else if (newValue !== void 0) { + throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); + } + } else if (assertCallable(newValue, (isField ? "field" : "method") + " decorators", "return")) { + if (isField) { + init.push(newValue); + } else { + desc[key] = newValue; + } + } + } + } finally { + decoratorFinishedRef.v = true; + } + } + if (isField || isAccessor) { + ret.push(function (instance, value) { + for (var i = init.length - 1; i >= 0; i--) { + value = init[i].call(instance, value); + } + return value; + }); + } + if (!isField && !isClass) { + if (isPrivate) { + if (isAccessor) { + ret.push(_bindPropCall(desc, "get"), _bindPropCall(desc, "set")); + } else { + ret.push(kind === 2 ? desc[key] : _bindPropCall.call.bind(desc[key])); + } + } else { + Object.defineProperty(Class, name, desc); + } + } + return newValue; + } + function applyMemberDecs(Class, decInfos, instanceBrand, metadata) { + var ret = []; + var protoInitializers; + var staticInitializers; + var staticBrand = function (_) { + return (0, _checkInRHS.default)(_) === Class; + }; + var existingNonFields = new Map(); + function pushInitializers(initializers) { + if (initializers) { + ret.push(runInitializers.bind(null, initializers)); + } + } + for (var i = 0; i < decInfos.length; i++) { + var decInfo = decInfos[i]; + if (!Array.isArray(decInfo)) continue; + var kind = decInfo[1]; + var name = decInfo[2]; + var isPrivate = decInfo.length > 3; + var decoratorsHaveThis = kind & 16; + var isStatic = !!(kind & 8); + kind &= 7; + var isField = kind === 0; + var key = name + "/" + isStatic; + if (!isField && !isPrivate) { + var existingKind = existingNonFields.get(key); + if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) { + throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name); + } + existingNonFields.set(key, kind > 2 ? kind : true); + } + applyDec(isStatic ? Class : Class.prototype, decInfo, decoratorsHaveThis, isPrivate ? "#" + name : (0, _toPropertyKey.default)(name), kind, metadata, isStatic ? staticInitializers = staticInitializers || [] : protoInitializers = protoInitializers || [], ret, isStatic, isPrivate, isField, kind === 1, isStatic && isPrivate ? staticBrand : instanceBrand); + } + pushInitializers(protoInitializers); + pushInitializers(staticInitializers); + return ret; + } + function defineMetadata(Class, metadata) { + return Object.defineProperty(Class, Symbol.metadata || Symbol["for"]("Symbol.metadata"), { + configurable: true, + enumerable: true, + value: metadata + }); + } + if (arguments.length >= 6) { + var parentMetadata = parentClass[Symbol.metadata || Symbol["for"]("Symbol.metadata")]; + } + var metadata = Object.create(parentMetadata == null ? null : parentMetadata); + var e = applyMemberDecs(targetClass, memberDecs, instanceBrand, metadata); + if (!classDecs.length) defineMetadata(targetClass, metadata); + return { + e: e, + get c() { + var initializers = []; + return classDecs.length && [defineMetadata(applyDec(targetClass, [classDecs], classDecsHaveThis, targetClass.name, 5, metadata, initializers), metadata), runInitializers.bind(null, initializers, targetClass)]; + } + }; +} + +//# sourceMappingURL=applyDecs2305.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2305.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2305.js.map new file mode 100644 index 0000000000000000000000000000000000000000..59502775ff20ac02400511d1fdc1434e81f44638 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2305.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_checkInRHS","require","_setFunctionName","_toPropertyKey","applyDecs2305","targetClass","memberDecs","classDecs","classDecsHaveThis","instanceBrand","parentClass","_bindPropCall","obj","name","before","_this","value","call","runInitializers","initializers","i","length","assertCallable","fn","hint1","hint2","throwUndefined","TypeError","applyDec","Class","decInfo","decoratorsHaveThis","kind","metadata","ret","isStatic","isPrivate","isField","isAccessor","hasPrivateBrand","assertInstanceIfPrivate","target","decs","decVal","_","isClass","Array","isArray","desc","init","key","get","setFunctionName","set","Object","getOwnPropertyDescriptor","newValue","dec","decThis","decoratorFinishedRef","ctx","addInitializer","initializer","v","Error","push","bind","access","has","instance","defineProperty","applyMemberDecs","decInfos","protoInitializers","staticInitializers","staticBrand","checkInRHS","existingNonFields","Map","pushInitializers","existingKind","prototype","toPropertyKey","defineMetadata","Symbol","configurable","enumerable","arguments","parentMetadata","create","e","c"],"sources":["../../src/helpers/applyDecs2305.ts"],"sourcesContent":["/* @minVersion 7.21.0 */\n/* @mangleFns */\n/* @onlyBabel7 */\n\nimport checkInRHS from \"./checkInRHS.ts\";\nimport setFunctionName from \"./setFunctionName.ts\";\nimport toPropertyKey from \"./toPropertyKey.ts\";\n\nconst enum PROP_KIND {\n FIELD = 0,\n ACCESSOR = 1,\n METHOD = 2,\n GETTER = 3,\n SETTER = 4,\n CLASS = 5,\n\n STATIC = 8,\n\n DECORATORS_HAVE_THIS = 16,\n}\n\ntype DecoratorFinishedRef = { v?: boolean };\ntype DecoratorContextAccess = {\n get?: (target: object) => any;\n set?: (target: object, value: any) => void;\n has: (target: object) => boolean;\n};\ntype DecoratorContext = {\n kind: \"accessor\" | \"method\" | \"getter\" | \"setter\" | \"field\" | \"class\";\n name: string;\n static?: boolean;\n private?: boolean;\n access?: DecoratorContextAccess;\n metadata?: any;\n addInitializer?: (initializer: Function) => void;\n};\ntype DecoratorInfo =\n | [\n decs: Function | Function[],\n kind: PROP_KIND,\n name: string,\n any?,\n Function?,\n ]\n | [classDecs: Function[]];\n\n/**\n Basic usage:\n\n applyDecs(\n Class,\n [\n // member decorators\n [\n decs, // dec, or array of decs, or array of this values and decs\n 0, // kind of value being decorated\n 'prop', // name of public prop on class containing the value being decorated,\n '#p', // the name of the private property (if is private, void 0 otherwise),\n ]\n ],\n [\n // class decorators\n dec1, dec2\n ]\n )\n ```\n\n Fully transpiled example:\n\n ```js\n @dec\n class Class {\n @dec\n a = 123;\n\n @dec\n #a = 123;\n\n @dec\n @dec2\n accessor b = 123;\n\n @dec\n accessor #b = 123;\n\n @dec\n c() { console.log('c'); }\n\n @dec\n #c() { console.log('privC'); }\n\n @dec\n get d() { console.log('d'); }\n\n @dec\n get #d() { console.log('privD'); }\n\n @dec\n set e(v) { console.log('e'); }\n\n @dec\n set #e(v) { console.log('privE'); }\n }\n\n\n // becomes\n let initializeInstance;\n let initializeClass;\n\n let initA;\n let initPrivA;\n\n let initB;\n let initPrivB, getPrivB, setPrivB;\n\n let privC;\n let privD;\n let privE;\n\n let Class;\n class _Class {\n static {\n let ret = applyDecs(\n this,\n [\n [dec, 0, 'a'],\n [dec, 0, 'a', (i) => i.#a, (i, v) => i.#a = v],\n [[dec, dec2], 1, 'b'],\n [dec, 1, 'b', (i) => i.#privBData, (i, v) => i.#privBData = v],\n [dec, 2, 'c'],\n [dec, 2, 'c', () => console.log('privC')],\n [dec, 3, 'd'],\n [dec, 3, 'd', () => console.log('privD')],\n [dec, 4, 'e'],\n [dec, 4, 'e', () => console.log('privE')],\n ],\n [\n dec\n ]\n );\n\n initA = ret[0];\n\n initPrivA = ret[1];\n\n initB = ret[2];\n\n initPrivB = ret[3];\n getPrivB = ret[4];\n setPrivB = ret[5];\n\n privC = ret[6];\n\n privD = ret[7];\n\n privE = ret[8];\n\n initializeInstance = ret[9];\n\n Class = ret[10]\n\n initializeClass = ret[11];\n }\n\n a = (initializeInstance(this), initA(this, 123));\n\n #a = initPrivA(this, 123);\n\n #bData = initB(this, 123);\n get b() { return this.#bData }\n set b(v) { this.#bData = v }\n\n #privBData = initPrivB(this, 123);\n get #b() { return getPrivB(this); }\n set #b(v) { setPrivB(this, v); }\n\n c() { console.log('c'); }\n\n #c(...args) { return privC(this, ...args) }\n\n get d() { console.log('d'); }\n\n get #d() { return privD(this); }\n\n set e(v) { console.log('e'); }\n\n set #e(v) { privE(this, v); }\n }\n\n initializeClass(Class);\n */\n\nexport default /* @no-mangle */ function applyDecs2305(\n targetClass: any,\n memberDecs: DecoratorInfo[],\n classDecs: Function[],\n classDecsHaveThis: number,\n instanceBrand: Function,\n parentClass: any,\n) {\n function _bindPropCall(obj: any, name: string, before?: Function) {\n return function (_this: any, value?: any) {\n if (before) {\n before(_this);\n }\n return obj[name].call(_this, value);\n };\n }\n\n function runInitializers(initializers: Function[], value: any) {\n for (var i = 0; i < initializers.length; i++) {\n initializers[i].call(value);\n }\n return value;\n }\n\n function assertCallable(\n fn: any,\n hint1: string,\n hint2?: string,\n throwUndefined?: boolean,\n ) {\n if (typeof fn !== \"function\") {\n if (throwUndefined || fn !== void 0) {\n throw new TypeError(\n hint1 +\n \" must \" +\n (hint2 || \"be\") +\n \" a function\" +\n (throwUndefined ? \"\" : \" or undefined\"),\n );\n }\n }\n return fn;\n }\n\n /* @no-mangle */\n function applyDec(\n Class: any,\n decInfo: DecoratorInfo,\n decoratorsHaveThis: number,\n name: string,\n kind: PROP_KIND,\n metadata: any,\n initializers: Function[],\n ret?: Function[],\n isStatic?: boolean,\n isPrivate?: boolean,\n isField?: boolean,\n isAccessor?: boolean,\n hasPrivateBrand?: Function,\n ) {\n function assertInstanceIfPrivate(target: any) {\n if (!hasPrivateBrand(target)) {\n throw new TypeError(\n \"Attempted to access private element on non-instance\",\n );\n }\n }\n\n var decs = decInfo[0],\n decVal = decInfo[3],\n _: any,\n isClass = !ret;\n\n if (!isClass) {\n if (!decoratorsHaveThis && !Array.isArray(decs)) {\n decs = [decs];\n }\n\n var desc: PropertyDescriptor = {},\n init: Function[] = [],\n key: \"get\" | \"set\" | \"value\" =\n kind === PROP_KIND.GETTER\n ? \"get\"\n : kind === PROP_KIND.SETTER || isAccessor\n ? \"set\"\n : \"value\";\n\n if (isPrivate) {\n if (isField || isAccessor) {\n desc = {\n get: setFunctionName(\n function (this: any) {\n return decVal(this);\n },\n name,\n \"get\",\n ),\n set: function (this: any, value: any) {\n decInfo[4](this, value);\n },\n };\n } else {\n desc[key] = decVal;\n }\n\n if (!isField) {\n setFunctionName(\n desc[key],\n name,\n kind === PROP_KIND.METHOD ? \"\" : key,\n );\n }\n } else if (!isField) {\n desc = Object.getOwnPropertyDescriptor(Class, name);\n }\n }\n\n var newValue = Class;\n\n for (var i = decs.length - 1; i >= 0; i -= decoratorsHaveThis ? 2 : 1) {\n var dec = (decs as Function[])[i],\n decThis = decoratorsHaveThis ? (decs as any[])[i - 1] : void 0;\n\n var decoratorFinishedRef: DecoratorFinishedRef = {};\n var ctx: DecoratorContext = {\n kind: [\"field\", \"accessor\", \"method\", \"getter\", \"setter\", \"class\"][\n kind\n ] as any,\n\n name: name,\n metadata: metadata,\n addInitializer: function (\n decoratorFinishedRef: DecoratorFinishedRef,\n initializer: Function,\n ) {\n if (decoratorFinishedRef.v) {\n throw new Error(\n \"attempted to call addInitializer after decoration was finished\",\n );\n }\n assertCallable(initializer, \"An initializer\", \"be\", true);\n initializers.push(initializer);\n }.bind(null, decoratorFinishedRef),\n };\n\n try {\n if (isClass) {\n if (\n (_ = assertCallable(\n dec.call(decThis, newValue, ctx),\n \"class decorators\",\n \"return\",\n ))\n ) {\n newValue = _;\n }\n } else {\n ctx[\"static\"] = isStatic;\n ctx[\"private\"] = isPrivate;\n\n var get, set;\n if (!isPrivate) {\n get = function (target: any) {\n return target[name];\n };\n if (kind < PROP_KIND.METHOD || kind === PROP_KIND.SETTER) {\n set = function (target: any, v: any) {\n target[name] = v;\n };\n }\n } else if (kind === PROP_KIND.METHOD) {\n get = function (_this: any) {\n assertInstanceIfPrivate(_this);\n return desc.value;\n };\n } else {\n if (kind < PROP_KIND.SETTER) {\n get = _bindPropCall(desc, \"get\", assertInstanceIfPrivate);\n }\n if (kind !== PROP_KIND.GETTER) {\n set = _bindPropCall(desc, \"set\", assertInstanceIfPrivate);\n }\n }\n\n var access: DecoratorContextAccess = (ctx.access = {\n has: isPrivate\n ? // @ts-expect-error no thisArg\n hasPrivateBrand.bind()\n : function (target: object) {\n return name in target;\n },\n });\n if (get) access.get = get;\n if (set) access.set = set;\n\n newValue = dec.call(\n decThis,\n isAccessor\n ? {\n get: desc.get,\n set: desc.set,\n }\n : desc[key],\n ctx,\n );\n\n if (isAccessor) {\n if (typeof newValue === \"object\" && newValue) {\n if ((_ = assertCallable(newValue.get, \"accessor.get\"))) {\n desc.get = _;\n }\n if ((_ = assertCallable(newValue.set, \"accessor.set\"))) {\n desc.set = _;\n }\n if ((_ = assertCallable(newValue.init, \"accessor.init\"))) {\n init.push(_);\n }\n } else if (newValue !== void 0) {\n throw new TypeError(\n \"accessor decorators must return an object with get, set, or init properties or void 0\",\n );\n }\n } else if (\n assertCallable(\n newValue,\n (isField ? \"field\" : \"method\") + \" decorators\",\n \"return\",\n )\n ) {\n if (isField) {\n init.push(newValue);\n } else {\n desc[key] = newValue;\n }\n }\n }\n } finally {\n decoratorFinishedRef.v = true;\n }\n }\n\n if (isField || isAccessor) {\n ret.push(function (instance: any, value: any) {\n for (var i = init.length - 1; i >= 0; i--) {\n value = init[i].call(instance, value);\n }\n return value;\n });\n }\n\n if (!isField && !isClass) {\n if (isPrivate) {\n if (isAccessor) {\n ret.push(_bindPropCall(desc, \"get\"), _bindPropCall(desc, \"set\"));\n } else {\n ret.push(\n kind === PROP_KIND.METHOD\n ? desc[key]\n : _bindPropCall.call.bind(desc[key]),\n );\n }\n } else {\n Object.defineProperty(Class, name, desc);\n }\n }\n return newValue;\n }\n\n /* @no-mangle */\n function applyMemberDecs(\n Class: any,\n decInfos: DecoratorInfo[],\n instanceBrand: Function,\n metadata: any,\n ) {\n var ret: Function[] = [];\n var protoInitializers: Function[];\n var staticInitializers: Function[];\n var staticBrand = function (_: any) {\n return checkInRHS(_) === Class;\n };\n\n var existingNonFields = new Map();\n\n function pushInitializers(initializers: Function[]) {\n if (initializers) {\n ret.push(runInitializers.bind(null, initializers));\n }\n }\n\n for (var i = 0; i < decInfos.length; i++) {\n var decInfo = decInfos[i];\n\n // skip computed property names\n if (!Array.isArray(decInfo)) continue;\n\n var kind = decInfo[1];\n var name = decInfo[2];\n var isPrivate = decInfo.length > 3;\n\n var decoratorsHaveThis = kind & PROP_KIND.DECORATORS_HAVE_THIS;\n var isStatic = !!(kind & PROP_KIND.STATIC);\n\n kind &= 7; /* 0b111 */\n\n var isField = kind === PROP_KIND.FIELD;\n\n var key = name + \"/\" + isStatic;\n\n if (!isField && !isPrivate) {\n var existingKind = existingNonFields.get(key);\n\n if (\n existingKind === true ||\n (existingKind === PROP_KIND.GETTER && kind !== PROP_KIND.SETTER) ||\n (existingKind === PROP_KIND.SETTER && kind !== PROP_KIND.GETTER)\n ) {\n throw new Error(\n \"Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: \" +\n name,\n );\n }\n existingNonFields.set(key, kind > PROP_KIND.METHOD ? kind : true);\n }\n\n applyDec(\n isStatic ? Class : Class.prototype,\n decInfo,\n decoratorsHaveThis,\n isPrivate ? \"#\" + name : (toPropertyKey(name) as string),\n kind,\n metadata,\n isStatic\n ? (staticInitializers = staticInitializers || [])\n : (protoInitializers = protoInitializers || []),\n ret,\n isStatic,\n isPrivate,\n isField,\n kind === PROP_KIND.ACCESSOR,\n isStatic && isPrivate ? staticBrand : instanceBrand,\n );\n }\n\n pushInitializers(protoInitializers);\n pushInitializers(staticInitializers);\n return ret;\n }\n\n function defineMetadata(Class: any, metadata: any) {\n return Object.defineProperty(\n Class,\n Symbol.metadata || Symbol[\"for\"](\"Symbol.metadata\"),\n { configurable: true, enumerable: true, value: metadata },\n );\n }\n\n if (arguments.length >= 6) {\n var parentMetadata =\n parentClass[Symbol.metadata || Symbol[\"for\"](\"Symbol.metadata\")];\n }\n var metadata = Object.create(parentMetadata == null ? null : parentMetadata);\n var e = applyMemberDecs(targetClass, memberDecs, instanceBrand, metadata);\n if (!classDecs.length) defineMetadata(targetClass, metadata);\n return {\n e: e,\n // Lazily apply class decorations so that member init locals can be properly bound.\n get c() {\n // The transformer will not emit assignment when there are no class decorators,\n // so we don't have to return an empty array here.\n var initializers: Function[] = [];\n return (\n classDecs.length && [\n defineMetadata(\n applyDec(\n targetClass,\n [classDecs],\n classDecsHaveThis,\n targetClass.name,\n PROP_KIND.CLASS,\n metadata,\n initializers,\n ),\n metadata,\n ),\n runInitializers.bind(null, initializers, targetClass),\n ]\n );\n },\n };\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2311.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2311.js new file mode 100644 index 0000000000000000000000000000000000000000..971714be4976282d27e0e9bae488d8630361154e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2311.js @@ -0,0 +1,236 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = applyDecs2311; +var _checkInRHS = require("./checkInRHS.js"); +var _setFunctionName = require("./setFunctionName.js"); +var _toPropertyKey = require("./toPropertyKey.js"); +function applyDecs2311(targetClass, classDecs, memberDecs, classDecsHaveThis, instanceBrand, parentClass) { + var symbolMetadata = Symbol.metadata || Symbol["for"]("Symbol.metadata"); + var defineProperty = Object.defineProperty; + var create = Object.create; + var metadata; + var existingNonFields = [create(null), create(null)]; + var hasClassDecs = classDecs.length; + var _; + function createRunInitializers(initializers, useStaticThis, hasValue) { + return function (thisArg, value) { + if (useStaticThis) { + value = thisArg; + thisArg = targetClass; + } + for (var i = 0; i < initializers.length; i++) { + value = initializers[i].apply(thisArg, hasValue ? [value] : []); + } + return hasValue ? value : thisArg; + }; + } + function assertCallable(fn, hint1, hint2, throwUndefined) { + if (typeof fn !== "function") { + if (throwUndefined || fn !== void 0) { + throw new TypeError(hint1 + " must " + (hint2 || "be") + " a function" + (throwUndefined ? "" : " or undefined")); + } + } + return fn; + } + function applyDec(Class, decInfo, decoratorsHaveThis, name, kind, initializers, ret, isStatic, isPrivate, isField, hasPrivateBrand) { + function assertInstanceIfPrivate(target) { + if (!hasPrivateBrand(target)) { + throw new TypeError("Attempted to access private element on non-instance"); + } + } + var decs = [].concat(decInfo[0]), + decVal = decInfo[3], + isClass = !ret; + var isAccessor = kind === 1; + var isGetter = kind === 3; + var isSetter = kind === 4; + var isMethod = kind === 2; + function _bindPropCall(name, useStaticThis, before) { + return function (_this, value) { + if (useStaticThis) { + value = _this; + _this = Class; + } + if (before) { + before(_this); + } + return desc[name].call(_this, value); + }; + } + if (!isClass) { + var desc = {}, + init = [], + key = isGetter ? "get" : isSetter || isAccessor ? "set" : "value"; + if (isPrivate) { + if (isField || isAccessor) { + desc = { + get: (0, _setFunctionName.default)(function () { + return decVal(this); + }, name, "get"), + set: function (value) { + decInfo[4](this, value); + } + }; + } else { + desc[key] = decVal; + } + if (!isField) { + (0, _setFunctionName.default)(desc[key], name, isMethod ? "" : key); + } + } else if (!isField) { + desc = Object.getOwnPropertyDescriptor(Class, name); + } + if (!isField && !isPrivate) { + _ = existingNonFields[+isStatic][name]; + if (_ && (_ ^ kind) !== 7) { + throw new Error("Decorating two elements with the same name (" + desc[key].name + ") is not supported yet"); + } + existingNonFields[+isStatic][name] = kind < 3 ? 1 : kind; + } + } + var newValue = Class; + for (var i = decs.length - 1; i >= 0; i -= decoratorsHaveThis ? 2 : 1) { + var dec = assertCallable(decs[i], "A decorator", "be", true), + decThis = decoratorsHaveThis ? decs[i - 1] : void 0; + var decoratorFinishedRef = {}; + var ctx = { + kind: ["field", "accessor", "method", "getter", "setter", "class"][kind], + name: name, + metadata: metadata, + addInitializer: function (decoratorFinishedRef, initializer) { + if (decoratorFinishedRef.v) { + throw new TypeError("attempted to call addInitializer after decoration was finished"); + } + assertCallable(initializer, "An initializer", "be", true); + initializers.push(initializer); + }.bind(null, decoratorFinishedRef) + }; + if (isClass) { + _ = dec.call(decThis, newValue, ctx); + decoratorFinishedRef.v = 1; + if (assertCallable(_, "class decorators", "return")) { + newValue = _; + } + } else { + ctx["static"] = isStatic; + ctx["private"] = isPrivate; + _ = ctx.access = { + has: isPrivate ? hasPrivateBrand.bind() : function (target) { + return name in target; + } + }; + if (!isSetter) { + _.get = isPrivate ? isMethod ? function (_this) { + assertInstanceIfPrivate(_this); + return desc.value; + } : _bindPropCall("get", 0, assertInstanceIfPrivate) : function (target) { + return target[name]; + }; + } + if (!isMethod && !isGetter) { + _.set = isPrivate ? _bindPropCall("set", 0, assertInstanceIfPrivate) : function (target, v) { + target[name] = v; + }; + } + newValue = dec.call(decThis, isAccessor ? { + get: desc.get, + set: desc.set + } : desc[key], ctx); + decoratorFinishedRef.v = 1; + if (isAccessor) { + if (typeof newValue === "object" && newValue) { + if (_ = assertCallable(newValue.get, "accessor.get")) { + desc.get = _; + } + if (_ = assertCallable(newValue.set, "accessor.set")) { + desc.set = _; + } + if (_ = assertCallable(newValue.init, "accessor.init")) { + init.unshift(_); + } + } else if (newValue !== void 0) { + throw new TypeError("accessor decorators must return an object with get, set, or init properties or undefined"); + } + } else if (assertCallable(newValue, (isField ? "field" : "method") + " decorators", "return")) { + if (isField) { + init.unshift(newValue); + } else { + desc[key] = newValue; + } + } + } + } + if (kind < 2) { + ret.push(createRunInitializers(init, isStatic, 1), createRunInitializers(initializers, isStatic, 0)); + } + if (!isField && !isClass) { + if (isPrivate) { + if (isAccessor) { + ret.splice(-1, 0, _bindPropCall("get", isStatic), _bindPropCall("set", isStatic)); + } else { + ret.push(isMethod ? desc[key] : assertCallable.call.bind(desc[key])); + } + } else { + defineProperty(Class, name, desc); + } + } + return newValue; + } + function applyMemberDecs() { + var ret = []; + var protoInitializers; + var staticInitializers; + var pushInitializers = function (initializers) { + if (initializers) { + ret.push(createRunInitializers(initializers)); + } + }; + var applyMemberDecsOfKind = function (isStatic, isField) { + for (var i = 0; i < memberDecs.length; i++) { + var decInfo = memberDecs[i]; + var kind = decInfo[1]; + var kindOnly = kind & 7; + if ((kind & 8) == isStatic && !kindOnly == isField) { + var name = decInfo[2]; + var isPrivate = !!decInfo[3]; + var decoratorsHaveThis = kind & 16; + applyDec(isStatic ? targetClass : targetClass.prototype, decInfo, decoratorsHaveThis, isPrivate ? "#" + name : (0, _toPropertyKey.default)(name), kindOnly, kindOnly < 2 ? [] : isStatic ? staticInitializers = staticInitializers || [] : protoInitializers = protoInitializers || [], ret, !!isStatic, isPrivate, isField, isStatic && isPrivate ? function (_) { + return (0, _checkInRHS.default)(_) === targetClass; + } : instanceBrand); + } + } + }; + applyMemberDecsOfKind(8, 0); + applyMemberDecsOfKind(0, 0); + applyMemberDecsOfKind(8, 1); + applyMemberDecsOfKind(0, 1); + pushInitializers(protoInitializers); + pushInitializers(staticInitializers); + return ret; + } + function defineMetadata(Class) { + return defineProperty(Class, symbolMetadata, { + configurable: true, + enumerable: true, + value: metadata + }); + } + if (parentClass !== undefined) { + metadata = parentClass[symbolMetadata]; + } + metadata = create(metadata == null ? null : metadata); + _ = applyMemberDecs(); + if (!hasClassDecs) defineMetadata(targetClass); + return { + e: _, + get c() { + var initializers = []; + return hasClassDecs && [defineMetadata(targetClass = applyDec(targetClass, [classDecs], classDecsHaveThis, targetClass.name, 5, initializers)), createRunInitializers(initializers, 1)]; + } + }; +} + +//# sourceMappingURL=applyDecs2311.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2311.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2311.js.map new file mode 100644 index 0000000000000000000000000000000000000000..f145827605a5cf2952569481316300ca85c852bd --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/applyDecs2311.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_checkInRHS","require","_setFunctionName","_toPropertyKey","applyDecs2311","targetClass","classDecs","memberDecs","classDecsHaveThis","instanceBrand","parentClass","symbolMetadata","Symbol","metadata","defineProperty","Object","create","existingNonFields","hasClassDecs","length","_","createRunInitializers","initializers","useStaticThis","hasValue","thisArg","value","i","apply","assertCallable","fn","hint1","hint2","throwUndefined","TypeError","applyDec","Class","decInfo","decoratorsHaveThis","name","kind","ret","isStatic","isPrivate","isField","hasPrivateBrand","assertInstanceIfPrivate","target","decs","concat","decVal","isClass","isAccessor","isGetter","isSetter","isMethod","_bindPropCall","before","_this","desc","call","init","key","get","setFunctionName","set","getOwnPropertyDescriptor","Error","newValue","dec","decThis","decoratorFinishedRef","ctx","addInitializer","initializer","v","push","bind","access","has","unshift","splice","applyMemberDecs","protoInitializers","staticInitializers","pushInitializers","applyMemberDecsOfKind","kindOnly","prototype","toPropertyKey","checkInRHS","defineMetadata","configurable","enumerable","undefined","e","c"],"sources":["../../src/helpers/applyDecs2311.ts"],"sourcesContent":["/* @minVersion 7.24.0 */\n/* @mangleFns */\n\n/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion -- `typescript-eslint` complains when using `!` */\n\nimport checkInRHS from \"./checkInRHS.ts\";\nimport setFunctionName from \"./setFunctionName.ts\";\nimport toPropertyKey from \"./toPropertyKey.ts\";\n\nconst enum PROP_KIND {\n FIELD = 0,\n ACCESSOR = 1,\n METHOD = 2,\n GETTER = 3,\n SETTER = 4,\n CLASS = 5,\n KIND_MASK = 7, // 0b111\n\n STATIC = 8,\n\n DECORATORS_HAVE_THIS = 16,\n}\n\ntype DecoratorFinishedRef = { v?: number };\ntype DecoratorContextAccess = {\n get?: (target: object) => any;\n set?: (target: object, value: any) => void;\n has: (target: object) => boolean;\n};\ntype DecoratorContext = {\n kind: \"accessor\" | \"method\" | \"getter\" | \"setter\" | \"field\" | \"class\";\n name: string | symbol;\n static?: boolean;\n private?: boolean;\n access?: DecoratorContextAccess;\n metadata?: any;\n addInitializer?: (initializer: Function) => void;\n};\ntype DecoratorInfo =\n | [\n decs: Function | Function[],\n kind: PROP_KIND,\n name: string,\n privateGetter?: Function,\n privateSetter?: Function,\n ]\n | [classDecs: Function[]];\ntype DecoratorNonFieldCheckStorage = Record<\n string | symbol,\n PROP_KIND.ACCESSOR | PROP_KIND.GETTER | PROP_KIND.SETTER\n>;\n/**\n Basic usage:\n\n applyDecs(\n Class,\n [\n // member decorators\n [\n decs, // dec, or array of decs, or array of this values and decs\n 0, // kind of value being decorated\n 'prop', // name of public prop on class containing the value being decorated,\n '#p', // the name of the private property (if is private, void 0 otherwise),\n ]\n ],\n [\n // class decorators\n dec1, dec2\n ]\n )\n ```\n\n Fully transpiled example:\n\n ```js\n @dec\n class Class {\n @dec\n a = 123;\n\n @dec\n #a = 123;\n\n @dec\n @dec2\n accessor b = 123;\n\n @dec\n accessor #b = 123;\n\n @dec\n c() { console.log('c'); }\n\n @dec\n #c() { console.log('privC'); }\n\n @dec\n get d() { console.log('d'); }\n\n @dec\n get #d() { console.log('privD'); }\n\n @dec\n set e(v) { console.log('e'); }\n\n @dec\n set #e(v) { console.log('privE'); }\n }\n\n\n // becomes\n let initializeInstance;\n let initializeClass;\n\n let initA;\n let initPrivA;\n\n let initB;\n let initPrivB, getPrivB, setPrivB;\n\n let privC;\n let privD;\n let privE;\n\n let Class;\n class _Class {\n static {\n let ret = applyDecs(\n this,\n [\n [dec, 0, 'a'],\n [dec, 0, 'a', (i) => i.#a, (i, v) => i.#a = v],\n [[dec, dec2], 1, 'b'],\n [dec, 1, 'b', (i) => i.#privBData, (i, v) => i.#privBData = v],\n [dec, 2, 'c'],\n [dec, 2, 'c', () => console.log('privC')],\n [dec, 3, 'd'],\n [dec, 3, 'd', () => console.log('privD')],\n [dec, 4, 'e'],\n [dec, 4, 'e', () => console.log('privE')],\n ],\n [\n dec\n ]\n );\n\n initA = ret[0];\n\n initPrivA = ret[1];\n\n initB = ret[2];\n\n initPrivB = ret[3];\n getPrivB = ret[4];\n setPrivB = ret[5];\n\n privC = ret[6];\n\n privD = ret[7];\n\n privE = ret[8];\n\n initializeInstance = ret[9];\n\n Class = ret[10]\n\n initializeClass = ret[11];\n }\n\n a = (initializeInstance(this), initA(this, 123));\n\n #a = initPrivA(this, 123);\n\n #bData = initB(this, 123);\n get b() { return this.#bData }\n set b(v) { this.#bData = v }\n\n #privBData = initPrivB(this, 123);\n get #b() { return getPrivB(this); }\n set #b(v) { setPrivB(this, v); }\n\n c() { console.log('c'); }\n\n #c(...args) { return privC(this, ...args) }\n\n get d() { console.log('d'); }\n\n get #d() { return privD(this); }\n\n set e(v) { console.log('e'); }\n\n set #e(v) { privE(this, v); }\n }\n\n initializeClass(Class);\n */\n\nexport default /* @no-mangle */ function applyDecs2311(\n targetClass: any,\n classDecs: Function[],\n memberDecs: DecoratorInfo[],\n classDecsHaveThis: number,\n instanceBrand: Function,\n parentClass: any,\n) {\n var symbolMetadata = Symbol.metadata || Symbol[\"for\"](\"Symbol.metadata\");\n var defineProperty = Object.defineProperty;\n var create = Object.create;\n var metadata: any;\n // Use both as and satisfies to ensure that we only use non-zero values\n var existingNonFields = [create(null), create(null)] as [\n DecoratorNonFieldCheckStorage,\n DecoratorNonFieldCheckStorage,\n ];\n var hasClassDecs = classDecs.length;\n // This is a temporary variable for smaller helper size\n var _: any;\n\n function createRunInitializers(\n initializers: Function[],\n useStaticThis?: 0 | 1 | boolean,\n hasValue?: 0 | 1,\n ) {\n return function (thisArg: any, value?: any) {\n if (useStaticThis) {\n value = thisArg;\n thisArg = targetClass;\n }\n for (var i = 0; i < initializers.length; i++) {\n value = initializers[i].apply(thisArg, hasValue ? [value] : []);\n }\n return hasValue ? value : thisArg;\n };\n }\n\n function assertCallable(\n fn: any,\n hint1: string,\n hint2?: string,\n throwUndefined?: boolean,\n ) {\n if (typeof fn !== \"function\") {\n if (throwUndefined || fn !== void 0) {\n throw new TypeError(\n hint1 +\n \" must \" +\n (hint2 || \"be\") +\n \" a function\" +\n (throwUndefined ? \"\" : \" or undefined\"),\n );\n }\n }\n return fn;\n }\n\n /* @no-mangle */\n function applyDec(\n Class: any,\n decInfo: DecoratorInfo,\n decoratorsHaveThis: 0 | PROP_KIND.DECORATORS_HAVE_THIS,\n name: string | symbol,\n kind: PROP_KIND,\n initializers: Function[],\n ret?: Function[],\n isStatic?: boolean,\n isPrivate?: boolean,\n isField?: 0 | 1,\n hasPrivateBrand?: Function,\n ) {\n function assertInstanceIfPrivate(target: any) {\n if (!hasPrivateBrand!(target)) {\n throw new TypeError(\n \"Attempted to access private element on non-instance\",\n );\n }\n }\n\n var decs = ([] as Function[]).concat(decInfo[0]),\n decVal = decInfo[3],\n isClass = !ret;\n\n var isAccessor = kind === PROP_KIND.ACCESSOR;\n var isGetter = kind === PROP_KIND.GETTER;\n var isSetter = kind === PROP_KIND.SETTER;\n var isMethod = kind === PROP_KIND.METHOD;\n\n function _bindPropCall(\n name: keyof PropertyDescriptor,\n useStaticThis: 0 | 1 | boolean,\n before?: Function,\n ) {\n return function (_this: any, value?: any) {\n if (useStaticThis) {\n value = _this;\n _this = Class;\n }\n if (before) {\n before(_this);\n }\n // eslint-disable-next-line @typescript-eslint/no-use-before-define\n return desc[name].call(_this, value);\n };\n }\n\n if (!isClass) {\n var desc: PropertyDescriptor = {},\n init: Function[] = [],\n key: \"get\" | \"set\" | \"value\" = isGetter\n ? \"get\"\n : isSetter || isAccessor\n ? \"set\"\n : \"value\";\n\n if (isPrivate) {\n if (isField || isAccessor) {\n desc = {\n get: setFunctionName(\n function (this: any) {\n return decVal!(this);\n },\n name,\n \"get\",\n ),\n set: function (this: any, value: any) {\n decInfo[4]!(this, value);\n },\n };\n } else {\n desc[key] = decVal;\n }\n\n if (!isField) {\n setFunctionName(desc[key], name, isMethod ? \"\" : key);\n }\n } else if (!isField) {\n desc = Object.getOwnPropertyDescriptor(Class, name)!;\n }\n\n if (!isField && !isPrivate) {\n _ = existingNonFields[+isStatic!][name];\n // flag is 1, 3, or 4; kind is 0, 1, 2, 3, or 4\n // flag ^ kind is 7 if and only if one of them is 3 and the other one is 4.\n if (_ && (_ ^ kind) !== 7) {\n throw new Error(\n \"Decorating two elements with the same name (\" +\n desc[key].name +\n \") is not supported yet\",\n );\n }\n // We use PROP_KIND.ACCESSOR to mark a name as \"fully used\":\n // either a get/set pair, or a non-getter/setter.\n existingNonFields[+isStatic!][name] =\n kind < PROP_KIND.GETTER\n ? PROP_KIND.ACCESSOR\n : (kind as PROP_KIND.GETTER | PROP_KIND.SETTER);\n }\n }\n\n var newValue = Class;\n\n for (var i = decs.length - 1; i >= 0; i -= decoratorsHaveThis ? 2 : 1) {\n var dec = assertCallable(decs[i], \"A decorator\", \"be\", true) as Function,\n decThis = decoratorsHaveThis ? decs[i - 1] : void 0;\n\n var decoratorFinishedRef: DecoratorFinishedRef = {};\n var ctx: DecoratorContext = {\n kind: [\"field\", \"accessor\", \"method\", \"getter\", \"setter\", \"class\"][\n kind\n ] as any,\n\n name: name,\n metadata: metadata,\n addInitializer: function (\n decoratorFinishedRef: DecoratorFinishedRef,\n initializer: Function,\n ) {\n if (decoratorFinishedRef.v) {\n throw new TypeError(\n \"attempted to call addInitializer after decoration was finished\",\n );\n }\n assertCallable(initializer, \"An initializer\", \"be\", true);\n initializers.push(initializer);\n }.bind(null, decoratorFinishedRef),\n };\n\n if (isClass) {\n _ = dec.call(decThis, newValue, ctx);\n decoratorFinishedRef.v = 1;\n\n if (assertCallable(_, \"class decorators\", \"return\")) {\n newValue = _;\n }\n } else {\n ctx[\"static\"] = isStatic;\n ctx[\"private\"] = isPrivate;\n\n _ = ctx.access = {\n has: isPrivate\n ? // @ts-expect-error no thisArg\n hasPrivateBrand.bind()\n : function (target: object) {\n return name in target;\n },\n };\n\n if (!isSetter) {\n _.get = isPrivate\n ? isMethod\n ? function (_this: any) {\n assertInstanceIfPrivate(_this);\n return desc.value;\n }\n : _bindPropCall(\"get\", 0, assertInstanceIfPrivate)\n : function (target: any) {\n return target[name];\n };\n }\n if (!isMethod && !isGetter) {\n _.set = isPrivate\n ? _bindPropCall(\"set\", 0, assertInstanceIfPrivate)\n : function (target: any, v: any) {\n target[name] = v;\n };\n }\n\n newValue = dec.call(\n decThis,\n isAccessor\n ? {\n get: desc!.get,\n set: desc!.set,\n }\n : desc![key!],\n ctx,\n );\n decoratorFinishedRef.v = 1;\n\n if (isAccessor) {\n if (typeof newValue === \"object\" && newValue) {\n if ((_ = assertCallable(newValue.get, \"accessor.get\"))) {\n desc!.get = _;\n }\n if ((_ = assertCallable(newValue.set, \"accessor.set\"))) {\n desc!.set = _;\n }\n if ((_ = assertCallable(newValue.init, \"accessor.init\"))) {\n init!.unshift(_);\n }\n } else if (newValue !== void 0) {\n throw new TypeError(\n \"accessor decorators must return an object with get, set, or init properties or undefined\",\n );\n }\n } else if (\n assertCallable(\n newValue,\n (isField ? \"field\" : \"method\") + \" decorators\",\n \"return\",\n )\n ) {\n if (isField) {\n init!.unshift(newValue);\n } else {\n desc![key!] = newValue;\n }\n }\n }\n }\n\n // isField || isAccessor\n if (kind < PROP_KIND.METHOD) {\n ret!.push(\n // init\n createRunInitializers(init!, isStatic, 1),\n // init_extra\n createRunInitializers(initializers, isStatic, 0),\n );\n }\n\n if (!isField && !isClass) {\n if (isPrivate) {\n if (isAccessor) {\n // get and set should be returned before init_extra\n ret!.splice(\n -1,\n 0,\n _bindPropCall(\"get\", isStatic!),\n _bindPropCall(\"set\", isStatic!),\n );\n } else {\n ret!.push(\n isMethod\n ? desc![key!]\n : // Equivalent to `Function.call`, just to reduce code size\n assertCallable.call.bind(desc![key!]),\n );\n }\n } else {\n defineProperty(Class, name, desc!);\n }\n }\n return newValue;\n }\n\n /* @no-mangle */\n function applyMemberDecs() {\n var ret: Function[] = [];\n var protoInitializers: Function[];\n var staticInitializers: Function[];\n\n var pushInitializers = function (initializers: Function[]) {\n if (initializers) {\n ret.push(createRunInitializers(initializers));\n }\n };\n\n var applyMemberDecsOfKind = function (\n isStatic: PROP_KIND.STATIC | 0,\n isField: 0 | 1,\n ) {\n for (var i = 0; i < memberDecs.length; i++) {\n var decInfo = memberDecs[i];\n\n var kind = decInfo[1]!;\n var kindOnly: PROP_KIND = kind & PROP_KIND.KIND_MASK;\n if (\n // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison, eqeqeq\n (kind & PROP_KIND.STATIC) == isStatic &&\n // @ts-expect-error comparing a boolean with 0 | 1\n // eslint-disable-next-line eqeqeq\n !kindOnly == isField\n ) {\n var name = decInfo[2];\n var isPrivate = !!decInfo[3];\n\n var decoratorsHaveThis: 0 | PROP_KIND.DECORATORS_HAVE_THIS =\n kind & PROP_KIND.DECORATORS_HAVE_THIS;\n\n applyDec(\n isStatic ? targetClass : targetClass.prototype,\n decInfo,\n decoratorsHaveThis,\n isPrivate ? \"#\" + name : (toPropertyKey(name) as string),\n kindOnly,\n kindOnly < PROP_KIND.METHOD // isField || isAccessor\n ? /* fieldInitializers */ []\n : isStatic\n ? (staticInitializers = staticInitializers || [])\n : (protoInitializers = protoInitializers || []),\n ret,\n !!isStatic,\n isPrivate,\n isField,\n isStatic && isPrivate\n ? function (_: any) {\n return checkInRHS(_) === targetClass;\n }\n : instanceBrand,\n );\n }\n }\n };\n\n applyMemberDecsOfKind(PROP_KIND.STATIC, 0);\n applyMemberDecsOfKind(0, 0);\n applyMemberDecsOfKind(PROP_KIND.STATIC, 1);\n applyMemberDecsOfKind(0, 1);\n\n pushInitializers(protoInitializers!);\n pushInitializers(staticInitializers!);\n return ret;\n }\n\n function defineMetadata(Class: any) {\n return defineProperty(Class, symbolMetadata, {\n configurable: true,\n enumerable: true,\n value: metadata,\n });\n }\n\n if (parentClass !== undefined) {\n metadata = parentClass[symbolMetadata];\n }\n metadata = create(metadata == null ? null : metadata);\n _ = applyMemberDecs();\n if (!hasClassDecs) defineMetadata(targetClass);\n return {\n e: _,\n // Lazily apply class decorations so that member init locals can be properly bound.\n get c() {\n // The transformer will not emit assignment when there are no class decorators,\n // so we don't have to return an empty array here.\n var initializers: Function[] = [];\n return (\n hasClassDecs && [\n defineMetadata(\n (targetClass = applyDec(\n targetClass,\n [classDecs],\n classDecsHaveThis,\n targetClass.name,\n PROP_KIND.CLASS,\n initializers,\n )),\n ),\n createRunInitializers(initializers, 1),\n ]\n );\n },\n };\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/arrayLikeToArray.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/arrayLikeToArray.js new file mode 100644 index 0000000000000000000000000000000000000000..2a4161251f9af988cc61beef5571872084dbb1b1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/arrayLikeToArray.js @@ -0,0 +1,13 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _arrayLikeToArray; +function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + return arr2; +} + +//# sourceMappingURL=arrayLikeToArray.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/arrayLikeToArray.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/arrayLikeToArray.js.map new file mode 100644 index 0000000000000000000000000000000000000000..1af9c857d29e1cfab64cc0091f09e2af3e9ee599 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/arrayLikeToArray.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_arrayLikeToArray","arr","len","length","i","arr2","Array"],"sources":["../../src/helpers/arrayLikeToArray.ts"],"sourcesContent":["/* @minVersion 7.9.0 */\n\nexport default function _arrayLikeToArray(\n arr: ArrayLike,\n len?: number | null,\n) {\n if (len == null || len > arr.length) len = arr.length;\n for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n return arr2;\n}\n"],"mappings":";;;;;;AAEe,SAASA,iBAAiBA,CACvCC,GAAiB,EACjBC,GAAmB,EACnB;EACA,IAAIA,GAAG,IAAI,IAAI,IAAIA,GAAG,GAAGD,GAAG,CAACE,MAAM,EAAED,GAAG,GAAGD,GAAG,CAACE,MAAM;EACrD,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEC,IAAI,GAAG,IAAIC,KAAK,CAAIJ,GAAG,CAAC,EAAEE,CAAC,GAAGF,GAAG,EAAEE,CAAC,EAAE,EAAEC,IAAI,CAACD,CAAC,CAAC,GAAGH,GAAG,CAACG,CAAC,CAAC;EACxE,OAAOC,IAAI;AACb","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/arrayWithHoles.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/arrayWithHoles.js new file mode 100644 index 0000000000000000000000000000000000000000..89e2b9051a3fb1e0ddd412d389389541fd5c6d9a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/arrayWithHoles.js @@ -0,0 +1,11 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _arrayWithHoles; +function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; +} + +//# sourceMappingURL=arrayWithHoles.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/arrayWithHoles.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/arrayWithHoles.js.map new file mode 100644 index 0000000000000000000000000000000000000000..16d9dfe8f75d096b9e843bb7d4618db4e9b18fb0 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/arrayWithHoles.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_arrayWithHoles","arr","Array","isArray"],"sources":["../../src/helpers/arrayWithHoles.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _arrayWithHoles(arr: Array) {\n if (Array.isArray(arr)) return arr;\n}\n"],"mappings":";;;;;;AAEe,SAASA,eAAeA,CAAIC,GAAa,EAAE;EACxD,IAAIC,KAAK,CAACC,OAAO,CAACF,GAAG,CAAC,EAAE,OAAOA,GAAG;AACpC","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/arrayWithoutHoles.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/arrayWithoutHoles.js new file mode 100644 index 0000000000000000000000000000000000000000..5c9f4aee22ddff5e9591fd68ce58b29a644b841d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/arrayWithoutHoles.js @@ -0,0 +1,12 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _arrayWithoutHoles; +var _arrayLikeToArray = require("./arrayLikeToArray.js"); +function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return (0, _arrayLikeToArray.default)(arr); +} + +//# sourceMappingURL=arrayWithoutHoles.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/arrayWithoutHoles.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/arrayWithoutHoles.js.map new file mode 100644 index 0000000000000000000000000000000000000000..d701d16b663489ef9efd2dfcbe03899816cd876d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/arrayWithoutHoles.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_arrayLikeToArray","require","_arrayWithoutHoles","arr","Array","isArray","arrayLikeToArray"],"sources":["../../src/helpers/arrayWithoutHoles.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nimport arrayLikeToArray from \"./arrayLikeToArray.ts\";\n\nexport default function _arrayWithoutHoles(arr: Array) {\n if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n"],"mappings":";;;;;;AAEA,IAAAA,iBAAA,GAAAC,OAAA;AAEe,SAASC,kBAAkBA,CAAIC,GAAa,EAAE;EAC3D,IAAIC,KAAK,CAACC,OAAO,CAACF,GAAG,CAAC,EAAE,OAAO,IAAAG,yBAAgB,EAAIH,GAAG,CAAC;AACzD","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/assertClassBrand.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/assertClassBrand.js new file mode 100644 index 0000000000000000000000000000000000000000..8d88e439ea724e0a5dd772d2c06230fb712c5f52 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/assertClassBrand.js @@ -0,0 +1,14 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _assertClassBrand; +function _assertClassBrand(brand, receiver, returnValue) { + if (typeof brand === "function" ? brand === receiver : brand.has(receiver)) { + return arguments.length < 3 ? receiver : returnValue; + } + throw new TypeError("Private element is not present on this object"); +} + +//# sourceMappingURL=assertClassBrand.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/assertClassBrand.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/assertClassBrand.js.map new file mode 100644 index 0000000000000000000000000000000000000000..c86acc268d8ac78e53578699de84919b6bdadfdd --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/assertClassBrand.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_assertClassBrand","brand","receiver","returnValue","has","arguments","length","TypeError"],"sources":["../../src/helpers/assertClassBrand.ts"],"sourcesContent":["/* @minVersion 7.24.0 */\n\nexport default function _assertClassBrand(\n brand: Function | WeakMap | WeakSet,\n receiver: any,\n returnValue?: any,\n) {\n if (typeof brand === \"function\" ? brand === receiver : brand.has(receiver)) {\n return arguments.length < 3 ? receiver : returnValue;\n }\n throw new TypeError(\"Private element is not present on this object\");\n}\n"],"mappings":";;;;;;AAEe,SAASA,iBAAiBA,CACvCC,KAAkD,EAClDC,QAAa,EACbC,WAAiB,EACjB;EACA,IAAI,OAAOF,KAAK,KAAK,UAAU,GAAGA,KAAK,KAAKC,QAAQ,GAAGD,KAAK,CAACG,GAAG,CAACF,QAAQ,CAAC,EAAE;IAC1E,OAAOG,SAAS,CAACC,MAAM,GAAG,CAAC,GAAGJ,QAAQ,GAAGC,WAAW;EACtD;EACA,MAAM,IAAII,SAAS,CAAC,+CAA+C,CAAC;AACtE","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/assertThisInitialized.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/assertThisInitialized.js new file mode 100644 index 0000000000000000000000000000000000000000..d8a4a5937b606708acf1b2636940a2dccfe5286a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/assertThisInitialized.js @@ -0,0 +1,14 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _assertThisInitialized; +function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + return self; +} + +//# sourceMappingURL=assertThisInitialized.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/assertThisInitialized.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/assertThisInitialized.js.map new file mode 100644 index 0000000000000000000000000000000000000000..654ac39a5437c9a98163f66ba2f250b26825a69b --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/assertThisInitialized.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_assertThisInitialized","self","ReferenceError"],"sources":["../../src/helpers/assertThisInitialized.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _assertThisInitialized(self: T | undefined): T {\n if (self === void 0) {\n throw new ReferenceError(\n \"this hasn't been initialised - super() hasn't been called\",\n );\n }\n return self;\n}\n"],"mappings":";;;;;;AAEe,SAASA,sBAAsBA,CAAIC,IAAmB,EAAK;EACxE,IAAIA,IAAI,KAAK,KAAK,CAAC,EAAE;IACnB,MAAM,IAAIC,cAAc,CACtB,2DACF,CAAC;EACH;EACA,OAAOD,IAAI;AACb","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/asyncGeneratorDelegate.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/asyncGeneratorDelegate.js new file mode 100644 index 0000000000000000000000000000000000000000..e1c9889c3dec0de3acdd6ac500e4c1229c7449bf --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/asyncGeneratorDelegate.js @@ -0,0 +1,52 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _asyncGeneratorDelegate; +var _OverloadYield = require("./OverloadYield.js"); +function _asyncGeneratorDelegate(inner) { + var iter = {}, + waiting = false; + function pump(key, value) { + waiting = true; + value = new Promise(function (resolve) { + resolve(inner[key](value)); + }); + return { + done: false, + value: new _OverloadYield.default(value, 1) + }; + } + iter[typeof Symbol !== "undefined" && Symbol.iterator || "@@iterator"] = function () { + return this; + }; + iter.next = function (value) { + if (waiting) { + waiting = false; + return value; + } + return pump("next", value); + }; + if (typeof inner["throw"] === "function") { + iter["throw"] = function (value) { + if (waiting) { + waiting = false; + throw value; + } + return pump("throw", value); + }; + } + if (typeof inner["return"] === "function") { + iter["return"] = function (value) { + if (waiting) { + waiting = false; + return value; + } + return pump("return", value); + }; + } + return iter; +} + +//# sourceMappingURL=asyncGeneratorDelegate.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/asyncGeneratorDelegate.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/asyncGeneratorDelegate.js.map new file mode 100644 index 0000000000000000000000000000000000000000..569146fe49c7b53faa45cf04004113b2467215fa --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/asyncGeneratorDelegate.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_OverloadYield","require","_asyncGeneratorDelegate","inner","iter","waiting","pump","key","value","Promise","resolve","done","OverloadYield","Symbol","iterator","next"],"sources":["../../src/helpers/asyncGeneratorDelegate.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nimport OverloadYield from \"./OverloadYield.ts\";\n\nexport default function _asyncGeneratorDelegate(inner: Generator) {\n var iter = {} as Generator,\n // See the comment in AsyncGenerator to understand what this is.\n waiting = false;\n\n function pump(\n key: \"next\" | \"throw\" | \"return\",\n value: any,\n ): IteratorYieldResult {\n waiting = true;\n value = new Promise(function (resolve) {\n resolve(inner[key](value));\n });\n return {\n done: false,\n value: new OverloadYield(value, /* kind: delegate */ 1),\n };\n }\n\n iter[\n ((typeof Symbol !== \"undefined\" && Symbol.iterator) ||\n \"@@iterator\") as typeof Symbol.iterator\n ] = function () {\n return this;\n };\n\n iter.next = function (value: any) {\n if (waiting) {\n waiting = false;\n return value;\n }\n return pump(\"next\", value);\n };\n\n if (typeof inner[\"throw\"] === \"function\") {\n iter[\"throw\"] = function (value: any) {\n if (waiting) {\n waiting = false;\n throw value;\n }\n return pump(\"throw\", value);\n };\n }\n\n if (typeof inner[\"return\"] === \"function\") {\n iter[\"return\"] = function (value: any) {\n if (waiting) {\n waiting = false;\n return value;\n }\n return pump(\"return\", value);\n };\n }\n\n return iter;\n}\n"],"mappings":";;;;;;AAEA,IAAAA,cAAA,GAAAC,OAAA;AAEe,SAASC,uBAAuBA,CAAIC,KAAmB,EAAE;EACtE,IAAIC,IAAI,GAAG,CAAC,CAAiB;IAE3BC,OAAO,GAAG,KAAK;EAEjB,SAASC,IAAIA,CACXC,GAAgC,EAChCC,KAAU,EACgB;IAC1BH,OAAO,GAAG,IAAI;IACdG,KAAK,GAAG,IAAIC,OAAO,CAAC,UAAUC,OAAO,EAAE;MACrCA,OAAO,CAACP,KAAK,CAACI,GAAG,CAAC,CAACC,KAAK,CAAC,CAAC;IAC5B,CAAC,CAAC;IACF,OAAO;MACLG,IAAI,EAAE,KAAK;MACXH,KAAK,EAAE,IAAII,sBAAa,CAACJ,KAAK,EAAuB,CAAC;IACxD,CAAC;EACH;EAEAJ,IAAI,CACA,OAAOS,MAAM,KAAK,WAAW,IAAIA,MAAM,CAACC,QAAQ,IAChD,YAAY,CACf,GAAG,YAAY;IACd,OAAO,IAAI;EACb,CAAC;EAEDV,IAAI,CAACW,IAAI,GAAG,UAAUP,KAAU,EAAE;IAChC,IAAIH,OAAO,EAAE;MACXA,OAAO,GAAG,KAAK;MACf,OAAOG,KAAK;IACd;IACA,OAAOF,IAAI,CAAC,MAAM,EAAEE,KAAK,CAAC;EAC5B,CAAC;EAED,IAAI,OAAOL,KAAK,CAAC,OAAO,CAAC,KAAK,UAAU,EAAE;IACxCC,IAAI,CAAC,OAAO,CAAC,GAAG,UAAUI,KAAU,EAAE;MACpC,IAAIH,OAAO,EAAE;QACXA,OAAO,GAAG,KAAK;QACf,MAAMG,KAAK;MACb;MACA,OAAOF,IAAI,CAAC,OAAO,EAAEE,KAAK,CAAC;IAC7B,CAAC;EACH;EAEA,IAAI,OAAOL,KAAK,CAAC,QAAQ,CAAC,KAAK,UAAU,EAAE;IACzCC,IAAI,CAAC,QAAQ,CAAC,GAAG,UAAUI,KAAU,EAAE;MACrC,IAAIH,OAAO,EAAE;QACXA,OAAO,GAAG,KAAK;QACf,OAAOG,KAAK;MACd;MACA,OAAOF,IAAI,CAAC,QAAQ,EAAEE,KAAK,CAAC;IAC9B,CAAC;EACH;EAEA,OAAOJ,IAAI;AACb","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/asyncIterator.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/asyncIterator.js new file mode 100644 index 0000000000000000000000000000000000000000..ec1ea6999d7bee31ffe2b7e715f41e3d83881e49 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/asyncIterator.js @@ -0,0 +1,72 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _asyncIterator; +function _asyncIterator(iterable) { + var method, + async, + sync, + retry = 2; + if (typeof Symbol !== "undefined") { + async = Symbol.asyncIterator; + sync = Symbol.iterator; + } + while (retry--) { + if (async && (method = iterable[async]) != null) { + return method.call(iterable); + } + if (sync && (method = iterable[sync]) != null) { + return new AsyncFromSyncIterator(method.call(iterable)); + } + async = "@@asyncIterator"; + sync = "@@iterator"; + } + throw new TypeError("Object is not async iterable"); +} +function AsyncFromSyncIterator(s) { + AsyncFromSyncIterator = function (s) { + this.s = s; + this.n = s.next; + }; + AsyncFromSyncIterator.prototype = { + s: null, + n: null, + next: function () { + return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments)); + }, + return: function (value) { + var ret = this.s["return"]; + if (ret === undefined) { + return Promise.resolve({ + value: value, + done: true + }); + } + return AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments)); + }, + throw: function (maybeError) { + var thr = this.s["return"]; + if (thr === undefined) { + return Promise.reject(maybeError); + } + return AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments)); + } + }; + function AsyncFromSyncIteratorContinuation(r) { + if (Object(r) !== r) { + return Promise.reject(new TypeError(r + " is not an object.")); + } + var done = r.done; + return Promise.resolve(r.value).then(function (value) { + return { + value: value, + done: done + }; + }); + } + return new AsyncFromSyncIterator(s); +} + +//# sourceMappingURL=asyncIterator.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/asyncIterator.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/asyncIterator.js.map new file mode 100644 index 0000000000000000000000000000000000000000..87fb7e6aad4afded6661feeead3e8b81df8213db --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/asyncIterator.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_asyncIterator","iterable","method","async","sync","retry","Symbol","asyncIterator","iterator","call","AsyncFromSyncIterator","TypeError","s","n","next","prototype","AsyncFromSyncIteratorContinuation","apply","arguments","return","value","ret","undefined","Promise","resolve","done","throw","maybeError","thr","reject","r","Object","then"],"sources":["../../src/helpers/asyncIterator.ts"],"sourcesContent":["/* @minVersion 7.15.9 */\n\ntype AsyncIteratorFn = AsyncIterable[typeof Symbol.asyncIterator];\ntype SyncIteratorFn = Iterable[typeof Symbol.iterator];\n\nexport default function _asyncIterator(\n iterable: AsyncIterable | Iterable,\n) {\n var method: AsyncIteratorFn | SyncIteratorFn,\n async: typeof Symbol.asyncIterator | \"@@asyncIterator\" | undefined,\n sync: typeof Symbol.iterator | \"@@iterator\" | undefined,\n retry = 2;\n\n if (typeof Symbol !== \"undefined\") {\n async = Symbol.asyncIterator;\n sync = Symbol.iterator;\n }\n\n while (retry--) {\n // TypeScript doesn't have in-function narrowing, and TypeScript can't narrow\n // AsyncIterable | Iterable down to AsyncIterable. So let's use any here.\n if (async && (method = (iterable as any)[async]) != null) {\n return (method as AsyncIteratorFn).call(iterable as AsyncIterable);\n }\n // Same here, TypeScript can't narrow AsyncIterable | Iterable down to Iterable.\n if (sync && (method = (iterable as any)[sync]) != null) {\n return new AsyncFromSyncIterator(\n (method as SyncIteratorFn).call(iterable as Iterable),\n );\n }\n\n async = \"@@asyncIterator\";\n sync = \"@@iterator\";\n }\n\n throw new TypeError(\"Object is not async iterable\");\n}\n\n// AsyncFromSyncIterator is actually a class that implements AsyncIterator interface\ndeclare class AsyncFromSyncIterator\n implements AsyncIterator\n{\n s: Iterator;\n n: Iterator[\"next\"];\n constructor(s: Iterator);\n\n next(...args: [] | [TNext]): Promise>;\n return?(\n value?: TReturn | PromiseLike,\n ): Promise>;\n throw?(e?: any): Promise>;\n}\n\n// Actual implementation of AsyncFromSyncIterator starts here\n// class only exists in ES6, so we need to use the old school way\n// This makes ESLint and TypeScript complain a lot, but it's the only way\nfunction AsyncFromSyncIterator(s: any) {\n // @ts-expect-error - Intentionally overriding the constructor.\n AsyncFromSyncIterator = function (\n this: AsyncFromSyncIterator,\n s: Iterator,\n ) {\n this.s = s;\n this.n = s.next;\n };\n AsyncFromSyncIterator.prototype = {\n // Initiating the \"s\" and \"n\", use \"any\" to prevent TS from complaining\n /* SyncIterator */ s: null as any,\n /* SyncIterator.[[Next]] */ n: null as any,\n next: function () {\n return AsyncFromSyncIteratorContinuation(\n // Use \"arguments\" here for better compatibility and smaller bundle size\n // Intentionally casting \"arguments\" to an array for the type of func.apply\n this.n.apply(this.s, arguments as any as [] | [undefined]),\n );\n },\n return: function (value) {\n var ret = this.s[\"return\"];\n if (ret === undefined) {\n return Promise.resolve>({\n // \"TReturn | PromiseLike\" should have been unwrapped by Awaited,\n // but TypeScript choked, let's just casting it away\n value: value as TReturn,\n done: true,\n });\n }\n return AsyncFromSyncIteratorContinuation(\n ret.apply(\n this.s,\n // Use \"arguments\" here for better compatibility and smaller bundle size\n // Intentionally casting \"arguments\" to an array for the type of func.apply\n arguments as any as [] | [TReturn | PromiseLike],\n ),\n );\n },\n throw: function (maybeError?: any) {\n var thr = this.s[\"return\"];\n if (thr === undefined) {\n // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors\n return Promise.reject(maybeError);\n }\n return AsyncFromSyncIteratorContinuation(\n // Use \"arguments\" here for better compatibility and smaller bundle size\n // Intentionally casting \"arguments\" to an array for the type of func.apply\n thr.apply(this.s, arguments as any as [any]),\n );\n },\n } satisfies AsyncFromSyncIterator;\n\n function AsyncFromSyncIteratorContinuation(r: any) {\n // This step is _before_ calling AsyncFromSyncIteratorContinuation in the spec.\n if (Object(r) !== r) {\n return Promise.reject(new TypeError(r + \" is not an object.\"));\n }\n\n var done = r.done;\n return Promise.resolve(r.value).then>(\n function (value) {\n return { value: value, done: done };\n },\n );\n }\n\n return new AsyncFromSyncIterator(s);\n}\n"],"mappings":";;;;;;AAKe,SAASA,cAAcA,CACpCC,QAAwC,EACxC;EACA,IAAIC,MAA8C;IAChDC,KAAkE;IAClEC,IAAuD;IACvDC,KAAK,GAAG,CAAC;EAEX,IAAI,OAAOC,MAAM,KAAK,WAAW,EAAE;IACjCH,KAAK,GAAGG,MAAM,CAACC,aAAa;IAC5BH,IAAI,GAAGE,MAAM,CAACE,QAAQ;EACxB;EAEA,OAAOH,KAAK,EAAE,EAAE;IAGd,IAAIF,KAAK,IAAI,CAACD,MAAM,GAAID,QAAQ,CAASE,KAAK,CAAC,KAAK,IAAI,EAAE;MACxD,OAAQD,MAAM,CAAwBO,IAAI,CAACR,QAA4B,CAAC;IAC1E;IAEA,IAAIG,IAAI,IAAI,CAACF,MAAM,GAAID,QAAQ,CAASG,IAAI,CAAC,KAAK,IAAI,EAAE;MACtD,OAAO,IAAIM,qBAAqB,CAC7BR,MAAM,CAAuBO,IAAI,CAACR,QAAuB,CAC5D,CAAC;IACH;IAEAE,KAAK,GAAG,iBAAiB;IACzBC,IAAI,GAAG,YAAY;EACrB;EAEA,MAAM,IAAIO,SAAS,CAAC,8BAA8B,CAAC;AACrD;AAoBA,SAASD,qBAAqBA,CAAsCE,CAAM,EAAE;EAE1EF,qBAAqB,GAAG,SAAAA,CAEtBE,CAAc,EACd;IACA,IAAI,CAACA,CAAC,GAAGA,CAAC;IACV,IAAI,CAACC,CAAC,GAAGD,CAAC,CAACE,IAAI;EACjB,CAAC;EACDJ,qBAAqB,CAACK,SAAS,GAAG;IAEbH,CAAC,EAAE,IAAW;IACLC,CAAC,EAAE,IAAW;IAC1CC,IAAI,EAAE,SAAAA,CAAA,EAAY;MAChB,OAAOE,iCAAiC,CAGtC,IAAI,CAACH,CAAC,CAACI,KAAK,CAAC,IAAI,CAACL,CAAC,EAAEM,SAAoC,CAC3D,CAAC;IACH,CAAC;IACDC,MAAM,EAAE,SAAAA,CAAUC,KAAK,EAAE;MACvB,IAAIC,GAAG,GAAG,IAAI,CAACT,CAAC,CAAC,QAAQ,CAAC;MAC1B,IAAIS,GAAG,KAAKC,SAAS,EAAE;QACrB,OAAOC,OAAO,CAACC,OAAO,CAAgC;UAGpDJ,KAAK,EAAEA,KAAgB;UACvBK,IAAI,EAAE;QACR,CAAC,CAAC;MACJ;MACA,OAAOT,iCAAiC,CACtCK,GAAG,CAACJ,KAAK,CACP,IAAI,CAACL,CAAC,EAGNM,SACF,CACF,CAAC;IACH,CAAC;IACDQ,KAAK,EAAE,SAAAA,CAAUC,UAAgB,EAAE;MACjC,IAAIC,GAAG,GAAG,IAAI,CAAChB,CAAC,CAAC,QAAQ,CAAC;MAC1B,IAAIgB,GAAG,KAAKN,SAAS,EAAE;QAErB,OAAOC,OAAO,CAACM,MAAM,CAACF,UAAU,CAAC;MACnC;MACA,OAAOX,iCAAiC,CAGtCY,GAAG,CAACX,KAAK,CAAC,IAAI,CAACL,CAAC,EAAEM,SAAyB,CAC7C,CAAC;IACH;EACF,CAAoD;EAEpD,SAASF,iCAAiCA,CAAac,CAAM,EAAE;IAE7D,IAAIC,MAAM,CAACD,CAAC,CAAC,KAAKA,CAAC,EAAE;MACnB,OAAOP,OAAO,CAACM,MAAM,CAAC,IAAIlB,SAAS,CAACmB,CAAC,GAAG,oBAAoB,CAAC,CAAC;IAChE;IAEA,IAAIL,IAAI,GAAGK,CAAC,CAACL,IAAI;IACjB,OAAOF,OAAO,CAACC,OAAO,CAACM,CAAC,CAACV,KAAK,CAAC,CAACY,IAAI,CAClC,UAAUZ,KAAK,EAAE;MACf,OAAO;QAAEA,KAAK,EAAEA,KAAK;QAAEK,IAAI,EAAEA;MAAK,CAAC;IACrC,CACF,CAAC;EACH;EAEA,OAAO,IAAIf,qBAAqB,CAACE,CAAC,CAAC;AACrC","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/asyncToGenerator.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/asyncToGenerator.js new file mode 100644 index 0000000000000000000000000000000000000000..9fec08d1d6fa713038fa281095f7059d4769d077 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/asyncToGenerator.js @@ -0,0 +1,38 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _asyncToGenerator; +function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { + try { + var info = gen[key](arg); + var value = info.value; + } catch (error) { + reject(error); + return; + } + if (info.done) { + resolve(value); + } else { + Promise.resolve(value).then(_next, _throw); + } +} +function _asyncToGenerator(fn) { + return function () { + var self = this, + args = arguments; + return new Promise(function (resolve, reject) { + var gen = fn.apply(self, args); + function _next(value) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); + } + function _throw(err) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); + } + _next(undefined); + }); + }; +} + +//# sourceMappingURL=asyncToGenerator.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/asyncToGenerator.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/asyncToGenerator.js.map new file mode 100644 index 0000000000000000000000000000000000000000..3f8ac5567297b7c265a025cd9325833333219000 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/asyncToGenerator.js.map @@ -0,0 +1 @@ +{"version":3,"names":["asyncGeneratorStep","gen","resolve","reject","_next","_throw","key","arg","info","value","error","done","Promise","then","_asyncToGenerator","fn","self","args","arguments","apply","err","undefined"],"sources":["../../src/helpers/asyncToGenerator.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nfunction asyncGeneratorStep(\n gen: Generator>,\n resolve: (value: TReturn) => void,\n reject: (error: unknown) => void,\n _next: (value: Awaited | undefined) => void,\n _throw: (err: unknown) => void,\n key: \"next\",\n arg: Awaited | undefined,\n): void;\nfunction asyncGeneratorStep(\n gen: Generator>,\n resolve: (value: TReturn) => void,\n reject: (error: unknown) => void,\n _next: (value: Awaited | undefined) => void,\n _throw: (err: unknown) => void,\n key: \"throw\",\n arg: unknown,\n): void;\nfunction asyncGeneratorStep(\n gen: Generator>,\n resolve: (value: TReturn) => void,\n reject: (error: unknown) => void,\n _next: (value: Awaited | undefined) => void,\n _throw: (err: unknown) => void,\n key: \"next\" | \"throw\",\n arg: any,\n): void {\n try {\n var info = gen[key](arg);\n var value = info.value;\n } catch (error) {\n reject(error);\n return;\n }\n\n if (info.done) {\n // The \"value\" variable is defined above before the \"info.done\" guard\n // So TypeScript can't narrowing \"value\" to TReturn here\n // If we use \"info.value\" here the type is narrowed correctly.\n // Still requires manual casting for the smaller bundle size.\n resolve(value as TReturn);\n } else {\n // Same as above, TypeScript can't narrow \"value\" to TYield here\n Promise.resolve(value as TYield).then(_next, _throw);\n }\n}\n\nexport default function _asyncToGenerator<\n This,\n Args extends unknown[],\n TYield,\n TReturn,\n>(\n fn: (\n this: This,\n ...args: Args\n ) => Generator>,\n): (this: This, ...args: Args) => Promise {\n return function (this: any) {\n var self = this,\n args = arguments;\n return new Promise(function (resolve, reject) {\n // Casting \"args\" to \"Args\" is intentional since we are trying to avoid the spread operator (not ES5)\n var gen = fn.apply(self, args as any as Args);\n function _next(value: Awaited | undefined) {\n asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n }\n function _throw(err: unknown) {\n asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n }\n\n _next(undefined);\n });\n };\n}\n"],"mappings":";;;;;;AAoBA,SAASA,kBAAkBA,CACzBC,GAAgD,EAChDC,OAAiC,EACjCC,MAAgC,EAChCC,KAAmD,EACnDC,MAA8B,EAC9BC,GAAqB,EACrBC,GAAQ,EACF;EACN,IAAI;IACF,IAAIC,IAAI,GAAGP,GAAG,CAACK,GAAG,CAAC,CAACC,GAAG,CAAC;IACxB,IAAIE,KAAK,GAAGD,IAAI,CAACC,KAAK;EACxB,CAAC,CAAC,OAAOC,KAAK,EAAE;IACdP,MAAM,CAACO,KAAK,CAAC;IACb;EACF;EAEA,IAAIF,IAAI,CAACG,IAAI,EAAE;IAKbT,OAAO,CAACO,KAAgB,CAAC;EAC3B,CAAC,MAAM;IAELG,OAAO,CAACV,OAAO,CAACO,KAAe,CAAC,CAACI,IAAI,CAACT,KAAK,EAAEC,MAAM,CAAC;EACtD;AACF;AAEe,SAASS,iBAAiBA,CAMvCC,EAGgD,EACC;EACjD,OAAO,YAAqB;IAC1B,IAAIC,IAAI,GAAG,IAAI;MACbC,IAAI,GAAGC,SAAS;IAClB,OAAO,IAAIN,OAAO,CAAC,UAAUV,OAAO,EAAEC,MAAM,EAAE;MAE5C,IAAIF,GAAG,GAAGc,EAAE,CAACI,KAAK,CAACH,IAAI,EAAEC,IAAmB,CAAC;MAC7C,SAASb,KAAKA,CAACK,KAAkC,EAAE;QACjDT,kBAAkB,CAACC,GAAG,EAAEC,OAAO,EAAEC,MAAM,EAAEC,KAAK,EAAEC,MAAM,EAAE,MAAM,EAAEI,KAAK,CAAC;MACxE;MACA,SAASJ,MAAMA,CAACe,GAAY,EAAE;QAC5BpB,kBAAkB,CAACC,GAAG,EAAEC,OAAO,EAAEC,MAAM,EAAEC,KAAK,EAAEC,MAAM,EAAE,OAAO,EAAEe,GAAG,CAAC;MACvE;MAEAhB,KAAK,CAACiB,SAAS,CAAC;IAClB,CAAC,CAAC;EACJ,CAAC;AACH","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/awaitAsyncGenerator.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/awaitAsyncGenerator.js new file mode 100644 index 0000000000000000000000000000000000000000..1338393f05a6947135b1f8d75cb376a84371ae45 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/awaitAsyncGenerator.js @@ -0,0 +1,12 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _awaitAsyncGenerator; +var _OverloadYield = require("./OverloadYield.js"); +function _awaitAsyncGenerator(value) { + return new _OverloadYield.default(value, 0); +} + +//# sourceMappingURL=awaitAsyncGenerator.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/awaitAsyncGenerator.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/awaitAsyncGenerator.js.map new file mode 100644 index 0000000000000000000000000000000000000000..01d22950d0c0248077a741f88a05ef8313be991f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/awaitAsyncGenerator.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_OverloadYield","require","_awaitAsyncGenerator","value","OverloadYield"],"sources":["../../src/helpers/awaitAsyncGenerator.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nimport OverloadYield from \"./OverloadYield.ts\";\n\nexport default function _awaitAsyncGenerator(value: T) {\n return new OverloadYield(value, /* kind: await */ 0);\n}\n"],"mappings":";;;;;;AAEA,IAAAA,cAAA,GAAAC,OAAA;AAEe,SAASC,oBAAoBA,CAAIC,KAAQ,EAAE;EACxD,OAAO,IAAIC,sBAAa,CAAID,KAAK,EAAoB,CAAC,CAAC;AACzD","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/callSuper.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/callSuper.js new file mode 100644 index 0000000000000000000000000000000000000000..2be00ab64098acb300052bb7dbe1ac1a500d4975 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/callSuper.js @@ -0,0 +1,15 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _callSuper; +var _getPrototypeOf = require("./getPrototypeOf.js"); +var _isNativeReflectConstruct = require("./isNativeReflectConstruct.js"); +var _possibleConstructorReturn = require("./possibleConstructorReturn.js"); +function _callSuper(_this, derived, args) { + derived = (0, _getPrototypeOf.default)(derived); + return (0, _possibleConstructorReturn.default)(_this, (0, _isNativeReflectConstruct.default)() ? Reflect.construct(derived, args || [], (0, _getPrototypeOf.default)(_this).constructor) : derived.apply(_this, args)); +} + +//# sourceMappingURL=callSuper.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/callSuper.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/callSuper.js.map new file mode 100644 index 0000000000000000000000000000000000000000..7177eebc4dbdea6ef1bbb48b423d9ebceb5520cb --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/callSuper.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_getPrototypeOf","require","_isNativeReflectConstruct","_possibleConstructorReturn","_callSuper","_this","derived","args","getPrototypeOf","possibleConstructorReturn","isNativeReflectConstruct","Reflect","construct","constructor","apply"],"sources":["../../src/helpers/callSuper.ts"],"sourcesContent":["/* @minVersion 7.23.8 */\n\n// This is duplicated to packages/babel-plugin-transform-classes/src/inline-callSuper-helpers.ts\n\nimport getPrototypeOf from \"./getPrototypeOf.ts\";\nimport isNativeReflectConstruct from \"./isNativeReflectConstruct.ts\";\nimport possibleConstructorReturn from \"./possibleConstructorReturn.ts\";\n\nexport default function _callSuper(\n _this: object,\n derived: Function,\n args: ArrayLike,\n) {\n // Super\n derived = getPrototypeOf(derived);\n return possibleConstructorReturn(\n _this,\n isNativeReflectConstruct()\n ? // NOTE: This doesn't work if this.__proto__.constructor has been modified.\n Reflect.construct(\n derived,\n args || [],\n getPrototypeOf(_this).constructor,\n )\n : derived.apply(_this, args),\n );\n}\n"],"mappings":";;;;;;AAIA,IAAAA,eAAA,GAAAC,OAAA;AACA,IAAAC,yBAAA,GAAAD,OAAA;AACA,IAAAE,0BAAA,GAAAF,OAAA;AAEe,SAASG,UAAUA,CAChCC,KAAa,EACbC,OAAiB,EACjBC,IAAoB,EACpB;EAEAD,OAAO,GAAG,IAAAE,uBAAc,EAACF,OAAO,CAAC;EACjC,OAAO,IAAAG,kCAAyB,EAC9BJ,KAAK,EACL,IAAAK,iCAAwB,EAAC,CAAC,GAEtBC,OAAO,CAACC,SAAS,CACfN,OAAO,EACPC,IAAI,IAAI,EAAE,EACV,IAAAC,uBAAc,EAACH,KAAK,CAAC,CAACQ,WACxB,CAAC,GACDP,OAAO,CAACQ,KAAK,CAACT,KAAK,EAAEE,IAAI,CAC/B,CAAC;AACH","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/checkInRHS.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/checkInRHS.js new file mode 100644 index 0000000000000000000000000000000000000000..0a6d3c74af2843a69d6a144d76496b63fb54cf9c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/checkInRHS.js @@ -0,0 +1,14 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _checkInRHS; +function _checkInRHS(value) { + if (Object(value) !== value) { + throw TypeError("right-hand side of 'in' should be an object, got " + (value !== null ? typeof value : "null")); + } + return value; +} + +//# sourceMappingURL=checkInRHS.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/checkInRHS.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/checkInRHS.js.map new file mode 100644 index 0000000000000000000000000000000000000000..5bcc4cc14161aeb0479a896dc5dc546c5a356947 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/checkInRHS.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_checkInRHS","value","Object","TypeError"],"sources":["../../src/helpers/checkInRHS.ts"],"sourcesContent":["/* @minVersion 7.20.5 */\n\nexport default function _checkInRHS(value: unknown) {\n if (Object(value) !== value) {\n throw TypeError(\n \"right-hand side of 'in' should be an object, got \" +\n (value !== null ? typeof value : \"null\"),\n );\n }\n return value;\n}\n"],"mappings":";;;;;;AAEe,SAASA,WAAWA,CAACC,KAAc,EAAE;EAClD,IAAIC,MAAM,CAACD,KAAK,CAAC,KAAKA,KAAK,EAAE;IAC3B,MAAME,SAAS,CACb,mDAAmD,IAChDF,KAAK,KAAK,IAAI,GAAG,OAAOA,KAAK,GAAG,MAAM,CAC3C,CAAC;EACH;EACA,OAAOA,KAAK;AACd","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/checkPrivateRedeclaration.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/checkPrivateRedeclaration.js new file mode 100644 index 0000000000000000000000000000000000000000..b14520ea3856593409de15e404968c64eec7ea21 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/checkPrivateRedeclaration.js @@ -0,0 +1,13 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _checkPrivateRedeclaration; +function _checkPrivateRedeclaration(obj, privateCollection) { + if (privateCollection.has(obj)) { + throw new TypeError("Cannot initialize the same private elements twice on an object"); + } +} + +//# sourceMappingURL=checkPrivateRedeclaration.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/checkPrivateRedeclaration.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/checkPrivateRedeclaration.js.map new file mode 100644 index 0000000000000000000000000000000000000000..9170bc529a6bec0803d58312c3f0c14569b9c7f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/checkPrivateRedeclaration.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_checkPrivateRedeclaration","obj","privateCollection","has","TypeError"],"sources":["../../src/helpers/checkPrivateRedeclaration.ts"],"sourcesContent":["/* @minVersion 7.14.1 */\n\nexport default function _checkPrivateRedeclaration(\n obj: object,\n privateCollection: WeakMap | WeakSet,\n) {\n if (privateCollection.has(obj)) {\n throw new TypeError(\n \"Cannot initialize the same private elements twice on an object\",\n );\n }\n}\n"],"mappings":";;;;;;AAEe,SAASA,0BAA0BA,CAChDC,GAAW,EACXC,iBAA6D,EAC7D;EACA,IAAIA,iBAAiB,CAACC,GAAG,CAACF,GAAG,CAAC,EAAE;IAC9B,MAAM,IAAIG,SAAS,CACjB,gEACF,CAAC;EACH;AACF","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classApplyDescriptorDestructureSet.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classApplyDescriptorDestructureSet.js new file mode 100644 index 0000000000000000000000000000000000000000..0159ce6ce0abcc238e30220bf61b0e9c7fcda91c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classApplyDescriptorDestructureSet.js @@ -0,0 +1,25 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classApplyDescriptorDestructureSet; +function _classApplyDescriptorDestructureSet(receiver, descriptor) { + if (descriptor.set) { + if (!("__destrObj" in descriptor)) { + descriptor.__destrObj = { + set value(v) { + descriptor.set.call(receiver, v); + } + }; + } + return descriptor.__destrObj; + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + return descriptor; + } +} + +//# sourceMappingURL=classApplyDescriptorDestructureSet.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classApplyDescriptorDestructureSet.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classApplyDescriptorDestructureSet.js.map new file mode 100644 index 0000000000000000000000000000000000000000..3cb25572c58f023c0f1bcdd944f75d7de85c77ee --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classApplyDescriptorDestructureSet.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_classApplyDescriptorDestructureSet","receiver","descriptor","set","__destrObj","value","v","call","writable","TypeError"],"sources":["../../src/helpers/classApplyDescriptorDestructureSet.js"],"sourcesContent":["/* @minVersion 7.13.10 */\n/* @onlyBabel7 */\n\nexport default function _classApplyDescriptorDestructureSet(\n receiver,\n descriptor,\n) {\n if (descriptor.set) {\n if (!(\"__destrObj\" in descriptor)) {\n descriptor.__destrObj = {\n set value(v) {\n descriptor.set.call(receiver, v);\n },\n };\n }\n return descriptor.__destrObj;\n } else {\n if (!descriptor.writable) {\n // This should only throw in strict mode, but class bodies are\n // always strict and private fields can only be used inside\n // class bodies.\n throw new TypeError(\"attempted to set read only private field\");\n }\n\n return descriptor;\n }\n}\n"],"mappings":";;;;;;AAGe,SAASA,mCAAmCA,CACzDC,QAAQ,EACRC,UAAU,EACV;EACA,IAAIA,UAAU,CAACC,GAAG,EAAE;IAClB,IAAI,EAAE,YAAY,IAAID,UAAU,CAAC,EAAE;MACjCA,UAAU,CAACE,UAAU,GAAG;QACtB,IAAIC,KAAKA,CAACC,CAAC,EAAE;UACXJ,UAAU,CAACC,GAAG,CAACI,IAAI,CAACN,QAAQ,EAAEK,CAAC,CAAC;QAClC;MACF,CAAC;IACH;IACA,OAAOJ,UAAU,CAACE,UAAU;EAC9B,CAAC,MAAM;IACL,IAAI,CAACF,UAAU,CAACM,QAAQ,EAAE;MAIxB,MAAM,IAAIC,SAAS,CAAC,0CAA0C,CAAC;IACjE;IAEA,OAAOP,UAAU;EACnB;AACF","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classApplyDescriptorGet.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classApplyDescriptorGet.js new file mode 100644 index 0000000000000000000000000000000000000000..0730734dd0665597a10678bd3103a0efd4fbe352 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classApplyDescriptorGet.js @@ -0,0 +1,14 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classApplyDescriptorGet; +function _classApplyDescriptorGet(receiver, descriptor) { + if (descriptor.get) { + return descriptor.get.call(receiver); + } + return descriptor.value; +} + +//# sourceMappingURL=classApplyDescriptorGet.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classApplyDescriptorGet.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classApplyDescriptorGet.js.map new file mode 100644 index 0000000000000000000000000000000000000000..45fabb93fbb70a284ec32df9fe2264c70b29869c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classApplyDescriptorGet.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_classApplyDescriptorGet","receiver","descriptor","get","call","value"],"sources":["../../src/helpers/classApplyDescriptorGet.js"],"sourcesContent":["/* @minVersion 7.13.10 */\n/* @onlyBabel7 */\n\nexport default function _classApplyDescriptorGet(receiver, descriptor) {\n if (descriptor.get) {\n return descriptor.get.call(receiver);\n }\n return descriptor.value;\n}\n"],"mappings":";;;;;;AAGe,SAASA,wBAAwBA,CAACC,QAAQ,EAAEC,UAAU,EAAE;EACrE,IAAIA,UAAU,CAACC,GAAG,EAAE;IAClB,OAAOD,UAAU,CAACC,GAAG,CAACC,IAAI,CAACH,QAAQ,CAAC;EACtC;EACA,OAAOC,UAAU,CAACG,KAAK;AACzB","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classApplyDescriptorSet.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classApplyDescriptorSet.js new file mode 100644 index 0000000000000000000000000000000000000000..a0ffc8a8b6842b404218391f15c280070440a93c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classApplyDescriptorSet.js @@ -0,0 +1,18 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classApplyDescriptorSet; +function _classApplyDescriptorSet(receiver, descriptor, value) { + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + descriptor.value = value; + } +} + +//# sourceMappingURL=classApplyDescriptorSet.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classApplyDescriptorSet.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classApplyDescriptorSet.js.map new file mode 100644 index 0000000000000000000000000000000000000000..5438c78621011a75f4bd8eaa438fbe464de5dc61 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classApplyDescriptorSet.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_classApplyDescriptorSet","receiver","descriptor","value","set","call","writable","TypeError"],"sources":["../../src/helpers/classApplyDescriptorSet.js"],"sourcesContent":["/* @minVersion 7.13.10 */\n/* @onlyBabel7 */\n\nexport default function _classApplyDescriptorSet(receiver, descriptor, value) {\n if (descriptor.set) {\n descriptor.set.call(receiver, value);\n } else {\n if (!descriptor.writable) {\n // This should only throw in strict mode, but class bodies are\n // always strict and private fields can only be used inside\n // class bodies.\n throw new TypeError(\"attempted to set read only private field\");\n }\n descriptor.value = value;\n }\n}\n"],"mappings":";;;;;;AAGe,SAASA,wBAAwBA,CAACC,QAAQ,EAAEC,UAAU,EAAEC,KAAK,EAAE;EAC5E,IAAID,UAAU,CAACE,GAAG,EAAE;IAClBF,UAAU,CAACE,GAAG,CAACC,IAAI,CAACJ,QAAQ,EAAEE,KAAK,CAAC;EACtC,CAAC,MAAM;IACL,IAAI,CAACD,UAAU,CAACI,QAAQ,EAAE;MAIxB,MAAM,IAAIC,SAAS,CAAC,0CAA0C,CAAC;IACjE;IACAL,UAAU,CAACC,KAAK,GAAGA,KAAK;EAC1B;AACF","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classCallCheck.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classCallCheck.js new file mode 100644 index 0000000000000000000000000000000000000000..9b56e55374bc3943745b9abe0d47012798fe7102 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classCallCheck.js @@ -0,0 +1,13 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classCallCheck; +function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +} + +//# sourceMappingURL=classCallCheck.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classCallCheck.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classCallCheck.js.map new file mode 100644 index 0000000000000000000000000000000000000000..041b85cb51cf77a51f8e2a2d7bbe96cb83df6ccf --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classCallCheck.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_classCallCheck","instance","Constructor","TypeError"],"sources":["../../src/helpers/classCallCheck.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _classCallCheck(\n instance: unknown,\n Constructor: new (...args: any[]) => T,\n): asserts instance is T {\n if (!(instance instanceof Constructor)) {\n throw new TypeError(\"Cannot call a class as a function\");\n }\n}\n"],"mappings":";;;;;;AAEe,SAASA,eAAeA,CACrCC,QAAiB,EACjBC,WAAsC,EACf;EACvB,IAAI,EAAED,QAAQ,YAAYC,WAAW,CAAC,EAAE;IACtC,MAAM,IAAIC,SAAS,CAAC,mCAAmC,CAAC;EAC1D;AACF","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classCheckPrivateStaticAccess.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classCheckPrivateStaticAccess.js new file mode 100644 index 0000000000000000000000000000000000000000..d6adf1869a70bfe40255987ab04135b610317475 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classCheckPrivateStaticAccess.js @@ -0,0 +1,12 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classCheckPrivateStaticAccess; +var _assertClassBrand = require("assertClassBrand"); +function _classCheckPrivateStaticAccess(receiver, classConstructor, returnValue) { + return _assertClassBrand(classConstructor, receiver, returnValue); +} + +//# sourceMappingURL=classCheckPrivateStaticAccess.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classCheckPrivateStaticAccess.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classCheckPrivateStaticAccess.js.map new file mode 100644 index 0000000000000000000000000000000000000000..34add344509cd2dc39e2dff333c2efc26071ed39 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classCheckPrivateStaticAccess.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_assertClassBrand","require","_classCheckPrivateStaticAccess","receiver","classConstructor","returnValue","assertClassBrand"],"sources":["../../src/helpers/classCheckPrivateStaticAccess.js"],"sourcesContent":["/* @minVersion 7.13.10 */\n/* @onlyBabel7 */\n\nimport assertClassBrand from \"assertClassBrand\";\nexport default function _classCheckPrivateStaticAccess(\n receiver,\n classConstructor,\n returnValue,\n) {\n return assertClassBrand(classConstructor, receiver, returnValue);\n}\n"],"mappings":";;;;;;AAGA,IAAAA,iBAAA,GAAAC,OAAA;AACe,SAASC,8BAA8BA,CACpDC,QAAQ,EACRC,gBAAgB,EAChBC,WAAW,EACX;EACA,OAAOC,iBAAgB,CAACF,gBAAgB,EAAED,QAAQ,EAAEE,WAAW,CAAC;AAClE","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classCheckPrivateStaticFieldDescriptor.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classCheckPrivateStaticFieldDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..6d96b72815a7989436d3797e98c503a224ec5786 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classCheckPrivateStaticFieldDescriptor.js @@ -0,0 +1,13 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classCheckPrivateStaticFieldDescriptor; +function _classCheckPrivateStaticFieldDescriptor(descriptor, action) { + if (descriptor === undefined) { + throw new TypeError("attempted to " + action + " private static field before its declaration"); + } +} + +//# sourceMappingURL=classCheckPrivateStaticFieldDescriptor.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classCheckPrivateStaticFieldDescriptor.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classCheckPrivateStaticFieldDescriptor.js.map new file mode 100644 index 0000000000000000000000000000000000000000..183b32174d9c68528ffb7e33d910a64639c750f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classCheckPrivateStaticFieldDescriptor.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_classCheckPrivateStaticFieldDescriptor","descriptor","action","undefined","TypeError"],"sources":["../../src/helpers/classCheckPrivateStaticFieldDescriptor.js"],"sourcesContent":["/* @minVersion 7.13.10 */\n/* @onlyBabel7 */\n\nexport default function _classCheckPrivateStaticFieldDescriptor(\n descriptor,\n action,\n) {\n if (descriptor === undefined) {\n throw new TypeError(\n \"attempted to \" + action + \" private static field before its declaration\",\n );\n }\n}\n"],"mappings":";;;;;;AAGe,SAASA,uCAAuCA,CAC7DC,UAAU,EACVC,MAAM,EACN;EACA,IAAID,UAAU,KAAKE,SAAS,EAAE;IAC5B,MAAM,IAAIC,SAAS,CACjB,eAAe,GAAGF,MAAM,GAAG,8CAC7B,CAAC;EACH;AACF","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classExtractFieldDescriptor.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classExtractFieldDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..aee037e9f6a27100e663af4571b0125f9e59660b --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classExtractFieldDescriptor.js @@ -0,0 +1,12 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classExtractFieldDescriptor; +var _classPrivateFieldGet = require("classPrivateFieldGet2"); +function _classExtractFieldDescriptor(receiver, privateMap) { + return _classPrivateFieldGet(privateMap, receiver); +} + +//# sourceMappingURL=classExtractFieldDescriptor.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classExtractFieldDescriptor.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classExtractFieldDescriptor.js.map new file mode 100644 index 0000000000000000000000000000000000000000..e6e81e8da98f10feee302c0909dc75e339fe0b50 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classExtractFieldDescriptor.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_classPrivateFieldGet","require","_classExtractFieldDescriptor","receiver","privateMap","classPrivateFieldGet2"],"sources":["../../src/helpers/classExtractFieldDescriptor.js"],"sourcesContent":["/* @minVersion 7.13.10 */\n/* @onlyBabel7 */\n\nimport classPrivateFieldGet2 from \"classPrivateFieldGet2\";\n\nexport default function _classExtractFieldDescriptor(receiver, privateMap) {\n return classPrivateFieldGet2(privateMap, receiver);\n}\n"],"mappings":";;;;;;AAGA,IAAAA,qBAAA,GAAAC,OAAA;AAEe,SAASC,4BAA4BA,CAACC,QAAQ,EAAEC,UAAU,EAAE;EACzE,OAAOC,qBAAqB,CAACD,UAAU,EAAED,QAAQ,CAAC;AACpD","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classNameTDZError.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classNameTDZError.js new file mode 100644 index 0000000000000000000000000000000000000000..6adfc09c1a837bf625f067c9cde2d044993cc212 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classNameTDZError.js @@ -0,0 +1,11 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classNameTDZError; +function _classNameTDZError(name) { + throw new ReferenceError('Class "' + name + '" cannot be referenced in computed property keys.'); +} + +//# sourceMappingURL=classNameTDZError.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classNameTDZError.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classNameTDZError.js.map new file mode 100644 index 0000000000000000000000000000000000000000..a640081b02212126bd471b7902ccfcb9c45dd259 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classNameTDZError.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_classNameTDZError","name","ReferenceError"],"sources":["../../src/helpers/classNameTDZError.js"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _classNameTDZError(name) {\n throw new ReferenceError(\n 'Class \"' + name + '\" cannot be referenced in computed property keys.',\n );\n}\n"],"mappings":";;;;;;AAEe,SAASA,kBAAkBA,CAACC,IAAI,EAAE;EAC/C,MAAM,IAAIC,cAAc,CACtB,SAAS,GAAGD,IAAI,GAAG,mDACrB,CAAC;AACH","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldDestructureSet.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldDestructureSet.js new file mode 100644 index 0000000000000000000000000000000000000000..caeb8a5b3ec818804d62a8ac48ac3eb57e91e694 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldDestructureSet.js @@ -0,0 +1,14 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classPrivateFieldDestructureSet; +var _classApplyDescriptorDestructureSet = require("classApplyDescriptorDestructureSet"); +var _classPrivateFieldGet = require("classPrivateFieldGet2"); +function _classPrivateFieldDestructureSet(receiver, privateMap) { + var descriptor = _classPrivateFieldGet(privateMap, receiver); + return _classApplyDescriptorDestructureSet(receiver, descriptor); +} + +//# sourceMappingURL=classPrivateFieldDestructureSet.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldDestructureSet.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldDestructureSet.js.map new file mode 100644 index 0000000000000000000000000000000000000000..ab46f775683d3ee436660a02f04cb80f4d7b10f0 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldDestructureSet.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_classApplyDescriptorDestructureSet","require","_classPrivateFieldGet","_classPrivateFieldDestructureSet","receiver","privateMap","descriptor","classPrivateFieldGet2","classApplyDescriptorDestructureSet"],"sources":["../../src/helpers/classPrivateFieldDestructureSet.js"],"sourcesContent":["/* @minVersion 7.4.4 */\n/* @onlyBabel7 */\n\nimport classApplyDescriptorDestructureSet from \"classApplyDescriptorDestructureSet\";\nimport classPrivateFieldGet2 from \"classPrivateFieldGet2\";\nexport default function _classPrivateFieldDestructureSet(receiver, privateMap) {\n var descriptor = classPrivateFieldGet2(privateMap, receiver);\n return classApplyDescriptorDestructureSet(receiver, descriptor);\n}\n"],"mappings":";;;;;;AAGA,IAAAA,mCAAA,GAAAC,OAAA;AACA,IAAAC,qBAAA,GAAAD,OAAA;AACe,SAASE,gCAAgCA,CAACC,QAAQ,EAAEC,UAAU,EAAE;EAC7E,IAAIC,UAAU,GAAGC,qBAAqB,CAACF,UAAU,EAAED,QAAQ,CAAC;EAC5D,OAAOI,mCAAkC,CAACJ,QAAQ,EAAEE,UAAU,CAAC;AACjE","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldGet.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldGet.js new file mode 100644 index 0000000000000000000000000000000000000000..225733fb2ca93a01a95871fc94599f7c0b3ff16e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldGet.js @@ -0,0 +1,14 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classPrivateFieldGet; +var _classApplyDescriptorGet = require("classApplyDescriptorGet"); +var _classPrivateFieldGet2 = require("classPrivateFieldGet2"); +function _classPrivateFieldGet(receiver, privateMap) { + var descriptor = _classPrivateFieldGet2(privateMap, receiver); + return _classApplyDescriptorGet(receiver, descriptor); +} + +//# sourceMappingURL=classPrivateFieldGet.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldGet.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldGet.js.map new file mode 100644 index 0000000000000000000000000000000000000000..8ba6a91b38a6a18da235098a45115fae04e5eb41 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldGet.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_classApplyDescriptorGet","require","_classPrivateFieldGet2","_classPrivateFieldGet","receiver","privateMap","descriptor","classPrivateFieldGet2","classApplyDescriptorGet"],"sources":["../../src/helpers/classPrivateFieldGet.js"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n/* @onlyBabel7 */\n\nimport classApplyDescriptorGet from \"classApplyDescriptorGet\";\nimport classPrivateFieldGet2 from \"classPrivateFieldGet2\";\nexport default function _classPrivateFieldGet(receiver, privateMap) {\n var descriptor = classPrivateFieldGet2(privateMap, receiver);\n return classApplyDescriptorGet(receiver, descriptor);\n}\n"],"mappings":";;;;;;AAGA,IAAAA,wBAAA,GAAAC,OAAA;AACA,IAAAC,sBAAA,GAAAD,OAAA;AACe,SAASE,qBAAqBA,CAACC,QAAQ,EAAEC,UAAU,EAAE;EAClE,IAAIC,UAAU,GAAGC,sBAAqB,CAACF,UAAU,EAAED,QAAQ,CAAC;EAC5D,OAAOI,wBAAuB,CAACJ,QAAQ,EAAEE,UAAU,CAAC;AACtD","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldGet2.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldGet2.js new file mode 100644 index 0000000000000000000000000000000000000000..655c90379bf5654398959a6709a71d1c31729be5 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldGet2.js @@ -0,0 +1,12 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classPrivateFieldGet2; +var _assertClassBrand = require("./assertClassBrand.js"); +function _classPrivateFieldGet2(privateMap, receiver) { + return privateMap.get((0, _assertClassBrand.default)(privateMap, receiver)); +} + +//# sourceMappingURL=classPrivateFieldGet2.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldGet2.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldGet2.js.map new file mode 100644 index 0000000000000000000000000000000000000000..fbc62e47d8329382e443a627f2aee59d362dedf2 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldGet2.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_assertClassBrand","require","_classPrivateFieldGet2","privateMap","receiver","get","assertClassBrand"],"sources":["../../src/helpers/classPrivateFieldGet2.ts"],"sourcesContent":["/* @minVersion 7.24.0 */\n\nimport assertClassBrand from \"./assertClassBrand.ts\";\n\nexport default function _classPrivateFieldGet2(\n privateMap: WeakMap,\n receiver: any,\n) {\n return privateMap.get(assertClassBrand(privateMap, receiver));\n}\n"],"mappings":";;;;;;AAEA,IAAAA,iBAAA,GAAAC,OAAA;AAEe,SAASC,sBAAsBA,CAC5CC,UAA6B,EAC7BC,QAAa,EACb;EACA,OAAOD,UAAU,CAACE,GAAG,CAAC,IAAAC,yBAAgB,EAACH,UAAU,EAAEC,QAAQ,CAAC,CAAC;AAC/D","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldInitSpec.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldInitSpec.js new file mode 100644 index 0000000000000000000000000000000000000000..db6806baff5c82f4bcbb7ef8ce035b3894e22425 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldInitSpec.js @@ -0,0 +1,13 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classPrivateFieldInitSpec; +var _checkPrivateRedeclaration = require("./checkPrivateRedeclaration.js"); +function _classPrivateFieldInitSpec(obj, privateMap, value) { + (0, _checkPrivateRedeclaration.default)(obj, privateMap); + privateMap.set(obj, value); +} + +//# sourceMappingURL=classPrivateFieldInitSpec.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldInitSpec.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldInitSpec.js.map new file mode 100644 index 0000000000000000000000000000000000000000..24b691d7aec8e2d4639262dfff6085e4ad6053e1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldInitSpec.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_checkPrivateRedeclaration","require","_classPrivateFieldInitSpec","obj","privateMap","value","checkPrivateRedeclaration","set"],"sources":["../../src/helpers/classPrivateFieldInitSpec.ts"],"sourcesContent":["/* @minVersion 7.14.1 */\n\nimport checkPrivateRedeclaration from \"./checkPrivateRedeclaration.ts\";\n\nexport default function _classPrivateFieldInitSpec(\n obj: object,\n privateMap: WeakMap,\n value: unknown,\n) {\n checkPrivateRedeclaration(obj, privateMap);\n privateMap.set(obj, value);\n}\n"],"mappings":";;;;;;AAEA,IAAAA,0BAAA,GAAAC,OAAA;AAEe,SAASC,0BAA0BA,CAChDC,GAAW,EACXC,UAAoC,EACpCC,KAAc,EACd;EACA,IAAAC,kCAAyB,EAACH,GAAG,EAAEC,UAAU,CAAC;EAC1CA,UAAU,CAACG,GAAG,CAACJ,GAAG,EAAEE,KAAK,CAAC;AAC5B","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldLooseBase.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldLooseBase.js new file mode 100644 index 0000000000000000000000000000000000000000..d89790b817a4653953e33df763e85f7f14e8ebc9 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldLooseBase.js @@ -0,0 +1,14 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classPrivateFieldBase; +function _classPrivateFieldBase(receiver, privateKey) { + if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { + throw new TypeError("attempted to use private field on non-instance"); + } + return receiver; +} + +//# sourceMappingURL=classPrivateFieldLooseBase.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldLooseBase.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldLooseBase.js.map new file mode 100644 index 0000000000000000000000000000000000000000..187b029a40fef22805bf63a2a45ed2601350c2df --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldLooseBase.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_classPrivateFieldBase","receiver","privateKey","Object","prototype","hasOwnProperty","call","TypeError"],"sources":["../../src/helpers/classPrivateFieldLooseBase.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _classPrivateFieldBase(\n receiver: T,\n privateKey: PropertyKey,\n) {\n if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {\n throw new TypeError(\"attempted to use private field on non-instance\");\n }\n return receiver;\n}\n"],"mappings":";;;;;;AAEe,SAASA,sBAAsBA,CAC5CC,QAAW,EACXC,UAAuB,EACvB;EACA,IAAI,CAACC,MAAM,CAACC,SAAS,CAACC,cAAc,CAACC,IAAI,CAACL,QAAQ,EAAEC,UAAU,CAAC,EAAE;IAC/D,MAAM,IAAIK,SAAS,CAAC,gDAAgD,CAAC;EACvE;EACA,OAAON,QAAQ;AACjB","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldLooseKey.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldLooseKey.js new file mode 100644 index 0000000000000000000000000000000000000000..5c3dac43f6f31dea0d30bc5fc5a843484345629e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldLooseKey.js @@ -0,0 +1,12 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classPrivateFieldKey; +var id = 0; +function _classPrivateFieldKey(name) { + return "__private_" + id++ + "_" + name; +} + +//# sourceMappingURL=classPrivateFieldLooseKey.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldLooseKey.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldLooseKey.js.map new file mode 100644 index 0000000000000000000000000000000000000000..6b84014cf63f388789f54eba5b1ba9098369e4ac --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldLooseKey.js.map @@ -0,0 +1 @@ +{"version":3,"names":["id","_classPrivateFieldKey","name"],"sources":["../../src/helpers/classPrivateFieldLooseKey.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nvar id = 0;\nexport default function _classPrivateFieldKey(name: string) {\n return \"__private_\" + id++ + \"_\" + name;\n}\n"],"mappings":";;;;;;AAEA,IAAIA,EAAE,GAAG,CAAC;AACK,SAASC,qBAAqBA,CAACC,IAAY,EAAE;EAC1D,OAAO,YAAY,GAAGF,EAAE,EAAE,GAAG,GAAG,GAAGE,IAAI;AACzC","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldSet.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldSet.js new file mode 100644 index 0000000000000000000000000000000000000000..f2466197c02a5a025fccbc8d7e75b92f5d36ed45 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldSet.js @@ -0,0 +1,15 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classPrivateFieldSet; +var _classApplyDescriptorSet = require("classApplyDescriptorSet"); +var _classPrivateFieldGet = require("classPrivateFieldGet2"); +function _classPrivateFieldSet(receiver, privateMap, value) { + var descriptor = _classPrivateFieldGet(privateMap, receiver); + _classApplyDescriptorSet(receiver, descriptor, value); + return value; +} + +//# sourceMappingURL=classPrivateFieldSet.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldSet.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldSet.js.map new file mode 100644 index 0000000000000000000000000000000000000000..67802c536a281dcaaa3b2191a50bcf9656e21afa --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldSet.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_classApplyDescriptorSet","require","_classPrivateFieldGet","_classPrivateFieldSet","receiver","privateMap","value","descriptor","classPrivateFieldGet2","classApplyDescriptorSet"],"sources":["../../src/helpers/classPrivateFieldSet.js"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n/* @onlyBabel7 */\n\nimport classApplyDescriptorSet from \"classApplyDescriptorSet\";\nimport classPrivateFieldGet2 from \"classPrivateFieldGet2\";\nexport default function _classPrivateFieldSet(receiver, privateMap, value) {\n var descriptor = classPrivateFieldGet2(privateMap, receiver);\n classApplyDescriptorSet(receiver, descriptor, value);\n return value;\n}\n"],"mappings":";;;;;;AAGA,IAAAA,wBAAA,GAAAC,OAAA;AACA,IAAAC,qBAAA,GAAAD,OAAA;AACe,SAASE,qBAAqBA,CAACC,QAAQ,EAAEC,UAAU,EAAEC,KAAK,EAAE;EACzE,IAAIC,UAAU,GAAGC,qBAAqB,CAACH,UAAU,EAAED,QAAQ,CAAC;EAC5DK,wBAAuB,CAACL,QAAQ,EAAEG,UAAU,EAAED,KAAK,CAAC;EACpD,OAAOA,KAAK;AACd","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldSet2.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldSet2.js new file mode 100644 index 0000000000000000000000000000000000000000..19cfe7f7a1f1c09fac3eb6e83964a80addab1da7 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldSet2.js @@ -0,0 +1,13 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classPrivateFieldSet2; +var _assertClassBrand = require("./assertClassBrand.js"); +function _classPrivateFieldSet2(privateMap, receiver, value) { + privateMap.set((0, _assertClassBrand.default)(privateMap, receiver), value); + return value; +} + +//# sourceMappingURL=classPrivateFieldSet2.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldSet2.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldSet2.js.map new file mode 100644 index 0000000000000000000000000000000000000000..26a4e30a73a84035e6983003c67612de4390afae --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateFieldSet2.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_assertClassBrand","require","_classPrivateFieldSet2","privateMap","receiver","value","set","assertClassBrand"],"sources":["../../src/helpers/classPrivateFieldSet2.ts"],"sourcesContent":["/* @minVersion 7.24.0 */\n\nimport assertClassBrand from \"./assertClassBrand.ts\";\n\nexport default function _classPrivateFieldSet2(\n privateMap: WeakMap,\n receiver: any,\n value: any,\n) {\n privateMap.set(assertClassBrand(privateMap, receiver), value);\n return value;\n}\n"],"mappings":";;;;;;AAEA,IAAAA,iBAAA,GAAAC,OAAA;AAEe,SAASC,sBAAsBA,CAC5CC,UAA6B,EAC7BC,QAAa,EACbC,KAAU,EACV;EACAF,UAAU,CAACG,GAAG,CAAC,IAAAC,yBAAgB,EAACJ,UAAU,EAAEC,QAAQ,CAAC,EAAEC,KAAK,CAAC;EAC7D,OAAOA,KAAK;AACd","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateGetter.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateGetter.js new file mode 100644 index 0000000000000000000000000000000000000000..ed413e0ee43bfafe02a08fb65ab83fbf52ff38e1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateGetter.js @@ -0,0 +1,12 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classPrivateGetter; +var _assertClassBrand = require("./assertClassBrand.js"); +function _classPrivateGetter(privateMap, receiver, getter) { + return getter((0, _assertClassBrand.default)(privateMap, receiver)); +} + +//# sourceMappingURL=classPrivateGetter.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateGetter.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateGetter.js.map new file mode 100644 index 0000000000000000000000000000000000000000..2799dc4262bd957cea787c7c481a59898cab54b7 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateGetter.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_assertClassBrand","require","_classPrivateGetter","privateMap","receiver","getter","assertClassBrand"],"sources":["../../src/helpers/classPrivateGetter.ts"],"sourcesContent":["/* @minVersion 7.24.0 */\n\nimport assertClassBrand from \"./assertClassBrand.ts\";\n\nexport default function _classPrivateGetter(\n privateMap: WeakMap | WeakSet,\n receiver: any,\n getter: Function,\n) {\n return getter(assertClassBrand(privateMap, receiver));\n}\n"],"mappings":";;;;;;AAEA,IAAAA,iBAAA,GAAAC,OAAA;AAEe,SAASC,mBAAmBA,CACzCC,UAA4C,EAC5CC,QAAa,EACbC,MAAgB,EAChB;EACA,OAAOA,MAAM,CAAC,IAAAC,yBAAgB,EAACH,UAAU,EAAEC,QAAQ,CAAC,CAAC;AACvD","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateMethodGet.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateMethodGet.js new file mode 100644 index 0000000000000000000000000000000000000000..a42ba7a97840e6b69fff2ac0240fdbca9bbfe921 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateMethodGet.js @@ -0,0 +1,13 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classPrivateMethodGet; +var _assertClassBrand = require("assertClassBrand"); +function _classPrivateMethodGet(receiver, privateSet, fn) { + _assertClassBrand(privateSet, receiver); + return fn; +} + +//# sourceMappingURL=classPrivateMethodGet.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateMethodGet.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateMethodGet.js.map new file mode 100644 index 0000000000000000000000000000000000000000..fbdb7465f48a0d7e542725b515cbbac313a169a0 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateMethodGet.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_assertClassBrand","require","_classPrivateMethodGet","receiver","privateSet","fn","assertClassBrand"],"sources":["../../src/helpers/classPrivateMethodGet.js"],"sourcesContent":["/* @minVersion 7.1.6 */\n/* @onlyBabel7 */\n\nimport assertClassBrand from \"assertClassBrand\";\nexport default function _classPrivateMethodGet(receiver, privateSet, fn) {\n assertClassBrand(privateSet, receiver);\n return fn;\n}\n"],"mappings":";;;;;;AAGA,IAAAA,iBAAA,GAAAC,OAAA;AACe,SAASC,sBAAsBA,CAACC,QAAQ,EAAEC,UAAU,EAAEC,EAAE,EAAE;EACvEC,iBAAgB,CAACF,UAAU,EAAED,QAAQ,CAAC;EACtC,OAAOE,EAAE;AACX","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateMethodInitSpec.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateMethodInitSpec.js new file mode 100644 index 0000000000000000000000000000000000000000..efc950294f746baea2e23de6069fbf4a697873bb --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateMethodInitSpec.js @@ -0,0 +1,13 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classPrivateMethodInitSpec; +var _checkPrivateRedeclaration = require("./checkPrivateRedeclaration.js"); +function _classPrivateMethodInitSpec(obj, privateSet) { + (0, _checkPrivateRedeclaration.default)(obj, privateSet); + privateSet.add(obj); +} + +//# sourceMappingURL=classPrivateMethodInitSpec.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateMethodInitSpec.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateMethodInitSpec.js.map new file mode 100644 index 0000000000000000000000000000000000000000..98bf9ecc91476b352b975d0b1c96351ef986986e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateMethodInitSpec.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_checkPrivateRedeclaration","require","_classPrivateMethodInitSpec","obj","privateSet","checkPrivateRedeclaration","add"],"sources":["../../src/helpers/classPrivateMethodInitSpec.ts"],"sourcesContent":["/* @minVersion 7.14.1 */\n\nimport checkPrivateRedeclaration from \"./checkPrivateRedeclaration.ts\";\n\nexport default function _classPrivateMethodInitSpec(\n obj: object,\n privateSet: WeakSet,\n) {\n checkPrivateRedeclaration(obj, privateSet);\n privateSet.add(obj);\n}\n"],"mappings":";;;;;;AAEA,IAAAA,0BAAA,GAAAC,OAAA;AAEe,SAASC,2BAA2BA,CACjDC,GAAW,EACXC,UAA2B,EAC3B;EACA,IAAAC,kCAAyB,EAACF,GAAG,EAAEC,UAAU,CAAC;EAC1CA,UAAU,CAACE,GAAG,CAACH,GAAG,CAAC;AACrB","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateMethodSet.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateMethodSet.js new file mode 100644 index 0000000000000000000000000000000000000000..49490587323ddc2b3f5006fb48a6b1debf7c1216 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateMethodSet.js @@ -0,0 +1,11 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classPrivateMethodSet; +function _classPrivateMethodSet() { + throw new TypeError("attempted to reassign private method"); +} + +//# sourceMappingURL=classPrivateMethodSet.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateMethodSet.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateMethodSet.js.map new file mode 100644 index 0000000000000000000000000000000000000000..ec8a20ff62e20cc951765b1b607ac758716e7d29 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateMethodSet.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_classPrivateMethodSet","TypeError"],"sources":["../../src/helpers/classPrivateMethodSet.js"],"sourcesContent":["/* @minVersion 7.1.6 */\n/* @onlyBabel7 */\n\n// use readOnlyError instead of attemptSet\n\nexport default function _classPrivateMethodSet() {\n throw new TypeError(\"attempted to reassign private method\");\n}\n"],"mappings":";;;;;;AAKe,SAASA,sBAAsBA,CAAA,EAAG;EAC/C,MAAM,IAAIC,SAAS,CAAC,sCAAsC,CAAC;AAC7D","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateSetter.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateSetter.js new file mode 100644 index 0000000000000000000000000000000000000000..f02ce7a92eae237b112cc0469a01feeee621f93b --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateSetter.js @@ -0,0 +1,13 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classPrivateSetter; +var _assertClassBrand = require("./assertClassBrand.js"); +function _classPrivateSetter(privateMap, setter, receiver, value) { + setter((0, _assertClassBrand.default)(privateMap, receiver), value); + return value; +} + +//# sourceMappingURL=classPrivateSetter.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateSetter.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateSetter.js.map new file mode 100644 index 0000000000000000000000000000000000000000..bbd9c5ddfc1a9d6a60a9adac3ee88eb408f7d8ca --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classPrivateSetter.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_assertClassBrand","require","_classPrivateSetter","privateMap","setter","receiver","value","assertClassBrand"],"sources":["../../src/helpers/classPrivateSetter.ts"],"sourcesContent":["/* @minVersion 7.24.0 */\n\nimport assertClassBrand from \"./assertClassBrand.ts\";\n\nexport default function _classPrivateSetter(\n privateMap: WeakMap | WeakSet,\n setter: Function,\n receiver: any,\n value: any,\n) {\n setter(assertClassBrand(privateMap, receiver), value);\n return value;\n}\n"],"mappings":";;;;;;AAEA,IAAAA,iBAAA,GAAAC,OAAA;AAEe,SAASC,mBAAmBA,CACzCC,UAA4C,EAC5CC,MAAgB,EAChBC,QAAa,EACbC,KAAU,EACV;EACAF,MAAM,CAAC,IAAAG,yBAAgB,EAACJ,UAAU,EAAEE,QAAQ,CAAC,EAAEC,KAAK,CAAC;EACrD,OAAOA,KAAK;AACd","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateFieldDestructureSet.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateFieldDestructureSet.js new file mode 100644 index 0000000000000000000000000000000000000000..2a60646b717f038ab9555b68aeb07fbb425b7376 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateFieldDestructureSet.js @@ -0,0 +1,16 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classStaticPrivateFieldDestructureSet; +var _classApplyDescriptorDestructureSet = require("classApplyDescriptorDestructureSet"); +var _assertClassBrand = require("assertClassBrand"); +var _classCheckPrivateStaticFieldDescriptor = require("classCheckPrivateStaticFieldDescriptor"); +function _classStaticPrivateFieldDestructureSet(receiver, classConstructor, descriptor) { + _assertClassBrand(classConstructor, receiver); + _classCheckPrivateStaticFieldDescriptor(descriptor, "set"); + return _classApplyDescriptorDestructureSet(receiver, descriptor); +} + +//# sourceMappingURL=classStaticPrivateFieldDestructureSet.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateFieldDestructureSet.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateFieldDestructureSet.js.map new file mode 100644 index 0000000000000000000000000000000000000000..c25c924d71a99595aa9183fd4b302b9c5c63bf8b --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateFieldDestructureSet.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_classApplyDescriptorDestructureSet","require","_assertClassBrand","_classCheckPrivateStaticFieldDescriptor","_classStaticPrivateFieldDestructureSet","receiver","classConstructor","descriptor","assertClassBrand","classCheckPrivateStaticFieldDescriptor","classApplyDescriptorDestructureSet"],"sources":["../../src/helpers/classStaticPrivateFieldDestructureSet.js"],"sourcesContent":["/* @minVersion 7.13.10 */\n/* @onlyBabel7 */\n\nimport classApplyDescriptorDestructureSet from \"classApplyDescriptorDestructureSet\";\nimport assertClassBrand from \"assertClassBrand\";\nimport classCheckPrivateStaticFieldDescriptor from \"classCheckPrivateStaticFieldDescriptor\";\nexport default function _classStaticPrivateFieldDestructureSet(\n receiver,\n classConstructor,\n descriptor,\n) {\n assertClassBrand(classConstructor, receiver);\n classCheckPrivateStaticFieldDescriptor(descriptor, \"set\");\n return classApplyDescriptorDestructureSet(receiver, descriptor);\n}\n"],"mappings":";;;;;;AAGA,IAAAA,mCAAA,GAAAC,OAAA;AACA,IAAAC,iBAAA,GAAAD,OAAA;AACA,IAAAE,uCAAA,GAAAF,OAAA;AACe,SAASG,sCAAsCA,CAC5DC,QAAQ,EACRC,gBAAgB,EAChBC,UAAU,EACV;EACAC,iBAAgB,CAACF,gBAAgB,EAAED,QAAQ,CAAC;EAC5CI,uCAAsC,CAACF,UAAU,EAAE,KAAK,CAAC;EACzD,OAAOG,mCAAkC,CAACL,QAAQ,EAAEE,UAAU,CAAC;AACjE","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateFieldSpecGet.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateFieldSpecGet.js new file mode 100644 index 0000000000000000000000000000000000000000..4e12ada10e462e966147a913171d6ee123ac7b85 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateFieldSpecGet.js @@ -0,0 +1,16 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classStaticPrivateFieldSpecGet; +var _classApplyDescriptorGet = require("classApplyDescriptorGet"); +var _assertClassBrand = require("assertClassBrand"); +var _classCheckPrivateStaticFieldDescriptor = require("classCheckPrivateStaticFieldDescriptor"); +function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) { + _assertClassBrand(classConstructor, receiver); + _classCheckPrivateStaticFieldDescriptor(descriptor, "get"); + return _classApplyDescriptorGet(receiver, descriptor); +} + +//# sourceMappingURL=classStaticPrivateFieldSpecGet.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateFieldSpecGet.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateFieldSpecGet.js.map new file mode 100644 index 0000000000000000000000000000000000000000..a707005d5fcc4e84b6e27c984211069c62139ed5 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateFieldSpecGet.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_classApplyDescriptorGet","require","_assertClassBrand","_classCheckPrivateStaticFieldDescriptor","_classStaticPrivateFieldSpecGet","receiver","classConstructor","descriptor","assertClassBrand","classCheckPrivateStaticFieldDescriptor","classApplyDescriptorGet"],"sources":["../../src/helpers/classStaticPrivateFieldSpecGet.js"],"sourcesContent":["/* @minVersion 7.0.2 */\n/* @onlyBabel7 */\n\nimport classApplyDescriptorGet from \"classApplyDescriptorGet\";\nimport assertClassBrand from \"assertClassBrand\";\nimport classCheckPrivateStaticFieldDescriptor from \"classCheckPrivateStaticFieldDescriptor\";\nexport default function _classStaticPrivateFieldSpecGet(\n receiver,\n classConstructor,\n descriptor,\n) {\n assertClassBrand(classConstructor, receiver);\n classCheckPrivateStaticFieldDescriptor(descriptor, \"get\");\n return classApplyDescriptorGet(receiver, descriptor);\n}\n"],"mappings":";;;;;;AAGA,IAAAA,wBAAA,GAAAC,OAAA;AACA,IAAAC,iBAAA,GAAAD,OAAA;AACA,IAAAE,uCAAA,GAAAF,OAAA;AACe,SAASG,+BAA+BA,CACrDC,QAAQ,EACRC,gBAAgB,EAChBC,UAAU,EACV;EACAC,iBAAgB,CAACF,gBAAgB,EAAED,QAAQ,CAAC;EAC5CI,uCAAsC,CAACF,UAAU,EAAE,KAAK,CAAC;EACzD,OAAOG,wBAAuB,CAACL,QAAQ,EAAEE,UAAU,CAAC;AACtD","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateFieldSpecSet.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateFieldSpecSet.js new file mode 100644 index 0000000000000000000000000000000000000000..b0aa7944fcd1bf7352b6f6240e5bbebcb9a1cec8 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateFieldSpecSet.js @@ -0,0 +1,17 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classStaticPrivateFieldSpecSet; +var _classApplyDescriptorSet = require("classApplyDescriptorSet"); +var _assertClassBrand = require("assertClassBrand"); +var _classCheckPrivateStaticFieldDescriptor = require("classCheckPrivateStaticFieldDescriptor"); +function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) { + _assertClassBrand(classConstructor, receiver); + _classCheckPrivateStaticFieldDescriptor(descriptor, "set"); + _classApplyDescriptorSet(receiver, descriptor, value); + return value; +} + +//# sourceMappingURL=classStaticPrivateFieldSpecSet.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateFieldSpecSet.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateFieldSpecSet.js.map new file mode 100644 index 0000000000000000000000000000000000000000..a57c804a6d972a946874b21cd2637d3e20d779b2 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateFieldSpecSet.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_classApplyDescriptorSet","require","_assertClassBrand","_classCheckPrivateStaticFieldDescriptor","_classStaticPrivateFieldSpecSet","receiver","classConstructor","descriptor","value","assertClassBrand","classCheckPrivateStaticFieldDescriptor","classApplyDescriptorSet"],"sources":["../../src/helpers/classStaticPrivateFieldSpecSet.js"],"sourcesContent":["/* @minVersion 7.0.2 */\n/* @onlyBabel7 */\n\nimport classApplyDescriptorSet from \"classApplyDescriptorSet\";\nimport assertClassBrand from \"assertClassBrand\";\nimport classCheckPrivateStaticFieldDescriptor from \"classCheckPrivateStaticFieldDescriptor\";\nexport default function _classStaticPrivateFieldSpecSet(\n receiver,\n classConstructor,\n descriptor,\n value,\n) {\n assertClassBrand(classConstructor, receiver);\n classCheckPrivateStaticFieldDescriptor(descriptor, \"set\");\n classApplyDescriptorSet(receiver, descriptor, value);\n return value;\n}\n"],"mappings":";;;;;;AAGA,IAAAA,wBAAA,GAAAC,OAAA;AACA,IAAAC,iBAAA,GAAAD,OAAA;AACA,IAAAE,uCAAA,GAAAF,OAAA;AACe,SAASG,+BAA+BA,CACrDC,QAAQ,EACRC,gBAAgB,EAChBC,UAAU,EACVC,KAAK,EACL;EACAC,iBAAgB,CAACH,gBAAgB,EAAED,QAAQ,CAAC;EAC5CK,uCAAsC,CAACH,UAAU,EAAE,KAAK,CAAC;EACzDI,wBAAuB,CAACN,QAAQ,EAAEE,UAAU,EAAEC,KAAK,CAAC;EACpD,OAAOA,KAAK;AACd","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateMethodGet.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateMethodGet.js new file mode 100644 index 0000000000000000000000000000000000000000..21003ce6d4ccb7b55654dcef1f4697ec71043eed --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateMethodGet.js @@ -0,0 +1,13 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classStaticPrivateMethodGet; +var _assertClassBrand = require("./assertClassBrand.js"); +function _classStaticPrivateMethodGet(receiver, classConstructor, method) { + (0, _assertClassBrand.default)(classConstructor, receiver); + return method; +} + +//# sourceMappingURL=classStaticPrivateMethodGet.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateMethodGet.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateMethodGet.js.map new file mode 100644 index 0000000000000000000000000000000000000000..ac2401b876b7e47ca9e009d6f61f8e6e50e690cf --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateMethodGet.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_assertClassBrand","require","_classStaticPrivateMethodGet","receiver","classConstructor","method","assertClassBrand"],"sources":["../../src/helpers/classStaticPrivateMethodGet.ts"],"sourcesContent":["/* @minVersion 7.3.2 */\n\nimport assertClassBrand from \"./assertClassBrand.ts\";\nexport default function _classStaticPrivateMethodGet(\n receiver: Function,\n classConstructor: Function,\n method: T,\n) {\n assertClassBrand(classConstructor, receiver);\n return method;\n}\n"],"mappings":";;;;;;AAEA,IAAAA,iBAAA,GAAAC,OAAA;AACe,SAASC,4BAA4BA,CAClDC,QAAkB,EAClBC,gBAA0B,EAC1BC,MAAS,EACT;EACA,IAAAC,yBAAgB,EAACF,gBAAgB,EAAED,QAAQ,CAAC;EAC5C,OAAOE,MAAM;AACf","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateMethodSet.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateMethodSet.js new file mode 100644 index 0000000000000000000000000000000000000000..a983dfc7d093c0cfaab7427ce9720be71f83bf3d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateMethodSet.js @@ -0,0 +1,11 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _classStaticPrivateMethodSet; +function _classStaticPrivateMethodSet() { + throw new TypeError("attempted to set read only static private field"); +} + +//# sourceMappingURL=classStaticPrivateMethodSet.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateMethodSet.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateMethodSet.js.map new file mode 100644 index 0000000000000000000000000000000000000000..1be9fa83016a444423fd2cf8af212c4325117b63 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/classStaticPrivateMethodSet.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_classStaticPrivateMethodSet","TypeError"],"sources":["../../src/helpers/classStaticPrivateMethodSet.js"],"sourcesContent":["/* @minVersion 7.3.2 */\n/* @onlyBabel7 */\n\nexport default function _classStaticPrivateMethodSet() {\n throw new TypeError(\"attempted to set read only static private field\");\n}\n"],"mappings":";;;;;;AAGe,SAASA,4BAA4BA,CAAA,EAAG;EACrD,MAAM,IAAIC,SAAS,CAAC,iDAAiD,CAAC;AACxE","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/construct.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/construct.js new file mode 100644 index 0000000000000000000000000000000000000000..e32d400b7e2d49012bba4d4f700efaacfa8abcca --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/construct.js @@ -0,0 +1,20 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _construct; +var _isNativeReflectConstruct = require("./isNativeReflectConstruct.js"); +var _setPrototypeOf = require("./setPrototypeOf.js"); +function _construct(Parent, args, Class) { + if ((0, _isNativeReflectConstruct.default)()) { + return Reflect.construct.apply(null, arguments); + } + var a = [null]; + a.push.apply(a, args); + var instance = new (Parent.bind.apply(Parent, a))(); + if (Class) (0, _setPrototypeOf.default)(instance, Class.prototype); + return instance; +} + +//# sourceMappingURL=construct.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/construct.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/construct.js.map new file mode 100644 index 0000000000000000000000000000000000000000..b7c87a0a9c367a7734ba369b767a2426870d6823 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/construct.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_isNativeReflectConstruct","require","_setPrototypeOf","_construct","Parent","args","Class","isNativeReflectConstruct","Reflect","construct","apply","arguments","a","push","instance","bind","setPrototypeOf","prototype"],"sources":["../../src/helpers/construct.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nimport isNativeReflectConstruct from \"./isNativeReflectConstruct.ts\";\nimport setPrototypeOf from \"./setPrototypeOf.ts\";\n\nexport default function _construct(\n Parent: Function,\n args: any[],\n Class: Function,\n): any {\n if (isNativeReflectConstruct()) {\n // Avoid issues with Class being present but undefined when it wasn't\n // present in the original call.\n return Reflect.construct.apply(null, arguments as any);\n }\n // NOTE: If Parent !== Class, the correct __proto__ is set *after*\n // calling the constructor.\n var a: [any, ...any[]] = [null];\n a.push.apply(a, args);\n var instance = new (Parent.bind.apply(Parent, a))();\n if (Class) setPrototypeOf(instance, Class.prototype);\n return instance;\n}\n"],"mappings":";;;;;;AAEA,IAAAA,yBAAA,GAAAC,OAAA;AACA,IAAAC,eAAA,GAAAD,OAAA;AAEe,SAASE,UAAUA,CAChCC,MAAgB,EAChBC,IAAW,EACXC,KAAe,EACV;EACL,IAAI,IAAAC,iCAAwB,EAAC,CAAC,EAAE;IAG9B,OAAOC,OAAO,CAACC,SAAS,CAACC,KAAK,CAAC,IAAI,EAAEC,SAAgB,CAAC;EACxD;EAGA,IAAIC,CAAkB,GAAG,CAAC,IAAI,CAAC;EAC/BA,CAAC,CAACC,IAAI,CAACH,KAAK,CAACE,CAAC,EAAEP,IAAI,CAAC;EACrB,IAAIS,QAAQ,GAAG,KAAKV,MAAM,CAACW,IAAI,CAACL,KAAK,CAACN,MAAM,EAAEQ,CAAC,CAAC,EAAE,CAAC;EACnD,IAAIN,KAAK,EAAE,IAAAU,uBAAc,EAACF,QAAQ,EAAER,KAAK,CAACW,SAAS,CAAC;EACpD,OAAOH,QAAQ;AACjB","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createClass.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createClass.js new file mode 100644 index 0000000000000000000000000000000000000000..c10839cd77166a728c9688278be870f4057acec6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createClass.js @@ -0,0 +1,26 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _createClass; +var _toPropertyKey = require("./toPropertyKey.js"); +function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, (0, _toPropertyKey.default)(descriptor.key), descriptor); + } +} +function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + Object.defineProperty(Constructor, "prototype", { + writable: false + }); + return Constructor; +} + +//# sourceMappingURL=createClass.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createClass.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createClass.js.map new file mode 100644 index 0000000000000000000000000000000000000000..b570f6849ab3b6d33fce198ac281bef896fce446 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createClass.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_toPropertyKey","require","_defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","Object","defineProperty","toPropertyKey","key","_createClass","Constructor","protoProps","staticProps","prototype"],"sources":["../../src/helpers/createClass.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nimport toPropertyKey from \"./toPropertyKey.ts\";\n\ninterface Prop extends PropertyDescriptor {\n key: PropertyKey;\n}\n\nfunction _defineProperties(target: object, props: Prop[]): void {\n for (var i = 0; i < props.length; i++) {\n var descriptor = props[i];\n descriptor.enumerable = descriptor.enumerable || false;\n descriptor.configurable = true;\n if (\"value\" in descriptor) descriptor.writable = true;\n Object.defineProperty(target, toPropertyKey(descriptor.key), descriptor);\n }\n}\n\nexport default function _createClass any>(\n Constructor: T,\n protoProps?: Prop[],\n staticProps?: Prop[],\n): T {\n if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n if (staticProps) _defineProperties(Constructor, staticProps);\n Object.defineProperty(Constructor, \"prototype\", { writable: false });\n return Constructor;\n}\n"],"mappings":";;;;;;AAEA,IAAAA,cAAA,GAAAC,OAAA;AAMA,SAASC,iBAAiBA,CAACC,MAAc,EAAEC,KAAa,EAAQ;EAC9D,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGD,KAAK,CAACE,MAAM,EAAED,CAAC,EAAE,EAAE;IACrC,IAAIE,UAAU,GAAGH,KAAK,CAACC,CAAC,CAAC;IACzBE,UAAU,CAACC,UAAU,GAAGD,UAAU,CAACC,UAAU,IAAI,KAAK;IACtDD,UAAU,CAACE,YAAY,GAAG,IAAI;IAC9B,IAAI,OAAO,IAAIF,UAAU,EAAEA,UAAU,CAACG,QAAQ,GAAG,IAAI;IACrDC,MAAM,CAACC,cAAc,CAACT,MAAM,EAAE,IAAAU,sBAAa,EAACN,UAAU,CAACO,GAAG,CAAC,EAAEP,UAAU,CAAC;EAC1E;AACF;AAEe,SAASQ,YAAYA,CAClCC,WAAc,EACdC,UAAmB,EACnBC,WAAoB,EACjB;EACH,IAAID,UAAU,EAAEf,iBAAiB,CAACc,WAAW,CAACG,SAAS,EAAEF,UAAU,CAAC;EACpE,IAAIC,WAAW,EAAEhB,iBAAiB,CAACc,WAAW,EAAEE,WAAW,CAAC;EAC5DP,MAAM,CAACC,cAAc,CAACI,WAAW,EAAE,WAAW,EAAE;IAAEN,QAAQ,EAAE;EAAM,CAAC,CAAC;EACpE,OAAOM,WAAW;AACpB","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createForOfIteratorHelper.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createForOfIteratorHelper.js new file mode 100644 index 0000000000000000000000000000000000000000..c4ebafc7716ece85a8a6edb2bee5cd6ad7279909 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createForOfIteratorHelper.js @@ -0,0 +1,64 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _createForOfIteratorHelper; +var _unsupportedIterableToArray = require("./unsupportedIterableToArray.js"); +function _createForOfIteratorHelper(o, allowArrayLike) { + var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; + if (!it) { + if (Array.isArray(o) || (it = (0, _unsupportedIterableToArray.default)(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + var F = function () {}; + return { + s: F, + n: function () { + if (i >= o.length) { + return { + done: true + }; + } + return { + done: false, + value: o[i++] + }; + }, + e: function (e) { + throw e; + }, + f: F + }; + } + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + var normalCompletion = true, + didErr = false, + err; + return { + s: function () { + it = it.call(o); + }, + n: function () { + var step = it.next(); + normalCompletion = step.done; + return step; + }, + e: function (e) { + didErr = true; + err = e; + }, + f: function () { + try { + if (!normalCompletion && it["return"] != null) { + it["return"](); + } + } finally { + if (didErr) throw err; + } + } + }; +} + +//# sourceMappingURL=createForOfIteratorHelper.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createForOfIteratorHelper.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createForOfIteratorHelper.js.map new file mode 100644 index 0000000000000000000000000000000000000000..7e04327e10eb3e8501ddbd79046a1ad70a847de7 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createForOfIteratorHelper.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_unsupportedIterableToArray","require","_createForOfIteratorHelper","o","allowArrayLike","it","Symbol","iterator","Array","isArray","unsupportedIterableToArray","length","i","F","s","n","done","value","e","f","TypeError","normalCompletion","didErr","err","call","step","next"],"sources":["../../src/helpers/createForOfIteratorHelper.ts"],"sourcesContent":["/* @minVersion 7.9.0 */\n\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.ts\";\n\nexport type IteratorFunction = () => Iterator;\n\nexport interface ForOfIteratorHelper {\n // s: start (create the iterator)\n s: () => void;\n // n: next\n n: () => IteratorResult;\n // e: error (called whenever something throws)\n e: (e: Error) => void;\n // f: finish (always called at the end)\n f: () => void;\n}\n\nexport default function _createForOfIteratorHelper(\n o: T[] | Iterable | ArrayLike,\n allowArrayLike: boolean,\n): ForOfIteratorHelper {\n var it: IteratorFunction | Iterator | T[] | undefined =\n (typeof Symbol !== \"undefined\" && (o as Iterable)[Symbol.iterator]) ||\n (o as any)[\"@@iterator\"];\n\n if (!it) {\n // Fallback for engines without symbol support\n if (\n Array.isArray(o) ||\n // union type doesn't work with function overload, have to use \"as any\".\n (it = unsupportedIterableToArray(o as any) as T[] | undefined) ||\n (allowArrayLike && o && typeof (o as ArrayLike).length === \"number\")\n ) {\n if (it) o = it;\n var i = 0;\n var F = function () {};\n return {\n s: F,\n n: function () {\n // After \"Array.isArray\" check, unsupportedIterableToArray to array, and allow arraylike\n // o is sure to be an array or arraylike, but TypeScript doesn't know that\n if (i >= (o as T[] | ArrayLike).length) {\n // explicit missing the \"value\" (undefined) to reduce the bundle size\n return { done: true } as IteratorReturnResult;\n }\n return { done: false, value: (o as T[] | ArrayLike)[i++] };\n },\n e: function (e: Error) {\n throw e;\n },\n f: F,\n };\n }\n\n throw new TypeError(\n \"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\",\n );\n }\n\n var normalCompletion = true,\n didErr = false,\n err: Error | undefined;\n\n // \"it\" is being reassigned multiple times to reduce the variables (bundle size)\n // thus TypeScript can't infer the correct type of the \"it\"\n return {\n s: function () {\n it = (it as IteratorFunction).call(o);\n },\n n: function () {\n var step = (it as Iterator).next();\n normalCompletion = step.done!;\n return step;\n },\n e: function (e: Error) {\n didErr = true;\n err = e;\n },\n f: function () {\n try {\n if (!normalCompletion && (it as Iterator)[\"return\"] != null) {\n (it as Iterator)[\"return\"]!();\n }\n } finally {\n // eslint-disable-next-line no-unsafe-finally\n if (didErr) throw err!;\n }\n },\n };\n}\n"],"mappings":";;;;;;AAEA,IAAAA,2BAAA,GAAAC,OAAA;AAee,SAASC,0BAA0BA,CAChDC,CAAmC,EACnCC,cAAuB,EACC;EACxB,IAAIC,EAAuD,GACxD,OAAOC,MAAM,KAAK,WAAW,IAAKH,CAAC,CAAiBG,MAAM,CAACC,QAAQ,CAAC,IACpEJ,CAAC,CAAS,YAAY,CAAC;EAE1B,IAAI,CAACE,EAAE,EAAE;IAEP,IACEG,KAAK,CAACC,OAAO,CAACN,CAAC,CAAC,KAEfE,EAAE,GAAG,IAAAK,mCAA0B,EAACP,CAAQ,CAAoB,CAAC,IAC7DC,cAAc,IAAID,CAAC,IAAI,OAAQA,CAAC,CAAkBQ,MAAM,KAAK,QAAS,EACvE;MACA,IAAIN,EAAE,EAAEF,CAAC,GAAGE,EAAE;MACd,IAAIO,CAAC,GAAG,CAAC;MACT,IAAIC,CAAC,GAAG,SAAAA,CAAA,EAAY,CAAC,CAAC;MACtB,OAAO;QACLC,CAAC,EAAED,CAAC;QACJE,CAAC,EAAE,SAAAA,CAAA,EAAY;UAGb,IAAIH,CAAC,IAAKT,CAAC,CAAwBQ,MAAM,EAAE;YAEzC,OAAO;cAAEK,IAAI,EAAE;YAAK,CAAC;UACvB;UACA,OAAO;YAAEA,IAAI,EAAE,KAAK;YAAEC,KAAK,EAAGd,CAAC,CAAwBS,CAAC,EAAE;UAAE,CAAC;QAC/D,CAAC;QACDM,CAAC,EAAE,SAAAA,CAAUA,CAAQ,EAAE;UACrB,MAAMA,CAAC;QACT,CAAC;QACDC,CAAC,EAAEN;MACL,CAAC;IACH;IAEA,MAAM,IAAIO,SAAS,CACjB,uIACF,CAAC;EACH;EAEA,IAAIC,gBAAgB,GAAG,IAAI;IACzBC,MAAM,GAAG,KAAK;IACdC,GAAsB;EAIxB,OAAO;IACLT,CAAC,EAAE,SAAAA,CAAA,EAAY;MACbT,EAAE,GAAIA,EAAE,CAAyBmB,IAAI,CAACrB,CAAC,CAAC;IAC1C,CAAC;IACDY,CAAC,EAAE,SAAAA,CAAA,EAAY;MACb,IAAIU,IAAI,GAAIpB,EAAE,CAAiBqB,IAAI,CAAC,CAAC;MACrCL,gBAAgB,GAAGI,IAAI,CAACT,IAAK;MAC7B,OAAOS,IAAI;IACb,CAAC;IACDP,CAAC,EAAE,SAAAA,CAAUA,CAAQ,EAAE;MACrBI,MAAM,GAAG,IAAI;MACbC,GAAG,GAAGL,CAAC;IACT,CAAC;IACDC,CAAC,EAAE,SAAAA,CAAA,EAAY;MACb,IAAI;QACF,IAAI,CAACE,gBAAgB,IAAKhB,EAAE,CAAiB,QAAQ,CAAC,IAAI,IAAI,EAAE;UAC7DA,EAAE,CAAiB,QAAQ,CAAC,CAAE,CAAC;QAClC;MACF,CAAC,SAAS;QAER,IAAIiB,MAAM,EAAE,MAAMC,GAAG;MACvB;IACF;EACF,CAAC;AACH","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createForOfIteratorHelperLoose.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createForOfIteratorHelperLoose.js new file mode 100644 index 0000000000000000000000000000000000000000..71b0d5056ceb662aabbbba2c055ac6f6d747735a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createForOfIteratorHelperLoose.js @@ -0,0 +1,29 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _createForOfIteratorHelperLoose; +var _unsupportedIterableToArray = require("./unsupportedIterableToArray.js"); +function _createForOfIteratorHelperLoose(o, allowArrayLike) { + var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; + if (it) return (it = it.call(o)).next.bind(it); + if (Array.isArray(o) || (it = (0, _unsupportedIterableToArray.default)(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + return function () { + if (i >= o.length) { + return { + done: true + }; + } + return { + done: false, + value: o[i++] + }; + }; + } + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} + +//# sourceMappingURL=createForOfIteratorHelperLoose.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createForOfIteratorHelperLoose.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createForOfIteratorHelperLoose.js.map new file mode 100644 index 0000000000000000000000000000000000000000..fec96ad6950ae359ea72ff23bede8e5c22be20fa --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createForOfIteratorHelperLoose.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_unsupportedIterableToArray","require","_createForOfIteratorHelperLoose","o","allowArrayLike","it","Symbol","iterator","call","next","bind","Array","isArray","unsupportedIterableToArray","length","i","done","value","TypeError"],"sources":["../../src/helpers/createForOfIteratorHelperLoose.ts"],"sourcesContent":["/* @minVersion 7.9.0 */\n\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.ts\";\n\nimport type { IteratorFunction } from \"./createForOfIteratorHelper.ts\";\n\nexport default function _createForOfIteratorHelperLoose(\n o: T[] | Iterable | ArrayLike,\n allowArrayLike: boolean,\n): () => IteratorResult {\n var it:\n | IteratorFunction\n | Iterator\n | T[]\n | IteratorResult\n | undefined =\n (typeof Symbol !== \"undefined\" && (o as Iterable)[Symbol.iterator]) ||\n (o as any)[\"@@iterator\"];\n\n if (it) return (it = (it as IteratorFunction).call(o)).next.bind(it);\n\n // Fallback for engines without symbol support\n if (\n Array.isArray(o) ||\n // union type doesn't work with function overload, have to use \"as any\".\n (it = unsupportedIterableToArray(o as any) as T[] | undefined) ||\n (allowArrayLike && o && typeof (o as ArrayLike).length === \"number\")\n ) {\n if (it) o = it;\n var i = 0;\n return function () {\n // After \"Array.isArray\" check, unsupportedIterableToArray to array, and allow arraylike\n // o is sure to be an array or arraylike, but TypeScript doesn't know that\n if (i >= (o as T[] | ArrayLike).length) {\n // explicit missing the \"value\" (undefined) to reduce the bundle size\n return { done: true } as IteratorReturnResult;\n }\n\n return { done: false, value: (o as T[] | ArrayLike)[i++] };\n };\n }\n\n throw new TypeError(\n \"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\",\n );\n}\n"],"mappings":";;;;;;AAEA,IAAAA,2BAAA,GAAAC,OAAA;AAIe,SAASC,+BAA+BA,CACrDC,CAAmC,EACnCC,cAAuB,EACa;EACpC,IAAIC,EAKS,GACV,OAAOC,MAAM,KAAK,WAAW,IAAKH,CAAC,CAAiBG,MAAM,CAACC,QAAQ,CAAC,IACpEJ,CAAC,CAAS,YAAY,CAAC;EAE1B,IAAIE,EAAE,EAAE,OAAO,CAACA,EAAE,GAAIA,EAAE,CAAyBG,IAAI,CAACL,CAAC,CAAC,EAAEM,IAAI,CAACC,IAAI,CAACL,EAAE,CAAC;EAGvE,IACEM,KAAK,CAACC,OAAO,CAACT,CAAC,CAAC,KAEfE,EAAE,GAAG,IAAAQ,mCAA0B,EAACV,CAAQ,CAAoB,CAAC,IAC7DC,cAAc,IAAID,CAAC,IAAI,OAAQA,CAAC,CAAkBW,MAAM,KAAK,QAAS,EACvE;IACA,IAAIT,EAAE,EAAEF,CAAC,GAAGE,EAAE;IACd,IAAIU,CAAC,GAAG,CAAC;IACT,OAAO,YAAY;MAGjB,IAAIA,CAAC,IAAKZ,CAAC,CAAwBW,MAAM,EAAE;QAEzC,OAAO;UAAEE,IAAI,EAAE;QAAK,CAAC;MACvB;MAEA,OAAO;QAAEA,IAAI,EAAE,KAAK;QAAEC,KAAK,EAAGd,CAAC,CAAwBY,CAAC,EAAE;MAAE,CAAC;IAC/D,CAAC;EACH;EAEA,MAAM,IAAIG,SAAS,CACjB,uIACF,CAAC;AACH","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createSuper.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createSuper.js new file mode 100644 index 0000000000000000000000000000000000000000..03b94bd22b3efa0f8f2558da9a7eb14feb34fddc --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createSuper.js @@ -0,0 +1,25 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _createSuper; +var _getPrototypeOf = require("getPrototypeOf"); +var _isNativeReflectConstruct = require("isNativeReflectConstruct"); +var _possibleConstructorReturn = require("possibleConstructorReturn"); +function _createSuper(Derived) { + var hasNativeReflectConstruct = _isNativeReflectConstruct(); + return function _createSuperInternal() { + var Super = _getPrototypeOf(Derived), + result; + if (hasNativeReflectConstruct) { + var NewTarget = _getPrototypeOf(this).constructor; + result = Reflect.construct(Super, arguments, NewTarget); + } else { + result = Super.apply(this, arguments); + } + return _possibleConstructorReturn(this, result); + }; +} + +//# sourceMappingURL=createSuper.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createSuper.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createSuper.js.map new file mode 100644 index 0000000000000000000000000000000000000000..fbbd49a6fc4843beab4d3528ece9ad8d959a2d6d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/createSuper.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_getPrototypeOf","require","_isNativeReflectConstruct","_possibleConstructorReturn","_createSuper","Derived","hasNativeReflectConstruct","isNativeReflectConstruct","_createSuperInternal","Super","getPrototypeOf","result","NewTarget","constructor","Reflect","construct","arguments","apply","possibleConstructorReturn"],"sources":["../../src/helpers/createSuper.js"],"sourcesContent":["/* @minVersion 7.9.0 */\n\nimport getPrototypeOf from \"getPrototypeOf\";\nimport isNativeReflectConstruct from \"isNativeReflectConstruct\";\nimport possibleConstructorReturn from \"possibleConstructorReturn\";\n\nexport default function _createSuper(Derived) {\n var hasNativeReflectConstruct = isNativeReflectConstruct();\n\n return function _createSuperInternal() {\n var Super = getPrototypeOf(Derived),\n result;\n if (hasNativeReflectConstruct) {\n // NOTE: This doesn't work if this.__proto__.constructor has been modified.\n var NewTarget = getPrototypeOf(this).constructor;\n result = Reflect.construct(Super, arguments, NewTarget);\n } else {\n result = Super.apply(this, arguments);\n }\n return possibleConstructorReturn(this, result);\n };\n}\n"],"mappings":";;;;;;AAEA,IAAAA,eAAA,GAAAC,OAAA;AACA,IAAAC,yBAAA,GAAAD,OAAA;AACA,IAAAE,0BAAA,GAAAF,OAAA;AAEe,SAASG,YAAYA,CAACC,OAAO,EAAE;EAC5C,IAAIC,yBAAyB,GAAGC,yBAAwB,CAAC,CAAC;EAE1D,OAAO,SAASC,oBAAoBA,CAAA,EAAG;IACrC,IAAIC,KAAK,GAAGC,eAAc,CAACL,OAAO,CAAC;MACjCM,MAAM;IACR,IAAIL,yBAAyB,EAAE;MAE7B,IAAIM,SAAS,GAAGF,eAAc,CAAC,IAAI,CAAC,CAACG,WAAW;MAChDF,MAAM,GAAGG,OAAO,CAACC,SAAS,CAACN,KAAK,EAAEO,SAAS,EAAEJ,SAAS,CAAC;IACzD,CAAC,MAAM;MACLD,MAAM,GAAGF,KAAK,CAACQ,KAAK,CAAC,IAAI,EAAED,SAAS,CAAC;IACvC;IACA,OAAOE,0BAAyB,CAAC,IAAI,EAAEP,MAAM,CAAC;EAChD,CAAC;AACH","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/decorate.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/decorate.js new file mode 100644 index 0000000000000000000000000000000000000000..63e0c41ab7d4cb671dae1fa1fb9d67c6bf697e78 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/decorate.js @@ -0,0 +1,350 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _decorate; +var _toArray = require("toArray"); +var _toPropertyKey = require("toPropertyKey"); +function _decorate(decorators, factory, superClass, mixins) { + var api = _getDecoratorsApi(); + if (mixins) { + for (var i = 0; i < mixins.length; i++) { + api = mixins[i](api); + } + } + var r = factory(function initialize(O) { + api.initializeInstanceElements(O, decorated.elements); + }, superClass); + var decorated = api.decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators); + api.initializeClassElements(r.F, decorated.elements); + return api.runClassFinishers(r.F, decorated.finishers); +} +function _getDecoratorsApi() { + _getDecoratorsApi = function () { + return api; + }; + var api = { + elementsDefinitionOrder: [["method"], ["field"]], + initializeInstanceElements: function (O, elements) { + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + if (element.kind === kind && element.placement === "own") { + this.defineClassElement(O, element); + } + }, this); + }, this); + }, + initializeClassElements: function (F, elements) { + var proto = F.prototype; + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + var placement = element.placement; + if (element.kind === kind && (placement === "static" || placement === "prototype")) { + var receiver = placement === "static" ? F : proto; + this.defineClassElement(receiver, element); + } + }, this); + }, this); + }, + defineClassElement: function (receiver, element) { + var descriptor = element.descriptor; + if (element.kind === "field") { + var initializer = element.initializer; + descriptor = { + enumerable: descriptor.enumerable, + writable: descriptor.writable, + configurable: descriptor.configurable, + value: initializer === void 0 ? void 0 : initializer.call(receiver) + }; + } + Object.defineProperty(receiver, element.key, descriptor); + }, + decorateClass: function (elements, decorators) { + var newElements = []; + var finishers = []; + var placements = { + static: [], + prototype: [], + own: [] + }; + elements.forEach(function (element) { + this.addElementPlacement(element, placements); + }, this); + elements.forEach(function (element) { + if (!_hasDecorators(element)) return newElements.push(element); + var elementFinishersExtras = this.decorateElement(element, placements); + newElements.push(elementFinishersExtras.element); + newElements.push.apply(newElements, elementFinishersExtras.extras); + finishers.push.apply(finishers, elementFinishersExtras.finishers); + }, this); + if (!decorators) { + return { + elements: newElements, + finishers: finishers + }; + } + var result = this.decorateConstructor(newElements, decorators); + finishers.push.apply(finishers, result.finishers); + result.finishers = finishers; + return result; + }, + addElementPlacement: function (element, placements, silent) { + var keys = placements[element.placement]; + if (!silent && keys.indexOf(element.key) !== -1) { + throw new TypeError("Duplicated element (" + element.key + ")"); + } + keys.push(element.key); + }, + decorateElement: function (element, placements) { + var extras = []; + var finishers = []; + for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) { + var keys = placements[element.placement]; + keys.splice(keys.indexOf(element.key), 1); + var elementObject = this.fromElementDescriptor(element); + var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject); + element = elementFinisherExtras.element; + this.addElementPlacement(element, placements); + if (elementFinisherExtras.finisher) { + finishers.push(elementFinisherExtras.finisher); + } + var newExtras = elementFinisherExtras.extras; + if (newExtras) { + for (var j = 0; j < newExtras.length; j++) { + this.addElementPlacement(newExtras[j], placements); + } + extras.push.apply(extras, newExtras); + } + } + return { + element: element, + finishers: finishers, + extras: extras + }; + }, + decorateConstructor: function (elements, decorators) { + var finishers = []; + for (var i = decorators.length - 1; i >= 0; i--) { + var obj = this.fromClassDescriptor(elements); + var elementsAndFinisher = this.toClassDescriptor((0, decorators[i])(obj) || obj); + if (elementsAndFinisher.finisher !== undefined) { + finishers.push(elementsAndFinisher.finisher); + } + if (elementsAndFinisher.elements !== undefined) { + elements = elementsAndFinisher.elements; + for (var j = 0; j < elements.length - 1; j++) { + for (var k = j + 1; k < elements.length; k++) { + if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) { + throw new TypeError("Duplicated element (" + elements[j].key + ")"); + } + } + } + } + } + return { + elements: elements, + finishers: finishers + }; + }, + fromElementDescriptor: function (element) { + var obj = { + kind: element.kind, + key: element.key, + placement: element.placement, + descriptor: element.descriptor + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + if (element.kind === "field") obj.initializer = element.initializer; + return obj; + }, + toElementDescriptors: function (elementObjects) { + if (elementObjects === undefined) return; + return _toArray(elementObjects).map(function (elementObject) { + var element = this.toElementDescriptor(elementObject); + this.disallowProperty(elementObject, "finisher", "An element descriptor"); + this.disallowProperty(elementObject, "extras", "An element descriptor"); + return element; + }, this); + }, + toElementDescriptor: function (elementObject) { + var kind = String(elementObject.kind); + if (kind !== "method" && kind !== "field") { + throw new TypeError('An element descriptor\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"'); + } + var key = _toPropertyKey(elementObject.key); + var placement = String(elementObject.placement); + if (placement !== "static" && placement !== "prototype" && placement !== "own") { + throw new TypeError('An element descriptor\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"'); + } + var descriptor = elementObject.descriptor; + this.disallowProperty(elementObject, "elements", "An element descriptor"); + var element = { + kind: kind, + key: key, + placement: placement, + descriptor: Object.assign({}, descriptor) + }; + if (kind !== "field") { + this.disallowProperty(elementObject, "initializer", "A method descriptor"); + } else { + this.disallowProperty(descriptor, "get", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "set", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "value", "The property descriptor of a field descriptor"); + element.initializer = elementObject.initializer; + } + return element; + }, + toElementFinisherExtras: function (elementObject) { + var element = this.toElementDescriptor(elementObject); + var finisher = _optionalCallableProperty(elementObject, "finisher"); + var extras = this.toElementDescriptors(elementObject.extras); + return { + element: element, + finisher: finisher, + extras: extras + }; + }, + fromClassDescriptor: function (elements) { + var obj = { + kind: "class", + elements: elements.map(this.fromElementDescriptor, this) + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + return obj; + }, + toClassDescriptor: function (obj) { + var kind = String(obj.kind); + if (kind !== "class") { + throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"'); + } + this.disallowProperty(obj, "key", "A class descriptor"); + this.disallowProperty(obj, "placement", "A class descriptor"); + this.disallowProperty(obj, "descriptor", "A class descriptor"); + this.disallowProperty(obj, "initializer", "A class descriptor"); + this.disallowProperty(obj, "extras", "A class descriptor"); + var finisher = _optionalCallableProperty(obj, "finisher"); + var elements = this.toElementDescriptors(obj.elements); + return { + elements: elements, + finisher: finisher + }; + }, + runClassFinishers: function (constructor, finishers) { + for (var i = 0; i < finishers.length; i++) { + var newConstructor = (0, finishers[i])(constructor); + if (newConstructor !== undefined) { + if (typeof newConstructor !== "function") { + throw new TypeError("Finishers must return a constructor."); + } + constructor = newConstructor; + } + } + return constructor; + }, + disallowProperty: function (obj, name, objectType) { + if (obj[name] !== undefined) { + throw new TypeError(objectType + " can't have a ." + name + " property."); + } + } + }; + return api; +} +function _createElementDescriptor(def) { + var key = _toPropertyKey(def.key); + var descriptor; + if (def.kind === "method") { + descriptor = { + value: def.value, + writable: true, + configurable: true, + enumerable: false + }; + } else if (def.kind === "get") { + descriptor = { + get: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "set") { + descriptor = { + set: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "field") { + descriptor = { + configurable: true, + writable: true, + enumerable: true + }; + } + var element = { + kind: def.kind === "field" ? "field" : "method", + key: key, + placement: def.static ? "static" : def.kind === "field" ? "own" : "prototype", + descriptor: descriptor + }; + if (def.decorators) element.decorators = def.decorators; + if (def.kind === "field") element.initializer = def.value; + return element; +} +function _coalesceGetterSetter(element, other) { + if (element.descriptor.get !== undefined) { + other.descriptor.get = element.descriptor.get; + } else { + other.descriptor.set = element.descriptor.set; + } +} +function _coalesceClassElements(elements) { + var newElements = []; + var isSameElement = function (other) { + return other.kind === "method" && other.key === element.key && other.placement === element.placement; + }; + for (var i = 0; i < elements.length; i++) { + var element = elements[i]; + var other; + if (element.kind === "method" && (other = newElements.find(isSameElement))) { + if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) { + if (_hasDecorators(element) || _hasDecorators(other)) { + throw new ReferenceError("Duplicated methods (" + element.key + ") can't be decorated."); + } + other.descriptor = element.descriptor; + } else { + if (_hasDecorators(element)) { + if (_hasDecorators(other)) { + throw new ReferenceError("Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ")."); + } + other.decorators = element.decorators; + } + _coalesceGetterSetter(element, other); + } + } else { + newElements.push(element); + } + } + return newElements; +} +function _hasDecorators(element) { + return element.decorators && element.decorators.length; +} +function _isDataDescriptor(desc) { + return desc !== undefined && !(desc.value === undefined && desc.writable === undefined); +} +function _optionalCallableProperty(obj, name) { + var value = obj[name]; + if (value !== undefined && typeof value !== "function") { + throw new TypeError("Expected '" + name + "' to be a function"); + } + return value; +} + +//# sourceMappingURL=decorate.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/decorate.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/decorate.js.map new file mode 100644 index 0000000000000000000000000000000000000000..44b01c68faa9620d6b4eb565ac9f44ddd4b21fc5 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/decorate.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_toArray","require","_toPropertyKey","_decorate","decorators","factory","superClass","mixins","api","_getDecoratorsApi","i","length","r","initialize","O","initializeInstanceElements","decorated","elements","decorateClass","_coalesceClassElements","d","map","_createElementDescriptor","initializeClassElements","F","runClassFinishers","finishers","elementsDefinitionOrder","forEach","kind","element","placement","defineClassElement","proto","prototype","receiver","descriptor","initializer","enumerable","writable","configurable","value","call","Object","defineProperty","key","newElements","placements","static","own","addElementPlacement","_hasDecorators","push","elementFinishersExtras","decorateElement","apply","extras","result","decorateConstructor","silent","keys","indexOf","TypeError","splice","elementObject","fromElementDescriptor","elementFinisherExtras","toElementFinisherExtras","finisher","newExtras","j","obj","fromClassDescriptor","elementsAndFinisher","toClassDescriptor","undefined","k","desc","Symbol","toStringTag","toElementDescriptors","elementObjects","toArray","toElementDescriptor","disallowProperty","String","toPropertyKey","assign","_optionalCallableProperty","constructor","newConstructor","name","objectType","def","get","set","_coalesceGetterSetter","other","isSameElement","find","_isDataDescriptor","ReferenceError"],"sources":["../../src/helpers/decorate.js"],"sourcesContent":["/* @minVersion 7.1.5 */\n\n// TODO: Only Babel 7\n\nimport toArray from \"toArray\";\nimport toPropertyKey from \"toPropertyKey\";\n\n/*::\n type PropertyDescriptor =\n | {\n value: any,\n writable: boolean,\n configurable: boolean,\n enumerable: boolean,\n }\n | {\n get?: () => any,\n set?: (v: any) => void,\n configurable: boolean,\n enumerable: boolean,\n };\n\n type FieldDescriptor ={\n writable: boolean,\n configurable: boolean,\n enumerable: boolean,\n };\n\n type Placement = \"static\" | \"prototype\" | \"own\";\n type Key = string | symbol; // PrivateName is not supported yet.\n\n type ElementDescriptor =\n | {\n kind: \"method\",\n key: Key,\n placement: Placement,\n descriptor: PropertyDescriptor\n }\n | {\n kind: \"field\",\n key: Key,\n placement: Placement,\n descriptor: FieldDescriptor,\n initializer?: () => any,\n };\n\n // This is exposed to the user code\n type ElementObjectInput = ElementDescriptor & {\n [@@toStringTag]?: \"Descriptor\"\n };\n\n // This is exposed to the user code\n type ElementObjectOutput = ElementDescriptor & {\n [@@toStringTag]?: \"Descriptor\"\n extras?: ElementDescriptor[],\n finisher?: ClassFinisher,\n };\n\n // This is exposed to the user code\n type ClassObject = {\n [@@toStringTag]?: \"Descriptor\",\n kind: \"class\",\n elements: ElementDescriptor[],\n };\n\n type ElementDecorator = (descriptor: ElementObjectInput) => ?ElementObjectOutput;\n type ClassDecorator = (descriptor: ClassObject) => ?ClassObject;\n type ClassFinisher = (cl: Class) => Class;\n\n // Only used by Babel in the transform output, not part of the spec.\n type ElementDefinition =\n | {\n kind: \"method\",\n value: any,\n key: Key,\n static?: boolean,\n decorators?: ElementDecorator[],\n }\n | {\n kind: \"field\",\n value: () => any,\n key: Key,\n static?: boolean,\n decorators?: ElementDecorator[],\n };\n\n declare function ClassFactory(initialize: (instance: C) => void): {\n F: Class,\n d: ElementDefinition[]\n }\n\n */\n\n/*::\n // Various combinations with/without extras and with one or many finishers\n\n type ElementFinisherExtras = {\n element: ElementDescriptor,\n finisher?: ClassFinisher,\n extras?: ElementDescriptor[],\n };\n\n type ElementFinishersExtras = {\n element: ElementDescriptor,\n finishers: ClassFinisher[],\n extras: ElementDescriptor[],\n };\n\n type ElementsFinisher = {\n elements: ElementDescriptor[],\n finisher?: ClassFinisher,\n };\n\n type ElementsFinishers = {\n elements: ElementDescriptor[],\n finishers: ClassFinisher[],\n };\n\n */\n\n/*::\n\n type Placements = {\n static: Key[],\n prototype: Key[],\n own: Key[],\n };\n\n */\n\n// ClassDefinitionEvaluation (Steps 26-*)\nexport default function _decorate(\n decorators /*: ClassDecorator[] */,\n factory /*: ClassFactory */,\n superClass /*: ?Class<*> */,\n mixins /*: ?Array */,\n) /*: Class<*> */ {\n var api = _getDecoratorsApi();\n if (mixins) {\n for (var i = 0; i < mixins.length; i++) {\n api = mixins[i](api);\n }\n }\n\n var r = factory(function initialize(O) {\n api.initializeInstanceElements(O, decorated.elements);\n }, superClass);\n var decorated = api.decorateClass(\n _coalesceClassElements(r.d.map(_createElementDescriptor)),\n decorators,\n );\n\n api.initializeClassElements(r.F, decorated.elements);\n\n return api.runClassFinishers(r.F, decorated.finishers);\n}\n\nfunction _getDecoratorsApi() {\n _getDecoratorsApi = function () {\n return api;\n };\n\n var api = {\n elementsDefinitionOrder: [[\"method\"], [\"field\"]],\n\n // InitializeInstanceElements\n initializeInstanceElements: function (\n /*::*/ O /*: C */,\n elements /*: ElementDescriptor[] */,\n ) {\n [\"method\", \"field\"].forEach(function (kind) {\n elements.forEach(function (element /*: ElementDescriptor */) {\n if (element.kind === kind && element.placement === \"own\") {\n this.defineClassElement(O, element);\n }\n }, this);\n }, this);\n },\n\n // InitializeClassElements\n initializeClassElements: function (\n /*::*/ F /*: Class */,\n elements /*: ElementDescriptor[] */,\n ) {\n var proto = F.prototype;\n\n [\"method\", \"field\"].forEach(function (kind) {\n elements.forEach(function (element /*: ElementDescriptor */) {\n var placement = element.placement;\n if (\n element.kind === kind &&\n (placement === \"static\" || placement === \"prototype\")\n ) {\n var receiver = placement === \"static\" ? F : proto;\n this.defineClassElement(receiver, element);\n }\n }, this);\n }, this);\n },\n\n // DefineClassElement\n defineClassElement: function (\n /*::*/ receiver /*: C | Class */,\n element /*: ElementDescriptor */,\n ) {\n var descriptor /*: PropertyDescriptor */ = element.descriptor;\n if (element.kind === \"field\") {\n var initializer = element.initializer;\n descriptor = {\n enumerable: descriptor.enumerable,\n writable: descriptor.writable,\n configurable: descriptor.configurable,\n value: initializer === void 0 ? void 0 : initializer.call(receiver),\n };\n }\n Object.defineProperty(receiver, element.key, descriptor);\n },\n\n // DecorateClass\n decorateClass: function (\n elements /*: ElementDescriptor[] */,\n decorators /*: ClassDecorator[] */,\n ) /*: ElementsFinishers */ {\n var newElements /*: ElementDescriptor[] */ = [];\n var finishers /*: ClassFinisher[] */ = [];\n var placements /*: Placements */ = {\n static: [],\n prototype: [],\n own: [],\n };\n\n elements.forEach(function (element /*: ElementDescriptor */) {\n this.addElementPlacement(element, placements);\n }, this);\n\n elements.forEach(function (element /*: ElementDescriptor */) {\n if (!_hasDecorators(element)) return newElements.push(element);\n\n var elementFinishersExtras /*: ElementFinishersExtras */ =\n this.decorateElement(element, placements);\n newElements.push(elementFinishersExtras.element);\n newElements.push.apply(newElements, elementFinishersExtras.extras);\n finishers.push.apply(finishers, elementFinishersExtras.finishers);\n }, this);\n\n if (!decorators) {\n return { elements: newElements, finishers: finishers };\n }\n\n var result /*: ElementsFinishers */ = this.decorateConstructor(\n newElements,\n decorators,\n );\n finishers.push.apply(finishers, result.finishers);\n result.finishers = finishers;\n\n return result;\n },\n\n // AddElementPlacement\n addElementPlacement: function (\n element /*: ElementDescriptor */,\n placements /*: Placements */,\n silent /*: boolean */,\n ) {\n var keys = placements[element.placement];\n if (!silent && keys.indexOf(element.key) !== -1) {\n throw new TypeError(\"Duplicated element (\" + element.key + \")\");\n }\n keys.push(element.key);\n },\n\n // DecorateElement\n decorateElement: function (\n element /*: ElementDescriptor */,\n placements /*: Placements */,\n ) /*: ElementFinishersExtras */ {\n var extras /*: ElementDescriptor[] */ = [];\n var finishers /*: ClassFinisher[] */ = [];\n\n for (\n var decorators = element.decorators, i = decorators.length - 1;\n i >= 0;\n i--\n ) {\n // (inlined) RemoveElementPlacement\n var keys = placements[element.placement];\n keys.splice(keys.indexOf(element.key), 1);\n\n var elementObject /*: ElementObjectInput */ =\n this.fromElementDescriptor(element);\n var elementFinisherExtras /*: ElementFinisherExtras */ =\n this.toElementFinisherExtras(\n (0, decorators[i])(elementObject) /*: ElementObjectOutput */ ||\n elementObject,\n );\n\n element = elementFinisherExtras.element;\n this.addElementPlacement(element, placements);\n\n if (elementFinisherExtras.finisher) {\n finishers.push(elementFinisherExtras.finisher);\n }\n\n var newExtras /*: ElementDescriptor[] | void */ =\n elementFinisherExtras.extras;\n if (newExtras) {\n for (var j = 0; j < newExtras.length; j++) {\n this.addElementPlacement(newExtras[j], placements);\n }\n extras.push.apply(extras, newExtras);\n }\n }\n\n return { element: element, finishers: finishers, extras: extras };\n },\n\n // DecorateConstructor\n decorateConstructor: function (\n elements /*: ElementDescriptor[] */,\n decorators /*: ClassDecorator[] */,\n ) /*: ElementsFinishers */ {\n var finishers /*: ClassFinisher[] */ = [];\n\n for (var i = decorators.length - 1; i >= 0; i--) {\n var obj /*: ClassObject */ = this.fromClassDescriptor(elements);\n var elementsAndFinisher /*: ElementsFinisher */ =\n this.toClassDescriptor(\n (0, decorators[i])(obj) /*: ClassObject */ || obj,\n );\n\n if (elementsAndFinisher.finisher !== undefined) {\n finishers.push(elementsAndFinisher.finisher);\n }\n\n if (elementsAndFinisher.elements !== undefined) {\n elements = elementsAndFinisher.elements;\n\n for (var j = 0; j < elements.length - 1; j++) {\n for (var k = j + 1; k < elements.length; k++) {\n if (\n elements[j].key === elements[k].key &&\n elements[j].placement === elements[k].placement\n ) {\n throw new TypeError(\n \"Duplicated element (\" + elements[j].key + \")\",\n );\n }\n }\n }\n }\n }\n\n return { elements: elements, finishers: finishers };\n },\n\n // FromElementDescriptor\n fromElementDescriptor: function (\n element /*: ElementDescriptor */,\n ) /*: ElementObject */ {\n var obj /*: ElementObject */ = {\n kind: element.kind,\n key: element.key,\n placement: element.placement,\n descriptor: element.descriptor,\n };\n\n var desc = {\n value: \"Descriptor\",\n configurable: true,\n };\n Object.defineProperty(obj, Symbol.toStringTag, desc);\n\n if (element.kind === \"field\") obj.initializer = element.initializer;\n\n return obj;\n },\n\n // ToElementDescriptors\n toElementDescriptors: function (\n elementObjects /*: ElementObject[] */,\n ) /*: ElementDescriptor[] */ {\n if (elementObjects === undefined) return;\n return toArray(elementObjects).map(function (elementObject) {\n var element = this.toElementDescriptor(elementObject);\n this.disallowProperty(\n elementObject,\n \"finisher\",\n \"An element descriptor\",\n );\n this.disallowProperty(elementObject, \"extras\", \"An element descriptor\");\n return element;\n }, this);\n },\n\n // ToElementDescriptor\n toElementDescriptor: function (\n elementObject /*: ElementObject */,\n ) /*: ElementDescriptor */ {\n var kind = String(elementObject.kind);\n if (kind !== \"method\" && kind !== \"field\") {\n throw new TypeError(\n 'An element descriptor\\'s .kind property must be either \"method\" or' +\n ' \"field\", but a decorator created an element descriptor with' +\n ' .kind \"' +\n kind +\n '\"',\n );\n }\n\n var key = toPropertyKey(elementObject.key);\n\n var placement = String(elementObject.placement);\n if (\n placement !== \"static\" &&\n placement !== \"prototype\" &&\n placement !== \"own\"\n ) {\n throw new TypeError(\n 'An element descriptor\\'s .placement property must be one of \"static\",' +\n ' \"prototype\" or \"own\", but a decorator created an element descriptor' +\n ' with .placement \"' +\n placement +\n '\"',\n );\n }\n\n var descriptor /*: PropertyDescriptor */ = elementObject.descriptor;\n\n this.disallowProperty(elementObject, \"elements\", \"An element descriptor\");\n\n var element /*: ElementDescriptor */ = {\n kind: kind,\n key: key,\n placement: placement,\n descriptor: Object.assign({}, descriptor),\n };\n\n if (kind !== \"field\") {\n this.disallowProperty(\n elementObject,\n \"initializer\",\n \"A method descriptor\",\n );\n } else {\n this.disallowProperty(\n descriptor,\n \"get\",\n \"The property descriptor of a field descriptor\",\n );\n this.disallowProperty(\n descriptor,\n \"set\",\n \"The property descriptor of a field descriptor\",\n );\n this.disallowProperty(\n descriptor,\n \"value\",\n \"The property descriptor of a field descriptor\",\n );\n\n element.initializer = elementObject.initializer;\n }\n\n return element;\n },\n\n toElementFinisherExtras: function (\n elementObject /*: ElementObject */,\n ) /*: ElementFinisherExtras */ {\n var element /*: ElementDescriptor */ =\n this.toElementDescriptor(elementObject);\n var finisher /*: ClassFinisher */ = _optionalCallableProperty(\n elementObject,\n \"finisher\",\n );\n var extras /*: ElementDescriptors[] */ = this.toElementDescriptors(\n elementObject.extras,\n );\n\n return { element: element, finisher: finisher, extras: extras };\n },\n\n // FromClassDescriptor\n fromClassDescriptor: function (\n elements /*: ElementDescriptor[] */,\n ) /*: ClassObject */ {\n var obj = {\n kind: \"class\",\n elements: elements.map(this.fromElementDescriptor, this),\n };\n\n var desc = { value: \"Descriptor\", configurable: true };\n Object.defineProperty(obj, Symbol.toStringTag, desc);\n\n return obj;\n },\n\n // ToClassDescriptor\n toClassDescriptor: function (\n obj /*: ClassObject */,\n ) /*: ElementsFinisher */ {\n var kind = String(obj.kind);\n if (kind !== \"class\") {\n throw new TypeError(\n 'A class descriptor\\'s .kind property must be \"class\", but a decorator' +\n ' created a class descriptor with .kind \"' +\n kind +\n '\"',\n );\n }\n\n this.disallowProperty(obj, \"key\", \"A class descriptor\");\n this.disallowProperty(obj, \"placement\", \"A class descriptor\");\n this.disallowProperty(obj, \"descriptor\", \"A class descriptor\");\n this.disallowProperty(obj, \"initializer\", \"A class descriptor\");\n this.disallowProperty(obj, \"extras\", \"A class descriptor\");\n\n var finisher = _optionalCallableProperty(obj, \"finisher\");\n var elements = this.toElementDescriptors(obj.elements);\n\n return { elements: elements, finisher: finisher };\n },\n\n // RunClassFinishers\n runClassFinishers: function (\n constructor /*: Class<*> */,\n finishers /*: ClassFinisher[] */,\n ) /*: Class<*> */ {\n for (var i = 0; i < finishers.length; i++) {\n var newConstructor /*: ?Class<*> */ = (0, finishers[i])(constructor);\n if (newConstructor !== undefined) {\n // NOTE: This should check if IsConstructor(newConstructor) is false.\n if (typeof newConstructor !== \"function\") {\n throw new TypeError(\"Finishers must return a constructor.\");\n }\n constructor = newConstructor;\n }\n }\n return constructor;\n },\n\n disallowProperty: function (obj, name, objectType) {\n if (obj[name] !== undefined) {\n throw new TypeError(\n objectType + \" can't have a .\" + name + \" property.\",\n );\n }\n },\n };\n\n return api;\n}\n\n// ClassElementEvaluation\nfunction _createElementDescriptor(\n def /*: ElementDefinition */,\n) /*: ElementDescriptor */ {\n var key = toPropertyKey(def.key);\n\n var descriptor /*: PropertyDescriptor */;\n if (def.kind === \"method\") {\n descriptor = {\n value: def.value,\n writable: true,\n configurable: true,\n enumerable: false,\n };\n } else if (def.kind === \"get\") {\n descriptor = { get: def.value, configurable: true, enumerable: false };\n } else if (def.kind === \"set\") {\n descriptor = { set: def.value, configurable: true, enumerable: false };\n } else if (def.kind === \"field\") {\n descriptor = { configurable: true, writable: true, enumerable: true };\n }\n\n var element /*: ElementDescriptor */ = {\n kind: def.kind === \"field\" ? \"field\" : \"method\",\n key: key,\n placement: def.static\n ? \"static\"\n : def.kind === \"field\"\n ? \"own\"\n : \"prototype\",\n descriptor: descriptor,\n };\n if (def.decorators) element.decorators = def.decorators;\n if (def.kind === \"field\") element.initializer = def.value;\n\n return element;\n}\n\n// CoalesceGetterSetter\nfunction _coalesceGetterSetter(\n element /*: ElementDescriptor */,\n other /*: ElementDescriptor */,\n) {\n if (element.descriptor.get !== undefined) {\n other.descriptor.get = element.descriptor.get;\n } else {\n other.descriptor.set = element.descriptor.set;\n }\n}\n\n// CoalesceClassElements\nfunction _coalesceClassElements(\n elements /*: ElementDescriptor[] */,\n) /*: ElementDescriptor[] */ {\n var newElements /*: ElementDescriptor[] */ = [];\n\n var isSameElement = function (other /*: ElementDescriptor */) /*: boolean */ {\n return (\n other.kind === \"method\" &&\n other.key === element.key &&\n other.placement === element.placement\n );\n };\n\n for (var i = 0; i < elements.length; i++) {\n var element /*: ElementDescriptor */ = elements[i];\n var other /*: ElementDescriptor */;\n\n if (\n element.kind === \"method\" &&\n (other = newElements.find(isSameElement))\n ) {\n if (\n _isDataDescriptor(element.descriptor) ||\n _isDataDescriptor(other.descriptor)\n ) {\n if (_hasDecorators(element) || _hasDecorators(other)) {\n throw new ReferenceError(\n \"Duplicated methods (\" + element.key + \") can't be decorated.\",\n );\n }\n other.descriptor = element.descriptor;\n } else {\n if (_hasDecorators(element)) {\n if (_hasDecorators(other)) {\n throw new ReferenceError(\n \"Decorators can't be placed on different accessors with for \" +\n \"the same property (\" +\n element.key +\n \").\",\n );\n }\n other.decorators = element.decorators;\n }\n _coalesceGetterSetter(element, other);\n }\n } else {\n newElements.push(element);\n }\n }\n\n return newElements;\n}\n\nfunction _hasDecorators(element /*: ElementDescriptor */) /*: boolean */ {\n return element.decorators && element.decorators.length;\n}\n\nfunction _isDataDescriptor(desc /*: PropertyDescriptor */) /*: boolean */ {\n return (\n desc !== undefined &&\n !(desc.value === undefined && desc.writable === undefined)\n );\n}\n\nfunction _optionalCallableProperty /*::*/(\n obj /*: T */,\n name /*: $Keys */,\n) /*: ?Function */ {\n var value = obj[name];\n if (value !== undefined && typeof value !== \"function\") {\n throw new TypeError(\"Expected '\" + name + \"' to be a function\");\n }\n return value;\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defaults.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defaults.js new file mode 100644 index 0000000000000000000000000000000000000000..d0406560c4a7c6f2e3a05167c8066967316e1a3f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defaults.js @@ -0,0 +1,18 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _defaults; +function _defaults(obj, defaults) { + for (var keys = Object.getOwnPropertyNames(defaults), i = 0; i < keys.length; i++) { + var key = keys[i], + value = Object.getOwnPropertyDescriptor(defaults, key); + if (value && value.configurable && obj[key] === undefined) { + Object.defineProperty(obj, key, value); + } + } + return obj; +} + +//# sourceMappingURL=defaults.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defaults.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defaults.js.map new file mode 100644 index 0000000000000000000000000000000000000000..4e3003e25cd0c8720d8acc84fbf62563d87ab043 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defaults.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_defaults","obj","defaults","keys","Object","getOwnPropertyNames","i","length","key","value","getOwnPropertyDescriptor","configurable","undefined","defineProperty"],"sources":["../../src/helpers/defaults.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _defaults(\n obj: T,\n defaults: S,\n): NonNullable {\n for (\n var keys: string[] = Object.getOwnPropertyNames(defaults), i = 0;\n i < keys.length;\n i++\n ) {\n var key: string = keys[i],\n value: PropertyDescriptor | undefined = Object.getOwnPropertyDescriptor(\n defaults,\n key,\n );\n if (value && value.configurable && obj[key as keyof T] === undefined) {\n Object.defineProperty(obj, key, value);\n }\n }\n return obj as NonNullable;\n}\n"],"mappings":";;;;;;AAEe,SAASA,SAASA,CAC/BC,GAAM,EACNC,QAAW,EACS;EACpB,KACE,IAAIC,IAAc,GAAGC,MAAM,CAACC,mBAAmB,CAACH,QAAQ,CAAC,EAAEI,CAAC,GAAG,CAAC,EAChEA,CAAC,GAAGH,IAAI,CAACI,MAAM,EACfD,CAAC,EAAE,EACH;IACA,IAAIE,GAAW,GAAGL,IAAI,CAACG,CAAC,CAAC;MACvBG,KAAqC,GAAGL,MAAM,CAACM,wBAAwB,CACrER,QAAQ,EACRM,GACF,CAAC;IACH,IAAIC,KAAK,IAAIA,KAAK,CAACE,YAAY,IAAIV,GAAG,CAACO,GAAG,CAAY,KAAKI,SAAS,EAAE;MACpER,MAAM,CAACS,cAAc,CAACZ,GAAG,EAAEO,GAAG,EAAEC,KAAK,CAAC;IACxC;EACF;EACA,OAAOR,GAAG;AACZ","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defineAccessor.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defineAccessor.js new file mode 100644 index 0000000000000000000000000000000000000000..fc5f8bcdb6b11b1b1b39aa156855455da1b3c54f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defineAccessor.js @@ -0,0 +1,16 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _defineAccessor; +function _defineAccessor(type, obj, key, fn) { + var desc = { + configurable: true, + enumerable: true + }; + desc[type] = fn; + return Object.defineProperty(obj, key, desc); +} + +//# sourceMappingURL=defineAccessor.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defineAccessor.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defineAccessor.js.map new file mode 100644 index 0000000000000000000000000000000000000000..9dd4e0d8e605c6c0c25265068c903de017830c1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defineAccessor.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_defineAccessor","type","obj","key","fn","desc","configurable","enumerable","Object","defineProperty"],"sources":["../../src/helpers/defineAccessor.ts"],"sourcesContent":["/* @minVersion 7.20.7 */\n\nexport default function _defineAccessor(\n type: Type,\n obj: any,\n key: string | symbol,\n fn: PropertyDescriptor[Type],\n) {\n var desc: PropertyDescriptor = { configurable: true, enumerable: true };\n desc[type] = fn;\n return Object.defineProperty(obj, key, desc);\n}\n"],"mappings":";;;;;;AAEe,SAASA,eAAeA,CACrCC,IAAU,EACVC,GAAQ,EACRC,GAAoB,EACpBC,EAA4B,EAC5B;EACA,IAAIC,IAAwB,GAAG;IAAEC,YAAY,EAAE,IAAI;IAAEC,UAAU,EAAE;EAAK,CAAC;EACvEF,IAAI,CAACJ,IAAI,CAAC,GAAGG,EAAE;EACf,OAAOI,MAAM,CAACC,cAAc,CAACP,GAAG,EAAEC,GAAG,EAAEE,IAAI,CAAC;AAC9C","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defineEnumerableProperties.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defineEnumerableProperties.js new file mode 100644 index 0000000000000000000000000000000000000000..a497e1d20ccb16417ad6ada6935bc1ac3c889371 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defineEnumerableProperties.js @@ -0,0 +1,27 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _defineEnumerableProperties; +function _defineEnumerableProperties(obj, descs) { + for (var key in descs) { + var desc = descs[key]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, key, desc); + } + if (Object.getOwnPropertySymbols) { + var objectSymbols = Object.getOwnPropertySymbols(descs); + for (var i = 0; i < objectSymbols.length; i++) { + var sym = objectSymbols[i]; + desc = descs[sym]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, sym, desc); + } + } + return obj; +} + +//# sourceMappingURL=defineEnumerableProperties.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defineEnumerableProperties.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defineEnumerableProperties.js.map new file mode 100644 index 0000000000000000000000000000000000000000..31fd3a88b29c7d7710f0a7b4618ea0ba5ff473e3 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defineEnumerableProperties.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_defineEnumerableProperties","obj","descs","key","desc","configurable","enumerable","writable","Object","defineProperty","getOwnPropertySymbols","objectSymbols","i","length","sym"],"sources":["../../src/helpers/defineEnumerableProperties.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n/* @onlyBabel7 */\nexport default function _defineEnumerableProperties(\n obj: T,\n descs: { [key: string | symbol]: PropertyDescriptor },\n): T {\n // eslint-disable-next-line guard-for-in\n for (var key in descs) {\n var desc = descs[key];\n desc.configurable = desc.enumerable = true;\n if (\"value\" in desc) desc.writable = true;\n Object.defineProperty(obj, key, desc);\n }\n\n // Symbols are not enumerated over by for-in loops. If native\n // Symbols are available, fetch all of the descs object's own\n // symbol properties and define them on our target object too.\n if (Object.getOwnPropertySymbols) {\n var objectSymbols = Object.getOwnPropertySymbols(descs);\n for (var i = 0; i < objectSymbols.length; i++) {\n var sym = objectSymbols[i];\n desc = descs[sym];\n desc.configurable = desc.enumerable = true;\n if (\"value\" in desc) desc.writable = true;\n Object.defineProperty(obj, sym, desc);\n }\n }\n return obj;\n}\n"],"mappings":";;;;;;AAEe,SAASA,2BAA2BA,CACjDC,GAAM,EACNC,KAAqD,EAClD;EAEH,KAAK,IAAIC,GAAG,IAAID,KAAK,EAAE;IACrB,IAAIE,IAAI,GAAGF,KAAK,CAACC,GAAG,CAAC;IACrBC,IAAI,CAACC,YAAY,GAAGD,IAAI,CAACE,UAAU,GAAG,IAAI;IAC1C,IAAI,OAAO,IAAIF,IAAI,EAAEA,IAAI,CAACG,QAAQ,GAAG,IAAI;IACzCC,MAAM,CAACC,cAAc,CAACR,GAAG,EAAEE,GAAG,EAAEC,IAAI,CAAC;EACvC;EAKA,IAAII,MAAM,CAACE,qBAAqB,EAAE;IAChC,IAAIC,aAAa,GAAGH,MAAM,CAACE,qBAAqB,CAACR,KAAK,CAAC;IACvD,KAAK,IAAIU,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGD,aAAa,CAACE,MAAM,EAAED,CAAC,EAAE,EAAE;MAC7C,IAAIE,GAAG,GAAGH,aAAa,CAACC,CAAC,CAAC;MAC1BR,IAAI,GAAGF,KAAK,CAACY,GAAG,CAAC;MACjBV,IAAI,CAACC,YAAY,GAAGD,IAAI,CAACE,UAAU,GAAG,IAAI;MAC1C,IAAI,OAAO,IAAIF,IAAI,EAAEA,IAAI,CAACG,QAAQ,GAAG,IAAI;MACzCC,MAAM,CAACC,cAAc,CAACR,GAAG,EAAEa,GAAG,EAAEV,IAAI,CAAC;IACvC;EACF;EACA,OAAOH,GAAG;AACZ","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defineProperty.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defineProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..989df3a438bbb0ebf3ff6788057f9979aa4fa28b --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defineProperty.js @@ -0,0 +1,23 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _defineProperty; +var _toPropertyKey = require("./toPropertyKey.js"); +function _defineProperty(obj, key, value) { + key = (0, _toPropertyKey.default)(key); + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; +} + +//# sourceMappingURL=defineProperty.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defineProperty.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defineProperty.js.map new file mode 100644 index 0000000000000000000000000000000000000000..9e8a52da9aab9268cc79b4d613a0f32697bd4eea --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/defineProperty.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_toPropertyKey","require","_defineProperty","obj","key","value","toPropertyKey","Object","defineProperty","enumerable","configurable","writable"],"sources":["../../src/helpers/defineProperty.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\nimport toPropertyKey from \"./toPropertyKey.ts\";\n\nexport default function _defineProperty(\n obj: T,\n key: PropertyKey,\n value: any,\n) {\n key = toPropertyKey(key);\n // Shortcircuit the slow defineProperty path when possible.\n // We are trying to avoid issues where setters defined on the\n // prototype cause side effects under the fast path of simple\n // assignment. By checking for existence of the property with\n // the in operator, we can optimize most of this overhead away.\n if (key in obj) {\n Object.defineProperty(obj, key, {\n value: value,\n enumerable: true,\n configurable: true,\n writable: true,\n });\n } else {\n // @ts-expect-error - Explicitly assigning to generic type key\n obj[key] = value;\n }\n return obj;\n}\n"],"mappings":";;;;;;AACA,IAAAA,cAAA,GAAAC,OAAA;AAEe,SAASC,eAAeA,CACrCC,GAAM,EACNC,GAAgB,EAChBC,KAAU,EACV;EACAD,GAAG,GAAG,IAAAE,sBAAa,EAACF,GAAG,CAAC;EAMxB,IAAIA,GAAG,IAAID,GAAG,EAAE;IACdI,MAAM,CAACC,cAAc,CAACL,GAAG,EAAEC,GAAG,EAAE;MAC9BC,KAAK,EAAEA,KAAK;MACZI,UAAU,EAAE,IAAI;MAChBC,YAAY,EAAE,IAAI;MAClBC,QAAQ,EAAE;IACZ,CAAC,CAAC;EACJ,CAAC,MAAM;IAELR,GAAG,CAACC,GAAG,CAAC,GAAGC,KAAK;EAClB;EACA,OAAOF,GAAG;AACZ","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/dispose.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/dispose.js new file mode 100644 index 0000000000000000000000000000000000000000..3093b47df29de748e9791dc777441f70b1763067 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/dispose.js @@ -0,0 +1,47 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _dispose; +function dispose_SuppressedError(error, suppressed) { + if (typeof SuppressedError !== "undefined") { + dispose_SuppressedError = SuppressedError; + } else { + dispose_SuppressedError = function SuppressedError(error, suppressed) { + this.suppressed = suppressed; + this.error = error; + this.stack = new Error().stack; + }; + dispose_SuppressedError.prototype = Object.create(Error.prototype, { + constructor: { + value: dispose_SuppressedError, + writable: true, + configurable: true + } + }); + } + return new dispose_SuppressedError(error, suppressed); +} +function _dispose(stack, error, hasError) { + function next() { + while (stack.length > 0) { + try { + var r = stack.pop(); + var p = r.d.call(r.v); + if (r.a) return Promise.resolve(p).then(next, err); + } catch (e) { + return err(e); + } + } + if (hasError) throw error; + } + function err(e) { + error = hasError ? new dispose_SuppressedError(error, e) : e; + hasError = true; + return next(); + } + return next(); +} + +//# sourceMappingURL=dispose.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/dispose.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/dispose.js.map new file mode 100644 index 0000000000000000000000000000000000000000..dd2e587c840dca4cfafc81de3f96d47f9b97594a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/dispose.js.map @@ -0,0 +1 @@ +{"version":3,"names":["dispose_SuppressedError","error","suppressed","SuppressedError","stack","Error","prototype","Object","create","constructor","value","writable","configurable","_dispose","hasError","next","length","r","pop","p","d","call","v","a","Promise","resolve","then","err","e"],"sources":["../../src/helpers/dispose.js"],"sourcesContent":["/* @minVersion 7.22.0 */\n/* @onlyBabel7 */\n\nfunction dispose_SuppressedError(error, suppressed) {\n if (typeof SuppressedError !== \"undefined\") {\n // eslint-disable-next-line no-undef\n dispose_SuppressedError = SuppressedError;\n } else {\n dispose_SuppressedError = function SuppressedError(error, suppressed) {\n this.suppressed = suppressed;\n this.error = error;\n this.stack = new Error().stack;\n };\n dispose_SuppressedError.prototype = Object.create(Error.prototype, {\n constructor: {\n value: dispose_SuppressedError,\n writable: true,\n configurable: true,\n },\n });\n }\n return new dispose_SuppressedError(error, suppressed);\n}\n\nexport default function _dispose(stack, error, hasError) {\n function next() {\n while (stack.length > 0) {\n try {\n var r = stack.pop();\n var p = r.d.call(r.v);\n if (r.a) return Promise.resolve(p).then(next, err);\n } catch (e) {\n return err(e);\n }\n }\n if (hasError) throw error;\n }\n\n function err(e) {\n error = hasError ? new dispose_SuppressedError(error, e) : e;\n hasError = true;\n\n return next();\n }\n\n return next();\n}\n"],"mappings":";;;;;;AAGA,SAASA,uBAAuBA,CAACC,KAAK,EAAEC,UAAU,EAAE;EAClD,IAAI,OAAOC,eAAe,KAAK,WAAW,EAAE;IAE1CH,uBAAuB,GAAGG,eAAe;EAC3C,CAAC,MAAM;IACLH,uBAAuB,GAAG,SAASG,eAAeA,CAACF,KAAK,EAAEC,UAAU,EAAE;MACpE,IAAI,CAACA,UAAU,GAAGA,UAAU;MAC5B,IAAI,CAACD,KAAK,GAAGA,KAAK;MAClB,IAAI,CAACG,KAAK,GAAG,IAAIC,KAAK,CAAC,CAAC,CAACD,KAAK;IAChC,CAAC;IACDJ,uBAAuB,CAACM,SAAS,GAAGC,MAAM,CAACC,MAAM,CAACH,KAAK,CAACC,SAAS,EAAE;MACjEG,WAAW,EAAE;QACXC,KAAK,EAAEV,uBAAuB;QAC9BW,QAAQ,EAAE,IAAI;QACdC,YAAY,EAAE;MAChB;IACF,CAAC,CAAC;EACJ;EACA,OAAO,IAAIZ,uBAAuB,CAACC,KAAK,EAAEC,UAAU,CAAC;AACvD;AAEe,SAASW,QAAQA,CAACT,KAAK,EAAEH,KAAK,EAAEa,QAAQ,EAAE;EACvD,SAASC,IAAIA,CAAA,EAAG;IACd,OAAOX,KAAK,CAACY,MAAM,GAAG,CAAC,EAAE;MACvB,IAAI;QACF,IAAIC,CAAC,GAAGb,KAAK,CAACc,GAAG,CAAC,CAAC;QACnB,IAAIC,CAAC,GAAGF,CAAC,CAACG,CAAC,CAACC,IAAI,CAACJ,CAAC,CAACK,CAAC,CAAC;QACrB,IAAIL,CAAC,CAACM,CAAC,EAAE,OAAOC,OAAO,CAACC,OAAO,CAACN,CAAC,CAAC,CAACO,IAAI,CAACX,IAAI,EAAEY,GAAG,CAAC;MACpD,CAAC,CAAC,OAAOC,CAAC,EAAE;QACV,OAAOD,GAAG,CAACC,CAAC,CAAC;MACf;IACF;IACA,IAAId,QAAQ,EAAE,MAAMb,KAAK;EAC3B;EAEA,SAAS0B,GAAGA,CAACC,CAAC,EAAE;IACd3B,KAAK,GAAGa,QAAQ,GAAG,IAAId,uBAAuB,CAACC,KAAK,EAAE2B,CAAC,CAAC,GAAGA,CAAC;IAC5Dd,QAAQ,GAAG,IAAI;IAEf,OAAOC,IAAI,CAAC,CAAC;EACf;EAEA,OAAOA,IAAI,CAAC,CAAC;AACf","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/extends.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/extends.js new file mode 100644 index 0000000000000000000000000000000000000000..bb9d07d4a18525dd07238fac71adb7de45789278 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/extends.js @@ -0,0 +1,22 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _extends; +function _extends() { + exports.default = _extends = Object.assign ? Object.assign.bind() : function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + return target; + }; + return _extends.apply(null, arguments); +} + +//# sourceMappingURL=extends.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/extends.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/extends.js.map new file mode 100644 index 0000000000000000000000000000000000000000..3fa6dc7c160f2abec3ff2fb9cd3e44eb2e2d5751 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/extends.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_extends","exports","default","Object","assign","bind","target","i","arguments","length","source","key","prototype","hasOwnProperty","call","apply"],"sources":["../../src/helpers/extends.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\ntype Intersection = R extends [infer H, ...infer S]\n ? H & Intersection\n : unknown;\n\nexport default function _extends(\n target: T,\n ...sources: U\n): T & Intersection;\nexport default function _extends() {\n // @ts-expect-error explicitly assign to function\n _extends = Object.assign\n ? // need a bind because https://github.com/babel/babel/issues/14527\n // @ts-expect-error -- intentionally omitting the argument\n Object.assign.bind(/* undefined */)\n : function (target: any) {\n for (var i = 1; i < arguments.length; i++) {\n var source = arguments[i];\n for (var key in source) {\n if (Object.prototype.hasOwnProperty.call(source, key)) {\n target[key] = source[key];\n }\n }\n }\n return target;\n };\n\n return _extends.apply(\n null,\n arguments as any as [source: object, ...target: any[]],\n );\n}\n"],"mappings":";;;;;;AAUe,SAASA,QAAQA,CAAA,EAAG;EAEjCC,OAAA,CAAAC,OAAA,GAAAF,QAAQ,GAAGG,MAAM,CAACC,MAAM,GAGpBD,MAAM,CAACC,MAAM,CAACC,IAAI,CAAgB,CAAC,GACnC,UAAUC,MAAW,EAAE;IACrB,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGC,SAAS,CAACC,MAAM,EAAEF,CAAC,EAAE,EAAE;MACzC,IAAIG,MAAM,GAAGF,SAAS,CAACD,CAAC,CAAC;MACzB,KAAK,IAAII,GAAG,IAAID,MAAM,EAAE;QACtB,IAAIP,MAAM,CAACS,SAAS,CAACC,cAAc,CAACC,IAAI,CAACJ,MAAM,EAAEC,GAAG,CAAC,EAAE;UACrDL,MAAM,CAACK,GAAG,CAAC,GAAGD,MAAM,CAACC,GAAG,CAAC;QAC3B;MACF;IACF;IACA,OAAOL,MAAM;EACf,CAAC;EAEL,OAAON,QAAQ,CAACe,KAAK,CACnB,IAAI,EACJP,SACF,CAAC;AACH","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/get.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/get.js new file mode 100644 index 0000000000000000000000000000000000000000..a2d37966e7106cbf0daa7fdfbf5eab2957b9dbdf --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/get.js @@ -0,0 +1,25 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _get; +var _superPropBase = require("./superPropBase.js"); +function _get() { + if (typeof Reflect !== "undefined" && Reflect.get) { + exports.default = _get = Reflect.get.bind(); + } else { + exports.default = _get = function _get(target, property, receiver) { + var base = (0, _superPropBase.default)(target, property); + if (!base) return; + var desc = Object.getOwnPropertyDescriptor(base, property); + if (desc.get) { + return desc.get.call(arguments.length < 3 ? target : receiver); + } + return desc.value; + }; + } + return _get.apply(null, arguments); +} + +//# sourceMappingURL=get.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/get.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/get.js.map new file mode 100644 index 0000000000000000000000000000000000000000..08de655ccc6c949797b44fac3a168461eb7e4444 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/get.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_superPropBase","require","_get","Reflect","get","exports","default","bind","target","property","receiver","base","superPropBase","desc","Object","getOwnPropertyDescriptor","call","arguments","length","value","apply"],"sources":["../../src/helpers/get.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nimport superPropBase from \"./superPropBase.ts\";\n\n// https://tc39.es/ecma262/multipage/reflection.html#sec-reflect.get\n//\n// 28.1ak.5 Reflect.get ( target, propertyKey [ , receiver ] )\nexport default function _get(\n target: T,\n property: P,\n receiver?: unknown,\n): P extends keyof T ? T[P] : any;\nexport default function _get(): any {\n if (typeof Reflect !== \"undefined\" && Reflect.get) {\n // need a bind because https://github.com/babel/babel/issues/14527\n // @ts-expect-error function reassign\n _get = Reflect.get.bind(/* undefined */);\n } else {\n // @ts-expect-error function reassign\n _get = function _get(target, property, receiver) {\n var base = superPropBase(target, property);\n\n if (!base) return;\n\n var desc = Object.getOwnPropertyDescriptor(base, property)!;\n if (desc.get) {\n // STEP 3. If receiver is not present, then set receiver to target.\n return desc.get.call(arguments.length < 3 ? target : receiver);\n }\n\n return desc.value;\n };\n }\n\n return _get.apply(null, arguments as any as Parameters);\n}\n"],"mappings":";;;;;;AAEA,IAAAA,cAAA,GAAAC,OAAA;AAUe,SAASC,IAAIA,CAAA,EAAQ;EAClC,IAAI,OAAOC,OAAO,KAAK,WAAW,IAAIA,OAAO,CAACC,GAAG,EAAE;IAGjDC,OAAA,CAAAC,OAAA,GAAAJ,IAAI,GAAGC,OAAO,CAACC,GAAG,CAACG,IAAI,CAAgB,CAAC;EAC1C,CAAC,MAAM;IAELF,OAAA,CAAAC,OAAA,GAAAJ,IAAI,GAAG,SAASA,IAAIA,CAACM,MAAM,EAAEC,QAAQ,EAAEC,QAAQ,EAAE;MAC/C,IAAIC,IAAI,GAAG,IAAAC,sBAAa,EAACJ,MAAM,EAAEC,QAAQ,CAAC;MAE1C,IAAI,CAACE,IAAI,EAAE;MAEX,IAAIE,IAAI,GAAGC,MAAM,CAACC,wBAAwB,CAACJ,IAAI,EAAEF,QAAQ,CAAE;MAC3D,IAAII,IAAI,CAACT,GAAG,EAAE;QAEZ,OAAOS,IAAI,CAACT,GAAG,CAACY,IAAI,CAACC,SAAS,CAACC,MAAM,GAAG,CAAC,GAAGV,MAAM,GAAGE,QAAQ,CAAC;MAChE;MAEA,OAAOG,IAAI,CAACM,KAAK;IACnB,CAAC;EACH;EAEA,OAAOjB,IAAI,CAACkB,KAAK,CAAC,IAAI,EAAEH,SAAkD,CAAC;AAC7E","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/getPrototypeOf.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/getPrototypeOf.js new file mode 100644 index 0000000000000000000000000000000000000000..6fc2df933fb3e35843653429d2315ec6cd8e230f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/getPrototypeOf.js @@ -0,0 +1,14 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _getPrototypeOf; +function _getPrototypeOf(o) { + exports.default = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; + return _getPrototypeOf(o); +} + +//# sourceMappingURL=getPrototypeOf.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/getPrototypeOf.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/getPrototypeOf.js.map new file mode 100644 index 0000000000000000000000000000000000000000..12b67d8bbf1e9b307d132f4489e5b16a477d46e1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/getPrototypeOf.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_getPrototypeOf","o","exports","default","Object","setPrototypeOf","getPrototypeOf","bind","__proto__"],"sources":["../../src/helpers/getPrototypeOf.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _getPrototypeOf(o: object): any {\n // @ts-expect-error explicitly assign to function\n _getPrototypeOf = Object.setPrototypeOf\n ? // @ts-expect-error -- intentionally omitting the argument\n Object.getPrototypeOf.bind(/* undefined */)\n : function _getPrototypeOf(o: T) {\n return (o as any).__proto__ || Object.getPrototypeOf(o);\n };\n return _getPrototypeOf(o);\n}\n"],"mappings":";;;;;;AAEe,SAASA,eAAeA,CAACC,CAAS,EAAO;EAEtDC,OAAA,CAAAC,OAAA,GAAAH,eAAe,GAAGI,MAAM,CAACC,cAAc,GAEnCD,MAAM,CAACE,cAAc,CAACC,IAAI,CAAgB,CAAC,GAC3C,SAASP,eAAeA,CAAmBC,CAAI,EAAE;IAC/C,OAAQA,CAAC,CAASO,SAAS,IAAIJ,MAAM,CAACE,cAAc,CAACL,CAAC,CAAC;EACzD,CAAC;EACL,OAAOD,eAAe,CAACC,CAAC,CAAC;AAC3B","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/identity.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/identity.js new file mode 100644 index 0000000000000000000000000000000000000000..7a5f5f4ff2e1cd9b8df258b34e1d4529198b254c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/identity.js @@ -0,0 +1,11 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _identity; +function _identity(x) { + return x; +} + +//# sourceMappingURL=identity.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/identity.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/identity.js.map new file mode 100644 index 0000000000000000000000000000000000000000..a7b15d0fcd96374c48bccb0d4055d435eec0c6fb --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/identity.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_identity","x"],"sources":["../../src/helpers/identity.ts"],"sourcesContent":["/* @minVersion 7.17.0 */\n\nexport default function _identity(x: T) {\n return x;\n}\n"],"mappings":";;;;;;AAEe,SAASA,SAASA,CAAIC,CAAI,EAAE;EACzC,OAAOA,CAAC;AACV","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/importDeferProxy.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/importDeferProxy.js new file mode 100644 index 0000000000000000000000000000000000000000..1529609ccad976f9f067979cd1a997709b1952c3 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/importDeferProxy.js @@ -0,0 +1,35 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _importDeferProxy; +function _importDeferProxy(init) { + var ns = null; + var constValue = function (v) { + return function () { + return v; + }; + }; + var proxy = function (run) { + return function (_target, p, receiver) { + if (ns === null) ns = init(); + return run(ns, p, receiver); + }; + }; + return new Proxy({}, { + defineProperty: constValue(false), + deleteProperty: constValue(false), + get: proxy(Reflect.get), + getOwnPropertyDescriptor: proxy(Reflect.getOwnPropertyDescriptor), + getPrototypeOf: constValue(null), + isExtensible: constValue(false), + has: proxy(Reflect.has), + ownKeys: proxy(Reflect.ownKeys), + preventExtensions: constValue(true), + set: constValue(false), + setPrototypeOf: constValue(false) + }); +} + +//# sourceMappingURL=importDeferProxy.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/importDeferProxy.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/importDeferProxy.js.map new file mode 100644 index 0000000000000000000000000000000000000000..dd66b3d187197a7692d23c233af493fdbf2442f6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/importDeferProxy.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_importDeferProxy","init","ns","constValue","v","proxy","run","_target","p","receiver","Proxy","defineProperty","deleteProperty","get","Reflect","getOwnPropertyDescriptor","getPrototypeOf","isExtensible","has","ownKeys","preventExtensions","set","setPrototypeOf"],"sources":["../../src/helpers/importDeferProxy.ts"],"sourcesContent":["/* @minVersion 7.23.0 */\n\nexport default function _importDeferProxy(\n init: () => T,\n): ProxyHandler {\n var ns: T | null = null;\n\n var constValue = function (v: V) {\n return function (): V {\n return v;\n };\n };\n\n var proxy = function (run: Function) {\n return function (_target: T, p?: string | symbol, receiver?: any) {\n if (ns === null) ns = init();\n return run(ns, p, receiver);\n };\n };\n\n return new Proxy(\n {},\n {\n defineProperty: constValue(false),\n deleteProperty: constValue(false),\n get: proxy(Reflect.get),\n getOwnPropertyDescriptor: proxy(Reflect.getOwnPropertyDescriptor),\n getPrototypeOf: constValue(null),\n isExtensible: constValue(false),\n has: proxy(Reflect.has),\n ownKeys: proxy(Reflect.ownKeys),\n preventExtensions: constValue(true),\n set: constValue(false),\n setPrototypeOf: constValue(false),\n },\n );\n}\n"],"mappings":";;;;;;AAEe,SAASA,iBAAiBA,CACvCC,IAAa,EACI;EACjB,IAAIC,EAAY,GAAG,IAAI;EAEvB,IAAIC,UAAU,GAAG,SAAAA,CAAoCC,CAAI,EAAE;IACzD,OAAO,YAAe;MACpB,OAAOA,CAAC;IACV,CAAC;EACH,CAAC;EAED,IAAIC,KAAK,GAAG,SAAAA,CAAUC,GAAa,EAAE;IACnC,OAAO,UAAUC,OAAU,EAAEC,CAAmB,EAAEC,QAAc,EAAE;MAChE,IAAIP,EAAE,KAAK,IAAI,EAAEA,EAAE,GAAGD,IAAI,CAAC,CAAC;MAC5B,OAAOK,GAAG,CAACJ,EAAE,EAAEM,CAAC,EAAEC,QAAQ,CAAC;IAC7B,CAAC;EACH,CAAC;EAED,OAAO,IAAIC,KAAK,CACd,CAAC,CAAC,EACF;IACEC,cAAc,EAAER,UAAU,CAAC,KAAK,CAAC;IACjCS,cAAc,EAAET,UAAU,CAAC,KAAK,CAAC;IACjCU,GAAG,EAAER,KAAK,CAACS,OAAO,CAACD,GAAG,CAAC;IACvBE,wBAAwB,EAAEV,KAAK,CAACS,OAAO,CAACC,wBAAwB,CAAC;IACjEC,cAAc,EAAEb,UAAU,CAAC,IAAI,CAAC;IAChCc,YAAY,EAAEd,UAAU,CAAC,KAAK,CAAC;IAC/Be,GAAG,EAAEb,KAAK,CAACS,OAAO,CAACI,GAAG,CAAC;IACvBC,OAAO,EAAEd,KAAK,CAACS,OAAO,CAACK,OAAO,CAAC;IAC/BC,iBAAiB,EAAEjB,UAAU,CAAC,IAAI,CAAC;IACnCkB,GAAG,EAAElB,UAAU,CAAC,KAAK,CAAC;IACtBmB,cAAc,EAAEnB,UAAU,CAAC,KAAK;EAClC,CACF,CAAC;AACH","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/inherits.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/inherits.js new file mode 100644 index 0000000000000000000000000000000000000000..6039a8e72508af8b406443d813474c1ac2ec3ee8 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/inherits.js @@ -0,0 +1,25 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _inherits; +var _setPrototypeOf = require("./setPrototypeOf.js"); +function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + writable: true, + configurable: true + } + }); + Object.defineProperty(subClass, "prototype", { + writable: false + }); + if (superClass) (0, _setPrototypeOf.default)(subClass, superClass); +} + +//# sourceMappingURL=inherits.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/inherits.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/inherits.js.map new file mode 100644 index 0000000000000000000000000000000000000000..c175318301179979e450b21895a5cf9bc98b8f8e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/inherits.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_setPrototypeOf","require","_inherits","subClass","superClass","TypeError","prototype","Object","create","constructor","value","writable","configurable","defineProperty","setPrototypeOf"],"sources":["../../src/helpers/inherits.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nimport setPrototypeOf from \"./setPrototypeOf.ts\";\n\nexport default function _inherits(\n subClass: Function,\n superClass: Function | null,\n) {\n if (typeof superClass !== \"function\" && superClass !== null) {\n throw new TypeError(\"Super expression must either be null or a function\");\n }\n // We can't use defineProperty to set the prototype in a single step because it\n // doesn't work in Chrome <= 36. https://github.com/babel/babel/issues/14056\n // V8 bug: https://bugs.chromium.org/p/v8/issues/detail?id=3334\n subClass.prototype = Object.create(superClass && superClass.prototype, {\n constructor: {\n value: subClass,\n writable: true,\n configurable: true,\n },\n });\n Object.defineProperty(subClass, \"prototype\", { writable: false });\n if (superClass) setPrototypeOf(subClass, superClass);\n}\n"],"mappings":";;;;;;AAEA,IAAAA,eAAA,GAAAC,OAAA;AAEe,SAASC,SAASA,CAC/BC,QAAkB,EAClBC,UAA2B,EAC3B;EACA,IAAI,OAAOA,UAAU,KAAK,UAAU,IAAIA,UAAU,KAAK,IAAI,EAAE;IAC3D,MAAM,IAAIC,SAAS,CAAC,oDAAoD,CAAC;EAC3E;EAIAF,QAAQ,CAACG,SAAS,GAAGC,MAAM,CAACC,MAAM,CAACJ,UAAU,IAAIA,UAAU,CAACE,SAAS,EAAE;IACrEG,WAAW,EAAE;MACXC,KAAK,EAAEP,QAAQ;MACfQ,QAAQ,EAAE,IAAI;MACdC,YAAY,EAAE;IAChB;EACF,CAAC,CAAC;EACFL,MAAM,CAACM,cAAc,CAACV,QAAQ,EAAE,WAAW,EAAE;IAAEQ,QAAQ,EAAE;EAAM,CAAC,CAAC;EACjE,IAAIP,UAAU,EAAE,IAAAU,uBAAc,EAACX,QAAQ,EAAEC,UAAU,CAAC;AACtD","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/inheritsLoose.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/inheritsLoose.js new file mode 100644 index 0000000000000000000000000000000000000000..0de50d70189e7edf6f1a56a8bd2d30de0e900e07 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/inheritsLoose.js @@ -0,0 +1,14 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _inheritsLoose; +var _setPrototypeOf = require("./setPrototypeOf.js"); +function _inheritsLoose(subClass, superClass) { + subClass.prototype = Object.create(superClass.prototype); + subClass.prototype.constructor = subClass; + (0, _setPrototypeOf.default)(subClass, superClass); +} + +//# sourceMappingURL=inheritsLoose.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/inheritsLoose.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/inheritsLoose.js.map new file mode 100644 index 0000000000000000000000000000000000000000..44cd15dfcb3692740083c69113f41a8775dbd016 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/inheritsLoose.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_setPrototypeOf","require","_inheritsLoose","subClass","superClass","prototype","Object","create","constructor","setPrototypeOf"],"sources":["../../src/helpers/inheritsLoose.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nimport setPrototypeOf from \"./setPrototypeOf.ts\";\n\nexport default function _inheritsLoose(\n subClass: Function,\n superClass: Function,\n) {\n subClass.prototype = Object.create(superClass.prototype);\n subClass.prototype.constructor = subClass;\n setPrototypeOf(subClass, superClass);\n}\n"],"mappings":";;;;;;AAEA,IAAAA,eAAA,GAAAC,OAAA;AAEe,SAASC,cAAcA,CACpCC,QAAkB,EAClBC,UAAoB,EACpB;EACAD,QAAQ,CAACE,SAAS,GAAGC,MAAM,CAACC,MAAM,CAACH,UAAU,CAACC,SAAS,CAAC;EACxDF,QAAQ,CAACE,SAAS,CAACG,WAAW,GAAGL,QAAQ;EACzC,IAAAM,uBAAc,EAACN,QAAQ,EAAEC,UAAU,CAAC;AACtC","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/initializerDefineProperty.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/initializerDefineProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..c0daf6d515abf3b36eea590fe3b223924004a31c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/initializerDefineProperty.js @@ -0,0 +1,17 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _initializerDefineProperty; +function _initializerDefineProperty(target, property, descriptor, context) { + if (!descriptor) return; + Object.defineProperty(target, property, { + enumerable: descriptor.enumerable, + configurable: descriptor.configurable, + writable: descriptor.writable, + value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 + }); +} + +//# sourceMappingURL=initializerDefineProperty.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/initializerDefineProperty.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/initializerDefineProperty.js.map new file mode 100644 index 0000000000000000000000000000000000000000..abee831dfb31273285f64e31bb548edcf07ea0a6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/initializerDefineProperty.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_initializerDefineProperty","target","property","descriptor","context","Object","defineProperty","enumerable","configurable","writable","value","initializer","call"],"sources":["../../src/helpers/initializerDefineProperty.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\ninterface DescriptorWithInitializer extends PropertyDescriptor {\n initializer?: () => any;\n}\n\nexport default function _initializerDefineProperty(\n target: T,\n property: PropertyKey,\n descriptor: DescriptorWithInitializer | undefined,\n context: DecoratorContext,\n): void {\n if (!descriptor) return;\n\n Object.defineProperty(target, property, {\n enumerable: descriptor.enumerable,\n configurable: descriptor.configurable,\n writable: descriptor.writable,\n value: descriptor.initializer\n ? descriptor.initializer.call(context)\n : void 0,\n });\n}\n"],"mappings":";;;;;;AAMe,SAASA,0BAA0BA,CAChDC,MAAS,EACTC,QAAqB,EACrBC,UAAiD,EACjDC,OAAyB,EACnB;EACN,IAAI,CAACD,UAAU,EAAE;EAEjBE,MAAM,CAACC,cAAc,CAACL,MAAM,EAAEC,QAAQ,EAAE;IACtCK,UAAU,EAAEJ,UAAU,CAACI,UAAU;IACjCC,YAAY,EAAEL,UAAU,CAACK,YAAY;IACrCC,QAAQ,EAAEN,UAAU,CAACM,QAAQ;IAC7BC,KAAK,EAAEP,UAAU,CAACQ,WAAW,GACzBR,UAAU,CAACQ,WAAW,CAACC,IAAI,CAACR,OAAO,CAAC,GACpC,KAAK;EACX,CAAC,CAAC;AACJ","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/initializerWarningHelper.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/initializerWarningHelper.js new file mode 100644 index 0000000000000000000000000000000000000000..4d8e5aad06c045a0363d92f63a675a6f979f1ae5 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/initializerWarningHelper.js @@ -0,0 +1,11 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _initializerWarningHelper; +function _initializerWarningHelper(descriptor, context) { + throw new Error("Decorating class property failed. Please ensure that " + "transform-class-properties is enabled and runs after the decorators transform."); +} + +//# sourceMappingURL=initializerWarningHelper.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/initializerWarningHelper.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/initializerWarningHelper.js.map new file mode 100644 index 0000000000000000000000000000000000000000..dec71a1f733a1e384b54ec887dcaeaa5569f391e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/initializerWarningHelper.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_initializerWarningHelper","descriptor","context","Error"],"sources":["../../src/helpers/initializerWarningHelper.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\nexport default function _initializerWarningHelper(\n descriptor: PropertyDescriptor,\n context: DecoratorContext,\n): never {\n throw new Error(\n \"Decorating class property failed. Please ensure that \" +\n \"transform-class-properties is enabled and runs after the decorators transform.\",\n );\n}\n"],"mappings":";;;;;;AAGe,SAASA,yBAAyBA,CAC/CC,UAA8B,EAC9BC,OAAyB,EAClB;EACP,MAAM,IAAIC,KAAK,CACb,uDAAuD,GACrD,gFACJ,CAAC;AACH","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/instanceof.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/instanceof.js new file mode 100644 index 0000000000000000000000000000000000000000..ff8272da6a2fc1f6c2009adc2514bd2fa96cd51e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/instanceof.js @@ -0,0 +1,15 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _instanceof; +function _instanceof(left, right) { + if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { + return !!right[Symbol.hasInstance](left); + } else { + return left instanceof right; + } +} + +//# sourceMappingURL=instanceof.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/instanceof.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/instanceof.js.map new file mode 100644 index 0000000000000000000000000000000000000000..725c00281a27490c10bc7dc217ac5e0b309c489a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/instanceof.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_instanceof","left","right","Symbol","hasInstance"],"sources":["../../src/helpers/instanceof.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _instanceof(left: any, right: Function) {\n if (\n right != null &&\n typeof Symbol !== \"undefined\" &&\n right[Symbol.hasInstance]\n ) {\n return !!right[Symbol.hasInstance](left);\n } else {\n return left instanceof right;\n }\n}\n"],"mappings":";;;;;;AAEe,SAASA,WAAWA,CAACC,IAAS,EAAEC,KAAe,EAAE;EAC9D,IACEA,KAAK,IAAI,IAAI,IACb,OAAOC,MAAM,KAAK,WAAW,IAC7BD,KAAK,CAACC,MAAM,CAACC,WAAW,CAAC,EACzB;IACA,OAAO,CAAC,CAACF,KAAK,CAACC,MAAM,CAACC,WAAW,CAAC,CAACH,IAAI,CAAC;EAC1C,CAAC,MAAM;IACL,OAAOA,IAAI,YAAYC,KAAK;EAC9B;AACF","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/interopRequireDefault.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/interopRequireDefault.js new file mode 100644 index 0000000000000000000000000000000000000000..8c2873d44a1dcbfa3844d1b1f2f4c854232ab45d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/interopRequireDefault.js @@ -0,0 +1,13 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _interopRequireDefault; +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; +} + +//# sourceMappingURL=interopRequireDefault.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/interopRequireDefault.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/interopRequireDefault.js.map new file mode 100644 index 0000000000000000000000000000000000000000..71e0a55f16c3f1b80d0a9bdccfd19fcd5d615df0 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/interopRequireDefault.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_interopRequireDefault","obj","__esModule","default"],"sources":["../../src/helpers/interopRequireDefault.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _interopRequireDefault(obj: any) {\n return obj && obj.__esModule ? obj : { default: obj };\n}\n"],"mappings":";;;;;;AAEe,SAASA,sBAAsBA,CAACC,GAAQ,EAAE;EACvD,OAAOA,GAAG,IAAIA,GAAG,CAACC,UAAU,GAAGD,GAAG,GAAG;IAAEE,OAAO,EAAEF;EAAI,CAAC;AACvD","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/interopRequireWildcard.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/interopRequireWildcard.js new file mode 100644 index 0000000000000000000000000000000000000000..eaa82e5cb88e58b2be196cf4e38e2ac4dcdfa555 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/interopRequireWildcard.js @@ -0,0 +1,44 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _interopRequireWildcard; +function _interopRequireWildcard(obj, nodeInterop) { + if (typeof WeakMap === "function") { + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + } + return (exports.default = _interopRequireWildcard = function (obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + var _; + var newObj = { + __proto__: null, + default: obj + }; + var desc; + if (obj === null || typeof obj !== "object" && typeof obj !== "function") { + return newObj; + } + _ = nodeInterop ? cacheNodeInterop : cacheBabelInterop; + if (_) { + if (_.has(obj)) return _.get(obj); + _.set(obj, newObj); + } + for (const key in obj) { + if (key !== "default" && {}.hasOwnProperty.call(obj, key)) { + desc = (_ = Object.defineProperty) && Object.getOwnPropertyDescriptor(obj, key); + if (desc && (desc.get || desc.set)) { + _(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + return newObj; + })(obj, nodeInterop); +} + +//# sourceMappingURL=interopRequireWildcard.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/interopRequireWildcard.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/interopRequireWildcard.js.map new file mode 100644 index 0000000000000000000000000000000000000000..10bd88bd7388cbbfaaa5acd94522b6d4397987a2 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/interopRequireWildcard.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_interopRequireWildcard","obj","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","exports","default","__esModule","_","newObj","__proto__","desc","has","get","set","key","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor"],"sources":["../../src/helpers/interopRequireWildcard.ts"],"sourcesContent":["/* @minVersion 7.14.0 */\n\nexport default function _interopRequireWildcard(\n obj: any,\n nodeInterop: boolean,\n) {\n if (typeof WeakMap === \"function\") {\n var cacheBabelInterop = new WeakMap();\n var cacheNodeInterop = new WeakMap();\n }\n\n // @ts-expect-error: assign to function\n return (_interopRequireWildcard = function (obj: any, nodeInterop: boolean) {\n if (!nodeInterop && obj && obj.__esModule) {\n return obj;\n }\n // Temporary variable for output size\n var _;\n var newObj: { [key: string]: any } = { __proto__: null, default: obj };\n var desc: PropertyDescriptor | undefined;\n\n if (\n obj === null ||\n (typeof obj !== \"object\" && typeof obj !== \"function\")\n ) {\n return newObj;\n }\n\n _ = nodeInterop ? cacheNodeInterop : cacheBabelInterop;\n if (_) {\n if (_.has(obj)) return _.get(obj);\n _.set(obj, newObj);\n }\n\n for (const key in obj) {\n if (key !== \"default\" && {}.hasOwnProperty.call(obj, key)) {\n desc =\n (_ = Object.defineProperty) &&\n Object.getOwnPropertyDescriptor(obj, key);\n if (desc && (desc.get || desc.set)) {\n _(newObj, key, desc);\n } else {\n newObj[key] = obj[key];\n }\n }\n }\n return newObj;\n })(obj, nodeInterop);\n}\n"],"mappings":";;;;;;AAEe,SAASA,uBAAuBA,CAC7CC,GAAQ,EACRC,WAAoB,EACpB;EACA,IAAI,OAAOC,OAAO,KAAK,UAAU,EAAE;IACjC,IAAIC,iBAAiB,GAAG,IAAID,OAAO,CAAC,CAAC;IACrC,IAAIE,gBAAgB,GAAG,IAAIF,OAAO,CAAC,CAAC;EACtC;EAGA,OAAO,CAAAG,OAAA,CAAAC,OAAA,GAACP,uBAAuB,GAAG,SAAAA,CAAUC,GAAQ,EAAEC,WAAoB,EAAE;IAC1E,IAAI,CAACA,WAAW,IAAID,GAAG,IAAIA,GAAG,CAACO,UAAU,EAAE;MACzC,OAAOP,GAAG;IACZ;IAEA,IAAIQ,CAAC;IACL,IAAIC,MAA8B,GAAG;MAAEC,SAAS,EAAE,IAAI;MAAEJ,OAAO,EAAEN;IAAI,CAAC;IACtE,IAAIW,IAAoC;IAExC,IACEX,GAAG,KAAK,IAAI,IACX,OAAOA,GAAG,KAAK,QAAQ,IAAI,OAAOA,GAAG,KAAK,UAAW,EACtD;MACA,OAAOS,MAAM;IACf;IAEAD,CAAC,GAAGP,WAAW,GAAGG,gBAAgB,GAAGD,iBAAiB;IACtD,IAAIK,CAAC,EAAE;MACL,IAAIA,CAAC,CAACI,GAAG,CAACZ,GAAG,CAAC,EAAE,OAAOQ,CAAC,CAACK,GAAG,CAACb,GAAG,CAAC;MACjCQ,CAAC,CAACM,GAAG,CAACd,GAAG,EAAES,MAAM,CAAC;IACpB;IAEA,KAAK,MAAMM,GAAG,IAAIf,GAAG,EAAE;MACrB,IAAIe,GAAG,KAAK,SAAS,IAAI,CAAC,CAAC,CAACC,cAAc,CAACC,IAAI,CAACjB,GAAG,EAAEe,GAAG,CAAC,EAAE;QACzDJ,IAAI,GACF,CAACH,CAAC,GAAGU,MAAM,CAACC,cAAc,KAC1BD,MAAM,CAACE,wBAAwB,CAACpB,GAAG,EAAEe,GAAG,CAAC;QAC3C,IAAIJ,IAAI,KAAKA,IAAI,CAACE,GAAG,IAAIF,IAAI,CAACG,GAAG,CAAC,EAAE;UAClCN,CAAC,CAACC,MAAM,EAAEM,GAAG,EAAEJ,IAAI,CAAC;QACtB,CAAC,MAAM;UACLF,MAAM,CAACM,GAAG,CAAC,GAAGf,GAAG,CAACe,GAAG,CAAC;QACxB;MACF;IACF;IACA,OAAON,MAAM;EACf,CAAC,EAAET,GAAG,EAAEC,WAAW,CAAC;AACtB","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/isNativeFunction.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/isNativeFunction.js new file mode 100644 index 0000000000000000000000000000000000000000..2d3c70ceada5ad9b5b9a1efe6c372eaa1c941c39 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/isNativeFunction.js @@ -0,0 +1,15 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _isNativeFunction; +function _isNativeFunction(fn) { + try { + return Function.toString.call(fn).indexOf("[native code]") !== -1; + } catch (_e) { + return typeof fn === "function"; + } +} + +//# sourceMappingURL=isNativeFunction.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/isNativeFunction.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/isNativeFunction.js.map new file mode 100644 index 0000000000000000000000000000000000000000..2b1c076ae585ca02e3e97ef924c2d432516cebf0 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/isNativeFunction.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_isNativeFunction","fn","Function","toString","call","indexOf","_e"],"sources":["../../src/helpers/isNativeFunction.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _isNativeFunction(fn: unknown): fn is Function {\n // Note: This function returns \"true\" for core-js functions.\n try {\n return Function.toString.call(fn).indexOf(\"[native code]\") !== -1;\n } catch (_e) {\n // Firefox 31 throws when \"toString\" is applied to an HTMLElement\n return typeof fn === \"function\";\n }\n}\n"],"mappings":";;;;;;AAEe,SAASA,iBAAiBA,CAACC,EAAW,EAAkB;EAErE,IAAI;IACF,OAAOC,QAAQ,CAACC,QAAQ,CAACC,IAAI,CAACH,EAAE,CAAC,CAACI,OAAO,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;EACnE,CAAC,CAAC,OAAOC,EAAE,EAAE;IAEX,OAAO,OAAOL,EAAE,KAAK,UAAU;EACjC;AACF","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/isNativeReflectConstruct.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/isNativeReflectConstruct.js new file mode 100644 index 0000000000000000000000000000000000000000..dbf66cd5d22a9987c099b5378692f6d66f2cfc19 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/isNativeReflectConstruct.js @@ -0,0 +1,16 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _isNativeReflectConstruct; +function _isNativeReflectConstruct() { + try { + var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); + } catch (_) {} + return (exports.default = _isNativeReflectConstruct = function () { + return !!result; + })(); +} + +//# sourceMappingURL=isNativeReflectConstruct.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/isNativeReflectConstruct.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/isNativeReflectConstruct.js.map new file mode 100644 index 0000000000000000000000000000000000000000..21028fddd77d1284753b76a78e639423f78d099e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/isNativeReflectConstruct.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_isNativeReflectConstruct","result","Boolean","prototype","valueOf","call","Reflect","construct","_","exports","default"],"sources":["../../src/helpers/isNativeReflectConstruct.ts"],"sourcesContent":["/* @minVersion 7.9.0 */\n\nexport default function _isNativeReflectConstruct() {\n // Since Reflect.construct can't be properly polyfilled, some\n // implementations (e.g. core-js@2) don't set the correct internal slots.\n // Those polyfills don't allow us to subclass built-ins, so we need to\n // use our fallback implementation.\n try {\n // If the internal slots aren't set, this throws an error similar to\n // TypeError: this is not a Boolean object.\n var result = !Boolean.prototype.valueOf.call(\n Reflect.construct(Boolean, [], function () {}),\n );\n } catch (_) {}\n // @ts-expect-error assign to function\n return (_isNativeReflectConstruct = function () {\n return !!result;\n })();\n}\n"],"mappings":";;;;;;AAEe,SAASA,yBAAyBA,CAAA,EAAG;EAKlD,IAAI;IAGF,IAAIC,MAAM,GAAG,CAACC,OAAO,CAACC,SAAS,CAACC,OAAO,CAACC,IAAI,CAC1CC,OAAO,CAACC,SAAS,CAACL,OAAO,EAAE,EAAE,EAAE,YAAY,CAAC,CAAC,CAC/C,CAAC;EACH,CAAC,CAAC,OAAOM,CAAC,EAAE,CAAC;EAEb,OAAO,CAAAC,OAAA,CAAAC,OAAA,GAACV,yBAAyB,GAAG,SAAAA,CAAA,EAAY;IAC9C,OAAO,CAAC,CAACC,MAAM;EACjB,CAAC,EAAE,CAAC;AACN","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/iterableToArray.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/iterableToArray.js new file mode 100644 index 0000000000000000000000000000000000000000..07ea96fe046e66589a5051edcc0acf0018993008 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/iterableToArray.js @@ -0,0 +1,13 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _iterableToArray; +function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) { + return Array.from(iter); + } +} + +//# sourceMappingURL=iterableToArray.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/iterableToArray.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/iterableToArray.js.map new file mode 100644 index 0000000000000000000000000000000000000000..e6481d7590c2e9f4bf0679d49463de016e8f77c8 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/iterableToArray.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_iterableToArray","iter","Symbol","iterator","Array","from"],"sources":["../../src/helpers/iterableToArray.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _iterableToArray(iter: Iterable) {\n if (\n (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null) ||\n (iter as any)[\"@@iterator\"] != null\n ) {\n return Array.from(iter);\n }\n}\n"],"mappings":";;;;;;AAEe,SAASA,gBAAgBA,CAAIC,IAAiB,EAAE;EAC7D,IACG,OAAOC,MAAM,KAAK,WAAW,IAAID,IAAI,CAACC,MAAM,CAACC,QAAQ,CAAC,IAAI,IAAI,IAC9DF,IAAI,CAAS,YAAY,CAAC,IAAI,IAAI,EACnC;IACA,OAAOG,KAAK,CAACC,IAAI,CAACJ,IAAI,CAAC;EACzB;AACF","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/iterableToArrayLimit.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/iterableToArrayLimit.js new file mode 100644 index 0000000000000000000000000000000000000000..9d351854c36866328803d1edd3738b1cc005dece --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/iterableToArrayLimit.js @@ -0,0 +1,41 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _iterableToArrayLimit; +function _iterableToArrayLimit(arr, i) { + var iterator = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; + if (iterator == null) return; + var _arr = []; + var iteratorNormalCompletion = true; + var didIteratorError = false; + var step, iteratorError, next, _return; + try { + next = (iterator = iterator.call(arr)).next; + if (i === 0) { + if (Object(iterator) !== iterator) return; + iteratorNormalCompletion = false; + } else { + for (; !(iteratorNormalCompletion = (step = next.call(iterator)).done); iteratorNormalCompletion = true) { + _arr.push(step.value); + if (_arr.length === i) break; + } + } + } catch (err) { + didIteratorError = true; + iteratorError = err; + } finally { + try { + if (!iteratorNormalCompletion && iterator["return"] != null) { + _return = iterator["return"](); + if (Object(_return) !== _return) return; + } + } finally { + if (didIteratorError) throw iteratorError; + } + } + return _arr; +} + +//# sourceMappingURL=iterableToArrayLimit.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/iterableToArrayLimit.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/iterableToArrayLimit.js.map new file mode 100644 index 0000000000000000000000000000000000000000..6ac2817eb3aa4f1bd296c440d81d706f5957f931 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/iterableToArrayLimit.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_iterableToArrayLimit","arr","i","iterator","Symbol","_arr","iteratorNormalCompletion","didIteratorError","step","iteratorError","next","_return","call","Object","done","push","value","length","err"],"sources":["../../src/helpers/iterableToArrayLimit.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _iterableToArrayLimit(arr: Iterable, i: number) {\n // this is an expanded form of \\`for...of\\` that properly supports abrupt completions of\n // iterators etc.\n\n var iterator: Iterator =\n arr == null\n ? null\n : (typeof Symbol !== \"undefined\" && arr[Symbol.iterator]) ||\n (arr as any)[\"@@iterator\"];\n if (iterator == null) return;\n\n var _arr: T[] = [];\n var iteratorNormalCompletion = true;\n var didIteratorError = false;\n var step, iteratorError, next, _return;\n try {\n next = (iterator = (iterator as unknown as Function).call(arr)).next;\n if (i === 0) {\n if (Object(iterator) !== iterator) return;\n iteratorNormalCompletion = false;\n } else {\n for (\n ;\n !(iteratorNormalCompletion = (step = next.call(iterator)).done);\n iteratorNormalCompletion = true\n ) {\n _arr.push(step.value);\n if (_arr.length === i) break;\n }\n }\n } catch (err) {\n didIteratorError = true;\n iteratorError = err;\n } finally {\n try {\n if (!iteratorNormalCompletion && iterator[\"return\"] != null) {\n _return = iterator[\"return\"]();\n // eslint-disable-next-line no-unsafe-finally\n if (Object(_return) !== _return) return;\n }\n } finally {\n // eslint-disable-next-line no-unsafe-finally\n if (didIteratorError) throw iteratorError;\n }\n }\n return _arr;\n}\n"],"mappings":";;;;;;AAEe,SAASA,qBAAqBA,CAAIC,GAAgB,EAAEC,CAAS,EAAE;EAI5E,IAAIC,QAAqB,GACvBF,GAAG,IAAI,IAAI,GACP,IAAI,GACH,OAAOG,MAAM,KAAK,WAAW,IAAIH,GAAG,CAACG,MAAM,CAACD,QAAQ,CAAC,IACrDF,GAAG,CAAS,YAAY,CAAC;EAChC,IAAIE,QAAQ,IAAI,IAAI,EAAE;EAEtB,IAAIE,IAAS,GAAG,EAAE;EAClB,IAAIC,wBAAwB,GAAG,IAAI;EACnC,IAAIC,gBAAgB,GAAG,KAAK;EAC5B,IAAIC,IAAI,EAAEC,aAAa,EAAEC,IAAI,EAAEC,OAAO;EACtC,IAAI;IACFD,IAAI,GAAG,CAACP,QAAQ,GAAIA,QAAQ,CAAyBS,IAAI,CAACX,GAAG,CAAC,EAAES,IAAI;IACpE,IAAIR,CAAC,KAAK,CAAC,EAAE;MACX,IAAIW,MAAM,CAACV,QAAQ,CAAC,KAAKA,QAAQ,EAAE;MACnCG,wBAAwB,GAAG,KAAK;IAClC,CAAC,MAAM;MACL,OAEE,EAAEA,wBAAwB,GAAG,CAACE,IAAI,GAAGE,IAAI,CAACE,IAAI,CAACT,QAAQ,CAAC,EAAEW,IAAI,CAAC,EAC/DR,wBAAwB,GAAG,IAAI,EAC/B;QACAD,IAAI,CAACU,IAAI,CAACP,IAAI,CAACQ,KAAK,CAAC;QACrB,IAAIX,IAAI,CAACY,MAAM,KAAKf,CAAC,EAAE;MACzB;IACF;EACF,CAAC,CAAC,OAAOgB,GAAG,EAAE;IACZX,gBAAgB,GAAG,IAAI;IACvBE,aAAa,GAAGS,GAAG;EACrB,CAAC,SAAS;IACR,IAAI;MACF,IAAI,CAACZ,wBAAwB,IAAIH,QAAQ,CAAC,QAAQ,CAAC,IAAI,IAAI,EAAE;QAC3DQ,OAAO,GAAGR,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;QAE9B,IAAIU,MAAM,CAACF,OAAO,CAAC,KAAKA,OAAO,EAAE;MACnC;IACF,CAAC,SAAS;MAER,IAAIJ,gBAAgB,EAAE,MAAME,aAAa;IAC3C;EACF;EACA,OAAOJ,IAAI;AACb","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/jsx.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/jsx.js new file mode 100644 index 0000000000000000000000000000000000000000..ca5a957d3d2078cf121f1ea549bd4cc5a3424f78 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/jsx.js @@ -0,0 +1,47 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _createRawReactElement; +var REACT_ELEMENT_TYPE; +function _createRawReactElement(type, props, key, children) { + if (!REACT_ELEMENT_TYPE) { + REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol["for"] && Symbol["for"]("react.element") || 0xeac7; + } + var defaultProps = type && type.defaultProps; + var childrenLength = arguments.length - 3; + if (!props && childrenLength !== 0) { + props = { + children: void 0 + }; + } + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = new Array(childrenLength); + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 3]; + } + props.children = childArray; + } + if (props && defaultProps) { + for (var propName in defaultProps) { + if (props[propName] === void 0) { + props[propName] = defaultProps[propName]; + } + } + } else if (!props) { + props = defaultProps || {}; + } + return { + $$typeof: REACT_ELEMENT_TYPE, + type: type, + key: key === undefined ? null : "" + key, + ref: null, + props: props, + _owner: null + }; +} + +//# sourceMappingURL=jsx.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/jsx.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/jsx.js.map new file mode 100644 index 0000000000000000000000000000000000000000..ef821f65b0b4ecb1518817cb9c8924df10ba8773 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/jsx.js.map @@ -0,0 +1 @@ +{"version":3,"names":["REACT_ELEMENT_TYPE","_createRawReactElement","type","props","key","children","Symbol","defaultProps","childrenLength","arguments","length","childArray","Array","i","propName","$$typeof","undefined","ref","_owner"],"sources":["../../src/helpers/jsx.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nvar REACT_ELEMENT_TYPE: symbol | 0xeac7;\n\ninterface Props {\n children?: any;\n [propName: string]: any;\n}\n\ninterface ReactElement {\n $$typeof: typeof REACT_ELEMENT_TYPE;\n type: any;\n key: string | null;\n ref: null;\n props: Props;\n _owner: null;\n}\n\ntype ReactElementType = any;\ntype ReactKey = string | number | bigint;\ntype ReactNode =\n | ReactElement\n | string\n | number\n | Iterable\n | boolean\n | null\n | undefined;\n\nexport default function _createRawReactElement(\n type: ReactElementType,\n props: Props,\n key?: ReactKey,\n children?: ReactNode[],\n): ReactElement {\n if (!REACT_ELEMENT_TYPE) {\n REACT_ELEMENT_TYPE =\n (typeof Symbol === \"function\" &&\n // \"for\" is a reserved keyword in ES3 so escaping it here for backward compatibility\n Symbol[\"for\"] &&\n Symbol[\"for\"](\"react.element\")) ||\n 0xeac7;\n }\n\n var defaultProps: Props = type && type.defaultProps;\n var childrenLength = arguments.length - 3;\n\n if (!props && childrenLength !== 0) {\n // If we're going to assign props.children, we create a new object now\n // to avoid mutating defaultProps.\n props = { children: void 0 };\n }\n\n if (childrenLength === 1) {\n props.children = children;\n } else if (childrenLength > 1) {\n var childArray = new Array(childrenLength);\n for (var i = 0; i < childrenLength; i++) {\n childArray[i] = arguments[i + 3];\n }\n props.children = childArray;\n }\n\n if (props && defaultProps) {\n for (var propName in defaultProps) {\n if (props[propName] === void 0) {\n props[propName] = defaultProps[propName];\n }\n }\n } else if (!props) {\n props = defaultProps || {};\n }\n\n return {\n $$typeof: REACT_ELEMENT_TYPE,\n type: type,\n key: key === undefined ? null : \"\" + key,\n ref: null,\n props: props,\n _owner: null,\n };\n}\n"],"mappings":";;;;;;AAEA,IAAIA,kBAAmC;AA2BxB,SAASC,sBAAsBA,CAC5CC,IAAsB,EACtBC,KAAY,EACZC,GAAc,EACdC,QAAsB,EACR;EACd,IAAI,CAACL,kBAAkB,EAAE;IACvBA,kBAAkB,GACf,OAAOM,MAAM,KAAK,UAAU,IAE3BA,MAAM,CAAC,KAAK,CAAC,IACbA,MAAM,CAAC,KAAK,CAAC,CAAC,eAAe,CAAC,IAChC,MAAM;EACV;EAEA,IAAIC,YAAmB,GAAGL,IAAI,IAAIA,IAAI,CAACK,YAAY;EACnD,IAAIC,cAAc,GAAGC,SAAS,CAACC,MAAM,GAAG,CAAC;EAEzC,IAAI,CAACP,KAAK,IAAIK,cAAc,KAAK,CAAC,EAAE;IAGlCL,KAAK,GAAG;MAAEE,QAAQ,EAAE,KAAK;IAAE,CAAC;EAC9B;EAEA,IAAIG,cAAc,KAAK,CAAC,EAAE;IACxBL,KAAK,CAACE,QAAQ,GAAGA,QAAQ;EAC3B,CAAC,MAAM,IAAIG,cAAc,GAAG,CAAC,EAAE;IAC7B,IAAIG,UAAU,GAAG,IAAIC,KAAK,CAACJ,cAAc,CAAC;IAC1C,KAAK,IAAIK,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGL,cAAc,EAAEK,CAAC,EAAE,EAAE;MACvCF,UAAU,CAACE,CAAC,CAAC,GAAGJ,SAAS,CAACI,CAAC,GAAG,CAAC,CAAC;IAClC;IACAV,KAAK,CAACE,QAAQ,GAAGM,UAAU;EAC7B;EAEA,IAAIR,KAAK,IAAII,YAAY,EAAE;IACzB,KAAK,IAAIO,QAAQ,IAAIP,YAAY,EAAE;MACjC,IAAIJ,KAAK,CAACW,QAAQ,CAAC,KAAK,KAAK,CAAC,EAAE;QAC9BX,KAAK,CAACW,QAAQ,CAAC,GAAGP,YAAY,CAACO,QAAQ,CAAC;MAC1C;IACF;EACF,CAAC,MAAM,IAAI,CAACX,KAAK,EAAE;IACjBA,KAAK,GAAGI,YAAY,IAAI,CAAC,CAAC;EAC5B;EAEA,OAAO;IACLQ,QAAQ,EAAEf,kBAAkB;IAC5BE,IAAI,EAAEA,IAAI;IACVE,GAAG,EAAEA,GAAG,KAAKY,SAAS,GAAG,IAAI,GAAG,EAAE,GAAGZ,GAAG;IACxCa,GAAG,EAAE,IAAI;IACTd,KAAK,EAAEA,KAAK;IACZe,MAAM,EAAE;EACV,CAAC;AACH","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/maybeArrayLike.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/maybeArrayLike.js new file mode 100644 index 0000000000000000000000000000000000000000..572bbb0d40ae9152d1b173e76b14e61c3dfa6ec2 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/maybeArrayLike.js @@ -0,0 +1,16 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _maybeArrayLike; +var _arrayLikeToArray = require("./arrayLikeToArray.js"); +function _maybeArrayLike(orElse, arr, i) { + if (arr && !Array.isArray(arr) && typeof arr.length === "number") { + var len = arr.length; + return (0, _arrayLikeToArray.default)(arr, i !== void 0 && i < len ? i : len); + } + return orElse(arr, i); +} + +//# sourceMappingURL=maybeArrayLike.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/maybeArrayLike.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/maybeArrayLike.js.map new file mode 100644 index 0000000000000000000000000000000000000000..b69080f1de6aa49c47b627e0a8d294b1397c1dca --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/maybeArrayLike.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_arrayLikeToArray","require","_maybeArrayLike","orElse","arr","i","Array","isArray","length","len","arrayLikeToArray"],"sources":["../../src/helpers/maybeArrayLike.ts"],"sourcesContent":["/* @minVersion 7.9.0 */\n\nimport arrayLikeToArray from \"./arrayLikeToArray.ts\";\n\nexport default function _maybeArrayLike(\n orElse: (arr: any, i: number) => T[] | undefined,\n arr: ArrayLike,\n i: number,\n) {\n if (arr && !Array.isArray(arr) && typeof arr.length === \"number\") {\n var len = arr.length;\n return arrayLikeToArray(arr, i !== void 0 && i < len ? i : len);\n }\n return orElse(arr, i);\n}\n"],"mappings":";;;;;;AAEA,IAAAA,iBAAA,GAAAC,OAAA;AAEe,SAASC,eAAeA,CACrCC,MAAgD,EAChDC,GAAiB,EACjBC,CAAS,EACT;EACA,IAAID,GAAG,IAAI,CAACE,KAAK,CAACC,OAAO,CAACH,GAAG,CAAC,IAAI,OAAOA,GAAG,CAACI,MAAM,KAAK,QAAQ,EAAE;IAChE,IAAIC,GAAG,GAAGL,GAAG,CAACI,MAAM;IACpB,OAAO,IAAAE,yBAAgB,EAAIN,GAAG,EAAEC,CAAC,KAAK,KAAK,CAAC,IAAIA,CAAC,GAAGI,GAAG,GAAGJ,CAAC,GAAGI,GAAG,CAAC;EACpE;EACA,OAAON,MAAM,CAACC,GAAG,EAAEC,CAAC,CAAC;AACvB","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/newArrowCheck.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/newArrowCheck.js new file mode 100644 index 0000000000000000000000000000000000000000..d750092f78a939b3d05df131475f49b0448cfcac --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/newArrowCheck.js @@ -0,0 +1,13 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _newArrowCheck; +function _newArrowCheck(innerThis, boundThis) { + if (innerThis !== boundThis) { + throw new TypeError("Cannot instantiate an arrow function"); + } +} + +//# sourceMappingURL=newArrowCheck.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/newArrowCheck.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/newArrowCheck.js.map new file mode 100644 index 0000000000000000000000000000000000000000..4bb901f945f5d2e742f066570f1096aaacaa8129 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/newArrowCheck.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_newArrowCheck","innerThis","boundThis","TypeError"],"sources":["../../src/helpers/newArrowCheck.js"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _newArrowCheck(innerThis, boundThis) {\n if (innerThis !== boundThis) {\n throw new TypeError(\"Cannot instantiate an arrow function\");\n }\n}\n"],"mappings":";;;;;;AAEe,SAASA,cAAcA,CAACC,SAAS,EAAEC,SAAS,EAAE;EAC3D,IAAID,SAAS,KAAKC,SAAS,EAAE;IAC3B,MAAM,IAAIC,SAAS,CAAC,sCAAsC,CAAC;EAC7D;AACF","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/nonIterableRest.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/nonIterableRest.js new file mode 100644 index 0000000000000000000000000000000000000000..391972fd9ec09a5a1df540e8a24f77de0415989c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/nonIterableRest.js @@ -0,0 +1,11 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _nonIterableRest; +function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} + +//# sourceMappingURL=nonIterableRest.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/nonIterableRest.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/nonIterableRest.js.map new file mode 100644 index 0000000000000000000000000000000000000000..f651ddcb721862240e63fed965b7000dc67cfd3d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/nonIterableRest.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_nonIterableRest","TypeError"],"sources":["../../src/helpers/nonIterableRest.js"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _nonIterableRest() {\n throw new TypeError(\n \"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\",\n );\n}\n"],"mappings":";;;;;;AAEe,SAASA,gBAAgBA,CAAA,EAAG;EACzC,MAAM,IAAIC,SAAS,CACjB,2IACF,CAAC;AACH","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/nonIterableSpread.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/nonIterableSpread.js new file mode 100644 index 0000000000000000000000000000000000000000..6a8bc3f5ab35db5f483dbe02cda75073b30a7a89 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/nonIterableSpread.js @@ -0,0 +1,11 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _nonIterableSpread; +function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} + +//# sourceMappingURL=nonIterableSpread.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/nonIterableSpread.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/nonIterableSpread.js.map new file mode 100644 index 0000000000000000000000000000000000000000..ddd86440b1dd2b465dd63875ca87adc68de3bc20 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/nonIterableSpread.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_nonIterableSpread","TypeError"],"sources":["../../src/helpers/nonIterableSpread.js"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _nonIterableSpread() {\n throw new TypeError(\n \"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\",\n );\n}\n"],"mappings":";;;;;;AAEe,SAASA,kBAAkBA,CAAA,EAAG;EAC3C,MAAM,IAAIC,SAAS,CACjB,sIACF,CAAC;AACH","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/nullishReceiverError.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/nullishReceiverError.js new file mode 100644 index 0000000000000000000000000000000000000000..741d3528805aa6f083700ee49956ec0ac711a9fa --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/nullishReceiverError.js @@ -0,0 +1,11 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _nullishReceiverError; +function _nullishReceiverError(r) { + throw new TypeError("Cannot set property of null or undefined."); +} + +//# sourceMappingURL=nullishReceiverError.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/nullishReceiverError.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/nullishReceiverError.js.map new file mode 100644 index 0000000000000000000000000000000000000000..e485bde31d31f106702227679f3e83db527a16d1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/nullishReceiverError.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_nullishReceiverError","r","TypeError"],"sources":["../../src/helpers/nullishReceiverError.js"],"sourcesContent":["/* @minVersion 7.22.6 */\n\n// eslint-disable-next-line no-unused-vars\nexport default function _nullishReceiverError(r) {\n throw new TypeError(\"Cannot set property of null or undefined.\");\n}\n"],"mappings":";;;;;;AAGe,SAASA,qBAAqBA,CAACC,CAAC,EAAE;EAC/C,MAAM,IAAIC,SAAS,CAAC,2CAA2C,CAAC;AAClE","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectDestructuringEmpty.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectDestructuringEmpty.js new file mode 100644 index 0000000000000000000000000000000000000000..30a045a58f04bc1670413f2956a643c9d170b245 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectDestructuringEmpty.js @@ -0,0 +1,11 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _objectDestructuringEmpty; +function _objectDestructuringEmpty(obj) { + if (obj == null) throw new TypeError("Cannot destructure " + obj); +} + +//# sourceMappingURL=objectDestructuringEmpty.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectDestructuringEmpty.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectDestructuringEmpty.js.map new file mode 100644 index 0000000000000000000000000000000000000000..5b914f8d75f1cb8c6db74cc213e4a688ccff6444 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectDestructuringEmpty.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_objectDestructuringEmpty","obj","TypeError"],"sources":["../../src/helpers/objectDestructuringEmpty.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _objectDestructuringEmpty(\n obj: T | null | undefined,\n): asserts obj is T {\n if (obj == null) throw new TypeError(\"Cannot destructure \" + obj);\n}\n"],"mappings":";;;;;;AAEe,SAASA,yBAAyBA,CAC/CC,GAAyB,EACP;EAClB,IAAIA,GAAG,IAAI,IAAI,EAAE,MAAM,IAAIC,SAAS,CAAC,qBAAqB,GAAGD,GAAG,CAAC;AACnE","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectSpread.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectSpread.js new file mode 100644 index 0000000000000000000000000000000000000000..e65ac316691f5303f1bdd9a3674b0fd597a9bcc9 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectSpread.js @@ -0,0 +1,24 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _objectSpread; +var _defineProperty = require("./defineProperty.js"); +function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? Object(arguments[i]) : {}; + var ownKeys = Object.keys(source); + if (typeof Object.getOwnPropertySymbols === "function") { + ownKeys.push.apply(ownKeys, Object.getOwnPropertySymbols(source).filter(function (sym) { + return Object.getOwnPropertyDescriptor(source, sym).enumerable; + })); + } + ownKeys.forEach(function (key) { + (0, _defineProperty.default)(target, key, source[key]); + }); + } + return target; +} + +//# sourceMappingURL=objectSpread.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectSpread.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectSpread.js.map new file mode 100644 index 0000000000000000000000000000000000000000..0579011293648fb3dac6bac3da0720a419bc4712 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectSpread.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_defineProperty","require","_objectSpread","target","i","arguments","length","source","Object","ownKeys","keys","getOwnPropertySymbols","push","apply","filter","sym","getOwnPropertyDescriptor","enumerable","forEach","key","defineProperty"],"sources":["../../src/helpers/objectSpread.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n/* @onlyBabel7 */\n\nimport defineProperty from \"./defineProperty.ts\";\n\ntype Intersection = R extends [infer H, ...infer S]\n ? H & Intersection\n : unknown;\n\nexport default function _objectSpread(\n target: T,\n ...sources: U\n): T & Intersection;\nexport default function _objectSpread(target: object) {\n for (var i = 1; i < arguments.length; i++) {\n var source: object = arguments[i] != null ? Object(arguments[i]) : {};\n var ownKeys: PropertyKey[] = Object.keys(source);\n if (typeof Object.getOwnPropertySymbols === \"function\") {\n ownKeys.push.apply(\n ownKeys,\n Object.getOwnPropertySymbols(source).filter(function (sym) {\n // sym already comes from `Object.getOwnPropertySymbols`, so getOwnPropertyDescriptor should always be defined\n return Object.getOwnPropertyDescriptor(source, sym)!.enumerable;\n }),\n );\n }\n ownKeys.forEach(function (key) {\n defineProperty(target, key, source[key as keyof typeof source]);\n });\n }\n return target;\n}\n"],"mappings":";;;;;;AAGA,IAAAA,eAAA,GAAAC,OAAA;AAUe,SAASC,aAAaA,CAACC,MAAc,EAAE;EACpD,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGC,SAAS,CAACC,MAAM,EAAEF,CAAC,EAAE,EAAE;IACzC,IAAIG,MAAc,GAAGF,SAAS,CAACD,CAAC,CAAC,IAAI,IAAI,GAAGI,MAAM,CAACH,SAAS,CAACD,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACrE,IAAIK,OAAsB,GAAGD,MAAM,CAACE,IAAI,CAACH,MAAM,CAAC;IAChD,IAAI,OAAOC,MAAM,CAACG,qBAAqB,KAAK,UAAU,EAAE;MACtDF,OAAO,CAACG,IAAI,CAACC,KAAK,CAChBJ,OAAO,EACPD,MAAM,CAACG,qBAAqB,CAACJ,MAAM,CAAC,CAACO,MAAM,CAAC,UAAUC,GAAG,EAAE;QAEzD,OAAOP,MAAM,CAACQ,wBAAwB,CAACT,MAAM,EAAEQ,GAAG,CAAC,CAAEE,UAAU;MACjE,CAAC,CACH,CAAC;IACH;IACAR,OAAO,CAACS,OAAO,CAAC,UAAUC,GAAG,EAAE;MAC7B,IAAAC,uBAAc,EAACjB,MAAM,EAAEgB,GAAG,EAAEZ,MAAM,CAACY,GAAG,CAAwB,CAAC;IACjE,CAAC,CAAC;EACJ;EACA,OAAOhB,MAAM;AACf","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectSpread2.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectSpread2.js new file mode 100644 index 0000000000000000000000000000000000000000..be4e56a778488f79378d26d37fa6f6794b507e68 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectSpread2.js @@ -0,0 +1,39 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _objectSpread2; +var _defineProperty = require("./defineProperty.js"); +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) { + symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + } + keys.push.apply(keys, symbols); + } + return keys; +} +function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + (0, _defineProperty.default)(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + return target; +} + +//# sourceMappingURL=objectSpread2.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectSpread2.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectSpread2.js.map new file mode 100644 index 0000000000000000000000000000000000000000..73f81ba0ad20b52bedfb00b8305c9237ffd1cac1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectSpread2.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_defineProperty","require","ownKeys","object","enumerableOnly","keys","Object","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread2","target","i","arguments","length","source","forEach","key","defineProperty","getOwnPropertyDescriptors","defineProperties"],"sources":["../../src/helpers/objectSpread2.ts"],"sourcesContent":["/* @minVersion 7.5.0 */\n\nimport defineProperty from \"./defineProperty.ts\";\n\n// This function is different to \"Reflect.ownKeys\". The enumerableOnly\n// filters on symbol properties only. Returned string properties are always\n// enumerable. It is good to use in objectSpread.\n\nfunction ownKeys(\n object: object,\n enumerableOnly?: boolean | undefined,\n): (string | symbol)[] {\n var keys: (string | symbol)[] = Object.keys(object);\n if (Object.getOwnPropertySymbols) {\n var symbols = Object.getOwnPropertySymbols(object);\n if (enumerableOnly) {\n symbols = symbols.filter(function (sym) {\n // sym already comes from `Object.getOwnPropertySymbols`, so getOwnPropertyDescriptor should always be defined\n return Object.getOwnPropertyDescriptor(object, sym)!.enumerable;\n });\n }\n keys.push.apply(keys, symbols);\n }\n return keys;\n}\n\ntype Intersection = R extends [infer H, ...infer S]\n ? H & Intersection\n : unknown;\n\nexport default function _objectSpread2(\n target: T,\n ...sources: U\n): T & Intersection;\nexport default function _objectSpread2(target: object) {\n for (var i = 1; i < arguments.length; i++) {\n var source = arguments[i] != null ? arguments[i] : {};\n if (i % 2) {\n ownKeys(Object(source), true).forEach(function (key) {\n defineProperty(target, key, source[key]);\n });\n } else if (Object.getOwnPropertyDescriptors) {\n Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n } else {\n ownKeys(Object(source)).forEach(function (key) {\n Object.defineProperty(\n target,\n key,\n // key already comes from ownKeys, so getOwnPropertyDescriptor should always be defined\n Object.getOwnPropertyDescriptor(source, key)!,\n );\n });\n }\n }\n return target;\n}\n"],"mappings":";;;;;;AAEA,IAAAA,eAAA,GAAAC,OAAA;AAMA,SAASC,OAAOA,CACdC,MAAc,EACdC,cAAoC,EACf;EACrB,IAAIC,IAAyB,GAAGC,MAAM,CAACD,IAAI,CAACF,MAAM,CAAC;EACnD,IAAIG,MAAM,CAACC,qBAAqB,EAAE;IAChC,IAAIC,OAAO,GAAGF,MAAM,CAACC,qBAAqB,CAACJ,MAAM,CAAC;IAClD,IAAIC,cAAc,EAAE;MAClBI,OAAO,GAAGA,OAAO,CAACC,MAAM,CAAC,UAAUC,GAAG,EAAE;QAEtC,OAAOJ,MAAM,CAACK,wBAAwB,CAACR,MAAM,EAAEO,GAAG,CAAC,CAAEE,UAAU;MACjE,CAAC,CAAC;IACJ;IACAP,IAAI,CAACQ,IAAI,CAACC,KAAK,CAACT,IAAI,EAAEG,OAAO,CAAC;EAChC;EACA,OAAOH,IAAI;AACb;AAUe,SAASU,cAAcA,CAACC,MAAc,EAAE;EACrD,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGC,SAAS,CAACC,MAAM,EAAEF,CAAC,EAAE,EAAE;IACzC,IAAIG,MAAM,GAAGF,SAAS,CAACD,CAAC,CAAC,IAAI,IAAI,GAAGC,SAAS,CAACD,CAAC,CAAC,GAAG,CAAC,CAAC;IACrD,IAAIA,CAAC,GAAG,CAAC,EAAE;MACTf,OAAO,CAACI,MAAM,CAACc,MAAM,CAAC,EAAE,IAAI,CAAC,CAACC,OAAO,CAAC,UAAUC,GAAG,EAAE;QACnD,IAAAC,uBAAc,EAACP,MAAM,EAAEM,GAAG,EAAEF,MAAM,CAACE,GAAG,CAAC,CAAC;MAC1C,CAAC,CAAC;IACJ,CAAC,MAAM,IAAIhB,MAAM,CAACkB,yBAAyB,EAAE;MAC3ClB,MAAM,CAACmB,gBAAgB,CAACT,MAAM,EAAEV,MAAM,CAACkB,yBAAyB,CAACJ,MAAM,CAAC,CAAC;IAC3E,CAAC,MAAM;MACLlB,OAAO,CAACI,MAAM,CAACc,MAAM,CAAC,CAAC,CAACC,OAAO,CAAC,UAAUC,GAAG,EAAE;QAC7ChB,MAAM,CAACiB,cAAc,CACnBP,MAAM,EACNM,GAAG,EAEHhB,MAAM,CAACK,wBAAwB,CAACS,MAAM,EAAEE,GAAG,CAC7C,CAAC;MACH,CAAC,CAAC;IACJ;EACF;EACA,OAAON,MAAM;AACf","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectWithoutProperties.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectWithoutProperties.js new file mode 100644 index 0000000000000000000000000000000000000000..bb6e69143a2edff79798850ed84d02065a5e0467 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectWithoutProperties.js @@ -0,0 +1,24 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _objectWithoutProperties; +var _objectWithoutPropertiesLoose = require("./objectWithoutPropertiesLoose.js"); +function _objectWithoutProperties(source, excluded) { + if (source == null) return {}; + var target = (0, _objectWithoutPropertiesLoose.default)(source, excluded); + var key, i; + if (Object.getOwnPropertySymbols) { + var sourceSymbolKeys = Object.getOwnPropertySymbols(source); + for (i = 0; i < sourceSymbolKeys.length; i++) { + key = sourceSymbolKeys[i]; + if (excluded.indexOf(key) !== -1) continue; + if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; + target[key] = source[key]; + } + } + return target; +} + +//# sourceMappingURL=objectWithoutProperties.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectWithoutProperties.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectWithoutProperties.js.map new file mode 100644 index 0000000000000000000000000000000000000000..0e8dc847d9ea549ddd054234ed2985617960d06f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectWithoutProperties.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_objectWithoutPropertiesLoose","require","_objectWithoutProperties","source","excluded","target","objectWithoutPropertiesLoose","key","i","Object","getOwnPropertySymbols","sourceSymbolKeys","length","indexOf","prototype","propertyIsEnumerable","call"],"sources":["../../src/helpers/objectWithoutProperties.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nimport objectWithoutPropertiesLoose from \"./objectWithoutPropertiesLoose.ts\";\n\nexport default function _objectWithoutProperties(\n source: null | undefined,\n excluded: PropertyKey[],\n): Record;\nexport default function _objectWithoutProperties<\n T extends object,\n K extends PropertyKey[],\n>(\n source: T | null | undefined,\n excluded: K,\n): Pick>;\nexport default function _objectWithoutProperties<\n T extends object,\n K extends PropertyKey[],\n>(\n source: T | null | undefined,\n excluded: K,\n): Pick> | Record {\n if (source == null) return {};\n\n var target = objectWithoutPropertiesLoose(source, excluded);\n var key, i;\n\n if (Object.getOwnPropertySymbols) {\n var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n for (i = 0; i < sourceSymbolKeys.length; i++) {\n key = sourceSymbolKeys[i] as keyof typeof source & keyof typeof target;\n if (excluded.indexOf(key) !== -1) continue;\n if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n target[key] = source[key];\n }\n }\n\n return target;\n}\n"],"mappings":";;;;;;AAEA,IAAAA,6BAAA,GAAAC,OAAA;AAae,SAASC,wBAAwBA,CAI9CC,MAA4B,EAC5BC,QAAW,EACmD;EAC9D,IAAID,MAAM,IAAI,IAAI,EAAE,OAAO,CAAC,CAAC;EAE7B,IAAIE,MAAM,GAAG,IAAAC,qCAA4B,EAACH,MAAM,EAAEC,QAAQ,CAAC;EAC3D,IAAIG,GAAG,EAAEC,CAAC;EAEV,IAAIC,MAAM,CAACC,qBAAqB,EAAE;IAChC,IAAIC,gBAAgB,GAAGF,MAAM,CAACC,qBAAqB,CAACP,MAAM,CAAC;IAC3D,KAAKK,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGG,gBAAgB,CAACC,MAAM,EAAEJ,CAAC,EAAE,EAAE;MAC5CD,GAAG,GAAGI,gBAAgB,CAACH,CAAC,CAA8C;MACtE,IAAIJ,QAAQ,CAACS,OAAO,CAACN,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE;MAClC,IAAI,CAACE,MAAM,CAACK,SAAS,CAACC,oBAAoB,CAACC,IAAI,CAACb,MAAM,EAAEI,GAAG,CAAC,EAAE;MAC9DF,MAAM,CAACE,GAAG,CAAC,GAAGJ,MAAM,CAACI,GAAG,CAAC;IAC3B;EACF;EAEA,OAAOF,MAAM;AACf","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectWithoutPropertiesLoose.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectWithoutPropertiesLoose.js new file mode 100644 index 0000000000000000000000000000000000000000..c611f6e46c7a95666641d648a1c6d04d90fb1c6d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectWithoutPropertiesLoose.js @@ -0,0 +1,19 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _objectWithoutPropertiesLoose; +function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + if (excluded.indexOf(key) !== -1) continue; + target[key] = source[key]; + } + } + return target; +} + +//# sourceMappingURL=objectWithoutPropertiesLoose.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectWithoutPropertiesLoose.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectWithoutPropertiesLoose.js.map new file mode 100644 index 0000000000000000000000000000000000000000..424f455bf781f10f7c7b731714cbc8a6e404d632 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/objectWithoutPropertiesLoose.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_objectWithoutPropertiesLoose","source","excluded","target","key","Object","prototype","hasOwnProperty","call","indexOf"],"sources":["../../src/helpers/objectWithoutPropertiesLoose.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _objectWithoutPropertiesLoose<\n T extends object,\n K extends PropertyKey[],\n>(\n source: T | null | undefined,\n excluded: K,\n): Pick>;\nexport default function _objectWithoutPropertiesLoose<\n T extends object,\n K extends Array,\n>(source: T | null | undefined, excluded: K): Omit;\nexport default function _objectWithoutPropertiesLoose(\n source: T | null | undefined,\n excluded: PropertyKey[],\n): Partial {\n if (source == null) return {};\n\n var target: Partial = {};\n\n for (var key in source) {\n if (Object.prototype.hasOwnProperty.call(source, key)) {\n if (excluded.indexOf(key) !== -1) continue;\n target[key] = source[key];\n }\n }\n\n return target;\n}\n"],"mappings":";;;;;;AAae,SAASA,6BAA6BA,CACnDC,MAA4B,EAC5BC,QAAuB,EACX;EACZ,IAAID,MAAM,IAAI,IAAI,EAAE,OAAO,CAAC,CAAC;EAE7B,IAAIE,MAAkB,GAAG,CAAC,CAAC;EAE3B,KAAK,IAAIC,GAAG,IAAIH,MAAM,EAAE;IACtB,IAAII,MAAM,CAACC,SAAS,CAACC,cAAc,CAACC,IAAI,CAACP,MAAM,EAAEG,GAAG,CAAC,EAAE;MACrD,IAAIF,QAAQ,CAACO,OAAO,CAACL,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE;MAClCD,MAAM,CAACC,GAAG,CAAC,GAAGH,MAAM,CAACG,GAAG,CAAC;IAC3B;EACF;EAEA,OAAOD,MAAM;AACf","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/possibleConstructorReturn.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/possibleConstructorReturn.js new file mode 100644 index 0000000000000000000000000000000000000000..6350d0699808c4345a675937be32f441ae2424f8 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/possibleConstructorReturn.js @@ -0,0 +1,17 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _possibleConstructorReturn; +var _assertThisInitialized = require("./assertThisInitialized.js"); +function _possibleConstructorReturn(self, value) { + if (value && (typeof value === "object" || typeof value === "function")) { + return value; + } else if (value !== void 0) { + throw new TypeError("Derived constructors may only return object or undefined"); + } + return (0, _assertThisInitialized.default)(self); +} + +//# sourceMappingURL=possibleConstructorReturn.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/possibleConstructorReturn.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/possibleConstructorReturn.js.map new file mode 100644 index 0000000000000000000000000000000000000000..aca1bc9d3bcf228eab5553b0c44a8dd79614c8c3 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/possibleConstructorReturn.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_assertThisInitialized","require","_possibleConstructorReturn","self","value","TypeError","assertThisInitialized"],"sources":["../../src/helpers/possibleConstructorReturn.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nimport assertThisInitialized from \"./assertThisInitialized.ts\";\n\nexport default function _possibleConstructorReturn(\n self: object | undefined,\n value: unknown,\n) {\n if (value && (typeof value === \"object\" || typeof value === \"function\")) {\n return value;\n } else if (value !== void 0) {\n throw new TypeError(\n \"Derived constructors may only return object or undefined\",\n );\n }\n\n return assertThisInitialized(self);\n}\n"],"mappings":";;;;;;AAEA,IAAAA,sBAAA,GAAAC,OAAA;AAEe,SAASC,0BAA0BA,CAChDC,IAAwB,EACxBC,KAAc,EACd;EACA,IAAIA,KAAK,KAAK,OAAOA,KAAK,KAAK,QAAQ,IAAI,OAAOA,KAAK,KAAK,UAAU,CAAC,EAAE;IACvE,OAAOA,KAAK;EACd,CAAC,MAAM,IAAIA,KAAK,KAAK,KAAK,CAAC,EAAE;IAC3B,MAAM,IAAIC,SAAS,CACjB,0DACF,CAAC;EACH;EAEA,OAAO,IAAAC,8BAAqB,EAACH,IAAI,CAAC;AACpC","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/readOnlyError.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/readOnlyError.js new file mode 100644 index 0000000000000000000000000000000000000000..e96906f0327fea18504ba54005b49acefe4e698d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/readOnlyError.js @@ -0,0 +1,11 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _readOnlyError; +function _readOnlyError(name) { + throw new TypeError('"' + name + '" is read-only'); +} + +//# sourceMappingURL=readOnlyError.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/readOnlyError.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/readOnlyError.js.map new file mode 100644 index 0000000000000000000000000000000000000000..d96eb46a139a959a0d9576ce0fdb6978883d413f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/readOnlyError.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_readOnlyError","name","TypeError"],"sources":["../../src/helpers/readOnlyError.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _readOnlyError(name: string) {\n throw new TypeError('\"' + name + '\" is read-only');\n}\n"],"mappings":";;;;;;AAEe,SAASA,cAAcA,CAACC,IAAY,EAAE;EACnD,MAAM,IAAIC,SAAS,CAAC,GAAG,GAAGD,IAAI,GAAG,gBAAgB,CAAC;AACpD","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/regenerator.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/regenerator.js new file mode 100644 index 0000000000000000000000000000000000000000..f1cb61b5eebc263d99a5145782cd20d1fab26da2 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/regenerator.js @@ -0,0 +1,188 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _regenerator; +var _regeneratorDefine = require("./regeneratorDefine.js"); +function _regenerator() { + var undefined; + var $Symbol = typeof Symbol === "function" ? Symbol : {}; + var iteratorSymbol = $Symbol.iterator || "@@iterator"; + var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; + var _; + function wrap(innerFn, outerFn, self, tryLocsList) { + var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator; + var generator = Object.create(protoGenerator.prototype); + (0, _regeneratorDefine.default)(generator, "_invoke", makeInvokeMethod(innerFn, self, tryLocsList), true); + return generator; + } + var ContinueSentinel = {}; + function Generator() {} + function GeneratorFunction() {} + function GeneratorFunctionPrototype() {} + _ = Object.getPrototypeOf; + var IteratorPrototype = [][iteratorSymbol] ? _(_([][iteratorSymbol]())) : ((0, _regeneratorDefine.default)(_ = {}, iteratorSymbol, function () { + return this; + }), _); + var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype); + GeneratorFunction.prototype = GeneratorFunctionPrototype; + (0, _regeneratorDefine.default)(Gp, "constructor", GeneratorFunctionPrototype); + (0, _regeneratorDefine.default)(GeneratorFunctionPrototype, "constructor", GeneratorFunction); + GeneratorFunction.displayName = "GeneratorFunction"; + (0, _regeneratorDefine.default)(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"); + (0, _regeneratorDefine.default)(Gp); + (0, _regeneratorDefine.default)(Gp, toStringTagSymbol, "Generator"); + (0, _regeneratorDefine.default)(Gp, iteratorSymbol, function () { + return this; + }); + (0, _regeneratorDefine.default)(Gp, "toString", function () { + return "[object Generator]"; + }); + function mark(genFun) { + if (Object.setPrototypeOf) { + Object.setPrototypeOf(genFun, GeneratorFunctionPrototype); + } else { + genFun.__proto__ = GeneratorFunctionPrototype; + (0, _regeneratorDefine.default)(genFun, toStringTagSymbol, "GeneratorFunction"); + } + genFun.prototype = Object.create(Gp); + return genFun; + } + function makeInvokeMethod(innerFn, self, tryLocsList) { + var state = 0; + function invoke(_methodName, _method, _arg) { + if (state > 1) { + throw TypeError("Generator is already running"); + } else if (done) { + if (_method === 1) { + Context_dispatchExceptionOrFinishOrAbrupt(_method, _arg); + } + } + method = _method; + arg = _arg; + while ((_ = method < 2 ? undefined : arg) || !done) { + if (!delegateIterator) { + if (!method) { + ctx.v = arg; + } else if (method < 3) { + if (method > 1) ctx.n = -1; + Context_dispatchExceptionOrFinishOrAbrupt(method, arg); + } else { + ctx.n = arg; + } + } + try { + state = 2; + if (delegateIterator) { + if (!method) _methodName = "next"; + if (_ = delegateIterator[_methodName]) { + if (!(_ = _.call(delegateIterator, arg))) { + throw TypeError("iterator result is not an object"); + } + if (!_.done) { + return _; + } + arg = _.value; + if (method < 2) { + method = 0; + } + } else { + if (method === 1 && (_ = delegateIterator["return"])) { + _.call(delegateIterator); + } + if (method < 2) { + arg = TypeError("The iterator does not provide a '" + _methodName + "' method"); + method = 1; + } + } + delegateIterator = undefined; + } else { + if (done = ctx.n < 0) { + _ = arg; + } else { + _ = innerFn.call(self, ctx); + } + if (_ !== ContinueSentinel) { + break; + } + } + } catch (e) { + delegateIterator = undefined; + method = 1; + arg = e; + } finally { + state = 1; + } + } + return { + value: _, + done: done + }; + } + var tryEntries = tryLocsList || []; + var done = false; + var delegateIterator; + var method; + var arg; + var ctx = { + p: 0, + n: 0, + v: undefined, + a: Context_dispatchExceptionOrFinishOrAbrupt, + f: Context_dispatchExceptionOrFinishOrAbrupt.bind(undefined, 4), + d: function (iterable, nextLoc) { + delegateIterator = iterable; + method = 0; + arg = undefined; + ctx.n = nextLoc; + return ContinueSentinel; + } + }; + function Context_dispatchExceptionOrFinishOrAbrupt(_type, _arg) { + method = _type; + arg = _arg; + for (_ = 0; !done && state && !shouldReturn && _ < tryEntries.length; _++) { + var entry = tryEntries[_]; + var prev = ctx.p; + var finallyLoc = entry[2]; + var shouldReturn; + if (_type > 3) { + if (shouldReturn = finallyLoc === _arg) { + arg = entry[(method = entry[4]) ? 5 : (method = 3, 3)]; + entry[4] = entry[5] = undefined; + } + } else { + if (entry[0] <= prev) { + if (shouldReturn = _type < 2 && prev < entry[1]) { + method = 0; + ctx.v = _arg; + ctx.n = entry[1]; + } else if (prev < finallyLoc) { + if (shouldReturn = _type < 3 || entry[0] > _arg || _arg > finallyLoc) { + entry[4] = _type; + entry[5] = _arg; + ctx.n = finallyLoc; + method = 0; + } + } + } + } + } + if (shouldReturn || _type > 1) { + return ContinueSentinel; + } + done = true; + throw _arg; + } + return invoke; + } + return (exports.default = _regenerator = function () { + return { + w: wrap, + m: mark + }; + })(); +} + +//# sourceMappingURL=regenerator.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/regenerator.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/regenerator.js.map new file mode 100644 index 0000000000000000000000000000000000000000..ef35e2d3c963f030c8d5510de54934656d9ef5c0 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/helpers/regenerator.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_regeneratorDefine","require","_regenerator","undefined","$Symbol","Symbol","iteratorSymbol","iterator","toStringTagSymbol","toStringTag","_","wrap","innerFn","outerFn","self","tryLocsList","protoGenerator","prototype","Generator","generator","Object","create","define","makeInvokeMethod","ContinueSentinel","GeneratorFunction","GeneratorFunctionPrototype","getPrototypeOf","IteratorPrototype","Gp","displayName","mark","genFun","setPrototypeOf","__proto__","state","invoke","_methodName","_method","_arg","TypeError","done","Context_dispatchExceptionOrFinishOrAbrupt","method","arg","delegateIterator","ctx","v","n","call","value","e","tryEntries","p","a","f","bind","d","iterable","nextLoc","_type","shouldReturn","length","entry","prev","finallyLoc","exports","default","w","m"],"sources":["../../src/helpers/regenerator.ts"],"sourcesContent":["/* @minVersion 7.27.0 */\n/* @mangleFns */\n\n/* eslint-disable @typescript-eslint/no-use-before-define */\n/* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */\n\nimport define from \"./regeneratorDefine.ts\";\n\nconst enum GenState {\n SuspendedStart,\n SuspendedYieldOrCompleted,\n Executing,\n}\n\nconst enum OperatorType {\n Next,\n Throw,\n Return,\n Jump,\n Finish,\n}\n\nconst enum ContextNext {\n End = -1,\n}\n\ntype TryLocs = [\n tryLoc: number,\n catchLoc?: number,\n finallyLoc?: number,\n afterLoc?: number,\n];\n\ntype TryEntry = [\n ...TryLocs,\n recordType?: OperatorType.Throw | OperatorType.Jump | OperatorType.Return,\n recordArg?: any,\n];\n\ntype Context = {\n // prev\n p: number;\n // next\n n: number;\n // value\n v: any;\n\n // abrupt\n a(type: OperatorType, arg?: any): any;\n // finish\n f(finallyLoc: number): any;\n // delegateYield\n d(iterable: any, nextLoc: number): any;\n};\n\nexport default function /* @no-mangle */ _regenerator() {\n /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */\n\n var undefined: undefined; // More compressible than void 0.\n var $Symbol =\n typeof Symbol === \"function\" ? Symbol : ({} as SymbolConstructor);\n var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n var _: any;\n\n function wrap(\n innerFn: (this: unknown, context: Context) => unknown,\n outerFn: Function,\n self: unknown,\n tryLocsList: TryLocs[],\n ) {\n // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n var protoGenerator =\n outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n var generator = Object.create(protoGenerator.prototype);\n\n // The ._invoke method unifies the implementations of the .next,\n // .throw, and .return methods.\n define(\n generator,\n \"_invoke\",\n makeInvokeMethod(innerFn, self, tryLocsList),\n true,\n );\n\n return generator;\n }\n\n // Returning this object from the innerFn has the same effect as\n // breaking out of the dispatch switch statement.\n var ContinueSentinel = {};\n\n // Dummy constructor functions that we use as the .constructor and\n // .constructor.prototype properties for functions that return Generator\n // objects. For full spec compliance, you may wish to configure your\n // minifier not to mangle the names of these two functions.\n /* @no-mangle */\n function Generator() {}\n /* @no-mangle */\n function GeneratorFunction() {}\n /* @no-mangle */\n function GeneratorFunctionPrototype() {}\n\n _ = Object.getPrototypeOf;\n var IteratorPrototype = [][iteratorSymbol as typeof Symbol.iterator]\n ? // This environment has a native %IteratorPrototype%; use it instead\n // of the polyfill.\n _(_([][iteratorSymbol as typeof Symbol.iterator]()))\n : // This is a polyfill for %IteratorPrototype% for environments that\n // don't natively support it.\n (define((_ = {}), iteratorSymbol, function (this: unknown) {\n return this;\n }),\n _);\n\n var Gp =\n (GeneratorFunctionPrototype.prototype =\n Generator.prototype =\n Object.create(IteratorPrototype));\n GeneratorFunction.prototype = GeneratorFunctionPrototype;\n define(Gp, \"constructor\", GeneratorFunctionPrototype);\n define(GeneratorFunctionPrototype, \"constructor\", GeneratorFunction);\n GeneratorFunction.displayName = \"GeneratorFunction\";\n define(GeneratorFunctionPrototype, toStringTagSymbol, \"GeneratorFunction\");\n\n // Define Generator.prototype.{next,throw,return} in terms of the\n // unified ._invoke helper method.\n define(Gp);\n\n define(Gp, toStringTagSymbol, \"Generator\");\n\n // A Generator should always return itself as the iterator object when the\n // @@iterator function is called on it. Some browsers' implementations of the\n // iterator prototype chain incorrectly implement this, causing the Generator\n // object to not be returned from this call. This ensures that doesn't happen.\n // See https://github.com/facebook/regenerator/issues/274 for more details.\n define(Gp, iteratorSymbol, function (this: Generator) {\n return this;\n });\n\n define(Gp, \"toString\", function () {\n return \"[object Generator]\";\n });\n\n function mark(genFun: Function) {\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n } else {\n // @ts-expect-error assign to __proto__\n genFun.__proto__ = GeneratorFunctionPrototype;\n define(genFun, toStringTagSymbol, \"GeneratorFunction\");\n }\n genFun.prototype = Object.create(Gp);\n return genFun;\n }\n\n function makeInvokeMethod(\n innerFn: Function,\n self: unknown,\n tryLocsList: TryLocs[],\n ) {\n var state = GenState.SuspendedStart;\n\n function invoke(\n _methodName: \"next\" | \"throw\" | \"return\",\n _method: OperatorType.Next | OperatorType.Throw | OperatorType.Return,\n _arg: any,\n ) {\n if (state > 1 /* Executing */) {\n throw TypeError(\"Generator is already running\");\n } else if (done) {\n if (_method === OperatorType.Throw) {\n Context_dispatchExceptionOrFinishOrAbrupt(_method, _arg);\n }\n }\n\n method = _method;\n arg = _arg;\n\n while ((_ = method < 2 /* Next | Throw */ ? undefined : arg) || !done) {\n if (!delegateIterator) {\n if (!method /* Next */) {\n ctx.v = arg;\n } else if (method < 3 /* Throw | Return */) {\n if (method > 1 /* Return */) ctx.n = ContextNext.End;\n Context_dispatchExceptionOrFinishOrAbrupt(method, arg);\n } else {\n /* Jump */\n ctx.n = arg;\n }\n }\n try {\n state = GenState.Executing;\n if (delegateIterator) {\n // Call delegate.iterator[context.method](context.arg) and handle the result\n\n if (!method /* Next */) _methodName = \"next\";\n if ((_ = delegateIterator[_methodName])) {\n if (!(_ = _.call(delegateIterator, arg))) {\n throw TypeError(\"iterator result is not an object\");\n }\n if (!_.done) {\n // Re-yield the result returned by the delegate method.\n return _;\n }\n\n arg = _.value;\n // If context.method was \"throw\" but the delegate handled the\n // exception, let the outer generator proceed normally. If\n // context.method was \"next\", forget context.arg since it has been\n // \"consumed\" by the delegate iterator. If context.method was\n // \"return\", allow the original .return call to continue in the\n // outer generator.\n // method !== OperatorType.Return\n if (method < 2 /* Throw */) {\n method = OperatorType.Next;\n }\n } else {\n // Note: [\"return\"] must be used for ES3 parsing compatibility.\n if (\n method === OperatorType.Throw &&\n (_ = delegateIterator[\"return\"])\n ) {\n // If the delegate iterator has a return method, give it a\n // chance to clean up.\n _.call(delegateIterator);\n }\n\n if (method < 2 /* Next | Throw */) {\n arg = TypeError(\n \"The iterator does not provide a '\" +\n _methodName +\n \"' method\",\n );\n method = OperatorType.Throw;\n }\n }\n\n // The delegate iterator is finished, so forget it and continue with\n // the outer generator.\n // &\n // A .throw or .return when the delegate iterator has no .throw\n // method, or a missing .next method, always terminate the\n // yield* loop.\n delegateIterator = undefined;\n } else {\n if ((done = ctx.n < 0) /* End */) {\n _ = arg;\n } else {\n _ = innerFn.call(self, ctx);\n }\n\n if (_ !== ContinueSentinel) {\n break;\n }\n }\n } catch (e) {\n delegateIterator = undefined;\n method = OperatorType.Throw;\n arg = e;\n } finally {\n state = GenState.SuspendedYieldOrCompleted;\n }\n }\n // Be forgiving, per GeneratorResume behavior specified since ES2015:\n // ES2015 spec, step 3: https://262.ecma-international.org/6.0/#sec-generatorresume\n // Latest spec, step 2: https://tc39.es/ecma262/#sec-generatorresume\n return {\n value: _,\n done: done,\n };\n }\n\n // The root entry object (effectively a try statement without a catch\n // or a finally block) gives us a place to store values thrown from\n // locations where there is no enclosing try statement.\n var tryEntries: TryEntry[] = tryLocsList || [];\n var done = false;\n var delegateIterator: Iterator | undefined;\n var method: OperatorType;\n var arg: any;\n\n var ctx: Context = {\n p: 0,\n n: 0,\n\n v: undefined,\n\n // abrupt\n a: Context_dispatchExceptionOrFinishOrAbrupt,\n // finish\n f: Context_dispatchExceptionOrFinishOrAbrupt.bind(\n undefined,\n OperatorType.Finish,\n ),\n // delegateYield\n d: function (iterable: any, nextLoc: number) {\n delegateIterator = iterable;\n\n // Deliberately forget the last sent value so that we don't\n // accidentally pass it on to the delegate.\n method = OperatorType.Next;\n arg = undefined;\n ctx.n = nextLoc;\n\n return ContinueSentinel;\n },\n };\n\n function Context_dispatchExceptionOrFinishOrAbrupt(\n _type: OperatorType,\n _arg: any,\n ) {\n method = _type;\n arg = _arg;\n for (\n _ = 0;\n !done &&\n state /* state !== SuspendedStart */ &&\n !shouldReturn &&\n _ < tryEntries.length;\n _++\n ) {\n var entry = tryEntries[_];\n var prev = ctx.p;\n var finallyLoc = entry[2]!;\n var shouldReturn;\n\n if (_type > 3 /* Finish */) {\n if ((shouldReturn = finallyLoc === _arg)) {\n // The following code logic is equivalent to the commented code.\n // if ((method = entry[4]!)) {\n // arg = entry[5];\n // } else {\n // method = OperatorType.Jump;\n // arg = entry[3];\n // }\n arg =\n entry[\n // eslint-disable-next-line no-cond-assign\n (method = entry[4]!) ? 5 : ((method = OperatorType.Jump), 3)\n ];\n entry[4] = entry[5] = undefined;\n }\n } else {\n if (entry[0] <= prev) {\n if ((shouldReturn = _type < 2 /* Throw */ && prev < entry[1]!)) {\n // If the dispatched exception was caught by a catch block,\n // then let that catch block handle the exception normally.\n method = OperatorType.Next;\n ctx.v = _arg;\n ctx.n = entry[1]!;\n } else if (prev < finallyLoc) {\n if (\n (shouldReturn =\n // Ignore the finally entry if control is not jumping to a\n // location outside the try/catch block.\n _type < 3 /* Throw | Return */ ||\n entry[0] > _arg ||\n _arg > finallyLoc)\n ) {\n entry[4] = _type as\n | OperatorType.Return\n | OperatorType.Jump\n | OperatorType.Throw;\n entry[5] = _arg;\n ctx.n = finallyLoc;\n method = OperatorType.Next;\n }\n }\n }\n }\n }\n if (shouldReturn || _type > 1 /* _type !== Throw */) {\n return ContinueSentinel;\n }\n done = true;\n throw _arg;\n }\n\n return invoke;\n }\n\n // @ts-expect-error explicit function assignment\n return (_regenerator = function () {\n return { w: wrap, m: mark };\n })();\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/index.js new file mode 100644 index 0000000000000000000000000000000000000000..a9bc9dbec0e8de0673b3f270629cd43212d552bd --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/index.js @@ -0,0 +1,126 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; +exports.get = get; +exports.getDependencies = getDependencies; +exports.isInternal = isInternal; +exports.list = void 0; +exports.minVersion = minVersion; +var _t = require("@babel/types"); +var _helpersGenerated = require("./helpers-generated.js"); +const { + cloneNode, + identifier +} = _t; +function deep(obj, path, value) { + try { + const parts = path.split("."); + let last = parts.shift(); + while (parts.length > 0) { + obj = obj[last]; + last = parts.shift(); + } + if (arguments.length > 2) { + obj[last] = value; + } else { + return obj[last]; + } + } catch (e) { + e.message += ` (when accessing ${path})`; + throw e; + } +} +function permuteHelperAST(ast, metadata, bindingName, localBindings, getDependency, adjustAst) { + const { + locals, + dependencies, + exportBindingAssignments, + exportName + } = metadata; + const bindings = new Set(localBindings || []); + if (bindingName) bindings.add(bindingName); + for (const [name, paths] of (Object.entries || (o => Object.keys(o).map(k => [k, o[k]])))(locals)) { + let newName = name; + if (bindingName && name === exportName) { + newName = bindingName; + } else { + while (bindings.has(newName)) newName = "_" + newName; + } + if (newName !== name) { + for (const path of paths) { + deep(ast, path, identifier(newName)); + } + } + } + for (const [name, paths] of (Object.entries || (o => Object.keys(o).map(k => [k, o[k]])))(dependencies)) { + const ref = typeof getDependency === "function" && getDependency(name) || identifier(name); + for (const path of paths) { + deep(ast, path, cloneNode(ref)); + } + } + adjustAst == null || adjustAst(ast, exportName, map => { + exportBindingAssignments.forEach(p => deep(ast, p, map(deep(ast, p)))); + }); +} +const helperData = Object.create(null); +function loadHelper(name) { + if (!helperData[name]) { + const helper = _helpersGenerated.default[name]; + if (!helper) { + throw Object.assign(new ReferenceError(`Unknown helper ${name}`), { + code: "BABEL_HELPER_UNKNOWN", + helper: name + }); + } + helperData[name] = { + minVersion: helper.minVersion, + build(getDependency, bindingName, localBindings, adjustAst) { + const ast = helper.ast(); + permuteHelperAST(ast, helper.metadata, bindingName, localBindings, getDependency, adjustAst); + return { + nodes: ast.body, + globals: helper.metadata.globals + }; + }, + getDependencies() { + return Object.keys(helper.metadata.dependencies); + } + }; + } + return helperData[name]; +} +function get(name, getDependency, bindingName, localBindings, adjustAst) { + { + if (typeof bindingName === "object") { + const id = bindingName; + if ((id == null ? void 0 : id.type) === "Identifier") { + bindingName = id.name; + } else { + bindingName = undefined; + } + } + } + return loadHelper(name).build(getDependency, bindingName, localBindings, adjustAst); +} +function minVersion(name) { + return loadHelper(name).minVersion; +} +function getDependencies(name) { + return loadHelper(name).getDependencies(); +} +function isInternal(name) { + var _helpers$name; + return (_helpers$name = _helpersGenerated.default[name]) == null ? void 0 : _helpers$name.metadata.internal; +} +{ + exports.ensure = name => { + loadHelper(name); + }; +} +const list = exports.list = Object.keys(_helpersGenerated.default).map(name => name.replace(/^_/, "")); +var _default = exports.default = get; + +//# sourceMappingURL=index.js.map diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/index.js.map b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/index.js.map new file mode 100644 index 0000000000000000000000000000000000000000..10d10d51f31f6824c1700c6af91a278c3b35fd3c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/lib/index.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_t","require","_helpersGenerated","cloneNode","identifier","deep","obj","path","value","parts","split","last","shift","length","arguments","e","message","permuteHelperAST","ast","metadata","bindingName","localBindings","getDependency","adjustAst","locals","dependencies","exportBindingAssignments","exportName","bindings","Set","add","name","paths","Object","entries","o","keys","map","k","newName","has","ref","forEach","p","helperData","create","loadHelper","helper","helpers","assign","ReferenceError","code","minVersion","build","nodes","body","globals","getDependencies","get","id","type","undefined","isInternal","_helpers$name","internal","exports","ensure","list","replace","_default","default"],"sources":["../src/index.ts"],"sourcesContent":["import { cloneNode, identifier } from \"@babel/types\";\nimport type * as t from \"@babel/types\";\nimport helpers from \"./helpers-generated.ts\";\nimport type { HelperMetadata } from \"./helpers-generated.ts\";\n\ntype GetDependency = (name: string) => t.Expression;\n\nfunction deep(obj: any, path: string, value?: unknown) {\n try {\n const parts = path.split(\".\");\n let last = parts.shift();\n while (parts.length > 0) {\n obj = obj[last];\n last = parts.shift();\n }\n if (arguments.length > 2) {\n obj[last] = value;\n } else {\n return obj[last];\n }\n } catch (e) {\n e.message += ` (when accessing ${path})`;\n throw e;\n }\n}\n\ntype AdjustAst = (\n ast: t.Program,\n exportName: string,\n mapExportBindingAssignments: (\n map: (node: t.Expression) => t.Expression,\n ) => void,\n) => void;\n\n/**\n * Given a helper AST and information about how it will be used, update the AST to match the usage.\n */\nfunction permuteHelperAST(\n ast: t.Program,\n metadata: HelperMetadata,\n bindingName: string | undefined,\n localBindings: string[] | undefined,\n getDependency: GetDependency | undefined,\n adjustAst: AdjustAst | undefined,\n) {\n const { locals, dependencies, exportBindingAssignments, exportName } =\n metadata;\n\n const bindings = new Set(localBindings || []);\n if (bindingName) bindings.add(bindingName);\n for (const [name, paths] of Object.entries(locals)) {\n let newName = name;\n if (bindingName && name === exportName) {\n newName = bindingName;\n } else {\n while (bindings.has(newName)) newName = \"_\" + newName;\n }\n\n if (newName !== name) {\n for (const path of paths) {\n deep(ast, path, identifier(newName));\n }\n }\n }\n\n for (const [name, paths] of Object.entries(dependencies)) {\n const ref =\n (typeof getDependency === \"function\" && getDependency(name)) ||\n identifier(name);\n for (const path of paths) {\n deep(ast, path, cloneNode(ref));\n }\n }\n\n adjustAst?.(ast, exportName, map => {\n exportBindingAssignments.forEach(p => deep(ast, p, map(deep(ast, p))));\n });\n}\n\ninterface HelperData {\n build: (\n getDependency: GetDependency | undefined,\n bindingName: string | undefined,\n localBindings: string[] | undefined,\n adjustAst: AdjustAst | undefined,\n ) => {\n nodes: t.Program[\"body\"];\n globals: string[];\n };\n minVersion: string;\n getDependencies: () => string[];\n}\n\nconst helperData: Record = Object.create(null);\nfunction loadHelper(name: string) {\n if (!helperData[name]) {\n const helper = helpers[name];\n if (!helper) {\n throw Object.assign(new ReferenceError(`Unknown helper ${name}`), {\n code: \"BABEL_HELPER_UNKNOWN\",\n helper: name,\n });\n }\n\n helperData[name] = {\n minVersion: helper.minVersion,\n build(getDependency, bindingName, localBindings, adjustAst) {\n const ast = helper.ast();\n permuteHelperAST(\n ast,\n helper.metadata,\n bindingName,\n localBindings,\n getDependency,\n adjustAst,\n );\n\n return {\n nodes: ast.body,\n globals: helper.metadata.globals,\n };\n },\n getDependencies() {\n return Object.keys(helper.metadata.dependencies);\n },\n };\n }\n\n return helperData[name];\n}\n\nexport function get(\n name: string,\n getDependency?: GetDependency,\n bindingName?: string,\n localBindings?: string[],\n adjustAst?: AdjustAst,\n) {\n if (!process.env.BABEL_8_BREAKING) {\n // In older versions, bindingName was a t.Identifier | t.MemberExpression\n if (typeof bindingName === \"object\") {\n const id = bindingName as t.Identifier | t.MemberExpression | null;\n if (id?.type === \"Identifier\") {\n bindingName = id.name;\n } else {\n bindingName = undefined;\n }\n }\n }\n return loadHelper(name).build(\n getDependency,\n bindingName,\n localBindings,\n adjustAst,\n );\n}\n\nexport function minVersion(name: string) {\n return loadHelper(name).minVersion;\n}\n\nexport function getDependencies(name: string): ReadonlyArray {\n return loadHelper(name).getDependencies();\n}\n\nexport function isInternal(name: string): boolean {\n return helpers[name]?.metadata.internal;\n}\n\nif (!process.env.BABEL_8_BREAKING && !USE_ESM) {\n // eslint-disable-next-line no-restricted-globals\n exports.ensure = (name: string) => {\n loadHelper(name);\n };\n}\n\nexport const list = Object.keys(helpers).map(name => name.replace(/^_/, \"\"));\n\nexport default get;\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/package.json new file mode 100644 index 0000000000000000000000000000000000000000..b5dbe25168dac15d1b06058add256ee7f08e6ce1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/helpers/package.json @@ -0,0 +1,31 @@ +{ + "name": "@babel/helpers", + "version": "7.28.3", + "description": "Collection of helper functions used by Babel transforms.", + "author": "The Babel Team (https://babel.dev/team)", + "homepage": "https://babel.dev/docs/en/next/babel-helpers", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-helpers" + }, + "main": "./lib/index.js", + "dependencies": { + "@babel/template": "^7.27.2", + "@babel/types": "^7.28.2" + }, + "devDependencies": { + "@babel/generator": "^7.28.3", + "@babel/helper-plugin-test-runner": "^7.27.1", + "@babel/parser": "^7.28.3", + "regenerator-runtime": "^0.14.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "type": "commonjs" +} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/parser/CHANGELOG.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/parser/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..b3840ac8d0ac588ea7a2483c29acb58929a7536e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/parser/CHANGELOG.md @@ -0,0 +1,1073 @@ +# Changelog + +> **Tags:** +> - :boom: [Breaking Change] +> - :eyeglasses: [Spec Compliance] +> - :rocket: [New Feature] +> - :bug: [Bug Fix] +> - :memo: [Documentation] +> - :house: [Internal] +> - :nail_care: [Polish] + +> Semver Policy: https://github.com/babel/babel/tree/main/packages/babel-parser#semver + +_Note: Gaps between patch versions are faulty, broken or test releases._ + +See the [Babel Changelog](https://github.com/babel/babel/blob/main/CHANGELOG.md) for the pre-6.8.0 version Changelog. + +## 6.17.1 (2017-05-10) + +### :bug: Bug Fix + * Fix typo in flow spread operator error (Brian Ng) + * Fixed invalid number literal parsing ([#473](https://github.com/babel/babylon/pull/473)) (Alex Kuzmenko) + * Fix number parser ([#433](https://github.com/babel/babylon/pull/433)) (Alex Kuzmenko) + * Ensure non pattern shorthand props are checked for reserved words ([#479](https://github.com/babel/babylon/pull/479)) (Brian Ng) + * Remove jsx context when parsing arrow functions ([#475](https://github.com/babel/babylon/pull/475)) (Brian Ng) + * Allow super in class properties ([#499](https://github.com/babel/babylon/pull/499)) (Brian Ng) + * Allow flow class field to be named constructor ([#510](https://github.com/babel/babylon/pull/510)) (Brian Ng) + +## 6.17.0 (2017-04-20) + +### :bug: Bug Fix + * Cherry-pick #418 to 6.x ([#476](https://github.com/babel/babylon/pull/476)) (Sebastian McKenzie) + * Add support for invalid escapes in tagged templates ([#274](https://github.com/babel/babylon/pull/274)) (Kevin Gibbons) + * Throw error if new.target is used outside of a function ([#402](https://github.com/babel/babylon/pull/402)) (Brian Ng) + * Fix parsing of class properties ([#351](https://github.com/babel/babylon/pull/351)) (Kevin Gibbons) + * Fix parsing yield with dynamicImport ([#383](https://github.com/babel/babylon/pull/383)) (Brian Ng) + * Ensure consistent start args for parseParenItem ([#386](https://github.com/babel/babylon/pull/386)) (Brian Ng) + +## 7.0.0-beta.8 (2017-04-04) + +### New Feature +* Add support for flow type spread (#418) (Conrad Buck) +* Allow statics in flow interfaces (#427) (Brian Ng) + +### Bug Fix +* Fix predicate attachment to match flow parser (#428) (Brian Ng) +* Add extra.raw back to JSXText and JSXAttribute (#344) (Alex Rattray) +* Fix rest parameters with array and objects (#424) (Brian Ng) +* Fix number parser (#433) (Alex Kuzmenko) + +### Docs +* Fix CONTRIBUTING.md [skip ci] (#432) (Alex Kuzmenko) + +### Internal +* Use babel-register script when running babel smoke tests (#442) (Brian Ng) + +## 7.0.0-beta.7 (2017-03-22) + +### Spec Compliance +* Remove babylon plugin for template revision since it's stage-4 (#426) (Henry Zhu) + +### Bug Fix + +* Fix push-pop logic in flow (#405) (Daniel Tschinder) + +## 7.0.0-beta.6 (2017-03-21) + +### New Feature +* Add support for invalid escapes in tagged templates (#274) (Kevin Gibbons) + +### Polish +* Improves error message when super is called outside of constructor (#408) (Arshabh Kumar Agarwal) + +### Docs + +* [7.0] Moved value field in spec from ObjectMember to ObjectProperty as ObjectMethod's don't have it (#415) [skip ci] (James Browning) + +## 7.0.0-beta.5 (2017-03-21) + +### Bug Fix +* Throw error if new.target is used outside of a function (#402) (Brian Ng) +* Fix parsing of class properties (#351) (Kevin Gibbons) + +### Other + * Test runner: Detect extra property in 'actual' but not in 'expected'. (#407) (Andy) + * Optimize travis builds (#419) (Daniel Tschinder) + * Update codecov to 2.0 (#412) (Daniel Tschinder) + * Fix spec for ClassMethod: It doesn't have a function, it *is* a function. (#406) [skip ci] (Andy) + * Changed Non-existent RestPattern to RestElement which is what is actually parsed (#409) [skip ci] (James Browning) + * Upgrade flow to 0.41 (Daniel Tschinder) + * Fix watch command (#403) (Brian Ng) + * Update yarn lock (Daniel Tschinder) + * Fix watch command (#403) (Brian Ng) + * chore(package): update flow-bin to version 0.41.0 (#395) (greenkeeper[bot]) + * Add estree test for correct order of directives (Daniel Tschinder) + * Add DoExpression to spec (#364) (Alex Kuzmenko) + * Mention cloning of repository in CONTRIBUTING.md (#391) [skip ci] (Sumedh Nimkarde) + * Explain how to run only one test (#389) [skip ci] (Aaron Ang) + + ## 7.0.0-beta.4 (2017-03-01) + +* Don't consume async when checking for async func decl (#377) (Brian Ng) +* add `ranges` option [skip ci] (Henry Zhu) +* Don't parse class properties without initializers when classProperties is disabled and Flow is enabled (#300) (Andrew Levine) + +## 7.0.0-beta.3 (2017-02-28) + +- [7.0] Change RestProperty/SpreadProperty to RestElement/SpreadElement (#384) +- Merge changes from 6.x + +## 7.0.0-beta.2 (2017-02-20) + +- estree: correctly change literals in all cases (#368) (Daniel Tschinder) + +## 7.0.0-beta.1 (2017-02-20) + +- Fix negative number literal typeannotations (#366) (Daniel Tschinder) +- Update contributing with more test info [skip ci] (#355) (Brian Ng) + +## 7.0.0-beta.0 (2017-02-15) + +- Reintroduce Variance node (#333) (Daniel Tschinder) +- Rename NumericLiteralTypeAnnotation to NumberLiteralTypeAnnotation (#332) (Charles Pick) +- [7.0] Remove ForAwaitStatement, add await flag to ForOfStatement (#349) (Brandon Dail) +- chore(package): update ava to version 0.18.0 (#345) (greenkeeper[bot]) +- chore(package): update babel-plugin-istanbul to version 4.0.0 (#350) (greenkeeper[bot]) +- Change location of ObjectTypeIndexer to match flow (#228) (Daniel Tschinder) +- Rename flow AST Type ExistentialTypeParam to ExistsTypeAnnotation (#322) (Toru Kobayashi) +- Revert "Temporary rollback for erroring on trailing comma with spread (#154)" (#290) (Daniel Tschinder) +- Remove classConstructorCall plugin (#291) (Brian Ng) +- Update yarn.lock (Daniel Tschinder) +- Update cross-env to 3.x (Daniel Tschinder) +- [7.0] Remove node 0.10, 0.12 and 5 from Travis (#284) (Sergey Rubanov) +- Remove `String.fromCodePoint` shim (#279) (Mathias Bynens) + +## 6.16.1 (2017-02-23) + +### :bug: Regression + +- Revert "Fix export default async function to be FunctionDeclaration" ([#375](https://github.com/babel/babylon/pull/375)) + +Need to modify Babel for this AST node change, so moving to 7.0. + +- Revert "Don't parse class properties without initializers when classProperties plugin is disabled, and Flow is enabled" ([#376](https://github.com/babel/babylon/pull/376)) + +[react-native](https://github.com/facebook/react-native/issues/12542) broke with this so we reverted. + +## 6.16.0 (2017-02-23) + +### :rocket: New Feature + +***ESTree*** compatibility as plugin ([#277](https://github.com/babel/babylon/pull/277)) (Daniel Tschinder) + +We finally introduce a new compatibility layer for ESTree. To put babylon into ESTree-compatible mode the new plugin `estree` can be enabled. In this mode the parser will output an AST that is compliant to the specs of [ESTree](https://github.com/estree/estree/) + +We highly recommend everyone who uses babylon outside of babel to use this plugin. This will make it much easier for users to switch between different ESTree-compatible parsers. We so far tested several projects with different parsers and exchanged their parser to babylon and in nearly all cases it worked out of the box. Some other estree-compatible parsers include `acorn`, `esprima`, `espree`, `flow-parser`, etc. + +To enable `estree` mode simply add the plugin in the config: +```json +{ + "plugins": [ "estree" ] +} +``` + +If you want to migrate your project from non-ESTree mode to ESTree, have a look at our [Readme](https://github.com/babel/babylon/#output), where all deviations are mentioned. + +Add a parseExpression public method ([#213](https://github.com/babel/babylon/pull/213)) (jeromew) + +Babylon exports a new function to parse a single expression + +```js +import { parseExpression } from 'babylon'; + +const ast = parseExpression('x || y && z', options); +``` + +The returned AST will only consist of the expression. The options are the same as for `parse()` + +Add startLine option ([#346](https://github.com/babel/babylon/pull/346)) (Raphael Mu) + +A new option was added to babylon allowing to change the initial linenumber for the first line which is usually `1`. +Changing this for example to `100` will make line `1` of the input source to be marked as line `100`, line `2` as `101`, line `3` as `102`, ... + +Function predicate declaration ([#103](https://github.com/babel/babylon/pull/103)) (Panagiotis Vekris) + +Added support for function predicates which flow introduced in version 0.33.0 + +```js +declare function is_number(x: mixed): boolean %checks(typeof x === "number"); +``` + +Allow imports in declare module ([#315](https://github.com/babel/babylon/pull/315)) (Daniel Tschinder) + +Added support for imports within module declarations which flow introduced in version 0.37.0 + +```js +declare module "C" { + import type { DT } from "D"; + declare export type CT = { D: DT }; +} +``` + +### :eyeglasses: Spec Compliance + +Forbid semicolons after decorators in classes ([#352](https://github.com/babel/babylon/pull/352)) (Kevin Gibbons) + +This example now correctly throws an error when there is a semicolon after the decorator: + +```js +class A { +@a; +foo(){} +} +``` + +Keywords are not allowed as local specifier ([#307](https://github.com/babel/babylon/pull/307)) (Daniel Tschinder) + +Using keywords in imports is not allowed anymore: + +```js +import { default } from "foo"; +import { a as debugger } from "foo"; +``` + +Do not allow overwritting of primitive types ([#314](https://github.com/babel/babylon/pull/314)) (Daniel Tschinder) + +In flow it is now forbidden to overwrite the primitive types `"any"`, `"mixed"`, `"empty"`, `"bool"`, `"boolean"`, `"number"`, `"string"`, `"void"` and `"null"` with your own type declaration. + +Disallow import type { type a } from … ([#305](https://github.com/babel/babylon/pull/305)) (Daniel Tschinder) + +The following code now correctly throws an error + +```js +import type { type a } from "foo"; +``` + +Don't parse class properties without initializers when classProperties is disabled and Flow is enabled ([#300](https://github.com/babel/babylon/pull/300)) (Andrew Levine) + +Ensure that you enable the `classProperties` plugin in order to enable correct parsing of class properties. Prior to this version it was possible to parse them by enabling the `flow` plugin but this was not intended the behaviour. + +If you enable the flow plugin you can only define the type of the class properties, but not initialize them. + +Fix export default async function to be FunctionDeclaration ([#324](https://github.com/babel/babylon/pull/324)) (Daniel Tschinder) + +Parsing the following code now returns a `FunctionDeclaration` AST node instead of `FunctionExpression`. + +```js +export default async function bar() {}; +``` + +### :nail_care: Polish + +Improve error message on attempt to destructure named import ([#288](https://github.com/babel/babylon/pull/288)) (Brian Ng) + +### :bug: Bug Fix + +Fix negative number literal typeannotations ([#366](https://github.com/babel/babylon/pull/366)) (Daniel Tschinder) + +Ensure takeDecorators is called on exported class ([#358](https://github.com/babel/babylon/pull/358)) (Brian Ng) + +ESTree: correctly change literals in all cases ([#368](https://github.com/babel/babylon/pull/368)) (Daniel Tschinder) + +Correctly convert RestProperty to Assignable ([#339](https://github.com/babel/babylon/pull/339)) (Daniel Tschinder) + +Fix #321 by allowing question marks in type params ([#338](https://github.com/babel/babylon/pull/338)) (Daniel Tschinder) + +Fix #336 by correctly setting arrow-param ([#337](https://github.com/babel/babylon/pull/337)) (Daniel Tschinder) + +Fix parse error when destructuring `set` with default value ([#317](https://github.com/babel/babylon/pull/317)) (Brian Ng) + +Fix ObjectTypeCallProperty static ([#298](https://github.com/babel/babylon/pull/298)) (Dan Harper) + + +### :house: Internal + +Fix generator-method-with-computed-name spec ([#360](https://github.com/babel/babylon/pull/360)) (Alex Rattray) + +Fix flow type-parameter-declaration test with unintended semantic ([#361](https://github.com/babel/babylon/pull/361)) (Alex Rattray) + +Cleanup and splitup parser functions ([#295](https://github.com/babel/babylon/pull/295)) (Daniel Tschinder) + +chore(package): update flow-bin to version 0.38.0 ([#313](https://github.com/babel/babylon/pull/313)) (greenkeeper[bot]) + +Call inner function instead of 1:1 copy to plugin ([#294](https://github.com/babel/babylon/pull/294)) (Daniel Tschinder) + +Update eslint-config-babel to the latest version 🚀 ([#299](https://github.com/babel/babylon/pull/299)) (greenkeeper[bot]) + +Update eslint-config-babel to the latest version 🚀 ([#293](https://github.com/babel/babylon/pull/293)) (greenkeeper[bot]) + +devDeps: remove eslint-plugin-babel ([#292](https://github.com/babel/babylon/pull/292)) (Kai Cataldo) + +Correct indent eslint rule config ([#276](https://github.com/babel/babylon/pull/276)) (Daniel Tschinder) + +Fail tests that have expected.json and throws-option ([#285](https://github.com/babel/babylon/pull/285)) (Daniel Tschinder) + +### :memo: Documentation + +Update contributing with more test info [skip ci] ([#355](https://github.com/babel/babylon/pull/355)) (Brian Ng) + +Update API documentation ([#330](https://github.com/babel/babylon/pull/330)) (Timothy Gu) + +Added keywords to package.json ([#323](https://github.com/babel/babylon/pull/323)) (Dmytro) + +AST spec: fix casing of `RegExpLiteral` ([#318](https://github.com/babel/babylon/pull/318)) (Mathias Bynens) + +## 6.15.0 (2017-01-10) + +### :eyeglasses: Spec Compliance + +Add support for Flow shorthand import type ([#267](https://github.com/babel/babylon/pull/267)) (Jeff Morrison) + +This change implements flows new shorthand import syntax +and where previously you had to write this code: + +```js +import {someValue} from "blah"; +import type {someType} from "blah"; +import typeof {someOtherValue} from "blah"; +``` + +you can now write it like this: + +```js +import { + someValue, + type someType, + typeof someOtherValue, +} from "blah"; +``` + +For more information look at [this](https://github.com/facebook/flow/pull/2890) pull request. + +flow: allow leading pipes in all positions ([#256](https://github.com/babel/babylon/pull/256)) (Vladimir Kurchatkin) + +This change now allows a leading pipe everywhere types can be used: +```js +var f = (x): | 1 | 2 => 1; +``` + +Throw error when exporting non-declaration ([#241](https://github.com/babel/babylon/pull/241)) (Kai Cataldo) + +Previously babylon parsed the following exports, although they are not valid: +```js +export typeof foo; +export new Foo(); +export function() {}; +export for (;;); +export while(foo); +``` + +### :bug: Bug Fix + +Don't set inType flag when parsing property names ([#266](https://github.com/babel/babylon/pull/266)) (Vladimir Kurchatkin) + +This fixes parsing of this case: + +```js +const map = { + [age <= 17] : 'Too young' +}; +``` + +Fix source location for JSXEmptyExpression nodes (fixes #248) ([#249](https://github.com/babel/babylon/pull/249)) (James Long) + +The following case produced an invalid AST +```js +
{/* foo */}
+``` + +Use fromCodePoint to convert high value unicode entities ([#243](https://github.com/babel/babylon/pull/243)) (Ryan Duffy) + +When high value unicode entities (e.g. 💩) were used in the input source code they are now correctly encoded in the resulting AST. + +Rename folder to avoid Windows-illegal characters ([#281](https://github.com/babel/babylon/pull/281)) (Ryan Plant) + +Allow this.state.clone() when parsing decorators ([#262](https://github.com/babel/babylon/pull/262)) (Alex Rattray) + +### :house: Internal + +User external-helpers ([#254](https://github.com/babel/babylon/pull/254)) (Daniel Tschinder) + +Add watch script for dev ([#234](https://github.com/babel/babylon/pull/234)) (Kai Cataldo) + +Freeze current plugins list for "*" option, and remove from README.md ([#245](https://github.com/babel/babylon/pull/245)) (Andrew Levine) + +Prepare tests for multiple fixture runners. ([#240](https://github.com/babel/babylon/pull/240)) (Daniel Tschinder) + +Add some test coverage for decorators stage-0 plugin ([#250](https://github.com/babel/babylon/pull/250)) (Andrew Levine) + +Refactor tokenizer types file ([#263](https://github.com/babel/babylon/pull/263)) (Sven SAULEAU) + +Update eslint-config-babel to the latest version 🚀 ([#273](https://github.com/babel/babylon/pull/273)) (greenkeeper[bot]) + +chore(package): update rollup to version 0.41.0 ([#272](https://github.com/babel/babylon/pull/272)) (greenkeeper[bot]) + +chore(package): update flow-bin to version 0.37.0 ([#255](https://github.com/babel/babylon/pull/255)) (greenkeeper[bot]) + +## 6.14.1 (2016-11-17) + +### :bug: Bug Fix + +Allow `"plugins": ["*"]` ([#229](https://github.com/babel/babylon/pull/229)) (Daniel Tschinder) + +```js +{ + "plugins": ["*"] +} +``` + +Will include all parser plugins instead of specifying each one individually. Useful for tools like babel-eslint, jscodeshift, and ast-explorer. + +## 6.14.0 (2016-11-16) + +### :eyeglasses: Spec Compliance + +Throw error for reserved words `enum` and `await` ([#195](https://github.com/babel/babylon/pull/195)) (Kai Cataldo) + +[11.6.2.2 Future Reserved Words](http://www.ecma-international.org/ecma-262/6.0/#sec-future-reserved-words) + +Babylon will throw for more reserved words such as `enum` or `await` (in strict mode). + +``` +class enum {} // throws +class await {} // throws in strict mode (module) +``` + +Optional names for function types and object type indexers ([#197](https://github.com/babel/babylon/pull/197)) (Gabe Levi) + +So where you used to have to write + +```js +type A = (x: string, y: boolean) => number; +type B = (z: string) => number; +type C = { [key: string]: number }; +``` + +you can now write (with flow 0.34.0) + +```js +type A = (string, boolean) => number; +type B = string => number; +type C = { [string]: number }; +``` + +Parse flow nested array type annotations like `number[][]` ([#219](https://github.com/babel/babylon/pull/219)) (Bernhard Häussner) + +Supports these form now of specifying array types: + +```js +var a: number[][][][]; +var b: string[][]; +``` + +### :bug: Bug Fix + +Correctly eat semicolon at the end of `DelcareModuleExports` ([#223](https://github.com/babel/babylon/pull/223)) (Daniel Tschinder) + +``` +declare module "foo" { declare module.exports: number } +declare module "foo" { declare module.exports: number; } // also allowed now +``` + +### :house: Internal + + * Count Babel tests towards Babylon code coverage ([#182](https://github.com/babel/babylon/pull/182)) (Moti Zilberman) + * Fix strange line endings ([#214](https://github.com/babel/babylon/pull/214)) (Thomas Grainger) + * Add node 7 (Daniel Tschinder) + * chore(package): update flow-bin to version 0.34.0 ([#204](https://github.com/babel/babylon/pull/204)) (Greenkeeper) + +## v6.13.1 (2016-10-26) + +### :nail_care: Polish + +- Use rollup for bundling to speed up startup time ([#190](https://github.com/babel/babylon/pull/190)) ([@drewml](https://github.com/DrewML)) + +```js +const babylon = require('babylon'); +const ast = babylon.parse('var foo = "lol";'); +``` + +With that test case, there was a ~95ms savings by removing the need for node to build/traverse the dependency graph. + +**Without bundling** +![image](https://cloud.githubusercontent.com/assets/5233399/19420264/3133497e-93ad-11e6-9a6a-2da59c4f5c13.png) + +**With bundling** +![image](https://cloud.githubusercontent.com/assets/5233399/19420267/388f556e-93ad-11e6-813e-7c5c396be322.png) + +- add clean command [skip ci] ([#201](https://github.com/babel/babylon/pull/201)) (Henry Zhu) +- add ForAwaitStatement (async generator already added) [skip ci] ([#196](https://github.com/babel/babylon/pull/196)) (Henry Zhu) + +## v6.13.0 (2016-10-21) + +### :eyeglasses: Spec Compliance + +Property variance type annotations for Flow plugin ([#161](https://github.com/babel/babylon/pull/161)) (Sam Goldman) + +> See https://flowtype.org/docs/variance.html for more information + +```js +type T = { +p: T }; +interface T { -p: T }; +declare class T { +[k:K]: V }; +class T { -[k:K]: V }; +class C2 { +p: T = e }; +``` + +Raise error on duplicate definition of __proto__ ([#183](https://github.com/babel/babylon/pull/183)) (Moti Zilberman) + +```js +({ __proto__: 1, __proto__: 2 }) // Throws an error now +``` + +### :bug: Bug Fix + +Flow: Allow class properties to be named `static` ([#184](https://github.com/babel/babylon/pull/184)) (Moti Zilberman) + +```js +declare class A { + static: T; +} +``` + +Allow "async" as identifier for object literal property shorthand ([#187](https://github.com/babel/babylon/pull/187)) (Andrew Levine) + +```js +var foo = { async, bar }; +``` + +### :nail_care: Polish + +Fix flowtype and add inType to state ([#189](https://github.com/babel/babylon/pull/189)) (Daniel Tschinder) + +> This improves the performance slightly (because of hidden classes) + +### :house: Internal + +Fix .gitattributes line ending setting ([#191](https://github.com/babel/babylon/pull/191)) (Moti Zilberman) + +Increase test coverage ([#175](https://github.com/babel/babylon/pull/175) (Moti Zilberman) + +Readd missin .eslinignore for IDEs (Daniel Tschinder) + +Error on missing expected.json fixture in CI ([#188](https://github.com/babel/babylon/pull/188)) (Moti Zilberman) + +Add .gitattributes and .editorconfig for LF line endings ([#179](https://github.com/babel/babylon/pull/179)) (Moti Zilberman) + +Fixes two tests that are failing after the merge of #172 ([#177](https://github.com/babel/babylon/pull/177)) (Moti Zilberman) + +## v6.12.0 (2016-10-14) + +### :eyeglasses: Spec Compliance + +Implement import() syntax ([#163](https://github.com/babel/babylon/pull/163)) (Jordan Gensler) + +#### Dynamic Import + +- Proposal Repo: https://github.com/domenic/proposal-dynamic-import +- Championed by [@domenic](https://github.com/domenic) +- stage-2 +- [sept-28 tc39 notes](https://github.com/rwaldron/tc39-notes/blob/master/es7/2016-09/sept-28.md#113a-import) + +> This repository contains a proposal for adding a "function-like" import() module loading syntactic form to JavaScript + +```js +import(`./section-modules/${link.dataset.entryModule}.js`) +.then(module => { + module.loadPageInto(main); +}) +``` + +Add EmptyTypeAnnotation ([#171](https://github.com/babel/babylon/pull/171)) (Sam Goldman) + +#### EmptyTypeAnnotation + +Just wasn't covered before. + +```js +type T = empty; +``` + +### :bug: Bug Fix + +Fix crash when exporting with destructuring and sparse array ([#170](https://github.com/babel/babylon/pull/170)) (Jeroen Engels) + +```js +// was failing due to sparse array +export const { foo: [ ,, qux7 ] } = bar; +``` + +Allow keyword in Flow object declaration property names with type parameters ([#146](https://github.com/babel/babylon/pull/146)) (Dan Harper) + +```js +declare class X { + foobar(): void; + static foobar(): void; +} +``` + +Allow keyword in object/class property names with Flow type parameters ([#145](https://github.com/babel/babylon/pull/145)) (Dan Harper) + +```js +class Foo { + delete(item: T): T { + return item; + } +} +``` + +Allow typeAnnotations for yield expressions ([#174](https://github.com/babel/babylon/pull/174))) (Daniel Tschinder) + +```js +function *foo() { + const x = (yield 5: any); +} +``` + +### :nail_care: Polish + +Annotate more errors with expected token ([#172](https://github.com/babel/babylon/pull/172))) (Moti Zilberman) + +```js +// Unexpected token, expected ; (1:6) +{ set 1 } +``` + +### :house: Internal + +Remove kcheck ([#173](https://github.com/babel/babylon/pull/173))) (Daniel Tschinder) + +Also run flow, linting, babel tests on separate instances (add back node 0.10) + +## v6.11.6 (2016-10-12) + +### :bug: Bug Fix/Regression + +Fix crash when exporting with destructuring and sparse array ([#170](https://github.com/babel/babylon/pull/170)) (Jeroen Engels) + +```js +// was failing with `Cannot read property 'type' of null` because of null identifiers +export const { foo: [ ,, qux7 ] } = bar; +``` + +## v6.11.5 (2016-10-12) + +### :eyeglasses: Spec Compliance + +Fix: Check for duplicate named exports in exported destructuring assignments ([#144](https://github.com/babel/babylon/pull/144)) (Kai Cataldo) + +```js +// `foo` has already been exported. Exported identifiers must be unique. (2:20) +export function foo() {}; +export const { a: [{foo}] } = bar; +``` + +Fix: Check for duplicate named exports in exported rest elements/properties ([#164](https://github.com/babel/babylon/pull/164)) (Kai Cataldo) + +```js +// `foo` has already been exported. Exported identifiers must be unique. (2:22) +export const foo = 1; +export const [bar, ...foo] = baz; +``` + +### :bug: Bug Fix + +Fix: Allow identifier `async` for default param in arrow expression ([#165](https://github.com/babel/babylon/pull/165)) (Kai Cataldo) + +```js +// this is ok now +const test = ({async = true}) => {}; +``` + +### :nail_care: Polish + +Babylon will now print out the token it's expecting if there's a `SyntaxError` ([#150](https://github.com/babel/babylon/pull/150)) (Daniel Tschinder) + +```bash +# So in the case of a missing ending curly (`}`) +Module build failed: SyntaxError: Unexpected token, expected } (30:0) + 28 | } + 29 | +> 30 | + | ^ +``` + +## v6.11.4 (2016-10-03) + +Temporary rollback for erroring on trailing comma with spread (#154) (Henry Zhu) + +## v6.11.3 (2016-10-01) + +### :eyeglasses: Spec Compliance + +Add static errors for object rest (#149) ([@danez](https://github.com/danez)) + +> https://github.com/sebmarkbage/ecmascript-rest-spread + +Object rest copies the *rest* of properties from the right hand side `obj` starting from the left to right. + +```js +let { x, y, ...z } = { x: 1, y: 2, z: 3 }; +// x = 1 +// y = 2 +// z = { z: 3 } +``` + +#### New Syntax Errors: + +**SyntaxError**: The rest element has to be the last element when destructuring (1:10) +```bash +> 1 | let { ...x, y, z } = { x: 1, y: 2, z: 3}; + | ^ +# Previous behavior: +# x = { x: 1, y: 2, z: 3 } +# y = 2 +# z = 3 +``` + +Before, this was just a more verbose way of shallow copying `obj` since it doesn't actually do what you think. + +**SyntaxError**: Cannot have multiple rest elements when destructuring (1:13) + +```bash +> 1 | let { x, ...y, ...z } = { x: 1, y: 2, z: 3}; + | ^ +# Previous behavior: +# x = 1 +# y = { y: 2, z: 3 } +# z = { y: 2, z: 3 } +``` + +Before y and z would just be the same value anyway so there is no reason to need to have both. + +**SyntaxError**: A trailing comma is not permitted after the rest element (1:16) + +```js +let { x, y, ...z, } = obj; +``` + +The rationale for this is that the use case for trailing comma is that you can add something at the end without affecting the line above. Since a RestProperty always has to be the last property it doesn't make sense. + +--- + +get / set are valid property names in default assignment (#142) ([@jezell](https://github.com/jezell)) + +```js +// valid +function something({ set = null, get = null }) {} +``` + +## v6.11.2 (2016-09-23) + +### Bug Fix + +- [#139](https://github.com/babel/babylon/issues/139) Don't do the duplicate check if not an identifier (#140) @hzoo + +```js +// regression with duplicate export check +SyntaxError: ./typography.js: `undefined` has already been exported. Exported identifiers must be unique. (22:13) + 20 | + 21 | export const { rhythm } = typography; +> 22 | export const { TypographyStyle } = typography +``` + +Bail out for now, and make a change to account for destructuring in the next release. + +## 6.11.1 (2016-09-22) + +### Bug Fix +- [#137](https://github.com/babel/babylon/pull/137) - Fix a regression with duplicate exports - it was erroring on all keys in `Object.prototype`. @danez + +```javascript +export toString from './toString'; +``` + +```bash +`toString` has already been exported. Exported identifiers must be unique. (1:7) +> 1 | export toString from './toString'; + | ^ + 2 | +``` + +## 6.11.0 (2016-09-22) + +### Spec Compliance (will break CI) + +- Disallow duplicate named exports ([#107](https://github.com/babel/babylon/pull/107)) @kaicataldo + +```js +// Only one default export allowed per module. (2:9) +export default function() {}; +export { foo as default }; + +// Only one default export allowed per module. (2:0) +export default {}; +export default function() {}; + +// `Foo` has already been exported. Exported identifiers must be unique. (2:0) +export { Foo }; +export class Foo {}; +``` + +### New Feature (Syntax) + +- Add support for computed class property names ([#121](https://github.com/babel/babylon/pull/121)) @motiz88 + +```js +// AST +interface ClassProperty <: Node { + type: "ClassProperty"; + key: Identifier; + value: Expression; + computed: boolean; // added +} +``` + +```js +// with "plugins": ["classProperties"] +class Foo { + [x] + ['y'] +} + +class Bar { + [p] + [m] () {} +} + ``` + +### Bug Fix + +- Fix `static` property falling through in the declare class Flow AST ([#135](https://github.com/babel/babylon/pull/135)) @danharper + +```js +declare class X { + a: number; + static b: number; // static + c: number; // this was being marked as static in the AST as well +} +``` + +### Polish + +- Rephrase "assigning/binding to rvalue" errors to include context ([#119](https://github.com/babel/babylon/pull/119)) @motiz88 + +```js +// Used to error with: +// SyntaxError: Assigning to rvalue (1:0) + +// Now: +// Invalid left-hand side in assignment expression (1:0) +3 = 4 + +// Invalid left-hand side in for-in statement (1:5) +for (+i in {}); +``` + +### Internal + +- Fix call to `this.parseMaybeAssign` with correct arguments ([#133](https://github.com/babel/babylon/pull/133)) @danez +- Add semver note to changelog ([#131](https://github.com/babel/babylon/pull/131)) @hzoo + +## 6.10.0 (2016-09-19) + +> We plan to include some spec compliance bugs in patch versions. An example was the multiple default exports issue. + +### Spec Compliance + +* Implement ES2016 check for simple parameter list in strict mode ([#106](https://github.com/babel/babylon/pull/106)) (Timothy Gu) + +> It is a Syntax Error if ContainsUseStrict of FunctionBody is true and IsSimpleParameterList of FormalParameters is false. https://tc39.github.io/ecma262/2016/#sec-function-definitions-static-semantics-early-errors + +More Context: [tc39-notes](https://github.com/rwaldron/tc39-notes/blob/master/es7/2015-07/july-29.md#611-the-scope-of-use-strict-with-respect-to-destructuring-in-parameter-lists) + +For example: + +```js +// this errors because it uses destructuring and default parameters +// in a function with a "use strict" directive +function a([ option1, option2 ] = []) { + "use strict"; +} + ``` + +The solution would be to use a top level "use strict" or to remove the destructuring or default parameters when using a function + "use strict" or to. + +### New Feature + +* Exact object type annotations for Flow plugin ([#104](https://github.com/babel/babylon/pull/104)) (Basil Hosmer) + +Added to flow in https://github.com/facebook/flow/commit/c710c40aa2a115435098d6c0dfeaadb023cd39b8 + +Looks like: + +```js +var a : {| x: number, y: string |} = { x: 0, y: 'foo' }; +``` + +### Bug Fixes + +* Include `typeParameter` location in `ArrowFunctionExpression` ([#126](https://github.com/babel/babylon/pull/126)) (Daniel Tschinder) +* Error on invalid flow type annotation with default assignment ([#122](https://github.com/babel/babylon/pull/122)) (Dan Harper) +* Fix Flow return types on arrow functions ([#124](https://github.com/babel/babylon/pull/124)) (Dan Harper) + +### Misc + +* Add tests for export extensions ([#127](https://github.com/babel/babylon/pull/127)) (Daniel Tschinder) +* Fix Contributing guidelines [skip ci] (Daniel Tschinder) + +## 6.9.2 (2016-09-09) + +The only change is to remove the `babel-runtime` dependency by compiling with Babel's ES2015 loose mode. So using babylon standalone should be smaller. + +## 6.9.1 (2016-08-23) + +This release contains mainly small bugfixes but also updates babylons default mode to es2017. The features for `exponentiationOperator`, `asyncFunctions` and `trailingFunctionCommas` which previously needed to be activated via plugin are now enabled by default and the plugins are now no-ops. + +### Bug Fixes + +- Fix issues with default object params in async functions ([#96](https://github.com/babel/babylon/pull/96)) @danez +- Fix issues with flow-types and async function ([#95](https://github.com/babel/babylon/pull/95)) @danez +- Fix arrow functions with destructuring, types & default value ([#94](https://github.com/babel/babylon/pull/94)) @danharper +- Fix declare class with qualified type identifier ([#97](https://github.com/babel/babylon/pull/97)) @danez +- Remove exponentiationOperator, asyncFunctions, trailingFunctionCommas plugins and enable them by default ([#98](https://github.com/babel/babylon/pull/98)) @danez + +## 6.9.0 (2016-08-16) + +### New syntax support + +- Add JSX spread children ([#42](https://github.com/babel/babylon/pull/42)) @calebmer + +(Be aware that React is not going to support this syntax) + +```js +
+ {...todos.map(todo => )} +
+``` + +- Add support for declare module.exports ([#72](https://github.com/babel/babylon/pull/72)) @danez + +```js +declare module "foo" { + declare module.exports: {} +} +``` + +### New Features + +- If supplied, attach filename property to comment node loc. ([#80](https://github.com/babel/babylon/pull/80)) @divmain +- Add identifier name to node loc field ([#90](https://github.com/babel/babylon/pull/90)) @kittens + +### Bug Fixes + +- Fix exponential operator to behave according to spec ([#75](https://github.com/babel/babylon/pull/75)) @danez +- Fix lookahead to not add comments to arrays which are not cloned ([#76](https://github.com/babel/babylon/pull/76)) @danez +- Fix accidental fall-through in Flow type parsing. ([#82](https://github.com/babel/babylon/pull/82)) @xiemaisi +- Only allow declares inside declare module ([#73](https://github.com/babel/babylon/pull/73)) @danez +- Small fix for parsing type parameter declarations ([#83](https://github.com/babel/babylon/pull/83)) @gabelevi +- Fix arrow param locations with flow types ([#57](https://github.com/babel/babylon/pull/57)) @danez +- Fixes SyntaxError position with flow optional type ([#65](https://github.com/babel/babylon/pull/65)) @danez + +### Internal + +- Add codecoverage to tests @danez +- Fix tests to not save expected output if we expect the test to fail @danez +- Make a shallow clone of babel for testing @danez +- chore(package): update cross-env to version 2.0.0 ([#77](https://github.com/babel/babylon/pull/77)) @greenkeeperio-bot +- chore(package): update ava to version 0.16.0 ([#86](https://github.com/babel/babylon/pull/86)) @greenkeeperio-bot +- chore(package): update babel-plugin-istanbul to version 2.0.0 ([#89](https://github.com/babel/babylon/pull/89)) @greenkeeperio-bot +- chore(package): update nyc to version 8.0.0 ([#88](https://github.com/babel/babylon/pull/88)) @greenkeeperio-bot + +## 6.8.4 (2016-07-06) + +### Bug Fixes + +- Fix the location of params, when flow and default value used ([#68](https://github.com/babel/babylon/pull/68)) @danez + +## 6.8.3 (2016-07-02) + +### Bug Fixes + +- Fix performance regression introduced in 6.8.2 with conditionals ([#63](https://github.com/babel/babylon/pull/63)) @danez + +## 6.8.2 (2016-06-24) + +### Bug Fixes + +- Fix parse error with yielding jsx elements in generators `function* it() { yield ; }` ([#31](https://github.com/babel/babylon/pull/31)) @eldereal +- When cloning nodes do not clone its comments ([#24](https://github.com/babel/babylon/pull/24)) @danez +- Fix parse errors when using arrow functions with an spread element and return type `(...props): void => {}` ([#10](https://github.com/babel/babylon/pull/10)) @danez +- Fix leading comments added from previous node ([#23](https://github.com/babel/babylon/pull/23)) @danez +- Fix parse errors with flow's optional arguments `(arg?) => {}` ([#19](https://github.com/babel/babylon/pull/19)) @danez +- Support negative numeric type literals @kittens +- Remove line terminator restriction after await keyword @kittens +- Remove grouped type arrow restriction as it seems flow no longer has it @kittens +- Fix parse error with generic methods that have the name `get` or `set` `class foo { get() {} }` ([#55](https://github.com/babel/babylon/pull/55)) @vkurchatkin +- Fix parse error with arrow functions that have flow type parameter declarations `(x: T): T => x;` ([#54](https://github.com/babel/babylon/pull/54)) @gabelevi + +### Documentation + +- Document AST differences from ESTree ([#41](https://github.com/babel/babylon/pull/41)) @nene +- Move ast spec from babel/babel ([#46](https://github.com/babel/babylon/pull/46)) @hzoo + +### Internal + +- Enable skipped tests ([#16](https://github.com/babel/babylon/pull/16)) @danez +- Add script to test latest version of babylon with babel ([#21](https://github.com/babel/babylon/pull/21)) @danez +- Upgrade test runner ava @kittens +- Add missing generate-identifier-regex script @kittens +- Rename parser context types @kittens +- Add node v6 to travis testing @hzoo +- Update to Unicode v9 ([#45](https://github.com/babel/babylon/pull/45)) @mathiasbynens + +## 6.8.1 (2016-06-06) + +### New Feature + +- Parse type parameter declarations with defaults like `type Foo = T` + +### Bug Fixes +- Type parameter declarations need 1 or more type parameters. +- The existential type `*` is not a valid type parameter. +- The existential type `*` is a primary type + +### Spec Compliance +- The param list for type parameter declarations now consists of `TypeParameter` nodes +- New `TypeParameter` AST Node (replaces using the `Identifier` node before) + +``` +interface TypeParameter <: Node { + bound: TypeAnnotation; + default: TypeAnnotation; + name: string; + variance: "plus" | "minus"; +} +``` + +## 6.8.0 (2016-05-02) + +#### New Feature + +##### Parse Method Parameter Decorators ([#12](https://github.com/babel/babylon/pull/12)) + +> [Method Parameter Decorators](https://goo.gl/8MmCMG) is now a TC39 [stage 0 proposal](https://github.com/tc39/ecma262/blob/master/stage0.md). + +Examples: + +```js +class Foo { + constructor(@foo() x, @bar({ a: 123 }) @baz() y) {} +} + +export default function func(@foo() x, @bar({ a: 123 }) @baz() y) {} + +var obj = { + method(@foo() x, @bar({ a: 123 }) @baz() y) {} +}; +``` + +##### Parse for-await statements (w/ `asyncGenerators` plugin) ([#17](https://github.com/babel/babylon/pull/17)) + +There is also a new node type, `ForAwaitStatement`. + +> [Async generators and for-await](https://github.com/tc39/proposal-async-iteration) are now a [stage 2 proposal](https://github.com/tc39/ecma262#current-proposals). + +Example: + +```js +async function f() { + for await (let x of y); +} +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/parser/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/parser/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..d4c7fc583804df4b030668031e21435eb2ba4910 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/parser/LICENSE @@ -0,0 +1,19 @@ +Copyright (C) 2012-2014 by various contributors (see AUTHORS) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/parser/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/parser/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a9463e813b4b62c84bc5272938b044f17194f047 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/parser/README.md @@ -0,0 +1,19 @@ +# @babel/parser + +> A JavaScript parser + +See our website [@babel/parser](https://babeljs.io/docs/babel-parser) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20parser%22+is%3Aopen) associated with this package. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/parser +``` + +or using yarn: + +```sh +yarn add @babel/parser --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/parser/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/parser/package.json new file mode 100644 index 0000000000000000000000000000000000000000..b4a288dfa1573644755a4b9516b271941dccf789 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/parser/package.json @@ -0,0 +1,50 @@ +{ + "name": "@babel/parser", + "version": "7.28.3", + "description": "A JavaScript parser", + "author": "The Babel Team (https://babel.dev/team)", + "homepage": "https://babel.dev/docs/en/next/babel-parser", + "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A+parser+%28babylon%29%22+is%3Aopen", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "keywords": [ + "babel", + "javascript", + "parser", + "tc39", + "ecmascript", + "@babel/parser" + ], + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-parser" + }, + "main": "./lib/index.js", + "types": "./typings/babel-parser.d.ts", + "files": [ + "bin", + "lib", + "typings/babel-parser.d.ts", + "index.cjs" + ], + "engines": { + "node": ">=6.0.0" + }, + "# dependencies": "This package doesn't actually have runtime dependencies. @babel/types is only needed for type definitions.", + "dependencies": { + "@babel/types": "^7.28.2" + }, + "devDependencies": { + "@babel/code-frame": "^7.27.1", + "@babel/helper-check-duplicate-nodes": "^7.27.1", + "@babel/helper-fixtures": "^7.28.0", + "@babel/helper-string-parser": "^7.27.1", + "@babel/helper-validator-identifier": "^7.27.1", + "charcodes": "^0.2.0" + }, + "bin": "./bin/babel-parser.js", + "type": "commonjs" +} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-async-generators/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-async-generators/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-async-generators/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-async-generators/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-async-generators/README.md new file mode 100644 index 0000000000000000000000000000000000000000..4fdb68df562d5dfd3ee37259c13048899c4a59e6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-async-generators/README.md @@ -0,0 +1,19 @@ +# @babel/plugin-syntax-async-generators + +> Allow parsing of async generator functions + +See our website [@babel/plugin-syntax-async-generators](https://babeljs.io/docs/en/next/babel-plugin-syntax-async-generators.html) for more information. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/plugin-syntax-async-generators +``` + +or using yarn: + +```sh +yarn add @babel/plugin-syntax-async-generators --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-async-generators/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-async-generators/package.json new file mode 100644 index 0000000000000000000000000000000000000000..5d9d9de6d21aaac74fa8e1d17d603cd9cabc0797 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-async-generators/package.json @@ -0,0 +1,23 @@ +{ + "name": "@babel/plugin-syntax-async-generators", + "version": "7.8.4", + "description": "Allow parsing of async generator functions", + "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-syntax-async-generators", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "main": "lib/index.js", + "keywords": [ + "babel-plugin" + ], + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + }, + "devDependencies": { + "@babel/core": "^7.8.0" + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-bigint/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-bigint/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-bigint/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-bigint/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-bigint/README.md new file mode 100644 index 0000000000000000000000000000000000000000..bb49aab8ee341aa8886c11e7685f2ba255b508a7 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-bigint/README.md @@ -0,0 +1,19 @@ +# @babel/plugin-syntax-bigint + +> Allow parsing of BigInt literals + +See our website [@babel/plugin-syntax-bigint](https://babeljs.io/docs/en/next/babel-plugin-syntax-bigint.html) for more information. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/plugin-syntax-bigint +``` + +or using yarn: + +```sh +yarn add @babel/plugin-syntax-bigint --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-bigint/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-bigint/package.json new file mode 100644 index 0000000000000000000000000000000000000000..9a18bcd81f55a5cd7a761d25f4aff7a15cc08060 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-bigint/package.json @@ -0,0 +1,23 @@ +{ + "name": "@babel/plugin-syntax-bigint", + "version": "7.8.3", + "description": "Allow parsing of BigInt literals", + "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-syntax-bigint", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "main": "lib/index.js", + "keywords": [ + "babel-plugin" + ], + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + }, + "devDependencies": { + "@babel/core": "^7.8.0" + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-class-properties/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-class-properties/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-class-properties/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-class-properties/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-class-properties/README.md new file mode 100644 index 0000000000000000000000000000000000000000..be6d11c3ad8c7e13450940138539ba3c46a504ed --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-class-properties/README.md @@ -0,0 +1,19 @@ +# @babel/plugin-syntax-class-properties + +> Allow parsing of class properties + +See our website [@babel/plugin-syntax-class-properties](https://babeljs.io/docs/en/babel-plugin-syntax-class-properties) for more information. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/plugin-syntax-class-properties +``` + +or using yarn: + +```sh +yarn add @babel/plugin-syntax-class-properties --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-class-properties/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-class-properties/package.json new file mode 100644 index 0000000000000000000000000000000000000000..cf443bab5cb8715d1e2e262bb3e62176510c75f8 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-class-properties/package.json @@ -0,0 +1,28 @@ +{ + "name": "@babel/plugin-syntax-class-properties", + "version": "7.12.13", + "description": "Allow parsing of class properties", + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-plugin-syntax-class-properties" + }, + "homepage": "https://babel.dev/docs/en/next/babel-plugin-syntax-class-properties", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "main": "lib/index.js", + "keywords": [ + "babel-plugin" + ], + "dependencies": { + "@babel/helper-plugin-utils": "^7.12.13" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + }, + "devDependencies": { + "@babel/core": "7.12.13" + } +} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-class-static-block/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-class-static-block/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-class-static-block/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-class-static-block/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-class-static-block/README.md new file mode 100644 index 0000000000000000000000000000000000000000..8dd2f6b32cb2c6f5dc29cfcad792d6506c6bbf74 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-class-static-block/README.md @@ -0,0 +1,19 @@ +# @babel/plugin-syntax-class-static-block + +> Allow parsing of class static blocks + +See our website [@babel/plugin-syntax-class-static-block](https://babeljs.io/docs/en/babel-plugin-syntax-class-static-block) for more information. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/plugin-syntax-class-static-block +``` + +or using yarn: + +```sh +yarn add @babel/plugin-syntax-class-static-block --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-class-static-block/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-class-static-block/package.json new file mode 100644 index 0000000000000000000000000000000000000000..13553eb04f631b9bab96c7fed2792ca812b645b2 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-class-static-block/package.json @@ -0,0 +1,32 @@ +{ + "name": "@babel/plugin-syntax-class-static-block", + "version": "7.14.5", + "description": "Allow parsing of class static blocks", + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-plugin-syntax-class-static-block" + }, + "homepage": "https://babel.dev/docs/en/next/babel-plugin-syntax-class-static-block", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "main": "./lib/index.js", + "exports": { + ".": "./lib/index.js" + }, + "keywords": [ + "babel-plugin" + ], + "dependencies": { + "@babel/helper-plugin-utils": "^7.14.5" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + }, + "engines": { + "node": ">=6.9.0" + }, + "author": "The Babel Team (https://babel.dev/team)" +} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-import-attributes/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-import-attributes/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-import-attributes/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-import-attributes/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-import-attributes/README.md new file mode 100644 index 0000000000000000000000000000000000000000..91f56a02f336978f44bd89b0b82e2fc8c2bc80bc --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-import-attributes/README.md @@ -0,0 +1,19 @@ +# @babel/plugin-syntax-import-attributes + +> Allow parsing of the module attributes in the import statement + +See our website [@babel/plugin-syntax-import-attributes](https://babeljs.io/docs/babel-plugin-syntax-import-attributes) for more information. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/plugin-syntax-import-attributes +``` + +or using yarn: + +```sh +yarn add @babel/plugin-syntax-import-attributes --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-import-attributes/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-import-attributes/package.json new file mode 100644 index 0000000000000000000000000000000000000000..128e87a15d18d97c51da9b95ddc0e29090a68ff7 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-import-attributes/package.json @@ -0,0 +1,40 @@ +{ + "name": "@babel/plugin-syntax-import-attributes", + "version": "7.27.1", + "description": "Allow parsing of the module attributes in the import statement", + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-plugin-syntax-import-attributes" + }, + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "main": "./lib/index.js", + "keywords": [ + "babel-plugin" + ], + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + }, + "devDependencies": { + "@babel/core": "^7.27.1", + "@babel/helper-plugin-test-runner": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "author": "The Babel Team (https://babel.dev/team)", + "exports": { + ".": { + "types": "./lib/index.d.ts", + "default": "./lib/index.js" + }, + "./package.json": "./package.json" + }, + "type": "commonjs" +} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-import-meta/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-import-meta/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-import-meta/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-import-meta/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-import-meta/README.md new file mode 100644 index 0000000000000000000000000000000000000000..dc39f7ca07856eeb6d305a8c1c92782e19d9c01a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-import-meta/README.md @@ -0,0 +1,19 @@ +# @babel/plugin-syntax-import-meta + +> Allow parsing of import.meta + +See our website [@babel/plugin-syntax-import-meta](https://babeljs.io/docs/en/next/babel-plugin-syntax-import-meta.html) for more information. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/plugin-syntax-import-meta +``` + +or using yarn: + +```sh +yarn add @babel/plugin-syntax-import-meta --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-import-meta/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-import-meta/package.json new file mode 100644 index 0000000000000000000000000000000000000000..de09665938e44df83818333c1d4381186546a225 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-import-meta/package.json @@ -0,0 +1,28 @@ +{ + "name": "@babel/plugin-syntax-import-meta", + "version": "7.10.4", + "description": "Allow parsing of import.meta", + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-plugin-syntax-import-meta" + }, + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "main": "lib/index.js", + "keywords": [ + "babel-plugin" + ], + "dependencies": { + "@babel/helper-plugin-utils": "^7.10.4" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + }, + "devDependencies": { + "@babel/core": "^7.10.4" + }, + "gitHead": "7fd40d86a0d03ff0e9c3ea16b29689945433d4df" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-json-strings/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-json-strings/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-json-strings/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-json-strings/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-json-strings/README.md new file mode 100644 index 0000000000000000000000000000000000000000..03c00a2d176441f8e9f9dcb23183c747649fc092 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-json-strings/README.md @@ -0,0 +1,19 @@ +# @babel/plugin-syntax-json-strings + +> Allow parsing of the U+2028 LINE SEPARATOR and U+2029 PARAGRAPH SEPARATOR in JS strings + +See our website [@babel/plugin-syntax-json-strings](https://babeljs.io/docs/en/next/babel-plugin-syntax-json-strings.html) for more information. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/plugin-syntax-json-strings +``` + +or using yarn: + +```sh +yarn add @babel/plugin-syntax-json-strings --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-json-strings/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-json-strings/package.json new file mode 100644 index 0000000000000000000000000000000000000000..e41c6464b340e5ea10d296ab296fa43954ae16c5 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-json-strings/package.json @@ -0,0 +1,23 @@ +{ + "name": "@babel/plugin-syntax-json-strings", + "version": "7.8.3", + "description": "Allow parsing of the U+2028 LINE SEPARATOR and U+2029 PARAGRAPH SEPARATOR in JS strings", + "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-syntax-json-strings", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "main": "lib/index.js", + "keywords": [ + "babel-plugin" + ], + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + }, + "devDependencies": { + "@babel/core": "^7.8.0" + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-jsx/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-jsx/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-jsx/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-jsx/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-jsx/README.md new file mode 100644 index 0000000000000000000000000000000000000000..4f001dc57802013d6522d9840c09ee6b0d357ebe --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-jsx/README.md @@ -0,0 +1,19 @@ +# @babel/plugin-syntax-jsx + +> Allow parsing of jsx + +See our website [@babel/plugin-syntax-jsx](https://babeljs.io/docs/babel-plugin-syntax-jsx) for more information. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/plugin-syntax-jsx +``` + +or using yarn: + +```sh +yarn add @babel/plugin-syntax-jsx --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-jsx/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-jsx/package.json new file mode 100644 index 0000000000000000000000000000000000000000..3f45cdf46dedb8c225e6b26b417da436615a1a53 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-jsx/package.json @@ -0,0 +1,33 @@ +{ + "name": "@babel/plugin-syntax-jsx", + "version": "7.27.1", + "description": "Allow parsing of jsx", + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-plugin-syntax-jsx" + }, + "homepage": "https://babel.dev/docs/en/next/babel-plugin-syntax-jsx", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "main": "./lib/index.js", + "keywords": [ + "babel-plugin" + ], + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + }, + "devDependencies": { + "@babel/core": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "author": "The Babel Team (https://babel.dev/team)", + "type": "commonjs" +} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-logical-assignment-operators/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-logical-assignment-operators/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-logical-assignment-operators/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-logical-assignment-operators/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-logical-assignment-operators/README.md new file mode 100644 index 0000000000000000000000000000000000000000..02fa394eb4a4eb869567e4fea63d4c975c566962 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-logical-assignment-operators/README.md @@ -0,0 +1,19 @@ +# @babel/plugin-syntax-logical-assignment-operators + +> Allow parsing of the logical assignment operators + +See our website [@babel/plugin-syntax-logical-assignment-operators](https://babeljs.io/docs/en/next/babel-plugin-syntax-logical-assignment-operators.html) for more information. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/plugin-syntax-logical-assignment-operators +``` + +or using yarn: + +```sh +yarn add @babel/plugin-syntax-logical-assignment-operators --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-logical-assignment-operators/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-logical-assignment-operators/package.json new file mode 100644 index 0000000000000000000000000000000000000000..cce0541b33fb8d363e4cb2005f52dbe0793ee780 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-logical-assignment-operators/package.json @@ -0,0 +1,28 @@ +{ + "name": "@babel/plugin-syntax-logical-assignment-operators", + "version": "7.10.4", + "description": "Allow parsing of the logical assignment operators", + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-plugin-syntax-logical-assignment-operators" + }, + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "main": "lib/index.js", + "keywords": [ + "babel-plugin" + ], + "dependencies": { + "@babel/helper-plugin-utils": "^7.10.4" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + }, + "devDependencies": { + "@babel/core": "^7.10.4" + }, + "gitHead": "7fd40d86a0d03ff0e9c3ea16b29689945433d4df" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-nullish-coalescing-operator/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-nullish-coalescing-operator/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-nullish-coalescing-operator/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-nullish-coalescing-operator/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-nullish-coalescing-operator/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f91e8117f78564f30e81af862cf3fb77057e70c7 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-nullish-coalescing-operator/README.md @@ -0,0 +1,19 @@ +# @babel/plugin-syntax-nullish-coalescing-operator + +> Allow parsing of the nullish-coalescing operator + +See our website [@babel/plugin-syntax-nullish-coalescing-operator](https://babeljs.io/docs/en/next/babel-plugin-syntax-nullish-coalescing-operator.html) for more information. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/plugin-syntax-nullish-coalescing-operator +``` + +or using yarn: + +```sh +yarn add @babel/plugin-syntax-nullish-coalescing-operator --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-nullish-coalescing-operator/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-nullish-coalescing-operator/package.json new file mode 100644 index 0000000000000000000000000000000000000000..983e6556df7dec77aa45e46dbd714ad0853b22ae --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-nullish-coalescing-operator/package.json @@ -0,0 +1,23 @@ +{ + "name": "@babel/plugin-syntax-nullish-coalescing-operator", + "version": "7.8.3", + "description": "Allow parsing of the nullish-coalescing operator", + "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-syntax-nullish-coalescing-operator", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "main": "lib/index.js", + "keywords": [ + "babel-plugin" + ], + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + }, + "devDependencies": { + "@babel/core": "^7.8.0" + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-numeric-separator/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-numeric-separator/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-numeric-separator/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-numeric-separator/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-numeric-separator/README.md new file mode 100644 index 0000000000000000000000000000000000000000..07856b86ab03e9d997e77d222aecd7bc300d2b7a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-numeric-separator/README.md @@ -0,0 +1,19 @@ +# @babel/plugin-syntax-numeric-separator + +> Allow parsing of Decimal, Binary, Hex and Octal literals that contain a Numeric Literal Separator + +See our website [@babel/plugin-syntax-numeric-separator](https://babeljs.io/docs/en/next/babel-plugin-syntax-numeric-separator.html) for more information. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/plugin-syntax-numeric-separator +``` + +or using yarn: + +```sh +yarn add @babel/plugin-syntax-numeric-separator --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-numeric-separator/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-numeric-separator/package.json new file mode 100644 index 0000000000000000000000000000000000000000..6dc4d9668372c437ce1444951067d7be8e34d010 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-numeric-separator/package.json @@ -0,0 +1,28 @@ +{ + "name": "@babel/plugin-syntax-numeric-separator", + "version": "7.10.4", + "description": "Allow parsing of Decimal, Binary, Hex and Octal literals that contain a Numeric Literal Separator", + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-plugin-syntax-numeric-separator" + }, + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "main": "lib/index.js", + "keywords": [ + "babel-plugin" + ], + "dependencies": { + "@babel/helper-plugin-utils": "^7.10.4" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + }, + "devDependencies": { + "@babel/core": "^7.10.4" + }, + "gitHead": "7fd40d86a0d03ff0e9c3ea16b29689945433d4df" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-object-rest-spread/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-object-rest-spread/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-object-rest-spread/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-object-rest-spread/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-object-rest-spread/README.md new file mode 100644 index 0000000000000000000000000000000000000000..95c4472ebe68e1a4278e5d8ee03e8d413a281407 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-object-rest-spread/README.md @@ -0,0 +1,19 @@ +# @babel/plugin-syntax-object-rest-spread + +> Allow parsing of object rest/spread + +See our website [@babel/plugin-syntax-object-rest-spread](https://babeljs.io/docs/en/next/babel-plugin-syntax-object-rest-spread.html) for more information. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/plugin-syntax-object-rest-spread +``` + +or using yarn: + +```sh +yarn add @babel/plugin-syntax-object-rest-spread --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-object-rest-spread/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-object-rest-spread/package.json new file mode 100644 index 0000000000000000000000000000000000000000..66b76d3a7a805394780928737b6c2745439da3ff --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-object-rest-spread/package.json @@ -0,0 +1,23 @@ +{ + "name": "@babel/plugin-syntax-object-rest-spread", + "version": "7.8.3", + "description": "Allow parsing of object rest/spread", + "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-syntax-object-rest-spread", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "main": "lib/index.js", + "keywords": [ + "babel-plugin" + ], + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + }, + "devDependencies": { + "@babel/core": "^7.8.0" + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-optional-catch-binding/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-optional-catch-binding/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-optional-catch-binding/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-optional-catch-binding/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-optional-catch-binding/README.md new file mode 100644 index 0000000000000000000000000000000000000000..9085f9180c54126260786c4dcdd4c182de590a28 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-optional-catch-binding/README.md @@ -0,0 +1,19 @@ +# @babel/plugin-syntax-optional-catch-binding + +> Allow parsing of optional catch bindings + +See our website [@babel/plugin-syntax-optional-catch-binding](https://babeljs.io/docs/en/next/babel-plugin-syntax-optional-catch-binding.html) for more information. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/plugin-syntax-optional-catch-binding +``` + +or using yarn: + +```sh +yarn add @babel/plugin-syntax-optional-catch-binding --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-optional-catch-binding/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-optional-catch-binding/package.json new file mode 100644 index 0000000000000000000000000000000000000000..5b38a0c1135c496aa2797e7d8a06cb7398d2e37f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-optional-catch-binding/package.json @@ -0,0 +1,23 @@ +{ + "name": "@babel/plugin-syntax-optional-catch-binding", + "version": "7.8.3", + "description": "Allow parsing of optional catch bindings", + "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-syntax-optional-catch-binding", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "main": "lib/index.js", + "keywords": [ + "babel-plugin" + ], + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + }, + "devDependencies": { + "@babel/core": "^7.8.0" + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-optional-chaining/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-optional-chaining/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-optional-chaining/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-optional-chaining/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-optional-chaining/README.md new file mode 100644 index 0000000000000000000000000000000000000000..712abc37046d514b9429ab4cd36097e85b6750c9 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-optional-chaining/README.md @@ -0,0 +1,19 @@ +# @babel/plugin-syntax-optional-chaining + +> Allow parsing of optional properties + +See our website [@babel/plugin-syntax-optional-chaining](https://babeljs.io/docs/en/next/babel-plugin-syntax-optional-chaining.html) for more information. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/plugin-syntax-optional-chaining +``` + +or using yarn: + +```sh +yarn add @babel/plugin-syntax-optional-chaining --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-optional-chaining/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-optional-chaining/package.json new file mode 100644 index 0000000000000000000000000000000000000000..a1dcdc2f82571e0acab89f1967424068b232c3a6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-optional-chaining/package.json @@ -0,0 +1,23 @@ +{ + "name": "@babel/plugin-syntax-optional-chaining", + "version": "7.8.3", + "description": "Allow parsing of optional properties", + "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-syntax-optional-chaining", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "main": "lib/index.js", + "keywords": [ + "babel-plugin" + ], + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + }, + "devDependencies": { + "@babel/core": "^7.8.0" + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-private-property-in-object/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-private-property-in-object/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-private-property-in-object/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-private-property-in-object/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-private-property-in-object/README.md new file mode 100644 index 0000000000000000000000000000000000000000..7869bc42241c0624c3cb7d1dda74df39f1e3405a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-private-property-in-object/README.md @@ -0,0 +1,19 @@ +# @babel/plugin-syntax-private-property-in-object + +> Allow parsing of '#foo in obj' brand checks + +See our website [@babel/plugin-syntax-private-property-in-object](https://babeljs.io/docs/en/babel-plugin-syntax-private-property-in-object) for more information. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/plugin-syntax-private-property-in-object +``` + +or using yarn: + +```sh +yarn add @babel/plugin-syntax-private-property-in-object --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-private-property-in-object/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-private-property-in-object/package.json new file mode 100644 index 0000000000000000000000000000000000000000..0df9140482acafbba3d27e67c209ada5540ea919 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-private-property-in-object/package.json @@ -0,0 +1,32 @@ +{ + "name": "@babel/plugin-syntax-private-property-in-object", + "version": "7.14.5", + "description": "Allow parsing of '#foo in obj' brand checks", + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-plugin-syntax-private-property-in-object" + }, + "homepage": "https://babel.dev/docs/en/next/babel-plugin-syntax-private-property-in-object", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "main": "./lib/index.js", + "exports": { + ".": "./lib/index.js" + }, + "keywords": [ + "babel-plugin" + ], + "dependencies": { + "@babel/helper-plugin-utils": "^7.14.5" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + }, + "engines": { + "node": ">=6.9.0" + }, + "author": "The Babel Team (https://babel.dev/team)" +} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-top-level-await/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-top-level-await/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-top-level-await/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-top-level-await/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-top-level-await/README.md new file mode 100644 index 0000000000000000000000000000000000000000..040c3029e888fafc5cb94af52f9dbc0b80f61a41 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-top-level-await/README.md @@ -0,0 +1,19 @@ +# @babel/plugin-syntax-top-level-await + +> Allow parsing of top-level await in modules + +See our website [@babel/plugin-syntax-top-level-await](https://babeljs.io/docs/en/babel-plugin-syntax-top-level-await) for more information. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/plugin-syntax-top-level-await +``` + +or using yarn: + +```sh +yarn add @babel/plugin-syntax-top-level-await --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-top-level-await/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-top-level-await/package.json new file mode 100644 index 0000000000000000000000000000000000000000..70952be39d4d4dba61a48ed9b5adef6cec7d9ec5 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-top-level-await/package.json @@ -0,0 +1,32 @@ +{ + "name": "@babel/plugin-syntax-top-level-await", + "version": "7.14.5", + "description": "Allow parsing of top-level await in modules", + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-plugin-syntax-top-level-await" + }, + "homepage": "https://babel.dev/docs/en/next/babel-plugin-syntax-top-level-await", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "main": "./lib/index.js", + "keywords": [ + "babel-plugin" + ], + "dependencies": { + "@babel/helper-plugin-utils": "^7.14.5" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + }, + "devDependencies": { + "@babel/core": "7.14.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "author": "The Babel Team (https://babel.dev/team)" +} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-typescript/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-typescript/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-typescript/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-typescript/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-typescript/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b7661da143a77d0f20fc404997cb546e77e1f173 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-typescript/README.md @@ -0,0 +1,19 @@ +# @babel/plugin-syntax-typescript + +> Allow parsing of TypeScript syntax + +See our website [@babel/plugin-syntax-typescript](https://babeljs.io/docs/babel-plugin-syntax-typescript) for more information. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/plugin-syntax-typescript +``` + +or using yarn: + +```sh +yarn add @babel/plugin-syntax-typescript --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-typescript/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-typescript/package.json new file mode 100644 index 0000000000000000000000000000000000000000..4fb9258e7ef3f0626e71f721090d61fb58e9cbf6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/plugin-syntax-typescript/package.json @@ -0,0 +1,35 @@ +{ + "name": "@babel/plugin-syntax-typescript", + "version": "7.27.1", + "description": "Allow parsing of TypeScript syntax", + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-plugin-syntax-typescript" + }, + "homepage": "https://babel.dev/docs/en/next/babel-plugin-syntax-typescript", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "main": "./lib/index.js", + "keywords": [ + "babel-plugin", + "typescript" + ], + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + }, + "devDependencies": { + "@babel/core": "^7.27.1", + "@babel/helper-plugin-test-runner": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "author": "The Babel Team (https://babel.dev/team)", + "type": "commonjs" +} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/template/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/template/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/template/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/template/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/template/README.md new file mode 100644 index 0000000000000000000000000000000000000000..c2980fd943f0f57eb88a27a2f52c5dd2dfa32019 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/template/README.md @@ -0,0 +1,19 @@ +# @babel/template + +> Generate an AST from a string template. + +See our website [@babel/template](https://babeljs.io/docs/babel-template) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20template%22+is%3Aopen) associated with this package. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/template +``` + +or using yarn: + +```sh +yarn add @babel/template --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/template/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/template/package.json new file mode 100644 index 0000000000000000000000000000000000000000..ef9e3d2f95754485dabb5ec9bae73816c7f695a0 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/template/package.json @@ -0,0 +1,27 @@ +{ + "name": "@babel/template", + "version": "7.27.2", + "description": "Generate an AST from a string template.", + "author": "The Babel Team (https://babel.dev/team)", + "homepage": "https://babel.dev/docs/en/next/babel-template", + "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20template%22+is%3Aopen", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-template" + }, + "main": "./lib/index.js", + "dependencies": { + "@babel/code-frame": "^7.27.1", + "@babel/parser": "^7.27.2", + "@babel/types": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "type": "commonjs" +} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/traverse/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/traverse/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/traverse/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/traverse/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/traverse/README.md new file mode 100644 index 0000000000000000000000000000000000000000..0bf7744413ba11a2922f07fd1a15d510ef921ebe --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/traverse/README.md @@ -0,0 +1,19 @@ +# @babel/traverse + +> The Babel Traverse module maintains the overall tree state, and is responsible for replacing, removing, and adding nodes + +See our website [@babel/traverse](https://babeljs.io/docs/babel-traverse) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20traverse%22+is%3Aopen) associated with this package. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/traverse +``` + +or using yarn: + +```sh +yarn add @babel/traverse --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/traverse/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/traverse/package.json new file mode 100644 index 0000000000000000000000000000000000000000..2d24af7c0649b1a2fca8b973bf4c2f5459f86ffb --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/traverse/package.json @@ -0,0 +1,35 @@ +{ + "name": "@babel/traverse", + "version": "7.28.3", + "description": "The Babel Traverse module maintains the overall tree state, and is responsible for replacing, removing, and adding nodes", + "author": "The Babel Team (https://babel.dev/team)", + "homepage": "https://babel.dev/docs/en/next/babel-traverse", + "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20traverse%22+is%3Aopen", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-traverse" + }, + "main": "./lib/index.js", + "dependencies": { + "@babel/code-frame": "^7.27.1", + "@babel/generator": "^7.28.3", + "@babel/helper-globals": "^7.28.0", + "@babel/parser": "^7.28.3", + "@babel/template": "^7.27.2", + "@babel/types": "^7.28.2", + "debug": "^4.3.1" + }, + "devDependencies": { + "@babel/core": "^7.28.3", + "@babel/helper-plugin-test-runner": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "type": "commonjs" +} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/types/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/types/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/types/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/types/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/types/README.md new file mode 100644 index 0000000000000000000000000000000000000000..54c9f81948972286aad02d0fcdb1bd1566ae0f0b --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/types/README.md @@ -0,0 +1,19 @@ +# @babel/types + +> Babel Types is a Lodash-esque utility library for AST nodes + +See our website [@babel/types](https://babeljs.io/docs/babel-types) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20types%22+is%3Aopen) associated with this package. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/types +``` + +or using yarn: + +```sh +yarn add @babel/types --dev +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@babel/types/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/types/package.json new file mode 100644 index 0000000000000000000000000000000000000000..ad5a211682b59015f32188a0040a9838490d7d19 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@babel/types/package.json @@ -0,0 +1,39 @@ +{ + "name": "@babel/types", + "version": "7.28.2", + "description": "Babel Types is a Lodash-esque utility library for AST nodes", + "author": "The Babel Team (https://babel.dev/team)", + "homepage": "https://babel.dev/docs/en/next/babel-types", + "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20types%22+is%3Aopen", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-types" + }, + "main": "./lib/index.js", + "dependencies": { + "@babel/helper-string-parser": "^7.27.1", + "@babel/helper-validator-identifier": "^7.27.1" + }, + "devDependencies": { + "@babel/generator": "^7.28.0", + "@babel/parser": "^7.28.0", + "glob": "^7.2.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "type": "commonjs", + "types": "./lib/index-legacy.d.ts", + "typesVersions": { + ">=4.1": { + "lib/index-legacy.d.ts": [ + "lib/index.d.ts" + ] + } + } +} \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/build/BufferedConsole.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/build/BufferedConsole.js new file mode 100644 index 0000000000000000000000000000000000000000..a6f41181600a9430f096b89f5b5e579e15da5951 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/build/BufferedConsole.js @@ -0,0 +1,197 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _assert() { + const data = require('assert'); + _assert = function () { + return data; + }; + return data; +} +function _console() { + const data = require('console'); + _console = function () { + return data; + }; + return data; +} +function _util() { + const data = require('util'); + _util = function () { + return data; + }; + return data; +} +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class BufferedConsole extends _console().Console { + _buffer = []; + _counters = {}; + _timers = {}; + _groupDepth = 0; + Console = _console().Console; + constructor() { + super({ + write: message => { + BufferedConsole.write(this._buffer, 'log', message, null); + return true; + } + }); + } + static write(buffer, type, message, level) { + const stackLevel = level != null ? level : 2; + const rawStack = new (_jestUtil().ErrorWithStack)( + undefined, + BufferedConsole.write + ).stack; + (0, _jestUtil().invariant)(rawStack != null, 'always have a stack trace'); + const origin = rawStack + .split('\n') + .slice(stackLevel) + .filter(Boolean) + .join('\n'); + buffer.push({ + message, + origin, + type + }); + return buffer; + } + _log(type, message) { + BufferedConsole.write( + this._buffer, + type, + ' '.repeat(this._groupDepth) + message, + 3 + ); + } + assert(value, message) { + try { + (0, _assert().strict)(value, message); + } catch (error) { + if (!(error instanceof _assert().AssertionError)) { + throw error; + } + // https://github.com/jestjs/jest/pull/13422#issuecomment-1273396392 + this._log('assert', error.toString().replace(/:\n\n.*\n/gs, '')); + } + } + count(label = 'default') { + if (!this._counters[label]) { + this._counters[label] = 0; + } + this._log( + 'count', + (0, _util().format)(`${label}: ${++this._counters[label]}`) + ); + } + countReset(label = 'default') { + this._counters[label] = 0; + } + debug(firstArg, ...rest) { + this._log('debug', (0, _util().format)(firstArg, ...rest)); + } + dir(firstArg, options = {}) { + const representation = (0, _util().inspect)(firstArg, options); + this._log('dir', (0, _util().formatWithOptions)(options, representation)); + } + dirxml(firstArg, ...rest) { + this._log('dirxml', (0, _util().format)(firstArg, ...rest)); + } + error(firstArg, ...rest) { + this._log('error', (0, _util().format)(firstArg, ...rest)); + } + group(title, ...rest) { + this._groupDepth++; + if (title != null || rest.length > 0) { + this._log( + 'group', + _chalk().default.bold((0, _util().format)(title, ...rest)) + ); + } + } + groupCollapsed(title, ...rest) { + this._groupDepth++; + if (title != null || rest.length > 0) { + this._log( + 'groupCollapsed', + _chalk().default.bold((0, _util().format)(title, ...rest)) + ); + } + } + groupEnd() { + if (this._groupDepth > 0) { + this._groupDepth--; + } + } + info(firstArg, ...rest) { + this._log('info', (0, _util().format)(firstArg, ...rest)); + } + log(firstArg, ...rest) { + this._log('log', (0, _util().format)(firstArg, ...rest)); + } + time(label = 'default') { + if (this._timers[label] != null) { + return; + } + this._timers[label] = new Date(); + } + timeEnd(label = 'default') { + const startTime = this._timers[label]; + if (startTime != null) { + const endTime = new Date(); + const time = endTime.getTime() - startTime.getTime(); + this._log( + 'time', + (0, _util().format)(`${label}: ${(0, _jestUtil().formatTime)(time)}`) + ); + delete this._timers[label]; + } + } + timeLog(label = 'default', ...data) { + const startTime = this._timers[label]; + if (startTime != null) { + const endTime = new Date(); + const time = endTime.getTime() - startTime.getTime(); + this._log( + 'time', + (0, _util().format)( + `${label}: ${(0, _jestUtil().formatTime)(time)}`, + ...data + ) + ); + } + } + warn(firstArg, ...rest) { + this._log('warn', (0, _util().format)(firstArg, ...rest)); + } + getBuffer() { + return this._buffer.length ? this._buffer : undefined; + } +} +exports.default = BufferedConsole; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/build/CustomConsole.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/build/CustomConsole.js new file mode 100644 index 0000000000000000000000000000000000000000..61846d8673969d3a747777cc03577f61529f73d4 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/build/CustomConsole.js @@ -0,0 +1,182 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _assert() { + const data = require('assert'); + _assert = function () { + return data; + }; + return data; +} +function _console() { + const data = require('console'); + _console = function () { + return data; + }; + return data; +} +function _util() { + const data = require('util'); + _util = function () { + return data; + }; + return data; +} +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class CustomConsole extends _console().Console { + _stdout; + _stderr; + _formatBuffer; + _counters = {}; + _timers = {}; + _groupDepth = 0; + Console = _console().Console; + constructor(stdout, stderr, formatBuffer = (_type, message) => message) { + super(stdout, stderr); + this._stdout = stdout; + this._stderr = stderr; + this._formatBuffer = formatBuffer; + } + _log(type, message) { + (0, _jestUtil().clearLine)(this._stdout); + super.log( + this._formatBuffer(type, ' '.repeat(this._groupDepth) + message) + ); + } + _logError(type, message) { + (0, _jestUtil().clearLine)(this._stderr); + super.error( + this._formatBuffer(type, ' '.repeat(this._groupDepth) + message) + ); + } + assert(value, message) { + try { + (0, _assert().strict)(value, message); + } catch (error) { + if (!(error instanceof _assert().AssertionError)) { + throw error; + } + // https://github.com/jestjs/jest/pull/13422#issuecomment-1273396392 + this._logError('assert', error.toString().replace(/:\n\n.*\n/gs, '')); + } + } + count(label = 'default') { + if (!this._counters[label]) { + this._counters[label] = 0; + } + this._log( + 'count', + (0, _util().format)(`${label}: ${++this._counters[label]}`) + ); + } + countReset(label = 'default') { + this._counters[label] = 0; + } + debug(firstArg, ...args) { + this._log('debug', (0, _util().format)(firstArg, ...args)); + } + dir(firstArg, options = {}) { + const representation = (0, _util().inspect)(firstArg, options); + this._log('dir', (0, _util().formatWithOptions)(options, representation)); + } + dirxml(firstArg, ...args) { + this._log('dirxml', (0, _util().format)(firstArg, ...args)); + } + error(firstArg, ...args) { + this._logError('error', (0, _util().format)(firstArg, ...args)); + } + group(title, ...args) { + this._groupDepth++; + if (title != null || args.length > 0) { + this._log( + 'group', + _chalk().default.bold((0, _util().format)(title, ...args)) + ); + } + } + groupCollapsed(title, ...args) { + this._groupDepth++; + if (title != null || args.length > 0) { + this._log( + 'groupCollapsed', + _chalk().default.bold((0, _util().format)(title, ...args)) + ); + } + } + groupEnd() { + if (this._groupDepth > 0) { + this._groupDepth--; + } + } + info(firstArg, ...args) { + this._log('info', (0, _util().format)(firstArg, ...args)); + } + log(firstArg, ...args) { + this._log('log', (0, _util().format)(firstArg, ...args)); + } + time(label = 'default') { + if (this._timers[label] != null) { + return; + } + this._timers[label] = new Date(); + } + timeEnd(label = 'default') { + const startTime = this._timers[label]; + if (startTime != null) { + const endTime = new Date().getTime(); + const time = endTime - startTime.getTime(); + this._log( + 'time', + (0, _util().format)(`${label}: ${(0, _jestUtil().formatTime)(time)}`) + ); + delete this._timers[label]; + } + } + timeLog(label = 'default', ...data) { + const startTime = this._timers[label]; + if (startTime != null) { + const endTime = new Date(); + const time = endTime.getTime() - startTime.getTime(); + this._log( + 'time', + (0, _util().format)( + `${label}: ${(0, _jestUtil().formatTime)(time)}`, + ...data + ) + ); + } + } + warn(firstArg, ...args) { + this._logError('warn', (0, _util().format)(firstArg, ...args)); + } + getBuffer() { + return undefined; + } +} +exports.default = CustomConsole; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/build/NullConsole.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/build/NullConsole.js new file mode 100644 index 0000000000000000000000000000000000000000..3a396a2d52a7a2e3d3e40b71fb1a856fe517f7b4 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/build/NullConsole.js @@ -0,0 +1,35 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +var _CustomConsole = _interopRequireDefault(require('./CustomConsole')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/* eslint-disable @typescript-eslint/no-empty-function */ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class NullConsole extends _CustomConsole.default { + assert() {} + debug() {} + dir() {} + error() {} + info() {} + log() {} + time() {} + timeEnd() {} + timeLog() {} + trace() {} + warn() {} + group() {} + groupCollapsed() {} + groupEnd() {} +} +exports.default = NullConsole; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/build/getConsoleOutput.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/build/getConsoleOutput.js new file mode 100644 index 0000000000000000000000000000000000000000..a38f85c67288039240e4a854ff32f16ca5705e1d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/build/getConsoleOutput.js @@ -0,0 +1,70 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getConsoleOutput; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _jestMessageUtil() { + const data = require('jest-message-util'); + _jestMessageUtil = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function getConsoleOutput(buffer, config, globalConfig) { + const TITLE_INDENT = + globalConfig.verbose === true ? ' '.repeat(2) : ' '.repeat(4); + const CONSOLE_INDENT = TITLE_INDENT + ' '.repeat(2); + const logEntries = buffer.reduce((output, {type, message, origin}) => { + message = message + .split(/\n/) + .map(line => CONSOLE_INDENT + line) + .join('\n'); + let typeMessage = `console.${type}`; + let noStackTrace = true; + let noCodeFrame = true; + if (type === 'warn') { + message = _chalk().default.yellow(message); + typeMessage = _chalk().default.yellow(typeMessage); + noStackTrace = globalConfig?.noStackTrace ?? false; + noCodeFrame = false; + } else if (type === 'error') { + message = _chalk().default.red(message); + typeMessage = _chalk().default.red(typeMessage); + noStackTrace = globalConfig?.noStackTrace ?? false; + noCodeFrame = false; + } + const options = { + noCodeFrame, + noStackTrace + }; + const formattedStackTrace = (0, _jestMessageUtil().formatStackTrace)( + origin, + config, + options + ); + return `${ + output + TITLE_INDENT + _chalk().default.dim(typeMessage) + }\n${message.trimRight()}\n${_chalk().default.dim( + formattedStackTrace.trimRight() + )}\n\n`; + }, ''); + return `${logEntries.trimRight()}\n`; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d4dcd2eb4ae881d9ff9cae14cf9606aafd6a7ae6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/build/index.d.ts @@ -0,0 +1,131 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/// + +import type {Config} from '@jest/types'; +import {Console as Console_2} from 'console'; +import {InspectOptions} from 'util'; +import {StackTraceConfig} from 'jest-message-util'; + +export declare class BufferedConsole extends Console_2 { + private readonly _buffer; + private _counters; + private _timers; + private _groupDepth; + Console: typeof Console_2; + constructor(); + static write( + this: void, + buffer: ConsoleBuffer, + type: LogType, + message: LogMessage, + level?: number | null, + ): ConsoleBuffer; + private _log; + assert(value: unknown, message?: string | Error): void; + count(label?: string): void; + countReset(label?: string): void; + debug(firstArg: unknown, ...rest: Array): void; + dir(firstArg: unknown, options?: InspectOptions): void; + dirxml(firstArg: unknown, ...rest: Array): void; + error(firstArg: unknown, ...rest: Array): void; + group(title?: string, ...rest: Array): void; + groupCollapsed(title?: string, ...rest: Array): void; + groupEnd(): void; + info(firstArg: unknown, ...rest: Array): void; + log(firstArg: unknown, ...rest: Array): void; + time(label?: string): void; + timeEnd(label?: string): void; + timeLog(label?: string, ...data: Array): void; + warn(firstArg: unknown, ...rest: Array): void; + getBuffer(): ConsoleBuffer | undefined; +} + +export declare type ConsoleBuffer = Array; + +export declare class CustomConsole extends Console_2 { + private readonly _stdout; + private readonly _stderr; + private readonly _formatBuffer; + private _counters; + private _timers; + private _groupDepth; + Console: typeof Console_2; + constructor( + stdout: NodeJS.WriteStream, + stderr: NodeJS.WriteStream, + formatBuffer?: Formatter, + ); + private _log; + private _logError; + assert(value: unknown, message?: string | Error): asserts value; + count(label?: string): void; + countReset(label?: string): void; + debug(firstArg: unknown, ...args: Array): void; + dir(firstArg: unknown, options?: InspectOptions): void; + dirxml(firstArg: unknown, ...args: Array): void; + error(firstArg: unknown, ...args: Array): void; + group(title?: string, ...args: Array): void; + groupCollapsed(title?: string, ...args: Array): void; + groupEnd(): void; + info(firstArg: unknown, ...args: Array): void; + log(firstArg: unknown, ...args: Array): void; + time(label?: string): void; + timeEnd(label?: string): void; + timeLog(label?: string, ...data: Array): void; + warn(firstArg: unknown, ...args: Array): void; + getBuffer(): undefined; +} + +declare type Formatter = (type: LogType, message: LogMessage) => string; + +export declare function getConsoleOutput( + buffer: ConsoleBuffer, + config: StackTraceConfig, + globalConfig: Config.GlobalConfig, +): string; + +export declare type LogEntry = { + message: LogMessage; + origin: string; + type: LogType; +}; + +export declare type LogMessage = string; + +export declare type LogType = + | 'assert' + | 'count' + | 'debug' + | 'dir' + | 'dirxml' + | 'error' + | 'group' + | 'groupCollapsed' + | 'info' + | 'log' + | 'time' + | 'warn'; + +export declare class NullConsole extends CustomConsole { + assert(): void; + debug(): void; + dir(): void; + error(): void; + info(): void; + log(): void; + time(): void; + timeEnd(): void; + timeLog(): void; + trace(): void; + warn(): void; + group(): void; + groupCollapsed(): void; + groupEnd(): void; +} + +export {}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..6383b61d52bf26329d19674364d8d88600cc95ac --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/build/index.js @@ -0,0 +1,36 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +Object.defineProperty(exports, 'BufferedConsole', { + enumerable: true, + get: function () { + return _BufferedConsole.default; + } +}); +Object.defineProperty(exports, 'CustomConsole', { + enumerable: true, + get: function () { + return _CustomConsole.default; + } +}); +Object.defineProperty(exports, 'NullConsole', { + enumerable: true, + get: function () { + return _NullConsole.default; + } +}); +Object.defineProperty(exports, 'getConsoleOutput', { + enumerable: true, + get: function () { + return _getConsoleOutput.default; + } +}); +var _BufferedConsole = _interopRequireDefault(require('./BufferedConsole')); +var _CustomConsole = _interopRequireDefault(require('./CustomConsole')); +var _NullConsole = _interopRequireDefault(require('./NullConsole')); +var _getConsoleOutput = _interopRequireDefault(require('./getConsoleOutput')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/build/types.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/build/types.js new file mode 100644 index 0000000000000000000000000000000000000000..ad9a93a7c160f02945911772460eb8a1bcb003db --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/build/types.js @@ -0,0 +1 @@ +'use strict'; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/package.json new file mode 100644 index 0000000000000000000000000000000000000000..4d08f3099211bb5d97be0b2a7b375755d17c295d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/console/package.json @@ -0,0 +1,37 @@ +{ + "name": "@jest/console", + "version": "29.7.0", + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/jest-console" + }, + "license": "MIT", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "dependencies": { + "@jest/types": "^29.6.3", + "@types/node": "*", + "chalk": "^4.0.0", + "jest-message-util": "^29.7.0", + "jest-util": "^29.7.0", + "slash": "^3.0.0" + }, + "devDependencies": { + "@jest/test-utils": "^29.7.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "publishConfig": { + "access": "public" + }, + "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/README.md new file mode 100644 index 0000000000000000000000000000000000000000..e5852b602abb9a53394f6074db8b1c4430100e83 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/README.md @@ -0,0 +1,3 @@ +# @jest/core + +Jest is currently working on providing a programmatic API. This is under development, and usage of this package directly is currently not supported. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/FailedTestsCache.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/FailedTestsCache.js new file mode 100644 index 0000000000000000000000000000000000000000..59fcb06b9fa5e260735bfc23ece6b4de6bdddda8 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/FailedTestsCache.js @@ -0,0 +1,46 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class FailedTestsCache { + _enabledTestsMap; + filterTests(tests) { + const enabledTestsMap = this._enabledTestsMap; + if (!enabledTestsMap) { + return tests; + } + return tests.filter(testResult => enabledTestsMap[testResult.path]); + } + setTestResults(testResults) { + this._enabledTestsMap = (testResults || []).reduce( + (suiteMap, testResult) => { + if (!testResult.numFailingTests) { + return suiteMap; + } + suiteMap[testResult.testFilePath] = testResult.testResults.reduce( + (testMap, test) => { + if (test.status !== 'failed') { + return testMap; + } + testMap[test.fullName] = true; + return testMap; + }, + {} + ); + return suiteMap; + }, + {} + ); + this._enabledTestsMap = Object.freeze(this._enabledTestsMap); + } +} +exports.default = FailedTestsCache; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/FailedTestsInteractiveMode.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/FailedTestsInteractiveMode.js new file mode 100644 index 0000000000000000000000000000000000000000..d64177fb018215a143dfbd5c9bb0b7b70767a3f5 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/FailedTestsInteractiveMode.js @@ -0,0 +1,195 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _ansiEscapes() { + const data = _interopRequireDefault(require('ansi-escapes')); + _ansiEscapes = function () { + return data; + }; + return data; +} +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +function _jestWatcher() { + const data = require('jest-watcher'); + _jestWatcher = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const {ARROW, CLEAR} = _jestUtil().specialChars; +function describeKey(key, description) { + return `${_chalk().default.dim( + `${ARROW}Press` + )} ${key} ${_chalk().default.dim(description)}`; +} +const TestProgressLabel = _chalk().default.bold('Interactive Test Progress'); +class FailedTestsInteractiveMode { + _isActive = false; + _countPaths = 0; + _skippedNum = 0; + _testAssertions = []; + _updateTestRunnerConfig; + constructor(_pipe) { + this._pipe = _pipe; + } + isActive() { + return this._isActive; + } + put(key) { + switch (key) { + case 's': + if (this._skippedNum === this._testAssertions.length) { + break; + } + this._skippedNum += 1; + // move skipped test to the end + this._testAssertions.push(this._testAssertions.shift()); + if (this._testAssertions.length - this._skippedNum > 0) { + this._run(); + } else { + this._drawUIDoneWithSkipped(); + } + break; + case 'q': + case _jestWatcher().KEYS.ESCAPE: + this.abort(); + break; + case 'r': + this.restart(); + break; + case _jestWatcher().KEYS.ENTER: + if (this._testAssertions.length === 0) { + this.abort(); + } else { + this._run(); + } + break; + default: + } + } + run(failedTestAssertions, updateConfig) { + if (failedTestAssertions.length === 0) return; + this._testAssertions = [...failedTestAssertions]; + this._countPaths = this._testAssertions.length; + this._updateTestRunnerConfig = updateConfig; + this._isActive = true; + this._run(); + } + updateWithResults(results) { + if (!results.snapshot.failure && results.numFailedTests > 0) { + return this._drawUIOverlay(); + } + this._testAssertions.shift(); + if (this._testAssertions.length === 0) { + return this._drawUIOverlay(); + } + + // Go to the next test + return this._run(); + } + _clearTestSummary() { + this._pipe.write(_ansiEscapes().default.cursorUp(6)); + this._pipe.write(_ansiEscapes().default.eraseDown); + } + _drawUIDone() { + this._pipe.write(CLEAR); + const messages = [ + _chalk().default.bold('Watch Usage'), + describeKey('Enter', 'to return to watch mode.') + ]; + this._pipe.write(`${messages.join('\n')}\n`); + } + _drawUIDoneWithSkipped() { + this._pipe.write(CLEAR); + let stats = `${(0, _jestUtil().pluralize)( + 'test', + this._countPaths + )} reviewed`; + if (this._skippedNum > 0) { + const skippedText = _chalk().default.bold.yellow( + `${(0, _jestUtil().pluralize)('test', this._skippedNum)} skipped` + ); + stats = `${stats}, ${skippedText}`; + } + const message = [ + TestProgressLabel, + `${ARROW}${stats}`, + '\n', + _chalk().default.bold('Watch Usage'), + describeKey('r', 'to restart Interactive Mode.'), + describeKey('q', 'to quit Interactive Mode.'), + describeKey('Enter', 'to return to watch mode.') + ]; + this._pipe.write(`\n${message.join('\n')}`); + } + _drawUIProgress() { + this._clearTestSummary(); + const numPass = this._countPaths - this._testAssertions.length; + const numRemaining = this._countPaths - numPass - this._skippedNum; + let stats = `${(0, _jestUtil().pluralize)('test', numRemaining)} remaining`; + if (this._skippedNum > 0) { + const skippedText = _chalk().default.bold.yellow( + `${(0, _jestUtil().pluralize)('test', this._skippedNum)} skipped` + ); + stats = `${stats}, ${skippedText}`; + } + const message = [ + TestProgressLabel, + `${ARROW}${stats}`, + '\n', + _chalk().default.bold('Watch Usage'), + describeKey('s', 'to skip the current test.'), + describeKey('q', 'to quit Interactive Mode.'), + describeKey('Enter', 'to return to watch mode.') + ]; + this._pipe.write(`\n${message.join('\n')}`); + } + _drawUIOverlay() { + if (this._testAssertions.length === 0) return this._drawUIDone(); + return this._drawUIProgress(); + } + _run() { + if (this._updateTestRunnerConfig) { + this._updateTestRunnerConfig(this._testAssertions[0]); + } + } + abort() { + this._isActive = false; + this._skippedNum = 0; + if (this._updateTestRunnerConfig) { + this._updateTestRunnerConfig(); + } + } + restart() { + this._skippedNum = 0; + this._countPaths = this._testAssertions.length; + this._run(); + } +} +exports.default = FailedTestsInteractiveMode; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/ReporterDispatcher.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/ReporterDispatcher.js new file mode 100644 index 0000000000000000000000000000000000000000..5666cbc207ddcd745a3b1f4c3e1314003930e380 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/ReporterDispatcher.js @@ -0,0 +1,87 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class ReporterDispatcher { + _reporters; + constructor() { + this._reporters = []; + } + register(reporter) { + this._reporters.push(reporter); + } + unregister(reporterConstructor) { + this._reporters = this._reporters.filter( + reporter => !(reporter instanceof reporterConstructor) + ); + } + async onTestFileResult(test, testResult, results) { + for (const reporter of this._reporters) { + if (reporter.onTestFileResult) { + await reporter.onTestFileResult(test, testResult, results); + } else if (reporter.onTestResult) { + await reporter.onTestResult(test, testResult, results); + } + } + + // Release memory if unused later. + testResult.coverage = undefined; + testResult.console = undefined; + } + async onTestFileStart(test) { + for (const reporter of this._reporters) { + if (reporter.onTestFileStart) { + await reporter.onTestFileStart(test); + } else if (reporter.onTestStart) { + await reporter.onTestStart(test); + } + } + } + async onRunStart(results, options) { + for (const reporter of this._reporters) { + reporter.onRunStart && (await reporter.onRunStart(results, options)); + } + } + async onTestCaseStart(test, testCaseStartInfo) { + for (const reporter of this._reporters) { + if (reporter.onTestCaseStart) { + await reporter.onTestCaseStart(test, testCaseStartInfo); + } + } + } + async onTestCaseResult(test, testCaseResult) { + for (const reporter of this._reporters) { + if (reporter.onTestCaseResult) { + await reporter.onTestCaseResult(test, testCaseResult); + } + } + } + async onRunComplete(testContexts, results) { + for (const reporter of this._reporters) { + if (reporter.onRunComplete) { + await reporter.onRunComplete(testContexts, results); + } + } + } + + // Return a list of last errors for every reporter + getErrors() { + return this._reporters.reduce((list, reporter) => { + const error = reporter.getLastError && reporter.getLastError(); + return error ? list.concat(error) : list; + }, []); + } + hasErrors() { + return this.getErrors().length !== 0; + } +} +exports.default = ReporterDispatcher; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/SearchSource.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/SearchSource.js new file mode 100644 index 0000000000000000000000000000000000000000..a81ef96af41ec7baa80b1223a166de214e5eae2b --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/SearchSource.js @@ -0,0 +1,408 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function os() { + const data = _interopRequireWildcard(require('os')); + os = function () { + return data; + }; + return data; +} +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _micromatch() { + const data = _interopRequireDefault(require('micromatch')); + _micromatch = function () { + return data; + }; + return data; +} +function _jestConfig() { + const data = require('jest-config'); + _jestConfig = function () { + return data; + }; + return data; +} +function _jestRegexUtil() { + const data = require('jest-regex-util'); + _jestRegexUtil = function () { + return data; + }; + return data; +} +function _jestResolveDependencies() { + const data = require('jest-resolve-dependencies'); + _jestResolveDependencies = function () { + return data; + }; + return data; +} +function _jestSnapshot() { + const data = require('jest-snapshot'); + _jestSnapshot = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const regexToMatcher = testRegex => { + const regexes = testRegex.map(testRegex => new RegExp(testRegex)); + return path => + regexes.some(regex => { + const result = regex.test(path); + + // prevent stateful regexes from breaking, just in case + regex.lastIndex = 0; + return result; + }); +}; +const toTests = (context, tests) => + tests.map(path => ({ + context, + duration: undefined, + path + })); +const hasSCM = changedFilesInfo => { + const {repos} = changedFilesInfo; + // no SCM (git/hg/...) is found in any of the roots. + const noSCM = Object.values(repos).every(scm => scm.size === 0); + return !noSCM; +}; +class SearchSource { + _context; + _dependencyResolver; + _testPathCases = []; + constructor(context) { + const {config} = context; + this._context = context; + this._dependencyResolver = null; + const rootPattern = new RegExp( + config.roots + .map(dir => (0, _jestRegexUtil().escapePathForRegex)(dir + path().sep)) + .join('|') + ); + this._testPathCases.push({ + isMatch: path => rootPattern.test(path), + stat: 'roots' + }); + if (config.testMatch.length) { + this._testPathCases.push({ + isMatch: (0, _jestUtil().globsToMatcher)(config.testMatch), + stat: 'testMatch' + }); + } + if (config.testPathIgnorePatterns.length) { + const testIgnorePatternsRegex = new RegExp( + config.testPathIgnorePatterns.join('|') + ); + this._testPathCases.push({ + isMatch: path => !testIgnorePatternsRegex.test(path), + stat: 'testPathIgnorePatterns' + }); + } + if (config.testRegex.length) { + this._testPathCases.push({ + isMatch: regexToMatcher(config.testRegex), + stat: 'testRegex' + }); + } + } + async _getOrBuildDependencyResolver() { + if (!this._dependencyResolver) { + this._dependencyResolver = + new (_jestResolveDependencies().DependencyResolver)( + this._context.resolver, + this._context.hasteFS, + await (0, _jestSnapshot().buildSnapshotResolver)(this._context.config) + ); + } + return this._dependencyResolver; + } + _filterTestPathsWithStats(allPaths, testPathPattern) { + const data = { + stats: { + roots: 0, + testMatch: 0, + testPathIgnorePatterns: 0, + testRegex: 0 + }, + tests: [], + total: allPaths.length + }; + const testCases = Array.from(this._testPathCases); // clone + if (testPathPattern) { + const regex = (0, _jestUtil().testPathPatternToRegExp)(testPathPattern); + testCases.push({ + isMatch: path => regex.test(path), + stat: 'testPathPattern' + }); + data.stats.testPathPattern = 0; + } + data.tests = allPaths.filter(test => { + let filterResult = true; + for (const {isMatch, stat} of testCases) { + if (isMatch(test.path)) { + data.stats[stat]++; + } else { + filterResult = false; + } + } + return filterResult; + }); + return data; + } + _getAllTestPaths(testPathPattern) { + return this._filterTestPathsWithStats( + toTests(this._context, this._context.hasteFS.getAllFiles()), + testPathPattern + ); + } + isTestFilePath(path) { + return this._testPathCases.every(testCase => testCase.isMatch(path)); + } + findMatchingTests(testPathPattern) { + return this._getAllTestPaths(testPathPattern); + } + async findRelatedTests(allPaths, collectCoverage) { + const dependencyResolver = await this._getOrBuildDependencyResolver(); + if (!collectCoverage) { + return { + tests: toTests( + this._context, + dependencyResolver.resolveInverse( + allPaths, + this.isTestFilePath.bind(this), + { + skipNodeResolution: this._context.config.skipNodeResolution + } + ) + ) + }; + } + const testModulesMap = dependencyResolver.resolveInverseModuleMap( + allPaths, + this.isTestFilePath.bind(this), + { + skipNodeResolution: this._context.config.skipNodeResolution + } + ); + const allPathsAbsolute = Array.from(allPaths).map(p => path().resolve(p)); + const collectCoverageFrom = new Set(); + testModulesMap.forEach(testModule => { + if (!testModule.dependencies) { + return; + } + testModule.dependencies.forEach(p => { + if (!allPathsAbsolute.includes(p)) { + return; + } + const filename = (0, _jestConfig().replaceRootDirInPath)( + this._context.config.rootDir, + p + ); + collectCoverageFrom.add( + path().isAbsolute(filename) + ? path().relative(this._context.config.rootDir, filename) + : filename + ); + }); + }); + return { + collectCoverageFrom, + tests: toTests( + this._context, + testModulesMap.map(testModule => testModule.file) + ) + }; + } + findTestsByPaths(paths) { + return { + tests: toTests( + this._context, + paths + .map(p => path().resolve(this._context.config.cwd, p)) + .filter(this.isTestFilePath.bind(this)) + ) + }; + } + async findRelatedTestsFromPattern(paths, collectCoverage) { + if (Array.isArray(paths) && paths.length) { + const resolvedPaths = paths.map(p => + path().resolve(this._context.config.cwd, p) + ); + return this.findRelatedTests(new Set(resolvedPaths), collectCoverage); + } + return { + tests: [] + }; + } + async findTestRelatedToChangedFiles(changedFilesInfo, collectCoverage) { + if (!hasSCM(changedFilesInfo)) { + return { + noSCM: true, + tests: [] + }; + } + const {changedFiles} = changedFilesInfo; + return this.findRelatedTests(changedFiles, collectCoverage); + } + async _getTestPaths(globalConfig, changedFiles) { + if (globalConfig.onlyChanged) { + if (!changedFiles) { + throw new Error('Changed files must be set when running with -o.'); + } + return this.findTestRelatedToChangedFiles( + changedFiles, + globalConfig.collectCoverage + ); + } + let paths = globalConfig.nonFlagArgs; + if (globalConfig.findRelatedTests && 'win32' === os().platform()) { + paths = this.filterPathsWin32(paths); + } + if (globalConfig.runTestsByPath && paths && paths.length) { + return this.findTestsByPaths(paths); + } else if (globalConfig.findRelatedTests && paths && paths.length) { + return this.findRelatedTestsFromPattern( + paths, + globalConfig.collectCoverage + ); + } else if (globalConfig.testPathPattern != null) { + return this.findMatchingTests(globalConfig.testPathPattern); + } else { + return { + tests: [] + }; + } + } + filterPathsWin32(paths) { + const allFiles = this._context.hasteFS.getAllFiles(); + const options = { + nocase: true, + windows: false + }; + function normalizePosix(filePath) { + return filePath.replace(/\\/g, '/'); + } + paths = paths + .map(p => { + // micromatch works with forward slashes: https://github.com/micromatch/micromatch#backslashes + const normalizedPath = normalizePosix( + path().resolve(this._context.config.cwd, p) + ); + const match = (0, _micromatch().default)( + allFiles.map(normalizePosix), + normalizedPath, + options + ); + return match[0]; + }) + .filter(Boolean) + .map(p => path().resolve(p)); + return paths; + } + async getTestPaths(globalConfig, changedFiles, filter) { + const searchResult = await this._getTestPaths(globalConfig, changedFiles); + const filterPath = globalConfig.filter; + if (filter) { + const tests = searchResult.tests; + const filterResult = await filter(tests.map(test => test.path)); + if (!Array.isArray(filterResult.filtered)) { + throw new Error( + `Filter ${filterPath} did not return a valid test list` + ); + } + const filteredSet = new Set( + filterResult.filtered.map(result => result.test) + ); + return { + ...searchResult, + tests: tests.filter(test => filteredSet.has(test.path)) + }; + } + return searchResult; + } + async findRelatedSourcesFromTestsInChangedFiles(changedFilesInfo) { + if (!hasSCM(changedFilesInfo)) { + return []; + } + const {changedFiles} = changedFilesInfo; + const dependencyResolver = await this._getOrBuildDependencyResolver(); + const relatedSourcesSet = new Set(); + changedFiles.forEach(filePath => { + if (this.isTestFilePath(filePath)) { + const sourcePaths = dependencyResolver.resolve(filePath, { + skipNodeResolution: this._context.config.skipNodeResolution + }); + sourcePaths.forEach(sourcePath => relatedSourcesSet.add(sourcePath)); + } + }); + return Array.from(relatedSourcesSet); + } +} +exports.default = SearchSource; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/SnapshotInteractiveMode.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/SnapshotInteractiveMode.js new file mode 100644 index 0000000000000000000000000000000000000000..40a4b547d5e6593a599449f703e705798ed9a906 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/SnapshotInteractiveMode.js @@ -0,0 +1,238 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _ansiEscapes() { + const data = _interopRequireDefault(require('ansi-escapes')); + _ansiEscapes = function () { + return data; + }; + return data; +} +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +function _jestWatcher() { + const data = require('jest-watcher'); + _jestWatcher = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const {ARROW, CLEAR} = _jestUtil().specialChars; +class SnapshotInteractiveMode { + _pipe; + _isActive; + _updateTestRunnerConfig; + _testAssertions; + _countPaths; + _skippedNum; + constructor(pipe) { + this._pipe = pipe; + this._isActive = false; + this._skippedNum = 0; + } + isActive() { + return this._isActive; + } + getSkippedNum() { + return this._skippedNum; + } + _clearTestSummary() { + this._pipe.write(_ansiEscapes().default.cursorUp(6)); + this._pipe.write(_ansiEscapes().default.eraseDown); + } + _drawUIProgress() { + this._clearTestSummary(); + const numPass = this._countPaths - this._testAssertions.length; + const numRemaining = this._countPaths - numPass - this._skippedNum; + let stats = _chalk().default.bold.dim( + `${(0, _jestUtil().pluralize)('snapshot', numRemaining)} remaining` + ); + if (numPass) { + stats += `, ${_chalk().default.bold.green( + `${(0, _jestUtil().pluralize)('snapshot', numPass)} updated` + )}`; + } + if (this._skippedNum) { + stats += `, ${_chalk().default.bold.yellow( + `${(0, _jestUtil().pluralize)('snapshot', this._skippedNum)} skipped` + )}`; + } + const messages = [ + `\n${_chalk().default.bold('Interactive Snapshot Progress')}`, + ARROW + stats, + `\n${_chalk().default.bold('Watch Usage')}`, + `${_chalk().default.dim(`${ARROW}Press `)}u${_chalk().default.dim( + ' to update failing snapshots for this test.' + )}`, + `${_chalk().default.dim(`${ARROW}Press `)}s${_chalk().default.dim( + ' to skip the current test.' + )}`, + `${_chalk().default.dim(`${ARROW}Press `)}q${_chalk().default.dim( + ' to quit Interactive Snapshot Mode.' + )}`, + `${_chalk().default.dim(`${ARROW}Press `)}Enter${_chalk().default.dim( + ' to trigger a test run.' + )}` + ]; + this._pipe.write(`${messages.filter(Boolean).join('\n')}\n`); + } + _drawUIDoneWithSkipped() { + this._pipe.write(CLEAR); + const numPass = this._countPaths - this._testAssertions.length; + let stats = _chalk().default.bold.dim( + `${(0, _jestUtil().pluralize)('snapshot', this._countPaths)} reviewed` + ); + if (numPass) { + stats += `, ${_chalk().default.bold.green( + `${(0, _jestUtil().pluralize)('snapshot', numPass)} updated` + )}`; + } + if (this._skippedNum) { + stats += `, ${_chalk().default.bold.yellow( + `${(0, _jestUtil().pluralize)('snapshot', this._skippedNum)} skipped` + )}`; + } + const messages = [ + `\n${_chalk().default.bold('Interactive Snapshot Result')}`, + ARROW + stats, + `\n${_chalk().default.bold('Watch Usage')}`, + `${_chalk().default.dim(`${ARROW}Press `)}r${_chalk().default.dim( + ' to restart Interactive Snapshot Mode.' + )}`, + `${_chalk().default.dim(`${ARROW}Press `)}q${_chalk().default.dim( + ' to quit Interactive Snapshot Mode.' + )}` + ]; + this._pipe.write(`${messages.filter(Boolean).join('\n')}\n`); + } + _drawUIDone() { + this._pipe.write(CLEAR); + const numPass = this._countPaths - this._testAssertions.length; + let stats = _chalk().default.bold.dim( + `${(0, _jestUtil().pluralize)('snapshot', this._countPaths)} reviewed` + ); + if (numPass) { + stats += `, ${_chalk().default.bold.green( + `${(0, _jestUtil().pluralize)('snapshot', numPass)} updated` + )}`; + } + const messages = [ + `\n${_chalk().default.bold('Interactive Snapshot Result')}`, + ARROW + stats, + `\n${_chalk().default.bold('Watch Usage')}`, + `${_chalk().default.dim(`${ARROW}Press `)}Enter${_chalk().default.dim( + ' to return to watch mode.' + )}` + ]; + this._pipe.write(`${messages.filter(Boolean).join('\n')}\n`); + } + _drawUIOverlay() { + if (this._testAssertions.length === 0) { + return this._drawUIDone(); + } + if (this._testAssertions.length - this._skippedNum === 0) { + return this._drawUIDoneWithSkipped(); + } + return this._drawUIProgress(); + } + put(key) { + switch (key) { + case 's': + if (this._skippedNum === this._testAssertions.length) break; + this._skippedNum += 1; + + // move skipped test to the end + this._testAssertions.push(this._testAssertions.shift()); + if (this._testAssertions.length - this._skippedNum > 0) { + this._run(false); + } else { + this._drawUIDoneWithSkipped(); + } + break; + case 'u': + this._run(true); + break; + case 'q': + case _jestWatcher().KEYS.ESCAPE: + this.abort(); + break; + case 'r': + this.restart(); + break; + case _jestWatcher().KEYS.ENTER: + if (this._testAssertions.length === 0) { + this.abort(); + } else { + this._run(false); + } + break; + default: + break; + } + } + abort() { + this._isActive = false; + this._skippedNum = 0; + this._updateTestRunnerConfig(null, false); + } + restart() { + this._skippedNum = 0; + this._countPaths = this._testAssertions.length; + this._run(false); + } + updateWithResults(results) { + const hasSnapshotFailure = !!results.snapshot.failure; + if (hasSnapshotFailure) { + this._drawUIOverlay(); + return; + } + this._testAssertions.shift(); + if (this._testAssertions.length - this._skippedNum === 0) { + this._drawUIOverlay(); + return; + } + + // Go to the next test + this._run(false); + } + _run(shouldUpdateSnapshot) { + const testAssertion = this._testAssertions[0]; + this._updateTestRunnerConfig(testAssertion, shouldUpdateSnapshot); + } + run(failedSnapshotTestAssertions, onConfigChange) { + if (!failedSnapshotTestAssertions.length) { + return; + } + this._testAssertions = [...failedSnapshotTestAssertions]; + this._countPaths = this._testAssertions.length; + this._updateTestRunnerConfig = onConfigChange; + this._isActive = true; + this._run(false); + } +} +exports.default = SnapshotInteractiveMode; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/TestNamePatternPrompt.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/TestNamePatternPrompt.js new file mode 100644 index 0000000000000000000000000000000000000000..be495ad6f37bf48f1205cafcf375bf5ecd871f70 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/TestNamePatternPrompt.js @@ -0,0 +1,39 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _jestWatcher() { + const data = require('jest-watcher'); + _jestWatcher = function () { + return data; + }; + return data; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class TestNamePatternPrompt extends _jestWatcher().PatternPrompt { + constructor(pipe, prompt) { + super(pipe, prompt, 'tests'); + } + _onChange(pattern, options) { + super._onChange(pattern, options); + this._printPrompt(pattern); + } + _printPrompt(pattern) { + const pipe = this._pipe; + (0, _jestWatcher().printPatternCaret)(pattern, pipe); + (0, _jestWatcher().printRestoredPatternCaret)( + pattern, + this._currentUsageRows, + pipe + ); + } +} +exports.default = TestNamePatternPrompt; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/TestPathPatternPrompt.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/TestPathPatternPrompt.js new file mode 100644 index 0000000000000000000000000000000000000000..648cef0a02ad3ec9fb5d236f422f2001ab6db5c1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/TestPathPatternPrompt.js @@ -0,0 +1,39 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _jestWatcher() { + const data = require('jest-watcher'); + _jestWatcher = function () { + return data; + }; + return data; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class TestPathPatternPrompt extends _jestWatcher().PatternPrompt { + constructor(pipe, prompt) { + super(pipe, prompt, 'filenames'); + } + _onChange(pattern, options) { + super._onChange(pattern, options); + this._printPrompt(pattern); + } + _printPrompt(pattern) { + const pipe = this._pipe; + (0, _jestWatcher().printPatternCaret)(pattern, pipe); + (0, _jestWatcher().printRestoredPatternCaret)( + pattern, + this._currentUsageRows, + pipe + ); + } +} +exports.default = TestPathPatternPrompt; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/TestScheduler.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/TestScheduler.js new file mode 100644 index 0000000000000000000000000000000000000000..26504fe52d121cebbfd7ffc9bc05dfa7f3f97622 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/TestScheduler.js @@ -0,0 +1,463 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.createTestScheduler = createTestScheduler; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _ciInfo() { + const data = require('ci-info'); + _ciInfo = function () { + return data; + }; + return data; +} +function _exit() { + const data = _interopRequireDefault(require('exit')); + _exit = function () { + return data; + }; + return data; +} +function _reporters() { + const data = require('@jest/reporters'); + _reporters = function () { + return data; + }; + return data; +} +function _testResult() { + const data = require('@jest/test-result'); + _testResult = function () { + return data; + }; + return data; +} +function _transform() { + const data = require('@jest/transform'); + _transform = function () { + return data; + }; + return data; +} +function _jestMessageUtil() { + const data = require('jest-message-util'); + _jestMessageUtil = function () { + return data; + }; + return data; +} +function _jestSnapshot() { + const data = require('jest-snapshot'); + _jestSnapshot = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +var _ReporterDispatcher = _interopRequireDefault( + require('./ReporterDispatcher') +); +var _testSchedulerHelper = require('./testSchedulerHelper'); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +async function createTestScheduler(globalConfig, context) { + const scheduler = new TestScheduler(globalConfig, context); + await scheduler._setupReporters(); + return scheduler; +} +class TestScheduler { + _context; + _dispatcher; + _globalConfig; + constructor(globalConfig, context) { + this._context = context; + this._dispatcher = new _ReporterDispatcher.default(); + this._globalConfig = globalConfig; + } + addReporter(reporter) { + this._dispatcher.register(reporter); + } + removeReporter(reporterConstructor) { + this._dispatcher.unregister(reporterConstructor); + } + async scheduleTests(tests, watcher) { + const onTestFileStart = this._dispatcher.onTestFileStart.bind( + this._dispatcher + ); + const timings = []; + const testContexts = new Set(); + tests.forEach(test => { + testContexts.add(test.context); + if (test.duration) { + timings.push(test.duration); + } + }); + const aggregatedResults = createAggregatedResults(tests.length); + const estimatedTime = Math.ceil( + getEstimatedTime(timings, this._globalConfig.maxWorkers) / 1000 + ); + const runInBand = (0, _testSchedulerHelper.shouldRunInBand)( + tests, + timings, + this._globalConfig + ); + const onResult = async (test, testResult) => { + if (watcher.isInterrupted()) { + return Promise.resolve(); + } + if (testResult.testResults.length === 0) { + const message = 'Your test suite must contain at least one test.'; + return onFailure(test, { + message, + stack: new Error(message).stack + }); + } + + // Throws when the context is leaked after executing a test. + if (testResult.leaks) { + const message = + `${_chalk().default.red.bold( + 'EXPERIMENTAL FEATURE!\n' + )}Your test suite is leaking memory. Please ensure all references are cleaned.\n` + + '\n' + + 'There is a number of things that can leak memory:\n' + + ' - Async operations that have not finished (e.g. fs.readFile).\n' + + ' - Timers not properly mocked (e.g. setInterval, setTimeout).\n' + + ' - Keeping references to the global scope.'; + return onFailure(test, { + message, + stack: new Error(message).stack + }); + } + (0, _testResult().addResult)(aggregatedResults, testResult); + await this._dispatcher.onTestFileResult( + test, + testResult, + aggregatedResults + ); + return this._bailIfNeeded(testContexts, aggregatedResults, watcher); + }; + const onFailure = async (test, error) => { + if (watcher.isInterrupted()) { + return; + } + const testResult = (0, _testResult().buildFailureTestResult)( + test.path, + error + ); + testResult.failureMessage = (0, _jestMessageUtil().formatExecError)( + testResult.testExecError, + test.context.config, + this._globalConfig, + test.path + ); + (0, _testResult().addResult)(aggregatedResults, testResult); + await this._dispatcher.onTestFileResult( + test, + testResult, + aggregatedResults + ); + }; + const updateSnapshotState = async () => { + const contextsWithSnapshotResolvers = await Promise.all( + Array.from(testContexts).map(async context => [ + context, + await (0, _jestSnapshot().buildSnapshotResolver)(context.config) + ]) + ); + contextsWithSnapshotResolvers.forEach(([context, snapshotResolver]) => { + const status = (0, _jestSnapshot().cleanup)( + context.hasteFS, + this._globalConfig.updateSnapshot, + snapshotResolver, + context.config.testPathIgnorePatterns + ); + aggregatedResults.snapshot.filesRemoved += status.filesRemoved; + aggregatedResults.snapshot.filesRemovedList = ( + aggregatedResults.snapshot.filesRemovedList || [] + ).concat(status.filesRemovedList); + }); + const updateAll = this._globalConfig.updateSnapshot === 'all'; + aggregatedResults.snapshot.didUpdate = updateAll; + aggregatedResults.snapshot.failure = !!( + !updateAll && + (aggregatedResults.snapshot.unchecked || + aggregatedResults.snapshot.unmatched || + aggregatedResults.snapshot.filesRemoved) + ); + }; + await this._dispatcher.onRunStart(aggregatedResults, { + estimatedTime, + showStatus: !runInBand + }); + const testRunners = Object.create(null); + const contextsByTestRunner = new WeakMap(); + try { + await Promise.all( + Array.from(testContexts).map(async context => { + const {config} = context; + if (!testRunners[config.runner]) { + const transformer = await (0, _transform().createScriptTransformer)( + config + ); + const Runner = await transformer.requireAndTranspileModule( + config.runner + ); + const runner = new Runner(this._globalConfig, { + changedFiles: this._context.changedFiles, + sourcesRelatedToTestsInChangedFiles: + this._context.sourcesRelatedToTestsInChangedFiles + }); + testRunners[config.runner] = runner; + contextsByTestRunner.set(runner, context); + } + }) + ); + const testsByRunner = this._partitionTests(testRunners, tests); + if (testsByRunner) { + try { + for (const runner of Object.keys(testRunners)) { + const testRunner = testRunners[runner]; + const context = contextsByTestRunner.get(testRunner); + (0, _jestUtil().invariant)(context); + const tests = testsByRunner[runner]; + const testRunnerOptions = { + serial: runInBand || Boolean(testRunner.isSerial) + }; + if (testRunner.supportsEventEmitters) { + const unsubscribes = [ + testRunner.on('test-file-start', ([test]) => + onTestFileStart(test) + ), + testRunner.on('test-file-success', ([test, testResult]) => + onResult(test, testResult) + ), + testRunner.on('test-file-failure', ([test, error]) => + onFailure(test, error) + ), + testRunner.on( + 'test-case-start', + ([testPath, testCaseStartInfo]) => { + const test = { + context, + path: testPath + }; + this._dispatcher.onTestCaseStart(test, testCaseStartInfo); + } + ), + testRunner.on( + 'test-case-result', + ([testPath, testCaseResult]) => { + const test = { + context, + path: testPath + }; + this._dispatcher.onTestCaseResult(test, testCaseResult); + } + ) + ]; + await testRunner.runTests(tests, watcher, testRunnerOptions); + unsubscribes.forEach(sub => sub()); + } else { + await testRunner.runTests( + tests, + watcher, + onTestFileStart, + onResult, + onFailure, + testRunnerOptions + ); + } + } + } catch (error) { + if (!watcher.isInterrupted()) { + throw error; + } + } + } + } catch (error) { + aggregatedResults.runExecError = buildExecError(error); + await this._dispatcher.onRunComplete(testContexts, aggregatedResults); + throw error; + } + await updateSnapshotState(); + aggregatedResults.wasInterrupted = watcher.isInterrupted(); + await this._dispatcher.onRunComplete(testContexts, aggregatedResults); + const anyTestFailures = !( + aggregatedResults.numFailedTests === 0 && + aggregatedResults.numRuntimeErrorTestSuites === 0 + ); + const anyReporterErrors = this._dispatcher.hasErrors(); + aggregatedResults.success = !( + anyTestFailures || + aggregatedResults.snapshot.failure || + anyReporterErrors + ); + return aggregatedResults; + } + _partitionTests(testRunners, tests) { + if (Object.keys(testRunners).length > 1) { + return tests.reduce((testRuns, test) => { + const runner = test.context.config.runner; + if (!testRuns[runner]) { + testRuns[runner] = []; + } + testRuns[runner].push(test); + return testRuns; + }, Object.create(null)); + } else if (tests.length > 0 && tests[0] != null) { + // If there is only one runner, don't partition the tests. + return Object.assign(Object.create(null), { + [tests[0].context.config.runner]: tests + }); + } else { + return null; + } + } + async _setupReporters() { + const {collectCoverage: coverage, notify, verbose} = this._globalConfig; + const reporters = this._globalConfig.reporters || [['default', {}]]; + let summaryOptions = null; + for (const [reporter, options] of reporters) { + switch (reporter) { + case 'default': + summaryOptions = options; + verbose + ? this.addReporter( + new (_reporters().VerboseReporter)(this._globalConfig) + ) + : this.addReporter( + new (_reporters().DefaultReporter)(this._globalConfig) + ); + break; + case 'github-actions': + _ciInfo().GITHUB_ACTIONS && + this.addReporter( + new (_reporters().GitHubActionsReporter)( + this._globalConfig, + options + ) + ); + break; + case 'summary': + summaryOptions = options; + break; + default: + await this._addCustomReporter(reporter, options); + } + } + if (notify) { + this.addReporter( + new (_reporters().NotifyReporter)(this._globalConfig, this._context) + ); + } + if (coverage) { + this.addReporter( + new (_reporters().CoverageReporter)(this._globalConfig, this._context) + ); + } + if (summaryOptions != null) { + this.addReporter( + new (_reporters().SummaryReporter)(this._globalConfig, summaryOptions) + ); + } + } + async _addCustomReporter(reporter, options) { + try { + const Reporter = await (0, _jestUtil().requireOrImportModule)(reporter); + this.addReporter( + new Reporter(this._globalConfig, options, this._context) + ); + } catch (error) { + error.message = `An error occurred while adding the reporter at path "${_chalk().default.bold( + reporter + )}".\n${error instanceof Error ? error.message : ''}`; + throw error; + } + } + async _bailIfNeeded(testContexts, aggregatedResults, watcher) { + if ( + this._globalConfig.bail !== 0 && + aggregatedResults.numFailedTests >= this._globalConfig.bail + ) { + if (watcher.isWatchMode()) { + await watcher.setState({ + interrupted: true + }); + return; + } + try { + await this._dispatcher.onRunComplete(testContexts, aggregatedResults); + } finally { + const exitCode = this._globalConfig.testFailureExitCode; + (0, _exit().default)(exitCode); + } + } + } +} +const createAggregatedResults = numTotalTestSuites => { + const result = (0, _testResult().makeEmptyAggregatedTestResult)(); + result.numTotalTestSuites = numTotalTestSuites; + result.startTime = Date.now(); + result.success = false; + return result; +}; +const getEstimatedTime = (timings, workers) => { + if (timings.length === 0) { + return 0; + } + const max = Math.max(...timings); + return timings.length <= workers + ? max + : Math.max(timings.reduce((sum, time) => sum + time) / workers, max); +}; +const strToError = errString => { + const {message, stack} = (0, _jestMessageUtil().separateMessageFromStack)( + errString + ); + if (stack.length > 0) { + return { + message, + stack + }; + } + const error = new (_jestUtil().ErrorWithStack)(message, buildExecError); + return { + message, + stack: error.stack || '' + }; +}; +const buildExecError = err => { + if (typeof err === 'string' || err == null) { + return strToError(err || 'Error'); + } + const anyErr = err; + if (typeof anyErr.message === 'string') { + if (typeof anyErr.stack === 'string' && anyErr.stack.length > 0) { + return anyErr; + } + return strToError(anyErr.message); + } + return strToError(JSON.stringify(err)); +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/cli/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/cli/index.js new file mode 100644 index 0000000000000000000000000000000000000000..2a81dac0b87a980a4ddd7ebfdaa914030816c20a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/cli/index.js @@ -0,0 +1,417 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.runCLI = runCLI; +function _perf_hooks() { + const data = require('perf_hooks'); + _perf_hooks = function () { + return data; + }; + return data; +} +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _exit() { + const data = _interopRequireDefault(require('exit')); + _exit = function () { + return data; + }; + return data; +} +function fs() { + const data = _interopRequireWildcard(require('graceful-fs')); + fs = function () { + return data; + }; + return data; +} +function _console() { + const data = require('@jest/console'); + _console = function () { + return data; + }; + return data; +} +function _jestConfig() { + const data = require('jest-config'); + _jestConfig = function () { + return data; + }; + return data; +} +function _jestRuntime() { + const data = _interopRequireDefault(require('jest-runtime')); + _jestRuntime = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +function _jestWatcher() { + const data = require('jest-watcher'); + _jestWatcher = function () { + return data; + }; + return data; +} +var _collectHandles = require('../collectHandles'); +var _getChangedFilesPromise = _interopRequireDefault( + require('../getChangedFilesPromise') +); +var _getConfigsOfProjectsToRun = _interopRequireDefault( + require('../getConfigsOfProjectsToRun') +); +var _getProjectNamesMissingWarning = _interopRequireDefault( + require('../getProjectNamesMissingWarning') +); +var _getSelectProjectsMessage = _interopRequireDefault( + require('../getSelectProjectsMessage') +); +var _createContext = _interopRequireDefault(require('../lib/createContext')); +var _handleDeprecationWarnings = _interopRequireDefault( + require('../lib/handleDeprecationWarnings') +); +var _logDebugMessages = _interopRequireDefault( + require('../lib/logDebugMessages') +); +var _runJest = _interopRequireDefault(require('../runJest')); +var _watch = _interopRequireDefault(require('../watch')); +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const {print: preRunMessagePrint} = _jestUtil().preRunMessage; +async function runCLI(argv, projects) { + _perf_hooks().performance.mark('jest/runCLI:start'); + let results; + + // If we output a JSON object, we can't write anything to stdout, since + // it'll break the JSON structure and it won't be valid. + const outputStream = + argv.json || argv.useStderr ? process.stderr : process.stdout; + const {globalConfig, configs, hasDeprecationWarnings} = await (0, + _jestConfig().readConfigs)(argv, projects); + if (argv.debug) { + (0, _logDebugMessages.default)(globalConfig, configs, outputStream); + } + if (argv.showConfig) { + (0, _logDebugMessages.default)(globalConfig, configs, process.stdout); + (0, _exit().default)(0); + } + if (argv.clearCache) { + // stick in a Set to dedupe the deletions + new Set(configs.map(config => config.cacheDirectory)).forEach( + cacheDirectory => { + fs().rmSync(cacheDirectory, { + force: true, + recursive: true + }); + process.stdout.write(`Cleared ${cacheDirectory}\n`); + } + ); + (0, _exit().default)(0); + } + const configsOfProjectsToRun = (0, _getConfigsOfProjectsToRun.default)( + configs, + { + ignoreProjects: argv.ignoreProjects, + selectProjects: argv.selectProjects + } + ); + if (argv.selectProjects || argv.ignoreProjects) { + const namesMissingWarning = (0, _getProjectNamesMissingWarning.default)( + configs, + { + ignoreProjects: argv.ignoreProjects, + selectProjects: argv.selectProjects + } + ); + if (namesMissingWarning) { + outputStream.write(namesMissingWarning); + } + outputStream.write( + (0, _getSelectProjectsMessage.default)(configsOfProjectsToRun, { + ignoreProjects: argv.ignoreProjects, + selectProjects: argv.selectProjects + }) + ); + } + await _run10000( + globalConfig, + configsOfProjectsToRun, + hasDeprecationWarnings, + outputStream, + r => { + results = r; + } + ); + if (argv.watch || argv.watchAll) { + // If in watch mode, return the promise that will never resolve. + // If the watch mode is interrupted, watch should handle the process + // shutdown. + // eslint-disable-next-line @typescript-eslint/no-empty-function + return new Promise(() => {}); + } + if (!results) { + throw new Error( + 'AggregatedResult must be present after test run is complete' + ); + } + const {openHandles} = results; + if (openHandles && openHandles.length) { + const formatted = (0, _collectHandles.formatHandleErrors)( + openHandles, + configs[0] + ); + const openHandlesString = (0, _jestUtil().pluralize)( + 'open handle', + formatted.length, + 's' + ); + const message = + _chalk().default.red( + `\nJest has detected the following ${openHandlesString} potentially keeping Jest from exiting:\n\n` + ) + formatted.join('\n\n'); + console.error(message); + } + _perf_hooks().performance.mark('jest/runCLI:end'); + return { + globalConfig, + results + }; +} +const buildContextsAndHasteMaps = async ( + configs, + globalConfig, + outputStream +) => { + const hasteMapInstances = Array(configs.length); + const contexts = await Promise.all( + configs.map(async (config, index) => { + (0, _jestUtil().createDirectory)(config.cacheDirectory); + const hasteMapInstance = await _jestRuntime().default.createHasteMap( + config, + { + console: new (_console().CustomConsole)(outputStream, outputStream), + maxWorkers: Math.max( + 1, + Math.floor(globalConfig.maxWorkers / configs.length) + ), + resetCache: !config.cache, + watch: globalConfig.watch || globalConfig.watchAll, + watchman: globalConfig.watchman, + workerThreads: globalConfig.workerThreads + } + ); + hasteMapInstances[index] = hasteMapInstance; + return (0, _createContext.default)( + config, + await hasteMapInstance.build() + ); + }) + ); + return { + contexts, + hasteMapInstances + }; +}; +const _run10000 = async ( + globalConfig, + configs, + hasDeprecationWarnings, + outputStream, + onComplete +) => { + // Queries to hg/git can take a while, so we need to start the process + // as soon as possible, so by the time we need the result it's already there. + const changedFilesPromise = (0, _getChangedFilesPromise.default)( + globalConfig, + configs + ); + if (changedFilesPromise) { + _perf_hooks().performance.mark('jest/getChangedFiles:start'); + changedFilesPromise.finally(() => { + _perf_hooks().performance.mark('jest/getChangedFiles:end'); + }); + } + + // Filter may need to do an HTTP call or something similar to setup. + // We will wait on an async response from this before using the filter. + let filter; + if (globalConfig.filter && !globalConfig.skipFilter) { + const rawFilter = require(globalConfig.filter); + let filterSetupPromise; + if (rawFilter.setup) { + // Wrap filter setup Promise to avoid "uncaught Promise" error. + // If an error is returned, we surface it in the return value. + filterSetupPromise = (async () => { + try { + await rawFilter.setup(); + } catch (err) { + return err; + } + return undefined; + })(); + } + filter = async testPaths => { + if (filterSetupPromise) { + // Expect an undefined return value unless there was an error. + const err = await filterSetupPromise; + if (err) { + throw err; + } + } + return rawFilter(testPaths); + }; + } + _perf_hooks().performance.mark('jest/buildContextsAndHasteMaps:start'); + const {contexts, hasteMapInstances} = await buildContextsAndHasteMaps( + configs, + globalConfig, + outputStream + ); + _perf_hooks().performance.mark('jest/buildContextsAndHasteMaps:end'); + globalConfig.watch || globalConfig.watchAll + ? await runWatch( + contexts, + configs, + hasDeprecationWarnings, + globalConfig, + outputStream, + hasteMapInstances, + filter + ) + : await runWithoutWatch( + globalConfig, + contexts, + outputStream, + onComplete, + changedFilesPromise, + filter + ); +}; +const runWatch = async ( + contexts, + _configs, + hasDeprecationWarnings, + globalConfig, + outputStream, + hasteMapInstances, + filter +) => { + if (hasDeprecationWarnings) { + try { + await (0, _handleDeprecationWarnings.default)( + outputStream, + process.stdin + ); + return await (0, _watch.default)( + globalConfig, + contexts, + outputStream, + hasteMapInstances, + undefined, + undefined, + filter + ); + } catch { + (0, _exit().default)(0); + } + } + return (0, _watch.default)( + globalConfig, + contexts, + outputStream, + hasteMapInstances, + undefined, + undefined, + filter + ); +}; +const runWithoutWatch = async ( + globalConfig, + contexts, + outputStream, + onComplete, + changedFilesPromise, + filter +) => { + const startRun = async () => { + if (!globalConfig.listTests) { + preRunMessagePrint(outputStream); + } + return (0, _runJest.default)({ + changedFilesPromise, + contexts, + failedTestsCache: undefined, + filter, + globalConfig, + onComplete, + outputStream, + startRun, + testWatcher: new (_jestWatcher().TestWatcher)({ + isWatchMode: false + }) + }); + }; + return startRun(); +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/collectHandles.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/collectHandles.js new file mode 100644 index 0000000000000000000000000000000000000000..ab371b6f23d5975f643a6743eb67727a9966b0c1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/collectHandles.js @@ -0,0 +1,266 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = collectHandles; +exports.formatHandleErrors = formatHandleErrors; +function asyncHooks() { + const data = _interopRequireWildcard(require('async_hooks')); + asyncHooks = function () { + return data; + }; + return data; +} +function _util() { + const data = require('util'); + _util = function () { + return data; + }; + return data; +} +function v8() { + const data = _interopRequireWildcard(require('v8')); + v8 = function () { + return data; + }; + return data; +} +function vm() { + const data = _interopRequireWildcard(require('vm')); + vm = function () { + return data; + }; + return data; +} +function _stripAnsi() { + const data = _interopRequireDefault(require('strip-ansi')); + _stripAnsi = function () { + return data; + }; + return data; +} +function _jestMessageUtil() { + const data = require('jest-message-util'); + _jestMessageUtil = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +/* eslint-disable local/ban-types-eventually */ + +function stackIsFromUser(stack) { + // Either the test file, or something required by it + if (stack.includes('Runtime.requireModule')) { + return true; + } + + // jest-jasmine it or describe call + if (stack.includes('asyncJestTest') || stack.includes('asyncJestLifecycle')) { + return true; + } + + // An async function call from within circus + if (stack.includes('callAsyncCircusFn')) { + // jest-circus it or describe call + return ( + stack.includes('_callCircusTest') || stack.includes('_callCircusHook') + ); + } + return false; +} +const alwaysActive = () => true; + +// @ts-expect-error: doesn't exist in v12 typings +const hasWeakRef = typeof WeakRef === 'function'; +const asyncSleep = (0, _util().promisify)(setTimeout); +let gcFunc = globalThis.gc; +function runGC() { + if (!gcFunc) { + v8().setFlagsFromString('--expose-gc'); + gcFunc = vm().runInNewContext('gc'); + v8().setFlagsFromString('--no-expose-gc'); + if (!gcFunc) { + throw new Error( + 'Cannot find `global.gc` function. Please run node with `--expose-gc` and report this issue in jest repo.' + ); + } + } + gcFunc(); +} + +// Inspired by https://github.com/mafintosh/why-is-node-running/blob/master/index.js +// Extracted as we want to format the result ourselves +function collectHandles() { + const activeHandles = new Map(); + const hook = asyncHooks().createHook({ + destroy(asyncId) { + activeHandles.delete(asyncId); + }, + init: function initHook(asyncId, type, triggerAsyncId, resource) { + // Skip resources that should not generally prevent the process from + // exiting, not last a meaningfully long time, or otherwise shouldn't be + // tracked. + if ( + type === 'PROMISE' || + type === 'TIMERWRAP' || + type === 'ELDHISTOGRAM' || + type === 'PerformanceObserver' || + type === 'RANDOMBYTESREQUEST' || + type === 'DNSCHANNEL' || + type === 'ZLIB' || + type === 'SIGNREQUEST' + ) { + return; + } + const error = new (_jestUtil().ErrorWithStack)(type, initHook, 100); + let fromUser = stackIsFromUser(error.stack || ''); + + // If the async resource was not directly created by user code, but was + // triggered by another async resource from user code, track it and use + // the original triggering resource's stack. + if (!fromUser) { + const triggeringHandle = activeHandles.get(triggerAsyncId); + if (triggeringHandle) { + fromUser = true; + error.stack = triggeringHandle.error.stack; + } + } + if (fromUser) { + let isActive; + + // Handle that supports hasRef + if ('hasRef' in resource) { + if (hasWeakRef) { + // @ts-expect-error: doesn't exist in v12 typings + const ref = new WeakRef(resource); + isActive = () => { + return ref.deref()?.hasRef() ?? false; + }; + } else { + isActive = resource.hasRef.bind(resource); + } + } else { + // Handle that doesn't support hasRef + isActive = alwaysActive; + } + activeHandles.set(asyncId, { + error, + isActive + }); + } + } + }); + hook.enable(); + return async () => { + // Wait briefly for any async resources that have been queued for + // destruction to actually be destroyed. + // For example, Node.js TCP Servers are not destroyed until *after* their + // `close` callback runs. If someone finishes a test from the `close` + // callback, we will not yet have seen the resource be destroyed here. + await asyncSleep(100); + if (activeHandles.size > 0) { + // For some special objects such as `TLSWRAP`. + // Ref: https://github.com/jestjs/jest/issues/11665 + runGC(); + await asyncSleep(0); + } + hook.disable(); + + // Get errors for every async resource still referenced at this moment + const result = Array.from(activeHandles.values()) + .filter(({isActive}) => isActive()) + .map(({error}) => error); + activeHandles.clear(); + return result; + }; +} +function formatHandleErrors(errors, config) { + const stacks = new Set(); + return ( + errors + .map(err => + (0, _jestMessageUtil().formatExecError)( + err, + config, + { + noStackTrace: false + }, + undefined, + true + ) + ) + // E.g. timeouts might give multiple traces to the same line of code + // This hairy filtering tries to remove entries with duplicate stack traces + .filter(handle => { + const ansiFree = (0, _stripAnsi().default)(handle); + const match = ansiFree.match(/\s+at(.*)/); + if (!match || match.length < 2) { + return true; + } + const stack = ansiFree.substr(ansiFree.indexOf(match[1])).trim(); + if (stacks.has(stack)) { + return false; + } + stacks.add(stack); + return true; + }) + ); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getChangedFilesPromise.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getChangedFilesPromise.js new file mode 100644 index 0000000000000000000000000000000000000000..aed28f569344c9357bde9b4113138faff7e7119e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getChangedFilesPromise.js @@ -0,0 +1,65 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getChangedFilesPromise; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _jestChangedFiles() { + const data = require('jest-changed-files'); + _jestChangedFiles = function () { + return data; + }; + return data; +} +function _jestMessageUtil() { + const data = require('jest-message-util'); + _jestMessageUtil = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function getChangedFilesPromise(globalConfig, configs) { + if (globalConfig.onlyChanged) { + const allRootsForAllProjects = configs.reduce((roots, config) => { + if (config.roots) { + roots.push(...config.roots); + } + return roots; + }, []); + return (0, _jestChangedFiles().getChangedFilesForRoots)( + allRootsForAllProjects, + { + changedSince: globalConfig.changedSince, + lastCommit: globalConfig.lastCommit, + withAncestor: globalConfig.changedFilesWithAncestor + } + ).catch(e => { + const message = (0, _jestMessageUtil().formatExecError)(e, configs[0], { + noStackTrace: true + }) + .split('\n') + .filter(line => !line.includes('Command failed:')) + .join('\n'); + console.error(_chalk().default.red(`\n\n${message}`)); + process.exit(1); + }); + } + return undefined; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getConfigsOfProjectsToRun.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getConfigsOfProjectsToRun.js new file mode 100644 index 0000000000000000000000000000000000000000..c07702eccb1b6c8c04012f9e3a619fd5d2a577b6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getConfigsOfProjectsToRun.js @@ -0,0 +1,40 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getConfigsOfProjectsToRun; +var _getProjectDisplayName = _interopRequireDefault( + require('./getProjectDisplayName') +); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function getConfigsOfProjectsToRun(projectConfigs, opts) { + const projectFilter = createProjectFilter(opts); + return projectConfigs.filter(config => { + const name = (0, _getProjectDisplayName.default)(config); + return projectFilter(name); + }); +} +function createProjectFilter(opts) { + const {selectProjects, ignoreProjects} = opts; + const always = () => true; + const selected = selectProjects + ? name => name && selectProjects.includes(name) + : always; + const notIgnore = ignoreProjects + ? name => !(name && ignoreProjects.includes(name)) + : always; + function test(name) { + return selected(name) && notIgnore(name); + } + return test; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getNoTestFound.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getNoTestFound.js new file mode 100644 index 0000000000000000000000000000000000000000..b84c23c4ed43736d66240a3e0e56d3f241ba845f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getNoTestFound.js @@ -0,0 +1,80 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getNoTestFound; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function getNoTestFound(testRunData, globalConfig, willExitWith0) { + const testFiles = testRunData.reduce( + (current, testRun) => current + (testRun.matches.total || 0), + 0 + ); + let dataMessage; + if (globalConfig.runTestsByPath) { + dataMessage = `Files: ${globalConfig.nonFlagArgs + .map(p => `"${p}"`) + .join(', ')}`; + } else { + dataMessage = `Pattern: ${_chalk().default.yellow( + globalConfig.testPathPattern + )} - 0 matches`; + } + if (willExitWith0) { + return ( + `${_chalk().default.bold('No tests found, exiting with code 0')}\n` + + `In ${_chalk().default.bold(globalConfig.rootDir)}` + + '\n' + + ` ${(0, _jestUtil().pluralize)( + 'file', + testFiles, + 's' + )} checked across ${(0, _jestUtil().pluralize)( + 'project', + testRunData.length, + 's' + )}. Run with \`--verbose\` for more details.` + + `\n${dataMessage}` + ); + } + return ( + `${_chalk().default.bold('No tests found, exiting with code 1')}\n` + + 'Run with `--passWithNoTests` to exit with code 0' + + '\n' + + `In ${_chalk().default.bold(globalConfig.rootDir)}` + + '\n' + + ` ${(0, _jestUtil().pluralize)( + 'file', + testFiles, + 's' + )} checked across ${(0, _jestUtil().pluralize)( + 'project', + testRunData.length, + 's' + )}. Run with \`--verbose\` for more details.` + + `\n${dataMessage}` + ); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getNoTestFoundFailed.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getNoTestFoundFailed.js new file mode 100644 index 0000000000000000000000000000000000000000..1c8cc61c03ec82c379ef0b08d11644d180daec58 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getNoTestFoundFailed.js @@ -0,0 +1,43 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getNoTestFoundFailed; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function getNoTestFoundFailed(globalConfig) { + let msg = _chalk().default.bold('No failed test found.'); + if (_jestUtil().isInteractive) { + msg += _chalk().default.dim( + `\n${ + globalConfig.watch + ? 'Press `f` to quit "only failed tests" mode.' + : 'Run Jest without `--onlyFailures` or with `--all` to run all tests.' + }` + ); + } + return msg; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getNoTestFoundPassWithNoTests.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getNoTestFoundPassWithNoTests.js new file mode 100644 index 0000000000000000000000000000000000000000..b0c36287d70cbfa30619a0c9f24f05b10708d0a0 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getNoTestFoundPassWithNoTests.js @@ -0,0 +1,26 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getNoTestFoundPassWithNoTests; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function getNoTestFoundPassWithNoTests() { + return _chalk().default.bold('No tests found, exiting with code 0'); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getNoTestFoundRelatedToChangedFiles.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getNoTestFoundRelatedToChangedFiles.js new file mode 100644 index 0000000000000000000000000000000000000000..334561f14e31933f2766c4b6ad7254873a8a9e96 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getNoTestFoundRelatedToChangedFiles.js @@ -0,0 +1,48 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getNoTestFoundRelatedToChangedFiles; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function getNoTestFoundRelatedToChangedFiles(globalConfig) { + const ref = globalConfig.changedSince + ? `"${globalConfig.changedSince}"` + : 'last commit'; + let msg = _chalk().default.bold( + `No tests found related to files changed since ${ref}.` + ); + if (_jestUtil().isInteractive) { + msg += _chalk().default.dim( + `\n${ + globalConfig.watch + ? 'Press `a` to run all tests, or run Jest with `--watchAll`.' + : 'Run Jest without `-o` or with `--all` to run all tests.' + }` + ); + } + return msg; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getNoTestFoundVerbose.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getNoTestFoundVerbose.js new file mode 100644 index 0000000000000000000000000000000000000000..414602cebbae3d37cf0f35238e681be9c83c56fb --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getNoTestFoundVerbose.js @@ -0,0 +1,91 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getNoTestFoundVerbose; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function getNoTestFoundVerbose(testRunData, globalConfig, willExitWith0) { + const individualResults = testRunData.map(testRun => { + const stats = testRun.matches.stats || {}; + const config = testRun.context.config; + const statsMessage = Object.keys(stats) + .map(key => { + if (key === 'roots' && config.roots.length === 1) { + return null; + } + const value = config[key]; + if (value) { + const valueAsString = Array.isArray(value) + ? value.join(', ') + : String(value); + const matches = (0, _jestUtil().pluralize)( + 'match', + stats[key] || 0, + 'es' + ); + return ` ${key}: ${_chalk().default.yellow( + valueAsString + )} - ${matches}`; + } + return null; + }) + .filter(line => line) + .join('\n'); + return testRun.matches.total + ? `In ${_chalk().default.bold(config.rootDir)}\n` + + ` ${(0, _jestUtil().pluralize)( + 'file', + testRun.matches.total || 0, + 's' + )} checked.\n${statsMessage}` + : `No files found in ${config.rootDir}.\n` + + "Make sure Jest's configuration does not exclude this directory." + + '\nTo set up Jest, make sure a package.json file exists.\n' + + 'Jest Documentation: ' + + 'https://jestjs.io/docs/configuration'; + }); + let dataMessage; + if (globalConfig.runTestsByPath) { + dataMessage = `Files: ${globalConfig.nonFlagArgs + .map(p => `"${p}"`) + .join(', ')}`; + } else { + dataMessage = `Pattern: ${_chalk().default.yellow( + globalConfig.testPathPattern + )} - 0 matches`; + } + if (willExitWith0) { + return `${_chalk().default.bold( + 'No tests found, exiting with code 0' + )}\n${individualResults.join('\n')}\n${dataMessage}`; + } + return ( + `${_chalk().default.bold('No tests found, exiting with code 1')}\n` + + 'Run with `--passWithNoTests` to exit with code 0' + + `\n${individualResults.join('\n')}\n${dataMessage}` + ); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getNoTestsFoundMessage.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getNoTestsFoundMessage.js new file mode 100644 index 0000000000000000000000000000000000000000..60f09a21569567e126693dde290a07a2a5251003 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getNoTestsFoundMessage.js @@ -0,0 +1,64 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getNoTestsFoundMessage; +var _getNoTestFound = _interopRequireDefault(require('./getNoTestFound')); +var _getNoTestFoundFailed = _interopRequireDefault( + require('./getNoTestFoundFailed') +); +var _getNoTestFoundPassWithNoTests = _interopRequireDefault( + require('./getNoTestFoundPassWithNoTests') +); +var _getNoTestFoundRelatedToChangedFiles = _interopRequireDefault( + require('./getNoTestFoundRelatedToChangedFiles') +); +var _getNoTestFoundVerbose = _interopRequireDefault( + require('./getNoTestFoundVerbose') +); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function getNoTestsFoundMessage(testRunData, globalConfig) { + const exitWith0 = + globalConfig.passWithNoTests || + globalConfig.lastCommit || + globalConfig.onlyChanged; + if (globalConfig.onlyFailures) { + return { + exitWith0, + message: (0, _getNoTestFoundFailed.default)(globalConfig) + }; + } + if (globalConfig.onlyChanged) { + return { + exitWith0, + message: (0, _getNoTestFoundRelatedToChangedFiles.default)(globalConfig) + }; + } + if (globalConfig.passWithNoTests) { + return { + exitWith0, + message: (0, _getNoTestFoundPassWithNoTests.default)() + }; + } + return { + exitWith0, + message: + testRunData.length === 1 || globalConfig.verbose + ? (0, _getNoTestFoundVerbose.default)( + testRunData, + globalConfig, + exitWith0 + ) + : (0, _getNoTestFound.default)(testRunData, globalConfig, exitWith0) + }; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getProjectDisplayName.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getProjectDisplayName.js new file mode 100644 index 0000000000000000000000000000000000000000..b5857033e0963ac9618c0d77a3114d0cdfce162c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getProjectDisplayName.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getProjectDisplayName; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function getProjectDisplayName(projectConfig) { + return projectConfig.displayName?.name || undefined; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getProjectNamesMissingWarning.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getProjectNamesMissingWarning.js new file mode 100644 index 0000000000000000000000000000000000000000..6efed637700848bc1b165eaef88ff725612c818b --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getProjectNamesMissingWarning.js @@ -0,0 +1,49 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getProjectNamesMissingWarning; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +var _getProjectDisplayName = _interopRequireDefault( + require('./getProjectDisplayName') +); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function getProjectNamesMissingWarning(projectConfigs, opts) { + const numberOfProjectsWithoutAName = projectConfigs.filter( + config => !(0, _getProjectDisplayName.default)(config) + ).length; + if (numberOfProjectsWithoutAName === 0) { + return undefined; + } + const args = []; + if (opts.selectProjects) { + args.push('--selectProjects'); + } + if (opts.ignoreProjects) { + args.push('--ignoreProjects'); + } + return _chalk().default.yellow( + `You provided values for ${args.join(' and ')} but ${ + numberOfProjectsWithoutAName === 1 + ? 'a project does not have a name' + : `${numberOfProjectsWithoutAName} projects do not have a name` + }.\n` + + 'Set displayName in the config of all projects in order to disable this warning.\n' + ); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getSelectProjectsMessage.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getSelectProjectsMessage.js new file mode 100644 index 0000000000000000000000000000000000000000..5f3f0ad85b79bdc5ab950af2425049f4978197d2 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/getSelectProjectsMessage.js @@ -0,0 +1,71 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getSelectProjectsMessage; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +var _getProjectDisplayName = _interopRequireDefault( + require('./getProjectDisplayName') +); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function getSelectProjectsMessage(projectConfigs, opts) { + if (projectConfigs.length === 0) { + return getNoSelectionWarning(opts); + } + return getProjectsRunningMessage(projectConfigs); +} +function getNoSelectionWarning(opts) { + if (opts.ignoreProjects && opts.selectProjects) { + return _chalk().default.yellow( + 'You provided values for --selectProjects and --ignoreProjects, but no projects were found matching the selection.\n' + + 'Are you ignoring all the selected projects?\n' + ); + } else if (opts.ignoreProjects) { + return _chalk().default.yellow( + 'You provided values for --ignoreProjects, but no projects were found matching the selection.\n' + + 'Are you ignoring all projects?\n' + ); + } else if (opts.selectProjects) { + return _chalk().default.yellow( + 'You provided values for --selectProjects but no projects were found matching the selection.\n' + ); + } else { + return _chalk().default.yellow('No projects were found.\n'); + } +} +function getProjectsRunningMessage(projectConfigs) { + if (projectConfigs.length === 1) { + const name = + (0, _getProjectDisplayName.default)(projectConfigs[0]) ?? + ''; + return `Running one project: ${_chalk().default.bold(name)}\n`; + } + const projectsList = projectConfigs + .map(getProjectNameListElement) + .sort() + .join('\n'); + return `Running ${projectConfigs.length} projects:\n${projectsList}\n`; +} +function getProjectNameListElement(projectConfig) { + const name = (0, _getProjectDisplayName.default)(projectConfig); + const elementContent = name + ? _chalk().default.bold(name) + : ''; + return `- ${elementContent}`; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..19d9ba34db49687129e0dcbfcaf8972d4860d16b --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/index.d.ts @@ -0,0 +1,118 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +import {AggregatedResult} from '@jest/test-result'; +import {BaseReporter} from '@jest/reporters'; +import type {ChangedFiles} from 'jest-changed-files'; +import type {Config} from '@jest/types'; +import {Reporter} from '@jest/reporters'; +import {ReporterContext} from '@jest/reporters'; +import {Test} from '@jest/test-result'; +import type {TestContext} from '@jest/test-result'; +import type {TestRunnerContext} from 'jest-runner'; +import type {TestWatcher} from 'jest-watcher'; + +export declare function createTestScheduler( + globalConfig: Config.GlobalConfig, + context: TestSchedulerContext, +): Promise; + +declare type Filter = (testPaths: Array) => Promise<{ + filtered: Array; +}>; + +declare type FilterResult = { + test: string; + message: string; +}; + +export declare function getVersion(): string; + +declare type ReporterConstructor = new ( + globalConfig: Config.GlobalConfig, + reporterConfig: Record, + reporterContext: ReporterContext, +) => BaseReporter; + +export declare function runCLI( + argv: Config.Argv, + projects: Array, +): Promise<{ + results: AggregatedResult; + globalConfig: Config.GlobalConfig; +}>; + +declare type SearchResult = { + noSCM?: boolean; + stats?: Stats; + collectCoverageFrom?: Set; + tests: Array; + total?: number; +}; + +export declare class SearchSource { + private readonly _context; + private _dependencyResolver; + private readonly _testPathCases; + constructor(context: TestContext); + private _getOrBuildDependencyResolver; + private _filterTestPathsWithStats; + private _getAllTestPaths; + isTestFilePath(path: string): boolean; + findMatchingTests(testPathPattern: string): SearchResult; + findRelatedTests( + allPaths: Set, + collectCoverage: boolean, + ): Promise; + findTestsByPaths(paths: Array): SearchResult; + findRelatedTestsFromPattern( + paths: Array, + collectCoverage: boolean, + ): Promise; + findTestRelatedToChangedFiles( + changedFilesInfo: ChangedFiles, + collectCoverage: boolean, + ): Promise; + private _getTestPaths; + filterPathsWin32(paths: Array): Array; + getTestPaths( + globalConfig: Config.GlobalConfig, + changedFiles?: ChangedFiles, + filter?: Filter, + ): Promise; + findRelatedSourcesFromTestsInChangedFiles( + changedFilesInfo: ChangedFiles, + ): Promise>; +} + +declare type Stats = { + roots: number; + testMatch: number; + testPathIgnorePatterns: number; + testRegex: number; + testPathPattern?: number; +}; + +declare class TestScheduler { + private readonly _context; + private readonly _dispatcher; + private readonly _globalConfig; + constructor(globalConfig: Config.GlobalConfig, context: TestSchedulerContext); + addReporter(reporter: Reporter): void; + removeReporter(reporterConstructor: ReporterConstructor): void; + scheduleTests( + tests: Array, + watcher: TestWatcher, + ): Promise; + private _partitionTests; + _setupReporters(): Promise; + private _addCustomReporter; + private _bailIfNeeded; +} + +declare type TestSchedulerContext = ReporterContext & TestRunnerContext; + +export {}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..e6a0fe59c8d95ad972932502c51d82364f018413 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/index.js @@ -0,0 +1,36 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +Object.defineProperty(exports, 'SearchSource', { + enumerable: true, + get: function () { + return _SearchSource.default; + } +}); +Object.defineProperty(exports, 'createTestScheduler', { + enumerable: true, + get: function () { + return _TestScheduler.createTestScheduler; + } +}); +Object.defineProperty(exports, 'getVersion', { + enumerable: true, + get: function () { + return _version.default; + } +}); +Object.defineProperty(exports, 'runCLI', { + enumerable: true, + get: function () { + return _cli.runCLI; + } +}); +var _SearchSource = _interopRequireDefault(require('./SearchSource')); +var _TestScheduler = require('./TestScheduler'); +var _cli = require('./cli'); +var _version = _interopRequireDefault(require('./version')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/lib/activeFiltersMessage.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/lib/activeFiltersMessage.js new file mode 100644 index 0000000000000000000000000000000000000000..2984f0916593c0b517c7349389526be97fdca3f5 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/lib/activeFiltersMessage.js @@ -0,0 +1,52 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const activeFilters = globalConfig => { + const {testNamePattern, testPathPattern} = globalConfig; + if (testNamePattern || testPathPattern) { + const filters = [ + testPathPattern + ? _chalk().default.dim('filename ') + + _chalk().default.yellow(`/${testPathPattern}/`) + : null, + testNamePattern + ? _chalk().default.dim('test name ') + + _chalk().default.yellow(`/${testNamePattern}/`) + : null + ] + .filter(_jestUtil().isNonNullable) + .join(', '); + const messages = `\n${_chalk().default.bold('Active Filters: ')}${filters}`; + return messages; + } + return ''; +}; +var _default = activeFilters; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/lib/createContext.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/lib/createContext.js new file mode 100644 index 0000000000000000000000000000000000000000..67d416d5a8fd69293486e361fa39d082b96fd8ef --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/lib/createContext.js @@ -0,0 +1,31 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = createContext; +function _jestRuntime() { + const data = _interopRequireDefault(require('jest-runtime')); + _jestRuntime = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function createContext(config, {hasteFS, moduleMap}) { + return { + config, + hasteFS, + moduleMap, + resolver: _jestRuntime().default.createResolver(config, moduleMap) + }; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/lib/handleDeprecationWarnings.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/lib/handleDeprecationWarnings.js new file mode 100644 index 0000000000000000000000000000000000000000..7d4dc1b7b19c672fef714429bb1b3ac770251b2b --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/lib/handleDeprecationWarnings.js @@ -0,0 +1,65 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = handleDeprecationWarnings; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _jestWatcher() { + const data = require('jest-watcher'); + _jestWatcher = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function handleDeprecationWarnings(pipe, stdin = process.stdin) { + return new Promise((resolve, reject) => { + if (typeof stdin.setRawMode === 'function') { + const messages = [ + _chalk().default.red('There are deprecation warnings.\n'), + `${_chalk().default.dim(' \u203A Press ')}Enter${_chalk().default.dim( + ' to continue.' + )}`, + `${_chalk().default.dim(' \u203A Press ')}Esc${_chalk().default.dim( + ' to exit.' + )}` + ]; + pipe.write(messages.join('\n')); + stdin.setRawMode(true); + stdin.resume(); + stdin.setEncoding('utf8'); + // this is a string since we set encoding above + stdin.on('data', key => { + if (key === _jestWatcher().KEYS.ENTER) { + resolve(); + } else if ( + [ + _jestWatcher().KEYS.ESCAPE, + _jestWatcher().KEYS.CONTROL_C, + _jestWatcher().KEYS.CONTROL_D + ].indexOf(key) !== -1 + ) { + reject(); + } + }); + } else { + resolve(); + } + }); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/lib/isValidPath.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/lib/isValidPath.js new file mode 100644 index 0000000000000000000000000000000000000000..fd2f91ca72d0e6164ebdcd3ca9e872a021b9d3d5 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/lib/isValidPath.js @@ -0,0 +1,26 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = isValidPath; +function _jestSnapshot() { + const data = require('jest-snapshot'); + _jestSnapshot = function () { + return data; + }; + return data; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function isValidPath(globalConfig, filePath) { + return ( + !filePath.includes(globalConfig.coverageDirectory) && + !(0, _jestSnapshot().isSnapshotPath)(filePath) + ); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/lib/logDebugMessages.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/lib/logDebugMessages.js new file mode 100644 index 0000000000000000000000000000000000000000..ab8fd0fd8563c62d8ea76d9d59ded90df47c11cc --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/lib/logDebugMessages.js @@ -0,0 +1,24 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = logDebugMessages; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const VERSION = require('../../package.json').version; + +// if the output here changes, update `getConfig` in e2e/runJest.ts +function logDebugMessages(globalConfig, configs, outputStream) { + const output = { + configs, + globalConfig, + version: VERSION + }; + outputStream.write(`${JSON.stringify(output, null, ' ')}\n`); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/lib/updateGlobalConfig.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/lib/updateGlobalConfig.js new file mode 100644 index 0000000000000000000000000000000000000000..38bdc4fa8bc51a9790ce8e83ade70fb9820f8a04 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/lib/updateGlobalConfig.js @@ -0,0 +1,95 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = updateGlobalConfig; +function _jestRegexUtil() { + const data = require('jest-regex-util'); + _jestRegexUtil = function () { + return data; + }; + return data; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function updateGlobalConfig(globalConfig, options = {}) { + const newConfig = { + ...globalConfig + }; + if (options.mode === 'watch') { + newConfig.watch = true; + newConfig.watchAll = false; + } else if (options.mode === 'watchAll') { + newConfig.watch = false; + newConfig.watchAll = true; + } + if (options.testNamePattern !== undefined) { + newConfig.testNamePattern = options.testNamePattern || ''; + } + if (options.testPathPattern !== undefined) { + newConfig.testPathPattern = + (0, _jestRegexUtil().replacePathSepForRegex)(options.testPathPattern) || + ''; + } + newConfig.onlyChanged = + !newConfig.watchAll && + !newConfig.testNamePattern && + !newConfig.testPathPattern; + if (typeof options.bail === 'boolean') { + newConfig.bail = options.bail ? 1 : 0; + } else if (options.bail !== undefined) { + newConfig.bail = options.bail; + } + if (options.changedSince !== undefined) { + newConfig.changedSince = options.changedSince; + } + if (options.collectCoverage !== undefined) { + newConfig.collectCoverage = options.collectCoverage || false; + } + if (options.collectCoverageFrom !== undefined) { + newConfig.collectCoverageFrom = options.collectCoverageFrom; + } + if (options.coverageDirectory !== undefined) { + newConfig.coverageDirectory = options.coverageDirectory; + } + if (options.coverageReporters !== undefined) { + newConfig.coverageReporters = options.coverageReporters; + } + if (options.findRelatedTests !== undefined) { + newConfig.findRelatedTests = options.findRelatedTests; + } + if (options.nonFlagArgs !== undefined) { + newConfig.nonFlagArgs = options.nonFlagArgs; + } + if (options.noSCM) { + newConfig.noSCM = true; + } + if (options.notify !== undefined) { + newConfig.notify = options.notify || false; + } + if (options.notifyMode !== undefined) { + newConfig.notifyMode = options.notifyMode; + } + if (options.onlyFailures !== undefined) { + newConfig.onlyFailures = options.onlyFailures || false; + } + if (options.passWithNoTests !== undefined) { + newConfig.passWithNoTests = true; + } + if (options.reporters !== undefined) { + newConfig.reporters = options.reporters; + } + if (options.updateSnapshot !== undefined) { + newConfig.updateSnapshot = options.updateSnapshot; + } + if (options.verbose !== undefined) { + newConfig.verbose = options.verbose || false; + } + return Object.freeze(newConfig); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/lib/watchPluginsHelpers.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/lib/watchPluginsHelpers.js new file mode 100644 index 0000000000000000000000000000000000000000..db8454cd0243efe163cc2117ce7928ec2bd108a0 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/lib/watchPluginsHelpers.js @@ -0,0 +1,56 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.getSortedUsageRows = exports.filterInteractivePlugins = void 0; +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const filterInteractivePlugins = (watchPlugins, globalConfig) => { + const usageInfos = watchPlugins.map( + p => p.getUsageInfo && p.getUsageInfo(globalConfig) + ); + return watchPlugins.filter((_plugin, i) => { + const usageInfo = usageInfos[i]; + if (usageInfo) { + const {key} = usageInfo; + return !usageInfos.slice(i + 1).some(u => !!u && key === u.key); + } + return false; + }); +}; +exports.filterInteractivePlugins = filterInteractivePlugins; +const getSortedUsageRows = (watchPlugins, globalConfig) => + filterInteractivePlugins(watchPlugins, globalConfig) + .sort((a, b) => { + if (a.isInternal && b.isInternal) { + // internal plugins in the order we specify them + return 0; + } + if (a.isInternal !== b.isInternal) { + // external plugins afterwards + return a.isInternal ? -1 : 1; + } + const usageInfoA = a.getUsageInfo && a.getUsageInfo(globalConfig); + const usageInfoB = b.getUsageInfo && b.getUsageInfo(globalConfig); + if (usageInfoA && usageInfoB) { + // external plugins in alphabetical order + return usageInfoA.key.localeCompare(usageInfoB.key); + } + return 0; + }) + .map(p => p.getUsageInfo && p.getUsageInfo(globalConfig)) + .filter(_jestUtil().isNonNullable); +exports.getSortedUsageRows = getSortedUsageRows; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/plugins/FailedTestsInteractive.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/plugins/FailedTestsInteractive.js new file mode 100644 index 0000000000000000000000000000000000000000..8e71740a18514da882866214d24c31981e1ee5da --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/plugins/FailedTestsInteractive.js @@ -0,0 +1,96 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _jestWatcher() { + const data = require('jest-watcher'); + _jestWatcher = function () { + return data; + }; + return data; +} +var _FailedTestsInteractiveMode = _interopRequireDefault( + require('../FailedTestsInteractiveMode') +); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class FailedTestsInteractivePlugin extends _jestWatcher().BaseWatchPlugin { + _failedTestAssertions; + _manager = new _FailedTestsInteractiveMode.default(this._stdout); + apply(hooks) { + hooks.onTestRunComplete(results => { + this._failedTestAssertions = this.getFailedTestAssertions(results); + if (this._manager.isActive()) this._manager.updateWithResults(results); + }); + } + getUsageInfo() { + if (this._failedTestAssertions?.length) { + return { + key: 'i', + prompt: 'run failing tests interactively' + }; + } + return null; + } + onKey(key) { + if (this._manager.isActive()) { + this._manager.put(key); + } + } + run(_, updateConfigAndRun) { + return new Promise(resolve => { + if ( + !this._failedTestAssertions || + this._failedTestAssertions.length === 0 + ) { + resolve(); + return; + } + this._manager.run(this._failedTestAssertions, failure => { + updateConfigAndRun({ + mode: 'watch', + testNamePattern: failure ? `^${failure.fullName}$` : '', + testPathPattern: failure?.path || '' + }); + if (!this._manager.isActive()) { + resolve(); + } + }); + }); + } + getFailedTestAssertions(results) { + const failedTestPaths = []; + if ( + // skip if no failed tests + results.numFailedTests === 0 || + // skip if missing test results + !results.testResults || + // skip if unmatched snapshots are present + results.snapshot.unmatched + ) { + return failedTestPaths; + } + results.testResults.forEach(testResult => { + testResult.testResults.forEach(result => { + if (result.status === 'failed') { + failedTestPaths.push({ + fullName: result.fullName, + path: testResult.testFilePath + }); + } + }); + }); + return failedTestPaths; + } +} +exports.default = FailedTestsInteractivePlugin; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/plugins/Quit.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/plugins/Quit.js new file mode 100644 index 0000000000000000000000000000000000000000..d417abc7cfe4898cf0c75aeaa3da72d0ee81616c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/plugins/Quit.js @@ -0,0 +1,42 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _jestWatcher() { + const data = require('jest-watcher'); + _jestWatcher = function () { + return data; + }; + return data; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class QuitPlugin extends _jestWatcher().BaseWatchPlugin { + isInternal; + constructor(options) { + super(options); + this.isInternal = true; + } + async run() { + if (typeof this._stdin.setRawMode === 'function') { + this._stdin.setRawMode(false); + } + this._stdout.write('\n'); + process.exit(0); + } + getUsageInfo() { + return { + key: 'q', + prompt: 'quit watch mode' + }; + } +} +var _default = QuitPlugin; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/plugins/TestNamePattern.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/plugins/TestNamePattern.js new file mode 100644 index 0000000000000000000000000000000000000000..f959b5668d6a32d671180909b35eed6903c88576 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/plugins/TestNamePattern.js @@ -0,0 +1,70 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _jestWatcher() { + const data = require('jest-watcher'); + _jestWatcher = function () { + return data; + }; + return data; +} +var _TestNamePatternPrompt = _interopRequireDefault( + require('../TestNamePatternPrompt') +); +var _activeFiltersMessage = _interopRequireDefault( + require('../lib/activeFiltersMessage') +); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class TestNamePatternPlugin extends _jestWatcher().BaseWatchPlugin { + _prompt; + isInternal; + constructor(options) { + super(options); + this._prompt = new (_jestWatcher().Prompt)(); + this.isInternal = true; + } + getUsageInfo() { + return { + key: 't', + prompt: 'filter by a test name regex pattern' + }; + } + onKey(key) { + this._prompt.put(key); + } + run(globalConfig, updateConfigAndRun) { + return new Promise((res, rej) => { + const testNamePatternPrompt = new _TestNamePatternPrompt.default( + this._stdout, + this._prompt + ); + testNamePatternPrompt.run( + value => { + updateConfigAndRun({ + mode: 'watch', + testNamePattern: value + }); + res(); + }, + rej, + { + header: (0, _activeFiltersMessage.default)(globalConfig) + } + ); + }); + } +} +var _default = TestNamePatternPlugin; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/plugins/TestPathPattern.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/plugins/TestPathPattern.js new file mode 100644 index 0000000000000000000000000000000000000000..10c4ccfe761b4ddf75250d72c46b140a4b315a08 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/plugins/TestPathPattern.js @@ -0,0 +1,70 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _jestWatcher() { + const data = require('jest-watcher'); + _jestWatcher = function () { + return data; + }; + return data; +} +var _TestPathPatternPrompt = _interopRequireDefault( + require('../TestPathPatternPrompt') +); +var _activeFiltersMessage = _interopRequireDefault( + require('../lib/activeFiltersMessage') +); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class TestPathPatternPlugin extends _jestWatcher().BaseWatchPlugin { + _prompt; + isInternal; + constructor(options) { + super(options); + this._prompt = new (_jestWatcher().Prompt)(); + this.isInternal = true; + } + getUsageInfo() { + return { + key: 'p', + prompt: 'filter by a filename regex pattern' + }; + } + onKey(key) { + this._prompt.put(key); + } + run(globalConfig, updateConfigAndRun) { + return new Promise((res, rej) => { + const testPathPatternPrompt = new _TestPathPatternPrompt.default( + this._stdout, + this._prompt + ); + testPathPatternPrompt.run( + value => { + updateConfigAndRun({ + mode: 'watch', + testPathPattern: value + }); + res(); + }, + rej, + { + header: (0, _activeFiltersMessage.default)(globalConfig) + } + ); + }); + } +} +var _default = TestPathPatternPlugin; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/plugins/UpdateSnapshots.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/plugins/UpdateSnapshots.js new file mode 100644 index 0000000000000000000000000000000000000000..17a8d15bed0483dfdb3d3a21bca46be78ae89a99 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/plugins/UpdateSnapshots.js @@ -0,0 +1,51 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _jestWatcher() { + const data = require('jest-watcher'); + _jestWatcher = function () { + return data; + }; + return data; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class UpdateSnapshotsPlugin extends _jestWatcher().BaseWatchPlugin { + _hasSnapshotFailure; + isInternal; + constructor(options) { + super(options); + this.isInternal = true; + this._hasSnapshotFailure = false; + } + run(_globalConfig, updateConfigAndRun) { + updateConfigAndRun({ + updateSnapshot: 'all' + }); + return Promise.resolve(false); + } + apply(hooks) { + hooks.onTestRunComplete(results => { + this._hasSnapshotFailure = results.snapshot.failure; + }); + } + getUsageInfo() { + if (this._hasSnapshotFailure) { + return { + key: 'u', + prompt: 'update failing snapshots' + }; + } + return null; + } +} +var _default = UpdateSnapshotsPlugin; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.js new file mode 100644 index 0000000000000000000000000000000000000000..d21821e36863a14c3c0ec6972b92c0843a6814f2 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.js @@ -0,0 +1,99 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _jestWatcher() { + const data = require('jest-watcher'); + _jestWatcher = function () { + return data; + }; + return data; +} +var _SnapshotInteractiveMode = _interopRequireDefault( + require('../SnapshotInteractiveMode') +); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +/* eslint-disable local/ban-types-eventually */ + +class UpdateSnapshotInteractivePlugin extends _jestWatcher().BaseWatchPlugin { + _snapshotInteractiveMode = new _SnapshotInteractiveMode.default(this._stdout); + _failedSnapshotTestAssertions = []; + isInternal = true; + getFailedSnapshotTestAssertions(testResults) { + const failedTestPaths = []; + if (testResults.numFailedTests === 0 || !testResults.testResults) { + return failedTestPaths; + } + testResults.testResults.forEach(testResult => { + if (testResult.snapshot && testResult.snapshot.unmatched) { + testResult.testResults.forEach(result => { + if (result.status === 'failed') { + failedTestPaths.push({ + fullName: result.fullName, + path: testResult.testFilePath + }); + } + }); + } + }); + return failedTestPaths; + } + apply(hooks) { + hooks.onTestRunComplete(results => { + this._failedSnapshotTestAssertions = + this.getFailedSnapshotTestAssertions(results); + if (this._snapshotInteractiveMode.isActive()) { + this._snapshotInteractiveMode.updateWithResults(results); + } + }); + } + onKey(key) { + if (this._snapshotInteractiveMode.isActive()) { + this._snapshotInteractiveMode.put(key); + } + } + run(_globalConfig, updateConfigAndRun) { + if (this._failedSnapshotTestAssertions.length) { + return new Promise(res => { + this._snapshotInteractiveMode.run( + this._failedSnapshotTestAssertions, + (assertion, shouldUpdateSnapshot) => { + updateConfigAndRun({ + mode: 'watch', + testNamePattern: assertion ? `^${assertion.fullName}$` : '', + testPathPattern: assertion ? assertion.path : '', + updateSnapshot: shouldUpdateSnapshot ? 'all' : 'none' + }); + if (!this._snapshotInteractiveMode.isActive()) { + res(); + } + } + ); + }); + } else { + return Promise.resolve(); + } + } + getUsageInfo() { + if (this._failedSnapshotTestAssertions?.length > 0) { + return { + key: 'i', + prompt: 'update failing snapshots interactively' + }; + } + return null; + } +} +var _default = UpdateSnapshotInteractivePlugin; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/runGlobalHook.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/runGlobalHook.js new file mode 100644 index 0000000000000000000000000000000000000000..dfba1bb9d992256abf39780e47c20b40267b1e08 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/runGlobalHook.js @@ -0,0 +1,133 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = runGlobalHook; +function util() { + const data = _interopRequireWildcard(require('util')); + util = function () { + return data; + }; + return data; +} +function _transform() { + const data = require('@jest/transform'); + _transform = function () { + return data; + }; + return data; +} +function _prettyFormat() { + const data = _interopRequireDefault(require('pretty-format')); + _prettyFormat = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +async function runGlobalHook({allTests, globalConfig, moduleName}) { + const globalModulePaths = new Set( + allTests.map(test => test.context.config[moduleName]) + ); + if (globalConfig[moduleName]) { + globalModulePaths.add(globalConfig[moduleName]); + } + if (globalModulePaths.size > 0) { + for (const modulePath of globalModulePaths) { + if (!modulePath) { + continue; + } + const correctConfig = allTests.find( + t => t.context.config[moduleName] === modulePath + ); + const projectConfig = correctConfig + ? correctConfig.context.config + : // Fallback to first config + allTests[0].context.config; + const transformer = await (0, _transform().createScriptTransformer)( + projectConfig + ); + try { + await transformer.requireAndTranspileModule( + modulePath, + async globalModule => { + if (typeof globalModule !== 'function') { + throw new TypeError( + `${moduleName} file must export a function at ${modulePath}` + ); + } + await globalModule(globalConfig, projectConfig); + } + ); + } catch (error) { + if ( + util().types.isNativeError(error) && + (Object.getOwnPropertyDescriptor(error, 'message')?.writable || + Object.getOwnPropertyDescriptor( + Object.getPrototypeOf(error), + 'message' + )?.writable) + ) { + error.message = `Jest: Got error running ${moduleName} - ${modulePath}, reason: ${error.message}`; + throw error; + } + throw new Error( + `Jest: Got error running ${moduleName} - ${modulePath}, reason: ${(0, + _prettyFormat().default)(error, { + maxDepth: 3 + })}` + ); + } + } + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/runJest.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/runJest.js new file mode 100644 index 0000000000000000000000000000000000000000..87cc30d1848f63fab2789a71f3b36a4d44446c3d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/runJest.js @@ -0,0 +1,391 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = runJest; +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _perf_hooks() { + const data = require('perf_hooks'); + _perf_hooks = function () { + return data; + }; + return data; +} +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _exit() { + const data = _interopRequireDefault(require('exit')); + _exit = function () { + return data; + }; + return data; +} +function fs() { + const data = _interopRequireWildcard(require('graceful-fs')); + fs = function () { + return data; + }; + return data; +} +function _console() { + const data = require('@jest/console'); + _console = function () { + return data; + }; + return data; +} +function _testResult() { + const data = require('@jest/test-result'); + _testResult = function () { + return data; + }; + return data; +} +function _jestResolve() { + const data = _interopRequireDefault(require('jest-resolve')); + _jestResolve = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +function _jestWatcher() { + const data = require('jest-watcher'); + _jestWatcher = function () { + return data; + }; + return data; +} +var _SearchSource = _interopRequireDefault(require('./SearchSource')); +var _TestScheduler = require('./TestScheduler'); +var _collectHandles = _interopRequireDefault(require('./collectHandles')); +var _getNoTestsFoundMessage = _interopRequireDefault( + require('./getNoTestsFoundMessage') +); +var _runGlobalHook = _interopRequireDefault(require('./runGlobalHook')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const getTestPaths = async ( + globalConfig, + source, + outputStream, + changedFiles, + jestHooks, + filter +) => { + const data = await source.getTestPaths(globalConfig, changedFiles, filter); + if (!data.tests.length && globalConfig.onlyChanged && data.noSCM) { + new (_console().CustomConsole)(outputStream, outputStream).log( + 'Jest can only find uncommitted changed files in a git or hg ' + + 'repository. If you make your project a git or hg ' + + 'repository (`git init` or `hg init`), Jest will be able ' + + 'to only run tests related to files changed since the last ' + + 'commit.' + ); + } + const shouldTestArray = await Promise.all( + data.tests.map(test => + jestHooks.shouldRunTestSuite({ + config: test.context.config, + duration: test.duration, + testPath: test.path + }) + ) + ); + const filteredTests = data.tests.filter((_test, i) => shouldTestArray[i]); + return { + ...data, + allTests: filteredTests.length, + tests: filteredTests + }; +}; +const processResults = async (runResults, options) => { + const { + outputFile, + json: isJSON, + onComplete, + outputStream, + testResultsProcessor, + collectHandles + } = options; + if (collectHandles) { + runResults.openHandles = await collectHandles(); + } else { + runResults.openHandles = []; + } + if (testResultsProcessor) { + const processor = await (0, _jestUtil().requireOrImportModule)( + testResultsProcessor + ); + runResults = await processor(runResults); + } + if (isJSON) { + if (outputFile) { + const cwd = (0, _jestUtil().tryRealpath)(process.cwd()); + const filePath = path().resolve(cwd, outputFile); + fs().writeFileSync( + filePath, + `${JSON.stringify((0, _testResult().formatTestResults)(runResults))}\n` + ); + outputStream.write( + `Test results written to: ${path().relative(cwd, filePath)}\n` + ); + } else { + process.stdout.write( + `${JSON.stringify((0, _testResult().formatTestResults)(runResults))}\n` + ); + } + } + onComplete?.(runResults); +}; +const testSchedulerContext = { + firstRun: true, + previousSuccess: true +}; +async function runJest({ + contexts, + globalConfig, + outputStream, + testWatcher, + jestHooks = new (_jestWatcher().JestHook)().getEmitter(), + startRun, + changedFilesPromise, + onComplete, + failedTestsCache, + filter +}) { + // Clear cache for required modules - there might be different resolutions + // from Jest's config loading to running the tests + _jestResolve().default.clearDefaultResolverCache(); + const Sequencer = await (0, _jestUtil().requireOrImportModule)( + globalConfig.testSequencer + ); + const sequencer = new Sequencer(); + let allTests = []; + if (changedFilesPromise && globalConfig.watch) { + const {repos} = await changedFilesPromise; + const noSCM = Object.keys(repos).every(scm => repos[scm].size === 0); + if (noSCM) { + process.stderr.write( + `\n${_chalk().default.bold( + '--watch' + )} is not supported without git/hg, please use --watchAll\n` + ); + (0, _exit().default)(1); + } + } + const searchSources = contexts.map( + context => new _SearchSource.default(context) + ); + _perf_hooks().performance.mark('jest/getTestPaths:start'); + const testRunData = await Promise.all( + contexts.map(async (context, index) => { + const searchSource = searchSources[index]; + const matches = await getTestPaths( + globalConfig, + searchSource, + outputStream, + changedFilesPromise && (await changedFilesPromise), + jestHooks, + filter + ); + allTests = allTests.concat(matches.tests); + return { + context, + matches + }; + }) + ); + _perf_hooks().performance.mark('jest/getTestPaths:end'); + if (globalConfig.shard) { + if (typeof sequencer.shard !== 'function') { + throw new Error( + `Shard ${globalConfig.shard.shardIndex}/${globalConfig.shard.shardCount} requested, but test sequencer ${Sequencer.name} in ${globalConfig.testSequencer} has no shard method.` + ); + } + allTests = await sequencer.shard(allTests, globalConfig.shard); + } + allTests = await sequencer.sort(allTests); + if (globalConfig.listTests) { + const testsPaths = Array.from(new Set(allTests.map(test => test.path))); + /* eslint-disable no-console */ + if (globalConfig.json) { + console.log(JSON.stringify(testsPaths)); + } else { + console.log(testsPaths.join('\n')); + } + /* eslint-enable */ + + onComplete && + onComplete((0, _testResult().makeEmptyAggregatedTestResult)()); + return; + } + if (globalConfig.onlyFailures) { + if (failedTestsCache) { + allTests = failedTestsCache.filterTests(allTests); + } else { + allTests = await sequencer.allFailedTests(allTests); + } + } + const hasTests = allTests.length > 0; + if (!hasTests) { + const {exitWith0, message: noTestsFoundMessage} = (0, + _getNoTestsFoundMessage.default)(testRunData, globalConfig); + if (exitWith0) { + new (_console().CustomConsole)(outputStream, outputStream).log( + noTestsFoundMessage + ); + } else { + new (_console().CustomConsole)(outputStream, outputStream).error( + noTestsFoundMessage + ); + (0, _exit().default)(1); + } + } else if ( + allTests.length === 1 && + globalConfig.silent !== true && + globalConfig.verbose !== false + ) { + const newConfig = { + ...globalConfig, + verbose: true + }; + globalConfig = Object.freeze(newConfig); + } + let collectHandles; + if (globalConfig.detectOpenHandles) { + collectHandles = (0, _collectHandles.default)(); + } + if (hasTests) { + _perf_hooks().performance.mark('jest/globalSetup:start'); + await (0, _runGlobalHook.default)({ + allTests, + globalConfig, + moduleName: 'globalSetup' + }); + _perf_hooks().performance.mark('jest/globalSetup:end'); + } + if (changedFilesPromise) { + const changedFilesInfo = await changedFilesPromise; + if (changedFilesInfo.changedFiles) { + testSchedulerContext.changedFiles = changedFilesInfo.changedFiles; + const sourcesRelatedToTestsInChangedFilesArray = ( + await Promise.all( + contexts.map(async (_, index) => { + const searchSource = searchSources[index]; + return searchSource.findRelatedSourcesFromTestsInChangedFiles( + changedFilesInfo + ); + }) + ) + ).reduce((total, paths) => total.concat(paths), []); + testSchedulerContext.sourcesRelatedToTestsInChangedFiles = new Set( + sourcesRelatedToTestsInChangedFilesArray + ); + } + } + const scheduler = await (0, _TestScheduler.createTestScheduler)( + globalConfig, + { + startRun, + ...testSchedulerContext + } + ); + + // @ts-expect-error - second arg is unsupported (but harmless) in Node 14 + _perf_hooks().performance.mark('jest/scheduleAndRun:start', { + detail: { + numTests: allTests.length + } + }); + const results = await scheduler.scheduleTests(allTests, testWatcher); + _perf_hooks().performance.mark('jest/scheduleAndRun:end'); + _perf_hooks().performance.mark('jest/cacheResults:start'); + sequencer.cacheResults(allTests, results); + _perf_hooks().performance.mark('jest/cacheResults:end'); + if (hasTests) { + _perf_hooks().performance.mark('jest/globalTeardown:start'); + await (0, _runGlobalHook.default)({ + allTests, + globalConfig, + moduleName: 'globalTeardown' + }); + _perf_hooks().performance.mark('jest/globalTeardown:end'); + } + _perf_hooks().performance.mark('jest/processResults:start'); + await processResults(results, { + collectHandles, + json: globalConfig.json, + onComplete, + outputFile: globalConfig.outputFile, + outputStream, + testResultsProcessor: globalConfig.testResultsProcessor + }); + _perf_hooks().performance.mark('jest/processResults:end'); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/testSchedulerHelper.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/testSchedulerHelper.js new file mode 100644 index 0000000000000000000000000000000000000000..86a283f3e5e19a5377f18dee065d81ca75be629b --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/testSchedulerHelper.js @@ -0,0 +1,57 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.shouldRunInBand = shouldRunInBand; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const SLOW_TEST_TIME = 1000; +function shouldRunInBand( + tests, + timings, + { + detectOpenHandles, + maxWorkers, + runInBand, + watch, + watchAll, + workerIdleMemoryLimit + } +) { + // If user asked for run in band, respect that. + // detectOpenHandles makes no sense without runInBand, because it cannot detect leaks in workers + if (runInBand || detectOpenHandles) { + return true; + } + + /* + * If we are using watch/watchAll mode, don't schedule anything in the main + * thread to keep the TTY responsive and to prevent watch mode crashes caused + * by leaks (improper test teardown). + */ + if (watch || watchAll) { + return false; + } + + /* + * Otherwise, run in band if we only have one test or one worker available. + * Also, if we are confident from previous runs that the tests will finish + * quickly we also run in band to reduce the overhead of spawning workers. + */ + const areFastTests = timings.every(timing => timing < SLOW_TEST_TIME); + const oneWorkerOrLess = maxWorkers <= 1; + const oneTestOrLess = tests.length <= 1; + return ( + // When specifying a memory limit, workers should be used + !workerIdleMemoryLimit && + (oneWorkerOrLess || + oneTestOrLess || + (tests.length <= 20 && timings.length > 0 && areFastTests)) + ); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/types.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/types.js new file mode 100644 index 0000000000000000000000000000000000000000..ad9a93a7c160f02945911772460eb8a1bcb003db --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/types.js @@ -0,0 +1 @@ +'use strict'; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/version.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/version.js new file mode 100644 index 0000000000000000000000000000000000000000..cb06e7fa84fdfdedb1af36087a4f99013c80c8ff --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/version.js @@ -0,0 +1,18 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getVersion; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// Cannot be `import` as it's not under TS root dir +const {version: VERSION} = require('../package.json'); +function getVersion() { + return VERSION; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/watch.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/watch.js new file mode 100644 index 0000000000000000000000000000000000000000..a61af3ea07d3faa925053d04bfb7e51d08dd3b3c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/build/watch.js @@ -0,0 +1,666 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = watch; +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _ansiEscapes() { + const data = _interopRequireDefault(require('ansi-escapes')); + _ansiEscapes = function () { + return data; + }; + return data; +} +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _exit() { + const data = _interopRequireDefault(require('exit')); + _exit = function () { + return data; + }; + return data; +} +function _slash() { + const data = _interopRequireDefault(require('slash')); + _slash = function () { + return data; + }; + return data; +} +function _jestMessageUtil() { + const data = require('jest-message-util'); + _jestMessageUtil = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +function _jestValidate() { + const data = require('jest-validate'); + _jestValidate = function () { + return data; + }; + return data; +} +function _jestWatcher() { + const data = require('jest-watcher'); + _jestWatcher = function () { + return data; + }; + return data; +} +var _FailedTestsCache = _interopRequireDefault(require('./FailedTestsCache')); +var _SearchSource = _interopRequireDefault(require('./SearchSource')); +var _getChangedFilesPromise = _interopRequireDefault( + require('./getChangedFilesPromise') +); +var _activeFiltersMessage = _interopRequireDefault( + require('./lib/activeFiltersMessage') +); +var _createContext = _interopRequireDefault(require('./lib/createContext')); +var _isValidPath = _interopRequireDefault(require('./lib/isValidPath')); +var _updateGlobalConfig = _interopRequireDefault( + require('./lib/updateGlobalConfig') +); +var _watchPluginsHelpers = require('./lib/watchPluginsHelpers'); +var _FailedTestsInteractive = _interopRequireDefault( + require('./plugins/FailedTestsInteractive') +); +var _Quit = _interopRequireDefault(require('./plugins/Quit')); +var _TestNamePattern = _interopRequireDefault( + require('./plugins/TestNamePattern') +); +var _TestPathPattern = _interopRequireDefault( + require('./plugins/TestPathPattern') +); +var _UpdateSnapshots = _interopRequireDefault( + require('./plugins/UpdateSnapshots') +); +var _UpdateSnapshotsInteractive = _interopRequireDefault( + require('./plugins/UpdateSnapshotsInteractive') +); +var _runJest = _interopRequireDefault(require('./runJest')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const {print: preRunMessagePrint} = _jestUtil().preRunMessage; +let hasExitListener = false; +const INTERNAL_PLUGINS = [ + _FailedTestsInteractive.default, + _TestPathPattern.default, + _TestNamePattern.default, + _UpdateSnapshots.default, + _UpdateSnapshotsInteractive.default, + _Quit.default +]; +const RESERVED_KEY_PLUGINS = new Map([ + [ + _UpdateSnapshots.default, + { + forbiddenOverwriteMessage: 'updating snapshots', + key: 'u' + } + ], + [ + _UpdateSnapshotsInteractive.default, + { + forbiddenOverwriteMessage: 'updating snapshots interactively', + key: 'i' + } + ], + [ + _Quit.default, + { + forbiddenOverwriteMessage: 'quitting watch mode' + } + ] +]); +async function watch( + initialGlobalConfig, + contexts, + outputStream, + hasteMapInstances, + stdin = process.stdin, + hooks = new (_jestWatcher().JestHook)(), + filter +) { + // `globalConfig` will be constantly updated and reassigned as a result of + // watch mode interactions. + let globalConfig = initialGlobalConfig; + let activePlugin; + globalConfig = (0, _updateGlobalConfig.default)(globalConfig, { + mode: globalConfig.watch ? 'watch' : 'watchAll', + passWithNoTests: true + }); + const updateConfigAndRun = ({ + bail, + changedSince, + collectCoverage, + collectCoverageFrom, + coverageDirectory, + coverageReporters, + findRelatedTests, + mode, + nonFlagArgs, + notify, + notifyMode, + onlyFailures, + reporters, + testNamePattern, + testPathPattern, + updateSnapshot, + verbose + } = {}) => { + const previousUpdateSnapshot = globalConfig.updateSnapshot; + globalConfig = (0, _updateGlobalConfig.default)(globalConfig, { + bail, + changedSince, + collectCoverage, + collectCoverageFrom, + coverageDirectory, + coverageReporters, + findRelatedTests, + mode, + nonFlagArgs, + notify, + notifyMode, + onlyFailures, + reporters, + testNamePattern, + testPathPattern, + updateSnapshot, + verbose + }); + startRun(globalConfig); + globalConfig = (0, _updateGlobalConfig.default)(globalConfig, { + // updateSnapshot is not sticky after a run. + updateSnapshot: + previousUpdateSnapshot === 'all' ? 'none' : previousUpdateSnapshot + }); + }; + const watchPlugins = INTERNAL_PLUGINS.map( + InternalPlugin => + new InternalPlugin({ + stdin, + stdout: outputStream + }) + ); + watchPlugins.forEach(plugin => { + const hookSubscriber = hooks.getSubscriber(); + if (plugin.apply) { + plugin.apply(hookSubscriber); + } + }); + if (globalConfig.watchPlugins != null) { + const watchPluginKeys = new Map(); + for (const plugin of watchPlugins) { + const reservedInfo = RESERVED_KEY_PLUGINS.get(plugin.constructor) || {}; + const key = reservedInfo.key || getPluginKey(plugin, globalConfig); + if (!key) { + continue; + } + const {forbiddenOverwriteMessage} = reservedInfo; + watchPluginKeys.set(key, { + forbiddenOverwriteMessage, + overwritable: forbiddenOverwriteMessage == null, + plugin + }); + } + for (const pluginWithConfig of globalConfig.watchPlugins) { + let plugin; + try { + const ThirdPartyPlugin = await (0, _jestUtil().requireOrImportModule)( + pluginWithConfig.path + ); + plugin = new ThirdPartyPlugin({ + config: pluginWithConfig.config, + stdin, + stdout: outputStream + }); + } catch (error) { + const errorWithContext = new Error( + `Failed to initialize watch plugin "${_chalk().default.bold( + (0, _slash().default)( + path().relative(process.cwd(), pluginWithConfig.path) + ) + )}":\n\n${(0, _jestMessageUtil().formatExecError)( + error, + contexts[0].config, + { + noStackTrace: false + } + )}` + ); + delete errorWithContext.stack; + return Promise.reject(errorWithContext); + } + checkForConflicts(watchPluginKeys, plugin, globalConfig); + const hookSubscriber = hooks.getSubscriber(); + if (plugin.apply) { + plugin.apply(hookSubscriber); + } + watchPlugins.push(plugin); + } + } + const failedTestsCache = new _FailedTestsCache.default(); + let searchSources = contexts.map(context => ({ + context, + searchSource: new _SearchSource.default(context) + })); + let isRunning = false; + let testWatcher; + let shouldDisplayWatchUsage = true; + let isWatchUsageDisplayed = false; + const emitFileChange = () => { + if (hooks.isUsed('onFileChange')) { + const projects = searchSources.map(({context, searchSource}) => ({ + config: context.config, + testPaths: searchSource.findMatchingTests('').tests.map(t => t.path) + })); + hooks.getEmitter().onFileChange({ + projects + }); + } + }; + emitFileChange(); + hasteMapInstances.forEach((hasteMapInstance, index) => { + hasteMapInstance.on('change', ({eventsQueue, hasteFS, moduleMap}) => { + const validPaths = eventsQueue.filter(({filePath}) => + (0, _isValidPath.default)(globalConfig, filePath) + ); + if (validPaths.length) { + const context = (contexts[index] = (0, _createContext.default)( + contexts[index].config, + { + hasteFS, + moduleMap + } + )); + activePlugin = null; + searchSources = searchSources.slice(); + searchSources[index] = { + context, + searchSource: new _SearchSource.default(context) + }; + emitFileChange(); + startRun(globalConfig); + } + }); + }); + if (!hasExitListener) { + hasExitListener = true; + process.on('exit', () => { + if (activePlugin) { + outputStream.write(_ansiEscapes().default.cursorDown()); + outputStream.write(_ansiEscapes().default.eraseDown); + } + }); + } + const startRun = globalConfig => { + if (isRunning) { + return Promise.resolve(null); + } + testWatcher = new (_jestWatcher().TestWatcher)({ + isWatchMode: true + }); + _jestUtil().isInteractive && + outputStream.write(_jestUtil().specialChars.CLEAR); + preRunMessagePrint(outputStream); + isRunning = true; + const configs = contexts.map(context => context.config); + const changedFilesPromise = (0, _getChangedFilesPromise.default)( + globalConfig, + configs + ); + return (0, _runJest.default)({ + changedFilesPromise, + contexts, + failedTestsCache, + filter, + globalConfig, + jestHooks: hooks.getEmitter(), + onComplete: results => { + isRunning = false; + hooks.getEmitter().onTestRunComplete(results); + + // Create a new testWatcher instance so that re-runs won't be blocked. + // The old instance that was passed to Jest will still be interrupted + // and prevent test runs from the previous run. + testWatcher = new (_jestWatcher().TestWatcher)({ + isWatchMode: true + }); + + // Do not show any Watch Usage related stuff when running in a + // non-interactive environment + if (_jestUtil().isInteractive) { + if (shouldDisplayWatchUsage) { + outputStream.write(usage(globalConfig, watchPlugins)); + shouldDisplayWatchUsage = false; // hide Watch Usage after first run + isWatchUsageDisplayed = true; + } else { + outputStream.write(showToggleUsagePrompt()); + shouldDisplayWatchUsage = false; + isWatchUsageDisplayed = false; + } + } else { + outputStream.write('\n'); + } + failedTestsCache.setTestResults(results.testResults); + }, + outputStream, + startRun, + testWatcher + }).catch(error => + // Errors thrown inside `runJest`, e.g. by resolvers, are caught here for + // continuous watch mode execution. We need to reprint them to the + // terminal and give just a little bit of extra space so they fit below + // `preRunMessagePrint` message nicely. + console.error( + `\n\n${(0, _jestMessageUtil().formatExecError)( + error, + contexts[0].config, + { + noStackTrace: false + } + )}` + ) + ); + }; + const onKeypress = key => { + if ( + key === _jestWatcher().KEYS.CONTROL_C || + key === _jestWatcher().KEYS.CONTROL_D + ) { + if (typeof stdin.setRawMode === 'function') { + stdin.setRawMode(false); + } + outputStream.write('\n'); + (0, _exit().default)(0); + return; + } + if (activePlugin != null && activePlugin.onKey) { + // if a plugin is activate, Jest should let it handle keystrokes, so ignore + // them here + activePlugin.onKey(key); + return; + } + + // Abort test run + const pluginKeys = (0, _watchPluginsHelpers.getSortedUsageRows)( + watchPlugins, + globalConfig + ).map(usage => Number(usage.key).toString(16)); + if ( + isRunning && + testWatcher && + ['q', _jestWatcher().KEYS.ENTER, 'a', 'o', 'f'] + .concat(pluginKeys) + .includes(key) + ) { + testWatcher.setState({ + interrupted: true + }); + return; + } + const matchingWatchPlugin = (0, + _watchPluginsHelpers.filterInteractivePlugins)( + watchPlugins, + globalConfig + ).find(plugin => getPluginKey(plugin, globalConfig) === key); + if (matchingWatchPlugin != null) { + if (isRunning) { + testWatcher.setState({ + interrupted: true + }); + return; + } + // "activate" the plugin, which has jest ignore keystrokes so the plugin + // can handle them + activePlugin = matchingWatchPlugin; + if (activePlugin.run) { + activePlugin.run(globalConfig, updateConfigAndRun).then( + shouldRerun => { + activePlugin = null; + if (shouldRerun) { + updateConfigAndRun(); + } + }, + () => { + activePlugin = null; + onCancelPatternPrompt(); + } + ); + } else { + activePlugin = null; + } + } + switch (key) { + case _jestWatcher().KEYS.ENTER: + startRun(globalConfig); + break; + case 'a': + globalConfig = (0, _updateGlobalConfig.default)(globalConfig, { + mode: 'watchAll', + testNamePattern: '', + testPathPattern: '' + }); + startRun(globalConfig); + break; + case 'c': + updateConfigAndRun({ + mode: 'watch', + testNamePattern: '', + testPathPattern: '' + }); + break; + case 'f': + globalConfig = (0, _updateGlobalConfig.default)(globalConfig, { + onlyFailures: !globalConfig.onlyFailures + }); + startRun(globalConfig); + break; + case 'o': + globalConfig = (0, _updateGlobalConfig.default)(globalConfig, { + mode: 'watch', + testNamePattern: '', + testPathPattern: '' + }); + startRun(globalConfig); + break; + case '?': + break; + case 'w': + if (!shouldDisplayWatchUsage && !isWatchUsageDisplayed) { + outputStream.write(_ansiEscapes().default.cursorUp()); + outputStream.write(_ansiEscapes().default.eraseDown); + outputStream.write(usage(globalConfig, watchPlugins)); + isWatchUsageDisplayed = true; + shouldDisplayWatchUsage = false; + } + break; + } + }; + const onCancelPatternPrompt = () => { + outputStream.write(_ansiEscapes().default.cursorHide); + outputStream.write(_jestUtil().specialChars.CLEAR); + outputStream.write(usage(globalConfig, watchPlugins)); + outputStream.write(_ansiEscapes().default.cursorShow); + }; + if (typeof stdin.setRawMode === 'function') { + stdin.setRawMode(true); + stdin.resume(); + stdin.setEncoding('utf8'); + stdin.on('data', onKeypress); + } + startRun(globalConfig); + return Promise.resolve(); +} +const checkForConflicts = (watchPluginKeys, plugin, globalConfig) => { + const key = getPluginKey(plugin, globalConfig); + if (!key) { + return; + } + const conflictor = watchPluginKeys.get(key); + if (!conflictor || conflictor.overwritable) { + watchPluginKeys.set(key, { + overwritable: false, + plugin + }); + return; + } + let error; + if (conflictor.forbiddenOverwriteMessage) { + error = ` + Watch plugin ${_chalk().default.bold.red( + getPluginIdentifier(plugin) + )} attempted to register key ${_chalk().default.bold.red(`<${key}>`)}, + that is reserved internally for ${_chalk().default.bold.red( + conflictor.forbiddenOverwriteMessage + )}. + Please change the configuration key for this plugin.`.trim(); + } else { + const plugins = [conflictor.plugin, plugin] + .map(p => _chalk().default.bold.red(getPluginIdentifier(p))) + .join(' and '); + error = ` + Watch plugins ${plugins} both attempted to register key ${_chalk().default.bold.red( + `<${key}>` + )}. + Please change the key configuration for one of the conflicting plugins to avoid overlap.`.trim(); + } + throw new (_jestValidate().ValidationError)( + 'Watch plugin configuration error', + error + ); +}; +const getPluginIdentifier = plugin => + // This breaks as `displayName` is not defined as a static, but since + // WatchPlugin is an interface, and it is my understanding interface + // static fields are not definable anymore, no idea how to circumvent + // this :-( + // @ts-expect-error: leave `displayName` be. + plugin.constructor.displayName || plugin.constructor.name; +const getPluginKey = (plugin, globalConfig) => { + if (typeof plugin.getUsageInfo === 'function') { + return ( + plugin.getUsageInfo(globalConfig) || { + key: null + } + ).key; + } + return null; +}; +const usage = (globalConfig, watchPlugins, delimiter = '\n') => { + const messages = [ + (0, _activeFiltersMessage.default)(globalConfig), + globalConfig.testPathPattern || globalConfig.testNamePattern + ? `${_chalk().default.dim(' \u203A Press ')}c${_chalk().default.dim( + ' to clear filters.' + )}` + : null, + `\n${_chalk().default.bold('Watch Usage')}`, + globalConfig.watch + ? `${_chalk().default.dim(' \u203A Press ')}a${_chalk().default.dim( + ' to run all tests.' + )}` + : null, + globalConfig.onlyFailures + ? `${_chalk().default.dim(' \u203A Press ')}f${_chalk().default.dim( + ' to quit "only failed tests" mode.' + )}` + : `${_chalk().default.dim(' \u203A Press ')}f${_chalk().default.dim( + ' to run only failed tests.' + )}`, + (globalConfig.watchAll || + globalConfig.testPathPattern || + globalConfig.testNamePattern) && + !globalConfig.noSCM + ? `${_chalk().default.dim(' \u203A Press ')}o${_chalk().default.dim( + ' to only run tests related to changed files.' + )}` + : null, + ...(0, _watchPluginsHelpers.getSortedUsageRows)( + watchPlugins, + globalConfig + ).map( + plugin => + `${_chalk().default.dim(' \u203A Press')} ${ + plugin.key + } ${_chalk().default.dim(`to ${plugin.prompt}.`)}` + ), + `${_chalk().default.dim(' \u203A Press ')}Enter${_chalk().default.dim( + ' to trigger a test run.' + )}` + ]; + return `${messages.filter(message => !!message).join(delimiter)}\n`; +}; +const showToggleUsagePrompt = () => + '\n' + + `${_chalk().default.bold('Watch Usage: ')}${_chalk().default.dim( + 'Press ' + )}w${_chalk().default.dim(' to show more.')}`; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/.bin/semver b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/.bin/semver new file mode 100644 index 0000000000000000000000000000000000000000..16e6872b5778b5c43af2cefec45471c090be89b9 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/.bin/semver @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a3ed56435cbd4b3f07a80c4a343edd86d787f89bf2cee0105bdf68cb653ba2a0 +size 4717 diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/build/ScriptTransformer.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/build/ScriptTransformer.js new file mode 100644 index 0000000000000000000000000000000000000000..0fe4bdac076757cc9666446a5b543ce0d16bc179 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/build/ScriptTransformer.js @@ -0,0 +1,1000 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.createScriptTransformer = createScriptTransformer; +exports.createTranspilingRequire = createTranspilingRequire; +function _crypto() { + const data = require('crypto'); + _crypto = function () { + return data; + }; + return data; +} +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _core() { + const data = require('@babel/core'); + _core = function () { + return data; + }; + return data; +} +function _babelPluginIstanbul() { + const data = _interopRequireDefault(require('babel-plugin-istanbul')); + _babelPluginIstanbul = function () { + return data; + }; + return data; +} +function _convertSourceMap() { + const data = require('convert-source-map'); + _convertSourceMap = function () { + return data; + }; + return data; +} +function _fastJsonStableStringify() { + const data = _interopRequireDefault(require('fast-json-stable-stringify')); + _fastJsonStableStringify = function () { + return data; + }; + return data; +} +function fs() { + const data = _interopRequireWildcard(require('graceful-fs')); + fs = function () { + return data; + }; + return data; +} +function _pirates() { + const data = require('pirates'); + _pirates = function () { + return data; + }; + return data; +} +function _slash() { + const data = _interopRequireDefault(require('slash')); + _slash = function () { + return data; + }; + return data; +} +function _writeFileAtomic() { + const data = require('write-file-atomic'); + _writeFileAtomic = function () { + return data; + }; + return data; +} +function _jestHasteMap() { + const data = _interopRequireDefault(require('jest-haste-map')); + _jestHasteMap = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +var _enhanceUnexpectedTokenMessage = _interopRequireDefault( + require('./enhanceUnexpectedTokenMessage') +); +var _runtimeErrorsAndWarnings = require('./runtimeErrorsAndWarnings'); +var _shouldInstrument = _interopRequireDefault(require('./shouldInstrument')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// @ts-expect-error: should just be `require.resolve`, but the tests mess that up + +// Use `require` to avoid TS rootDir +const {version: VERSION} = require('../package.json'); +// This data structure is used to avoid recalculating some data every time that +// we need to transform a file. Since ScriptTransformer is instantiated for each +// file we need to keep this object in the local scope of this module. +const projectCaches = new Map(); + +// To reset the cache for specific changesets (rather than package version). +const CACHE_VERSION = '1'; +async function waitForPromiseWithCleanup(promise, cleanup) { + try { + await promise; + } finally { + cleanup(); + } +} + +// type predicate +function isTransformerFactory(t) { + return typeof t.createTransformer === 'function'; +} +class ScriptTransformer { + _cache; + _transformCache = new Map(); + _transformsAreLoaded = false; + constructor(_config, _cacheFS) { + this._config = _config; + this._cacheFS = _cacheFS; + const configString = (0, _fastJsonStableStringify().default)(this._config); + let projectCache = projectCaches.get(configString); + if (!projectCache) { + projectCache = { + configString, + ignorePatternsRegExp: calcIgnorePatternRegExp(this._config), + transformRegExp: calcTransformRegExp(this._config), + transformedFiles: new Map() + }; + projectCaches.set(configString, projectCache); + } + this._cache = projectCache; + } + _buildCacheKeyFromFileInfo( + fileData, + filename, + transformOptions, + transformerCacheKey + ) { + if (transformerCacheKey != null) { + return (0, _crypto().createHash)('sha1') + .update(transformerCacheKey) + .update(CACHE_VERSION) + .digest('hex') + .substring(0, 32); + } + return (0, _crypto().createHash)('sha1') + .update(fileData) + .update(transformOptions.configString) + .update(transformOptions.instrument ? 'instrument' : '') + .update(filename) + .update(CACHE_VERSION) + .digest('hex') + .substring(0, 32); + } + _buildTransformCacheKey(pattern, filepath) { + return pattern + filepath; + } + _getCacheKey(fileData, filename, options) { + const configString = this._cache.configString; + const {transformer, transformerConfig = {}} = + this._getTransformer(filename) ?? {}; + let transformerCacheKey = undefined; + const transformOptions = { + ...options, + cacheFS: this._cacheFS, + config: this._config, + configString, + transformerConfig + }; + if (typeof transformer?.getCacheKey === 'function') { + transformerCacheKey = transformer.getCacheKey( + fileData, + filename, + transformOptions + ); + } + return this._buildCacheKeyFromFileInfo( + fileData, + filename, + transformOptions, + transformerCacheKey + ); + } + async _getCacheKeyAsync(fileData, filename, options) { + const configString = this._cache.configString; + const {transformer, transformerConfig = {}} = + this._getTransformer(filename) ?? {}; + let transformerCacheKey = undefined; + const transformOptions = { + ...options, + cacheFS: this._cacheFS, + config: this._config, + configString, + transformerConfig + }; + if (transformer) { + const getCacheKey = + transformer.getCacheKeyAsync ?? transformer.getCacheKey; + if (typeof getCacheKey === 'function') { + transformerCacheKey = await getCacheKey( + fileData, + filename, + transformOptions + ); + } + } + return this._buildCacheKeyFromFileInfo( + fileData, + filename, + transformOptions, + transformerCacheKey + ); + } + _createCachedFilename(filename, cacheKey) { + const HasteMapClass = _jestHasteMap().default.getStatic(this._config); + const baseCacheDir = HasteMapClass.getCacheFilePath( + this._config.cacheDirectory, + `jest-transform-cache-${this._config.id}`, + VERSION + ); + // Create sub folders based on the cacheKey to avoid creating one + // directory with many files. + const cacheDir = path().join(baseCacheDir, cacheKey[0] + cacheKey[1]); + const cacheFilenamePrefix = path() + .basename(filename, path().extname(filename)) + .replace(/\W/g, ''); + return (0, _slash().default)( + path().join(cacheDir, `${cacheFilenamePrefix}_${cacheKey}`) + ); + } + _getFileCachePath(filename, content, options) { + const cacheKey = this._getCacheKey(content, filename, options); + return this._createCachedFilename(filename, cacheKey); + } + async _getFileCachePathAsync(filename, content, options) { + const cacheKey = await this._getCacheKeyAsync(content, filename, options); + return this._createCachedFilename(filename, cacheKey); + } + _getTransformPatternAndPath(filename) { + const transformEntry = this._cache.transformRegExp; + if (transformEntry == null) { + return undefined; + } + for (let i = 0; i < transformEntry.length; i++) { + const [transformRegExp, transformPath] = transformEntry[i]; + if (transformRegExp.test(filename)) { + return [transformRegExp.source, transformPath]; + } + } + return undefined; + } + _getTransformPath(filename) { + const transformInfo = this._getTransformPatternAndPath(filename); + if (!Array.isArray(transformInfo)) { + return undefined; + } + return transformInfo[1]; + } + async loadTransformers() { + await Promise.all( + this._config.transform.map( + async ([transformPattern, transformPath, transformerConfig], i) => { + let transformer = await (0, _jestUtil().requireOrImportModule)( + transformPath + ); + if (transformer == null) { + throw new Error( + (0, _runtimeErrorsAndWarnings.makeInvalidTransformerError)( + transformPath + ) + ); + } + if (isTransformerFactory(transformer)) { + transformer = await transformer.createTransformer( + transformerConfig + ); + } + if ( + typeof transformer.process !== 'function' && + typeof transformer.processAsync !== 'function' + ) { + throw new Error( + (0, _runtimeErrorsAndWarnings.makeInvalidTransformerError)( + transformPath + ) + ); + } + const res = { + transformer, + transformerConfig + }; + const transformCacheKey = this._buildTransformCacheKey( + this._cache.transformRegExp?.[i]?.[0].source ?? + new RegExp(transformPattern).source, + transformPath + ); + this._transformCache.set(transformCacheKey, res); + } + ) + ); + this._transformsAreLoaded = true; + } + _getTransformer(filename) { + if (!this._transformsAreLoaded) { + throw new Error( + 'Jest: Transformers have not been loaded yet - make sure to run `loadTransformers` and wait for it to complete before starting to transform files' + ); + } + if (this._config.transform.length === 0) { + return null; + } + const transformPatternAndPath = this._getTransformPatternAndPath(filename); + if (!Array.isArray(transformPatternAndPath)) { + return null; + } + const [transformPattern, transformPath] = transformPatternAndPath; + const transformCacheKey = this._buildTransformCacheKey( + transformPattern, + transformPath + ); + const transformer = this._transformCache.get(transformCacheKey); + if (transformer !== undefined) { + return transformer; + } + throw new Error( + `Jest was unable to load the transformer defined for ${filename}. This is a bug in Jest, please open up an issue` + ); + } + _instrumentFile(filename, input, canMapToInput, options) { + const inputCode = typeof input === 'string' ? input : input.code; + const inputMap = typeof input === 'string' ? null : input.map; + const result = (0, _core().transformSync)(inputCode, { + auxiliaryCommentBefore: ' istanbul ignore next ', + babelrc: false, + caller: { + name: '@jest/transform', + supportsDynamicImport: options.supportsDynamicImport, + supportsExportNamespaceFrom: options.supportsExportNamespaceFrom, + supportsStaticESM: options.supportsStaticESM, + supportsTopLevelAwait: options.supportsTopLevelAwait + }, + configFile: false, + filename, + plugins: [ + [ + _babelPluginIstanbul().default, + { + compact: false, + // files outside `cwd` will not be instrumented + cwd: this._config.rootDir, + exclude: [], + extension: false, + inputSourceMap: inputMap, + useInlineSourceMaps: false + } + ] + ], + sourceMaps: canMapToInput ? 'both' : false + }); + if (result?.code != null) { + return result; + } + return input; + } + _buildTransformResult( + filename, + cacheFilePath, + content, + transformer, + shouldCallTransform, + options, + processed, + sourceMapPath + ) { + let transformed = { + code: content, + map: null + }; + if (transformer && shouldCallTransform) { + if (processed != null && typeof processed.code === 'string') { + transformed = processed; + } else { + const transformPath = this._getTransformPath(filename); + (0, _jestUtil().invariant)(transformPath); + throw new Error( + (0, _runtimeErrorsAndWarnings.makeInvalidReturnValueError)( + transformPath + ) + ); + } + } + if (transformed.map == null || transformed.map === '') { + try { + //Could be a potential freeze here. + //See: https://github.com/jestjs/jest/pull/5177#discussion_r158883570 + const inlineSourceMap = (0, _convertSourceMap().fromSource)( + transformed.code + ); + if (inlineSourceMap) { + transformed.map = inlineSourceMap.toObject(); + } + } catch { + const transformPath = this._getTransformPath(filename); + (0, _jestUtil().invariant)(transformPath); + console.warn( + (0, _runtimeErrorsAndWarnings.makeInvalidSourceMapWarning)( + filename, + transformPath + ) + ); + } + } + + // That means that the transform has a custom instrumentation + // logic and will handle it based on `config.collectCoverage` option + const transformWillInstrument = + shouldCallTransform && transformer && transformer.canInstrument; + + // Apply instrumentation to the code if necessary, keeping the instrumented code and new map + let map = transformed.map; + let code; + if (transformWillInstrument !== true && options.instrument) { + /** + * We can map the original source code to the instrumented code ONLY if + * - the process of transforming the code produced a source map e.g. ts-jest + * - we did not transform the source code + * + * Otherwise we cannot make any statements about how the instrumented code corresponds to the original code, + * and we should NOT emit any source maps + * + */ + const shouldEmitSourceMaps = + (transformer != null && map != null) || transformer == null; + const instrumented = this._instrumentFile( + filename, + transformed, + shouldEmitSourceMaps, + options + ); + code = + typeof instrumented === 'string' ? instrumented : instrumented.code; + map = typeof instrumented === 'string' ? null : instrumented.map; + } else { + code = transformed.code; + } + if (map != null) { + const sourceMapContent = + typeof map === 'string' ? map : JSON.stringify(map); + (0, _jestUtil().invariant)( + sourceMapPath, + 'We should always have default sourceMapPath' + ); + writeCacheFile(sourceMapPath, sourceMapContent); + } else { + sourceMapPath = null; + } + writeCodeCacheFile(cacheFilePath, code); + return { + code, + originalCode: content, + sourceMapPath + }; + } + transformSource(filepath, content, options) { + const filename = (0, _jestUtil().tryRealpath)(filepath); + const {transformer, transformerConfig = {}} = + this._getTransformer(filename) ?? {}; + const cacheFilePath = this._getFileCachePath(filename, content, options); + const sourceMapPath = `${cacheFilePath}.map`; + // Ignore cache if `config.cache` is set (--no-cache) + const code = this._config.cache ? readCodeCacheFile(cacheFilePath) : null; + if (code != null) { + // This is broken: we return the code, and a path for the source map + // directly from the cache. But, nothing ensures the source map actually + // matches that source code. They could have gotten out-of-sync in case + // two separate processes write concurrently to the same cache files. + return { + code, + originalCode: content, + sourceMapPath + }; + } + let processed = null; + let shouldCallTransform = false; + if (transformer && this.shouldTransform(filename)) { + shouldCallTransform = true; + assertSyncTransformer(transformer, this._getTransformPath(filename)); + processed = transformer.process(content, filename, { + ...options, + cacheFS: this._cacheFS, + config: this._config, + configString: this._cache.configString, + transformerConfig + }); + } + (0, _jestUtil().createDirectory)(path().dirname(cacheFilePath)); + return this._buildTransformResult( + filename, + cacheFilePath, + content, + transformer, + shouldCallTransform, + options, + processed, + sourceMapPath + ); + } + async transformSourceAsync(filepath, content, options) { + const filename = (0, _jestUtil().tryRealpath)(filepath); + const {transformer, transformerConfig = {}} = + this._getTransformer(filename) ?? {}; + const cacheFilePath = await this._getFileCachePathAsync( + filename, + content, + options + ); + const sourceMapPath = `${cacheFilePath}.map`; + // Ignore cache if `config.cache` is set (--no-cache) + const code = this._config.cache ? readCodeCacheFile(cacheFilePath) : null; + if (code != null) { + // This is broken: we return the code, and a path for the source map + // directly from the cache. But, nothing ensures the source map actually + // matches that source code. They could have gotten out-of-sync in case + // two separate processes write concurrently to the same cache files. + return { + code, + originalCode: content, + sourceMapPath + }; + } + let processed = null; + let shouldCallTransform = false; + if (transformer && this.shouldTransform(filename)) { + shouldCallTransform = true; + const process = transformer.processAsync ?? transformer.process; + + // This is probably dead code since `_getTransformerAsync` already asserts this + (0, _jestUtil().invariant)( + typeof process === 'function', + 'A transformer must always export either a `process` or `processAsync`' + ); + processed = await process(content, filename, { + ...options, + cacheFS: this._cacheFS, + config: this._config, + configString: this._cache.configString, + transformerConfig + }); + } + (0, _jestUtil().createDirectory)(path().dirname(cacheFilePath)); + return this._buildTransformResult( + filename, + cacheFilePath, + content, + transformer, + shouldCallTransform, + options, + processed, + sourceMapPath + ); + } + async _transformAndBuildScriptAsync( + filename, + options, + transformOptions, + fileSource + ) { + const {isInternalModule} = options; + let fileContent = fileSource ?? this._cacheFS.get(filename); + if (fileContent == null) { + fileContent = fs().readFileSync(filename, 'utf8'); + this._cacheFS.set(filename, fileContent); + } + const content = stripShebang(fileContent); + let code = content; + let sourceMapPath = null; + const willTransform = + isInternalModule !== true && + (transformOptions.instrument || this.shouldTransform(filename)); + try { + if (willTransform) { + const transformedSource = await this.transformSourceAsync( + filename, + content, + transformOptions + ); + code = transformedSource.code; + sourceMapPath = transformedSource.sourceMapPath; + } + return { + code, + originalCode: content, + sourceMapPath + }; + } catch (e) { + if (!(e instanceof Error)) { + throw e; + } + throw (0, _enhanceUnexpectedTokenMessage.default)(e); + } + } + _transformAndBuildScript(filename, options, transformOptions, fileSource) { + const {isInternalModule} = options; + let fileContent = fileSource ?? this._cacheFS.get(filename); + if (fileContent == null) { + fileContent = fs().readFileSync(filename, 'utf8'); + this._cacheFS.set(filename, fileContent); + } + const content = stripShebang(fileContent); + let code = content; + let sourceMapPath = null; + const willTransform = + isInternalModule !== true && + (transformOptions.instrument || this.shouldTransform(filename)); + try { + if (willTransform) { + const transformedSource = this.transformSource( + filename, + content, + transformOptions + ); + code = transformedSource.code; + sourceMapPath = transformedSource.sourceMapPath; + } + return { + code, + originalCode: content, + sourceMapPath + }; + } catch (e) { + if (!(e instanceof Error)) { + throw e; + } + throw (0, _enhanceUnexpectedTokenMessage.default)(e); + } + } + async transformAsync(filename, options, fileSource) { + const instrument = + options.coverageProvider === 'babel' && + (0, _shouldInstrument.default)(filename, options, this._config); + const scriptCacheKey = getScriptCacheKey(filename, instrument); + let result = this._cache.transformedFiles.get(scriptCacheKey); + if (result) { + return result; + } + result = await this._transformAndBuildScriptAsync( + filename, + options, + { + ...options, + instrument + }, + fileSource + ); + if (scriptCacheKey) { + this._cache.transformedFiles.set(scriptCacheKey, result); + } + return result; + } + transform(filename, options, fileSource) { + const instrument = + options.coverageProvider === 'babel' && + (0, _shouldInstrument.default)(filename, options, this._config); + const scriptCacheKey = getScriptCacheKey(filename, instrument); + let result = this._cache.transformedFiles.get(scriptCacheKey); + if (result) { + return result; + } + result = this._transformAndBuildScript( + filename, + options, + { + ...options, + instrument + }, + fileSource + ); + if (scriptCacheKey) { + this._cache.transformedFiles.set(scriptCacheKey, result); + } + return result; + } + transformJson(filename, options, fileSource) { + const {isInternalModule} = options; + const willTransform = + isInternalModule !== true && this.shouldTransform(filename); + if (willTransform) { + const {code: transformedJsonSource} = this.transformSource( + filename, + fileSource, + { + ...options, + instrument: false + } + ); + return transformedJsonSource; + } + return fileSource; + } + async requireAndTranspileModule( + moduleName, + callback, + options = { + applyInteropRequireDefault: true, + instrument: false, + supportsDynamicImport: false, + supportsExportNamespaceFrom: false, + supportsStaticESM: false, + supportsTopLevelAwait: false + } + ) { + let transforming = false; + const {applyInteropRequireDefault, ...transformOptions} = options; + const revertHook = (0, _pirates().addHook)( + (code, filename) => { + try { + transforming = true; + return ( + this.transformSource(filename, code, transformOptions).code || code + ); + } finally { + transforming = false; + } + }, + { + // Exclude `mjs` extension when addHook because pirates don't support hijack es module + exts: this._config.moduleFileExtensions + .filter(ext => ext !== 'mjs') + .map(ext => `.${ext}`), + ignoreNodeModules: false, + matcher: filename => { + if (transforming) { + // Don't transform any dependency required by the transformer itself + return false; + } + return this.shouldTransform(filename); + } + } + ); + try { + const module = await (0, _jestUtil().requireOrImportModule)( + moduleName, + applyInteropRequireDefault + ); + if (!callback) { + revertHook(); + return module; + } + const cbResult = callback(module); + if ((0, _jestUtil().isPromise)(cbResult)) { + return await waitForPromiseWithCleanup(cbResult, revertHook).then( + () => module + ); + } + return module; + } finally { + revertHook(); + } + } + shouldTransform(filename) { + const ignoreRegexp = this._cache.ignorePatternsRegExp; + const isIgnored = ignoreRegexp ? ignoreRegexp.test(filename) : false; + return this._config.transform.length !== 0 && !isIgnored; + } +} + +// TODO: do we need to define the generics twice? +async function createTranspilingRequire(config) { + const transformer = await createScriptTransformer(config); + return async function requireAndTranspileModule( + resolverPath, + applyInteropRequireDefault = false + ) { + const transpiledModule = await transformer.requireAndTranspileModule( + resolverPath, + // eslint-disable-next-line @typescript-eslint/no-empty-function + () => {}, + { + applyInteropRequireDefault, + instrument: false, + supportsDynamicImport: false, + // this might be true, depending on node version. + supportsExportNamespaceFrom: false, + supportsStaticESM: false, + supportsTopLevelAwait: false + } + ); + return transpiledModule; + }; +} +const removeFile = path => { + try { + fs().unlinkSync(path); + } catch {} +}; +const stripShebang = content => { + // If the file data starts with a shebang remove it. Leaves the empty line + // to keep stack trace line numbers correct. + if (content.startsWith('#!')) { + return content.replace(/^#!.*/, ''); + } else { + return content; + } +}; + +/** + * This is like `writeCacheFile` but with an additional sanity checksum. We + * cannot use the same technique for source maps because we expose source map + * cache file paths directly to callsites, with the expectation they can read + * it right away. This is not a great system, because source map cache file + * could get corrupted, out-of-sync, etc. + */ +function writeCodeCacheFile(cachePath, code) { + const checksum = (0, _crypto().createHash)('sha1') + .update(code) + .digest('hex') + .substring(0, 32); + writeCacheFile(cachePath, `${checksum}\n${code}`); +} + +/** + * Read counterpart of `writeCodeCacheFile`. We verify that the content of the + * file matches the checksum, in case some kind of corruption happened. This + * could happen if an older version of `jest-runtime` writes non-atomically to + * the same cache, for example. + */ +function readCodeCacheFile(cachePath) { + const content = readCacheFile(cachePath); + if (content == null) { + return null; + } + const code = content.substring(33); + const checksum = (0, _crypto().createHash)('sha1') + .update(code) + .digest('hex') + .substring(0, 32); + if (checksum === content.substring(0, 32)) { + return code; + } + return null; +} + +/** + * Writing to the cache atomically relies on 'rename' being atomic on most + * file systems. Doing atomic write reduces the risk of corruption by avoiding + * two processes to write to the same file at the same time. It also reduces + * the risk of reading a file that's being overwritten at the same time. + */ +const writeCacheFile = (cachePath, fileData) => { + try { + (0, _writeFileAtomic().sync)(cachePath, fileData, { + encoding: 'utf8', + fsync: false + }); + } catch (e) { + if (!(e instanceof Error)) { + throw e; + } + if (cacheWriteErrorSafeToIgnore(e, cachePath)) { + return; + } + e.message = `jest: failed to cache transform results in: ${cachePath}\nFailure message: ${e.message}`; + removeFile(cachePath); + throw e; + } +}; + +/** + * On Windows, renames are not atomic, leading to EPERM exceptions when two + * processes attempt to rename to the same target file at the same time. + * If the target file exists we can be reasonably sure another process has + * legitimately won a cache write race and ignore the error. + */ +const cacheWriteErrorSafeToIgnore = (e, cachePath) => + process.platform === 'win32' && + e.code === 'EPERM' && + fs().existsSync(cachePath); +const readCacheFile = cachePath => { + if (!fs().existsSync(cachePath)) { + return null; + } + let fileData; + try { + fileData = fs().readFileSync(cachePath, 'utf8'); + } catch (e) { + if (!(e instanceof Error)) { + throw e; + } + // on windows write-file-atomic is not atomic which can + // result in this error + if (e.code === 'ENOENT' && process.platform === 'win32') { + return null; + } + e.message = `jest: failed to read cache file: ${cachePath}\nFailure message: ${e.message}`; + removeFile(cachePath); + throw e; + } + if (fileData == null) { + // We must have somehow created the file but failed to write to it, + // let's delete it and retry. + removeFile(cachePath); + } + return fileData; +}; +const getScriptCacheKey = (filename, instrument) => { + const mtime = fs().statSync(filename).mtime; + return `${filename}_${mtime.getTime()}${instrument ? '_instrumented' : ''}`; +}; +const calcIgnorePatternRegExp = config => { + if ( + config.transformIgnorePatterns == null || + config.transformIgnorePatterns.length === 0 + ) { + return undefined; + } + return new RegExp(config.transformIgnorePatterns.join('|')); +}; +const calcTransformRegExp = config => { + if (!config.transform.length) { + return undefined; + } + const transformRegexp = []; + for (let i = 0; i < config.transform.length; i++) { + transformRegexp.push([ + new RegExp(config.transform[i][0]), + config.transform[i][1], + config.transform[i][2] + ]); + } + return transformRegexp; +}; +function assertSyncTransformer(transformer, name) { + (0, _jestUtil().invariant)(name); + (0, _jestUtil().invariant)( + typeof transformer.process === 'function', + (0, _runtimeErrorsAndWarnings.makeInvalidSyncTransformerError)(name) + ); +} +async function createScriptTransformer(config, cacheFS = new Map()) { + const transformer = new ScriptTransformer(config, cacheFS); + await transformer.loadTransformers(); + return transformer; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/build/enhanceUnexpectedTokenMessage.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/build/enhanceUnexpectedTokenMessage.js new file mode 100644 index 0000000000000000000000000000000000000000..d0498e696837756aa57b9ca8ab58526620493533 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/build/enhanceUnexpectedTokenMessage.js @@ -0,0 +1,76 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = handlePotentialSyntaxError; +exports.enhanceUnexpectedTokenMessage = enhanceUnexpectedTokenMessage; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const DOT = ' \u2022 '; +function handlePotentialSyntaxError(e) { + if (e.codeFrame != null) { + e.stack = `${e.message}\n${e.codeFrame}`; + } + if ( + // `instanceof` might come from the wrong context + e.name === 'SyntaxError' && + !e.message.includes(' expected') + ) { + throw enhanceUnexpectedTokenMessage(e); + } + return e; +} +function enhanceUnexpectedTokenMessage(e) { + e.stack = `${_chalk().default.bold.red( + 'Jest encountered an unexpected token' + )} + +Jest failed to parse a file. This happens e.g. when your code or its dependencies use non-standard JavaScript syntax, or when Jest is not configured to support such syntax. + +Out of the box Jest supports Babel, which will be used to transform your files into valid JS based on your Babel configuration. + +By default "node_modules" folder is ignored by transformers. + +Here's what you can do: +${DOT}If you are trying to use ECMAScript Modules, see ${_chalk().default.underline( + 'https://jestjs.io/docs/ecmascript-modules' + )} for how to enable it. +${DOT}If you are trying to use TypeScript, see ${_chalk().default.underline( + 'https://jestjs.io/docs/getting-started#using-typescript' + )} +${DOT}To have some of your "node_modules" files transformed, you can specify a custom ${_chalk().default.bold( + '"transformIgnorePatterns"' + )} in your config. +${DOT}If you need a custom transformation specify a ${_chalk().default.bold( + '"transform"' + )} option in your config. +${DOT}If you simply want to mock your non-JS modules (e.g. binary assets) you can stub them out with the ${_chalk().default.bold( + '"moduleNameMapper"' + )} config option. + +You'll find more details and examples of these config options in the docs: +${_chalk().default.cyan('https://jestjs.io/docs/configuration')} +For information about custom transformations, see: +${_chalk().default.cyan('https://jestjs.io/docs/code-transformation')} + +${_chalk().default.bold.red('Details:')} + +${e.stack ?? ''}`.trimRight(); + return e; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a5065488fc379a12c4385fda5a34a2b403333291 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/build/index.d.ts @@ -0,0 +1,240 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +import type {Config} from '@jest/types'; +import type {EncodedSourceMap} from '@jridgewell/trace-mapping'; +import type {TransformTypes} from '@jest/types'; + +export declare interface AsyncTransformer { + /** + * Indicates if the transformer is capable of instrumenting the code for code coverage. + * + * If V8 coverage is _not_ active, and this is `true`, Jest will assume the code is instrumented. + * If V8 coverage is _not_ active, and this is `false`. Jest will instrument the code returned by this transformer using Babel. + */ + canInstrument?: boolean; + getCacheKey?: ( + sourceText: string, + sourcePath: string, + options: TransformOptions, + ) => string; + getCacheKeyAsync?: ( + sourceText: string, + sourcePath: string, + options: TransformOptions, + ) => Promise; + process?: ( + sourceText: string, + sourcePath: string, + options: TransformOptions, + ) => TransformedSource; + processAsync: ( + sourceText: string, + sourcePath: string, + options: TransformOptions, + ) => Promise; +} + +export declare interface CallerTransformOptions { + supportsDynamicImport: boolean; + supportsExportNamespaceFrom: boolean; + supportsStaticESM: boolean; + supportsTopLevelAwait: boolean; +} + +export declare function createScriptTransformer( + config: Config.ProjectConfig, + cacheFS?: StringMap, +): Promise; + +export declare function createTranspilingRequire( + config: Config.ProjectConfig, +): Promise< + ( + resolverPath: string, + applyInteropRequireDefault?: boolean, + ) => Promise +>; + +declare interface ErrorWithCodeFrame extends Error { + codeFrame?: string; +} + +declare interface FixedRawSourceMap extends Omit { + version: number; +} + +export declare function handlePotentialSyntaxError( + e: ErrorWithCodeFrame, +): ErrorWithCodeFrame; + +declare interface ReducedTransformOptions extends CallerTransformOptions { + instrument: boolean; +} + +declare interface RequireAndTranspileModuleOptions + extends ReducedTransformOptions { + applyInteropRequireDefault: boolean; +} + +export declare type ScriptTransformer = ScriptTransformer_2; + +declare class ScriptTransformer_2 { + private readonly _config; + private readonly _cacheFS; + private readonly _cache; + private readonly _transformCache; + private _transformsAreLoaded; + constructor(_config: Config.ProjectConfig, _cacheFS: StringMap); + private _buildCacheKeyFromFileInfo; + private _buildTransformCacheKey; + private _getCacheKey; + private _getCacheKeyAsync; + private _createCachedFilename; + private _getFileCachePath; + private _getFileCachePathAsync; + private _getTransformPatternAndPath; + private _getTransformPath; + loadTransformers(): Promise; + private _getTransformer; + private _instrumentFile; + private _buildTransformResult; + transformSource( + filepath: string, + content: string, + options: ReducedTransformOptions, + ): TransformResult; + transformSourceAsync( + filepath: string, + content: string, + options: ReducedTransformOptions, + ): Promise; + private _transformAndBuildScriptAsync; + private _transformAndBuildScript; + transformAsync( + filename: string, + options: TransformationOptions, + fileSource?: string, + ): Promise; + transform( + filename: string, + options: TransformationOptions, + fileSource?: string, + ): TransformResult; + transformJson( + filename: string, + options: TransformationOptions, + fileSource: string, + ): string; + requireAndTranspileModule( + moduleName: string, + callback?: (module: ModuleType) => void | Promise, + options?: RequireAndTranspileModuleOptions, + ): Promise; + shouldTransform(filename: string): boolean; +} + +export declare function shouldInstrument( + filename: string, + options: ShouldInstrumentOptions, + config: Config.ProjectConfig, + loadedFilenames?: Array, +): boolean; + +export declare interface ShouldInstrumentOptions + extends Pick< + Config.GlobalConfig, + 'collectCoverage' | 'collectCoverageFrom' | 'coverageProvider' + > { + changedFiles?: Set; + sourcesRelatedToTestsInChangedFiles?: Set; +} + +declare type StringMap = Map; + +export declare interface SyncTransformer { + /** + * Indicates if the transformer is capable of instrumenting the code for code coverage. + * + * If V8 coverage is _not_ active, and this is `true`, Jest will assume the code is instrumented. + * If V8 coverage is _not_ active, and this is `false`. Jest will instrument the code returned by this transformer using Babel. + */ + canInstrument?: boolean; + getCacheKey?: ( + sourceText: string, + sourcePath: string, + options: TransformOptions, + ) => string; + getCacheKeyAsync?: ( + sourceText: string, + sourcePath: string, + options: TransformOptions, + ) => Promise; + process: ( + sourceText: string, + sourcePath: string, + options: TransformOptions, + ) => TransformedSource; + processAsync?: ( + sourceText: string, + sourcePath: string, + options: TransformOptions, + ) => Promise; +} + +export declare interface TransformationOptions + extends ShouldInstrumentOptions, + CallerTransformOptions { + isInternalModule?: boolean; +} + +export declare type TransformedSource = { + code: string; + map?: FixedRawSourceMap | string | null; +}; + +/** + * We have both sync (`process`) and async (`processAsync`) code transformation, which both can be provided. + * `require` will always use `process`, and `import` will use `processAsync` if it exists, otherwise fall back to `process`. + * Meaning, if you use `import` exclusively you do not need `process`, but in most cases supplying both makes sense: + * Jest transpiles on demand rather than ahead of time, so the sync one needs to exist. + * + * For more info on the sync vs async model, see https://jestjs.io/docs/code-transformation#writing-custom-transformers + */ +declare type Transformer_2 = + | SyncTransformer + | AsyncTransformer; +export {Transformer_2 as Transformer}; + +export declare type TransformerCreator< + X extends Transformer_2, + TransformerConfig = unknown, +> = (transformerConfig?: TransformerConfig) => X | Promise; + +/** + * Instead of having your custom transformer implement the Transformer interface + * directly, you can choose to export a factory function to dynamically create + * transformers. This is to allow having a transformer config in your jest config. + */ +export declare type TransformerFactory = { + createTransformer: TransformerCreator; +}; + +export declare interface TransformOptions + extends ReducedTransformOptions { + /** Cached file system which is used by `jest-runtime` to improve performance. */ + cacheFS: StringMap; + /** Jest configuration of currently running project. */ + config: Config.ProjectConfig; + /** Stringified version of the `config` - useful in cache busting. */ + configString: string; + /** Transformer configuration passed through `transform` option by the user. */ + transformerConfig: TransformerConfig; +} + +export declare type TransformResult = TransformTypes.TransformResult; + +export {}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..7b2d0303af5b6095f8cf55717c647ab0b05c4dd5 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/build/index.js @@ -0,0 +1,37 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +Object.defineProperty(exports, 'createScriptTransformer', { + enumerable: true, + get: function () { + return _ScriptTransformer.createScriptTransformer; + } +}); +Object.defineProperty(exports, 'createTranspilingRequire', { + enumerable: true, + get: function () { + return _ScriptTransformer.createTranspilingRequire; + } +}); +Object.defineProperty(exports, 'handlePotentialSyntaxError', { + enumerable: true, + get: function () { + return _enhanceUnexpectedTokenMessage.default; + } +}); +Object.defineProperty(exports, 'shouldInstrument', { + enumerable: true, + get: function () { + return _shouldInstrument.default; + } +}); +var _ScriptTransformer = require('./ScriptTransformer'); +var _shouldInstrument = _interopRequireDefault(require('./shouldInstrument')); +var _enhanceUnexpectedTokenMessage = _interopRequireDefault( + require('./enhanceUnexpectedTokenMessage') +); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/build/runtimeErrorsAndWarnings.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/build/runtimeErrorsAndWarnings.js new file mode 100644 index 0000000000000000000000000000000000000000..eba96778f2af706494fdff36382a5aa7b40752fe --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/build/runtimeErrorsAndWarnings.js @@ -0,0 +1,94 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.makeInvalidTransformerError = + exports.makeInvalidSyncTransformerError = + exports.makeInvalidSourceMapWarning = + exports.makeInvalidReturnValueError = + void 0; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _slash() { + const data = _interopRequireDefault(require('slash')); + _slash = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const BULLET = '\u25cf '; +const DOCUMENTATION_NOTE = ` ${_chalk().default.bold( + 'Code Transformation Documentation:' +)} + https://jestjs.io/docs/code-transformation +`; +const UPGRADE_NOTE = ` ${_chalk().default.bold( + 'This error may be caused by a breaking change in Jest 28:' +)} + https://jestjs.io/docs/28.x/upgrading-to-jest28#transformer +`; +const makeInvalidReturnValueError = transformPath => + _chalk().default.red( + [ + _chalk().default.bold(`${BULLET}Invalid return value:`), + ' `process()` or/and `processAsync()` method of code transformer found at ', + ` "${(0, _slash().default)(transformPath)}" `, + ' should return an object or a Promise resolving to an object. The object ', + ' must have `code` property with a string of processed code.', + '' + ].join('\n') + + UPGRADE_NOTE + + DOCUMENTATION_NOTE + ); +exports.makeInvalidReturnValueError = makeInvalidReturnValueError; +const makeInvalidSourceMapWarning = (filename, transformPath) => + _chalk().default.yellow( + [ + _chalk().default.bold(`${BULLET}Invalid source map:`), + ` The source map for "${(0, _slash().default)( + filename + )}" returned by "${(0, _slash().default)(transformPath)}" is invalid.`, + ' Proceeding without source mapping for that file.' + ].join('\n') + ); +exports.makeInvalidSourceMapWarning = makeInvalidSourceMapWarning; +const makeInvalidSyncTransformerError = transformPath => + _chalk().default.red( + [ + _chalk().default.bold(`${BULLET}Invalid synchronous transformer module:`), + ` "${(0, _slash().default)( + transformPath + )}" specified in the "transform" object of Jest configuration`, + ' must export a `process` function.', + '' + ].join('\n') + DOCUMENTATION_NOTE + ); +exports.makeInvalidSyncTransformerError = makeInvalidSyncTransformerError; +const makeInvalidTransformerError = transformPath => + _chalk().default.red( + [ + _chalk().default.bold(`${BULLET}Invalid transformer module:`), + ` "${(0, _slash().default)( + transformPath + )}" specified in the "transform" object of Jest configuration`, + ' must export a `process` or `processAsync` or `createTransformer` function.', + '' + ].join('\n') + DOCUMENTATION_NOTE + ); +exports.makeInvalidTransformerError = makeInvalidTransformerError; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/build/shouldInstrument.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/build/shouldInstrument.js new file mode 100644 index 0000000000000000000000000000000000000000..8ba5d94b01764ed153b6e00f36cdb725dab2eb98 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/build/shouldInstrument.js @@ -0,0 +1,177 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = shouldInstrument; +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _micromatch() { + const data = _interopRequireDefault(require('micromatch')); + _micromatch = function () { + return data; + }; + return data; +} +function _jestRegexUtil() { + const data = require('jest-regex-util'); + _jestRegexUtil = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const MOCKS_PATTERN = new RegExp( + (0, _jestRegexUtil().escapePathForRegex)( + `${path().sep}__mocks__${path().sep}` + ) +); +const cachedRegexes = new Map(); +const getRegex = regexStr => { + if (!cachedRegexes.has(regexStr)) { + cachedRegexes.set(regexStr, new RegExp(regexStr)); + } + const regex = cachedRegexes.get(regexStr); + + // prevent stateful regexes from breaking, just in case + regex.lastIndex = 0; + return regex; +}; +function shouldInstrument(filename, options, config, loadedFilenames) { + if (!options.collectCoverage) { + return false; + } + if ( + config.forceCoverageMatch.length && + _micromatch().default.any(filename, config.forceCoverageMatch) + ) { + return true; + } + if ( + !config.testPathIgnorePatterns.some(pattern => + getRegex(pattern).test(filename) + ) + ) { + if (config.testRegex.some(regex => new RegExp(regex).test(filename))) { + return false; + } + if ( + (0, _jestUtil().globsToMatcher)(config.testMatch)( + (0, _jestUtil().replacePathSepForGlob)(filename) + ) + ) { + return false; + } + } + if ( + options.collectCoverageFrom.length === 0 && + loadedFilenames != null && + !loadedFilenames.includes(filename) + ) { + return false; + } + if ( + // still cover if `only` is specified + options.collectCoverageFrom.length && + !(0, _jestUtil().globsToMatcher)(options.collectCoverageFrom)( + (0, _jestUtil().replacePathSepForGlob)( + path().relative(config.rootDir, filename) + ) + ) + ) { + return false; + } + if ( + config.coveragePathIgnorePatterns.some(pattern => !!filename.match(pattern)) + ) { + return false; + } + if (config.globalSetup === filename) { + return false; + } + if (config.globalTeardown === filename) { + return false; + } + if (config.setupFiles.includes(filename)) { + return false; + } + if (config.setupFilesAfterEnv.includes(filename)) { + return false; + } + if (MOCKS_PATTERN.test(filename)) { + return false; + } + if (options.changedFiles && !options.changedFiles.has(filename)) { + if (!options.sourcesRelatedToTestsInChangedFiles) { + return false; + } + if (!options.sourcesRelatedToTestsInChangedFiles.has(filename)) { + return false; + } + } + if (filename.endsWith('.json')) { + return false; + } + return true; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/build/types.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/build/types.js new file mode 100644 index 0000000000000000000000000000000000000000..ad9a93a7c160f02945911772460eb8a1bcb003db --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/build/types.js @@ -0,0 +1 @@ +'use strict'; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/package.json new file mode 100644 index 0000000000000000000000000000000000000000..20d4209bcb3352d84e12d79a2da5fcdc8bea57e9 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/@jest/transform/package.json @@ -0,0 +1,52 @@ +{ + "name": "@jest/transform", + "version": "29.7.0", + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/jest-transform" + }, + "license": "MIT", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "dependencies": { + "@babel/core": "^7.11.6", + "@jest/types": "^29.6.3", + "@jridgewell/trace-mapping": "^0.3.18", + "babel-plugin-istanbul": "^6.1.1", + "chalk": "^4.0.0", + "convert-source-map": "^2.0.0", + "fast-json-stable-stringify": "^2.1.0", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^29.7.0", + "jest-regex-util": "^29.6.3", + "jest-util": "^29.7.0", + "micromatch": "^4.0.4", + "pirates": "^4.0.4", + "slash": "^3.0.0", + "write-file-atomic": "^4.0.2" + }, + "devDependencies": { + "@jest/test-utils": "^29.7.0", + "@types/babel__core": "^7.1.14", + "@types/convert-source-map": "^2.0.0", + "@types/graceful-fs": "^4.1.3", + "@types/micromatch": "^4.0.1", + "@types/write-file-atomic": "^4.0.0", + "dedent": "^1.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "publishConfig": { + "access": "public" + }, + "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/ansi-regex/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/ansi-regex/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2dbf6af2b6f3b5701c83caaea7ed2210192023a8 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/ansi-regex/index.d.ts @@ -0,0 +1,37 @@ +declare namespace ansiRegex { + interface Options { + /** + Match only the first ANSI escape. + + @default false + */ + onlyFirst: boolean; + } +} + +/** +Regular expression for matching ANSI escape codes. + +@example +``` +import ansiRegex = require('ansi-regex'); + +ansiRegex().test('\u001B[4mcake\u001B[0m'); +//=> true + +ansiRegex().test('cake'); +//=> false + +'\u001B[4mcake\u001B[0m'.match(ansiRegex()); +//=> ['\u001B[4m', '\u001B[0m'] + +'\u001B[4mcake\u001B[0m'.match(ansiRegex({onlyFirst: true})); +//=> ['\u001B[4m'] + +'\u001B]8;;https://github.com\u0007click\u001B]8;;\u0007'.match(ansiRegex()); +//=> ['\u001B]8;;https://github.com\u0007', '\u001B]8;;\u0007'] +``` +*/ +declare function ansiRegex(options?: ansiRegex.Options): RegExp; + +export = ansiRegex; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/ansi-regex/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/ansi-regex/index.js new file mode 100644 index 0000000000000000000000000000000000000000..616ff837d3ff01e028c208062fc699c7f1c8d418 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/ansi-regex/index.js @@ -0,0 +1,10 @@ +'use strict'; + +module.exports = ({onlyFirst = false} = {}) => { + const pattern = [ + '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)', + '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))' + ].join('|'); + + return new RegExp(pattern, onlyFirst ? undefined : 'g'); +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/ansi-regex/license b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/ansi-regex/license new file mode 100644 index 0000000000000000000000000000000000000000..e7af2f77107d73046421ef56c4684cbfdd3c1e89 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/ansi-regex/license @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) Sindre Sorhus (sindresorhus.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/ansi-regex/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/ansi-regex/package.json new file mode 100644 index 0000000000000000000000000000000000000000..017f53116a9e2805ccb12efc3c7fcd7e4384735d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/ansi-regex/package.json @@ -0,0 +1,55 @@ +{ + "name": "ansi-regex", + "version": "5.0.1", + "description": "Regular expression for matching ANSI escape codes", + "license": "MIT", + "repository": "chalk/ansi-regex", + "author": { + "name": "Sindre Sorhus", + "email": "sindresorhus@gmail.com", + "url": "sindresorhus.com" + }, + "engines": { + "node": ">=8" + }, + "scripts": { + "test": "xo && ava && tsd", + "view-supported": "node fixtures/view-codes.js" + }, + "files": [ + "index.js", + "index.d.ts" + ], + "keywords": [ + "ansi", + "styles", + "color", + "colour", + "colors", + "terminal", + "console", + "cli", + "string", + "tty", + "escape", + "formatting", + "rgb", + "256", + "shell", + "xterm", + "command-line", + "text", + "regex", + "regexp", + "re", + "match", + "test", + "find", + "pattern" + ], + "devDependencies": { + "ava": "^2.4.0", + "tsd": "^0.9.0", + "xo": "^0.25.3" + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/ansi-regex/readme.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/ansi-regex/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..4d848bc36f6b862e5db3effa59ebed515730284e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/ansi-regex/readme.md @@ -0,0 +1,78 @@ +# ansi-regex + +> Regular expression for matching [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code) + + +## Install + +``` +$ npm install ansi-regex +``` + + +## Usage + +```js +const ansiRegex = require('ansi-regex'); + +ansiRegex().test('\u001B[4mcake\u001B[0m'); +//=> true + +ansiRegex().test('cake'); +//=> false + +'\u001B[4mcake\u001B[0m'.match(ansiRegex()); +//=> ['\u001B[4m', '\u001B[0m'] + +'\u001B[4mcake\u001B[0m'.match(ansiRegex({onlyFirst: true})); +//=> ['\u001B[4m'] + +'\u001B]8;;https://github.com\u0007click\u001B]8;;\u0007'.match(ansiRegex()); +//=> ['\u001B]8;;https://github.com\u0007', '\u001B]8;;\u0007'] +``` + + +## API + +### ansiRegex(options?) + +Returns a regex for matching ANSI escape codes. + +#### options + +Type: `object` + +##### onlyFirst + +Type: `boolean`
+Default: `false` *(Matches any ANSI escape codes in a string)* + +Match only the first ANSI escape. + + +## FAQ + +### Why do you test for codes not in the ECMA 48 standard? + +Some of the codes we run as a test are codes that we acquired finding various lists of non-standard or manufacturer specific codes. We test for both standard and non-standard codes, as most of them follow the same or similar format and can be safely matched in strings without the risk of removing actual string content. There are a few non-standard control codes that do not follow the traditional format (i.e. they end in numbers) thus forcing us to exclude them from the test because we cannot reliably match them. + +On the historical side, those ECMA standards were established in the early 90's whereas the VT100, for example, was designed in the mid/late 70's. At that point in time, control codes were still pretty ungoverned and engineers used them for a multitude of things, namely to activate hardware ports that may have been proprietary. Somewhere else you see a similar 'anarchy' of codes is in the x86 architecture for processors; there are a ton of "interrupts" that can mean different things on certain brands of processors, most of which have been phased out. + + +## Maintainers + +- [Sindre Sorhus](https://github.com/sindresorhus) +- [Josh Junon](https://github.com/qix-) + + +--- + +
+ + Get professional support for this package with a Tidelift subscription + +
+ + Tidelift helps make open source sustainable for maintainers while giving companies
assurances about security, maintenance, and licensing for their dependencies. + +
diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/babel-plugin-istanbul/CHANGELOG.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/babel-plugin-istanbul/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..aa57d4f1aec33b3fd3edc98bc50c74c0a3d2ba3e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/babel-plugin-istanbul/CHANGELOG.md @@ -0,0 +1,320 @@ +# Changelog + +All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines. + +### [6.1.1](https://www.github.com/istanbuljs/babel-plugin-istanbul/compare/v6.1.0...v6.1.1) (2021-10-16) + + +### Bug Fixes + +* **build:** first automated publication ([9a1b893](https://www.github.com/istanbuljs/babel-plugin-istanbul/commit/9a1b89342565d1127a011e31262520b057120531)) + +## [6.1.0](https://www.github.com/istanbuljs/babel-plugin-istanbul/compare/v6.0.0...v6.1.0) (2021-10-16) + + +### Features + +* **instrumenter:** instrumenter with fixes for branchMap instrumentation ([#265](https://www.github.com/istanbuljs/babel-plugin-istanbul/issues/265)) ([1e9ec62](https://www.github.com/istanbuljs/babel-plugin-istanbul/commit/1e9ec62b50c9d2224e7bb0ccb071fd10b80e018f)) + +## [6.0.0](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v5.2.0...v6.0.0) (2019-12-20) + + +### ⚠ BREAKING CHANGES + +* Drop node.js 6 (#226) + +### Features + +* Add support for instrumenter options ([#227](https://github.com/istanbuljs/babel-plugin-istanbul/issues/227)) ([fe08f5b](https://github.com/istanbuljs/babel-plugin-istanbul/commit/fe08f5b8282136c7ed9375fa32148586bd6a7e28)), closes [#208](https://github.com/istanbuljs/babel-plugin-istanbul/issues/208) [#212](https://github.com/istanbuljs/babel-plugin-istanbul/issues/212) +* Drop node.js 6 ([#226](https://github.com/istanbuljs/babel-plugin-istanbul/issues/226)) ([93db21a](https://github.com/istanbuljs/babel-plugin-istanbul/commit/93db21aa2bbdbb06fb784f52c24a7847fad6be92)), closes [#209](https://github.com/istanbuljs/babel-plugin-istanbul/issues/209) + +## [5.2.0](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v5.1.4...v5.2.0) (2019-07-18) + + +### Bug Fixes + +* Print explicit error if use with babel 6 is attempted ([#207](https://github.com/istanbuljs/babel-plugin-istanbul/issues/207)) ([a12cf16](https://github.com/istanbuljs/babel-plugin-istanbul/commit/a12cf16)) + + +### Features + +* Support turning off node_modules default exclude via flag ([#172](https://github.com/istanbuljs/babel-plugin-istanbul/issues/172)) ([a314f06](https://github.com/istanbuljs/babel-plugin-istanbul/commit/a314f06)) + + + +## [5.1.4](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v5.1.3...v5.1.4) (2019-04-25) + + + +## [5.1.3](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v5.1.2...v5.1.3) (2019-04-23) + + +### Bug Fixes + +* Revert [#192](https://github.com/istanbuljs/babel-plugin-istanbul/issues/192) ([201a933](https://github.com/istanbuljs/babel-plugin-istanbul/commit/201a933)) due to regression detailed at [#201](https://github.com/istanbuljs/babel-plugin-istanbul/issues/201) + + + +## [5.1.2](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v5.1.1...v5.1.2) (2019-04-10) + + +### Bug Fixes + +* Ensure correct scope references after traversal ([#192](https://github.com/istanbuljs/babel-plugin-istanbul/issues/192)) ([201a933](https://github.com/istanbuljs/babel-plugin-istanbul/commit/201a933)) + + + + +## [5.1.1](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v5.1.0...v5.1.1) (2019-01-11) + + +### Bug Fixes + +* respect changes of cwd in options ([#171](https://github.com/istanbuljs/babel-plugin-istanbul/issues/171)) ([adec723](https://github.com/istanbuljs/babel-plugin-istanbul/commit/adec723)) + + + + +# [5.1.0](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v5.0.1...v5.1.0) (2018-09-07) + + +### Features + +* Bump dependencies. ([b509649](https://github.com/istanbuljs/babel-plugin-istanbul/commit/b509649)) + + + + +## [5.0.1](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v5.0.0...v5.0.1) (2018-07-24) + + + + +# [5.0.0](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v4.1.6...v5.0.0) (2018-06-27) + + +### Features + +* upgrade to babel 7 and newest istanbul libraries ([#158](https://github.com/istanbuljs/babel-plugin-istanbul/issues/158)) ([a9e1564](https://github.com/istanbuljs/babel-plugin-istanbul/commit/a9e1564)) + + +### BREAKING CHANGES + +* Drop node 4 support, upgrade to babel 7, stop shipping @babel/plugin-syntax-object-rest-spread + + + + +## 4.1.6 (2018-03-09) + +* chore: explicit update of istanbul dependencies (#149) ([77b6eb7](https://github.com/istanbuljs/babel-plugin-istanbul/commit/77b6eb7)), closes [#149](https://github.com/istanbuljs/babel-plugin-istanbul/issues/149) +* chore(package): update coveralls to version 3.0.0 (#133) ([7045a03](https://github.com/istanbuljs/babel-plugin-istanbul/commit/7045a03)), closes [#133](https://github.com/istanbuljs/babel-plugin-istanbul/issues/133) +* chore(package): update mocha to version 4.0.0 (#134) ([38176ba](https://github.com/istanbuljs/babel-plugin-istanbul/commit/38176ba)), closes [#134](https://github.com/istanbuljs/babel-plugin-istanbul/issues/134) +* fix: babel-preset-es2015 => babel-preset-env (#138) ([18fe954](https://github.com/istanbuljs/babel-plugin-istanbul/commit/18fe954)), closes [#138](https://github.com/istanbuljs/babel-plugin-istanbul/issues/138) +* fix: include object-spread-syntax plugin (#141) ([428a952](https://github.com/istanbuljs/babel-plugin-istanbul/commit/428a952)), closes [#141](https://github.com/istanbuljs/babel-plugin-istanbul/issues/141) + + + + +## [4.1.5](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v4.1.2...v4.1.5) (2017-08-23) + + + + +## [4.1.4](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v4.1.3...v4.1.4) (2017-05-27) + + + + +## [4.1.3](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v4.1.1...v4.1.3) (2017-04-29) + + + + +## [4.1.2](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v4.1.1...v4.1.2) (2017-03-27) + + + + +## [4.1.1](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v4.1.0...v4.1.1) (2017-03-22) + + +### Bug Fixes + +* explicit upgrade to patched version of istanbul-lib-instrument ([db8ecbe](https://github.com/istanbuljs/babel-plugin-istanbul/commit/db8ecbe)) + + + + +# [4.1.0](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v4.0.0...v4.1.0) (2017-03-21) + + +### Features + +* add includeUntested option to expose coverage of all instrumented files ([#80](https://github.com/istanbuljs/babel-plugin-istanbul/issues/80)) ([b078bbd](https://github.com/istanbuljs/babel-plugin-istanbul/commit/b078bbd)) + + + + +# [4.0.0](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v3.1.2...v4.0.0) (2017-02-07) + + +### Bug Fixes + +* load configuration from process.env.NYC_CONFIG if present ([#93](https://github.com/istanbuljs/babel-plugin-istanbul/issues/93)) ([e902924](https://github.com/istanbuljs/babel-plugin-istanbul/commit/e902924)) + + +### Features + +* drop Node 0.10 and 0.12 support, upgrade dependencies to reflect this ([#88](https://github.com/istanbuljs/babel-plugin-istanbul/issues/88)) ([594c03a](https://github.com/istanbuljs/babel-plugin-istanbul/commit/594c03a)) +* we can now use the language feature Object.assign ([#92](https://github.com/istanbuljs/babel-plugin-istanbul/issues/92)) ([f77db2a](https://github.com/istanbuljs/babel-plugin-istanbul/commit/f77db2a)) + + +### BREAKING CHANGES + +* I've updated dependencies and dropped Node 0.10 and Node 0.12 support. + + + + +## [3.1.2](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v3.1.1...v3.1.2) (2017-01-04) + + +### Bug Fixes + +* address regression related to export const foo = () => {} ([#79](https://github.com/istanbuljs/babel-plugin-istanbul/issues/79)) ([f870a8f](https://github.com/istanbuljs/babel-plugin-istanbul/commit/f870a8f)) + + + + +## [3.1.1](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v3.1.0...v3.1.1) (2017-01-02) + + + + +# [3.1.0](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v3.0.0...v3.1.0) (2016-12-27) + + +### Bug Fixes + +* upgrade a bunch of core dependencies ([#77](https://github.com/istanbuljs/babel-plugin-istanbul/issues/77)) ([e764330](https://github.com/istanbuljs/babel-plugin-istanbul/commit/e764330)) + + +### Features + +* accept source map input for the visitor ([#75](https://github.com/istanbuljs/babel-plugin-istanbul/issues/75)) ([437e90b](https://github.com/istanbuljs/babel-plugin-istanbul/commit/437e90b)) + + + + +# [3.0.0](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v2.0.3...v3.0.0) (2016-11-14) + + +### Chores + +* **package:** update test-exclude to version 3.0.0 ([#68](https://github.com/istanbuljs/babel-plugin-istanbul/issues/68)) ([0396385](https://github.com/istanbuljs/babel-plugin-istanbul/commit/0396385)) + + +### BREAKING CHANGES + +* package: test-exclude now adds `**/node_modules/**` as exclude rule by default. + + + + +## [2.0.3](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v2.0.2...v2.0.3) (2016-10-17) + + +### Bug Fixes + +* force istanbul-lib-instrument with variable hoisting fix ([#64](https://github.com/istanbuljs/babel-plugin-istanbul/issues/64)) ([209a0cf](https://github.com/istanbuljs/babel-plugin-istanbul/commit/209a0cf)) +* switch deprecated lodash.assign for object-assign ([#58](https://github.com/istanbuljs/babel-plugin-istanbul/issues/58)) ([6e051fc](https://github.com/istanbuljs/babel-plugin-istanbul/commit/6e051fc)) + + + + +## [2.0.2](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v2.0.1...v2.0.2) (2016-09-08) + + +### Bug Fixes + +* take realpath of cwd, whether or not set in env ([#37](https://github.com/istanbuljs/babel-plugin-istanbul/issues/37)) ([6274d83](https://github.com/istanbuljs/babel-plugin-istanbul/commit/6274d83)) + + + + +## [2.0.1](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v2.0.0...v2.0.1) (2016-09-02) + + +### Bug Fixes + +* update istanbul-lib-instrument ([573e0d4](https://github.com/istanbuljs/babel-plugin-istanbul/commit/573e0d4)) + + + + +# [2.0.0](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v1.1.0...v2.0.0) (2016-08-14) + + +### Chores + +* upgrade to version of test-exclude with new exclude rules ([#35](https://github.com/istanbuljs/babel-plugin-istanbul/issues/35)) ([220ce2b](https://github.com/istanbuljs/babel-plugin-istanbul/commit/220ce2b)) + + +### BREAKING CHANGES + +* see https://github.com/istanbuljs/test-exclude/blob/master/CHANGELOG.md#breaking-changes + + + + +# [1.1.0](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v1.0.3...v1.1.0) (2016-07-21) + + +### Bug Fixes + +* upgrade to istanbul-lib-instrument with faster babel-generator ([#18](https://github.com/istanbuljs/babel-plugin-istanbul/issues/18)) ([d33263c](https://github.com/istanbuljs/babel-plugin-istanbul/commit/d33263c)) + + +### Features + +* allow exclude/include options to be passed as Babel plugin config ([#16](https://github.com/istanbuljs/babel-plugin-istanbul/issues/16)) ([cf68421](https://github.com/istanbuljs/babel-plugin-istanbul/commit/cf68421)) + + + + +## [1.0.3](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v1.0.2...v1.0.3) (2016-07-09) + + +### Bug Fixes + +* keep using NYC_CWD if available ([#10](https://github.com/istanbuljs/babel-plugin-istanbul/issues/10)) ([db0352b](https://github.com/istanbuljs/babel-plugin-istanbul/commit/db0352b)) + + + + +## [1.0.2](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v1.0.1...v1.0.2) (2016-07-03) + + +### Bug Fixes + +* take realpath of process.cwd(), fixes [#7](https://github.com/istanbuljs/babel-plugin-istanbul/issues/7) ([#8](https://github.com/istanbuljs/babel-plugin-istanbul/issues/8)) ([e8d3785](https://github.com/istanbuljs/babel-plugin-istanbul/commit/e8d3785)), closes [#7](https://github.com/istanbuljs/babel-plugin-istanbul/issues/7) [#8](https://github.com/istanbuljs/babel-plugin-istanbul/issues/8) + + + + +## [1.0.1](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v1.0.0...v1.0.1) (2016-06-30) + + +### Bug Fixes + +* upgrade to version of istanbul-lib-instrument that fixes some out of bounds issues ([#6](https://github.com/istanbuljs/babel-plugin-istanbul/issues/6)) ([a949065](https://github.com/istanbuljs/babel-plugin-istanbul/commit/a949065)), closes [#6](https://github.com/istanbuljs/babel-plugin-istanbul/issues/6) + + + +# 1.0.0 (2016-06-26) + + +### Features + +* port functionality from __coverage__, get ready for first release ([#2](https://github.com/istanbuljs/babel-plugin-istanbul/issues/2)) ([2a8ee44](https://github.com/istanbuljs/babel-plugin-istanbul/commit/2a8ee44)) diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/babel-plugin-istanbul/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/babel-plugin-istanbul/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..22f21ab994030c471bbe1ea9cc9c59ed10fa7f56 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/babel-plugin-istanbul/LICENSE @@ -0,0 +1,27 @@ +Copyright (c) 2016, Istanbul Code Coverage +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +* Neither the name of babel-plugin-istanbul nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/babel-plugin-istanbul/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/babel-plugin-istanbul/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a027e9b78223e042fa95bd119e8250250850359b --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/babel-plugin-istanbul/README.md @@ -0,0 +1,135 @@ +# babel-plugin-istanbul + +[![Coverage Status](https://coveralls.io/repos/github/istanbuljs/babel-plugin-istanbul/badge.svg?branch=master)](https://coveralls.io/github/istanbuljs/babel-plugin-istanbul?branch=master) +[![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow.svg)](https://conventionalcommits.org) +[![community slack](http://devtoolscommunity.herokuapp.com/badge.svg)](http://devtoolscommunity.herokuapp.com) + +_Having problems? want to contribute? join our [community slack](http://devtoolscommunity.herokuapp.com)_. + +A Babel plugin that instruments your code with Istanbul coverage. +It can instantly be used with [karma-coverage](https://github.com/karma-runner/karma-coverage) and mocha on Node.js (through [nyc](https://github.com/bcoe/nyc)). + +__Note:__ This plugin does not generate any report or save any data to any file; +it only adds instrumenting code to your JavaScript source code. +To integrate with testing tools, please see the [Integrations](#integrations) section. + +## Usage + +Install it: + +``` +npm install --save-dev babel-plugin-istanbul +``` + +Add it to `.babelrc` in test mode: + +```js +{ + "env": { + "test": { + "plugins": [ "istanbul" ] + } + } +} +``` + +Optionally, use [cross-env](https://www.npmjs.com/package/cross-env) to set +`NODE_ENV=test`: + +```json +{ + "scripts": { + "test": "cross-env NODE_ENV=test nyc --reporter=lcov --reporter=text mocha test/*.js" + } +} +``` + +## Integrations + +### karma + +It _just works_ with Karma. First, make sure that the code is already transpiled by Babel (either using `karma-babel-preprocessor`, `karma-webpack`, or `karma-browserify`). Then, simply set up [karma-coverage](https://github.com/karma-runner/karma-coverage) according to the docs, but __don’t add the `coverage` preprocessor.__ This plugin has already instrumented your code, and Karma should pick it up automatically. + +It has been tested with [bemusic/bemuse](https://codecov.io/github/bemusic/bemuse) project, which contains ~2400 statements. + +### mocha on node.js (through nyc) + +Configure Mocha to transpile JavaScript code using Babel, then you can run your tests with [`nyc`](https://github.com/bcoe/nyc), which will collect all the coverage report. + +babel-plugin-istanbul respects the `include`/`exclude` configuration options from nyc, +but you also need to __configure NYC not to instrument your code__ by adding these settings in your `package.json`: + +```js + "nyc": { + "sourceMap": false, + "instrument": false + }, +``` + +## Ignoring files + +You don't want to cover your test files as this will skew your coverage results. You can configure this by providing plugin options matching nyc's [`exclude`/`include` rules](https://github.com/bcoe/nyc#excluding-files): + +```json +{ + "env": { + "test": { + "plugins": [ + ["istanbul", { + "exclude": [ + "**/*.spec.js" + ] + }] + ] + } + } +} +``` + +If you don't provide options in your Babel config, the plugin will look for `exclude`/`include` config under an `"nyc"` key in `package.json`. + +You can also use [istanbul's ignore hints](https://github.com/gotwarlost/istanbul/blob/master/ignoring-code-for-coverage.md#ignoring-code-for-coverage-purposes) to specify specific lines of code to skip instrumenting. + +## Source Maps + +By default, this plugin will pick up inline source maps and attach them to the instrumented code such that code coverage can be remapped back to the original source, even for multi-step build processes. This can be memory intensive. Set `useInlineSourceMaps` to prevent this behavior. + +```json +{ + "env": { + "test": { + "plugins": [ + ["istanbul", { + "useInlineSourceMaps": false + }] + ] + } + } +} +``` + +If you're instrumenting code programatically, you can pass a source map explicitly. +```js +import babelPluginIstanbul from 'babel-plugin-istanbul'; + +function instrument(sourceCode, sourceMap, fileName) { + return babel.transform(sourceCode, { + filename, + plugins: [ + [babelPluginIstanbul, { + inputSourceMap: sourceMap + }] + ] + }) +} +``` + +## Credit where credit is due + +The approach used in `babel-plugin-istanbul` was inspired by [Thai Pangsakulyanont](https://github.com/dtinth)'s original library [`babel-plugin-__coverage__`](https://github.com/dtinth/babel-plugin-__coverage__). + +## `babel-plugin-istanbul` for enterprise + +Available as part of the Tidelift Subscription. + +The maintainers of `babel-plugin-istanbul` and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-babel-plugin-istanbul?utm_source=npm-babel-plugin-istanbul&utm_medium=referral&utm_campaign=enterprise&utm_term=repo) diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/babel-plugin-istanbul/lib/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/babel-plugin-istanbul/lib/index.js new file mode 100644 index 0000000000000000000000000000000000000000..8cf743330be881aebef098b71d83ad97883f2a15 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/babel-plugin-istanbul/lib/index.js @@ -0,0 +1,170 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _path = _interopRequireDefault(require("path")); + +var _fs = require("fs"); + +var _child_process = require("child_process"); + +var _helperPluginUtils = require("@babel/helper-plugin-utils"); + +var _istanbulLibInstrument = require("istanbul-lib-instrument"); + +var _testExclude = _interopRequireDefault(require("test-exclude")); + +var _schema = _interopRequireDefault(require("@istanbuljs/schema")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function getRealpath(n) { + try { + return (0, _fs.realpathSync)(n) || + /* istanbul ignore next */ + n; + } catch (e) { + /* istanbul ignore next */ + return n; + } +} + +const memoize = new Map(); +/* istanbul ignore next */ + +const memosep = _path.default.sep === '/' ? ':' : ';'; + +function loadNycConfig(cwd, opts) { + let memokey = cwd; + const args = [_path.default.resolve(__dirname, 'load-nyc-config-sync.js'), cwd]; + + if ('nycrcPath' in opts) { + args.push(opts.nycrcPath); + memokey += memosep + opts.nycrcPath; + } + /* execFileSync is expensive, avoid it if possible! */ + + + if (memoize.has(memokey)) { + return memoize.get(memokey); + } + + const result = JSON.parse((0, _child_process.execFileSync)(process.execPath, args)); + const error = result['load-nyc-config-sync-error']; + + if (error) { + throw new Error(error); + } + + const config = { ..._schema.default.defaults.babelPluginIstanbul, + cwd, + ...result + }; + memoize.set(memokey, config); + return config; +} + +function findConfig(opts) { + const cwd = getRealpath(opts.cwd || process.env.NYC_CWD || + /* istanbul ignore next */ + process.cwd()); + const keys = Object.keys(opts); + const ignored = Object.keys(opts).filter(s => s === 'nycrcPath' || s === 'cwd'); + + if (keys.length > ignored.length) { + // explicitly configuring options in babel + // takes precedence. + return { ..._schema.default.defaults.babelPluginIstanbul, + cwd, + ...opts + }; + } + + if (ignored.length === 0 && process.env.NYC_CONFIG) { + // defaults were already applied by nyc + return JSON.parse(process.env.NYC_CONFIG); + } + + return loadNycConfig(cwd, opts); +} + +function makeShouldSkip() { + let exclude; + return function shouldSkip(file, nycConfig) { + if (!exclude || exclude.cwd !== nycConfig.cwd) { + exclude = new _testExclude.default({ + cwd: nycConfig.cwd, + include: nycConfig.include, + exclude: nycConfig.exclude, + extension: nycConfig.extension, + // Make sure this is true unless explicitly set to `false`. `undefined` is still `true`. + excludeNodeModules: nycConfig.excludeNodeModules !== false + }); + } + + return !exclude.shouldInstrument(file); + }; +} + +var _default = (0, _helperPluginUtils.declare)(api => { + api.assertVersion(7); + const shouldSkip = makeShouldSkip(); + const t = api.types; + return { + visitor: { + Program: { + enter(path) { + this.__dv__ = null; + this.nycConfig = findConfig(this.opts); + const realPath = getRealpath(this.file.opts.filename); + + if (shouldSkip(realPath, this.nycConfig)) { + return; + } + + let { + inputSourceMap + } = this.opts; + + if (this.opts.useInlineSourceMaps !== false) { + if (!inputSourceMap && this.file.inputMap) { + inputSourceMap = this.file.inputMap.sourcemap; + } + } + + const visitorOptions = {}; + Object.entries(_schema.default.defaults.instrumentVisitor).forEach(([name, defaultValue]) => { + if (name in this.nycConfig) { + visitorOptions[name] = this.nycConfig[name]; + } else { + visitorOptions[name] = _schema.default.defaults.instrumentVisitor[name]; + } + }); + this.__dv__ = (0, _istanbulLibInstrument.programVisitor)(t, realPath, { ...visitorOptions, + inputSourceMap + }); + + this.__dv__.enter(path); + }, + + exit(path) { + if (!this.__dv__) { + return; + } + + const result = this.__dv__.exit(path); + + if (this.opts.onCover) { + this.opts.onCover(getRealpath(this.file.opts.filename), result.fileCoverage); + } + } + + } + } + }; +}); + +exports.default = _default; \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/babel-plugin-istanbul/lib/load-nyc-config-sync.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/babel-plugin-istanbul/lib/load-nyc-config-sync.js new file mode 100644 index 0000000000000000000000000000000000000000..790679384e1cb337b4bf8532d881f6c00fd02836 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/babel-plugin-istanbul/lib/load-nyc-config-sync.js @@ -0,0 +1,20 @@ +#!/usr/bin/env node +'use strict'; + +const { + loadNycConfig +} = require('@istanbuljs/load-nyc-config'); + +async function main() { + const [cwd, nycrcPath] = process.argv.slice(2); + console.log(JSON.stringify(await loadNycConfig({ + cwd, + nycrcPath + }))); +} + +main().catch(error => { + console.log(JSON.stringify({ + 'load-nyc-config-sync-error': error.message + })); +}); \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/babel-plugin-istanbul/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/babel-plugin-istanbul/package.json new file mode 100644 index 0000000000000000000000000000000000000000..2b58513921d40cba72ce6fefff035085bb766168 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/babel-plugin-istanbul/package.json @@ -0,0 +1,71 @@ +{ + "name": "babel-plugin-istanbul", + "version": "6.1.1", + "author": "Thai Pangsakulyanont @dtinth", + "license": "BSD-3-Clause", + "description": "A babel plugin that adds istanbul instrumentation to ES6 code", + "main": "lib/index.js", + "files": [ + "lib" + ], + "dependencies": { + "@babel/helper-plugin-utils": "^7.0.0", + "@istanbuljs/load-nyc-config": "^1.0.0", + "@istanbuljs/schema": "^0.1.2", + "istanbul-lib-instrument": "^5.0.4", + "test-exclude": "^6.0.0" + }, + "devDependencies": { + "@babel/cli": "^7.7.5", + "@babel/core": "^7.7.5", + "@babel/plugin-transform-modules-commonjs": "^7.7.5", + "@babel/register": "^7.7.4", + "chai": "^4.2.0", + "coveralls": "^3.0.9", + "cross-env": "^6.0.3", + "mocha": "^6.2.2", + "nyc": "^15.0.0", + "pmock": "^0.2.3", + "standard": "^14.3.1" + }, + "scripts": { + "coverage": "nyc report --reporter=text-lcov | coveralls", + "release": "babel src --out-dir lib", + "pretest": "standard && npm run release", + "test": "cross-env NODE_ENV=test nyc --reporter=lcov --reporter=text mocha --timeout 5000 test/*.js", + "prepublish": "npm test && npm run release" + }, + "standard": { + "ignore": [ + "fixtures/*.js" + ] + }, + "repository": { + "type": "git", + "url": "git+https://github.com/istanbuljs/babel-plugin-istanbul.git" + }, + "keywords": [ + "istanbul", + "babel", + "plugin", + "instrumentation" + ], + "nyc": { + "include": [ + "src/*.js", + "fixtures/should-cover.js" + ], + "require": [ + "@babel/register" + ], + "sourceMap": false, + "instrument": false + }, + "bugs": { + "url": "https://github.com/istanbuljs/babel-plugin-istanbul/issues" + }, + "homepage": "https://github.com/istanbuljs/babel-plugin-istanbul#readme", + "engines": { + "node": ">=8" + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/CHANGELOG.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..8b8ac0592155e7a3e22a1e03ebc6cc1b65a87274 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/CHANGELOG.md @@ -0,0 +1,631 @@ +# Change Log + +All notable changes to this project will be documented in this file. +See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. + +## [5.2.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument-v5.2.0...istanbul-lib-instrument-v5.2.1) (2022-10-05) + + +### Bug Fixes + +* handle error when inputSourceMap is not a plain object ([#662](https://github.com/istanbuljs/istanbuljs/issues/662)) ([3e3611f](https://github.com/istanbuljs/istanbuljs/commit/3e3611f0efffefd5f87e6cbccd840e9f33aaf43e)) + +## [5.2.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument-v5.1.0...istanbul-lib-instrument-v5.2.0) (2022-02-21) + + +### Features + +* exclude Empty Object and Arrays in Truthy Detection ([#666](https://github.com/istanbuljs/istanbuljs/issues/666)) ([e279684](https://github.com/istanbuljs/istanbuljs/commit/e279684e735f4b7dbe2b632cde2515f6862099de)) + +## [5.1.0](https://www.github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument-v5.0.4...istanbul-lib-instrument-v5.1.0) (2021-10-27) + + +### Features + +* option to evaluate logical truthiness, for applications such as fuzzing ([#629](https://www.github.com/istanbuljs/istanbuljs/issues/629)) ([a743b84](https://www.github.com/istanbuljs/istanbuljs/commit/a743b8442e977f0c77ffa282eed7ac84ca200d1f)) + +### [5.0.4](https://www.github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument-v5.0.3...istanbul-lib-instrument-v5.0.4) (2021-10-16) + + +### Bug Fixes + +* **magic-value:** make incrementing magic value a manual step ([#641](https://www.github.com/istanbuljs/istanbuljs/issues/641)) ([823010b](https://www.github.com/istanbuljs/istanbuljs/commit/823010b821cf81bd91377d75fc83f0875925db66)) + +### [5.0.3](https://www.github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument-v5.0.2...istanbul-lib-instrument-v5.0.3) (2021-10-06) + + +### Bug Fixes + +* coverage.branchMap else location. ([#633](https://www.github.com/istanbuljs/istanbuljs/issues/633)) ([eb4b4ec](https://www.github.com/istanbuljs/istanbuljs/commit/eb4b4ec8f4b858655a66b0033fcc662f44ef4cc9)) + +### [5.0.2](https://www.github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument-v5.0.1...istanbul-lib-instrument-v5.0.2) (2021-09-13) + + +### Bug Fixes + +* **build:** verfiy automated publication ([b232690](https://www.github.com/istanbuljs/istanbuljs/commit/b232690193f4b524332046c96dd1cdc6e881c6c7)) + +### [5.0.1](https://www.github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument-v5.0.0...istanbul-lib-instrument-v5.0.1) (2021-09-13) + + +### Bug Fixes + +* **build:** verfiy automated publication ([74c96bd](https://www.github.com/istanbuljs/istanbuljs/commit/74c96bdc4224a06e2e1166ebd9adf8faf28438b1)) + +## [5.0.0](https://www.github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument-v4.0.3...istanbul-lib-instrument-v5.0.0) (2021-09-13) + + +### ⚠ BREAKING CHANGES + +* istanbul-lib-instrument no longer uses babel + +### Code Refactoring + +* istanbul-lib-instrument no longer uses babel ([8d3badb](https://www.github.com/istanbuljs/istanbuljs/commit/8d3badb8f6c9a4bed9af8e19c3ac6459ebd7267b)) + +## [4.0.3](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@4.0.2...istanbul-lib-instrument@4.0.3) (2020-05-09) + + +### Bug Fixes + +* Prevent readInitialCoverage from reading babel config ([#562](https://github.com/istanbuljs/istanbuljs/issues/562)) ([49b4745](https://github.com/istanbuljs/istanbuljs/commit/49b474525c15e703642916011bd86f663aca0c3d)) + + + + + +## [4.0.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@4.0.1...istanbul-lib-instrument@4.0.2) (2020-05-06) + + +### Bug Fixes + +* Add ts-ignore to reassignment of generated function ([#557](https://github.com/istanbuljs/istanbuljs/issues/557)) ([817efb0](https://github.com/istanbuljs/istanbuljs/commit/817efb04fc161efae426b2231a0221606b09f559)) +* Use @babel/core for all babel imports. ([#555](https://github.com/istanbuljs/istanbuljs/issues/555)) ([a99a13e](https://github.com/istanbuljs/istanbuljs/commit/a99a13ee6931fc124a2a723c3f511cdbcb0aa81d)) + + + + + +## [4.0.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@4.0.0...istanbul-lib-instrument@4.0.1) (2020-02-03) + + +### Bug Fixes + +* Always call coverage initialization function ([#524](https://github.com/istanbuljs/istanbuljs/issues/524)) ([c6536c1](https://github.com/istanbuljs/istanbuljs/commit/c6536c14bf0663ca7e0493dd40ea132b05352594)) + + + + + +# [4.0.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@4.0.0-alpha.3...istanbul-lib-instrument@4.0.0) (2019-12-20) + +**Note:** Version bump only for package istanbul-lib-instrument + + + + + +# [4.0.0-alpha.3](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@4.0.0-alpha.2...istanbul-lib-instrument@4.0.0-alpha.3) (2019-12-07) + +**Note:** Version bump only for package istanbul-lib-instrument + + + + + +# [4.0.0-alpha.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@4.0.0-alpha.1...istanbul-lib-instrument@4.0.0-alpha.2) (2019-11-01) + + +### Bug Fixes + +* Produce properly merged source-maps when inputSourceMap is provided ([#487](https://github.com/istanbuljs/istanbuljs/issues/487)) ([8f8c88e](https://github.com/istanbuljs/istanbuljs/commit/8f8c88e3a2add4c08729e41e356aa7981dc69d4d)) + + + + + +# [4.0.0-alpha.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@4.0.0-alpha.0...istanbul-lib-instrument@4.0.0-alpha.1) (2019-10-06) + + +### Bug Fixes + +* Eliminate babel hoisting of the coverage variable ([#481](https://github.com/istanbuljs/istanbuljs/issues/481)) ([8dfbcba](https://github.com/istanbuljs/istanbuljs/commit/8dfbcba)), closes [#92](https://github.com/istanbuljs/istanbuljs/issues/92) +* Honor ignore hints in chained if statements ([#469](https://github.com/istanbuljs/istanbuljs/issues/469)) ([a629770](https://github.com/istanbuljs/istanbuljs/commit/a629770)), closes [#468](https://github.com/istanbuljs/istanbuljs/issues/468) +* Populate lastFileCoverage for already instrumented files ([#470](https://github.com/istanbuljs/istanbuljs/issues/470)) ([ea6d779](https://github.com/istanbuljs/istanbuljs/commit/ea6d779)), closes [istanbuljs/nyc#594](https://github.com/istanbuljs/nyc/issues/594) + + +### Features + +* Use @istanbuljs/schema to pull defaults ([#485](https://github.com/istanbuljs/istanbuljs/issues/485)) ([87e27f3](https://github.com/istanbuljs/istanbuljs/commit/87e27f3)), closes [#460](https://github.com/istanbuljs/istanbuljs/issues/460) + + +### BREAKING CHANGES + +* The defaults for `autoWrap`, `preserveComments`, +`esModules` and `produceSourceMap` are now true. This applies only to +the stand-alone instrumenter, the visitor does not use these options. +* The `flow` and `jsx` parser plugins are no longer +enabled by default. This applies only to the stand-alone instrumenter, +the visitor does not use this option. +* The `plugins` option of the stand-alone instrumenter +has been renamed to `parserPlugins` to match nyc. + + + + + +# [4.0.0-alpha.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@3.3.0...istanbul-lib-instrument@4.0.0-alpha.0) (2019-06-19) + + +### Features + +* Update dependencies, require Node.js 8 ([#401](https://github.com/istanbuljs/istanbuljs/issues/401)) ([bf3a539](https://github.com/istanbuljs/istanbuljs/commit/bf3a539)) + + +### BREAKING CHANGES + +* Node.js 8 is now required + + + + + +# [3.3.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@3.2.0...istanbul-lib-instrument@3.3.0) (2019-04-24) + + +### Features + +* Enable classProperties and classPrivateProperties parsers and coverage. ([#379](https://github.com/istanbuljs/istanbuljs/issues/379)) ([c09dc38](https://github.com/istanbuljs/istanbuljs/commit/c09dc38)) + + + + + +# [3.2.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@3.1.2...istanbul-lib-instrument@3.2.0) (2019-04-09) + + +### Features + +* Add bigInt and importMeta to default parser plugins. ([#356](https://github.com/istanbuljs/istanbuljs/issues/356)) ([fb4d6ed](https://github.com/istanbuljs/istanbuljs/commit/fb4d6ed)), closes [#338](https://github.com/istanbuljs/istanbuljs/issues/338) + + + + + +## [3.1.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@3.1.1...istanbul-lib-instrument@3.1.2) (2019-04-03) + + +### Bug Fixes + +* Be more friendly to ts-node. ([#352](https://github.com/istanbuljs/istanbuljs/issues/352)) ([40d15f5](https://github.com/istanbuljs/istanbuljs/commit/40d15f5)), closes [#336](https://github.com/istanbuljs/istanbuljs/issues/336) + + + + + +## [3.1.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@3.1.0...istanbul-lib-instrument@3.1.1) (2019-03-12) + + +### Bug Fixes + +* Honor istanbul ignore next hints placed before export statement. ([#298](https://github.com/istanbuljs/istanbuljs/issues/298)) ([f24795d](https://github.com/istanbuljs/istanbuljs/commit/f24795d)), closes [#297](https://github.com/istanbuljs/istanbuljs/issues/297) + + + + + +# [3.1.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@3.0.1...istanbul-lib-instrument@3.1.0) (2019-01-26) + + +### Features + +* dont skip for loop initialization instrumentation ([#188](https://github.com/istanbuljs/istanbuljs/issues/188)) ([2e0258e](https://github.com/istanbuljs/istanbuljs/commit/2e0258e)) +* New options coverageGlobalScope and coverageGlobalScopeFunc. ([#200](https://github.com/istanbuljs/istanbuljs/issues/200)) ([25509c7](https://github.com/istanbuljs/istanbuljs/commit/25509c7)), closes [#199](https://github.com/istanbuljs/istanbuljs/issues/199) + + + + + + +## [3.0.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@3.0.0...istanbul-lib-instrument@3.0.1) (2018-12-25) + + + + +**Note:** Version bump only for package istanbul-lib-instrument + + +# [3.0.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.3.2...istanbul-lib-instrument@3.0.0) (2018-09-06) + + +### Chores + +* Update test for babel 7. ([#218](https://github.com/istanbuljs/istanbuljs/issues/218)) ([9cf4d43](https://github.com/istanbuljs/istanbuljs/commit/9cf4d43)), closes [#205](https://github.com/istanbuljs/istanbuljs/issues/205) + + +### Features + +* Add option plugins ([#205](https://github.com/istanbuljs/istanbuljs/issues/205)) ([312f81f](https://github.com/istanbuljs/istanbuljs/commit/312f81f)) +* Update babel to 7.0.0. ([#215](https://github.com/istanbuljs/istanbuljs/issues/215)) ([8a96613](https://github.com/istanbuljs/istanbuljs/commit/8a96613)) + + +### BREAKING CHANGES + +* was added which requires an option for the `decorators` +plugin. Add it to get tests working again, commit updated api.md. + + + + + +## [2.3.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.3.1...istanbul-lib-instrument@2.3.2) (2018-07-24) + + + + +**Note:** Version bump only for package istanbul-lib-instrument + + +## [2.3.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.3.0...istanbul-lib-instrument@2.3.1) (2018-07-07) + + +### Bug Fixes + +* Don't ignore src/visitor.js for self test. ([#194](https://github.com/istanbuljs/istanbuljs/issues/194)) ([71b815d](https://github.com/istanbuljs/istanbuljs/commit/71b815d)) + + + + + +# [2.3.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.2.1...istanbul-lib-instrument@2.3.0) (2018-06-27) + + +### Features + +* update pinned babel version to latest release. ([#189](https://github.com/istanbuljs/istanbuljs/issues/189)) ([ac8ec07](https://github.com/istanbuljs/istanbuljs/commit/ac8ec07)) + + + + + +## [2.2.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.2.0...istanbul-lib-instrument@2.2.1) (2018-06-26) + + +### Bug Fixes + +* Instrument ObjectMethod's. ([#182](https://github.com/istanbuljs/istanbuljs/issues/182)) ([126f09d](https://github.com/istanbuljs/istanbuljs/commit/126f09d)) +* update default args test guard to work on supported versions. ([#185](https://github.com/istanbuljs/istanbuljs/issues/185)) ([955511a](https://github.com/istanbuljs/istanbuljs/commit/955511a)) + + + + + +# [2.2.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.0.2...istanbul-lib-instrument@2.2.0) (2018-06-06) + + +### Features + +* add support for optional catch binding ([#175](https://github.com/istanbuljs/istanbuljs/issues/175)) ([088dd9f](https://github.com/istanbuljs/istanbuljs/commit/088dd9f)) + + + + + +# [2.1.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.0.2...istanbul-lib-instrument@2.1.0) (2018-05-31) + + +### Features + +* add support for optional catch binding ([#175](https://github.com/istanbuljs/istanbuljs/issues/175)) ([088dd9f](https://github.com/istanbuljs/istanbuljs/commit/088dd9f)) + + + + + +## [2.0.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.0.1...istanbul-lib-instrument@2.0.2) (2018-05-31) + + + + +**Note:** Version bump only for package istanbul-lib-instrument + + +## [2.0.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.0.0...istanbul-lib-instrument@2.0.1) (2018-05-31) + + +### Bug Fixes + +* should import [@babel](https://github.com/babel)/template ([85a0d1a](https://github.com/istanbuljs/istanbuljs/commit/85a0d1a)) + + + + + +# [2.0.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.10.1...istanbul-lib-instrument@2.0.0) (2018-05-31) + + +### Bug Fixes + +* parenthesize superClass on non-idetifier case ([#158](https://github.com/istanbuljs/istanbuljs/issues/158)) ([6202c88](https://github.com/istanbuljs/istanbuljs/commit/6202c88)) + + +### Chores + +* upgrade babel in instrumenter ([#174](https://github.com/istanbuljs/istanbuljs/issues/174)) ([ce23e91](https://github.com/istanbuljs/istanbuljs/commit/ce23e91)) + + +### BREAKING CHANGES + +* babel@7 drops Node@4 support + + + + + +## [1.10.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.10.0...istanbul-lib-instrument@1.10.1) (2018-03-09) + + +### Bug Fixes + +* default value for ignorelassMethods ([#151](https://github.com/istanbuljs/istanbuljs/issues/151)) ([5dd88e8](https://github.com/istanbuljs/istanbuljs/commit/5dd88e8)) + + + + + +# [1.10.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.9.2...istanbul-lib-instrument@1.10.0) (2018-03-04) + + +### Features + +* allows an array of ignored method names to be provided ([#127](https://github.com/istanbuljs/istanbuljs/issues/127)) ([67918e2](https://github.com/istanbuljs/istanbuljs/commit/67918e2)) + + + + + +## [1.9.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.9.1...istanbul-lib-instrument@1.9.2) (2018-02-13) + + +### Bug Fixes + +* compatibility with babel 7 ([#135](https://github.com/istanbuljs/istanbuljs/issues/135)) ([6cac849](https://github.com/istanbuljs/istanbuljs/commit/6cac849)) +* handle instrumentation when a function is called Function ([#131](https://github.com/istanbuljs/istanbuljs/issues/131)) ([b12a07e](https://github.com/istanbuljs/istanbuljs/commit/b12a07e)) +* proper passing of the preserveComments option to babel ([#122](https://github.com/istanbuljs/istanbuljs/issues/122)) ([470bb0e](https://github.com/istanbuljs/istanbuljs/commit/470bb0e)) +* update instrument, account for lack of arrow expression ([#119](https://github.com/istanbuljs/istanbuljs/issues/119)) ([#125](https://github.com/istanbuljs/istanbuljs/issues/125)) ([0968206](https://github.com/istanbuljs/istanbuljs/commit/0968206)) + + + + + +## [1.9.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.9.0...istanbul-lib-instrument@1.9.1) (2017-10-22) + + +### Bug Fixes + +* address issue with class instrumentation ([#111](https://github.com/istanbuljs/istanbuljs/issues/111)) ([cbd1c14](https://github.com/istanbuljs/istanbuljs/commit/cbd1c14)) + + + + + +# [1.9.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.8.0...istanbul-lib-instrument@1.9.0) (2017-10-21) + + +### Bug Fixes + +* support conditional expression for superClass ([#106](https://github.com/istanbuljs/istanbuljs/issues/106)) ([aae256f](https://github.com/istanbuljs/istanbuljs/commit/aae256f)) + + +### Features + +* add support for ignoring entire files ([#108](https://github.com/istanbuljs/istanbuljs/issues/108)) ([f12da65](https://github.com/istanbuljs/istanbuljs/commit/f12da65)) + + + + + +# [1.8.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.7.5...istanbul-lib-instrument@1.8.0) (2017-09-05) + + +### Features + +* add support for object-spread syntax ([#82](https://github.com/istanbuljs/istanbuljs/issues/82)) ([28d5566](https://github.com/istanbuljs/istanbuljs/commit/28d5566)) + + + + + +## [1.7.5](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.7.4...istanbul-lib-instrument@1.7.5) (2017-08-23) + + +### Bug Fixes + +* name of function is now preserved or named exports ([#79](https://github.com/istanbuljs/istanbuljs/issues/79)) ([2ce8974](https://github.com/istanbuljs/istanbuljs/commit/2ce8974)) + + + + + +## [1.7.4](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.7.3...istanbul-lib-instrument@1.7.4) (2017-07-16) + + +### Bug Fixes + +* update increment operator to appropriate expression type ([#74](https://github.com/istanbuljs/istanbuljs/issues/74)) ([dc69e66](https://github.com/istanbuljs/istanbuljs/commit/dc69e66)) + + + + + +## [1.7.3](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.7.2...istanbul-lib-instrument@1.7.3) (2017-06-25) + + + + + +## [1.7.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.7.1...istanbul-lib-instrument@1.7.2) (2017-05-27) + + +### Bug Fixes + +* hoist statement counter for class variables, so that name is preserved ([#60](https://github.com/istanbuljs/istanbuljs/issues/60)) ([120d221](https://github.com/istanbuljs/istanbuljs/commit/120d221)) + + + + + +## [1.7.1](https://github.com/istanbuljs/istanbul-lib-instrument/compare/istanbul-lib-instrument@1.7.0...istanbul-lib-instrument@1.7.1) (2017-04-29) + + +### Bug Fixes + +* don't instrument a file if it has already been instrumented ([#38](https://github.com/istanbuljs/istanbuljs/issues/38)) ([9c38e4e](https://github.com/istanbuljs/istanbul-lib-instrument/commit/9c38e4e)) + + + + + +# [1.7.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/istanbul-lib-instrument@1.6.2...istanbul-lib-instrument@1.7.0) (2017-03-27) + + +### Features + +* use extended babylon support; adding features such as jsx ([#22](https://github.com/istanbuljs/istanbuljs/issues/22)) ([11c2438](https://github.com/istanbuljs/istanbul-lib-instrument/commit/11c2438)) + + +## [1.6.2](https://github.com/istanbuljs/istanbul-lib-instrument/compare/istanbul-lib-instrument@1.6.1...istanbul-lib-instrument@1.6.2) (2017-03-22) + + +### Bug Fixes + +* loc is sometimes not defined, so loc.start fails see [#99](https://github.com/istanbuljs/istanbuljs/issues/99) ([#18](https://github.com/istanbuljs/istanbuljs/issues/18)) ([df85ba6](https://github.com/istanbuljs/istanbul-lib-instrument/commit/df85ba6)) + + +## [1.6.1](https://github.com/istanbuljs/istanbul-lib-instrument/compare/istanbul-lib-instrument@1.6.0...istanbul-lib-instrument@1.6.1) (2017-03-21) + + +# [1.6.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/istanbul-lib-instrument@1.4.2...istanbul-lib-instrument@1.6.0) (2017-03-21) + + +### Features + +* adds line number property back to coverage.json ([b03b927](https://github.com/istanbuljs/istanbul-lib-instrument/commit/b03b927)) + + +## [1.4.2](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.4.1...v1.4.2) (2017-01-04) + + +### Bug Fixes + +* only hoist counter for a smaller subset of function declarations ([9f8931e](https://github.com/istanbuljs/istanbul-lib-instrument/commit/9f8931e)) + + + + +## [1.4.1](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.4.0...v1.4.1) (2017-01-04) + + +### Bug Fixes + +* address regression discussed in https://github.com/istanbuljs/babel-plugin-istanbul/issues/78 ([#40](https://github.com/istanbuljs/istanbul-lib-instrument/issues/40)) ([7f458a3](https://github.com/istanbuljs/istanbul-lib-instrument/commit/7f458a3)) + + + + +# [1.4.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.3.1...v1.4.0) (2017-01-02) + + +### Features + +* preserve inferred function names ([#38](https://github.com/istanbuljs/istanbul-lib-instrument/issues/38)) ([312666e](https://github.com/istanbuljs/istanbul-lib-instrument/commit/312666e)) + + + + +## [1.3.1](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.3.0...v1.3.1) (2016-12-27) + + +### Bug Fixes + +* function declaration assignment now retains function name ([#33](https://github.com/istanbuljs/istanbul-lib-instrument/issues/33)) ([2d781da](https://github.com/istanbuljs/istanbul-lib-instrument/commit/2d781da)) + + + + +# [1.3.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.2.0...v1.3.0) (2016-11-10) + + +### Features + +* allow an input source-map to be passed to instrumentSync() ([#23](https://github.com/istanbuljs/istanbul-lib-instrument/issues/23)) ([b08e4f5](https://github.com/istanbuljs/istanbul-lib-instrument/commit/b08e4f5)) + + + + +# [1.2.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.4...v1.2.0) (2016-10-25) + + +### Features + +* implement function to extract empty coverage data from an instrumented file ([#28](https://github.com/istanbuljs/istanbul-lib-instrument/issues/28)) ([06d0ef6](https://github.com/istanbuljs/istanbul-lib-instrument/commit/06d0ef6)) + + + + +## [1.1.4](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.3...v1.1.4) (2016-10-17) + + +### Bug Fixes + +* hoist coverage variable to very top of file ([#26](https://github.com/istanbuljs/istanbul-lib-instrument/issues/26)) ([0225e8c](https://github.com/istanbuljs/istanbul-lib-instrument/commit/0225e8c)) + + + + +## [1.1.3](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.2...v1.1.3) (2016-09-13) + + +### Performance Improvements + +* simplify coverage variable naming https://github.com/istanbuljs/istanbul-lib-instrument/pull/24 ([7252aae](https://github.com/istanbuljs/istanbul-lib-instrument/commit/7252aae)) + + + + +## [1.1.2](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.1...v1.1.2) (2016-09-08) + + +### Performance Improvements + +* use zero-based numeric indices for much faster instrumented code ([#22](https://github.com/istanbuljs/istanbul-lib-instrument/issues/22)) ([5b401f5](https://github.com/istanbuljs/istanbul-lib-instrument/commit/5b401f5)) + + + + +## [1.1.1](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.0...v1.1.1) (2016-08-30) + + +### Bug Fixes + +* upgrade istanbul-lib-coverage ([eb9b1f6](https://github.com/istanbuljs/istanbul-lib-instrument/commit/eb9b1f6)) + + + + +# [1.1.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.0-alpha.4...v1.1.0) (2016-08-11) + + +### Bug Fixes + +* guard against invalid loc ([#16](https://github.com/istanbuljs/istanbul-lib-instrument/issues/16)) ([23ebfc3](https://github.com/istanbuljs/istanbul-lib-instrument/commit/23ebfc3)) + + + + +# [1.1.0-alpha.4](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.0.0-alpha.5...v1.1.0-alpha.4) (2016-07-20) + + +### Bug Fixes + +* require more performant babel-generator ([#15](https://github.com/istanbuljs/istanbul-lib-instrument/issues/15)) ([21b2563](https://github.com/istanbuljs/istanbul-lib-instrument/commit/21b2563)) diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..d55d2916eb85ce7dff3bd1e309b9e4045f9a9c8f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/LICENSE @@ -0,0 +1,24 @@ +Copyright 2012-2015 Yahoo! Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of the Yahoo! Inc. nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL YAHOO! INC. BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/README.md new file mode 100644 index 0000000000000000000000000000000000000000..902831cfb69282f6cfd558e9c84efad0f14fcd3f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/README.md @@ -0,0 +1,22 @@ +## istanbul-lib-instrument + +[![Build Status](https://travis-ci.org/istanbuljs/istanbul-lib-instrument.svg?branch=master)](https://travis-ci.org/istanbuljs/istanbul-lib-instrument) + +Istanbul instrumenter library. + +Version 1.1.x now implements instrumentation using `Babel`. The implementation is inspired +by prior art by @dtinth as demonstrated in the `__coverage__` babel plugin. + +It provides 2 "modes" of instrumentation. + +- The old API that is mostly unchanged (except for incompatibilities noted) and + performs the instrumentation using babel as a library. + +- A `programVisitor` function for the Babel AST that can be used by a Babel plugin + to emit instrumentation for ES6 code directly without any source map + processing. This is the preferred path for babel users. The Babel plugin is + called `babel-plugin-istanbul`. + +Incompatibilities and changes to instrumentation behavior can be found in +[v0-changes.md](v0-changes.md). + diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/package.json new file mode 100644 index 0000000000000000000000000000000000000000..bcf03e2e623038500d4845f3ed4a008459464fae --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/package.json @@ -0,0 +1,50 @@ +{ + "name": "istanbul-lib-instrument", + "version": "5.2.1", + "description": "Core istanbul API for JS code coverage", + "author": "Krishnan Anantheswaran ", + "main": "src/index.js", + "files": [ + "src" + ], + "scripts": { + "test": "nyc mocha" + }, + "dependencies": { + "@babel/core": "^7.12.3", + "@babel/parser": "^7.14.7", + "@istanbuljs/schema": "^0.1.2", + "istanbul-lib-coverage": "^3.2.0", + "semver": "^6.3.0" + }, + "devDependencies": { + "@babel/cli": "^7.7.5", + "chai": "^4.2.0", + "clone": "^2.1.2", + "debug": "^4.1.1", + "documentation": "^12.1.4", + "js-yaml": "^3.13.1", + "mocha": "^6.2.3", + "nopt": "^4.0.1", + "nyc": "^15.1.0" + }, + "license": "BSD-3-Clause", + "bugs": { + "url": "https://github.com/istanbuljs/istanbuljs/issues" + }, + "homepage": "https://istanbul.js.org/", + "repository": { + "type": "git", + "url": "git+ssh://git@github.com/istanbuljs/istanbuljs.git", + "directory": "packages/istanbul-lib-instrument" + }, + "keywords": [ + "coverage", + "istanbul", + "js", + "instrumentation" + ], + "engines": { + "node": ">=8" + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/src/constants.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/src/constants.js new file mode 100644 index 0000000000000000000000000000000000000000..2cd402bc0811e8fe1f0a7909774a296dfbcb0aeb --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/src/constants.js @@ -0,0 +1,14 @@ +const { createHash } = require('crypto'); +const { name } = require('../package.json'); +// TODO: increment this version if there are schema changes +// that are not backwards compatible: +const VERSION = '4'; + +const SHA = 'sha1'; +module.exports = { + SHA, + MAGIC_KEY: '_coverageSchema', + MAGIC_VALUE: createHash(SHA) + .update(name + '@' + VERSION) + .digest('hex') +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/src/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/src/index.js new file mode 100644 index 0000000000000000000000000000000000000000..33d2a4c1a6cef000dc5c62bdef80402d55081241 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/src/index.js @@ -0,0 +1,21 @@ +const { defaults } = require('@istanbuljs/schema'); +const Instrumenter = require('./instrumenter'); +const programVisitor = require('./visitor'); +const readInitialCoverage = require('./read-coverage'); + +/** + * createInstrumenter creates a new instrumenter with the + * supplied options. + * @param {Object} opts - instrumenter options. See the documentation + * for the Instrumenter class. + */ +function createInstrumenter(opts) { + return new Instrumenter(opts); +} + +module.exports = { + createInstrumenter, + programVisitor, + readInitialCoverage, + defaultOpts: defaults.instrumenter +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/src/instrumenter.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/src/instrumenter.js new file mode 100644 index 0000000000000000000000000000000000000000..3322e6eb295d632a609ca950cefbcd6c6ae4776f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/src/instrumenter.js @@ -0,0 +1,162 @@ +/* + Copyright 2012-2015, Yahoo Inc. + Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms. + */ +const { transformSync } = require('@babel/core'); +const { defaults } = require('@istanbuljs/schema'); +const programVisitor = require('./visitor'); +const readInitialCoverage = require('./read-coverage'); + +/** + * Instrumenter is the public API for the instrument library. + * It is typically used for ES5 code. For ES6 code that you + * are already running under `babel` use the coverage plugin + * instead. + * @param {Object} opts optional. + * @param {string} [opts.coverageVariable=__coverage__] name of global coverage variable. + * @param {boolean} [opts.reportLogic=false] report boolean value of logical expressions. + * @param {boolean} [opts.preserveComments=false] preserve comments in output. + * @param {boolean} [opts.compact=true] generate compact code. + * @param {boolean} [opts.esModules=false] set to true to instrument ES6 modules. + * @param {boolean} [opts.autoWrap=false] set to true to allow `return` statements outside of functions. + * @param {boolean} [opts.produceSourceMap=false] set to true to produce a source map for the instrumented code. + * @param {Array} [opts.ignoreClassMethods=[]] set to array of class method names to ignore for coverage. + * @param {Function} [opts.sourceMapUrlCallback=null] a callback function that is called when a source map URL + * is found in the original code. This function is called with the source file name and the source map URL. + * @param {boolean} [opts.debug=false] - turn debugging on. + * @param {array} [opts.parserPlugins] - set babel parser plugins, see @istanbuljs/schema for defaults. + * @param {string} [opts.coverageGlobalScope=this] the global coverage variable scope. + * @param {boolean} [opts.coverageGlobalScopeFunc=true] use an evaluated function to find coverageGlobalScope. + */ +class Instrumenter { + constructor(opts = {}) { + this.opts = { + ...defaults.instrumenter, + ...opts + }; + this.fileCoverage = null; + this.sourceMap = null; + } + /** + * instrument the supplied code and track coverage against the supplied + * filename. It throws if invalid code is passed to it. ES5 and ES6 syntax + * is supported. To instrument ES6 modules, make sure that you set the + * `esModules` property to `true` when creating the instrumenter. + * + * @param {string} code - the code to instrument + * @param {string} filename - the filename against which to track coverage. + * @param {object} [inputSourceMap] - the source map that maps the not instrumented code back to it's original form. + * Is assigned to the coverage object and therefore, is available in the json output and can be used to remap the + * coverage to the untranspiled source. + * @returns {string} the instrumented code. + */ + instrumentSync(code, filename, inputSourceMap) { + if (typeof code !== 'string') { + throw new Error('Code must be a string'); + } + filename = filename || String(new Date().getTime()) + '.js'; + const { opts } = this; + let output = {}; + const babelOpts = { + configFile: false, + babelrc: false, + ast: true, + filename: filename || String(new Date().getTime()) + '.js', + inputSourceMap, + sourceMaps: opts.produceSourceMap, + compact: opts.compact, + comments: opts.preserveComments, + parserOpts: { + allowReturnOutsideFunction: opts.autoWrap, + sourceType: opts.esModules ? 'module' : 'script', + plugins: opts.parserPlugins + }, + plugins: [ + [ + ({ types }) => { + const ee = programVisitor(types, filename, { + coverageVariable: opts.coverageVariable, + reportLogic: opts.reportLogic, + coverageGlobalScope: opts.coverageGlobalScope, + coverageGlobalScopeFunc: + opts.coverageGlobalScopeFunc, + ignoreClassMethods: opts.ignoreClassMethods, + inputSourceMap + }); + + return { + visitor: { + Program: { + enter: ee.enter, + exit(path) { + output = ee.exit(path); + } + } + } + }; + } + ] + ] + }; + + const codeMap = transformSync(code, babelOpts); + + if (!output || !output.fileCoverage) { + const initialCoverage = + readInitialCoverage(codeMap.ast) || + /* istanbul ignore next: paranoid check */ {}; + this.fileCoverage = initialCoverage.coverageData; + this.sourceMap = inputSourceMap; + return code; + } + + this.fileCoverage = output.fileCoverage; + this.sourceMap = codeMap.map; + const cb = this.opts.sourceMapUrlCallback; + if (cb && output.sourceMappingURL) { + cb(filename, output.sourceMappingURL); + } + + return codeMap.code; + } + /** + * callback-style instrument method that calls back with an error + * as opposed to throwing one. Note that in the current implementation, + * the callback will be called in the same process tick and is not asynchronous. + * + * @param {string} code - the code to instrument + * @param {string} filename - the filename against which to track coverage. + * @param {Function} callback - the callback + * @param {Object} inputSourceMap - the source map that maps the not instrumented code back to it's original form. + * Is assigned to the coverage object and therefore, is available in the json output and can be used to remap the + * coverage to the untranspiled source. + */ + instrument(code, filename, callback, inputSourceMap) { + if (!callback && typeof filename === 'function') { + callback = filename; + filename = null; + } + try { + const out = this.instrumentSync(code, filename, inputSourceMap); + callback(null, out); + } catch (ex) { + callback(ex); + } + } + /** + * returns the file coverage object for the last file instrumented. + * @returns {Object} the file coverage object. + */ + lastFileCoverage() { + return this.fileCoverage; + } + /** + * returns the source map produced for the last file instrumented. + * @returns {null|Object} the source map object. + */ + lastSourceMap() { + return this.sourceMap; + } +} + +module.exports = Instrumenter; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/src/read-coverage.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/src/read-coverage.js new file mode 100644 index 0000000000000000000000000000000000000000..5b76dbb1d57328b1494ec6dad5f5618d91ef1e2e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/src/read-coverage.js @@ -0,0 +1,77 @@ +const { parseSync, traverse } = require('@babel/core'); +const { defaults } = require('@istanbuljs/schema'); +const { MAGIC_KEY, MAGIC_VALUE } = require('./constants'); + +function getAst(code) { + if (typeof code === 'object' && typeof code.type === 'string') { + // Assume code is already a babel ast. + return code; + } + + if (typeof code !== 'string') { + throw new Error('Code must be a string'); + } + + // Parse as leniently as possible + return parseSync(code, { + babelrc: false, + configFile: false, + parserOpts: { + allowAwaitOutsideFunction: true, + allowImportExportEverywhere: true, + allowReturnOutsideFunction: true, + allowSuperOutsideMethod: true, + sourceType: 'script', + plugins: defaults.instrumenter.parserPlugins + } + }); +} + +module.exports = function readInitialCoverage(code) { + const ast = getAst(code); + + let covScope; + traverse(ast, { + ObjectProperty(path) { + const { node } = path; + if ( + !node.computed && + path.get('key').isIdentifier() && + node.key.name === MAGIC_KEY + ) { + const magicValue = path.get('value').evaluate(); + if (!magicValue.confident || magicValue.value !== MAGIC_VALUE) { + return; + } + covScope = + path.scope.getFunctionParent() || + path.scope.getProgramParent(); + path.stop(); + } + } + }); + + if (!covScope) { + return null; + } + + const result = {}; + + for (const key of ['path', 'hash', 'gcv', 'coverageData']) { + const binding = covScope.getOwnBinding(key); + if (!binding) { + return null; + } + const valuePath = binding.path.get('init'); + const value = valuePath.evaluate(); + if (!value.confident) { + return null; + } + result[key] = value.value; + } + + delete result.coverageData[MAGIC_KEY]; + delete result.coverageData.hash; + + return result; +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/src/source-coverage.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/src/source-coverage.js new file mode 100644 index 0000000000000000000000000000000000000000..ec3f234d5d11b21297c4b7da44d2fd60c212f31c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/src/source-coverage.js @@ -0,0 +1,135 @@ +const { classes } = require('istanbul-lib-coverage'); + +function cloneLocation(loc) { + return { + start: { + line: loc && loc.start.line, + column: loc && loc.start.column + }, + end: { + line: loc && loc.end.line, + column: loc && loc.end.column + } + }; +} +/** + * SourceCoverage provides mutation methods to manipulate the structure of + * a file coverage object. Used by the instrumenter to create a full coverage + * object for a file incrementally. + * + * @private + * @param pathOrObj {String|Object} - see the argument for {@link FileCoverage} + * @extends FileCoverage + * @constructor + */ +class SourceCoverage extends classes.FileCoverage { + constructor(pathOrObj) { + super(pathOrObj); + this.meta = { + last: { + s: 0, + f: 0, + b: 0 + } + }; + } + + newStatement(loc) { + const s = this.meta.last.s; + this.data.statementMap[s] = cloneLocation(loc); + this.data.s[s] = 0; + this.meta.last.s += 1; + return s; + } + + newFunction(name, decl, loc) { + const f = this.meta.last.f; + name = name || '(anonymous_' + f + ')'; + this.data.fnMap[f] = { + name, + decl: cloneLocation(decl), + loc: cloneLocation(loc), + // DEPRECATED: some legacy reports require this info. + line: loc && loc.start.line + }; + this.data.f[f] = 0; + this.meta.last.f += 1; + return f; + } + + newBranch(type, loc, isReportLogic = false) { + const b = this.meta.last.b; + this.data.b[b] = []; + this.data.branchMap[b] = { + loc: cloneLocation(loc), + type, + locations: [], + // DEPRECATED: some legacy reports require this info. + line: loc && loc.start.line + }; + this.meta.last.b += 1; + this.maybeNewBranchTrue(type, b, isReportLogic); + return b; + } + + maybeNewBranchTrue(type, name, isReportLogic) { + if (!isReportLogic) { + return; + } + if (type !== 'binary-expr') { + return; + } + this.data.bT = this.data.bT || {}; + this.data.bT[name] = []; + } + + addBranchPath(name, location) { + const bMeta = this.data.branchMap[name]; + const counts = this.data.b[name]; + + /* istanbul ignore if: paranoid check */ + if (!bMeta) { + throw new Error('Invalid branch ' + name); + } + bMeta.locations.push(cloneLocation(location)); + counts.push(0); + this.maybeAddBranchTrue(name); + return counts.length - 1; + } + + maybeAddBranchTrue(name) { + if (!this.data.bT) { + return; + } + const countsTrue = this.data.bT[name]; + if (!countsTrue) { + return; + } + countsTrue.push(0); + } + + /** + * Assigns an input source map to the coverage that can be used + * to remap the coverage output to the original source + * @param sourceMap {object} the source map + */ + inputSourceMap(sourceMap) { + this.data.inputSourceMap = sourceMap; + } + + freeze() { + // prune empty branches + const map = this.data.branchMap; + const branches = this.data.b; + const branchesT = this.data.bT || {}; + Object.keys(map).forEach(b => { + if (map[b].locations.length === 0) { + delete map[b]; + delete branches[b]; + delete branchesT[b]; + } + }); + } +} + +module.exports = { SourceCoverage }; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/src/visitor.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/src/visitor.js new file mode 100644 index 0000000000000000000000000000000000000000..46c71290d05c04c8f07a4421e9aab6cdbd74ec6e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/istanbul-lib-instrument/src/visitor.js @@ -0,0 +1,843 @@ +const { createHash } = require('crypto'); +const { template } = require('@babel/core'); +const { defaults } = require('@istanbuljs/schema'); +const { SourceCoverage } = require('./source-coverage'); +const { SHA, MAGIC_KEY, MAGIC_VALUE } = require('./constants'); + +// pattern for istanbul to ignore a section +const COMMENT_RE = /^\s*istanbul\s+ignore\s+(if|else|next)(?=\W|$)/; +// pattern for istanbul to ignore the whole file +const COMMENT_FILE_RE = /^\s*istanbul\s+ignore\s+(file)(?=\W|$)/; +// source map URL pattern +const SOURCE_MAP_RE = /[#@]\s*sourceMappingURL=(.*)\s*$/m; + +// generate a variable name from hashing the supplied file path +function genVar(filename) { + const hash = createHash(SHA); + hash.update(filename); + return 'cov_' + parseInt(hash.digest('hex').substr(0, 12), 16).toString(36); +} + +// VisitState holds the state of the visitor, provides helper functions +// and is the `this` for the individual coverage visitors. +class VisitState { + constructor( + types, + sourceFilePath, + inputSourceMap, + ignoreClassMethods = [], + reportLogic = false + ) { + this.varName = genVar(sourceFilePath); + this.attrs = {}; + this.nextIgnore = null; + this.cov = new SourceCoverage(sourceFilePath); + + if (typeof inputSourceMap !== 'undefined') { + this.cov.inputSourceMap(inputSourceMap); + } + this.ignoreClassMethods = ignoreClassMethods; + this.types = types; + this.sourceMappingURL = null; + this.reportLogic = reportLogic; + } + + // should we ignore the node? Yes, if specifically ignoring + // or if the node is generated. + shouldIgnore(path) { + return this.nextIgnore || !path.node.loc; + } + + // extract the ignore comment hint (next|if|else) or null + hintFor(node) { + let hint = null; + if (node.leadingComments) { + node.leadingComments.forEach(c => { + const v = ( + c.value || /* istanbul ignore next: paranoid check */ '' + ).trim(); + const groups = v.match(COMMENT_RE); + if (groups) { + hint = groups[1]; + } + }); + } + return hint; + } + + // extract a source map URL from comments and keep track of it + maybeAssignSourceMapURL(node) { + const extractURL = comments => { + if (!comments) { + return; + } + comments.forEach(c => { + const v = ( + c.value || /* istanbul ignore next: paranoid check */ '' + ).trim(); + const groups = v.match(SOURCE_MAP_RE); + if (groups) { + this.sourceMappingURL = groups[1]; + } + }); + }; + extractURL(node.leadingComments); + extractURL(node.trailingComments); + } + + // for these expressions the statement counter needs to be hoisted, so + // function name inference can be preserved + counterNeedsHoisting(path) { + return ( + path.isFunctionExpression() || + path.isArrowFunctionExpression() || + path.isClassExpression() + ); + } + + // all the generic stuff that needs to be done on enter for every node + onEnter(path) { + const n = path.node; + + this.maybeAssignSourceMapURL(n); + + // if already ignoring, nothing more to do + if (this.nextIgnore !== null) { + return; + } + // check hint to see if ignore should be turned on + const hint = this.hintFor(n); + if (hint === 'next') { + this.nextIgnore = n; + return; + } + // else check custom node attribute set by a prior visitor + if (this.getAttr(path.node, 'skip-all') !== null) { + this.nextIgnore = n; + } + + // else check for ignored class methods + if ( + path.isFunctionExpression() && + this.ignoreClassMethods.some( + name => path.node.id && name === path.node.id.name + ) + ) { + this.nextIgnore = n; + return; + } + if ( + path.isClassMethod() && + this.ignoreClassMethods.some(name => name === path.node.key.name) + ) { + this.nextIgnore = n; + return; + } + } + + // all the generic stuff on exit of a node, + // including reseting ignores and custom node attrs + onExit(path) { + // restore ignore status, if needed + if (path.node === this.nextIgnore) { + this.nextIgnore = null; + } + // nuke all attributes for the node + delete path.node.__cov__; + } + + // set a node attribute for the supplied node + setAttr(node, name, value) { + node.__cov__ = node.__cov__ || {}; + node.__cov__[name] = value; + } + + // retrieve a node attribute for the supplied node or null + getAttr(node, name) { + const c = node.__cov__; + if (!c) { + return null; + } + return c[name]; + } + + // + increase(type, id, index) { + const T = this.types; + const wrap = + index !== null + ? // If `index` present, turn `x` into `x[index]`. + x => T.memberExpression(x, T.numericLiteral(index), true) + : x => x; + return T.updateExpression( + '++', + wrap( + T.memberExpression( + T.memberExpression( + T.callExpression(T.identifier(this.varName), []), + T.identifier(type) + ), + T.numericLiteral(id), + true + ) + ) + ); + } + + // Reads the logic expression conditions and conditionally increments truthy counter. + increaseTrue(type, id, index, node) { + const T = this.types; + const tempName = `${this.varName}_temp`; + + return T.sequenceExpression([ + T.assignmentExpression( + '=', + T.memberExpression( + T.callExpression(T.identifier(this.varName), []), + T.identifier(tempName) + ), + node // Only evaluates once. + ), + T.parenthesizedExpression( + T.conditionalExpression( + this.validateTrueNonTrivial(T, tempName), + this.increase(type, id, index), + T.nullLiteral() + ) + ), + T.memberExpression( + T.callExpression(T.identifier(this.varName), []), + T.identifier(tempName) + ) + ]); + } + + validateTrueNonTrivial(T, tempName) { + return T.logicalExpression( + '&&', + T.memberExpression( + T.callExpression(T.identifier(this.varName), []), + T.identifier(tempName) + ), + T.logicalExpression( + '&&', + T.parenthesizedExpression( + T.logicalExpression( + '||', + T.unaryExpression( + '!', + T.callExpression( + T.memberExpression( + T.identifier('Array'), + T.identifier('isArray') + ), + [ + T.memberExpression( + T.callExpression( + T.identifier(this.varName), + [] + ), + T.identifier(tempName) + ) + ] + ) + ), + T.memberExpression( + T.memberExpression( + T.callExpression( + T.identifier(this.varName), + [] + ), + T.identifier(tempName) + ), + T.identifier('length') + ) + ) + ), + T.parenthesizedExpression( + T.logicalExpression( + '||', + T.binaryExpression( + '!==', + T.callExpression( + T.memberExpression( + T.identifier('Object'), + T.identifier('getPrototypeOf') + ), + [ + T.memberExpression( + T.callExpression( + T.identifier(this.varName), + [] + ), + T.identifier(tempName) + ) + ] + ), + T.memberExpression( + T.identifier('Object'), + T.identifier('prototype') + ) + ), + T.memberExpression( + T.callExpression( + T.memberExpression( + T.identifier('Object'), + T.identifier('values') + ), + [ + T.memberExpression( + T.callExpression( + T.identifier(this.varName), + [] + ), + T.identifier(tempName) + ) + ] + ), + T.identifier('length') + ) + ) + ) + ) + ); + } + + insertCounter(path, increment) { + const T = this.types; + if (path.isBlockStatement()) { + path.node.body.unshift(T.expressionStatement(increment)); + } else if (path.isStatement()) { + path.insertBefore(T.expressionStatement(increment)); + } else if ( + this.counterNeedsHoisting(path) && + T.isVariableDeclarator(path.parentPath) + ) { + // make an attempt to hoist the statement counter, so that + // function names are maintained. + const parent = path.parentPath.parentPath; + if (parent && T.isExportNamedDeclaration(parent.parentPath)) { + parent.parentPath.insertBefore( + T.expressionStatement(increment) + ); + } else if ( + parent && + (T.isProgram(parent.parentPath) || + T.isBlockStatement(parent.parentPath)) + ) { + parent.insertBefore(T.expressionStatement(increment)); + } else { + path.replaceWith(T.sequenceExpression([increment, path.node])); + } + } /* istanbul ignore else: not expected */ else if ( + path.isExpression() + ) { + path.replaceWith(T.sequenceExpression([increment, path.node])); + } else { + console.error( + 'Unable to insert counter for node type:', + path.node.type + ); + } + } + + insertStatementCounter(path) { + /* istanbul ignore if: paranoid check */ + if (!(path.node && path.node.loc)) { + return; + } + const index = this.cov.newStatement(path.node.loc); + const increment = this.increase('s', index, null); + this.insertCounter(path, increment); + } + + insertFunctionCounter(path) { + const T = this.types; + /* istanbul ignore if: paranoid check */ + if (!(path.node && path.node.loc)) { + return; + } + const n = path.node; + + let dloc = null; + // get location for declaration + switch (n.type) { + case 'FunctionDeclaration': + case 'FunctionExpression': + /* istanbul ignore else: paranoid check */ + if (n.id) { + dloc = n.id.loc; + } + break; + } + if (!dloc) { + dloc = { + start: n.loc.start, + end: { line: n.loc.start.line, column: n.loc.start.column + 1 } + }; + } + + const name = path.node.id ? path.node.id.name : path.node.name; + const index = this.cov.newFunction(name, dloc, path.node.body.loc); + const increment = this.increase('f', index, null); + const body = path.get('body'); + /* istanbul ignore else: not expected */ + if (body.isBlockStatement()) { + body.node.body.unshift(T.expressionStatement(increment)); + } else { + console.error( + 'Unable to process function body node type:', + path.node.type + ); + } + } + + getBranchIncrement(branchName, loc) { + const index = this.cov.addBranchPath(branchName, loc); + return this.increase('b', branchName, index); + } + + getBranchLogicIncrement(path, branchName, loc) { + const index = this.cov.addBranchPath(branchName, loc); + return [ + this.increase('b', branchName, index), + this.increaseTrue('bT', branchName, index, path.node) + ]; + } + + insertBranchCounter(path, branchName, loc) { + const increment = this.getBranchIncrement( + branchName, + loc || path.node.loc + ); + this.insertCounter(path, increment); + } + + findLeaves(node, accumulator, parent, property) { + if (!node) { + return; + } + if (node.type === 'LogicalExpression') { + const hint = this.hintFor(node); + if (hint !== 'next') { + this.findLeaves(node.left, accumulator, node, 'left'); + this.findLeaves(node.right, accumulator, node, 'right'); + } + } else { + accumulator.push({ + node, + parent, + property + }); + } + } +} + +// generic function that takes a set of visitor methods and +// returns a visitor object with `enter` and `exit` properties, +// such that: +// +// * standard entry processing is done +// * the supplied visitors are called only when ignore is not in effect +// This relieves them from worrying about ignore states and generated nodes. +// * standard exit processing is done +// +function entries(...enter) { + // the enter function + const wrappedEntry = function(path, node) { + this.onEnter(path); + if (this.shouldIgnore(path)) { + return; + } + enter.forEach(e => { + e.call(this, path, node); + }); + }; + const exit = function(path, node) { + this.onExit(path, node); + }; + return { + enter: wrappedEntry, + exit + }; +} + +function coverStatement(path) { + this.insertStatementCounter(path); +} + +/* istanbul ignore next: no node.js support */ +function coverAssignmentPattern(path) { + const n = path.node; + const b = this.cov.newBranch('default-arg', n.loc); + this.insertBranchCounter(path.get('right'), b); +} + +function coverFunction(path) { + this.insertFunctionCounter(path); +} + +function coverVariableDeclarator(path) { + this.insertStatementCounter(path.get('init')); +} + +function coverClassPropDeclarator(path) { + this.insertStatementCounter(path.get('value')); +} + +function makeBlock(path) { + const T = this.types; + if (!path.node) { + path.replaceWith(T.blockStatement([])); + } + if (!path.isBlockStatement()) { + path.replaceWith(T.blockStatement([path.node])); + path.node.loc = path.node.body[0].loc; + path.node.body[0].leadingComments = path.node.leadingComments; + path.node.leadingComments = undefined; + } +} + +function blockProp(prop) { + return function(path) { + makeBlock.call(this, path.get(prop)); + }; +} + +function makeParenthesizedExpressionForNonIdentifier(path) { + const T = this.types; + if (path.node && !path.isIdentifier()) { + path.replaceWith(T.parenthesizedExpression(path.node)); + } +} + +function parenthesizedExpressionProp(prop) { + return function(path) { + makeParenthesizedExpressionForNonIdentifier.call(this, path.get(prop)); + }; +} + +function convertArrowExpression(path) { + const n = path.node; + const T = this.types; + if (!T.isBlockStatement(n.body)) { + const bloc = n.body.loc; + if (n.expression === true) { + n.expression = false; + } + n.body = T.blockStatement([T.returnStatement(n.body)]); + // restore body location + n.body.loc = bloc; + // set up the location for the return statement so it gets + // instrumented + n.body.body[0].loc = bloc; + } +} + +function coverIfBranches(path) { + const n = path.node; + const hint = this.hintFor(n); + const ignoreIf = hint === 'if'; + const ignoreElse = hint === 'else'; + const branch = this.cov.newBranch('if', n.loc); + + if (ignoreIf) { + this.setAttr(n.consequent, 'skip-all', true); + } else { + this.insertBranchCounter(path.get('consequent'), branch, n.loc); + } + if (ignoreElse) { + this.setAttr(n.alternate, 'skip-all', true); + } else { + this.insertBranchCounter(path.get('alternate'), branch); + } +} + +function createSwitchBranch(path) { + const b = this.cov.newBranch('switch', path.node.loc); + this.setAttr(path.node, 'branchName', b); +} + +function coverSwitchCase(path) { + const T = this.types; + const b = this.getAttr(path.parentPath.node, 'branchName'); + /* istanbul ignore if: paranoid check */ + if (b === null) { + throw new Error('Unable to get switch branch name'); + } + const increment = this.getBranchIncrement(b, path.node.loc); + path.node.consequent.unshift(T.expressionStatement(increment)); +} + +function coverTernary(path) { + const n = path.node; + const branch = this.cov.newBranch('cond-expr', path.node.loc); + const cHint = this.hintFor(n.consequent); + const aHint = this.hintFor(n.alternate); + + if (cHint !== 'next') { + this.insertBranchCounter(path.get('consequent'), branch); + } + if (aHint !== 'next') { + this.insertBranchCounter(path.get('alternate'), branch); + } +} + +function coverLogicalExpression(path) { + const T = this.types; + if (path.parentPath.node.type === 'LogicalExpression') { + return; // already processed + } + const leaves = []; + this.findLeaves(path.node, leaves); + const b = this.cov.newBranch( + 'binary-expr', + path.node.loc, + this.reportLogic + ); + for (let i = 0; i < leaves.length; i += 1) { + const leaf = leaves[i]; + const hint = this.hintFor(leaf.node); + if (hint === 'next') { + continue; + } + + if (this.reportLogic) { + const increment = this.getBranchLogicIncrement( + leaf, + b, + leaf.node.loc + ); + if (!increment[0]) { + continue; + } + leaf.parent[leaf.property] = T.sequenceExpression([ + increment[0], + increment[1] + ]); + continue; + } + + const increment = this.getBranchIncrement(b, leaf.node.loc); + if (!increment) { + continue; + } + leaf.parent[leaf.property] = T.sequenceExpression([ + increment, + leaf.node + ]); + } +} + +const codeVisitor = { + ArrowFunctionExpression: entries(convertArrowExpression, coverFunction), + AssignmentPattern: entries(coverAssignmentPattern), + BlockStatement: entries(), // ignore processing only + ExportDefaultDeclaration: entries(), // ignore processing only + ExportNamedDeclaration: entries(), // ignore processing only + ClassMethod: entries(coverFunction), + ClassDeclaration: entries(parenthesizedExpressionProp('superClass')), + ClassProperty: entries(coverClassPropDeclarator), + ClassPrivateProperty: entries(coverClassPropDeclarator), + ObjectMethod: entries(coverFunction), + ExpressionStatement: entries(coverStatement), + BreakStatement: entries(coverStatement), + ContinueStatement: entries(coverStatement), + DebuggerStatement: entries(coverStatement), + ReturnStatement: entries(coverStatement), + ThrowStatement: entries(coverStatement), + TryStatement: entries(coverStatement), + VariableDeclaration: entries(), // ignore processing only + VariableDeclarator: entries(coverVariableDeclarator), + IfStatement: entries( + blockProp('consequent'), + blockProp('alternate'), + coverStatement, + coverIfBranches + ), + ForStatement: entries(blockProp('body'), coverStatement), + ForInStatement: entries(blockProp('body'), coverStatement), + ForOfStatement: entries(blockProp('body'), coverStatement), + WhileStatement: entries(blockProp('body'), coverStatement), + DoWhileStatement: entries(blockProp('body'), coverStatement), + SwitchStatement: entries(createSwitchBranch, coverStatement), + SwitchCase: entries(coverSwitchCase), + WithStatement: entries(blockProp('body'), coverStatement), + FunctionDeclaration: entries(coverFunction), + FunctionExpression: entries(coverFunction), + LabeledStatement: entries(coverStatement), + ConditionalExpression: entries(coverTernary), + LogicalExpression: entries(coverLogicalExpression) +}; +const globalTemplateAlteredFunction = template(` + var Function = (function(){}).constructor; + var global = (new Function(GLOBAL_COVERAGE_SCOPE))(); +`); +const globalTemplateFunction = template(` + var global = (new Function(GLOBAL_COVERAGE_SCOPE))(); +`); +const globalTemplateVariable = template(` + var global = GLOBAL_COVERAGE_SCOPE; +`); +// the template to insert at the top of the program. +const coverageTemplate = template( + ` + function COVERAGE_FUNCTION () { + var path = PATH; + var hash = HASH; + GLOBAL_COVERAGE_TEMPLATE + var gcv = GLOBAL_COVERAGE_VAR; + var coverageData = INITIAL; + var coverage = global[gcv] || (global[gcv] = {}); + if (!coverage[path] || coverage[path].hash !== hash) { + coverage[path] = coverageData; + } + + var actualCoverage = coverage[path]; + { + // @ts-ignore + COVERAGE_FUNCTION = function () { + return actualCoverage; + } + } + + return actualCoverage; + } +`, + { preserveComments: true } +); +// the rewire plugin (and potentially other babel middleware) +// may cause files to be instrumented twice, see: +// https://github.com/istanbuljs/babel-plugin-istanbul/issues/94 +// we should only instrument code for coverage the first time +// it's run through istanbul-lib-instrument. +function alreadyInstrumented(path, visitState) { + return path.scope.hasBinding(visitState.varName); +} +function shouldIgnoreFile(programNode) { + return ( + programNode.parent && + programNode.parent.comments.some(c => COMMENT_FILE_RE.test(c.value)) + ); +} + +/** + * programVisitor is a `babel` adaptor for instrumentation. + * It returns an object with two methods `enter` and `exit`. + * These should be assigned to or called from `Program` entry and exit functions + * in a babel visitor. + * These functions do not make assumptions about the state set by Babel and thus + * can be used in a context other than a Babel plugin. + * + * The exit function returns an object that currently has the following keys: + * + * `fileCoverage` - the file coverage object created for the source file. + * `sourceMappingURL` - any source mapping URL found when processing the file. + * + * @param {Object} types - an instance of babel-types. + * @param {string} sourceFilePath - the path to source file. + * @param {Object} opts - additional options. + * @param {string} [opts.coverageVariable=__coverage__] the global coverage variable name. + * @param {boolean} [opts.reportLogic=false] report boolean value of logical expressions. + * @param {string} [opts.coverageGlobalScope=this] the global coverage variable scope. + * @param {boolean} [opts.coverageGlobalScopeFunc=true] use an evaluated function to find coverageGlobalScope. + * @param {Array} [opts.ignoreClassMethods=[]] names of methods to ignore by default on classes. + * @param {object} [opts.inputSourceMap=undefined] the input source map, that maps the uninstrumented code back to the + * original code. + */ +function programVisitor(types, sourceFilePath = 'unknown.js', opts = {}) { + const T = types; + opts = { + ...defaults.instrumentVisitor, + ...opts + }; + const visitState = new VisitState( + types, + sourceFilePath, + opts.inputSourceMap, + opts.ignoreClassMethods, + opts.reportLogic + ); + return { + enter(path) { + if (shouldIgnoreFile(path.find(p => p.isProgram()))) { + return; + } + if (alreadyInstrumented(path, visitState)) { + return; + } + path.traverse(codeVisitor, visitState); + }, + exit(path) { + if (alreadyInstrumented(path, visitState)) { + return; + } + visitState.cov.freeze(); + const coverageData = visitState.cov.toJSON(); + if (shouldIgnoreFile(path.find(p => p.isProgram()))) { + return { + fileCoverage: coverageData, + sourceMappingURL: visitState.sourceMappingURL + }; + } + coverageData[MAGIC_KEY] = MAGIC_VALUE; + const hash = createHash(SHA) + .update(JSON.stringify(coverageData)) + .digest('hex'); + coverageData.hash = hash; + if ( + coverageData.inputSourceMap && + Object.getPrototypeOf(coverageData.inputSourceMap) !== + Object.prototype + ) { + coverageData.inputSourceMap = { + ...coverageData.inputSourceMap + }; + } + const coverageNode = T.valueToNode(coverageData); + delete coverageData[MAGIC_KEY]; + delete coverageData.hash; + let gvTemplate; + if (opts.coverageGlobalScopeFunc) { + if (path.scope.getBinding('Function')) { + gvTemplate = globalTemplateAlteredFunction({ + GLOBAL_COVERAGE_SCOPE: T.stringLiteral( + 'return ' + opts.coverageGlobalScope + ) + }); + } else { + gvTemplate = globalTemplateFunction({ + GLOBAL_COVERAGE_SCOPE: T.stringLiteral( + 'return ' + opts.coverageGlobalScope + ) + }); + } + } else { + gvTemplate = globalTemplateVariable({ + GLOBAL_COVERAGE_SCOPE: opts.coverageGlobalScope + }); + } + const cv = coverageTemplate({ + GLOBAL_COVERAGE_VAR: T.stringLiteral(opts.coverageVariable), + GLOBAL_COVERAGE_TEMPLATE: gvTemplate, + COVERAGE_FUNCTION: T.identifier(visitState.varName), + PATH: T.stringLiteral(sourceFilePath), + INITIAL: coverageNode, + HASH: T.stringLiteral(hash) + }); + // explicitly call this.varName to ensure coverage is always initialized + path.node.body.unshift( + T.expressionStatement( + T.callExpression(T.identifier(visitState.varName), []) + ) + ); + path.node.body.unshift(cv); + return { + fileCoverage: coverageData, + sourceMappingURL: visitState.sourceMappingURL + }; + } + }; +} + +module.exports = programVisitor; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/HasteFS.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/HasteFS.js new file mode 100644 index 0000000000000000000000000000000000000000..09384ba521fade5c0719499780ff31edb785a946 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/HasteFS.js @@ -0,0 +1,139 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +var _constants = _interopRequireDefault(require('./constants')); +var fastPath = _interopRequireWildcard(require('./lib/fast_path')); +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class HasteFS { + _rootDir; + _files; + constructor({rootDir, files}) { + this._rootDir = rootDir; + this._files = files; + } + getModuleName(file) { + const fileMetadata = this._getFileData(file); + return (fileMetadata && fileMetadata[_constants.default.ID]) || null; + } + getSize(file) { + const fileMetadata = this._getFileData(file); + return (fileMetadata && fileMetadata[_constants.default.SIZE]) || null; + } + getDependencies(file) { + const fileMetadata = this._getFileData(file); + if (fileMetadata) { + return fileMetadata[_constants.default.DEPENDENCIES] + ? fileMetadata[_constants.default.DEPENDENCIES].split( + _constants.default.DEPENDENCY_DELIM + ) + : []; + } else { + return null; + } + } + getSha1(file) { + const fileMetadata = this._getFileData(file); + return (fileMetadata && fileMetadata[_constants.default.SHA1]) || null; + } + exists(file) { + return this._getFileData(file) != null; + } + getAllFiles() { + return Array.from(this.getAbsoluteFileIterator()); + } + getFileIterator() { + return this._files.keys(); + } + *getAbsoluteFileIterator() { + for (const file of this.getFileIterator()) { + yield fastPath.resolve(this._rootDir, file); + } + } + matchFiles(pattern) { + if (!(pattern instanceof RegExp)) { + pattern = new RegExp(pattern); + } + const files = []; + for (const file of this.getAbsoluteFileIterator()) { + if (pattern.test(file)) { + files.push(file); + } + } + return files; + } + matchFilesWithGlob(globs, root) { + const files = new Set(); + const matcher = (0, _jestUtil().globsToMatcher)(globs); + for (const file of this.getAbsoluteFileIterator()) { + const filePath = root ? fastPath.relative(root, file) : file; + if (matcher((0, _jestUtil().replacePathSepForGlob)(filePath))) { + files.add(file); + } + } + return files; + } + _getFileData(file) { + const relativePath = fastPath.relative(this._rootDir, file); + return this._files.get(relativePath); + } +} +exports.default = HasteFS; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/ModuleMap.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/ModuleMap.js new file mode 100644 index 0000000000000000000000000000000000000000..5ddd1fd8c26289d7702347ecefe986c55c99a6dc --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/ModuleMap.js @@ -0,0 +1,249 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +var _constants = _interopRequireDefault(require('./constants')); +var fastPath = _interopRequireWildcard(require('./lib/fast_path')); +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const EMPTY_OBJ = {}; +const EMPTY_MAP = new Map(); +class ModuleMap { + static DuplicateHasteCandidatesError; + _raw; + json; + static mapToArrayRecursive(map) { + let arr = Array.from(map); + if (arr[0] && arr[0][1] instanceof Map) { + arr = arr.map(el => [el[0], this.mapToArrayRecursive(el[1])]); + } + return arr; + } + static mapFromArrayRecursive(arr) { + if (arr[0] && Array.isArray(arr[1])) { + arr = arr.map(el => [el[0], this.mapFromArrayRecursive(el[1])]); + } + return new Map(arr); + } + constructor(raw) { + this._raw = raw; + } + getModule(name, platform, supportsNativePlatform, type) { + if (type == null) { + type = _constants.default.MODULE; + } + const module = this._getModuleMetadata( + name, + platform, + !!supportsNativePlatform + ); + if (module && module[_constants.default.TYPE] === type) { + const modulePath = module[_constants.default.PATH]; + return modulePath && fastPath.resolve(this._raw.rootDir, modulePath); + } + return null; + } + getPackage(name, platform, _supportsNativePlatform) { + return this.getModule(name, platform, null, _constants.default.PACKAGE); + } + getMockModule(name) { + const mockPath = + this._raw.mocks.get(name) || this._raw.mocks.get(`${name}/index`); + return mockPath && fastPath.resolve(this._raw.rootDir, mockPath); + } + getRawModuleMap() { + return { + duplicates: this._raw.duplicates, + map: this._raw.map, + mocks: this._raw.mocks, + rootDir: this._raw.rootDir + }; + } + toJSON() { + if (!this.json) { + this.json = { + duplicates: ModuleMap.mapToArrayRecursive(this._raw.duplicates), + map: Array.from(this._raw.map), + mocks: Array.from(this._raw.mocks), + rootDir: this._raw.rootDir + }; + } + return this.json; + } + static fromJSON(serializableModuleMap) { + return new ModuleMap({ + duplicates: ModuleMap.mapFromArrayRecursive( + serializableModuleMap.duplicates + ), + map: new Map(serializableModuleMap.map), + mocks: new Map(serializableModuleMap.mocks), + rootDir: serializableModuleMap.rootDir + }); + } + + /** + * When looking up a module's data, we walk through each eligible platform for + * the query. For each platform, we want to check if there are known + * duplicates for that name+platform pair. The duplication logic normally + * removes elements from the `map` object, but we want to check upfront to be + * extra sure. If metadata exists both in the `duplicates` object and the + * `map`, this would be a bug. + */ + _getModuleMetadata(name, platform, supportsNativePlatform) { + const map = this._raw.map.get(name) || EMPTY_OBJ; + const dupMap = this._raw.duplicates.get(name) || EMPTY_MAP; + if (platform != null) { + this._assertNoDuplicates( + name, + platform, + supportsNativePlatform, + dupMap.get(platform) + ); + if (map[platform] != null) { + return map[platform]; + } + } + if (supportsNativePlatform) { + this._assertNoDuplicates( + name, + _constants.default.NATIVE_PLATFORM, + supportsNativePlatform, + dupMap.get(_constants.default.NATIVE_PLATFORM) + ); + if (map[_constants.default.NATIVE_PLATFORM]) { + return map[_constants.default.NATIVE_PLATFORM]; + } + } + this._assertNoDuplicates( + name, + _constants.default.GENERIC_PLATFORM, + supportsNativePlatform, + dupMap.get(_constants.default.GENERIC_PLATFORM) + ); + if (map[_constants.default.GENERIC_PLATFORM]) { + return map[_constants.default.GENERIC_PLATFORM]; + } + return null; + } + _assertNoDuplicates(name, platform, supportsNativePlatform, relativePathSet) { + if (relativePathSet == null) { + return; + } + // Force flow refinement + const previousSet = relativePathSet; + const duplicates = new Map(); + for (const [relativePath, type] of previousSet) { + const duplicatePath = fastPath.resolve(this._raw.rootDir, relativePath); + duplicates.set(duplicatePath, type); + } + throw new DuplicateHasteCandidatesError( + name, + platform, + supportsNativePlatform, + duplicates + ); + } + static create(rootDir) { + return new ModuleMap({ + duplicates: new Map(), + map: new Map(), + mocks: new Map(), + rootDir + }); + } +} +exports.default = ModuleMap; +class DuplicateHasteCandidatesError extends Error { + hasteName; + platform; + supportsNativePlatform; + duplicatesSet; + constructor(name, platform, supportsNativePlatform, duplicatesSet) { + const platformMessage = getPlatformMessage(platform); + super( + `The name \`${name}\` was looked up in the Haste module map. It ` + + 'cannot be resolved, because there exists several different ' + + 'files, or packages, that provide a module for ' + + `that particular name and platform. ${platformMessage} You must ` + + `delete or exclude files until there remains only one of these:\n\n${Array.from( + duplicatesSet + ) + .map( + ([dupFilePath, dupFileType]) => + ` * \`${dupFilePath}\` (${getTypeMessage(dupFileType)})\n` + ) + .sort() + .join('')}` + ); + this.hasteName = name; + this.platform = platform; + this.supportsNativePlatform = supportsNativePlatform; + this.duplicatesSet = duplicatesSet; + } +} +function getPlatformMessage(platform) { + if (platform === _constants.default.GENERIC_PLATFORM) { + return 'The platform is generic (no extension).'; + } + return `The platform extension is \`${platform}\`.`; +} +function getTypeMessage(type) { + switch (type) { + case _constants.default.MODULE: + return 'module'; + case _constants.default.PACKAGE: + return 'package'; + } + return 'unknown'; +} +ModuleMap.DuplicateHasteCandidatesError = DuplicateHasteCandidatesError; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/blacklist.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/blacklist.js new file mode 100644 index 0000000000000000000000000000000000000000..ae90b1a75e09a2b04e9174b0aa3a0afc750f51f6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/blacklist.js @@ -0,0 +1,64 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// This list is compiled after the MDN list of the most common MIME types (see +// https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/ +// Complete_list_of_MIME_types). +// +// Only MIME types starting with "image/", "video/", "audio/" and "font/" are +// reflected in the list. Adding "application/" is too risky since some text +// file formats (like ".js" and ".json") have an "application/" MIME type. +// +// Feel free to add any extensions that cannot be a Haste module. + +const extensions = new Set([ + // JSONs are never haste modules, except for "package.json", which is handled. + '.json', + // Image extensions. + '.bmp', + '.gif', + '.ico', + '.jpeg', + '.jpg', + '.png', + '.svg', + '.tiff', + '.tif', + '.webp', + // Video extensions. + '.avi', + '.mp4', + '.mpeg', + '.mpg', + '.ogv', + '.webm', + '.3gp', + '.3g2', + // Audio extensions. + '.aac', + '.midi', + '.mid', + '.mp3', + '.oga', + '.wav', + '.3gp', + '.3g2', + // Font extensions. + '.eot', + '.otf', + '.ttf', + '.woff', + '.woff2' +]); +var _default = extensions; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/constants.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/constants.js new file mode 100644 index 0000000000000000000000000000000000000000..1b8804ec3e31764202e2805c82eb5d438ca22158 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/constants.js @@ -0,0 +1,46 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +/* + * This file exports a set of constants that are used for Jest's haste map + * serialization. On very large repositories, the haste map cache becomes very + * large to the point where it is the largest overhead in starting up Jest. + * + * This constant key map allows to keep the map smaller without having to build + * a custom serialization library. + */ + +/* eslint-disable sort-keys */ +const constants = { + /* dependency serialization */ + DEPENDENCY_DELIM: '\0', + /* file map attributes */ + ID: 0, + MTIME: 1, + SIZE: 2, + VISITED: 3, + DEPENDENCIES: 4, + SHA1: 5, + /* module map attributes */ + PATH: 0, + TYPE: 1, + /* module types */ + MODULE: 0, + PACKAGE: 1, + /* platforms */ + GENERIC_PLATFORM: 'g', + NATIVE_PLATFORM: 'native' +}; +/* eslint-enable */ +var _default = constants; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/crawlers/node.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/crawlers/node.js new file mode 100644 index 0000000000000000000000000000000000000000..eb90b4e1bce64ab6809d914db9122e1fc8dc151c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/crawlers/node.js @@ -0,0 +1,269 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.nodeCrawl = nodeCrawl; +function _child_process() { + const data = require('child_process'); + _child_process = function () { + return data; + }; + return data; +} +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function fs() { + const data = _interopRequireWildcard(require('graceful-fs')); + fs = function () { + return data; + }; + return data; +} +var _constants = _interopRequireDefault(require('../constants')); +var fastPath = _interopRequireWildcard(require('../lib/fast_path')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +async function hasNativeFindSupport(forceNodeFilesystemAPI) { + if (forceNodeFilesystemAPI) { + return false; + } + try { + return await new Promise(resolve => { + // Check the find binary supports the non-POSIX -iname parameter wrapped in parens. + const args = [ + '.', + '-type', + 'f', + '(', + '-iname', + '*.ts', + '-o', + '-iname', + '*.js', + ')' + ]; + const child = (0, _child_process().spawn)('find', args, { + cwd: __dirname + }); + child.on('error', () => { + resolve(false); + }); + child.on('exit', code => { + resolve(code === 0); + }); + }); + } catch { + return false; + } +} +function find(roots, extensions, ignore, enableSymlinks, callback) { + const result = []; + let activeCalls = 0; + function search(directory) { + activeCalls++; + fs().readdir( + directory, + { + withFileTypes: true + }, + (err, entries) => { + activeCalls--; + if (err) { + if (activeCalls === 0) { + callback(result); + } + return; + } + entries.forEach(entry => { + const file = path().join(directory, entry.name); + if (ignore(file)) { + return; + } + if (entry.isSymbolicLink()) { + return; + } + if (entry.isDirectory()) { + search(file); + return; + } + activeCalls++; + const stat = enableSymlinks ? fs().stat : fs().lstat; + stat(file, (err, stat) => { + activeCalls--; + + // This logic is unnecessary for node > v10.10, but leaving it in + // since we need it for backwards-compatibility still. + if (!err && stat && !stat.isSymbolicLink()) { + if (stat.isDirectory()) { + search(file); + } else { + const ext = path().extname(file).substr(1); + if (extensions.indexOf(ext) !== -1) { + result.push([file, stat.mtime.getTime(), stat.size]); + } + } + } + if (activeCalls === 0) { + callback(result); + } + }); + }); + if (activeCalls === 0) { + callback(result); + } + } + ); + } + if (roots.length > 0) { + roots.forEach(search); + } else { + callback(result); + } +} +function findNative(roots, extensions, ignore, enableSymlinks, callback) { + const args = Array.from(roots); + if (enableSymlinks) { + args.push('(', '-type', 'f', '-o', '-type', 'l', ')'); + } else { + args.push('-type', 'f'); + } + if (extensions.length) { + args.push('('); + } + extensions.forEach((ext, index) => { + if (index) { + args.push('-o'); + } + args.push('-iname'); + args.push(`*.${ext}`); + }); + if (extensions.length) { + args.push(')'); + } + const child = (0, _child_process().spawn)('find', args); + let stdout = ''; + if (child.stdout === null) { + throw new Error( + 'stdout is null - this should never happen. Please open up an issue at https://github.com/jestjs/jest' + ); + } + child.stdout.setEncoding('utf-8'); + child.stdout.on('data', data => (stdout += data)); + child.stdout.on('close', () => { + const lines = stdout + .trim() + .split('\n') + .filter(x => !ignore(x)); + const result = []; + let count = lines.length; + if (!count) { + callback([]); + } else { + lines.forEach(path => { + fs().stat(path, (err, stat) => { + // Filter out symlinks that describe directories + if (!err && stat && !stat.isDirectory()) { + result.push([path, stat.mtime.getTime(), stat.size]); + } + if (--count === 0) { + callback(result); + } + }); + }); + } + }); +} +async function nodeCrawl(options) { + const { + data, + extensions, + forceNodeFilesystemAPI, + ignore, + rootDir, + enableSymlinks, + roots + } = options; + const useNativeFind = await hasNativeFindSupport(forceNodeFilesystemAPI); + return new Promise(resolve => { + const callback = list => { + const files = new Map(); + const removedFiles = new Map(data.files); + list.forEach(fileData => { + const [filePath, mtime, size] = fileData; + const relativeFilePath = fastPath.relative(rootDir, filePath); + const existingFile = data.files.get(relativeFilePath); + if (existingFile && existingFile[_constants.default.MTIME] === mtime) { + files.set(relativeFilePath, existingFile); + } else { + // See ../constants.js; SHA-1 will always be null and fulfilled later. + files.set(relativeFilePath, ['', mtime, size, 0, '', null]); + } + removedFiles.delete(relativeFilePath); + }); + data.files = files; + resolve({ + hasteMap: data, + removedFiles + }); + }; + if (useNativeFind) { + findNative(roots, extensions, ignore, enableSymlinks, callback); + } else { + find(roots, extensions, ignore, enableSymlinks, callback); + } + }); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/crawlers/watchman.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/crawlers/watchman.js new file mode 100644 index 0000000000000000000000000000000000000000..3b2fbfffad80c05dc3b7e8ecf74f1eeef9bacff9 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/crawlers/watchman.js @@ -0,0 +1,339 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.watchmanCrawl = watchmanCrawl; +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _fbWatchman() { + const data = _interopRequireDefault(require('fb-watchman')); + _fbWatchman = function () { + return data; + }; + return data; +} +var _constants = _interopRequireDefault(require('../constants')); +var fastPath = _interopRequireWildcard(require('../lib/fast_path')); +var _normalizePathSep = _interopRequireDefault( + require('../lib/normalizePathSep') +); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const watchmanURL = 'https://facebook.github.io/watchman/docs/troubleshooting'; +function WatchmanError(error) { + error.message = + `Watchman error: ${error.message.trim()}. Make sure watchman ` + + `is running for this project. See ${watchmanURL}.`; + return error; +} + +/** + * Wrap watchman capabilityCheck method as a promise. + * + * @param client watchman client + * @param caps capabilities to verify + * @returns a promise resolving to a list of verified capabilities + */ +async function capabilityCheck(client, caps) { + return new Promise((resolve, reject) => { + client.capabilityCheck( + // @ts-expect-error: incorrectly typed + caps, + (error, response) => { + if (error) { + reject(error); + } else { + resolve(response); + } + } + ); + }); +} +async function watchmanCrawl(options) { + const fields = ['name', 'exists', 'mtime_ms', 'size']; + const {data, extensions, ignore, rootDir, roots} = options; + const defaultWatchExpression = ['allof', ['type', 'f']]; + const clocks = data.clocks; + const client = new (_fbWatchman().default.Client)(); + + // https://facebook.github.io/watchman/docs/capabilities.html + // Check adds about ~28ms + const capabilities = await capabilityCheck(client, { + // If a required capability is missing then an error will be thrown, + // we don't need this assertion, so using optional instead. + optional: ['suffix-set'] + }); + if (capabilities?.capabilities['suffix-set']) { + // If available, use the optimized `suffix-set` operation: + // https://facebook.github.io/watchman/docs/expr/suffix.html#suffix-set + defaultWatchExpression.push(['suffix', extensions]); + } else { + // Otherwise use the older and less optimal suffix tuple array + defaultWatchExpression.push([ + 'anyof', + ...extensions.map(extension => ['suffix', extension]) + ]); + } + let clientError; + client.on('error', error => (clientError = WatchmanError(error))); + const cmd = (...args) => + new Promise((resolve, reject) => + client.command(args, (error, result) => + error ? reject(WatchmanError(error)) : resolve(result) + ) + ); + if (options.computeSha1) { + const {capabilities} = await cmd('list-capabilities'); + if (capabilities.indexOf('field-content.sha1hex') !== -1) { + fields.push('content.sha1hex'); + } + } + async function getWatchmanRoots(roots) { + const watchmanRoots = new Map(); + await Promise.all( + roots.map(async root => { + const response = await cmd('watch-project', root); + const existing = watchmanRoots.get(response.watch); + // A root can only be filtered if it was never seen with a + // relative_path before. + const canBeFiltered = !existing || existing.length > 0; + if (canBeFiltered) { + if (response.relative_path) { + watchmanRoots.set( + response.watch, + (existing || []).concat(response.relative_path) + ); + } else { + // Make the filter directories an empty array to signal that this + // root was already seen and needs to be watched for all files or + // directories. + watchmanRoots.set(response.watch, []); + } + } + }) + ); + return watchmanRoots; + } + async function queryWatchmanForDirs(rootProjectDirMappings) { + const results = new Map(); + let isFresh = false; + await Promise.all( + Array.from(rootProjectDirMappings).map( + async ([root, directoryFilters]) => { + const expression = Array.from(defaultWatchExpression); + const glob = []; + if (directoryFilters.length > 0) { + expression.push([ + 'anyof', + ...directoryFilters.map(dir => ['dirname', dir]) + ]); + for (const directory of directoryFilters) { + for (const extension of extensions) { + glob.push(`${directory}/**/*.${extension}`); + } + } + } else { + for (const extension of extensions) { + glob.push(`**/*.${extension}`); + } + } + + // Jest is only going to store one type of clock; a string that + // represents a local clock. However, the Watchman crawler supports + // a second type of clock that can be written by automation outside of + // Jest, called an "scm query", which fetches changed files based on + // source control mergebases. The reason this is necessary is because + // local clocks are not portable across systems, but scm queries are. + // By using scm queries, we can create the haste map on a different + // system and import it, transforming the clock into a local clock. + const since = clocks.get(fastPath.relative(rootDir, root)); + const query = + since !== undefined + ? // Use the `since` generator if we have a clock available + { + expression, + fields, + since + } + : // Otherwise use the `glob` filter + { + expression, + fields, + glob, + glob_includedotfiles: true + }; + const response = await cmd('query', root, query); + if ('warning' in response) { + console.warn('watchman warning: ', response.warning); + } + + // When a source-control query is used, we ignore the "is fresh" + // response from Watchman because it will be true despite the query + // being incremental. + const isSourceControlQuery = + typeof since !== 'string' && + since?.scm?.['mergebase-with'] !== undefined; + if (!isSourceControlQuery) { + isFresh = isFresh || response.is_fresh_instance; + } + results.set(root, response); + } + ) + ); + return { + isFresh, + results + }; + } + let files = data.files; + let removedFiles = new Map(); + const changedFiles = new Map(); + let results; + let isFresh = false; + try { + const watchmanRoots = await getWatchmanRoots(roots); + const watchmanFileResults = await queryWatchmanForDirs(watchmanRoots); + + // Reset the file map if watchman was restarted and sends us a list of + // files. + if (watchmanFileResults.isFresh) { + files = new Map(); + removedFiles = new Map(data.files); + isFresh = true; + } + results = watchmanFileResults.results; + } finally { + client.end(); + } + if (clientError) { + throw clientError; + } + for (const [watchRoot, response] of results) { + const fsRoot = (0, _normalizePathSep.default)(watchRoot); + const relativeFsRoot = fastPath.relative(rootDir, fsRoot); + clocks.set( + relativeFsRoot, + // Ensure we persist only the local clock. + typeof response.clock === 'string' ? response.clock : response.clock.clock + ); + for (const fileData of response.files) { + const filePath = + fsRoot + path().sep + (0, _normalizePathSep.default)(fileData.name); + const relativeFilePath = fastPath.relative(rootDir, filePath); + const existingFileData = data.files.get(relativeFilePath); + + // If watchman is fresh, the removed files map starts with all files + // and we remove them as we verify they still exist. + if (isFresh && existingFileData && fileData.exists) { + removedFiles.delete(relativeFilePath); + } + if (!fileData.exists) { + // No need to act on files that do not exist and were not tracked. + if (existingFileData) { + files.delete(relativeFilePath); + + // If watchman is not fresh, we will know what specific files were + // deleted since we last ran and can track only those files. + if (!isFresh) { + removedFiles.set(relativeFilePath, existingFileData); + } + } + } else if (!ignore(filePath)) { + const mtime = + typeof fileData.mtime_ms === 'number' + ? fileData.mtime_ms + : fileData.mtime_ms.toNumber(); + const size = fileData.size; + let sha1hex = fileData['content.sha1hex']; + if (typeof sha1hex !== 'string' || sha1hex.length !== 40) { + sha1hex = undefined; + } + let nextData; + if ( + existingFileData && + existingFileData[_constants.default.MTIME] === mtime + ) { + nextData = existingFileData; + } else if ( + existingFileData && + sha1hex && + existingFileData[_constants.default.SHA1] === sha1hex + ) { + nextData = [ + existingFileData[0], + mtime, + existingFileData[2], + existingFileData[3], + existingFileData[4], + existingFileData[5] + ]; + } else { + // See ../constants.ts + nextData = ['', mtime, size, 0, '', sha1hex ?? null]; + } + files.set(relativeFilePath, nextData); + changedFiles.set(relativeFilePath, nextData); + } + } + } + data.files = files; + return { + changedFiles: isFresh ? undefined : changedFiles, + hasteMap: data, + removedFiles + }; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/getMockName.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/getMockName.js new file mode 100644 index 0000000000000000000000000000000000000000..445e0b27c057193ccebdf52d7c6bd877b1c11fb7 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/getMockName.js @@ -0,0 +1,69 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const MOCKS_PATTERN = `${path().sep}__mocks__${path().sep}`; +const getMockName = filePath => { + const mockPath = filePath.split(MOCKS_PATTERN)[1]; + return mockPath + .substring(0, mockPath.lastIndexOf(path().extname(mockPath))) + .replace(/\\/g, '/'); +}; +var _default = getMockName; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a0466fe85c1a1eeb24d85b3014166b7e2881c4e3 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/index.d.ts @@ -0,0 +1,242 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/// + +import type {Config} from '@jest/types'; +import type {Stats} from 'graceful-fs'; + +declare type ChangeEvent = { + eventsQueue: EventsQueue; + hasteFS: HasteFS; + moduleMap: ModuleMap_2; +}; + +export declare class DuplicateError extends Error { + mockPath1: string; + mockPath2: string; + constructor(mockPath1: string, mockPath2: string); +} + +declare class DuplicateHasteCandidatesError extends Error { + hasteName: string; + platform: string | null; + supportsNativePlatform: boolean; + duplicatesSet: DuplicatesSet; + constructor( + name: string, + platform: string, + supportsNativePlatform: boolean, + duplicatesSet: DuplicatesSet, + ); +} + +declare type DuplicatesIndex = Map>; + +declare type DuplicatesSet = Map; + +declare type EventsQueue = Array<{ + filePath: string; + stat: Stats | undefined; + type: string; +}>; + +declare type FileData = Map; + +declare type FileMetaData = [ + id: string, + mtime: number, + size: number, + visited: 0 | 1, + dependencies: string, + sha1: string | null | undefined, +]; + +declare class HasteFS implements IHasteFS { + private readonly _rootDir; + private readonly _files; + constructor({rootDir, files}: {rootDir: string; files: FileData}); + getModuleName(file: string): string | null; + getSize(file: string): number | null; + getDependencies(file: string): Array | null; + getSha1(file: string): string | null; + exists(file: string): boolean; + getAllFiles(): Array; + getFileIterator(): Iterable; + getAbsoluteFileIterator(): Iterable; + matchFiles(pattern: RegExp | string): Array; + matchFilesWithGlob(globs: Array, root: string | null): Set; + private _getFileData; +} + +declare type HasteMapStatic = { + getCacheFilePath( + tmpdir: string, + name: string, + ...extra: Array + ): string; + getModuleMapFromJSON(json: S): IModuleMap; +}; + +declare type HasteRegExp = RegExp | ((str: string) => boolean); + +declare type HType = { + ID: 0; + MTIME: 1; + SIZE: 2; + VISITED: 3; + DEPENDENCIES: 4; + SHA1: 5; + PATH: 0; + TYPE: 1; + MODULE: 0; + PACKAGE: 1; + GENERIC_PLATFORM: 'g'; + NATIVE_PLATFORM: 'native'; + DEPENDENCY_DELIM: '\0'; +}; + +declare type HTypeValue = HType[keyof HType]; + +export declare interface IHasteFS { + exists(path: string): boolean; + getAbsoluteFileIterator(): Iterable; + getAllFiles(): Array; + getDependencies(file: string): Array | null; + getSize(path: string): number | null; + matchFiles(pattern: RegExp | string): Array; + matchFilesWithGlob( + globs: ReadonlyArray, + root: string | null, + ): Set; +} + +export declare interface IHasteMap { + on(eventType: 'change', handler: (event: ChangeEvent) => void): void; + build(): Promise<{ + hasteFS: IHasteFS; + moduleMap: IModuleMap; + }>; +} + +declare type IJestHasteMap = HasteMapStatic & { + create(options: Options): Promise; + getStatic(config: Config.ProjectConfig): HasteMapStatic; +}; + +export declare interface IModuleMap { + getModule( + name: string, + platform?: string | null, + supportsNativePlatform?: boolean | null, + type?: HTypeValue | null, + ): string | null; + getPackage( + name: string, + platform: string | null | undefined, + _supportsNativePlatform: boolean | null, + ): string | null; + getMockModule(name: string): string | undefined; + getRawModuleMap(): RawModuleMap; + toJSON(): S; +} + +declare const JestHasteMap: IJestHasteMap; +export default JestHasteMap; + +declare type MockData = Map; + +export declare const ModuleMap: { + create: (rootPath: string) => IModuleMap; +}; + +declare class ModuleMap_2 implements IModuleMap { + static DuplicateHasteCandidatesError: typeof DuplicateHasteCandidatesError; + private readonly _raw; + private json; + private static mapToArrayRecursive; + private static mapFromArrayRecursive; + constructor(raw: RawModuleMap); + getModule( + name: string, + platform?: string | null, + supportsNativePlatform?: boolean | null, + type?: HTypeValue | null, + ): string | null; + getPackage( + name: string, + platform: string | null | undefined, + _supportsNativePlatform: boolean | null, + ): string | null; + getMockModule(name: string): string | undefined; + getRawModuleMap(): RawModuleMap; + toJSON(): SerializableModuleMap; + static fromJSON(serializableModuleMap: SerializableModuleMap): ModuleMap_2; + /** + * When looking up a module's data, we walk through each eligible platform for + * the query. For each platform, we want to check if there are known + * duplicates for that name+platform pair. The duplication logic normally + * removes elements from the `map` object, but we want to check upfront to be + * extra sure. If metadata exists both in the `duplicates` object and the + * `map`, this would be a bug. + */ + private _getModuleMetadata; + private _assertNoDuplicates; + static create(rootDir: string): ModuleMap_2; +} + +declare type ModuleMapData = Map; + +declare type ModuleMapItem = { + [platform: string]: ModuleMetaData; +}; + +declare type ModuleMetaData = [path: string, type: number]; + +declare type Options = { + cacheDirectory?: string; + computeDependencies?: boolean; + computeSha1?: boolean; + console?: Console; + dependencyExtractor?: string | null; + enableSymlinks?: boolean; + extensions: Array; + forceNodeFilesystemAPI?: boolean; + hasteImplModulePath?: string; + hasteMapModulePath?: string; + id: string; + ignorePattern?: HasteRegExp; + maxWorkers: number; + mocksPattern?: string; + platforms: Array; + resetCache?: boolean; + retainAllFiles: boolean; + rootDir: string; + roots: Array; + skipPackageJson?: boolean; + throwOnModuleCollision?: boolean; + useWatchman?: boolean; + watch?: boolean; + workerThreads?: boolean; +}; + +declare type RawModuleMap = { + rootDir: string; + duplicates: DuplicatesIndex; + map: ModuleMapData; + mocks: MockData; +}; + +export declare type SerializableModuleMap = { + duplicates: ReadonlyArray<[string, [string, [string, [string, number]]]]>; + map: ReadonlyArray<[string, ValueType]>; + mocks: ReadonlyArray<[string, ValueType]>; + rootDir: string; +}; + +declare type ValueType = T extends Map ? V : never; + +export {}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..d8a3b5eca24acbbc2bb4d4adeede73fac8d01bda --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/index.js @@ -0,0 +1,1107 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = exports.ModuleMap = exports.DuplicateError = void 0; +function _crypto() { + const data = require('crypto'); + _crypto = function () { + return data; + }; + return data; +} +function _events() { + const data = require('events'); + _events = function () { + return data; + }; + return data; +} +function _os() { + const data = require('os'); + _os = function () { + return data; + }; + return data; +} +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _v() { + const data = require('v8'); + _v = function () { + return data; + }; + return data; +} +function _gracefulFs() { + const data = require('graceful-fs'); + _gracefulFs = function () { + return data; + }; + return data; +} +function _jestRegexUtil() { + const data = require('jest-regex-util'); + _jestRegexUtil = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +function _jestWorker() { + const data = require('jest-worker'); + _jestWorker = function () { + return data; + }; + return data; +} +var _HasteFS = _interopRequireDefault(require('./HasteFS')); +var _ModuleMap = _interopRequireDefault(require('./ModuleMap')); +var _constants = _interopRequireDefault(require('./constants')); +var _node = require('./crawlers/node'); +var _watchman = require('./crawlers/watchman'); +var _getMockName = _interopRequireDefault(require('./getMockName')); +var fastPath = _interopRequireWildcard(require('./lib/fast_path')); +var _getPlatformExtension = _interopRequireDefault( + require('./lib/getPlatformExtension') +); +var _isWatchmanInstalled = _interopRequireDefault( + require('./lib/isWatchmanInstalled') +); +var _normalizePathSep = _interopRequireDefault( + require('./lib/normalizePathSep') +); +var _FSEventsWatcher = require('./watchers/FSEventsWatcher'); +var _NodeWatcher = _interopRequireDefault(require('./watchers/NodeWatcher')); +var _WatchmanWatcher = _interopRequireDefault( + require('./watchers/WatchmanWatcher') +); +var _worker = require('./worker'); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// @ts-expect-error: not converted to TypeScript - it's a fork: https://github.com/jestjs/jest/pull/10919 + +// @ts-expect-error: not converted to TypeScript - it's a fork: https://github.com/jestjs/jest/pull/5387 + +// TypeScript doesn't like us importing from outside `rootDir`, but it doesn't +// understand `require`. +const {version: VERSION} = require('../package.json'); +const ModuleMap = _ModuleMap.default; +exports.ModuleMap = ModuleMap; +const CHANGE_INTERVAL = 30; +const MAX_WAIT_TIME = 240000; +const NODE_MODULES = `${path().sep}node_modules${path().sep}`; +const PACKAGE_JSON = `${path().sep}package.json`; +const VCS_DIRECTORIES = ['.git', '.hg', '.sl'] + .map(vcs => + (0, _jestRegexUtil().escapePathForRegex)(path().sep + vcs + path().sep) + ) + .join('|'); + +/** + * HasteMap is a JavaScript implementation of Facebook's haste module system. + * + * This implementation is inspired by https://github.com/facebook/node-haste + * and was built with for high-performance in large code repositories with + * hundreds of thousands of files. This implementation is scalable and provides + * predictable performance. + * + * Because the haste map creation and synchronization is critical to startup + * performance and most tasks are blocked by I/O this class makes heavy use of + * synchronous operations. It uses worker processes for parallelizing file + * access and metadata extraction. + * + * The data structures created by `jest-haste-map` can be used directly from the + * cache without further processing. The metadata objects in the `files` and + * `map` objects contain cross-references: a metadata object from one can look + * up the corresponding metadata object in the other map. Note that in most + * projects, the number of files will be greater than the number of haste + * modules one module can refer to many files based on platform extensions. + * + * type HasteMap = { + * clocks: WatchmanClocks, + * files: {[filepath: string]: FileMetaData}, + * map: {[id: string]: ModuleMapItem}, + * mocks: {[id: string]: string}, + * } + * + * // Watchman clocks are used for query synchronization and file system deltas. + * type WatchmanClocks = {[filepath: string]: string}; + * + * type FileMetaData = { + * id: ?string, // used to look up module metadata objects in `map`. + * mtime: number, // check for outdated files. + * size: number, // size of the file in bytes. + * visited: boolean, // whether the file has been parsed or not. + * dependencies: Array, // all relative dependencies of this file. + * sha1: ?string, // SHA-1 of the file, if requested via options. + * }; + * + * // Modules can be targeted to a specific platform based on the file name. + * // Example: platform.ios.js and Platform.android.js will both map to the same + * // `Platform` module. The platform should be specified during resolution. + * type ModuleMapItem = {[platform: string]: ModuleMetaData}; + * + * // + * type ModuleMetaData = { + * path: string, // the path to look up the file object in `files`. + * type: string, // the module type (either `package` or `module`). + * }; + * + * Note that the data structures described above are conceptual only. The actual + * implementation uses arrays and constant keys for metadata storage. Instead of + * `{id: 'flatMap', mtime: 3421, size: 42, visited: true, dependencies: []}` the real + * representation is similar to `['flatMap', 3421, 42, 1, []]` to save storage space + * and reduce parse and write time of a big JSON blob. + * + * The HasteMap is created as follows: + * 1. read data from the cache or create an empty structure. + * + * 2. crawl the file system. + * * empty cache: crawl the entire file system. + * * cache available: + * * if watchman is available: get file system delta changes. + * * if watchman is unavailable: crawl the entire file system. + * * build metadata objects for every file. This builds the `files` part of + * the `HasteMap`. + * + * 3. parse and extract metadata from changed files. + * * this is done in parallel over worker processes to improve performance. + * * the worst case is to parse all files. + * * the best case is no file system access and retrieving all data from + * the cache. + * * the average case is a small number of changed files. + * + * 4. serialize the new `HasteMap` in a cache file. + * Worker processes can directly access the cache through `HasteMap.read()`. + * + */ +class HasteMap extends _events().EventEmitter { + _buildPromise = null; + _cachePath = ''; + _changeInterval; + _console; + _isWatchmanInstalledPromise = null; + _options; + _watchers = []; + _worker = null; + static getStatic(config) { + if (config.haste.hasteMapModulePath) { + return require(config.haste.hasteMapModulePath); + } + return HasteMap; + } + static async create(options) { + if (options.hasteMapModulePath) { + const CustomHasteMap = require(options.hasteMapModulePath); + return new CustomHasteMap(options); + } + const hasteMap = new HasteMap(options); + await hasteMap.setupCachePath(options); + return hasteMap; + } + constructor(options) { + super(); + this._options = { + cacheDirectory: options.cacheDirectory || (0, _os().tmpdir)(), + computeDependencies: options.computeDependencies ?? true, + computeSha1: options.computeSha1 || false, + dependencyExtractor: options.dependencyExtractor || null, + enableSymlinks: options.enableSymlinks || false, + extensions: options.extensions, + forceNodeFilesystemAPI: !!options.forceNodeFilesystemAPI, + hasteImplModulePath: options.hasteImplModulePath, + id: options.id, + maxWorkers: options.maxWorkers, + mocksPattern: options.mocksPattern + ? new RegExp(options.mocksPattern) + : null, + platforms: options.platforms, + resetCache: options.resetCache, + retainAllFiles: options.retainAllFiles, + rootDir: options.rootDir, + roots: Array.from(new Set(options.roots)), + skipPackageJson: !!options.skipPackageJson, + throwOnModuleCollision: !!options.throwOnModuleCollision, + useWatchman: options.useWatchman ?? true, + watch: !!options.watch, + workerThreads: options.workerThreads + }; + this._console = options.console || globalThis.console; + if (options.ignorePattern) { + if (options.ignorePattern instanceof RegExp) { + this._options.ignorePattern = new RegExp( + options.ignorePattern.source.concat(`|${VCS_DIRECTORIES}`), + options.ignorePattern.flags + ); + } else { + throw new Error( + 'jest-haste-map: the `ignorePattern` option must be a RegExp' + ); + } + } else { + this._options.ignorePattern = new RegExp(VCS_DIRECTORIES); + } + if (this._options.enableSymlinks && this._options.useWatchman) { + throw new Error( + 'jest-haste-map: enableSymlinks config option was set, but ' + + 'is incompatible with watchman.\n' + + 'Set either `enableSymlinks` to false or `useWatchman` to false.' + ); + } + } + async setupCachePath(options) { + const rootDirHash = (0, _crypto().createHash)('sha1') + .update(options.rootDir) + .digest('hex') + .substring(0, 32); + let hasteImplHash = ''; + let dependencyExtractorHash = ''; + if (options.hasteImplModulePath) { + const hasteImpl = require(options.hasteImplModulePath); + if (hasteImpl.getCacheKey) { + hasteImplHash = String(hasteImpl.getCacheKey()); + } + } + if (options.dependencyExtractor) { + const dependencyExtractor = await (0, _jestUtil().requireOrImportModule)( + options.dependencyExtractor, + false + ); + if (dependencyExtractor.getCacheKey) { + dependencyExtractorHash = String(dependencyExtractor.getCacheKey()); + } + } + this._cachePath = HasteMap.getCacheFilePath( + this._options.cacheDirectory, + `haste-map-${this._options.id}-${rootDirHash}`, + VERSION, + this._options.id, + this._options.roots + .map(root => fastPath.relative(options.rootDir, root)) + .join(':'), + this._options.extensions.join(':'), + this._options.platforms.join(':'), + this._options.computeSha1.toString(), + options.mocksPattern || '', + (options.ignorePattern || '').toString(), + hasteImplHash, + dependencyExtractorHash, + this._options.computeDependencies.toString() + ); + } + static getCacheFilePath(tmpdir, id, ...extra) { + const hash = (0, _crypto().createHash)('sha1').update(extra.join('')); + return path().join( + tmpdir, + `${id.replace(/\W/g, '-')}-${hash.digest('hex').substring(0, 32)}` + ); + } + static getModuleMapFromJSON(json) { + return _ModuleMap.default.fromJSON(json); + } + getCacheFilePath() { + return this._cachePath; + } + build() { + if (!this._buildPromise) { + this._buildPromise = (async () => { + const data = await this._buildFileMap(); + + // Persist when we don't know if files changed (changedFiles undefined) + // or when we know a file was changed or deleted. + let hasteMap; + if ( + data.changedFiles === undefined || + data.changedFiles.size > 0 || + data.removedFiles.size > 0 + ) { + hasteMap = await this._buildHasteMap(data); + this._persist(hasteMap); + } else { + hasteMap = data.hasteMap; + } + const rootDir = this._options.rootDir; + const hasteFS = new _HasteFS.default({ + files: hasteMap.files, + rootDir + }); + const moduleMap = new _ModuleMap.default({ + duplicates: hasteMap.duplicates, + map: hasteMap.map, + mocks: hasteMap.mocks, + rootDir + }); + const __hasteMapForTest = + (process.env.NODE_ENV === 'test' && hasteMap) || null; + await this._watch(hasteMap); + return { + __hasteMapForTest, + hasteFS, + moduleMap + }; + })(); + } + return this._buildPromise; + } + + /** + * 1. read data from the cache or create an empty structure. + */ + read() { + let hasteMap; + try { + hasteMap = (0, _v().deserialize)( + (0, _gracefulFs().readFileSync)(this._cachePath) + ); + } catch { + hasteMap = this._createEmptyMap(); + } + return hasteMap; + } + readModuleMap() { + const data = this.read(); + return new _ModuleMap.default({ + duplicates: data.duplicates, + map: data.map, + mocks: data.mocks, + rootDir: this._options.rootDir + }); + } + + /** + * 2. crawl the file system. + */ + async _buildFileMap() { + let hasteMap; + try { + const read = this._options.resetCache ? this._createEmptyMap : this.read; + hasteMap = read.call(this); + } catch { + hasteMap = this._createEmptyMap(); + } + return this._crawl(hasteMap); + } + + /** + * 3. parse and extract metadata from changed files. + */ + _processFile(hasteMap, map, mocks, filePath, workerOptions) { + const rootDir = this._options.rootDir; + const setModule = (id, module) => { + let moduleMap = map.get(id); + if (!moduleMap) { + moduleMap = Object.create(null); + map.set(id, moduleMap); + } + const platform = + (0, _getPlatformExtension.default)( + module[_constants.default.PATH], + this._options.platforms + ) || _constants.default.GENERIC_PLATFORM; + const existingModule = moduleMap[platform]; + if ( + existingModule && + existingModule[_constants.default.PATH] !== + module[_constants.default.PATH] + ) { + const method = this._options.throwOnModuleCollision ? 'error' : 'warn'; + this._console[method]( + [ + `jest-haste-map: Haste module naming collision: ${id}`, + ' The following files share their name; please adjust your hasteImpl:', + ` * ${path().sep}${ + existingModule[_constants.default.PATH] + }`, + ` * ${path().sep}${module[_constants.default.PATH]}`, + '' + ].join('\n') + ); + if (this._options.throwOnModuleCollision) { + throw new DuplicateError( + existingModule[_constants.default.PATH], + module[_constants.default.PATH] + ); + } + + // We do NOT want consumers to use a module that is ambiguous. + delete moduleMap[platform]; + if (Object.keys(moduleMap).length === 1) { + map.delete(id); + } + let dupsByPlatform = hasteMap.duplicates.get(id); + if (dupsByPlatform == null) { + dupsByPlatform = new Map(); + hasteMap.duplicates.set(id, dupsByPlatform); + } + const dups = new Map([ + [module[_constants.default.PATH], module[_constants.default.TYPE]], + [ + existingModule[_constants.default.PATH], + existingModule[_constants.default.TYPE] + ] + ]); + dupsByPlatform.set(platform, dups); + return; + } + const dupsByPlatform = hasteMap.duplicates.get(id); + if (dupsByPlatform != null) { + const dups = dupsByPlatform.get(platform); + if (dups != null) { + dups.set( + module[_constants.default.PATH], + module[_constants.default.TYPE] + ); + } + return; + } + moduleMap[platform] = module; + }; + const relativeFilePath = fastPath.relative(rootDir, filePath); + const fileMetadata = hasteMap.files.get(relativeFilePath); + if (!fileMetadata) { + throw new Error( + 'jest-haste-map: File to process was not found in the haste map.' + ); + } + const moduleMetadata = hasteMap.map.get( + fileMetadata[_constants.default.ID] + ); + const computeSha1 = + this._options.computeSha1 && !fileMetadata[_constants.default.SHA1]; + + // Callback called when the response from the worker is successful. + const workerReply = metadata => { + // `1` for truthy values instead of `true` to save cache space. + fileMetadata[_constants.default.VISITED] = 1; + const metadataId = metadata.id; + const metadataModule = metadata.module; + if (metadataId && metadataModule) { + fileMetadata[_constants.default.ID] = metadataId; + setModule(metadataId, metadataModule); + } + fileMetadata[_constants.default.DEPENDENCIES] = metadata.dependencies + ? metadata.dependencies.join(_constants.default.DEPENDENCY_DELIM) + : ''; + if (computeSha1) { + fileMetadata[_constants.default.SHA1] = metadata.sha1; + } + }; + + // Callback called when the response from the worker is an error. + const workerError = error => { + if (typeof error !== 'object' || !error.message || !error.stack) { + error = new Error(error); + error.stack = ''; // Remove stack for stack-less errors. + } + + if (!['ENOENT', 'EACCES'].includes(error.code)) { + throw error; + } + + // If a file cannot be read we remove it from the file list and + // ignore the failure silently. + hasteMap.files.delete(relativeFilePath); + }; + + // If we retain all files in the virtual HasteFS representation, we avoid + // reading them if they aren't important (node_modules). + if (this._options.retainAllFiles && filePath.includes(NODE_MODULES)) { + if (computeSha1) { + return this._getWorker(workerOptions) + .getSha1({ + computeDependencies: this._options.computeDependencies, + computeSha1, + dependencyExtractor: this._options.dependencyExtractor, + filePath, + hasteImplModulePath: this._options.hasteImplModulePath, + rootDir + }) + .then(workerReply, workerError); + } + return null; + } + if ( + this._options.mocksPattern && + this._options.mocksPattern.test(filePath) + ) { + const mockPath = (0, _getMockName.default)(filePath); + const existingMockPath = mocks.get(mockPath); + if (existingMockPath) { + const secondMockPath = fastPath.relative(rootDir, filePath); + if (existingMockPath !== secondMockPath) { + const method = this._options.throwOnModuleCollision + ? 'error' + : 'warn'; + this._console[method]( + [ + `jest-haste-map: duplicate manual mock found: ${mockPath}`, + ' The following files share their name; please delete one of them:', + ` * ${path().sep}${existingMockPath}`, + ` * ${path().sep}${secondMockPath}`, + '' + ].join('\n') + ); + if (this._options.throwOnModuleCollision) { + throw new DuplicateError(existingMockPath, secondMockPath); + } + } + } + mocks.set(mockPath, relativeFilePath); + } + if (fileMetadata[_constants.default.VISITED]) { + if (!fileMetadata[_constants.default.ID]) { + return null; + } + if (moduleMetadata != null) { + const platform = + (0, _getPlatformExtension.default)( + filePath, + this._options.platforms + ) || _constants.default.GENERIC_PLATFORM; + const module = moduleMetadata[platform]; + if (module == null) { + return null; + } + const moduleId = fileMetadata[_constants.default.ID]; + let modulesByPlatform = map.get(moduleId); + if (!modulesByPlatform) { + modulesByPlatform = Object.create(null); + map.set(moduleId, modulesByPlatform); + } + modulesByPlatform[platform] = module; + return null; + } + } + return this._getWorker(workerOptions) + .worker({ + computeDependencies: this._options.computeDependencies, + computeSha1, + dependencyExtractor: this._options.dependencyExtractor, + filePath, + hasteImplModulePath: this._options.hasteImplModulePath, + rootDir + }) + .then(workerReply, workerError); + } + _buildHasteMap(data) { + const {removedFiles, changedFiles, hasteMap} = data; + + // If any files were removed or we did not track what files changed, process + // every file looking for changes. Otherwise, process only changed files. + let map; + let mocks; + let filesToProcess; + if (changedFiles === undefined || removedFiles.size) { + map = new Map(); + mocks = new Map(); + filesToProcess = hasteMap.files; + } else { + map = hasteMap.map; + mocks = hasteMap.mocks; + filesToProcess = changedFiles; + } + for (const [relativeFilePath, fileMetadata] of removedFiles) { + this._recoverDuplicates( + hasteMap, + relativeFilePath, + fileMetadata[_constants.default.ID] + ); + } + const promises = []; + for (const relativeFilePath of filesToProcess.keys()) { + if ( + this._options.skipPackageJson && + relativeFilePath.endsWith(PACKAGE_JSON) + ) { + continue; + } + // SHA-1, if requested, should already be present thanks to the crawler. + const filePath = fastPath.resolve( + this._options.rootDir, + relativeFilePath + ); + const promise = this._processFile(hasteMap, map, mocks, filePath); + if (promise) { + promises.push(promise); + } + } + return Promise.all(promises).then( + () => { + this._cleanup(); + hasteMap.map = map; + hasteMap.mocks = mocks; + return hasteMap; + }, + error => { + this._cleanup(); + throw error; + } + ); + } + _cleanup() { + const worker = this._worker; + if (worker && 'end' in worker) { + worker.end(); + } + this._worker = null; + } + + /** + * 4. serialize the new `HasteMap` in a cache file. + */ + _persist(hasteMap) { + (0, _gracefulFs().writeFileSync)( + this._cachePath, + (0, _v().serialize)(hasteMap) + ); + } + + /** + * Creates workers or parses files and extracts metadata in-process. + */ + _getWorker( + options = { + forceInBand: false + } + ) { + if (!this._worker) { + if (options.forceInBand || this._options.maxWorkers <= 1) { + this._worker = { + getSha1: _worker.getSha1, + worker: _worker.worker + }; + } else { + this._worker = new (_jestWorker().Worker)(require.resolve('./worker'), { + enableWorkerThreads: this._options.workerThreads, + exposedMethods: ['getSha1', 'worker'], + forkOptions: { + serialization: 'json' + }, + maxRetries: 3, + numWorkers: this._options.maxWorkers + }); + } + } + return this._worker; + } + async _crawl(hasteMap) { + const options = this._options; + const ignore = this._ignore.bind(this); + const crawl = (await this._shouldUseWatchman()) + ? _watchman.watchmanCrawl + : _node.nodeCrawl; + const crawlerOptions = { + computeSha1: options.computeSha1, + data: hasteMap, + enableSymlinks: options.enableSymlinks, + extensions: options.extensions, + forceNodeFilesystemAPI: options.forceNodeFilesystemAPI, + ignore, + rootDir: options.rootDir, + roots: options.roots + }; + const retry = error => { + if (crawl === _watchman.watchmanCrawl) { + this._console.warn( + 'jest-haste-map: Watchman crawl failed. Retrying once with node ' + + 'crawler.\n' + + " Usually this happens when watchman isn't running. Create an " + + "empty `.watchmanconfig` file in your project's root folder or " + + 'initialize a git or hg repository in your project.\n' + + ` ${error}` + ); + return (0, _node.nodeCrawl)(crawlerOptions).catch(e => { + throw new Error( + 'Crawler retry failed:\n' + + ` Original error: ${error.message}\n` + + ` Retry error: ${e.message}\n` + ); + }); + } + throw error; + }; + try { + return await crawl(crawlerOptions); + } catch (error) { + return retry(error); + } + } + + /** + * Watch mode + */ + async _watch(hasteMap) { + if (!this._options.watch) { + return Promise.resolve(); + } + + // In watch mode, we'll only warn about module collisions and we'll retain + // all files, even changes to node_modules. + this._options.throwOnModuleCollision = false; + this._options.retainAllFiles = true; + + // WatchmanWatcher > FSEventsWatcher > sane.NodeWatcher + const Watcher = (await this._shouldUseWatchman()) + ? _WatchmanWatcher.default + : _FSEventsWatcher.FSEventsWatcher.isSupported() + ? _FSEventsWatcher.FSEventsWatcher + : _NodeWatcher.default; + const extensions = this._options.extensions; + const ignorePattern = this._options.ignorePattern; + const rootDir = this._options.rootDir; + let changeQueue = Promise.resolve(); + let eventsQueue = []; + // We only need to copy the entire haste map once on every "frame". + let mustCopy = true; + const createWatcher = root => { + const watcher = new Watcher(root, { + dot: true, + glob: extensions.map(extension => `**/*.${extension}`), + ignored: ignorePattern + }); + return new Promise((resolve, reject) => { + const rejectTimeout = setTimeout( + () => reject(new Error('Failed to start watch mode.')), + MAX_WAIT_TIME + ); + watcher.once('ready', () => { + clearTimeout(rejectTimeout); + watcher.on('all', onChange); + resolve(watcher); + }); + }); + }; + const emitChange = () => { + if (eventsQueue.length) { + mustCopy = true; + const changeEvent = { + eventsQueue, + hasteFS: new _HasteFS.default({ + files: hasteMap.files, + rootDir + }), + moduleMap: new _ModuleMap.default({ + duplicates: hasteMap.duplicates, + map: hasteMap.map, + mocks: hasteMap.mocks, + rootDir + }) + }; + this.emit('change', changeEvent); + eventsQueue = []; + } + }; + const onChange = (type, filePath, root, stat) => { + filePath = path().join(root, (0, _normalizePathSep.default)(filePath)); + if ( + (stat && stat.isDirectory()) || + this._ignore(filePath) || + !extensions.some(extension => filePath.endsWith(extension)) + ) { + return; + } + const relativeFilePath = fastPath.relative(rootDir, filePath); + const fileMetadata = hasteMap.files.get(relativeFilePath); + + // The file has been accessed, not modified + if ( + type === 'change' && + fileMetadata && + stat && + fileMetadata[_constants.default.MTIME] === stat.mtime.getTime() + ) { + return; + } + changeQueue = changeQueue + .then(() => { + // If we get duplicate events for the same file, ignore them. + if ( + eventsQueue.find( + event => + event.type === type && + event.filePath === filePath && + ((!event.stat && !stat) || + (!!event.stat && + !!stat && + event.stat.mtime.getTime() === stat.mtime.getTime())) + ) + ) { + return null; + } + if (mustCopy) { + mustCopy = false; + hasteMap = { + clocks: new Map(hasteMap.clocks), + duplicates: new Map(hasteMap.duplicates), + files: new Map(hasteMap.files), + map: new Map(hasteMap.map), + mocks: new Map(hasteMap.mocks) + }; + } + const add = () => { + eventsQueue.push({ + filePath, + stat, + type + }); + return null; + }; + const fileMetadata = hasteMap.files.get(relativeFilePath); + + // If it's not an addition, delete the file and all its metadata + if (fileMetadata != null) { + const moduleName = fileMetadata[_constants.default.ID]; + const platform = + (0, _getPlatformExtension.default)( + filePath, + this._options.platforms + ) || _constants.default.GENERIC_PLATFORM; + hasteMap.files.delete(relativeFilePath); + let moduleMap = hasteMap.map.get(moduleName); + if (moduleMap != null) { + // We are forced to copy the object because jest-haste-map exposes + // the map as an immutable entity. + moduleMap = copy(moduleMap); + delete moduleMap[platform]; + if (Object.keys(moduleMap).length === 0) { + hasteMap.map.delete(moduleName); + } else { + hasteMap.map.set(moduleName, moduleMap); + } + } + if ( + this._options.mocksPattern && + this._options.mocksPattern.test(filePath) + ) { + const mockName = (0, _getMockName.default)(filePath); + hasteMap.mocks.delete(mockName); + } + this._recoverDuplicates(hasteMap, relativeFilePath, moduleName); + } + + // If the file was added or changed, + // parse it and update the haste map. + if (type === 'add' || type === 'change') { + (0, _jestUtil().invariant)( + stat, + 'since the file exists or changed, it should have stats' + ); + const fileMetadata = [ + '', + stat.mtime.getTime(), + stat.size, + 0, + '', + null + ]; + hasteMap.files.set(relativeFilePath, fileMetadata); + const promise = this._processFile( + hasteMap, + hasteMap.map, + hasteMap.mocks, + filePath, + { + forceInBand: true + } + ); + // Cleanup + this._cleanup(); + if (promise) { + return promise.then(add); + } else { + // If a file in node_modules has changed, + // emit an event regardless. + add(); + } + } else { + add(); + } + return null; + }) + .catch(error => { + this._console.error( + `jest-haste-map: watch error:\n ${error.stack}\n` + ); + }); + }; + this._changeInterval = setInterval(emitChange, CHANGE_INTERVAL); + return Promise.all(this._options.roots.map(createWatcher)).then( + watchers => { + this._watchers = watchers; + } + ); + } + + /** + * This function should be called when the file under `filePath` is removed + * or changed. When that happens, we want to figure out if that file was + * part of a group of files that had the same ID. If it was, we want to + * remove it from the group. Furthermore, if there is only one file + * remaining in the group, then we want to restore that single file as the + * correct resolution for its ID, and cleanup the duplicates index. + */ + _recoverDuplicates(hasteMap, relativeFilePath, moduleName) { + let dupsByPlatform = hasteMap.duplicates.get(moduleName); + if (dupsByPlatform == null) { + return; + } + const platform = + (0, _getPlatformExtension.default)( + relativeFilePath, + this._options.platforms + ) || _constants.default.GENERIC_PLATFORM; + let dups = dupsByPlatform.get(platform); + if (dups == null) { + return; + } + dupsByPlatform = copyMap(dupsByPlatform); + hasteMap.duplicates.set(moduleName, dupsByPlatform); + dups = copyMap(dups); + dupsByPlatform.set(platform, dups); + dups.delete(relativeFilePath); + if (dups.size !== 1) { + return; + } + const uniqueModule = dups.entries().next().value; + if (!uniqueModule) { + return; + } + let dedupMap = hasteMap.map.get(moduleName); + if (!dedupMap) { + dedupMap = Object.create(null); + hasteMap.map.set(moduleName, dedupMap); + } + dedupMap[platform] = uniqueModule; + dupsByPlatform.delete(platform); + if (dupsByPlatform.size === 0) { + hasteMap.duplicates.delete(moduleName); + } + } + async end() { + if (this._changeInterval) { + clearInterval(this._changeInterval); + } + if (!this._watchers.length) { + return; + } + await Promise.all(this._watchers.map(watcher => watcher.close())); + this._watchers = []; + } + + /** + * Helpers + */ + _ignore(filePath) { + const ignorePattern = this._options.ignorePattern; + const ignoreMatched = + ignorePattern instanceof RegExp + ? ignorePattern.test(filePath) + : ignorePattern && ignorePattern(filePath); + return ( + ignoreMatched || + (!this._options.retainAllFiles && filePath.includes(NODE_MODULES)) + ); + } + async _shouldUseWatchman() { + if (!this._options.useWatchman) { + return false; + } + if (!this._isWatchmanInstalledPromise) { + this._isWatchmanInstalledPromise = (0, _isWatchmanInstalled.default)(); + } + return this._isWatchmanInstalledPromise; + } + _createEmptyMap() { + return { + clocks: new Map(), + duplicates: new Map(), + files: new Map(), + map: new Map(), + mocks: new Map() + }; + } + static H = _constants.default; +} +class DuplicateError extends Error { + mockPath1; + mockPath2; + constructor(mockPath1, mockPath2) { + super('Duplicated files or mocks. Please check the console for more info'); + this.mockPath1 = mockPath1; + this.mockPath2 = mockPath2; + } +} +exports.DuplicateError = DuplicateError; +function copy(object) { + return Object.assign(Object.create(null), object); +} +function copyMap(input) { + return new Map(input); +} + +// Export the smallest API surface required by Jest + +const JestHasteMap = HasteMap; +var _default = JestHasteMap; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/lib/dependencyExtractor.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/lib/dependencyExtractor.js new file mode 100644 index 0000000000000000000000000000000000000000..9a2a14f8525fd8f92975e1cddf189f77440cb06a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/lib/dependencyExtractor.js @@ -0,0 +1,84 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.extractor = void 0; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const NOT_A_DOT = '(? `([\`'"])([^'"\`]*?)(?:\\${pos})`; +const WORD_SEPARATOR = '\\b'; +const LEFT_PARENTHESIS = '\\('; +const RIGHT_PARENTHESIS = '\\)'; +const WHITESPACE = '\\s*'; +const OPTIONAL_COMMA = '(:?,\\s*)?'; +function createRegExp(parts, flags) { + return new RegExp(parts.join(''), flags); +} +function alternatives(...parts) { + return `(?:${parts.join('|')})`; +} +function functionCallStart(...names) { + return [ + NOT_A_DOT, + WORD_SEPARATOR, + alternatives(...names), + WHITESPACE, + LEFT_PARENTHESIS, + WHITESPACE + ]; +} +const BLOCK_COMMENT_RE = /\/\*[^]*?\*\//g; +const LINE_COMMENT_RE = /\/\/.*/g; +const REQUIRE_OR_DYNAMIC_IMPORT_RE = createRegExp( + [ + ...functionCallStart('require', 'import'), + CAPTURE_STRING_LITERAL(1), + WHITESPACE, + OPTIONAL_COMMA, + RIGHT_PARENTHESIS + ], + 'g' +); +const IMPORT_OR_EXPORT_RE = createRegExp( + [ + '\\b(?:import|export)\\s+(?!type(?:of)?\\s+)(?:[^\'"]+\\s+from\\s+)?', + CAPTURE_STRING_LITERAL(1) + ], + 'g' +); +const JEST_EXTENSIONS_RE = createRegExp( + [ + ...functionCallStart( + 'jest\\s*\\.\\s*(?:requireActual|requireMock|genMockFromModule|createMockFromModule)' + ), + CAPTURE_STRING_LITERAL(1), + WHITESPACE, + OPTIONAL_COMMA, + RIGHT_PARENTHESIS + ], + 'g' +); +const extractor = { + extract(code) { + const dependencies = new Set(); + const addDependency = (match, _, dep) => { + dependencies.add(dep); + return match; + }; + code + .replace(BLOCK_COMMENT_RE, '') + .replace(LINE_COMMENT_RE, '') + .replace(IMPORT_OR_EXPORT_RE, addDependency) + .replace(REQUIRE_OR_DYNAMIC_IMPORT_RE, addDependency) + .replace(JEST_EXTENSIONS_RE, addDependency); + return dependencies; + } +}; +exports.extractor = extractor; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/lib/fast_path.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/lib/fast_path.js new file mode 100644 index 0000000000000000000000000000000000000000..f82787ccb387f40d71dbcc00f1931481fb961294 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/lib/fast_path.js @@ -0,0 +1,76 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.relative = relative; +exports.resolve = resolve; +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// rootDir and filename must be absolute paths (resolved) +function relative(rootDir, filename) { + return filename.indexOf(rootDir + path().sep) === 0 + ? filename.substring(rootDir.length + 1) + : path().relative(rootDir, filename); +} +const INDIRECTION_FRAGMENT = `..${path().sep}`; + +// rootDir must be an absolute path and relativeFilename must be simple +// (e.g.: foo/bar or ../foo/bar, but never ./foo or foo/../bar) +function resolve(rootDir, relativeFilename) { + return relativeFilename.indexOf(INDIRECTION_FRAGMENT) === 0 + ? path().resolve(rootDir, relativeFilename) + : rootDir + path().sep + relativeFilename; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/lib/getPlatformExtension.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/lib/getPlatformExtension.js new file mode 100644 index 0000000000000000000000000000000000000000..2e1d2045e9a75313216b97f1d251d4d6ad075d70 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/lib/getPlatformExtension.js @@ -0,0 +1,30 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getPlatformExtension; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const SUPPORTED_PLATFORM_EXTS = new Set(['android', 'ios', 'native', 'web']); + +// Extract platform extension: index.ios.js -> ios +function getPlatformExtension(file, platforms) { + const last = file.lastIndexOf('.'); + const secondToLast = file.lastIndexOf('.', last - 1); + if (secondToLast === -1) { + return null; + } + const platform = file.substring(secondToLast + 1, last); + // If an overriding platform array is passed, check that first + + if (platforms && platforms.indexOf(platform) !== -1) { + return platform; + } + return SUPPORTED_PLATFORM_EXTS.has(platform) ? platform : null; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/lib/isWatchmanInstalled.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/lib/isWatchmanInstalled.js new file mode 100644 index 0000000000000000000000000000000000000000..b04abb24e117f96eb98c4be5e11f7836d2e49cf6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/lib/isWatchmanInstalled.js @@ -0,0 +1,37 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = isWatchmanInstalled; +function _child_process() { + const data = require('child_process'); + _child_process = function () { + return data; + }; + return data; +} +function _util() { + const data = require('util'); + _util = function () { + return data; + }; + return data; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +async function isWatchmanInstalled() { + try { + await (0, _util().promisify)(_child_process().execFile)('watchman', [ + '--version' + ]); + return true; + } catch { + return false; + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/lib/normalizePathSep.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/lib/normalizePathSep.js new file mode 100644 index 0000000000000000000000000000000000000000..ad8cd1fe42f1074edb7d64774301d1c025817b9c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/lib/normalizePathSep.js @@ -0,0 +1,68 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +let normalizePathSep; +if (path().sep === '/') { + normalizePathSep = filePath => filePath; +} else { + normalizePathSep = filePath => filePath.replace(/\//g, path().sep); +} +var _default = normalizePathSep; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/types.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/types.js new file mode 100644 index 0000000000000000000000000000000000000000..ad9a93a7c160f02945911772460eb8a1bcb003db --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/types.js @@ -0,0 +1 @@ +'use strict'; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/watchers/FSEventsWatcher.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/watchers/FSEventsWatcher.js new file mode 100644 index 0000000000000000000000000000000000000000..a8b59d7f382b290ed9e09593c439c17137d8fb3e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/watchers/FSEventsWatcher.js @@ -0,0 +1,244 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.FSEventsWatcher = void 0; +function _events() { + const data = require('events'); + _events = function () { + return data; + }; + return data; +} +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _anymatch() { + const data = _interopRequireDefault(require('anymatch')); + _anymatch = function () { + return data; + }; + return data; +} +function fs() { + const data = _interopRequireWildcard(require('graceful-fs')); + fs = function () { + return data; + }; + return data; +} +function _micromatch() { + const data = _interopRequireDefault(require('micromatch')); + _micromatch = function () { + return data; + }; + return data; +} +function _walker() { + const data = _interopRequireDefault(require('walker')); + _walker = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + */ + +// @ts-expect-error no types + +// eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error, @typescript-eslint/ban-ts-comment +// @ts-ignore: this is for CI which runs linux and might not have this +let fsevents = null; +try { + fsevents = require('fsevents'); +} catch { + // Optional dependency, only supported on Darwin. +} +const CHANGE_EVENT = 'change'; +const DELETE_EVENT = 'delete'; +const ADD_EVENT = 'add'; +const ALL_EVENT = 'all'; +/** + * Export `FSEventsWatcher` class. + * Watches `dir`. + */ +class FSEventsWatcher extends _events().EventEmitter { + root; + ignored; + glob; + dot; + hasIgnore; + doIgnore; + fsEventsWatchStopper; + _tracked; + static isSupported() { + return fsevents !== null; + } + static normalizeProxy(callback) { + return (filepath, stats) => callback(path().normalize(filepath), stats); + } + static recReaddir( + dir, + dirCallback, + fileCallback, + endCallback, + errorCallback, + ignored + ) { + (0, _walker().default)(dir) + .filterDir( + currentDir => !ignored || !(0, _anymatch().default)(ignored, currentDir) + ) + .on('dir', FSEventsWatcher.normalizeProxy(dirCallback)) + .on('file', FSEventsWatcher.normalizeProxy(fileCallback)) + .on('error', errorCallback) + .on('end', () => { + endCallback(); + }); + } + constructor(dir, opts) { + if (!fsevents) { + throw new Error( + '`fsevents` unavailable (this watcher can only be used on Darwin)' + ); + } + super(); + this.dot = opts.dot || false; + this.ignored = opts.ignored; + this.glob = Array.isArray(opts.glob) ? opts.glob : [opts.glob]; + this.hasIgnore = + Boolean(opts.ignored) && !(Array.isArray(opts) && opts.length > 0); + this.doIgnore = opts.ignored + ? (0, _anymatch().default)(opts.ignored) + : () => false; + this.root = path().resolve(dir); + this.fsEventsWatchStopper = fsevents.watch( + this.root, + this.handleEvent.bind(this) + ); + this._tracked = new Set(); + FSEventsWatcher.recReaddir( + this.root, + filepath => { + this._tracked.add(filepath); + }, + filepath => { + this._tracked.add(filepath); + }, + this.emit.bind(this, 'ready'), + this.emit.bind(this, 'error'), + this.ignored + ); + } + + /** + * End watching. + */ + async close(callback) { + await this.fsEventsWatchStopper(); + this.removeAllListeners(); + if (typeof callback === 'function') { + process.nextTick(() => callback()); + } + } + isFileIncluded(relativePath) { + if (this.doIgnore(relativePath)) { + return false; + } + return this.glob.length + ? (0, _micromatch().default)([relativePath], this.glob, { + dot: this.dot + }).length > 0 + : this.dot || + (0, _micromatch().default)([relativePath], '**/*').length > 0; + } + handleEvent(filepath) { + const relativePath = path().relative(this.root, filepath); + if (!this.isFileIncluded(relativePath)) { + return; + } + fs().lstat(filepath, (error, stat) => { + if (error && error.code !== 'ENOENT') { + this.emit('error', error); + return; + } + if (error) { + // Ignore files that aren't tracked and don't exist. + if (!this._tracked.has(filepath)) { + return; + } + this._emit(DELETE_EVENT, relativePath); + this._tracked.delete(filepath); + return; + } + if (this._tracked.has(filepath)) { + this._emit(CHANGE_EVENT, relativePath, stat); + } else { + this._tracked.add(filepath); + this._emit(ADD_EVENT, relativePath, stat); + } + }); + } + + /** + * Emit events. + */ + _emit(type, file, stat) { + this.emit(type, file, this.root, stat); + this.emit(ALL_EVENT, type, file, this.root, stat); + } +} +exports.FSEventsWatcher = FSEventsWatcher; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/watchers/NodeWatcher.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/watchers/NodeWatcher.js new file mode 100644 index 0000000000000000000000000000000000000000..62cface561db0cc60322174036216ef867cd86da --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/watchers/NodeWatcher.js @@ -0,0 +1,369 @@ +// vendored from https://github.com/amasad/sane/blob/64ff3a870c42e84f744086884bf55a4f9c22d376/src/node_watcher.js + +'use strict'; + +const EventEmitter = require('events').EventEmitter; +const fs = require('fs'); +const platform = require('os').platform(); +const path = require('path'); +const common = require('./common'); + +/** + * Constants + */ + +const DEFAULT_DELAY = common.DEFAULT_DELAY; +const CHANGE_EVENT = common.CHANGE_EVENT; +const DELETE_EVENT = common.DELETE_EVENT; +const ADD_EVENT = common.ADD_EVENT; +const ALL_EVENT = common.ALL_EVENT; + +/** + * Export `NodeWatcher` class. + * Watches `dir`. + * + * @class NodeWatcher + * @param {String} dir + * @param {Object} opts + * @public + */ + +module.exports = class NodeWatcher extends EventEmitter { + constructor(dir, opts) { + super(); + common.assignOptions(this, opts); + this.watched = Object.create(null); + this.changeTimers = Object.create(null); + this.dirRegistery = Object.create(null); + this.root = path.resolve(dir); + this.watchdir = this.watchdir.bind(this); + this.register = this.register.bind(this); + this.checkedEmitError = this.checkedEmitError.bind(this); + this.watchdir(this.root); + common.recReaddir( + this.root, + this.watchdir, + this.register, + this.emit.bind(this, 'ready'), + this.checkedEmitError, + this.ignored + ); + } + + /** + * Register files that matches our globs to know what to type of event to + * emit in the future. + * + * Registery looks like the following: + * + * dirRegister => Map { + * dirpath => Map { + * filename => true + * } + * } + * + * @param {string} filepath + * @return {boolean} whether or not we have registered the file. + * @private + */ + + register(filepath) { + const relativePath = path.relative(this.root, filepath); + if ( + !common.isFileIncluded(this.globs, this.dot, this.doIgnore, relativePath) + ) { + return false; + } + const dir = path.dirname(filepath); + if (!this.dirRegistery[dir]) { + this.dirRegistery[dir] = Object.create(null); + } + const filename = path.basename(filepath); + this.dirRegistery[dir][filename] = true; + return true; + } + + /** + * Removes a file from the registery. + * + * @param {string} filepath + * @private + */ + + unregister(filepath) { + const dir = path.dirname(filepath); + if (this.dirRegistery[dir]) { + const filename = path.basename(filepath); + delete this.dirRegistery[dir][filename]; + } + } + + /** + * Removes a dir from the registery. + * + * @param {string} dirpath + * @private + */ + + unregisterDir(dirpath) { + if (this.dirRegistery[dirpath]) { + delete this.dirRegistery[dirpath]; + } + } + + /** + * Checks if a file or directory exists in the registery. + * + * @param {string} fullpath + * @return {boolean} + * @private + */ + + registered(fullpath) { + const dir = path.dirname(fullpath); + return ( + this.dirRegistery[fullpath] || + (this.dirRegistery[dir] && + this.dirRegistery[dir][path.basename(fullpath)]) + ); + } + + /** + * Emit "error" event if it's not an ignorable event + * + * @param error + * @private + */ + checkedEmitError(error) { + if (!isIgnorableFileError(error)) { + this.emit('error', error); + } + } + + /** + * Watch a directory. + * + * @param {string} dir + * @private + */ + + watchdir(dir) { + if (this.watched[dir]) { + return; + } + const watcher = fs.watch( + dir, + { + persistent: true + }, + this.normalizeChange.bind(this, dir) + ); + this.watched[dir] = watcher; + watcher.on('error', this.checkedEmitError); + if (this.root !== dir) { + this.register(dir); + } + } + + /** + * Stop watching a directory. + * + * @param {string} dir + * @private + */ + + stopWatching(dir) { + if (this.watched[dir]) { + this.watched[dir].close(); + delete this.watched[dir]; + } + } + + /** + * End watching. + * + * @public + */ + + close() { + Object.keys(this.watched).forEach(this.stopWatching, this); + this.removeAllListeners(); + return Promise.resolve(); + } + + /** + * On some platforms, as pointed out on the fs docs (most likely just win32) + * the file argument might be missing from the fs event. Try to detect what + * change by detecting if something was deleted or the most recent file change. + * + * @param {string} dir + * @param {string} event + * @param {string} file + * @public + */ + + detectChangedFile(dir, event, callback) { + if (!this.dirRegistery[dir]) { + return; + } + let found = false; + let closest = { + mtime: 0 + }; + let c = 0; + Object.keys(this.dirRegistery[dir]).forEach(function (file, i, arr) { + fs.lstat(path.join(dir, file), (error, stat) => { + if (found) { + return; + } + if (error) { + if (isIgnorableFileError(error)) { + found = true; + callback(file); + } else { + this.emit('error', error); + } + } else { + if (stat.mtime > closest.mtime) { + stat.file = file; + closest = stat; + } + if (arr.length === ++c) { + callback(closest.file); + } + } + }); + }, this); + } + + /** + * Normalize fs events and pass it on to be processed. + * + * @param {string} dir + * @param {string} event + * @param {string} file + * @public + */ + + normalizeChange(dir, event, file) { + if (!file) { + this.detectChangedFile(dir, event, actualFile => { + if (actualFile) { + this.processChange(dir, event, actualFile); + } + }); + } else { + this.processChange(dir, event, path.normalize(file)); + } + } + + /** + * Process changes. + * + * @param {string} dir + * @param {string} event + * @param {string} file + * @public + */ + + processChange(dir, event, file) { + const fullPath = path.join(dir, file); + const relativePath = path.join(path.relative(this.root, dir), file); + fs.lstat(fullPath, (error, stat) => { + if (error && error.code !== 'ENOENT') { + this.emit('error', error); + } else if (!error && stat.isDirectory()) { + // win32 emits usless change events on dirs. + if (event !== 'change') { + this.watchdir(fullPath); + if ( + common.isFileIncluded( + this.globs, + this.dot, + this.doIgnore, + relativePath + ) + ) { + this.emitEvent(ADD_EVENT, relativePath, stat); + } + } + } else { + const registered = this.registered(fullPath); + if (error && error.code === 'ENOENT') { + this.unregister(fullPath); + this.stopWatching(fullPath); + this.unregisterDir(fullPath); + if (registered) { + this.emitEvent(DELETE_EVENT, relativePath); + } + } else if (registered) { + this.emitEvent(CHANGE_EVENT, relativePath, stat); + } else { + if (this.register(fullPath)) { + this.emitEvent(ADD_EVENT, relativePath, stat); + } + } + } + }); + } + + /** + * Triggers a 'change' event after debounding it to take care of duplicate + * events on os x. + * + * @private + */ + + emitEvent(type, file, stat) { + const key = `${type}-${file}`; + const addKey = `${ADD_EVENT}-${file}`; + if (type === CHANGE_EVENT && this.changeTimers[addKey]) { + // Ignore the change event that is immediately fired after an add event. + // (This happens on Linux). + return; + } + clearTimeout(this.changeTimers[key]); + this.changeTimers[key] = setTimeout(() => { + delete this.changeTimers[key]; + if (type === ADD_EVENT && stat.isDirectory()) { + // Recursively emit add events and watch for sub-files/folders + common.recReaddir( + path.resolve(this.root, file), + function emitAddDir(dir, stats) { + this.watchdir(dir); + this.rawEmitEvent(ADD_EVENT, path.relative(this.root, dir), stats); + }.bind(this), + function emitAddFile(file, stats) { + this.register(file); + this.rawEmitEvent(ADD_EVENT, path.relative(this.root, file), stats); + }.bind(this), + function endCallback() {}, + this.checkedEmitError, + this.ignored + ); + } else { + this.rawEmitEvent(type, file, stat); + } + }, DEFAULT_DELAY); + } + + /** + * Actually emit the events + */ + rawEmitEvent(type, file, stat) { + this.emit(type, file, this.root, stat); + this.emit(ALL_EVENT, type, file, this.root, stat); + } +}; +/** + * Determine if a given FS error can be ignored + * + * @private + */ +function isIgnorableFileError(error) { + return ( + error.code === 'ENOENT' || + // Workaround Windows node issue #4337. + (error.code === 'EPERM' && platform === 'win32') + ); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/watchers/RecrawlWarning.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/watchers/RecrawlWarning.js new file mode 100644 index 0000000000000000000000000000000000000000..5b1b6d3528dbce198dc624289ec893fd4ccf5607 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/watchers/RecrawlWarning.js @@ -0,0 +1,49 @@ +// vendored from https://github.com/amasad/sane/blob/64ff3a870c42e84f744086884bf55a4f9c22d376/src/utils/recrawl-warning-dedupe.js + +'use strict'; + +class RecrawlWarning { + constructor(root, count) { + this.root = root; + this.count = count; + } + static findByRoot(root) { + for (let i = 0; i < this.RECRAWL_WARNINGS.length; i++) { + const warning = this.RECRAWL_WARNINGS[i]; + if (warning.root === root) { + return warning; + } + } + return undefined; + } + static isRecrawlWarningDupe(warningMessage) { + if (typeof warningMessage !== 'string') { + return false; + } + const match = warningMessage.match(this.REGEXP); + if (!match) { + return false; + } + const count = Number(match[1]); + const root = match[2]; + const warning = this.findByRoot(root); + if (warning) { + // only keep the highest count, assume count to either stay the same or + // increase. + if (warning.count >= count) { + return true; + } else { + // update the existing warning to the latest (highest) count + warning.count = count; + return false; + } + } else { + this.RECRAWL_WARNINGS.push(new RecrawlWarning(root, count)); + return false; + } + } +} +RecrawlWarning.RECRAWL_WARNINGS = []; +RecrawlWarning.REGEXP = + /Recrawled this watch (\d+) times, most recently because:\n([^:]+)/; +module.exports = RecrawlWarning; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/watchers/WatchmanWatcher.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/watchers/WatchmanWatcher.js new file mode 100644 index 0000000000000000000000000000000000000000..7b341687fb8c17d09cfc2bc9ed9901cce388b796 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/watchers/WatchmanWatcher.js @@ -0,0 +1,383 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = WatchmanWatcher; +function _assert() { + const data = require('assert'); + _assert = function () { + return data; + }; + return data; +} +function _events() { + const data = require('events'); + _events = function () { + return data; + }; + return data; +} +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _fbWatchman() { + const data = _interopRequireDefault(require('fb-watchman')); + _fbWatchman = function () { + return data; + }; + return data; +} +function _gracefulFs() { + const data = _interopRequireDefault(require('graceful-fs')); + _gracefulFs = function () { + return data; + }; + return data; +} +var _RecrawlWarning = _interopRequireDefault(require('./RecrawlWarning')); +var _common = _interopRequireDefault(require('./common')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const CHANGE_EVENT = _common.default.CHANGE_EVENT; +const DELETE_EVENT = _common.default.DELETE_EVENT; +const ADD_EVENT = _common.default.ADD_EVENT; +const ALL_EVENT = _common.default.ALL_EVENT; +const SUB_NAME = 'sane-sub'; + +/** + * Watches `dir`. + * + * @class PollWatcher + * @param String dir + * @param {Object} opts + * @public + */ + +function WatchmanWatcher(dir, opts) { + _common.default.assignOptions(this, opts); + this.root = path().resolve(dir); + this.init(); +} +Object.setPrototypeOf( + WatchmanWatcher.prototype, + _events().EventEmitter.prototype +); + +/** + * Run the watchman `watch` command on the root and subscribe to changes. + * + * @private + */ + +WatchmanWatcher.prototype.init = function () { + if (this.client) { + this.client.removeAllListeners(); + } + const self = this; + this.client = new (_fbWatchman().default.Client)(); + this.client.on('error', error => { + self.emit('error', error); + }); + this.client.on('subscription', this.handleChangeEvent.bind(this)); + this.client.on('end', () => { + console.warn('[sane] Warning: Lost connection to watchman, reconnecting..'); + self.init(); + }); + this.watchProjectInfo = null; + function getWatchRoot() { + return self.watchProjectInfo ? self.watchProjectInfo.root : self.root; + } + function onCapability(error, resp) { + if (handleError(self, error)) { + // The Watchman watcher is unusable on this system, we cannot continue + return; + } + handleWarning(resp); + self.capabilities = resp.capabilities; + if (self.capabilities.relative_root) { + self.client.command(['watch-project', getWatchRoot()], onWatchProject); + } else { + self.client.command(['watch', getWatchRoot()], onWatch); + } + } + function onWatchProject(error, resp) { + if (handleError(self, error)) { + return; + } + handleWarning(resp); + self.watchProjectInfo = { + relativePath: resp.relative_path ? resp.relative_path : '', + root: resp.watch + }; + self.client.command(['clock', getWatchRoot()], onClock); + } + function onWatch(error, resp) { + if (handleError(self, error)) { + return; + } + handleWarning(resp); + self.client.command(['clock', getWatchRoot()], onClock); + } + function onClock(error, resp) { + if (handleError(self, error)) { + return; + } + handleWarning(resp); + const options = { + fields: ['name', 'exists', 'new'], + since: resp.clock + }; + + // If the server has the wildmatch capability available it supports + // the recursive **/*.foo style match and we can offload our globs + // to the watchman server. This saves both on data size to be + // communicated back to us and compute for evaluating the globs + // in our node process. + if (self.capabilities.wildmatch) { + if (self.globs.length === 0) { + if (!self.dot) { + // Make sure we honor the dot option if even we're not using globs. + options.expression = [ + 'match', + '**', + 'wholename', + { + includedotfiles: false + } + ]; + } + } else { + options.expression = ['anyof']; + for (const i in self.globs) { + options.expression.push([ + 'match', + self.globs[i], + 'wholename', + { + includedotfiles: self.dot + } + ]); + } + } + } + if (self.capabilities.relative_root) { + options.relative_root = self.watchProjectInfo.relativePath; + } + self.client.command( + ['subscribe', getWatchRoot(), SUB_NAME, options], + onSubscribe + ); + } + function onSubscribe(error, resp) { + if (handleError(self, error)) { + return; + } + handleWarning(resp); + self.emit('ready'); + } + self.client.capabilityCheck( + { + optional: ['wildmatch', 'relative_root'] + }, + onCapability + ); +}; + +/** + * Handles a change event coming from the subscription. + * + * @param {Object} resp + * @private + */ + +WatchmanWatcher.prototype.handleChangeEvent = function (resp) { + _assert().strict.equal( + resp.subscription, + SUB_NAME, + 'Invalid subscription event.' + ); + if (resp.is_fresh_instance) { + this.emit('fresh_instance'); + } + if (resp.is_fresh_instance) { + this.emit('fresh_instance'); + } + if (Array.isArray(resp.files)) { + resp.files.forEach(this.handleFileChange, this); + } +}; + +/** + * Handles a single change event record. + * + * @param {Object} changeDescriptor + * @private + */ + +WatchmanWatcher.prototype.handleFileChange = function (changeDescriptor) { + const self = this; + let absPath; + let relativePath; + if (this.capabilities.relative_root) { + relativePath = changeDescriptor.name; + absPath = path().join( + this.watchProjectInfo.root, + this.watchProjectInfo.relativePath, + relativePath + ); + } else { + absPath = path().join(this.root, changeDescriptor.name); + relativePath = changeDescriptor.name; + } + if ( + !(self.capabilities.wildmatch && !this.hasIgnore) && + !_common.default.isFileIncluded( + this.globs, + this.dot, + this.doIgnore, + relativePath + ) + ) { + return; + } + if (!changeDescriptor.exists) { + self.emitEvent(DELETE_EVENT, relativePath, self.root); + } else { + _gracefulFs().default.lstat(absPath, (error, stat) => { + // Files can be deleted between the event and the lstat call + // the most reliable thing to do here is to ignore the event. + if (error && error.code === 'ENOENT') { + return; + } + if (handleError(self, error)) { + return; + } + const eventType = changeDescriptor.new ? ADD_EVENT : CHANGE_EVENT; + + // Change event on dirs are mostly useless. + if (!(eventType === CHANGE_EVENT && stat.isDirectory())) { + self.emitEvent(eventType, relativePath, self.root, stat); + } + }); + } +}; + +/** + * Dispatches the event. + * + * @param {string} eventType + * @param {string} filepath + * @param {string} root + * @param {fs.Stat} stat + * @private + */ + +WatchmanWatcher.prototype.emitEvent = function ( + eventType, + filepath, + root, + stat +) { + this.emit(eventType, filepath, root, stat); + this.emit(ALL_EVENT, eventType, filepath, root, stat); +}; + +/** + * Closes the watcher. + * + */ + +WatchmanWatcher.prototype.close = function () { + this.client.removeAllListeners(); + this.client.end(); + return Promise.resolve(); +}; + +/** + * Handles an error and returns true if exists. + * + * @param {WatchmanWatcher} self + * @param {Error} error + * @private + */ + +function handleError(self, error) { + if (error != null) { + self.emit('error', error); + return true; + } else { + return false; + } +} + +/** + * Handles a warning in the watchman resp object. + * + * @param {object} resp + * @private + */ + +function handleWarning(resp) { + if ('warning' in resp) { + if (_RecrawlWarning.default.isRecrawlWarningDupe(resp.warning)) { + return true; + } + console.warn(resp.warning); + return true; + } else { + return false; + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/watchers/common.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/watchers/common.js new file mode 100644 index 0000000000000000000000000000000000000000..b8fa0c30bdaa10b46e6c70eb9b4f29072b6f97f5 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/watchers/common.js @@ -0,0 +1,111 @@ +// vendored from https://github.com/amasad/sane/blob/64ff3a870c42e84f744086884bf55a4f9c22d376/src/common.js + +'use strict'; + +const platform = require('os').platform(); +const path = require('path'); +const anymatch = require('anymatch'); +const micromatch = require('micromatch'); +const walker = require('walker'); + +/** + * Constants + */ + +exports.DEFAULT_DELAY = 100; +exports.CHANGE_EVENT = 'change'; +exports.DELETE_EVENT = 'delete'; +exports.ADD_EVENT = 'add'; +exports.ALL_EVENT = 'all'; + +/** + * Assigns options to the watcher. + * + * @param {NodeWatcher|PollWatcher|WatchmanWatcher} watcher + * @param {?object} opts + * @return {boolean} + * @public + */ + +exports.assignOptions = function (watcher, opts) { + opts = opts || {}; + watcher.globs = opts.glob || []; + watcher.dot = opts.dot || false; + watcher.ignored = opts.ignored || false; + if (!Array.isArray(watcher.globs)) { + watcher.globs = [watcher.globs]; + } + watcher.hasIgnore = + Boolean(opts.ignored) && !(Array.isArray(opts) && opts.length > 0); + watcher.doIgnore = opts.ignored ? anymatch(opts.ignored) : () => false; + if (opts.watchman && opts.watchmanPath) { + watcher.watchmanPath = opts.watchmanPath; + } + return opts; +}; + +/** + * Checks a file relative path against the globs array. + * + * @param {array} globs + * @param {string} relativePath + * @return {boolean} + * @public + */ + +exports.isFileIncluded = function (globs, dot, doIgnore, relativePath) { + if (doIgnore(relativePath)) { + return false; + } + return globs.length + ? micromatch.some(relativePath, globs, { + dot + }) + : dot || micromatch.some(relativePath, '**/*'); +}; + +/** + * Traverse a directory recursively calling `callback` on every directory. + * + * @param {string} dir + * @param {function} dirCallback + * @param {function} fileCallback + * @param {function} endCallback + * @param {*} ignored + * @public + */ + +exports.recReaddir = function ( + dir, + dirCallback, + fileCallback, + endCallback, + errorCallback, + ignored +) { + walker(dir) + .filterDir(currentDir => !anymatch(ignored, currentDir)) + .on('dir', normalizeProxy(dirCallback)) + .on('file', normalizeProxy(fileCallback)) + .on('error', errorCallback) + .on('end', () => { + if (platform === 'win32') { + setTimeout(endCallback, 1000); + } else { + endCallback(); + } + }); +}; + +/** + * Returns a callback that when called will normalize a path and call the + * original callback + * + * @param {function} callback + * @return {function} + * @private + */ + +function normalizeProxy(callback) { + return (filepath, stats) => callback(path.normalize(filepath), stats); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/worker.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/worker.js new file mode 100644 index 0000000000000000000000000000000000000000..7f27df08d7251b1ddc23737ad525ae1f01734729 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/build/worker.js @@ -0,0 +1,180 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.getSha1 = getSha1; +exports.worker = worker; +function _crypto() { + const data = require('crypto'); + _crypto = function () { + return data; + }; + return data; +} +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function fs() { + const data = _interopRequireWildcard(require('graceful-fs')); + fs = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +var _blacklist = _interopRequireDefault(require('./blacklist')); +var _constants = _interopRequireDefault(require('./constants')); +var _dependencyExtractor = require('./lib/dependencyExtractor'); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const PACKAGE_JSON = `${path().sep}package.json`; +let hasteImpl = null; +let hasteImplModulePath = null; +function sha1hex(content) { + return (0, _crypto().createHash)('sha1').update(content).digest('hex'); +} +async function worker(data) { + if ( + data.hasteImplModulePath && + data.hasteImplModulePath !== hasteImplModulePath + ) { + if (hasteImpl) { + throw new Error('jest-haste-map: hasteImplModulePath changed'); + } + hasteImplModulePath = data.hasteImplModulePath; + hasteImpl = require(hasteImplModulePath); + } + let content; + let dependencies; + let id; + let module; + let sha1; + const {computeDependencies, computeSha1, rootDir, filePath} = data; + const getContent = () => { + if (content === undefined) { + content = fs().readFileSync(filePath, 'utf8'); + } + return content; + }; + if (filePath.endsWith(PACKAGE_JSON)) { + // Process a package.json that is returned as a PACKAGE type with its name. + try { + const fileData = JSON.parse(getContent()); + if (fileData.name) { + const relativeFilePath = path().relative(rootDir, filePath); + id = fileData.name; + module = [relativeFilePath, _constants.default.PACKAGE]; + } + } catch (err) { + throw new Error(`Cannot parse ${filePath} as JSON: ${err.message}`); + } + } else if ( + !_blacklist.default.has(filePath.substring(filePath.lastIndexOf('.'))) + ) { + // Process a random file that is returned as a MODULE. + if (hasteImpl) { + id = hasteImpl.getHasteName(filePath); + } + if (computeDependencies) { + const content = getContent(); + const extractor = data.dependencyExtractor + ? await (0, _jestUtil().requireOrImportModule)( + data.dependencyExtractor, + false + ) + : _dependencyExtractor.extractor; + dependencies = Array.from( + extractor.extract( + content, + filePath, + _dependencyExtractor.extractor.extract + ) + ); + } + if (id) { + const relativeFilePath = path().relative(rootDir, filePath); + module = [relativeFilePath, _constants.default.MODULE]; + } + } + + // If a SHA-1 is requested on update, compute it. + if (computeSha1) { + sha1 = sha1hex(content || fs().readFileSync(filePath)); + } + return { + dependencies, + id, + module, + sha1 + }; +} +async function getSha1(data) { + const sha1 = data.computeSha1 + ? sha1hex(fs().readFileSync(data.filePath)) + : null; + return { + dependencies: undefined, + id: undefined, + module: undefined, + sha1 + }; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/package.json new file mode 100644 index 0000000000000000000000000000000000000000..ee459fdff926c11c17110c05124251fdfa0fd26e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-haste-map/package.json @@ -0,0 +1,47 @@ +{ + "name": "jest-haste-map", + "version": "29.7.0", + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/jest-haste-map" + }, + "license": "MIT", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "dependencies": { + "@jest/types": "^29.6.3", + "@types/graceful-fs": "^4.1.3", + "@types/node": "*", + "anymatch": "^3.0.3", + "fb-watchman": "^2.0.0", + "graceful-fs": "^4.2.9", + "jest-regex-util": "^29.6.3", + "jest-util": "^29.7.0", + "jest-worker": "^29.7.0", + "micromatch": "^4.0.4", + "walker": "^1.0.8" + }, + "devDependencies": { + "@types/fb-watchman": "^2.0.0", + "@types/micromatch": "^4.0.1", + "slash": "^3.0.0" + }, + "optionalDependencies": { + "fsevents": "^2.3.2" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "publishConfig": { + "access": "public" + }, + "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-regex-util/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-regex-util/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-regex-util/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-regex-util/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-regex-util/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8de7081045133753a839e978a29a0c0d612fa6c0 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-regex-util/build/index.d.ts @@ -0,0 +1,20 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + */ +export declare const escapePathForRegex: (dir: string) => string; + +export declare const escapeStrForRegex: (string: string) => string; + +export declare const replacePathSepForRegex: (string: string) => string; + +export {}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-regex-util/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-regex-util/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..0bb27016d51ed693d3c951f27cd2e8d84997a661 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-regex-util/build/index.js @@ -0,0 +1,40 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.replacePathSepForRegex = + exports.escapeStrForRegex = + exports.escapePathForRegex = + void 0; +var _path = require('path'); +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + */ + +const escapePathForRegex = dir => { + if (_path.sep === '\\') { + // Replace "\" with "/" so it's not escaped by escapeStrForRegex. + // replacePathSepForRegex will convert it back. + dir = dir.replace(/\\/g, '/'); + } + return replacePathSepForRegex(escapeStrForRegex(dir)); +}; +exports.escapePathForRegex = escapePathForRegex; +const escapeStrForRegex = string => + string.replace(/[[\]{}()*+?.\\^$|]/g, '\\$&'); +exports.escapeStrForRegex = escapeStrForRegex; +const replacePathSepForRegex = string => { + if (_path.sep === '\\') { + return string.replace( + /(\/|(.)?\\(?![[\]{}()*+?.^$|\\]))/g, + (_match, _, p2) => (p2 && p2 !== '\\' ? `${p2}\\\\` : '\\\\') + ); + } + return string; +}; +exports.replacePathSepForRegex = replacePathSepForRegex; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-regex-util/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-regex-util/package.json new file mode 100644 index 0000000000000000000000000000000000000000..ed8bc70707d3fc647eaf310d5cd0060b5cfbdb9d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-regex-util/package.json @@ -0,0 +1,29 @@ +{ + "name": "jest-regex-util", + "version": "29.6.3", + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/jest-regex-util" + }, + "devDependencies": { + "@types/node": "*" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "license": "MIT", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "publishConfig": { + "access": "public" + }, + "gitHead": "fb7d95c8af6e0d65a8b65348433d8a0ea0725b5b" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f9e1131c95e794f7399c3fd25354ec19d20a8b96 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/README.md @@ -0,0 +1,272 @@ +# jest-worker + +Module for executing heavy tasks under forked processes in parallel, by providing a `Promise` based interface, minimum overhead, and bound workers. + +The module works by providing an absolute path of the module to be loaded in all forked processes. All methods are exposed on the parent process as promises, so they can be `await`'ed. Child (worker) methods can either be synchronous or asynchronous. + +The module also implements support for bound workers. Binding a worker means that, based on certain parameters, the same task will always be executed by the same worker. The way bound workers work is by using the returned string of the `computeWorkerKey` method. If the string was used before for a task, the call will be queued to the related worker that processed the task earlier; if not, it will be executed by the first available worker, then sticked to the worker that executed it; so the next time it will be processed by the same worker. If you have no preference on the worker executing the task, but you have defined a `computeWorkerKey` method because you want _some_ of the tasks to be sticked, you can return `null` from it. + +The list of exposed methods can be explicitly provided via the `exposedMethods` option. If it is not provided, it will be obtained by requiring the child module into the main process, and analyzed via reflection. Check the "minimal example" section for a valid one. + +## Install + +```sh +yarn add jest-worker +``` + +## Example + +This example covers the minimal usage: + +### File `parent.js` + +```js +import {Worker as JestWorker} from 'jest-worker'; + +async function main() { + const worker = new JestWorker(require.resolve('./worker')); + const result = await worker.hello('Alice'); // "Hello, Alice" +} + +main(); +``` + +### File `worker.js` + +```js +export function hello(param) { + return `Hello, ${param}`; +} +``` + +## Experimental worker + +Node shipped with [`worker_threads`](https://nodejs.org/api/worker_threads.html), a "threading API" that uses `SharedArrayBuffers` to communicate between the main process and its child threads. This feature can significantly improve the communication time between parent and child processes in `jest-worker`. + +To use `worker_threads` instead of default `child_process` you have to pass `enableWorkerThreads: true` when instantiating the worker. + +## API + +The `Worker` export is a constructor that is initialized by passing the worker path, plus an options object. + +### `workerPath: string | URL` (required) + +Node module name or absolute path or file URL of the file to be loaded in the child processes. You can use `require.resolve` to transform a relative path into an absolute one. + +### `options: Object` (optional) + +#### `computeWorkerKey: (method: string, ...args: Array) => string | null` (optional) + +Every time a method exposed via the API is called, `computeWorkerKey` is also called in order to bound the call to a worker. This is useful for workers that are able to cache the result or part of it. You bound calls to a worker by making `computeWorkerKey` return the same identifier for all different calls. If you do not want to bind the call to any worker, return `null`. + +The callback you provide is called with the method name, plus all the rest of the arguments of the call. Thus, you have full control to decide what to return. Check a practical example on bound workers under the "bound worker usage" section. + +By default, no process is bound to any worker. + +#### `enableWorkerThreads: boolean` (optional) + +By default, `jest-worker` will use `child_process` threads to spawn new Node.js processes. If you prefer [`worker_threads`](https://nodejs.org/api/worker_threads.html) instead, pass `enableWorkerThreads: true`. + +#### `exposedMethods: ReadonlyArray` (optional) + +List of method names that can be called on the child processes from the parent process. You cannot expose any method named like a public `Worker` method, or starting with `_`. If you use method auto-discovery, then these methods will not be exposed, even if they exist. + +#### `forkOptions: ForkOptions` (optional) + +Allow customizing all options passed to `child_process.fork`. By default, some values are set (`cwd`, `env`, `execArgv` and `serialization`), but you can override them and customize the rest. For a list of valid values, check [the Node documentation](https://nodejs.org/api/child_process.html#child_process_child_process_fork_modulepath_args_options). + +#### `idleMemoryLimit: number` (optional) + +Specifies the memory limit for workers before they are recycled and is primarily a work-around for [this issue](https://github.com/jestjs/jest/issues/11956); + +After the worker has executed a task the memory usage of it is checked. If it exceeds the value specified the worker is killed and restarted. If no limit is set this process does not occur. The limit can be specified in 2 ways: + +- `<= 1` - The value is assumed to be a percentage of system memory. So 0.5 sets the memory limit of the worker to half of the total system memory +- `\> 1` - Assumed to be a fixed byte value. Because of the previous rule if you wanted a value of 1 byte (I don't know why) you could use `1.1`. + +#### `maxRetries: number` (optional) + +Maximum amount of times that a dead child can be re-spawned, per call. Defaults to `3`, pass `Infinity` to allow endless retries. + +#### `numWorkers: number` (optional) + +Amount of workers to spawn. Defaults to the number of CPUs minus 1. + +#### `resourceLimits: ResourceLimits` (optional) + +The `resourceLimits` option which will be passed to `worker_threads` workers. + +#### `silent: Boolean` (optional) + +Set to false for `stdout` and `stderr` to be logged to console. + +By default this is true. + +#### `setupArgs: Array` (optional) + +The arguments that will be passed to the `setup` method during initialization. + +#### `taskQueue: TaskQueue` (optional) + +The task queue defines in which order tasks (method calls) are processed by the workers. `jest-worker` ships with a `FifoQueue` and `PriorityQueue`: + +- `FifoQueue` (default): Processes the method calls (tasks) in the call order. +- `PriorityQueue`: Processes the method calls by a computed priority in natural ordering (lower priorities first). Tasks with the same priority are processed in any order (FIFO not guaranteed). The constructor accepts a single argument, the function that is passed the name of the called function and the arguments and returns a numerical value for the priority: `new require('jest-worker').PriorityQueue((method, filename) => filename.length)`. + +#### `WorkerPool: new (workerPath: string, options?: WorkerPoolOptions) => WorkerPoolInterface` (optional) + +Provide a custom WorkerPool class to be used for spawning child processes. + +#### `workerSchedulingPolicy: 'round-robin' | 'in-order'` (optional) + +Specifies the policy how tasks are assigned to workers if multiple workers are _idle_: + +- `round-robin` (default): The task will be sequentially distributed onto the workers. The first task is assigned to the worker 1, the second to the worker 2, to ensure that the work is distributed across workers. +- `in-order`: The task will be assigned to the first free worker starting with worker 1 and only assign the work to worker 2 if the worker 1 is busy. + +Tasks are always assigned to the first free worker as soon as tasks start to queue up. The scheduling policy does not define the task scheduling which is always first-in, first-out. + +## JestWorker + +### Methods + +The returned `JestWorker` instance has all the exposed methods, plus some additional ones to interact with the workers itself: + +#### `getStdout(): Readable` + +Returns a `ReadableStream` where the standard output of all workers is piped. Note that the `silent` option of the child workers must be set to `true` to make it work. This is the default set by `jest-worker`, but keep it in mind when overriding options through `forkOptions`. + +#### `getStderr(): Readable` + +Returns a `ReadableStream` where the standard error of all workers is piped. Note that the `silent` option of the child workers must be set to `true` to make it work. This is the default set by `jest-worker`, but keep it in mind when overriding options through `forkOptions`. + +#### `start()` + +Starts up every worker and calls their `setup` function, if it exists. Returns a `Promise` which resolves when all workers are running and have completed their `setup`. + +This is useful if you want to start up all your workers eagerly before they are used to call any other functions. + +#### `end()` + +Finishes the workers by killing all workers. No further calls can be done to the `Worker` instance. + +Returns a `Promise` that resolves with `{ forceExited: boolean }` once all workers are dead. If `forceExited` is `true`, at least one of the workers did not exit gracefully, which likely happened because it executed a leaky task that left handles open. This should be avoided, force exiting workers is a last resort to prevent creating lots of orphans. + +**Note:** + +`await`ing the `end()` Promise immediately after the workers are no longer needed before proceeding to do other useful things in your program may not be a good idea. If workers have to be force exited, `jest-worker` may go through multiple stages of force exiting (e.g. SIGTERM, later SIGKILL) and give the worker overall around 1 second time to exit on its own. During this time, your program will wait, even though it may not be necessary that all workers are dead before continuing execution. + +Consider deliberately leaving this Promise floating (unhandled resolution). After your program has done the rest of its work and is about to exit, the Node process will wait for the Promise to resolve after all workers are dead as the last event loop task. That way you parallelized computation time of your program and waiting time and you didn't delay the outputs of your program unnecessarily. + +### Worker IDs + +Each worker has a unique id (index that starts with `'1'`), which is available inside the worker as `process.env.JEST_WORKER_ID`. + +## Setting up and tearing down the child process + +The child process can define two special methods (both of them can be asynchronous): + +- `setup()`: If defined, it's executed before the first call to any method in the child. +- `teardown()`: If defined, it's executed when the farm ends. + +# More examples + +## Standard usage + +This example covers the standard usage: + +### File `parent.js` + +```js +import {Worker as JestWorker} from 'jest-worker'; + +async function main() { + const myWorker = new JestWorker(require.resolve('./worker'), { + exposedMethods: ['foo', 'bar', 'getWorkerId'], + numWorkers: 4, + }); + + console.log(await myWorker.foo('Alice')); // "Hello from foo: Alice" + console.log(await myWorker.bar('Bob')); // "Hello from bar: Bob" + console.log(await myWorker.getWorkerId()); // "3" -> this message has sent from the 3rd worker + + const {forceExited} = await myWorker.end(); + if (forceExited) { + console.error('Workers failed to exit gracefully'); + } +} + +main(); +``` + +### File `worker.js` + +```js +export function foo(param) { + return `Hello from foo: ${param}`; +} + +export function bar(param) { + return `Hello from bar: ${param}`; +} + +export function getWorkerId() { + return process.env.JEST_WORKER_ID; +} +``` + +## Bound worker usage: + +This example covers the usage with a `computeWorkerKey` method: + +### File `parent.js` + +```js +import {Worker as JestWorker} from 'jest-worker'; + +async function main() { + const myWorker = new JestWorker(require.resolve('./worker'), { + computeWorkerKey: (method, filename) => filename, + }); + + // Transform the given file, within the first available worker. + console.log(await myWorker.transform('/tmp/foo.js')); + + // Wait a bit. + await sleep(10000); + + // Transform the same file again. Will immediately return because the + // transformed file is cached in the worker, and `computeWorkerKey` ensures + // the same worker that processed the file the first time will process it now. + console.log(await myWorker.transform('/tmp/foo.js')); + + const {forceExited} = await myWorker.end(); + if (forceExited) { + console.error('Workers failed to exit gracefully'); + } +} + +main(); +``` + +### File `worker.js` + +```js +import babel from '@babel/core'; + +const cache = Object.create(null); + +export function transform(filename) { + if (cache[filename]) { + return cache[filename]; + } + + // jest-worker can handle both immediate results and thenables. If a + // thenable is returned, it will be await'ed until it resolves. + return babel.transformFileAsync(filename).then(result => { + cache[filename] = result; + + return result; + }); +} +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/Farm.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/Farm.js new file mode 100644 index 0000000000000000000000000000000000000000..bb9accf675771738ace59536349701701db1183e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/Farm.js @@ -0,0 +1,152 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +var _FifoQueue = _interopRequireDefault(require('./FifoQueue')); +var _types = require('./types'); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class Farm { + _computeWorkerKey; + _workerSchedulingPolicy; + _cacheKeys = Object.create(null); + _locks = []; + _offset = 0; + _taskQueue; + constructor(_numOfWorkers, _callback, options = {}) { + this._numOfWorkers = _numOfWorkers; + this._callback = _callback; + this._computeWorkerKey = options.computeWorkerKey; + this._workerSchedulingPolicy = + options.workerSchedulingPolicy ?? 'round-robin'; + this._taskQueue = options.taskQueue ?? new _FifoQueue.default(); + } + doWork(method, ...args) { + const customMessageListeners = new Set(); + const addCustomMessageListener = listener => { + customMessageListeners.add(listener); + return () => { + customMessageListeners.delete(listener); + }; + }; + const onCustomMessage = message => { + customMessageListeners.forEach(listener => listener(message)); + }; + const promise = new Promise( + // Bind args to this function so it won't reference to the parent scope. + // This prevents a memory leak in v8, because otherwise the function will + // retain args for the closure. + ((args, resolve, reject) => { + const computeWorkerKey = this._computeWorkerKey; + const request = [_types.CHILD_MESSAGE_CALL, false, method, args]; + let worker = null; + let hash = null; + if (computeWorkerKey) { + hash = computeWorkerKey.call(this, method, ...args); + worker = hash == null ? null : this._cacheKeys[hash]; + } + const onStart = worker => { + if (hash != null) { + this._cacheKeys[hash] = worker; + } + }; + const onEnd = (error, result) => { + customMessageListeners.clear(); + if (error) { + reject(error); + } else { + resolve(result); + } + }; + const task = { + onCustomMessage, + onEnd, + onStart, + request + }; + if (worker) { + this._taskQueue.enqueue(task, worker.getWorkerId()); + this._process(worker.getWorkerId()); + } else { + this._push(task); + } + }).bind(null, args) + ); + promise.UNSTABLE_onCustomMessage = addCustomMessageListener; + return promise; + } + _process(workerId) { + if (this._isLocked(workerId)) { + return this; + } + const task = this._taskQueue.dequeue(workerId); + if (!task) { + return this; + } + if (task.request[1]) { + throw new Error('Queue implementation returned processed task'); + } + + // Reference the task object outside so it won't be retained by onEnd, + // and other properties of the task object, such as task.request can be + // garbage collected. + let taskOnEnd = task.onEnd; + const onEnd = (error, result) => { + if (taskOnEnd) { + taskOnEnd(error, result); + } + taskOnEnd = null; + this._unlock(workerId); + this._process(workerId); + }; + task.request[1] = true; + this._lock(workerId); + this._callback( + workerId, + task.request, + task.onStart, + onEnd, + task.onCustomMessage + ); + return this; + } + _push(task) { + this._taskQueue.enqueue(task); + const offset = this._getNextWorkerOffset(); + for (let i = 0; i < this._numOfWorkers; i++) { + this._process((offset + i) % this._numOfWorkers); + if (task.request[1]) { + break; + } + } + return this; + } + _getNextWorkerOffset() { + switch (this._workerSchedulingPolicy) { + case 'in-order': + return 0; + case 'round-robin': + return this._offset++; + } + } + _lock(workerId) { + this._locks[workerId] = true; + } + _unlock(workerId) { + this._locks[workerId] = false; + } + _isLocked(workerId) { + return this._locks[workerId]; + } +} +exports.default = Farm; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/FifoQueue.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/FifoQueue.js new file mode 100644 index 0000000000000000000000000000000000000000..1831e024b876617bd0bd00bf904b222e831016b3 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/FifoQueue.js @@ -0,0 +1,89 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +/** + * First-in, First-out task queue that manages a dedicated pool + * for each worker as well as a shared queue. The FIFO ordering is guaranteed + * across the worker specific and shared queue. + */ +class FifoQueue { + _workerQueues = []; + _sharedQueue = new InternalQueue(); + enqueue(task, workerId) { + if (workerId == null) { + this._sharedQueue.enqueue(task); + return; + } + let workerQueue = this._workerQueues[workerId]; + if (workerQueue == null) { + workerQueue = this._workerQueues[workerId] = new InternalQueue(); + } + const sharedTop = this._sharedQueue.peekLast(); + const item = { + previousSharedTask: sharedTop, + task + }; + workerQueue.enqueue(item); + } + dequeue(workerId) { + const workerTop = this._workerQueues[workerId]?.peek(); + const sharedTaskIsProcessed = + workerTop?.previousSharedTask?.request[1] ?? true; + + // Process the top task from the shared queue if + // - there's no task in the worker specific queue or + // - if the non-worker-specific task after which this worker specific task + // has been queued wasn't processed yet + if (workerTop != null && sharedTaskIsProcessed) { + return this._workerQueues[workerId]?.dequeue()?.task ?? null; + } + return this._sharedQueue.dequeue(); + } +} +exports.default = FifoQueue; +/** + * FIFO queue for a single worker / shared queue. + */ +class InternalQueue { + _head = null; + _last = null; + enqueue(value) { + const item = { + next: null, + value + }; + if (this._last == null) { + this._head = item; + } else { + this._last.next = item; + } + this._last = item; + } + dequeue() { + if (this._head == null) { + return null; + } + const item = this._head; + this._head = item.next; + if (this._head == null) { + this._last = null; + } + return item.value; + } + peek() { + return this._head?.value ?? null; + } + peekLast() { + return this._last?.value ?? null; + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/PriorityQueue.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/PriorityQueue.js new file mode 100644 index 0000000000000000000000000000000000000000..6218a8ea6186fffb90656d6a914f11bf704a1ce9 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/PriorityQueue.js @@ -0,0 +1,137 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +/** + * Priority queue that processes tasks in natural ordering (lower priority first) + * according to the priority computed by the function passed in the constructor. + * + * FIFO ordering isn't guaranteed for tasks with the same priority. + * + * Worker specific tasks with the same priority as a non-worker specific task + * are always processed first. + */ +class PriorityQueue { + _queue = []; + _sharedQueue = new MinHeap(); + constructor(_computePriority) { + this._computePriority = _computePriority; + } + enqueue(task, workerId) { + if (workerId == null) { + this._enqueue(task, this._sharedQueue); + } else { + const queue = this._getWorkerQueue(workerId); + this._enqueue(task, queue); + } + } + _enqueue(task, queue) { + const item = { + priority: this._computePriority(task.request[2], ...task.request[3]), + task + }; + queue.add(item); + } + dequeue(workerId) { + const workerQueue = this._getWorkerQueue(workerId); + const workerTop = workerQueue.peek(); + const sharedTop = this._sharedQueue.peek(); + + // use the task from the worker queue if there's no task in the shared queue + // or if the priority of the worker queue is smaller or equal to the + // priority of the top task in the shared queue. The tasks of the + // worker specific queue are preferred because no other worker can pick this + // specific task up. + if ( + sharedTop == null || + (workerTop != null && workerTop.priority <= sharedTop.priority) + ) { + return workerQueue.poll()?.task ?? null; + } + return this._sharedQueue.poll().task; + } + _getWorkerQueue(workerId) { + let queue = this._queue[workerId]; + if (queue == null) { + queue = this._queue[workerId] = new MinHeap(); + } + return queue; + } +} +exports.default = PriorityQueue; +class MinHeap { + _heap = []; + peek() { + return this._heap[0] ?? null; + } + add(item) { + const nodes = this._heap; + nodes.push(item); + if (nodes.length === 1) { + return; + } + let currentIndex = nodes.length - 1; + + // Bubble up the added node as long as the parent is bigger + while (currentIndex > 0) { + const parentIndex = Math.floor((currentIndex + 1) / 2) - 1; + const parent = nodes[parentIndex]; + if (parent.priority <= item.priority) { + break; + } + nodes[currentIndex] = parent; + nodes[parentIndex] = item; + currentIndex = parentIndex; + } + } + poll() { + const nodes = this._heap; + const result = nodes[0]; + const lastElement = nodes.pop(); + + // heap was empty or removed the last element + if (result == null || nodes.length === 0) { + return result ?? null; + } + let index = 0; + nodes[0] = lastElement ?? null; + const element = nodes[0]; + while (true) { + let swapIndex = null; + const rightChildIndex = (index + 1) * 2; + const leftChildIndex = rightChildIndex - 1; + const rightChild = nodes[rightChildIndex]; + const leftChild = nodes[leftChildIndex]; + + // if the left child is smaller, swap with the left + if (leftChild != null && leftChild.priority < element.priority) { + swapIndex = leftChildIndex; + } + + // If the right child is smaller or the right child is smaller than the left + // then swap with the right child + if ( + rightChild != null && + rightChild.priority < (swapIndex == null ? element : leftChild).priority + ) { + swapIndex = rightChildIndex; + } + if (swapIndex == null) { + break; + } + nodes[index] = nodes[swapIndex]; + nodes[swapIndex] = element; + index = swapIndex; + } + return result; + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/WorkerPool.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/WorkerPool.js new file mode 100644 index 0000000000000000000000000000000000000000..b1e439d2c53e7a33a6431a9b066d91816252d30e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/WorkerPool.js @@ -0,0 +1,34 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +var _BaseWorkerPool = _interopRequireDefault(require('./base/BaseWorkerPool')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class WorkerPool extends _BaseWorkerPool.default { + send(workerId, request, onStart, onEnd, onCustomMessage) { + this.restartWorkerIfShutDown(workerId); + this.getWorkerById(workerId).send(request, onStart, onEnd, onCustomMessage); + } + createWorker(workerOptions) { + let Worker; + if (this._options.enableWorkerThreads) { + Worker = require('./workers/NodeThreadsWorker').default; + } else { + Worker = require('./workers/ChildProcessWorker').default; + } + return new Worker(workerOptions); + } +} +var _default = WorkerPool; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/base/BaseWorkerPool.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/base/BaseWorkerPool.js new file mode 100644 index 0000000000000000000000000000000000000000..b49d061d78d293f256c7dff0bd123d73479e69df --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/base/BaseWorkerPool.js @@ -0,0 +1,156 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _mergeStream() { + const data = _interopRequireDefault(require('merge-stream')); + _mergeStream = function () { + return data; + }; + return data; +} +var _types = require('../types'); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// How long to wait for the child process to terminate +// after CHILD_MESSAGE_END before sending force exiting. +const FORCE_EXIT_DELAY = 500; + +/* istanbul ignore next */ +// eslint-disable-next-line @typescript-eslint/no-empty-function +const emptyMethod = () => {}; +class BaseWorkerPool { + _stderr; + _stdout; + _options; + _workers; + _workerPath; + constructor(workerPath, options) { + this._options = options; + this._workerPath = workerPath; + this._workers = new Array(options.numWorkers); + const stdout = (0, _mergeStream().default)(); + const stderr = (0, _mergeStream().default)(); + const {forkOptions, maxRetries, resourceLimits, setupArgs} = options; + for (let i = 0; i < options.numWorkers; i++) { + const workerOptions = { + forkOptions, + idleMemoryLimit: this._options.idleMemoryLimit, + maxRetries, + resourceLimits, + setupArgs, + workerId: i, + workerPath + }; + const worker = this.createWorker(workerOptions); + const workerStdout = worker.getStdout(); + const workerStderr = worker.getStderr(); + if (workerStdout) { + stdout.add(workerStdout); + } + if (workerStderr) { + stderr.add(workerStderr); + } + this._workers[i] = worker; + } + this._stdout = stdout; + this._stderr = stderr; + } + getStderr() { + return this._stderr; + } + getStdout() { + return this._stdout; + } + getWorkers() { + return this._workers; + } + getWorkerById(workerId) { + return this._workers[workerId]; + } + restartWorkerIfShutDown(workerId) { + if (this._workers[workerId].state === _types.WorkerStates.SHUT_DOWN) { + const {forkOptions, maxRetries, resourceLimits, setupArgs} = + this._options; + const workerOptions = { + forkOptions, + idleMemoryLimit: this._options.idleMemoryLimit, + maxRetries, + resourceLimits, + setupArgs, + workerId, + workerPath: this._workerPath + }; + const worker = this.createWorker(workerOptions); + this._workers[workerId] = worker; + } + } + createWorker(_workerOptions) { + throw Error('Missing method createWorker in WorkerPool'); + } + async start() { + await Promise.all( + this._workers.map(async worker => { + await worker.waitForWorkerReady(); + await new Promise((resolve, reject) => { + worker.send( + [_types.CHILD_MESSAGE_CALL_SETUP], + emptyMethod, + error => { + if (error) { + reject(error); + } else { + resolve(); + } + }, + emptyMethod + ); + }); + }) + ); + } + async end() { + // We do not cache the request object here. If so, it would only be only + // processed by one of the workers, and we want them all to close. + const workerExitPromises = this._workers.map(async worker => { + worker.send( + [_types.CHILD_MESSAGE_END, false], + emptyMethod, + emptyMethod, + emptyMethod + ); + + // Schedule a force exit in case worker fails to exit gracefully so + // await worker.waitForExit() never takes longer than FORCE_EXIT_DELAY + let forceExited = false; + const forceExitTimeout = setTimeout(() => { + worker.forceExit(); + forceExited = true; + }, FORCE_EXIT_DELAY); + await worker.waitForExit(); + // Worker ideally exited gracefully, don't send force exit then + clearTimeout(forceExitTimeout); + return forceExited; + }); + const workerExits = await Promise.all(workerExitPromises); + return workerExits.reduce( + (result, forceExited) => ({ + forceExited: result.forceExited || forceExited + }), + { + forceExited: false + } + ); + } +} +exports.default = BaseWorkerPool; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8f25376839df6060786fa173cc4f6753e8f43d4d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/index.d.ts @@ -0,0 +1,355 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/// + +import type {ForkOptions} from 'child_process'; +import type {ResourceLimits} from 'worker_threads'; + +declare const CHILD_MESSAGE_CALL = 1; + +declare const CHILD_MESSAGE_CALL_SETUP = 4; + +declare const CHILD_MESSAGE_END = 2; + +declare const CHILD_MESSAGE_INITIALIZE = 0; + +declare const CHILD_MESSAGE_MEM_USAGE = 3; + +declare type ChildMessage = + | ChildMessageInitialize + | ChildMessageCall + | ChildMessageEnd + | ChildMessageMemUsage + | ChildMessageCallSetup; + +declare type ChildMessageCall = [ + type: typeof CHILD_MESSAGE_CALL, + isProcessed: boolean, + methodName: string, + args: Array, +]; + +declare type ChildMessageCallSetup = [type: typeof CHILD_MESSAGE_CALL_SETUP]; + +declare type ChildMessageEnd = [ + type: typeof CHILD_MESSAGE_END, + isProcessed: boolean, +]; + +declare type ChildMessageInitialize = [ + type: typeof CHILD_MESSAGE_INITIALIZE, + isProcessed: boolean, + fileName: string, + setupArgs: Array, + workerId: string | undefined, +]; + +declare type ChildMessageMemUsage = [type: typeof CHILD_MESSAGE_MEM_USAGE]; + +declare type ComputeTaskPriorityCallback = ( + method: string, + ...args: Array +) => number; + +declare type ExcludeReservedKeys = Exclude; + +/** + * First-in, First-out task queue that manages a dedicated pool + * for each worker as well as a shared queue. The FIFO ordering is guaranteed + * across the worker specific and shared queue. + */ +export declare class FifoQueue implements TaskQueue { + private _workerQueues; + private readonly _sharedQueue; + enqueue(task: QueueChildMessage, workerId?: number): void; + dequeue(workerId: number): QueueChildMessage | null; +} + +declare type FunctionLike = (...args: any) => unknown; + +declare type HeapItem = { + priority: number; +}; + +export declare type JestWorkerFarm> = + Worker_2 & WorkerModule; + +export declare function messageParent( + message: unknown, + parentProcess?: NodeJS.Process, +): void; + +declare type MethodLikeKeys = { + [K in keyof T]: T[K] extends FunctionLike ? K : never; +}[keyof T]; + +declare class MinHeap { + private readonly _heap; + peek(): TItem | null; + add(item: TItem): void; + poll(): TItem | null; +} + +declare type OnCustomMessage = (message: Array | unknown) => void; + +declare type OnEnd = (err: Error | null, result: unknown) => void; + +declare type OnStart = (worker: WorkerInterface) => void; + +declare type OnStateChangeHandler = ( + state: WorkerStates, + oldState: WorkerStates, +) => void; + +declare type PoolExitResult = { + forceExited: boolean; +}; + +/** + * Priority queue that processes tasks in natural ordering (lower priority first) + * according to the priority computed by the function passed in the constructor. + * + * FIFO ordering isn't guaranteed for tasks with the same priority. + * + * Worker specific tasks with the same priority as a non-worker specific task + * are always processed first. + */ +export declare class PriorityQueue implements TaskQueue { + private readonly _computePriority; + private _queue; + private readonly _sharedQueue; + constructor(_computePriority: ComputeTaskPriorityCallback); + enqueue(task: QueueChildMessage, workerId?: number): void; + _enqueue(task: QueueChildMessage, queue: MinHeap): void; + dequeue(workerId: number): QueueChildMessage | null; + _getWorkerQueue(workerId: number): MinHeap; +} + +export declare interface PromiseWithCustomMessage extends Promise { + UNSTABLE_onCustomMessage?: (listener: OnCustomMessage) => () => void; +} + +declare type Promisify = ReturnType extends Promise< + infer R +> + ? (...args: Parameters) => Promise + : (...args: Parameters) => Promise>; + +declare type QueueChildMessage = { + request: ChildMessageCall; + onStart: OnStart; + onEnd: OnEnd; + onCustomMessage: OnCustomMessage; +}; + +declare type QueueItem = { + task: QueueChildMessage; + priority: number; +}; + +declare type ReservedKeys = + | 'end' + | 'getStderr' + | 'getStdout' + | 'setup' + | 'teardown'; + +export declare interface TaskQueue { + /** + * Enqueues the task in the queue for the specified worker or adds it to the + * queue shared by all workers + * @param task the task to queue + * @param workerId the id of the worker that should process this task or undefined + * if there's no preference. + */ + enqueue(task: QueueChildMessage, workerId?: number): void; + /** + * Dequeues the next item from the queue for the specified worker + * @param workerId the id of the worker for which the next task should be retrieved + */ + dequeue(workerId: number): QueueChildMessage | null; +} + +/** + * The Jest farm (publicly called "Worker") is a class that allows you to queue + * methods across multiple child processes, in order to parallelize work. This + * is done by providing an absolute path to a module that will be loaded on each + * of the child processes, and bridged to the main process. + * + * Bridged methods are specified by using the "exposedMethods" property of the + * "options" object. This is an array of strings, where each of them corresponds + * to the exported name in the loaded module. + * + * You can also control the amount of workers by using the "numWorkers" property + * of the "options" object, and the settings passed to fork the process through + * the "forkOptions" property. The amount of workers defaults to the amount of + * CPUS minus one. + * + * Queueing calls can be done in two ways: + * - Standard method: calls will be redirected to the first available worker, + * so they will get executed as soon as they can. + * + * - Sticky method: if a "computeWorkerKey" method is provided within the + * config, the resulting string of this method will be used as a key. + * Every time this key is returned, it is guaranteed that your job will be + * processed by the same worker. This is specially useful if your workers + * are caching results. + */ +declare class Worker_2 { + private _ending; + private readonly _farm; + private readonly _options; + private readonly _workerPool; + constructor(workerPath: string | URL, options?: WorkerFarmOptions); + private _bindExposedWorkerMethods; + private _callFunctionWithArgs; + getStderr(): NodeJS.ReadableStream; + getStdout(): NodeJS.ReadableStream; + start(): Promise; + end(): Promise; +} +export {Worker_2 as Worker}; + +declare type WorkerCallback = ( + workerId: number, + request: ChildMessage, + onStart: OnStart, + onEnd: OnEnd, + onCustomMessage: OnCustomMessage, +) => void; + +declare enum WorkerEvents { + STATE_CHANGE = 'state-change', +} + +export declare type WorkerFarmOptions = { + computeWorkerKey?: (method: string, ...args: Array) => string | null; + enableWorkerThreads?: boolean; + exposedMethods?: ReadonlyArray; + forkOptions?: ForkOptions; + maxRetries?: number; + numWorkers?: number; + resourceLimits?: ResourceLimits; + setupArgs?: Array; + taskQueue?: TaskQueue; + WorkerPool?: new ( + workerPath: string, + options?: WorkerPoolOptions, + ) => WorkerPoolInterface; + workerSchedulingPolicy?: WorkerSchedulingPolicy; + idleMemoryLimit?: number; +}; + +declare interface WorkerInterface { + get state(): WorkerStates; + send( + request: ChildMessage, + onProcessStart: OnStart, + onProcessEnd: OnEnd, + onCustomMessage: OnCustomMessage, + ): void; + waitForExit(): Promise; + forceExit(): void; + getWorkerId(): number; + getStderr(): NodeJS.ReadableStream | null; + getStdout(): NodeJS.ReadableStream | null; + /** + * Some system level identifier for the worker. IE, process id, thread id, etc. + */ + getWorkerSystemId(): number; + getMemoryUsage(): Promise; + /** + * Checks to see if the child worker is actually running. + */ + isWorkerRunning(): boolean; + /** + * When the worker child is started and ready to start handling requests. + * + * @remarks + * This mostly exists to help with testing so that you don't check the status + * of things like isWorkerRunning before it actually is. + */ + waitForWorkerReady(): Promise; +} + +declare type WorkerModule = { + [K in keyof T as Extract< + ExcludeReservedKeys, + MethodLikeKeys + >]: T[K] extends FunctionLike ? Promisify : never; +}; + +declare type WorkerOptions_2 = { + forkOptions: ForkOptions; + resourceLimits: ResourceLimits; + setupArgs: Array; + maxRetries: number; + workerId: number; + workerData?: unknown; + workerPath: string; + /** + * After a job has executed the memory usage it should return to. + * + * @remarks + * Note this is different from ResourceLimits in that it checks at idle, after + * a job is complete. So you could have a resource limit of 500MB but an idle + * limit of 50MB. The latter will only trigger if after a job has completed the + * memory usage hasn't returned back down under 50MB. + */ + idleMemoryLimit?: number; + /** + * This mainly exists so the path can be changed during testing. + * https://github.com/jestjs/jest/issues/9543 + */ + childWorkerPath?: string; + /** + * This is useful for debugging individual tests allowing you to see + * the raw output of the worker. + */ + silent?: boolean; + /** + * Used to immediately bind event handlers. + */ + on?: { + [WorkerEvents.STATE_CHANGE]: + | OnStateChangeHandler + | ReadonlyArray; + }; +}; + +export declare interface WorkerPoolInterface { + getStderr(): NodeJS.ReadableStream; + getStdout(): NodeJS.ReadableStream; + getWorkers(): Array; + createWorker(options: WorkerOptions_2): WorkerInterface; + send: WorkerCallback; + start(): Promise; + end(): Promise; +} + +export declare type WorkerPoolOptions = { + setupArgs: Array; + forkOptions: ForkOptions; + resourceLimits: ResourceLimits; + maxRetries: number; + numWorkers: number; + enableWorkerThreads: boolean; + idleMemoryLimit?: number; +}; + +declare type WorkerSchedulingPolicy = 'round-robin' | 'in-order'; + +declare enum WorkerStates { + STARTING = 'starting', + OK = 'ok', + OUT_OF_MEMORY = 'oom', + RESTARTING = 'restarting', + SHUTTING_DOWN = 'shutting-down', + SHUT_DOWN = 'shut-down', +} + +export {}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..6e840cc2a2655d83001096adbb16931d8041677a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/index.js @@ -0,0 +1,192 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +Object.defineProperty(exports, 'FifoQueue', { + enumerable: true, + get: function () { + return _FifoQueue.default; + } +}); +Object.defineProperty(exports, 'PriorityQueue', { + enumerable: true, + get: function () { + return _PriorityQueue.default; + } +}); +exports.Worker = void 0; +Object.defineProperty(exports, 'messageParent', { + enumerable: true, + get: function () { + return _messageParent.default; + } +}); +function _os() { + const data = require('os'); + _os = function () { + return data; + }; + return data; +} +function _path() { + const data = require('path'); + _path = function () { + return data; + }; + return data; +} +function _url() { + const data = require('url'); + _url = function () { + return data; + }; + return data; +} +var _Farm = _interopRequireDefault(require('./Farm')); +var _WorkerPool = _interopRequireDefault(require('./WorkerPool')); +var _PriorityQueue = _interopRequireDefault(require('./PriorityQueue')); +var _FifoQueue = _interopRequireDefault(require('./FifoQueue')); +var _messageParent = _interopRequireDefault(require('./workers/messageParent')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function getExposedMethods(workerPath, options) { + let exposedMethods = options.exposedMethods; + + // If no methods list is given, try getting it by auto-requiring the module. + if (!exposedMethods) { + const module = require(workerPath); + exposedMethods = Object.keys(module).filter( + name => typeof module[name] === 'function' + ); + if (typeof module === 'function') { + exposedMethods = [...exposedMethods, 'default']; + } + } + return exposedMethods; +} +function getNumberOfCpus() { + return typeof _os().availableParallelism === 'function' + ? (0, _os().availableParallelism)() + : (0, _os().cpus)().length; +} + +/** + * The Jest farm (publicly called "Worker") is a class that allows you to queue + * methods across multiple child processes, in order to parallelize work. This + * is done by providing an absolute path to a module that will be loaded on each + * of the child processes, and bridged to the main process. + * + * Bridged methods are specified by using the "exposedMethods" property of the + * "options" object. This is an array of strings, where each of them corresponds + * to the exported name in the loaded module. + * + * You can also control the amount of workers by using the "numWorkers" property + * of the "options" object, and the settings passed to fork the process through + * the "forkOptions" property. The amount of workers defaults to the amount of + * CPUS minus one. + * + * Queueing calls can be done in two ways: + * - Standard method: calls will be redirected to the first available worker, + * so they will get executed as soon as they can. + * + * - Sticky method: if a "computeWorkerKey" method is provided within the + * config, the resulting string of this method will be used as a key. + * Every time this key is returned, it is guaranteed that your job will be + * processed by the same worker. This is specially useful if your workers + * are caching results. + */ +class Worker { + _ending; + _farm; + _options; + _workerPool; + constructor(workerPath, options) { + this._options = { + ...options + }; + this._ending = false; + if (typeof workerPath !== 'string') { + workerPath = workerPath.href; + } + if (workerPath.startsWith('file:')) { + workerPath = (0, _url().fileURLToPath)(workerPath); + } else if (!(0, _path().isAbsolute)(workerPath)) { + throw new Error(`'workerPath' must be absolute, got '${workerPath}'`); + } + const workerPoolOptions = { + enableWorkerThreads: this._options.enableWorkerThreads ?? false, + forkOptions: this._options.forkOptions ?? {}, + idleMemoryLimit: this._options.idleMemoryLimit, + maxRetries: this._options.maxRetries ?? 3, + numWorkers: + this._options.numWorkers ?? Math.max(getNumberOfCpus() - 1, 1), + resourceLimits: this._options.resourceLimits ?? {}, + setupArgs: this._options.setupArgs ?? [] + }; + if (this._options.WorkerPool) { + this._workerPool = new this._options.WorkerPool( + workerPath, + workerPoolOptions + ); + } else { + this._workerPool = new _WorkerPool.default(workerPath, workerPoolOptions); + } + this._farm = new _Farm.default( + workerPoolOptions.numWorkers, + this._workerPool.send.bind(this._workerPool), + { + computeWorkerKey: this._options.computeWorkerKey, + taskQueue: this._options.taskQueue, + workerSchedulingPolicy: this._options.workerSchedulingPolicy + } + ); + this._bindExposedWorkerMethods(workerPath, this._options); + } + _bindExposedWorkerMethods(workerPath, options) { + getExposedMethods(workerPath, options).forEach(name => { + if (name.startsWith('_')) { + return; + } + + // eslint-disable-next-line no-prototype-builtins + if (this.constructor.prototype.hasOwnProperty(name)) { + throw new TypeError(`Cannot define a method called ${name}`); + } + + // @ts-expect-error: dynamic extension of the class instance is expected. + this[name] = this._callFunctionWithArgs.bind(this, name); + }); + } + _callFunctionWithArgs(method, ...args) { + if (this._ending) { + throw new Error('Farm is ended, no more calls can be done to it'); + } + return this._farm.doWork(method, ...args); + } + getStderr() { + return this._workerPool.getStderr(); + } + getStdout() { + return this._workerPool.getStdout(); + } + async start() { + await this._workerPool.start(); + } + async end() { + if (this._ending) { + throw new Error('Farm is ended, no more calls can be done to it'); + } + this._ending = true; + return this._workerPool.end(); + } +} +exports.Worker = Worker; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/types.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/types.js new file mode 100644 index 0000000000000000000000000000000000000000..feedb0b71bc9c2654c00c828a89ce358deb7edd6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/types.js @@ -0,0 +1,72 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.WorkerStates = + exports.WorkerEvents = + exports.PARENT_MESSAGE_SETUP_ERROR = + exports.PARENT_MESSAGE_OK = + exports.PARENT_MESSAGE_MEM_USAGE = + exports.PARENT_MESSAGE_CUSTOM = + exports.PARENT_MESSAGE_CLIENT_ERROR = + exports.CHILD_MESSAGE_MEM_USAGE = + exports.CHILD_MESSAGE_INITIALIZE = + exports.CHILD_MESSAGE_END = + exports.CHILD_MESSAGE_CALL_SETUP = + exports.CHILD_MESSAGE_CALL = + void 0; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// Because of the dynamic nature of a worker communication process, all messages +// coming from any of the other processes cannot be typed. Thus, many types +// include "unknown" as a TS type, which is (unfortunately) correct here. + +const CHILD_MESSAGE_INITIALIZE = 0; +exports.CHILD_MESSAGE_INITIALIZE = CHILD_MESSAGE_INITIALIZE; +const CHILD_MESSAGE_CALL = 1; +exports.CHILD_MESSAGE_CALL = CHILD_MESSAGE_CALL; +const CHILD_MESSAGE_END = 2; +exports.CHILD_MESSAGE_END = CHILD_MESSAGE_END; +const CHILD_MESSAGE_MEM_USAGE = 3; +exports.CHILD_MESSAGE_MEM_USAGE = CHILD_MESSAGE_MEM_USAGE; +const CHILD_MESSAGE_CALL_SETUP = 4; +exports.CHILD_MESSAGE_CALL_SETUP = CHILD_MESSAGE_CALL_SETUP; +const PARENT_MESSAGE_OK = 0; +exports.PARENT_MESSAGE_OK = PARENT_MESSAGE_OK; +const PARENT_MESSAGE_CLIENT_ERROR = 1; +exports.PARENT_MESSAGE_CLIENT_ERROR = PARENT_MESSAGE_CLIENT_ERROR; +const PARENT_MESSAGE_SETUP_ERROR = 2; +exports.PARENT_MESSAGE_SETUP_ERROR = PARENT_MESSAGE_SETUP_ERROR; +const PARENT_MESSAGE_CUSTOM = 3; +exports.PARENT_MESSAGE_CUSTOM = PARENT_MESSAGE_CUSTOM; +const PARENT_MESSAGE_MEM_USAGE = 4; + +// Option objects. + +// Messages passed from the parent to the children. + +// Messages passed from the children to the parent. + +// Queue types. +exports.PARENT_MESSAGE_MEM_USAGE = PARENT_MESSAGE_MEM_USAGE; +let WorkerStates = /*#__PURE__*/ (function (WorkerStates) { + WorkerStates['STARTING'] = 'starting'; + WorkerStates['OK'] = 'ok'; + WorkerStates['OUT_OF_MEMORY'] = 'oom'; + WorkerStates['RESTARTING'] = 'restarting'; + WorkerStates['SHUTTING_DOWN'] = 'shutting-down'; + WorkerStates['SHUT_DOWN'] = 'shut-down'; + return WorkerStates; +})({}); +exports.WorkerStates = WorkerStates; +let WorkerEvents = /*#__PURE__*/ (function (WorkerEvents) { + WorkerEvents['STATE_CHANGE'] = 'state-change'; + return WorkerEvents; +})({}); +exports.WorkerEvents = WorkerEvents; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/workers/ChildProcessWorker.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/workers/ChildProcessWorker.js new file mode 100644 index 0000000000000000000000000000000000000000..6a9d1f369ba05a7891793baf29d48b6e49946ff6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/workers/ChildProcessWorker.js @@ -0,0 +1,490 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = exports.SIGKILL_DELAY = void 0; +function _child_process() { + const data = require('child_process'); + _child_process = function () { + return data; + }; + return data; +} +function _os() { + const data = require('os'); + _os = function () { + return data; + }; + return data; +} +function _mergeStream() { + const data = _interopRequireDefault(require('merge-stream')); + _mergeStream = function () { + return data; + }; + return data; +} +function _supportsColor() { + const data = require('supports-color'); + _supportsColor = function () { + return data; + }; + return data; +} +var _types = require('../types'); +var _WorkerAbstract = _interopRequireDefault(require('./WorkerAbstract')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const SIGNAL_BASE_EXIT_CODE = 128; +const SIGKILL_EXIT_CODE = SIGNAL_BASE_EXIT_CODE + 9; +const SIGTERM_EXIT_CODE = SIGNAL_BASE_EXIT_CODE + 15; + +// How long to wait after SIGTERM before sending SIGKILL +const SIGKILL_DELAY = 500; + +/** + * This class wraps the child process and provides a nice interface to + * communicate with. It takes care of: + * + * - Re-spawning the process if it dies. + * - Queues calls while the worker is busy. + * - Re-sends the requests if the worker blew up. + * + * The reason for queueing them here (since childProcess.send also has an + * internal queue) is because the worker could be doing asynchronous work, and + * this would lead to the child process to read its receiving buffer and start a + * second call. By queueing calls here, we don't send the next call to the + * children until we receive the result of the previous one. + * + * As soon as a request starts to be processed by a worker, its "processed" + * field is changed to "true", so that other workers which might encounter the + * same call skip it. + */ +exports.SIGKILL_DELAY = SIGKILL_DELAY; +class ChildProcessWorker extends _WorkerAbstract.default { + _child; + _options; + _request; + _retries; + _onProcessEnd; + _onCustomMessage; + _stdout; + _stderr; + _stderrBuffer = []; + _memoryUsagePromise; + _resolveMemoryUsage; + _childIdleMemoryUsage; + _childIdleMemoryUsageLimit; + _memoryUsageCheck = false; + _childWorkerPath; + constructor(options) { + super(options); + this._options = options; + this._request = null; + this._stdout = null; + this._stderr = null; + this._childIdleMemoryUsage = null; + this._childIdleMemoryUsageLimit = options.idleMemoryLimit || null; + this._childWorkerPath = + options.childWorkerPath || require.resolve('./processChild'); + this.state = _types.WorkerStates.STARTING; + this.initialize(); + } + initialize() { + if ( + this.state === _types.WorkerStates.OUT_OF_MEMORY || + this.state === _types.WorkerStates.SHUTTING_DOWN || + this.state === _types.WorkerStates.SHUT_DOWN + ) { + return; + } + if (this._child && this._child.connected) { + this._child.kill('SIGKILL'); + } + this.state = _types.WorkerStates.STARTING; + const forceColor = _supportsColor().stdout + ? { + FORCE_COLOR: '1' + } + : {}; + const silent = this._options.silent ?? true; + if (!silent) { + // NOTE: Detecting an out of memory crash is independent of idle memory usage monitoring. We want to + // monitor for a crash occurring so that it can be handled as required and so we can tell the difference + // between an OOM crash and another kind of crash. We need to do this because if a worker crashes due to + // an OOM event sometimes it isn't seen by the worker pool and it just sits there waiting for the worker + // to respond and it never will. + console.warn('Unable to detect out of memory event if silent === false'); + } + this._stderrBuffer = []; + const options = { + cwd: process.cwd(), + env: { + ...process.env, + JEST_WORKER_ID: String(this._options.workerId + 1), + // 0-indexed workerId, 1-indexed JEST_WORKER_ID + ...forceColor + }, + // Suppress --debug / --inspect flags while preserving others (like --harmony). + execArgv: process.execArgv.filter(v => !/^--(debug|inspect)/.test(v)), + // default to advanced serialization in order to match worker threads + serialization: 'advanced', + silent, + ...this._options.forkOptions + }; + this._child = (0, _child_process().fork)( + this._childWorkerPath, + [], + options + ); + if (this._child.stdout) { + if (!this._stdout) { + // We need to add a permanent stream to the merged stream to prevent it + // from ending when the subprocess stream ends + this._stdout = (0, _mergeStream().default)(this._getFakeStream()); + } + this._stdout.add(this._child.stdout); + } + if (this._child.stderr) { + if (!this._stderr) { + // We need to add a permanent stream to the merged stream to prevent it + // from ending when the subprocess stream ends + this._stderr = (0, _mergeStream().default)(this._getFakeStream()); + } + this._stderr.add(this._child.stderr); + this._child.stderr.on('data', this.stderrDataHandler.bind(this)); + } + this._child.on('message', this._onMessage.bind(this)); + this._child.on('exit', this._onExit.bind(this)); + this._child.on('disconnect', this._onDisconnect.bind(this)); + this._child.send([ + _types.CHILD_MESSAGE_INITIALIZE, + false, + this._options.workerPath, + this._options.setupArgs + ]); + this._retries++; + + // If we exceeded the amount of retries, we will emulate an error reply + // coming from the child. This avoids code duplication related with cleaning + // the queue, and scheduling the next call. + if (this._retries > this._options.maxRetries) { + const error = new Error( + `Jest worker encountered ${this._retries} child process exceptions, exceeding retry limit` + ); + this._onMessage([ + _types.PARENT_MESSAGE_CLIENT_ERROR, + error.name, + error.message, + error.stack, + { + type: 'WorkerError' + } + ]); + + // Clear the request so we don't keep executing it. + this._request = null; + } + this.state = _types.WorkerStates.OK; + if (this._resolveWorkerReady) { + this._resolveWorkerReady(); + } + } + stderrDataHandler(chunk) { + if (chunk) { + this._stderrBuffer.push(Buffer.from(chunk)); + } + this._detectOutOfMemoryCrash(); + if (this.state === _types.WorkerStates.OUT_OF_MEMORY) { + this._workerReadyPromise = undefined; + this._resolveWorkerReady = undefined; + this.killChild(); + this._shutdown(); + } + } + _detectOutOfMemoryCrash() { + try { + const bufferStr = Buffer.concat(this._stderrBuffer).toString('utf8'); + if ( + bufferStr.includes('heap out of memory') || + bufferStr.includes('allocation failure;') || + bufferStr.includes('Last few GCs') + ) { + if ( + this.state === _types.WorkerStates.OK || + this.state === _types.WorkerStates.STARTING + ) { + this.state = _types.WorkerStates.OUT_OF_MEMORY; + } + } + } catch (err) { + console.error('Error looking for out of memory crash', err); + } + } + _onDisconnect() { + this._workerReadyPromise = undefined; + this._resolveWorkerReady = undefined; + this._detectOutOfMemoryCrash(); + if (this.state === _types.WorkerStates.OUT_OF_MEMORY) { + this.killChild(); + this._shutdown(); + } + } + _onMessage(response) { + // Ignore messages not intended for us + if (!Array.isArray(response)) return; + + // TODO: Add appropriate type check + let error; + switch (response[0]) { + case _types.PARENT_MESSAGE_OK: + this._onProcessEnd(null, response[1]); + break; + case _types.PARENT_MESSAGE_CLIENT_ERROR: + error = response[4]; + if (error != null && typeof error === 'object') { + const extra = error; + // @ts-expect-error: no index + const NativeCtor = globalThis[response[1]]; + const Ctor = typeof NativeCtor === 'function' ? NativeCtor : Error; + error = new Ctor(response[2]); + error.type = response[1]; + error.stack = response[3]; + for (const key in extra) { + error[key] = extra[key]; + } + } + this._onProcessEnd(error, null); + break; + case _types.PARENT_MESSAGE_SETUP_ERROR: + error = new Error(`Error when calling setup: ${response[2]}`); + error.type = response[1]; + error.stack = response[3]; + this._onProcessEnd(error, null); + break; + case _types.PARENT_MESSAGE_CUSTOM: + this._onCustomMessage(response[1]); + break; + case _types.PARENT_MESSAGE_MEM_USAGE: + this._childIdleMemoryUsage = response[1]; + if (this._resolveMemoryUsage) { + this._resolveMemoryUsage(response[1]); + this._resolveMemoryUsage = undefined; + this._memoryUsagePromise = undefined; + } + this._performRestartIfRequired(); + break; + default: + // Ignore messages not intended for us + break; + } + } + _performRestartIfRequired() { + if (this._memoryUsageCheck) { + this._memoryUsageCheck = false; + let limit = this._childIdleMemoryUsageLimit; + + // TODO: At some point it would make sense to make use of + // stringToBytes found in jest-config, however as this + // package does not have any dependencies on an other jest + // packages that can wait until some other time. + if (limit && limit > 0 && limit <= 1) { + limit = Math.floor((0, _os().totalmem)() * limit); + } else if (limit) { + limit = Math.floor(limit); + } + if ( + limit && + this._childIdleMemoryUsage && + this._childIdleMemoryUsage > limit + ) { + this.state = _types.WorkerStates.RESTARTING; + this.killChild(); + } + } + } + _onExit(exitCode, signal) { + this._workerReadyPromise = undefined; + this._resolveWorkerReady = undefined; + this._detectOutOfMemoryCrash(); + if (exitCode !== 0 && this.state === _types.WorkerStates.OUT_OF_MEMORY) { + this._onProcessEnd( + new Error('Jest worker ran out of memory and crashed'), + null + ); + this._shutdown(); + } else if ( + (exitCode !== 0 && + exitCode !== null && + exitCode !== SIGTERM_EXIT_CODE && + exitCode !== SIGKILL_EXIT_CODE && + this.state !== _types.WorkerStates.SHUTTING_DOWN) || + this.state === _types.WorkerStates.RESTARTING + ) { + this.state = _types.WorkerStates.RESTARTING; + this.initialize(); + if (this._request) { + this._child.send(this._request); + } + } else { + // At this point, it's not clear why the child process exited. There could + // be several reasons: + // + // 1. The child process exited successfully after finishing its work. + // This is the most likely case. + // 2. The child process crashed in a manner that wasn't caught through + // any of the heuristic-based checks above. + // 3. The child process was killed by another process or daemon unrelated + // to Jest. For example, oom-killer on Linux may have picked the child + // process to kill because overall system memory is constrained. + // + // If there's a pending request to the child process in any of those + // situations, the request still needs to be handled in some manner before + // entering the shutdown phase. Otherwise the caller expecting a response + // from the worker will never receive indication that something unexpected + // happened and hang forever. + // + // In normal operation, the request is handled and cleared before the + // child process exits. If it's still present, it's not clear what + // happened and probably best to throw an error. In practice, this usually + // happens when the child process is killed externally. + // + // There's a reasonable argument that the child process should be retried + // with request re-sent in this scenario. However, if the problem was due + // to situations such as oom-killer attempting to free up system + // resources, retrying would exacerbate the problem. + const isRequestStillPending = !!this._request; + if (isRequestStillPending) { + // If a signal is present, we can be reasonably confident the process + // was killed externally. Log this fact so it's more clear to users that + // something went wrong externally, rather than a bug in Jest itself. + const error = new Error( + signal != null + ? `A jest worker process (pid=${this._child.pid}) was terminated by another process: signal=${signal}, exitCode=${exitCode}. Operating system logs may contain more information on why this occurred.` + : `A jest worker process (pid=${this._child.pid}) crashed for an unknown reason: exitCode=${exitCode}` + ); + this._onProcessEnd(error, null); + } + this._shutdown(); + } + } + send(request, onProcessStart, onProcessEnd, onCustomMessage) { + this._stderrBuffer = []; + onProcessStart(this); + this._onProcessEnd = (...args) => { + const hasRequest = !!this._request; + + // Clean the request to avoid sending past requests to workers that fail + // while waiting for a new request (timers, unhandled rejections...) + this._request = null; + if ( + this._childIdleMemoryUsageLimit && + this._child.connected && + hasRequest + ) { + this.checkMemoryUsage(); + } + return onProcessEnd(...args); + }; + this._onCustomMessage = (...arg) => onCustomMessage(...arg); + this._request = request; + this._retries = 0; + // eslint-disable-next-line @typescript-eslint/no-empty-function + this._child.send(request, () => {}); + } + waitForExit() { + return this._exitPromise; + } + killChild() { + // We store a reference so that there's no way we can accidentally + // kill a new worker that has been spawned. + const childToKill = this._child; + childToKill.kill('SIGTERM'); + return setTimeout(() => childToKill.kill('SIGKILL'), SIGKILL_DELAY); + } + forceExit() { + this.state = _types.WorkerStates.SHUTTING_DOWN; + const sigkillTimeout = this.killChild(); + this._exitPromise.then(() => clearTimeout(sigkillTimeout)); + } + getWorkerId() { + return this._options.workerId; + } + + /** + * Gets the process id of the worker. + * + * @returns Process id. + */ + getWorkerSystemId() { + return this._child.pid; + } + getStdout() { + return this._stdout; + } + getStderr() { + return this._stderr; + } + + /** + * Gets the last reported memory usage. + * + * @returns Memory usage in bytes. + */ + getMemoryUsage() { + if (!this._memoryUsagePromise) { + let rejectCallback; + const promise = new Promise((resolve, reject) => { + this._resolveMemoryUsage = resolve; + rejectCallback = reject; + }); + this._memoryUsagePromise = promise; + if (!this._child.connected && rejectCallback) { + rejectCallback(new Error('Child process is not running.')); + this._memoryUsagePromise = undefined; + this._resolveMemoryUsage = undefined; + return promise; + } + this._child.send([_types.CHILD_MESSAGE_MEM_USAGE], err => { + if (err && rejectCallback) { + this._memoryUsagePromise = undefined; + this._resolveMemoryUsage = undefined; + rejectCallback(err); + } + }); + return promise; + } + return this._memoryUsagePromise; + } + + /** + * Gets updated memory usage and restarts if required + */ + checkMemoryUsage() { + if (this._childIdleMemoryUsageLimit) { + this._memoryUsageCheck = true; + this._child.send([_types.CHILD_MESSAGE_MEM_USAGE], err => { + if (err) { + console.error('Unable to check memory usage', err); + } + }); + } else { + console.warn( + 'Memory usage of workers can only be checked if a limit is set' + ); + } + } + isWorkerRunning() { + return this._child.connected && !this._child.killed; + } +} +exports.default = ChildProcessWorker; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/workers/NodeThreadsWorker.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/workers/NodeThreadsWorker.js new file mode 100644 index 0000000000000000000000000000000000000000..e25247a6ddc65fe9a91eb36aae37657de8b6e8c6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/workers/NodeThreadsWorker.js @@ -0,0 +1,359 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _os() { + const data = require('os'); + _os = function () { + return data; + }; + return data; +} +function _worker_threads() { + const data = require('worker_threads'); + _worker_threads = function () { + return data; + }; + return data; +} +function _mergeStream() { + const data = _interopRequireDefault(require('merge-stream')); + _mergeStream = function () { + return data; + }; + return data; +} +var _types = require('../types'); +var _WorkerAbstract = _interopRequireDefault(require('./WorkerAbstract')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class ExperimentalWorker extends _WorkerAbstract.default { + _worker; + _options; + _request; + _retries; + _onProcessEnd; + _onCustomMessage; + _stdout; + _stderr; + _memoryUsagePromise; + _resolveMemoryUsage; + _childWorkerPath; + _childIdleMemoryUsage; + _childIdleMemoryUsageLimit; + _memoryUsageCheck = false; + constructor(options) { + super(options); + this._options = options; + this._request = null; + this._stdout = null; + this._stderr = null; + this._childWorkerPath = + options.childWorkerPath || require.resolve('./threadChild'); + this._childIdleMemoryUsage = null; + this._childIdleMemoryUsageLimit = options.idleMemoryLimit || null; + this.initialize(); + } + initialize() { + if ( + this.state === _types.WorkerStates.OUT_OF_MEMORY || + this.state === _types.WorkerStates.SHUTTING_DOWN || + this.state === _types.WorkerStates.SHUT_DOWN + ) { + return; + } + if (this._worker) { + this._worker.terminate(); + } + this.state = _types.WorkerStates.STARTING; + this._worker = new (_worker_threads().Worker)(this._childWorkerPath, { + eval: false, + resourceLimits: this._options.resourceLimits, + stderr: true, + stdout: true, + workerData: this._options.workerData, + ...this._options.forkOptions + }); + if (this._worker.stdout) { + if (!this._stdout) { + // We need to add a permanent stream to the merged stream to prevent it + // from ending when the subprocess stream ends + this._stdout = (0, _mergeStream().default)(this._getFakeStream()); + } + this._stdout.add(this._worker.stdout); + } + if (this._worker.stderr) { + if (!this._stderr) { + // We need to add a permanent stream to the merged stream to prevent it + // from ending when the subprocess stream ends + this._stderr = (0, _mergeStream().default)(this._getFakeStream()); + } + this._stderr.add(this._worker.stderr); + } + + // This can be useful for debugging. + if (!(this._options.silent ?? true)) { + this._worker.stdout.setEncoding('utf8'); + // eslint-disable-next-line no-console + this._worker.stdout.on('data', console.log); + this._worker.stderr.setEncoding('utf8'); + this._worker.stderr.on('data', console.error); + } + this._worker.on('message', this._onMessage.bind(this)); + this._worker.on('exit', this._onExit.bind(this)); + this._worker.on('error', this._onError.bind(this)); + this._worker.postMessage([ + _types.CHILD_MESSAGE_INITIALIZE, + false, + this._options.workerPath, + this._options.setupArgs, + String(this._options.workerId + 1) // 0-indexed workerId, 1-indexed JEST_WORKER_ID + ]); + + this._retries++; + + // If we exceeded the amount of retries, we will emulate an error reply + // coming from the child. This avoids code duplication related with cleaning + // the queue, and scheduling the next call. + if (this._retries > this._options.maxRetries) { + const error = new Error('Call retries were exceeded'); + this._onMessage([ + _types.PARENT_MESSAGE_CLIENT_ERROR, + error.name, + error.message, + error.stack, + { + type: 'WorkerError' + } + ]); + } + this.state = _types.WorkerStates.OK; + if (this._resolveWorkerReady) { + this._resolveWorkerReady(); + } + } + _onError(error) { + if (error.message.includes('heap out of memory')) { + this.state = _types.WorkerStates.OUT_OF_MEMORY; + + // Threads don't behave like processes, they don't crash when they run out of + // memory. But for consistency we want them to behave like processes so we call + // terminate to simulate a crash happening that was not planned + this._worker.terminate(); + } + } + _onMessage(response) { + // Ignore messages not intended for us + if (!Array.isArray(response)) return; + let error; + switch (response[0]) { + case _types.PARENT_MESSAGE_OK: + this._onProcessEnd(null, response[1]); + break; + case _types.PARENT_MESSAGE_CLIENT_ERROR: + error = response[4]; + if (error != null && typeof error === 'object') { + const extra = error; + // @ts-expect-error: no index + const NativeCtor = globalThis[response[1]]; + const Ctor = typeof NativeCtor === 'function' ? NativeCtor : Error; + error = new Ctor(response[2]); + error.type = response[1]; + error.stack = response[3]; + for (const key in extra) { + // @ts-expect-error: no index + error[key] = extra[key]; + } + } + this._onProcessEnd(error, null); + break; + case _types.PARENT_MESSAGE_SETUP_ERROR: + error = new Error(`Error when calling setup: ${response[2]}`); + + // @ts-expect-error: adding custom properties to errors. + error.type = response[1]; + error.stack = response[3]; + this._onProcessEnd(error, null); + break; + case _types.PARENT_MESSAGE_CUSTOM: + this._onCustomMessage(response[1]); + break; + case _types.PARENT_MESSAGE_MEM_USAGE: + this._childIdleMemoryUsage = response[1]; + if (this._resolveMemoryUsage) { + this._resolveMemoryUsage(response[1]); + this._resolveMemoryUsage = undefined; + this._memoryUsagePromise = undefined; + } + this._performRestartIfRequired(); + break; + default: + // Ignore messages not intended for us + break; + } + } + _onExit(exitCode) { + this._workerReadyPromise = undefined; + this._resolveWorkerReady = undefined; + if (exitCode !== 0 && this.state === _types.WorkerStates.OUT_OF_MEMORY) { + this._onProcessEnd( + new Error('Jest worker ran out of memory and crashed'), + null + ); + this._shutdown(); + } else if ( + (exitCode !== 0 && + this.state !== _types.WorkerStates.SHUTTING_DOWN && + this.state !== _types.WorkerStates.SHUT_DOWN) || + this.state === _types.WorkerStates.RESTARTING + ) { + this.initialize(); + if (this._request) { + this._worker.postMessage(this._request); + } + } else { + // If the worker thread exits while a request is still pending, throw an + // error. This is unexpected and tests may not have run to completion. + const isRequestStillPending = !!this._request; + if (isRequestStillPending) { + this._onProcessEnd( + new Error( + 'A Jest worker thread exited unexpectedly before finishing tests for an unknown reason. One of the ways this can happen is if process.exit() was called in testing code.' + ), + null + ); + } + this._shutdown(); + } + } + waitForExit() { + return this._exitPromise; + } + forceExit() { + this.state = _types.WorkerStates.SHUTTING_DOWN; + this._worker.terminate(); + } + send(request, onProcessStart, onProcessEnd, onCustomMessage) { + onProcessStart(this); + this._onProcessEnd = (...args) => { + const hasRequest = !!this._request; + + // Clean the request to avoid sending past requests to workers that fail + // while waiting for a new request (timers, unhandled rejections...) + this._request = null; + if (this._childIdleMemoryUsageLimit && hasRequest) { + this.checkMemoryUsage(); + } + const res = onProcessEnd?.(...args); + + // Clean up the reference so related closures can be garbage collected. + onProcessEnd = null; + return res; + }; + this._onCustomMessage = (...arg) => onCustomMessage(...arg); + this._request = request; + this._retries = 0; + this._worker.postMessage(request); + } + getWorkerId() { + return this._options.workerId; + } + getStdout() { + return this._stdout; + } + getStderr() { + return this._stderr; + } + _performRestartIfRequired() { + if (this._memoryUsageCheck) { + this._memoryUsageCheck = false; + let limit = this._childIdleMemoryUsageLimit; + + // TODO: At some point it would make sense to make use of + // stringToBytes found in jest-config, however as this + // package does not have any dependencies on an other jest + // packages that can wait until some other time. + if (limit && limit > 0 && limit <= 1) { + limit = Math.floor((0, _os().totalmem)() * limit); + } else if (limit) { + limit = Math.floor(limit); + } + if ( + limit && + this._childIdleMemoryUsage && + this._childIdleMemoryUsage > limit + ) { + this.state = _types.WorkerStates.RESTARTING; + this._worker.terminate(); + } + } + } + + /** + * Gets the last reported memory usage. + * + * @returns Memory usage in bytes. + */ + getMemoryUsage() { + if (!this._memoryUsagePromise) { + let rejectCallback; + const promise = new Promise((resolve, reject) => { + this._resolveMemoryUsage = resolve; + rejectCallback = reject; + }); + this._memoryUsagePromise = promise; + if (!this._worker.threadId) { + rejectCallback(new Error('Child process is not running.')); + this._memoryUsagePromise = undefined; + this._resolveMemoryUsage = undefined; + return promise; + } + try { + this._worker.postMessage([_types.CHILD_MESSAGE_MEM_USAGE]); + } catch (err) { + this._memoryUsagePromise = undefined; + this._resolveMemoryUsage = undefined; + rejectCallback(err); + } + return promise; + } + return this._memoryUsagePromise; + } + + /** + * Gets updated memory usage and restarts if required + */ + checkMemoryUsage() { + if (this._childIdleMemoryUsageLimit) { + this._memoryUsageCheck = true; + this._worker.postMessage([_types.CHILD_MESSAGE_MEM_USAGE]); + } else { + console.warn( + 'Memory usage of workers can only be checked if a limit is set' + ); + } + } + + /** + * Gets the thread id of the worker. + * + * @returns Thread id. + */ + getWorkerSystemId() { + return this._worker.threadId; + } + isWorkerRunning() { + return this._worker.threadId >= 0; + } +} +exports.default = ExperimentalWorker; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/workers/WorkerAbstract.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/workers/WorkerAbstract.js new file mode 100644 index 0000000000000000000000000000000000000000..1bd32f52a215464659b169d6839329324bfc8cd3 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/workers/WorkerAbstract.js @@ -0,0 +1,135 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _stream() { + const data = require('stream'); + _stream = function () { + return data; + }; + return data; +} +var _types = require('../types'); +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class WorkerAbstract extends _stream().EventEmitter { + /** + * DO NOT WRITE TO THIS DIRECTLY. + * Use this.state getter/setters so events are emitted correctly. + */ + #state = _types.WorkerStates.STARTING; + _fakeStream = null; + _exitPromise; + _resolveExitPromise; + _workerReadyPromise; + _resolveWorkerReady; + get state() { + return this.#state; + } + set state(value) { + if (this.#state !== value) { + const oldState = this.#state; + this.#state = value; + this.emit(_types.WorkerEvents.STATE_CHANGE, value, oldState); + } + } + constructor(options) { + super(); + if (typeof options.on === 'object') { + for (const [event, handlers] of Object.entries(options.on)) { + // Can't do Array.isArray on a ReadonlyArray. + // https://github.com/microsoft/TypeScript/issues/17002 + if (typeof handlers === 'function') { + super.on(event, handlers); + } else { + for (const handler of handlers) { + super.on(event, handler); + } + } + } + } + this._exitPromise = new Promise(resolve => { + this._resolveExitPromise = resolve; + }); + this._exitPromise.then(() => { + this.state = _types.WorkerStates.SHUT_DOWN; + }); + } + + /** + * Wait for the worker child process to be ready to handle requests. + * + * @returns Promise which resolves when ready. + */ + waitForWorkerReady() { + if (!this._workerReadyPromise) { + this._workerReadyPromise = new Promise((resolve, reject) => { + let settled = false; + let to; + switch (this.state) { + case _types.WorkerStates.OUT_OF_MEMORY: + case _types.WorkerStates.SHUTTING_DOWN: + case _types.WorkerStates.SHUT_DOWN: + settled = true; + reject( + new Error( + `Worker state means it will never be ready: ${this.state}` + ) + ); + break; + case _types.WorkerStates.STARTING: + case _types.WorkerStates.RESTARTING: + this._resolveWorkerReady = () => { + settled = true; + resolve(); + if (to) { + clearTimeout(to); + } + }; + break; + case _types.WorkerStates.OK: + settled = true; + resolve(); + break; + } + if (!settled) { + to = setTimeout(() => { + if (!settled) { + reject(new Error('Timeout starting worker')); + } + }, 500); + } + }); + } + return this._workerReadyPromise; + } + + /** + * Used to shut down the current working instance once the children have been + * killed off. + */ + _shutdown() { + this.state === _types.WorkerStates.SHUT_DOWN; + + // End the permanent stream so the merged stream end too + if (this._fakeStream) { + this._fakeStream.end(); + this._fakeStream = null; + } + this._resolveExitPromise(); + } + _getFakeStream() { + if (!this._fakeStream) { + this._fakeStream = new (_stream().PassThrough)(); + } + return this._fakeStream; + } +} +exports.default = WorkerAbstract; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/workers/messageParent.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/workers/messageParent.js new file mode 100644 index 0000000000000000000000000000000000000000..62e2ccec5716b6909dbb9a41081d4f9a7dcd364f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/workers/messageParent.js @@ -0,0 +1,33 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = messageParent; +function _worker_threads() { + const data = require('worker_threads'); + _worker_threads = function () { + return data; + }; + return data; +} +var _types = require('../types'); +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function messageParent(message, parentProcess = process) { + if (!_worker_threads().isMainThread && _worker_threads().parentPort != null) { + _worker_threads().parentPort.postMessage([ + _types.PARENT_MESSAGE_CUSTOM, + message + ]); + } else if (typeof parentProcess.send === 'function') { + parentProcess.send([_types.PARENT_MESSAGE_CUSTOM, message]); + } else { + throw new Error('"messageParent" can only be used inside a worker'); + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/workers/processChild.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/workers/processChild.js new file mode 100644 index 0000000000000000000000000000000000000000..1a47f23c1b4fe56a3504d25e99514ed4218ae7a2 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/workers/processChild.js @@ -0,0 +1,159 @@ +'use strict'; + +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +var _types = require('../types'); +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +let file = null; +let setupArgs = []; +let initialized = false; + +/** + * This file is a small bootstrapper for workers. It sets up the communication + * between the worker and the parent process, interpreting parent messages and + * sending results back. + * + * The file loaded will be lazily initialized the first time any of the workers + * is called. This is done for optimal performance: if the farm is initialized, + * but no call is made to it, child Node processes will be consuming the least + * possible amount of memory. + * + * If an invalid message is detected, the child will exit (by throwing) with a + * non-zero exit code. + */ +const messageListener = request => { + switch (request[0]) { + case _types.CHILD_MESSAGE_INITIALIZE: + const init = request; + file = init[2]; + setupArgs = init[3]; + break; + case _types.CHILD_MESSAGE_CALL: + const call = request; + execMethod(call[2], call[3]); + break; + case _types.CHILD_MESSAGE_END: + end(); + break; + case _types.CHILD_MESSAGE_MEM_USAGE: + reportMemoryUsage(); + break; + case _types.CHILD_MESSAGE_CALL_SETUP: + if (initialized) { + reportSuccess(void 0); + } else { + const main = require(file); + initialized = true; + if (main.setup) { + execFunction( + main.setup, + main, + setupArgs, + reportSuccess, + reportInitializeError + ); + } else { + reportSuccess(void 0); + } + } + break; + default: + throw new TypeError( + `Unexpected request from parent process: ${request[0]}` + ); + } +}; +process.on('message', messageListener); +function reportSuccess(result) { + if (!process || !process.send) { + throw new Error('Child can only be used on a forked process'); + } + process.send([_types.PARENT_MESSAGE_OK, result]); +} +function reportClientError(error) { + return reportError(error, _types.PARENT_MESSAGE_CLIENT_ERROR); +} +function reportInitializeError(error) { + return reportError(error, _types.PARENT_MESSAGE_SETUP_ERROR); +} +function reportMemoryUsage() { + if (!process || !process.send) { + throw new Error('Child can only be used on a forked process'); + } + const msg = [_types.PARENT_MESSAGE_MEM_USAGE, process.memoryUsage().heapUsed]; + process.send(msg); +} +function reportError(error, type) { + if (!process || !process.send) { + throw new Error('Child can only be used on a forked process'); + } + if (error == null) { + error = new Error('"null" or "undefined" thrown'); + } + process.send([ + type, + error.constructor && error.constructor.name, + error.message, + error.stack, + typeof error === 'object' + ? { + ...error + } + : error + ]); +} +function end() { + const main = require(file); + if (!main.teardown) { + exitProcess(); + return; + } + execFunction(main.teardown, main, [], exitProcess, exitProcess); +} +function exitProcess() { + // Clean up open handles so the process ideally exits gracefully + process.removeListener('message', messageListener); +} +function execMethod(method, args) { + const main = require(file); + let fn; + if (method === 'default') { + fn = main.__esModule ? main.default : main; + } else { + fn = main[method]; + } + function execHelper() { + execFunction(fn, main, args, reportSuccess, reportClientError); + } + if (initialized || !main.setup) { + execHelper(); + return; + } + initialized = true; + execFunction(main.setup, main, setupArgs, execHelper, reportInitializeError); +} +function execFunction(fn, ctx, args, onResult, onError) { + let result; + try { + result = fn.apply(ctx, args); + } catch (err) { + onError(err); + return; + } + if ((0, _jestUtil().isPromise)(result)) { + result.then(onResult, onError); + } else { + onResult(result); + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/workers/threadChild.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/workers/threadChild.js new file mode 100644 index 0000000000000000000000000000000000000000..16aca004efd020a1456354299a3a606cdf0e4bc7 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/build/workers/threadChild.js @@ -0,0 +1,177 @@ +'use strict'; + +function _worker_threads() { + const data = require('worker_threads'); + _worker_threads = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +var _types = require('../types'); +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +let file = null; +let setupArgs = []; +let initialized = false; + +/** + * This file is a small bootstrapper for workers. It sets up the communication + * between the worker and the parent process, interpreting parent messages and + * sending results back. + * + * The file loaded will be lazily initialized the first time any of the workers + * is called. This is done for optimal performance: if the farm is initialized, + * but no call is made to it, child Node processes will be consuming the least + * possible amount of memory. + * + * If an invalid message is detected, the child will exit (by throwing) with a + * non-zero exit code. + */ +const messageListener = request => { + switch (request[0]) { + case _types.CHILD_MESSAGE_INITIALIZE: + const init = request; + file = init[2]; + setupArgs = init[3]; + process.env.JEST_WORKER_ID = init[4]; + break; + case _types.CHILD_MESSAGE_CALL: + const call = request; + execMethod(call[2], call[3]); + break; + case _types.CHILD_MESSAGE_END: + end(); + break; + case _types.CHILD_MESSAGE_MEM_USAGE: + reportMemoryUsage(); + break; + case _types.CHILD_MESSAGE_CALL_SETUP: + if (initialized) { + reportSuccess(void 0); + } else { + const main = require(file); + initialized = true; + if (main.setup) { + execFunction( + main.setup, + main, + setupArgs, + reportSuccess, + reportInitializeError + ); + } else { + reportSuccess(void 0); + } + } + break; + default: + throw new TypeError( + `Unexpected request from parent process: ${request[0]}` + ); + } +}; +_worker_threads().parentPort.on('message', messageListener); +function reportMemoryUsage() { + if (_worker_threads().isMainThread) { + throw new Error('Child can only be used on a forked process'); + } + const msg = [_types.PARENT_MESSAGE_MEM_USAGE, process.memoryUsage().heapUsed]; + _worker_threads().parentPort.postMessage(msg); +} +function reportSuccess(result) { + if (_worker_threads().isMainThread) { + throw new Error('Child can only be used on a forked process'); + } + try { + _worker_threads().parentPort.postMessage([ + _types.PARENT_MESSAGE_OK, + result + ]); + } catch (err) { + // Handling it here to avoid unhandled `DataCloneError` rejection + // which is hard to distinguish on the parent side + // (such error doesn't have any message or stack trace) + reportClientError(err); + } +} +function reportClientError(error) { + return reportError(error, _types.PARENT_MESSAGE_CLIENT_ERROR); +} +function reportInitializeError(error) { + return reportError(error, _types.PARENT_MESSAGE_SETUP_ERROR); +} +function reportError(error, type) { + if (_worker_threads().isMainThread) { + throw new Error('Child can only be used on a forked process'); + } + if (error == null) { + error = new Error('"null" or "undefined" thrown'); + } + _worker_threads().parentPort.postMessage([ + type, + error.constructor && error.constructor.name, + error.message, + error.stack, + typeof error === 'object' + ? { + ...error + } + : error + ]); +} +function end() { + const main = require(file); + if (!main.teardown) { + exitProcess(); + return; + } + execFunction(main.teardown, main, [], exitProcess, exitProcess); +} +function exitProcess() { + // Clean up open handles so the worker ideally exits gracefully + _worker_threads().parentPort.removeListener('message', messageListener); +} +function execMethod(method, args) { + const main = require(file); + let fn; + if (method === 'default') { + fn = main.__esModule ? main.default : main; + } else { + fn = main[method]; + } + function execHelper() { + execFunction(fn, main, args, reportSuccess, reportClientError); + } + if (initialized || !main.setup) { + execHelper(); + return; + } + initialized = true; + execFunction(main.setup, main, setupArgs, execHelper, reportInitializeError); +} +function execFunction(fn, ctx, args, onResult, onError) { + let result; + try { + result = fn.apply(ctx, args); + } catch (err) { + onError(err); + return; + } + if ((0, _jestUtil().isPromise)(result)) { + result.then(onResult, onError); + } else { + onResult(result); + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/package.json new file mode 100644 index 0000000000000000000000000000000000000000..6975f97288e35f38ad274485dd358e4d04f4ba9f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/jest-worker/package.json @@ -0,0 +1,42 @@ +{ + "name": "jest-worker", + "version": "29.7.0", + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/jest-worker" + }, + "license": "MIT", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "dependencies": { + "@types/node": "*", + "jest-util": "^29.7.0", + "merge-stream": "^2.0.0", + "supports-color": "^8.0.0" + }, + "devDependencies": { + "@babel/core": "^7.11.6", + "@tsd/typescript": "^5.0.4", + "@types/merge-stream": "^1.1.2", + "@types/supports-color": "^8.1.0", + "get-stream": "^6.0.0", + "jest-leak-detector": "^29.7.0", + "tsd-lite": "^0.7.0", + "worker-farm": "^1.6.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "publishConfig": { + "access": "public" + }, + "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/semver/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/semver/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..19129e315fe593965a2fdd50ec0d1253bcbd2ece --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/semver/LICENSE @@ -0,0 +1,15 @@ +The ISC License + +Copyright (c) Isaac Z. Schlueter and Contributors + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +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. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/semver/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/semver/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2293a14fdc3579558dbe9fbc50aa549657948c3e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/semver/README.md @@ -0,0 +1,443 @@ +semver(1) -- The semantic versioner for npm +=========================================== + +## Install + +```bash +npm install semver +```` + +## Usage + +As a node module: + +```js +const semver = require('semver') + +semver.valid('1.2.3') // '1.2.3' +semver.valid('a.b.c') // null +semver.clean(' =v1.2.3 ') // '1.2.3' +semver.satisfies('1.2.3', '1.x || >=2.5.0 || 5.0.0 - 7.2.3') // true +semver.gt('1.2.3', '9.8.7') // false +semver.lt('1.2.3', '9.8.7') // true +semver.minVersion('>=1.0.0') // '1.0.0' +semver.valid(semver.coerce('v2')) // '2.0.0' +semver.valid(semver.coerce('42.6.7.9.3-alpha')) // '42.6.7' +``` + +As a command-line utility: + +``` +$ semver -h + +A JavaScript implementation of the https://semver.org/ specification +Copyright Isaac Z. Schlueter + +Usage: semver [options] [ [...]] +Prints valid versions sorted by SemVer precedence + +Options: +-r --range + Print versions that match the specified range. + +-i --increment [] + Increment a version by the specified level. Level can + be one of: major, minor, patch, premajor, preminor, + prepatch, or prerelease. Default level is 'patch'. + Only one version may be specified. + +--preid + Identifier to be used to prefix premajor, preminor, + prepatch or prerelease version increments. + +-l --loose + Interpret versions and ranges loosely + +-p --include-prerelease + Always include prerelease versions in range matching + +-c --coerce + Coerce a string into SemVer if possible + (does not imply --loose) + +--rtl + Coerce version strings right to left + +--ltr + Coerce version strings left to right (default) + +Program exits successfully if any valid version satisfies +all supplied ranges, and prints all satisfying versions. + +If no satisfying versions are found, then exits failure. + +Versions are printed in ascending order, so supplying +multiple versions to the utility will just sort them. +``` + +## Versions + +A "version" is described by the `v2.0.0` specification found at +. + +A leading `"="` or `"v"` character is stripped off and ignored. + +## Ranges + +A `version range` is a set of `comparators` which specify versions +that satisfy the range. + +A `comparator` is composed of an `operator` and a `version`. The set +of primitive `operators` is: + +* `<` Less than +* `<=` Less than or equal to +* `>` Greater than +* `>=` Greater than or equal to +* `=` Equal. If no operator is specified, then equality is assumed, + so this operator is optional, but MAY be included. + +For example, the comparator `>=1.2.7` would match the versions +`1.2.7`, `1.2.8`, `2.5.3`, and `1.3.9`, but not the versions `1.2.6` +or `1.1.0`. + +Comparators can be joined by whitespace to form a `comparator set`, +which is satisfied by the **intersection** of all of the comparators +it includes. + +A range is composed of one or more comparator sets, joined by `||`. A +version matches a range if and only if every comparator in at least +one of the `||`-separated comparator sets is satisfied by the version. + +For example, the range `>=1.2.7 <1.3.0` would match the versions +`1.2.7`, `1.2.8`, and `1.2.99`, but not the versions `1.2.6`, `1.3.0`, +or `1.1.0`. + +The range `1.2.7 || >=1.2.9 <2.0.0` would match the versions `1.2.7`, +`1.2.9`, and `1.4.6`, but not the versions `1.2.8` or `2.0.0`. + +### Prerelease Tags + +If a version has a prerelease tag (for example, `1.2.3-alpha.3`) then +it will only be allowed to satisfy comparator sets if at least one +comparator with the same `[major, minor, patch]` tuple also has a +prerelease tag. + +For example, the range `>1.2.3-alpha.3` would be allowed to match the +version `1.2.3-alpha.7`, but it would *not* be satisfied by +`3.4.5-alpha.9`, even though `3.4.5-alpha.9` is technically "greater +than" `1.2.3-alpha.3` according to the SemVer sort rules. The version +range only accepts prerelease tags on the `1.2.3` version. The +version `3.4.5` *would* satisfy the range, because it does not have a +prerelease flag, and `3.4.5` is greater than `1.2.3-alpha.7`. + +The purpose for this behavior is twofold. First, prerelease versions +frequently are updated very quickly, and contain many breaking changes +that are (by the author's design) not yet fit for public consumption. +Therefore, by default, they are excluded from range matching +semantics. + +Second, a user who has opted into using a prerelease version has +clearly indicated the intent to use *that specific* set of +alpha/beta/rc versions. By including a prerelease tag in the range, +the user is indicating that they are aware of the risk. However, it +is still not appropriate to assume that they have opted into taking a +similar risk on the *next* set of prerelease versions. + +Note that this behavior can be suppressed (treating all prerelease +versions as if they were normal versions, for the purpose of range +matching) by setting the `includePrerelease` flag on the options +object to any +[functions](https://github.com/npm/node-semver#functions) that do +range matching. + +#### Prerelease Identifiers + +The method `.inc` takes an additional `identifier` string argument that +will append the value of the string as a prerelease identifier: + +```javascript +semver.inc('1.2.3', 'prerelease', 'beta') +// '1.2.4-beta.0' +``` + +command-line example: + +```bash +$ semver 1.2.3 -i prerelease --preid beta +1.2.4-beta.0 +``` + +Which then can be used to increment further: + +```bash +$ semver 1.2.4-beta.0 -i prerelease +1.2.4-beta.1 +``` + +### Advanced Range Syntax + +Advanced range syntax desugars to primitive comparators in +deterministic ways. + +Advanced ranges may be combined in the same way as primitive +comparators using white space or `||`. + +#### Hyphen Ranges `X.Y.Z - A.B.C` + +Specifies an inclusive set. + +* `1.2.3 - 2.3.4` := `>=1.2.3 <=2.3.4` + +If a partial version is provided as the first version in the inclusive +range, then the missing pieces are replaced with zeroes. + +* `1.2 - 2.3.4` := `>=1.2.0 <=2.3.4` + +If a partial version is provided as the second version in the +inclusive range, then all versions that start with the supplied parts +of the tuple are accepted, but nothing that would be greater than the +provided tuple parts. + +* `1.2.3 - 2.3` := `>=1.2.3 <2.4.0` +* `1.2.3 - 2` := `>=1.2.3 <3.0.0` + +#### X-Ranges `1.2.x` `1.X` `1.2.*` `*` + +Any of `X`, `x`, or `*` may be used to "stand in" for one of the +numeric values in the `[major, minor, patch]` tuple. + +* `*` := `>=0.0.0` (Any version satisfies) +* `1.x` := `>=1.0.0 <2.0.0` (Matching major version) +* `1.2.x` := `>=1.2.0 <1.3.0` (Matching major and minor versions) + +A partial version range is treated as an X-Range, so the special +character is in fact optional. + +* `""` (empty string) := `*` := `>=0.0.0` +* `1` := `1.x.x` := `>=1.0.0 <2.0.0` +* `1.2` := `1.2.x` := `>=1.2.0 <1.3.0` + +#### Tilde Ranges `~1.2.3` `~1.2` `~1` + +Allows patch-level changes if a minor version is specified on the +comparator. Allows minor-level changes if not. + +* `~1.2.3` := `>=1.2.3 <1.(2+1).0` := `>=1.2.3 <1.3.0` +* `~1.2` := `>=1.2.0 <1.(2+1).0` := `>=1.2.0 <1.3.0` (Same as `1.2.x`) +* `~1` := `>=1.0.0 <(1+1).0.0` := `>=1.0.0 <2.0.0` (Same as `1.x`) +* `~0.2.3` := `>=0.2.3 <0.(2+1).0` := `>=0.2.3 <0.3.0` +* `~0.2` := `>=0.2.0 <0.(2+1).0` := `>=0.2.0 <0.3.0` (Same as `0.2.x`) +* `~0` := `>=0.0.0 <(0+1).0.0` := `>=0.0.0 <1.0.0` (Same as `0.x`) +* `~1.2.3-beta.2` := `>=1.2.3-beta.2 <1.3.0` Note that prereleases in + the `1.2.3` version will be allowed, if they are greater than or + equal to `beta.2`. So, `1.2.3-beta.4` would be allowed, but + `1.2.4-beta.2` would not, because it is a prerelease of a + different `[major, minor, patch]` tuple. + +#### Caret Ranges `^1.2.3` `^0.2.5` `^0.0.4` + +Allows changes that do not modify the left-most non-zero element in the +`[major, minor, patch]` tuple. In other words, this allows patch and +minor updates for versions `1.0.0` and above, patch updates for +versions `0.X >=0.1.0`, and *no* updates for versions `0.0.X`. + +Many authors treat a `0.x` version as if the `x` were the major +"breaking-change" indicator. + +Caret ranges are ideal when an author may make breaking changes +between `0.2.4` and `0.3.0` releases, which is a common practice. +However, it presumes that there will *not* be breaking changes between +`0.2.4` and `0.2.5`. It allows for changes that are presumed to be +additive (but non-breaking), according to commonly observed practices. + +* `^1.2.3` := `>=1.2.3 <2.0.0` +* `^0.2.3` := `>=0.2.3 <0.3.0` +* `^0.0.3` := `>=0.0.3 <0.0.4` +* `^1.2.3-beta.2` := `>=1.2.3-beta.2 <2.0.0` Note that prereleases in + the `1.2.3` version will be allowed, if they are greater than or + equal to `beta.2`. So, `1.2.3-beta.4` would be allowed, but + `1.2.4-beta.2` would not, because it is a prerelease of a + different `[major, minor, patch]` tuple. +* `^0.0.3-beta` := `>=0.0.3-beta <0.0.4` Note that prereleases in the + `0.0.3` version *only* will be allowed, if they are greater than or + equal to `beta`. So, `0.0.3-pr.2` would be allowed. + +When parsing caret ranges, a missing `patch` value desugars to the +number `0`, but will allow flexibility within that value, even if the +major and minor versions are both `0`. + +* `^1.2.x` := `>=1.2.0 <2.0.0` +* `^0.0.x` := `>=0.0.0 <0.1.0` +* `^0.0` := `>=0.0.0 <0.1.0` + +A missing `minor` and `patch` values will desugar to zero, but also +allow flexibility within those values, even if the major version is +zero. + +* `^1.x` := `>=1.0.0 <2.0.0` +* `^0.x` := `>=0.0.0 <1.0.0` + +### Range Grammar + +Putting all this together, here is a Backus-Naur grammar for ranges, +for the benefit of parser authors: + +```bnf +range-set ::= range ( logical-or range ) * +logical-or ::= ( ' ' ) * '||' ( ' ' ) * +range ::= hyphen | simple ( ' ' simple ) * | '' +hyphen ::= partial ' - ' partial +simple ::= primitive | partial | tilde | caret +primitive ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial +partial ::= xr ( '.' xr ( '.' xr qualifier ? )? )? +xr ::= 'x' | 'X' | '*' | nr +nr ::= '0' | ['1'-'9'] ( ['0'-'9'] ) * +tilde ::= '~' partial +caret ::= '^' partial +qualifier ::= ( '-' pre )? ( '+' build )? +pre ::= parts +build ::= parts +parts ::= part ( '.' part ) * +part ::= nr | [-0-9A-Za-z]+ +``` + +## Functions + +All methods and classes take a final `options` object argument. All +options in this object are `false` by default. The options supported +are: + +- `loose` Be more forgiving about not-quite-valid semver strings. + (Any resulting output will always be 100% strict compliant, of + course.) For backwards compatibility reasons, if the `options` + argument is a boolean value instead of an object, it is interpreted + to be the `loose` param. +- `includePrerelease` Set to suppress the [default + behavior](https://github.com/npm/node-semver#prerelease-tags) of + excluding prerelease tagged versions from ranges unless they are + explicitly opted into. + +Strict-mode Comparators and Ranges will be strict about the SemVer +strings that they parse. + +* `valid(v)`: Return the parsed version, or null if it's not valid. +* `inc(v, release)`: Return the version incremented by the release + type (`major`, `premajor`, `minor`, `preminor`, `patch`, + `prepatch`, or `prerelease`), or null if it's not valid + * `premajor` in one call will bump the version up to the next major + version and down to a prerelease of that major version. + `preminor`, and `prepatch` work the same way. + * If called from a non-prerelease version, the `prerelease` will work the + same as `prepatch`. It increments the patch version, then makes a + prerelease. If the input version is already a prerelease it simply + increments it. +* `prerelease(v)`: Returns an array of prerelease components, or null + if none exist. Example: `prerelease('1.2.3-alpha.1') -> ['alpha', 1]` +* `major(v)`: Return the major version number. +* `minor(v)`: Return the minor version number. +* `patch(v)`: Return the patch version number. +* `intersects(r1, r2, loose)`: Return true if the two supplied ranges + or comparators intersect. +* `parse(v)`: Attempt to parse a string as a semantic version, returning either + a `SemVer` object or `null`. + +### Comparison + +* `gt(v1, v2)`: `v1 > v2` +* `gte(v1, v2)`: `v1 >= v2` +* `lt(v1, v2)`: `v1 < v2` +* `lte(v1, v2)`: `v1 <= v2` +* `eq(v1, v2)`: `v1 == v2` This is true if they're logically equivalent, + even if they're not the exact same string. You already know how to + compare strings. +* `neq(v1, v2)`: `v1 != v2` The opposite of `eq`. +* `cmp(v1, comparator, v2)`: Pass in a comparison string, and it'll call + the corresponding function above. `"==="` and `"!=="` do simple + string comparison, but are included for completeness. Throws if an + invalid comparison string is provided. +* `compare(v1, v2)`: Return `0` if `v1 == v2`, or `1` if `v1` is greater, or `-1` if + `v2` is greater. Sorts in ascending order if passed to `Array.sort()`. +* `rcompare(v1, v2)`: The reverse of compare. Sorts an array of versions + in descending order when passed to `Array.sort()`. +* `compareBuild(v1, v2)`: The same as `compare` but considers `build` when two versions + are equal. Sorts in ascending order if passed to `Array.sort()`. + `v2` is greater. Sorts in ascending order if passed to `Array.sort()`. +* `diff(v1, v2)`: Returns difference between two versions by the release type + (`major`, `premajor`, `minor`, `preminor`, `patch`, `prepatch`, or `prerelease`), + or null if the versions are the same. + +### Comparators + +* `intersects(comparator)`: Return true if the comparators intersect + +### Ranges + +* `validRange(range)`: Return the valid range or null if it's not valid +* `satisfies(version, range)`: Return true if the version satisfies the + range. +* `maxSatisfying(versions, range)`: Return the highest version in the list + that satisfies the range, or `null` if none of them do. +* `minSatisfying(versions, range)`: Return the lowest version in the list + that satisfies the range, or `null` if none of them do. +* `minVersion(range)`: Return the lowest version that can possibly match + the given range. +* `gtr(version, range)`: Return `true` if version is greater than all the + versions possible in the range. +* `ltr(version, range)`: Return `true` if version is less than all the + versions possible in the range. +* `outside(version, range, hilo)`: Return true if the version is outside + the bounds of the range in either the high or low direction. The + `hilo` argument must be either the string `'>'` or `'<'`. (This is + the function called by `gtr` and `ltr`.) +* `intersects(range)`: Return true if any of the ranges comparators intersect + +Note that, since ranges may be non-contiguous, a version might not be +greater than a range, less than a range, *or* satisfy a range! For +example, the range `1.2 <1.2.9 || >2.0.0` would have a hole from `1.2.9` +until `2.0.0`, so the version `1.2.10` would not be greater than the +range (because `2.0.1` satisfies, which is higher), nor less than the +range (since `1.2.8` satisfies, which is lower), and it also does not +satisfy the range. + +If you want to know if a version satisfies or does not satisfy a +range, use the `satisfies(version, range)` function. + +### Coercion + +* `coerce(version, options)`: Coerces a string to semver if possible + +This aims to provide a very forgiving translation of a non-semver string to +semver. It looks for the first digit in a string, and consumes all +remaining characters which satisfy at least a partial semver (e.g., `1`, +`1.2`, `1.2.3`) up to the max permitted length (256 characters). Longer +versions are simply truncated (`4.6.3.9.2-alpha2` becomes `4.6.3`). All +surrounding text is simply ignored (`v3.4 replaces v3.3.1` becomes +`3.4.0`). Only text which lacks digits will fail coercion (`version one` +is not valid). The maximum length for any semver component considered for +coercion is 16 characters; longer components will be ignored +(`10000000000000000.4.7.4` becomes `4.7.4`). The maximum value for any +semver component is `Integer.MAX_SAFE_INTEGER || (2**53 - 1)`; higher value +components are invalid (`9999999999999999.4.7.4` is likely invalid). + +If the `options.rtl` flag is set, then `coerce` will return the right-most +coercible tuple that does not share an ending index with a longer coercible +tuple. For example, `1.2.3.4` will return `2.3.4` in rtl mode, not +`4.0.0`. `1.2.3/4` will return `4.0.0`, because the `4` is not a part of +any other overlapping SemVer tuple. + +### Clean + +* `clean(version)`: Clean a string to be a valid semver if possible + +This will return a cleaned and trimmed semver version. If the provided version is not valid a null will be returned. This does not work for ranges. + +ex. +* `s.clean(' = v 2.1.5foo')`: `null` +* `s.clean(' = v 2.1.5foo', { loose: true })`: `'2.1.5-foo'` +* `s.clean(' = v 2.1.5-foo')`: `null` +* `s.clean(' = v 2.1.5-foo', { loose: true })`: `'2.1.5-foo'` +* `s.clean('=v2.1.5')`: `'2.1.5'` +* `s.clean(' =v2.1.5')`: `2.1.5` +* `s.clean(' 2.1.5 ')`: `'2.1.5'` +* `s.clean('~1.0.0')`: `null` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/semver/bin/semver.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/semver/bin/semver.js new file mode 100644 index 0000000000000000000000000000000000000000..666034a75d8442be9bb2d9c55c3909b55a093cb5 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/semver/bin/semver.js @@ -0,0 +1,174 @@ +#!/usr/bin/env node +// Standalone semver comparison program. +// Exits successfully and prints matching version(s) if +// any supplied version is valid and passes all tests. + +var argv = process.argv.slice(2) + +var versions = [] + +var range = [] + +var inc = null + +var version = require('../package.json').version + +var loose = false + +var includePrerelease = false + +var coerce = false + +var rtl = false + +var identifier + +var semver = require('../semver') + +var reverse = false + +var options = {} + +main() + +function main () { + if (!argv.length) return help() + while (argv.length) { + var a = argv.shift() + var indexOfEqualSign = a.indexOf('=') + if (indexOfEqualSign !== -1) { + a = a.slice(0, indexOfEqualSign) + argv.unshift(a.slice(indexOfEqualSign + 1)) + } + switch (a) { + case '-rv': case '-rev': case '--rev': case '--reverse': + reverse = true + break + case '-l': case '--loose': + loose = true + break + case '-p': case '--include-prerelease': + includePrerelease = true + break + case '-v': case '--version': + versions.push(argv.shift()) + break + case '-i': case '--inc': case '--increment': + switch (argv[0]) { + case 'major': case 'minor': case 'patch': case 'prerelease': + case 'premajor': case 'preminor': case 'prepatch': + inc = argv.shift() + break + default: + inc = 'patch' + break + } + break + case '--preid': + identifier = argv.shift() + break + case '-r': case '--range': + range.push(argv.shift()) + break + case '-c': case '--coerce': + coerce = true + break + case '--rtl': + rtl = true + break + case '--ltr': + rtl = false + break + case '-h': case '--help': case '-?': + return help() + default: + versions.push(a) + break + } + } + + var options = { loose: loose, includePrerelease: includePrerelease, rtl: rtl } + + versions = versions.map(function (v) { + return coerce ? (semver.coerce(v, options) || { version: v }).version : v + }).filter(function (v) { + return semver.valid(v) + }) + if (!versions.length) return fail() + if (inc && (versions.length !== 1 || range.length)) { return failInc() } + + for (var i = 0, l = range.length; i < l; i++) { + versions = versions.filter(function (v) { + return semver.satisfies(v, range[i], options) + }) + if (!versions.length) return fail() + } + return success(versions) +} + +function failInc () { + console.error('--inc can only be used on a single version with no range') + fail() +} + +function fail () { process.exit(1) } + +function success () { + var compare = reverse ? 'rcompare' : 'compare' + versions.sort(function (a, b) { + return semver[compare](a, b, options) + }).map(function (v) { + return semver.clean(v, options) + }).map(function (v) { + return inc ? semver.inc(v, inc, options, identifier) : v + }).forEach(function (v, i, _) { console.log(v) }) +} + +function help () { + console.log(['SemVer ' + version, + '', + 'A JavaScript implementation of the https://semver.org/ specification', + 'Copyright Isaac Z. Schlueter', + '', + 'Usage: semver [options] [ [...]]', + 'Prints valid versions sorted by SemVer precedence', + '', + 'Options:', + '-r --range ', + ' Print versions that match the specified range.', + '', + '-i --increment []', + ' Increment a version by the specified level. Level can', + ' be one of: major, minor, patch, premajor, preminor,', + " prepatch, or prerelease. Default level is 'patch'.", + ' Only one version may be specified.', + '', + '--preid ', + ' Identifier to be used to prefix premajor, preminor,', + ' prepatch or prerelease version increments.', + '', + '-l --loose', + ' Interpret versions and ranges loosely', + '', + '-p --include-prerelease', + ' Always include prerelease versions in range matching', + '', + '-c --coerce', + ' Coerce a string into SemVer if possible', + ' (does not imply --loose)', + '', + '--rtl', + ' Coerce version strings right to left', + '', + '--ltr', + ' Coerce version strings left to right (default)', + '', + 'Program exits successfully if any valid version satisfies', + 'all supplied ranges, and prints all satisfying versions.', + '', + 'If no satisfying versions are found, then exits failure.', + '', + 'Versions are printed in ascending order, so supplying', + 'multiple versions to the utility will just sort them.' + ].join('\n')) +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/semver/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/semver/package.json new file mode 100644 index 0000000000000000000000000000000000000000..6b970a629ffe81d300d6b0469fa9b1992ca24c8e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/semver/package.json @@ -0,0 +1,38 @@ +{ + "name": "semver", + "version": "6.3.1", + "description": "The semantic version parser used by npm.", + "main": "semver.js", + "scripts": { + "test": "tap test/ --100 --timeout=30", + "lint": "echo linting disabled", + "postlint": "template-oss-check", + "template-oss-apply": "template-oss-apply --force", + "lintfix": "npm run lint -- --fix", + "snap": "tap test/ --100 --timeout=30", + "posttest": "npm run lint" + }, + "devDependencies": { + "@npmcli/template-oss": "4.17.0", + "tap": "^12.7.0" + }, + "license": "ISC", + "repository": { + "type": "git", + "url": "https://github.com/npm/node-semver.git" + }, + "bin": { + "semver": "./bin/semver.js" + }, + "files": [ + "bin", + "range.bnf", + "semver.js" + ], + "author": "GitHub Inc.", + "templateOSS": { + "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.", + "content": "./scripts/template-oss", + "version": "4.17.0" + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/semver/range.bnf b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/semver/range.bnf new file mode 100644 index 0000000000000000000000000000000000000000..d4c6ae0d76c9ac0c10c93062e5ff9cec277b07cd --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/semver/range.bnf @@ -0,0 +1,16 @@ +range-set ::= range ( logical-or range ) * +logical-or ::= ( ' ' ) * '||' ( ' ' ) * +range ::= hyphen | simple ( ' ' simple ) * | '' +hyphen ::= partial ' - ' partial +simple ::= primitive | partial | tilde | caret +primitive ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial +partial ::= xr ( '.' xr ( '.' xr qualifier ? )? )? +xr ::= 'x' | 'X' | '*' | nr +nr ::= '0' | [1-9] ( [0-9] ) * +tilde ::= '~' partial +caret ::= '^' partial +qualifier ::= ( '-' pre )? ( '+' build )? +pre ::= parts +build ::= parts +parts ::= part ( '.' part ) * +part ::= nr | [-0-9A-Za-z]+ diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/semver/semver.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/semver/semver.js new file mode 100644 index 0000000000000000000000000000000000000000..39319c13cac27d65d88d34dac95470a6494a0dae --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/semver/semver.js @@ -0,0 +1,1643 @@ +exports = module.exports = SemVer + +var debug +/* istanbul ignore next */ +if (typeof process === 'object' && + process.env && + process.env.NODE_DEBUG && + /\bsemver\b/i.test(process.env.NODE_DEBUG)) { + debug = function () { + var args = Array.prototype.slice.call(arguments, 0) + args.unshift('SEMVER') + console.log.apply(console, args) + } +} else { + debug = function () {} +} + +// Note: this is the semver.org version of the spec that it implements +// Not necessarily the package version of this code. +exports.SEMVER_SPEC_VERSION = '2.0.0' + +var MAX_LENGTH = 256 +var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || + /* istanbul ignore next */ 9007199254740991 + +// Max safe segment length for coercion. +var MAX_SAFE_COMPONENT_LENGTH = 16 + +var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6 + +// The actual regexps go on exports.re +var re = exports.re = [] +var safeRe = exports.safeRe = [] +var src = exports.src = [] +var t = exports.tokens = {} +var R = 0 + +function tok (n) { + t[n] = R++ +} + +var LETTERDASHNUMBER = '[a-zA-Z0-9-]' + +// Replace some greedy regex tokens to prevent regex dos issues. These regex are +// used internally via the safeRe object since all inputs in this library get +// normalized first to trim and collapse all extra whitespace. The original +// regexes are exported for userland consumption and lower level usage. A +// future breaking change could export the safer regex only with a note that +// all input should have extra whitespace removed. +var safeRegexReplacements = [ + ['\\s', 1], + ['\\d', MAX_LENGTH], + [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH], +] + +function makeSafeRe (value) { + for (var i = 0; i < safeRegexReplacements.length; i++) { + var token = safeRegexReplacements[i][0] + var max = safeRegexReplacements[i][1] + value = value + .split(token + '*').join(token + '{0,' + max + '}') + .split(token + '+').join(token + '{1,' + max + '}') + } + return value +} + +// The following Regular Expressions can be used for tokenizing, +// validating, and parsing SemVer version strings. + +// ## Numeric Identifier +// A single `0`, or a non-zero digit followed by zero or more digits. + +tok('NUMERICIDENTIFIER') +src[t.NUMERICIDENTIFIER] = '0|[1-9]\\d*' +tok('NUMERICIDENTIFIERLOOSE') +src[t.NUMERICIDENTIFIERLOOSE] = '\\d+' + +// ## Non-numeric Identifier +// Zero or more digits, followed by a letter or hyphen, and then zero or +// more letters, digits, or hyphens. + +tok('NONNUMERICIDENTIFIER') +src[t.NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-]' + LETTERDASHNUMBER + '*' + +// ## Main Version +// Three dot-separated numeric identifiers. + +tok('MAINVERSION') +src[t.MAINVERSION] = '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + + '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + + '(' + src[t.NUMERICIDENTIFIER] + ')' + +tok('MAINVERSIONLOOSE') +src[t.MAINVERSIONLOOSE] = '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')' + +// ## Pre-release Version Identifier +// A numeric identifier, or a non-numeric identifier. + +tok('PRERELEASEIDENTIFIER') +src[t.PRERELEASEIDENTIFIER] = '(?:' + src[t.NUMERICIDENTIFIER] + + '|' + src[t.NONNUMERICIDENTIFIER] + ')' + +tok('PRERELEASEIDENTIFIERLOOSE') +src[t.PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[t.NUMERICIDENTIFIERLOOSE] + + '|' + src[t.NONNUMERICIDENTIFIER] + ')' + +// ## Pre-release Version +// Hyphen, followed by one or more dot-separated pre-release version +// identifiers. + +tok('PRERELEASE') +src[t.PRERELEASE] = '(?:-(' + src[t.PRERELEASEIDENTIFIER] + + '(?:\\.' + src[t.PRERELEASEIDENTIFIER] + ')*))' + +tok('PRERELEASELOOSE') +src[t.PRERELEASELOOSE] = '(?:-?(' + src[t.PRERELEASEIDENTIFIERLOOSE] + + '(?:\\.' + src[t.PRERELEASEIDENTIFIERLOOSE] + ')*))' + +// ## Build Metadata Identifier +// Any combination of digits, letters, or hyphens. + +tok('BUILDIDENTIFIER') +src[t.BUILDIDENTIFIER] = LETTERDASHNUMBER + '+' + +// ## Build Metadata +// Plus sign, followed by one or more period-separated build metadata +// identifiers. + +tok('BUILD') +src[t.BUILD] = '(?:\\+(' + src[t.BUILDIDENTIFIER] + + '(?:\\.' + src[t.BUILDIDENTIFIER] + ')*))' + +// ## Full Version String +// A main version, followed optionally by a pre-release version and +// build metadata. + +// Note that the only major, minor, patch, and pre-release sections of +// the version string are capturing groups. The build metadata is not a +// capturing group, because it should not ever be used in version +// comparison. + +tok('FULL') +tok('FULLPLAIN') +src[t.FULLPLAIN] = 'v?' + src[t.MAINVERSION] + + src[t.PRERELEASE] + '?' + + src[t.BUILD] + '?' + +src[t.FULL] = '^' + src[t.FULLPLAIN] + '$' + +// like full, but allows v1.2.3 and =1.2.3, which people do sometimes. +// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty +// common in the npm registry. +tok('LOOSEPLAIN') +src[t.LOOSEPLAIN] = '[v=\\s]*' + src[t.MAINVERSIONLOOSE] + + src[t.PRERELEASELOOSE] + '?' + + src[t.BUILD] + '?' + +tok('LOOSE') +src[t.LOOSE] = '^' + src[t.LOOSEPLAIN] + '$' + +tok('GTLT') +src[t.GTLT] = '((?:<|>)?=?)' + +// Something like "2.*" or "1.2.x". +// Note that "x.x" is a valid xRange identifer, meaning "any version" +// Only the first item is strictly required. +tok('XRANGEIDENTIFIERLOOSE') +src[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + '|x|X|\\*' +tok('XRANGEIDENTIFIER') +src[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + '|x|X|\\*' + +tok('XRANGEPLAIN') +src[t.XRANGEPLAIN] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIER] + ')' + + '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + + '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + + '(?:' + src[t.PRERELEASE] + ')?' + + src[t.BUILD] + '?' + + ')?)?' + +tok('XRANGEPLAINLOOSE') +src[t.XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + + '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + + '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + + '(?:' + src[t.PRERELEASELOOSE] + ')?' + + src[t.BUILD] + '?' + + ')?)?' + +tok('XRANGE') +src[t.XRANGE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAIN] + '$' +tok('XRANGELOOSE') +src[t.XRANGELOOSE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAINLOOSE] + '$' + +// Coercion. +// Extract anything that could conceivably be a part of a valid semver +tok('COERCE') +src[t.COERCE] = '(^|[^\\d])' + + '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' + + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + + '(?:$|[^\\d])' +tok('COERCERTL') +re[t.COERCERTL] = new RegExp(src[t.COERCE], 'g') +safeRe[t.COERCERTL] = new RegExp(makeSafeRe(src[t.COERCE]), 'g') + +// Tilde ranges. +// Meaning is "reasonably at or greater than" +tok('LONETILDE') +src[t.LONETILDE] = '(?:~>?)' + +tok('TILDETRIM') +src[t.TILDETRIM] = '(\\s*)' + src[t.LONETILDE] + '\\s+' +re[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], 'g') +safeRe[t.TILDETRIM] = new RegExp(makeSafeRe(src[t.TILDETRIM]), 'g') +var tildeTrimReplace = '$1~' + +tok('TILDE') +src[t.TILDE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAIN] + '$' +tok('TILDELOOSE') +src[t.TILDELOOSE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + '$' + +// Caret ranges. +// Meaning is "at least and backwards compatible with" +tok('LONECARET') +src[t.LONECARET] = '(?:\\^)' + +tok('CARETTRIM') +src[t.CARETTRIM] = '(\\s*)' + src[t.LONECARET] + '\\s+' +re[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], 'g') +safeRe[t.CARETTRIM] = new RegExp(makeSafeRe(src[t.CARETTRIM]), 'g') +var caretTrimReplace = '$1^' + +tok('CARET') +src[t.CARET] = '^' + src[t.LONECARET] + src[t.XRANGEPLAIN] + '$' +tok('CARETLOOSE') +src[t.CARETLOOSE] = '^' + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + '$' + +// A simple gt/lt/eq thing, or just "" to indicate "any version" +tok('COMPARATORLOOSE') +src[t.COMPARATORLOOSE] = '^' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + ')$|^$' +tok('COMPARATOR') +src[t.COMPARATOR] = '^' + src[t.GTLT] + '\\s*(' + src[t.FULLPLAIN] + ')$|^$' + +// An expression to strip any whitespace between the gtlt and the thing +// it modifies, so that `> 1.2.3` ==> `>1.2.3` +tok('COMPARATORTRIM') +src[t.COMPARATORTRIM] = '(\\s*)' + src[t.GTLT] + + '\\s*(' + src[t.LOOSEPLAIN] + '|' + src[t.XRANGEPLAIN] + ')' + +// this one has to use the /g flag +re[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], 'g') +safeRe[t.COMPARATORTRIM] = new RegExp(makeSafeRe(src[t.COMPARATORTRIM]), 'g') +var comparatorTrimReplace = '$1$2$3' + +// Something like `1.2.3 - 1.2.4` +// Note that these all use the loose form, because they'll be +// checked against either the strict or loose comparator form +// later. +tok('HYPHENRANGE') +src[t.HYPHENRANGE] = '^\\s*(' + src[t.XRANGEPLAIN] + ')' + + '\\s+-\\s+' + + '(' + src[t.XRANGEPLAIN] + ')' + + '\\s*$' + +tok('HYPHENRANGELOOSE') +src[t.HYPHENRANGELOOSE] = '^\\s*(' + src[t.XRANGEPLAINLOOSE] + ')' + + '\\s+-\\s+' + + '(' + src[t.XRANGEPLAINLOOSE] + ')' + + '\\s*$' + +// Star ranges basically just allow anything at all. +tok('STAR') +src[t.STAR] = '(<|>)?=?\\s*\\*' + +// Compile to actual regexp objects. +// All are flag-free, unless they were created above with a flag. +for (var i = 0; i < R; i++) { + debug(i, src[i]) + if (!re[i]) { + re[i] = new RegExp(src[i]) + + // Replace all greedy whitespace to prevent regex dos issues. These regex are + // used internally via the safeRe object since all inputs in this library get + // normalized first to trim and collapse all extra whitespace. The original + // regexes are exported for userland consumption and lower level usage. A + // future breaking change could export the safer regex only with a note that + // all input should have extra whitespace removed. + safeRe[i] = new RegExp(makeSafeRe(src[i])) + } +} + +exports.parse = parse +function parse (version, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + if (version instanceof SemVer) { + return version + } + + if (typeof version !== 'string') { + return null + } + + if (version.length > MAX_LENGTH) { + return null + } + + var r = options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL] + if (!r.test(version)) { + return null + } + + try { + return new SemVer(version, options) + } catch (er) { + return null + } +} + +exports.valid = valid +function valid (version, options) { + var v = parse(version, options) + return v ? v.version : null +} + +exports.clean = clean +function clean (version, options) { + var s = parse(version.trim().replace(/^[=v]+/, ''), options) + return s ? s.version : null +} + +exports.SemVer = SemVer + +function SemVer (version, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + if (version instanceof SemVer) { + if (version.loose === options.loose) { + return version + } else { + version = version.version + } + } else if (typeof version !== 'string') { + throw new TypeError('Invalid Version: ' + version) + } + + if (version.length > MAX_LENGTH) { + throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters') + } + + if (!(this instanceof SemVer)) { + return new SemVer(version, options) + } + + debug('SemVer', version, options) + this.options = options + this.loose = !!options.loose + + var m = version.trim().match(options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL]) + + if (!m) { + throw new TypeError('Invalid Version: ' + version) + } + + this.raw = version + + // these are actually numbers + this.major = +m[1] + this.minor = +m[2] + this.patch = +m[3] + + if (this.major > MAX_SAFE_INTEGER || this.major < 0) { + throw new TypeError('Invalid major version') + } + + if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) { + throw new TypeError('Invalid minor version') + } + + if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) { + throw new TypeError('Invalid patch version') + } + + // numberify any prerelease numeric ids + if (!m[4]) { + this.prerelease = [] + } else { + this.prerelease = m[4].split('.').map(function (id) { + if (/^[0-9]+$/.test(id)) { + var num = +id + if (num >= 0 && num < MAX_SAFE_INTEGER) { + return num + } + } + return id + }) + } + + this.build = m[5] ? m[5].split('.') : [] + this.format() +} + +SemVer.prototype.format = function () { + this.version = this.major + '.' + this.minor + '.' + this.patch + if (this.prerelease.length) { + this.version += '-' + this.prerelease.join('.') + } + return this.version +} + +SemVer.prototype.toString = function () { + return this.version +} + +SemVer.prototype.compare = function (other) { + debug('SemVer.compare', this.version, this.options, other) + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + return this.compareMain(other) || this.comparePre(other) +} + +SemVer.prototype.compareMain = function (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + return compareIdentifiers(this.major, other.major) || + compareIdentifiers(this.minor, other.minor) || + compareIdentifiers(this.patch, other.patch) +} + +SemVer.prototype.comparePre = function (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + // NOT having a prerelease is > having one + if (this.prerelease.length && !other.prerelease.length) { + return -1 + } else if (!this.prerelease.length && other.prerelease.length) { + return 1 + } else if (!this.prerelease.length && !other.prerelease.length) { + return 0 + } + + var i = 0 + do { + var a = this.prerelease[i] + var b = other.prerelease[i] + debug('prerelease compare', i, a, b) + if (a === undefined && b === undefined) { + return 0 + } else if (b === undefined) { + return 1 + } else if (a === undefined) { + return -1 + } else if (a === b) { + continue + } else { + return compareIdentifiers(a, b) + } + } while (++i) +} + +SemVer.prototype.compareBuild = function (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + var i = 0 + do { + var a = this.build[i] + var b = other.build[i] + debug('prerelease compare', i, a, b) + if (a === undefined && b === undefined) { + return 0 + } else if (b === undefined) { + return 1 + } else if (a === undefined) { + return -1 + } else if (a === b) { + continue + } else { + return compareIdentifiers(a, b) + } + } while (++i) +} + +// preminor will bump the version up to the next minor release, and immediately +// down to pre-release. premajor and prepatch work the same way. +SemVer.prototype.inc = function (release, identifier) { + switch (release) { + case 'premajor': + this.prerelease.length = 0 + this.patch = 0 + this.minor = 0 + this.major++ + this.inc('pre', identifier) + break + case 'preminor': + this.prerelease.length = 0 + this.patch = 0 + this.minor++ + this.inc('pre', identifier) + break + case 'prepatch': + // If this is already a prerelease, it will bump to the next version + // drop any prereleases that might already exist, since they are not + // relevant at this point. + this.prerelease.length = 0 + this.inc('patch', identifier) + this.inc('pre', identifier) + break + // If the input is a non-prerelease version, this acts the same as + // prepatch. + case 'prerelease': + if (this.prerelease.length === 0) { + this.inc('patch', identifier) + } + this.inc('pre', identifier) + break + + case 'major': + // If this is a pre-major version, bump up to the same major version. + // Otherwise increment major. + // 1.0.0-5 bumps to 1.0.0 + // 1.1.0 bumps to 2.0.0 + if (this.minor !== 0 || + this.patch !== 0 || + this.prerelease.length === 0) { + this.major++ + } + this.minor = 0 + this.patch = 0 + this.prerelease = [] + break + case 'minor': + // If this is a pre-minor version, bump up to the same minor version. + // Otherwise increment minor. + // 1.2.0-5 bumps to 1.2.0 + // 1.2.1 bumps to 1.3.0 + if (this.patch !== 0 || this.prerelease.length === 0) { + this.minor++ + } + this.patch = 0 + this.prerelease = [] + break + case 'patch': + // If this is not a pre-release version, it will increment the patch. + // If it is a pre-release it will bump up to the same patch version. + // 1.2.0-5 patches to 1.2.0 + // 1.2.0 patches to 1.2.1 + if (this.prerelease.length === 0) { + this.patch++ + } + this.prerelease = [] + break + // This probably shouldn't be used publicly. + // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction. + case 'pre': + if (this.prerelease.length === 0) { + this.prerelease = [0] + } else { + var i = this.prerelease.length + while (--i >= 0) { + if (typeof this.prerelease[i] === 'number') { + this.prerelease[i]++ + i = -2 + } + } + if (i === -1) { + // didn't increment anything + this.prerelease.push(0) + } + } + if (identifier) { + // 1.2.0-beta.1 bumps to 1.2.0-beta.2, + // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0 + if (this.prerelease[0] === identifier) { + if (isNaN(this.prerelease[1])) { + this.prerelease = [identifier, 0] + } + } else { + this.prerelease = [identifier, 0] + } + } + break + + default: + throw new Error('invalid increment argument: ' + release) + } + this.format() + this.raw = this.version + return this +} + +exports.inc = inc +function inc (version, release, loose, identifier) { + if (typeof (loose) === 'string') { + identifier = loose + loose = undefined + } + + try { + return new SemVer(version, loose).inc(release, identifier).version + } catch (er) { + return null + } +} + +exports.diff = diff +function diff (version1, version2) { + if (eq(version1, version2)) { + return null + } else { + var v1 = parse(version1) + var v2 = parse(version2) + var prefix = '' + if (v1.prerelease.length || v2.prerelease.length) { + prefix = 'pre' + var defaultResult = 'prerelease' + } + for (var key in v1) { + if (key === 'major' || key === 'minor' || key === 'patch') { + if (v1[key] !== v2[key]) { + return prefix + key + } + } + } + return defaultResult // may be undefined + } +} + +exports.compareIdentifiers = compareIdentifiers + +var numeric = /^[0-9]+$/ +function compareIdentifiers (a, b) { + var anum = numeric.test(a) + var bnum = numeric.test(b) + + if (anum && bnum) { + a = +a + b = +b + } + + return a === b ? 0 + : (anum && !bnum) ? -1 + : (bnum && !anum) ? 1 + : a < b ? -1 + : 1 +} + +exports.rcompareIdentifiers = rcompareIdentifiers +function rcompareIdentifiers (a, b) { + return compareIdentifiers(b, a) +} + +exports.major = major +function major (a, loose) { + return new SemVer(a, loose).major +} + +exports.minor = minor +function minor (a, loose) { + return new SemVer(a, loose).minor +} + +exports.patch = patch +function patch (a, loose) { + return new SemVer(a, loose).patch +} + +exports.compare = compare +function compare (a, b, loose) { + return new SemVer(a, loose).compare(new SemVer(b, loose)) +} + +exports.compareLoose = compareLoose +function compareLoose (a, b) { + return compare(a, b, true) +} + +exports.compareBuild = compareBuild +function compareBuild (a, b, loose) { + var versionA = new SemVer(a, loose) + var versionB = new SemVer(b, loose) + return versionA.compare(versionB) || versionA.compareBuild(versionB) +} + +exports.rcompare = rcompare +function rcompare (a, b, loose) { + return compare(b, a, loose) +} + +exports.sort = sort +function sort (list, loose) { + return list.sort(function (a, b) { + return exports.compareBuild(a, b, loose) + }) +} + +exports.rsort = rsort +function rsort (list, loose) { + return list.sort(function (a, b) { + return exports.compareBuild(b, a, loose) + }) +} + +exports.gt = gt +function gt (a, b, loose) { + return compare(a, b, loose) > 0 +} + +exports.lt = lt +function lt (a, b, loose) { + return compare(a, b, loose) < 0 +} + +exports.eq = eq +function eq (a, b, loose) { + return compare(a, b, loose) === 0 +} + +exports.neq = neq +function neq (a, b, loose) { + return compare(a, b, loose) !== 0 +} + +exports.gte = gte +function gte (a, b, loose) { + return compare(a, b, loose) >= 0 +} + +exports.lte = lte +function lte (a, b, loose) { + return compare(a, b, loose) <= 0 +} + +exports.cmp = cmp +function cmp (a, op, b, loose) { + switch (op) { + case '===': + if (typeof a === 'object') + a = a.version + if (typeof b === 'object') + b = b.version + return a === b + + case '!==': + if (typeof a === 'object') + a = a.version + if (typeof b === 'object') + b = b.version + return a !== b + + case '': + case '=': + case '==': + return eq(a, b, loose) + + case '!=': + return neq(a, b, loose) + + case '>': + return gt(a, b, loose) + + case '>=': + return gte(a, b, loose) + + case '<': + return lt(a, b, loose) + + case '<=': + return lte(a, b, loose) + + default: + throw new TypeError('Invalid operator: ' + op) + } +} + +exports.Comparator = Comparator +function Comparator (comp, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + if (comp instanceof Comparator) { + if (comp.loose === !!options.loose) { + return comp + } else { + comp = comp.value + } + } + + if (!(this instanceof Comparator)) { + return new Comparator(comp, options) + } + + comp = comp.trim().split(/\s+/).join(' ') + debug('comparator', comp, options) + this.options = options + this.loose = !!options.loose + this.parse(comp) + + if (this.semver === ANY) { + this.value = '' + } else { + this.value = this.operator + this.semver.version + } + + debug('comp', this) +} + +var ANY = {} +Comparator.prototype.parse = function (comp) { + var r = this.options.loose ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR] + var m = comp.match(r) + + if (!m) { + throw new TypeError('Invalid comparator: ' + comp) + } + + this.operator = m[1] !== undefined ? m[1] : '' + if (this.operator === '=') { + this.operator = '' + } + + // if it literally is just '>' or '' then allow anything. + if (!m[2]) { + this.semver = ANY + } else { + this.semver = new SemVer(m[2], this.options.loose) + } +} + +Comparator.prototype.toString = function () { + return this.value +} + +Comparator.prototype.test = function (version) { + debug('Comparator.test', version, this.options.loose) + + if (this.semver === ANY || version === ANY) { + return true + } + + if (typeof version === 'string') { + try { + version = new SemVer(version, this.options) + } catch (er) { + return false + } + } + + return cmp(version, this.operator, this.semver, this.options) +} + +Comparator.prototype.intersects = function (comp, options) { + if (!(comp instanceof Comparator)) { + throw new TypeError('a Comparator is required') + } + + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + var rangeTmp + + if (this.operator === '') { + if (this.value === '') { + return true + } + rangeTmp = new Range(comp.value, options) + return satisfies(this.value, rangeTmp, options) + } else if (comp.operator === '') { + if (comp.value === '') { + return true + } + rangeTmp = new Range(this.value, options) + return satisfies(comp.semver, rangeTmp, options) + } + + var sameDirectionIncreasing = + (this.operator === '>=' || this.operator === '>') && + (comp.operator === '>=' || comp.operator === '>') + var sameDirectionDecreasing = + (this.operator === '<=' || this.operator === '<') && + (comp.operator === '<=' || comp.operator === '<') + var sameSemVer = this.semver.version === comp.semver.version + var differentDirectionsInclusive = + (this.operator === '>=' || this.operator === '<=') && + (comp.operator === '>=' || comp.operator === '<=') + var oppositeDirectionsLessThan = + cmp(this.semver, '<', comp.semver, options) && + ((this.operator === '>=' || this.operator === '>') && + (comp.operator === '<=' || comp.operator === '<')) + var oppositeDirectionsGreaterThan = + cmp(this.semver, '>', comp.semver, options) && + ((this.operator === '<=' || this.operator === '<') && + (comp.operator === '>=' || comp.operator === '>')) + + return sameDirectionIncreasing || sameDirectionDecreasing || + (sameSemVer && differentDirectionsInclusive) || + oppositeDirectionsLessThan || oppositeDirectionsGreaterThan +} + +exports.Range = Range +function Range (range, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + if (range instanceof Range) { + if (range.loose === !!options.loose && + range.includePrerelease === !!options.includePrerelease) { + return range + } else { + return new Range(range.raw, options) + } + } + + if (range instanceof Comparator) { + return new Range(range.value, options) + } + + if (!(this instanceof Range)) { + return new Range(range, options) + } + + this.options = options + this.loose = !!options.loose + this.includePrerelease = !!options.includePrerelease + + // First reduce all whitespace as much as possible so we do not have to rely + // on potentially slow regexes like \s*. This is then stored and used for + // future error messages as well. + this.raw = range + .trim() + .split(/\s+/) + .join(' ') + + // First, split based on boolean or || + this.set = this.raw.split('||').map(function (range) { + return this.parseRange(range.trim()) + }, this).filter(function (c) { + // throw out any that are not relevant for whatever reason + return c.length + }) + + if (!this.set.length) { + throw new TypeError('Invalid SemVer Range: ' + this.raw) + } + + this.format() +} + +Range.prototype.format = function () { + this.range = this.set.map(function (comps) { + return comps.join(' ').trim() + }).join('||').trim() + return this.range +} + +Range.prototype.toString = function () { + return this.range +} + +Range.prototype.parseRange = function (range) { + var loose = this.options.loose + // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4` + var hr = loose ? safeRe[t.HYPHENRANGELOOSE] : safeRe[t.HYPHENRANGE] + range = range.replace(hr, hyphenReplace) + debug('hyphen replace', range) + // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5` + range = range.replace(safeRe[t.COMPARATORTRIM], comparatorTrimReplace) + debug('comparator trim', range, safeRe[t.COMPARATORTRIM]) + + // `~ 1.2.3` => `~1.2.3` + range = range.replace(safeRe[t.TILDETRIM], tildeTrimReplace) + + // `^ 1.2.3` => `^1.2.3` + range = range.replace(safeRe[t.CARETTRIM], caretTrimReplace) + + // normalize spaces + range = range.split(/\s+/).join(' ') + + // At this point, the range is completely trimmed and + // ready to be split into comparators. + + var compRe = loose ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR] + var set = range.split(' ').map(function (comp) { + return parseComparator(comp, this.options) + }, this).join(' ').split(/\s+/) + if (this.options.loose) { + // in loose mode, throw out any that are not valid comparators + set = set.filter(function (comp) { + return !!comp.match(compRe) + }) + } + set = set.map(function (comp) { + return new Comparator(comp, this.options) + }, this) + + return set +} + +Range.prototype.intersects = function (range, options) { + if (!(range instanceof Range)) { + throw new TypeError('a Range is required') + } + + return this.set.some(function (thisComparators) { + return ( + isSatisfiable(thisComparators, options) && + range.set.some(function (rangeComparators) { + return ( + isSatisfiable(rangeComparators, options) && + thisComparators.every(function (thisComparator) { + return rangeComparators.every(function (rangeComparator) { + return thisComparator.intersects(rangeComparator, options) + }) + }) + ) + }) + ) + }) +} + +// take a set of comparators and determine whether there +// exists a version which can satisfy it +function isSatisfiable (comparators, options) { + var result = true + var remainingComparators = comparators.slice() + var testComparator = remainingComparators.pop() + + while (result && remainingComparators.length) { + result = remainingComparators.every(function (otherComparator) { + return testComparator.intersects(otherComparator, options) + }) + + testComparator = remainingComparators.pop() + } + + return result +} + +// Mostly just for testing and legacy API reasons +exports.toComparators = toComparators +function toComparators (range, options) { + return new Range(range, options).set.map(function (comp) { + return comp.map(function (c) { + return c.value + }).join(' ').trim().split(' ') + }) +} + +// comprised of xranges, tildes, stars, and gtlt's at this point. +// already replaced the hyphen ranges +// turn into a set of JUST comparators. +function parseComparator (comp, options) { + debug('comp', comp, options) + comp = replaceCarets(comp, options) + debug('caret', comp) + comp = replaceTildes(comp, options) + debug('tildes', comp) + comp = replaceXRanges(comp, options) + debug('xrange', comp) + comp = replaceStars(comp, options) + debug('stars', comp) + return comp +} + +function isX (id) { + return !id || id.toLowerCase() === 'x' || id === '*' +} + +// ~, ~> --> * (any, kinda silly) +// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0 +// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0 +// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0 +// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0 +// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0 +function replaceTildes (comp, options) { + return comp.trim().split(/\s+/).map(function (comp) { + return replaceTilde(comp, options) + }).join(' ') +} + +function replaceTilde (comp, options) { + var r = options.loose ? safeRe[t.TILDELOOSE] : safeRe[t.TILDE] + return comp.replace(r, function (_, M, m, p, pr) { + debug('tilde', comp, _, M, m, p, pr) + var ret + + if (isX(M)) { + ret = '' + } else if (isX(m)) { + ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0' + } else if (isX(p)) { + // ~1.2 == >=1.2.0 <1.3.0 + ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0' + } else if (pr) { + debug('replaceTilde pr', pr) + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + M + '.' + (+m + 1) + '.0' + } else { + // ~1.2.3 == >=1.2.3 <1.3.0 + ret = '>=' + M + '.' + m + '.' + p + + ' <' + M + '.' + (+m + 1) + '.0' + } + + debug('tilde return', ret) + return ret + }) +} + +// ^ --> * (any, kinda silly) +// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0 +// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0 +// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0 +// ^1.2.3 --> >=1.2.3 <2.0.0 +// ^1.2.0 --> >=1.2.0 <2.0.0 +function replaceCarets (comp, options) { + return comp.trim().split(/\s+/).map(function (comp) { + return replaceCaret(comp, options) + }).join(' ') +} + +function replaceCaret (comp, options) { + debug('caret', comp, options) + var r = options.loose ? safeRe[t.CARETLOOSE] : safeRe[t.CARET] + return comp.replace(r, function (_, M, m, p, pr) { + debug('caret', comp, _, M, m, p, pr) + var ret + + if (isX(M)) { + ret = '' + } else if (isX(m)) { + ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0' + } else if (isX(p)) { + if (M === '0') { + ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0' + } else { + ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0' + } + } else if (pr) { + debug('replaceCaret pr', pr) + if (M === '0') { + if (m === '0') { + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + M + '.' + m + '.' + (+p + 1) + } else { + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + M + '.' + (+m + 1) + '.0' + } + } else { + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + (+M + 1) + '.0.0' + } + } else { + debug('no pr') + if (M === '0') { + if (m === '0') { + ret = '>=' + M + '.' + m + '.' + p + + ' <' + M + '.' + m + '.' + (+p + 1) + } else { + ret = '>=' + M + '.' + m + '.' + p + + ' <' + M + '.' + (+m + 1) + '.0' + } + } else { + ret = '>=' + M + '.' + m + '.' + p + + ' <' + (+M + 1) + '.0.0' + } + } + + debug('caret return', ret) + return ret + }) +} + +function replaceXRanges (comp, options) { + debug('replaceXRanges', comp, options) + return comp.split(/\s+/).map(function (comp) { + return replaceXRange(comp, options) + }).join(' ') +} + +function replaceXRange (comp, options) { + comp = comp.trim() + var r = options.loose ? safeRe[t.XRANGELOOSE] : safeRe[t.XRANGE] + return comp.replace(r, function (ret, gtlt, M, m, p, pr) { + debug('xRange', comp, ret, gtlt, M, m, p, pr) + var xM = isX(M) + var xm = xM || isX(m) + var xp = xm || isX(p) + var anyX = xp + + if (gtlt === '=' && anyX) { + gtlt = '' + } + + // if we're including prereleases in the match, then we need + // to fix this to -0, the lowest possible prerelease value + pr = options.includePrerelease ? '-0' : '' + + if (xM) { + if (gtlt === '>' || gtlt === '<') { + // nothing is allowed + ret = '<0.0.0-0' + } else { + // nothing is forbidden + ret = '*' + } + } else if (gtlt && anyX) { + // we know patch is an x, because we have any x at all. + // replace X with 0 + if (xm) { + m = 0 + } + p = 0 + + if (gtlt === '>') { + // >1 => >=2.0.0 + // >1.2 => >=1.3.0 + // >1.2.3 => >= 1.2.4 + gtlt = '>=' + if (xm) { + M = +M + 1 + m = 0 + p = 0 + } else { + m = +m + 1 + p = 0 + } + } else if (gtlt === '<=') { + // <=0.7.x is actually <0.8.0, since any 0.7.x should + // pass. Similarly, <=7.x is actually <8.0.0, etc. + gtlt = '<' + if (xm) { + M = +M + 1 + } else { + m = +m + 1 + } + } + + ret = gtlt + M + '.' + m + '.' + p + pr + } else if (xm) { + ret = '>=' + M + '.0.0' + pr + ' <' + (+M + 1) + '.0.0' + pr + } else if (xp) { + ret = '>=' + M + '.' + m + '.0' + pr + + ' <' + M + '.' + (+m + 1) + '.0' + pr + } + + debug('xRange return', ret) + + return ret + }) +} + +// Because * is AND-ed with everything else in the comparator, +// and '' means "any version", just remove the *s entirely. +function replaceStars (comp, options) { + debug('replaceStars', comp, options) + // Looseness is ignored here. star is always as loose as it gets! + return comp.trim().replace(safeRe[t.STAR], '') +} + +// This function is passed to string.replace(re[t.HYPHENRANGE]) +// M, m, patch, prerelease, build +// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5 +// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do +// 1.2 - 3.4 => >=1.2.0 <3.5.0 +function hyphenReplace ($0, + from, fM, fm, fp, fpr, fb, + to, tM, tm, tp, tpr, tb) { + if (isX(fM)) { + from = '' + } else if (isX(fm)) { + from = '>=' + fM + '.0.0' + } else if (isX(fp)) { + from = '>=' + fM + '.' + fm + '.0' + } else { + from = '>=' + from + } + + if (isX(tM)) { + to = '' + } else if (isX(tm)) { + to = '<' + (+tM + 1) + '.0.0' + } else if (isX(tp)) { + to = '<' + tM + '.' + (+tm + 1) + '.0' + } else if (tpr) { + to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr + } else { + to = '<=' + to + } + + return (from + ' ' + to).trim() +} + +// if ANY of the sets match ALL of its comparators, then pass +Range.prototype.test = function (version) { + if (!version) { + return false + } + + if (typeof version === 'string') { + try { + version = new SemVer(version, this.options) + } catch (er) { + return false + } + } + + for (var i = 0; i < this.set.length; i++) { + if (testSet(this.set[i], version, this.options)) { + return true + } + } + return false +} + +function testSet (set, version, options) { + for (var i = 0; i < set.length; i++) { + if (!set[i].test(version)) { + return false + } + } + + if (version.prerelease.length && !options.includePrerelease) { + // Find the set of versions that are allowed to have prereleases + // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0 + // That should allow `1.2.3-pr.2` to pass. + // However, `1.2.4-alpha.notready` should NOT be allowed, + // even though it's within the range set by the comparators. + for (i = 0; i < set.length; i++) { + debug(set[i].semver) + if (set[i].semver === ANY) { + continue + } + + if (set[i].semver.prerelease.length > 0) { + var allowed = set[i].semver + if (allowed.major === version.major && + allowed.minor === version.minor && + allowed.patch === version.patch) { + return true + } + } + } + + // Version has a -pre, but it's not one of the ones we like. + return false + } + + return true +} + +exports.satisfies = satisfies +function satisfies (version, range, options) { + try { + range = new Range(range, options) + } catch (er) { + return false + } + return range.test(version) +} + +exports.maxSatisfying = maxSatisfying +function maxSatisfying (versions, range, options) { + var max = null + var maxSV = null + try { + var rangeObj = new Range(range, options) + } catch (er) { + return null + } + versions.forEach(function (v) { + if (rangeObj.test(v)) { + // satisfies(v, range, options) + if (!max || maxSV.compare(v) === -1) { + // compare(max, v, true) + max = v + maxSV = new SemVer(max, options) + } + } + }) + return max +} + +exports.minSatisfying = minSatisfying +function minSatisfying (versions, range, options) { + var min = null + var minSV = null + try { + var rangeObj = new Range(range, options) + } catch (er) { + return null + } + versions.forEach(function (v) { + if (rangeObj.test(v)) { + // satisfies(v, range, options) + if (!min || minSV.compare(v) === 1) { + // compare(min, v, true) + min = v + minSV = new SemVer(min, options) + } + } + }) + return min +} + +exports.minVersion = minVersion +function minVersion (range, loose) { + range = new Range(range, loose) + + var minver = new SemVer('0.0.0') + if (range.test(minver)) { + return minver + } + + minver = new SemVer('0.0.0-0') + if (range.test(minver)) { + return minver + } + + minver = null + for (var i = 0; i < range.set.length; ++i) { + var comparators = range.set[i] + + comparators.forEach(function (comparator) { + // Clone to avoid manipulating the comparator's semver object. + var compver = new SemVer(comparator.semver.version) + switch (comparator.operator) { + case '>': + if (compver.prerelease.length === 0) { + compver.patch++ + } else { + compver.prerelease.push(0) + } + compver.raw = compver.format() + /* fallthrough */ + case '': + case '>=': + if (!minver || gt(minver, compver)) { + minver = compver + } + break + case '<': + case '<=': + /* Ignore maximum versions */ + break + /* istanbul ignore next */ + default: + throw new Error('Unexpected operation: ' + comparator.operator) + } + }) + } + + if (minver && range.test(minver)) { + return minver + } + + return null +} + +exports.validRange = validRange +function validRange (range, options) { + try { + // Return '*' instead of '' so that truthiness works. + // This will throw if it's invalid anyway + return new Range(range, options).range || '*' + } catch (er) { + return null + } +} + +// Determine if version is less than all the versions possible in the range +exports.ltr = ltr +function ltr (version, range, options) { + return outside(version, range, '<', options) +} + +// Determine if version is greater than all the versions possible in the range. +exports.gtr = gtr +function gtr (version, range, options) { + return outside(version, range, '>', options) +} + +exports.outside = outside +function outside (version, range, hilo, options) { + version = new SemVer(version, options) + range = new Range(range, options) + + var gtfn, ltefn, ltfn, comp, ecomp + switch (hilo) { + case '>': + gtfn = gt + ltefn = lte + ltfn = lt + comp = '>' + ecomp = '>=' + break + case '<': + gtfn = lt + ltefn = gte + ltfn = gt + comp = '<' + ecomp = '<=' + break + default: + throw new TypeError('Must provide a hilo val of "<" or ">"') + } + + // If it satisifes the range it is not outside + if (satisfies(version, range, options)) { + return false + } + + // From now on, variable terms are as if we're in "gtr" mode. + // but note that everything is flipped for the "ltr" function. + + for (var i = 0; i < range.set.length; ++i) { + var comparators = range.set[i] + + var high = null + var low = null + + comparators.forEach(function (comparator) { + if (comparator.semver === ANY) { + comparator = new Comparator('>=0.0.0') + } + high = high || comparator + low = low || comparator + if (gtfn(comparator.semver, high.semver, options)) { + high = comparator + } else if (ltfn(comparator.semver, low.semver, options)) { + low = comparator + } + }) + + // If the edge version comparator has a operator then our version + // isn't outside it + if (high.operator === comp || high.operator === ecomp) { + return false + } + + // If the lowest version comparator has an operator and our version + // is less than it then it isn't higher than the range + if ((!low.operator || low.operator === comp) && + ltefn(version, low.semver)) { + return false + } else if (low.operator === ecomp && ltfn(version, low.semver)) { + return false + } + } + return true +} + +exports.prerelease = prerelease +function prerelease (version, options) { + var parsed = parse(version, options) + return (parsed && parsed.prerelease.length) ? parsed.prerelease : null +} + +exports.intersects = intersects +function intersects (r1, r2, options) { + r1 = new Range(r1, options) + r2 = new Range(r2, options) + return r1.intersects(r2) +} + +exports.coerce = coerce +function coerce (version, options) { + if (version instanceof SemVer) { + return version + } + + if (typeof version === 'number') { + version = String(version) + } + + if (typeof version !== 'string') { + return null + } + + options = options || {} + + var match = null + if (!options.rtl) { + match = version.match(safeRe[t.COERCE]) + } else { + // Find the right-most coercible string that does not share + // a terminus with a more left-ward coercible string. + // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4' + // + // Walk through the string checking with a /g regexp + // Manually set the index so as to pick up overlapping matches. + // Stop when we get a match that ends at the string end, since no + // coercible string can be more right-ward without the same terminus. + var next + while ((next = safeRe[t.COERCERTL].exec(version)) && + (!match || match.index + match[0].length !== version.length) + ) { + if (!match || + next.index + next[0].length !== match.index + match[0].length) { + match = next + } + safeRe[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length + } + // leave it in a clean state + safeRe[t.COERCERTL].lastIndex = -1 + } + + if (match === null) { + return null + } + + return parse(match[2] + + '.' + (match[3] || '0') + + '.' + (match[4] || '0'), options) +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/signal-exit/LICENSE.txt b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/signal-exit/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..eead04a12162dc336a2d5029bc5101c9e430aa21 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/signal-exit/LICENSE.txt @@ -0,0 +1,16 @@ +The ISC License + +Copyright (c) 2015, Contributors + +Permission to use, copy, modify, and/or distribute this software +for any purpose with or without fee is hereby granted, provided +that the above copyright notice and this permission notice +appear in all copies. + +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. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/signal-exit/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/signal-exit/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f9c7c007d550d035f81a0c310b179fee771274b1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/signal-exit/README.md @@ -0,0 +1,39 @@ +# signal-exit + +[![Build Status](https://travis-ci.org/tapjs/signal-exit.png)](https://travis-ci.org/tapjs/signal-exit) +[![Coverage](https://coveralls.io/repos/tapjs/signal-exit/badge.svg?branch=master)](https://coveralls.io/r/tapjs/signal-exit?branch=master) +[![NPM version](https://img.shields.io/npm/v/signal-exit.svg)](https://www.npmjs.com/package/signal-exit) +[![Standard Version](https://img.shields.io/badge/release-standard%20version-brightgreen.svg)](https://github.com/conventional-changelog/standard-version) + +When you want to fire an event no matter how a process exits: + +* reaching the end of execution. +* explicitly having `process.exit(code)` called. +* having `process.kill(pid, sig)` called. +* receiving a fatal signal from outside the process + +Use `signal-exit`. + +```js +var onExit = require('signal-exit') + +onExit(function (code, signal) { + console.log('process exited!') +}) +``` + +## API + +`var remove = onExit(function (code, signal) {}, options)` + +The return value of the function is a function that will remove the +handler. + +Note that the function *only* fires for signals if the signal would +cause the process to exit. That is, there are no other listeners, and +it is a fatal signal. + +## Options + +* `alwaysLast`: Run this handler after any other signal or exit + handlers. This causes `process.emit` to be monkeypatched. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/signal-exit/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/signal-exit/index.js new file mode 100644 index 0000000000000000000000000000000000000000..93703f369265c6771ae720335b27b2014049bea5 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/signal-exit/index.js @@ -0,0 +1,202 @@ +// Note: since nyc uses this module to output coverage, any lines +// that are in the direct sync flow of nyc's outputCoverage are +// ignored, since we can never get coverage for them. +// grab a reference to node's real process object right away +var process = global.process + +const processOk = function (process) { + return process && + typeof process === 'object' && + typeof process.removeListener === 'function' && + typeof process.emit === 'function' && + typeof process.reallyExit === 'function' && + typeof process.listeners === 'function' && + typeof process.kill === 'function' && + typeof process.pid === 'number' && + typeof process.on === 'function' +} + +// some kind of non-node environment, just no-op +/* istanbul ignore if */ +if (!processOk(process)) { + module.exports = function () { + return function () {} + } +} else { + var assert = require('assert') + var signals = require('./signals.js') + var isWin = /^win/i.test(process.platform) + + var EE = require('events') + /* istanbul ignore if */ + if (typeof EE !== 'function') { + EE = EE.EventEmitter + } + + var emitter + if (process.__signal_exit_emitter__) { + emitter = process.__signal_exit_emitter__ + } else { + emitter = process.__signal_exit_emitter__ = new EE() + emitter.count = 0 + emitter.emitted = {} + } + + // Because this emitter is a global, we have to check to see if a + // previous version of this library failed to enable infinite listeners. + // I know what you're about to say. But literally everything about + // signal-exit is a compromise with evil. Get used to it. + if (!emitter.infinite) { + emitter.setMaxListeners(Infinity) + emitter.infinite = true + } + + module.exports = function (cb, opts) { + /* istanbul ignore if */ + if (!processOk(global.process)) { + return function () {} + } + assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler') + + if (loaded === false) { + load() + } + + var ev = 'exit' + if (opts && opts.alwaysLast) { + ev = 'afterexit' + } + + var remove = function () { + emitter.removeListener(ev, cb) + if (emitter.listeners('exit').length === 0 && + emitter.listeners('afterexit').length === 0) { + unload() + } + } + emitter.on(ev, cb) + + return remove + } + + var unload = function unload () { + if (!loaded || !processOk(global.process)) { + return + } + loaded = false + + signals.forEach(function (sig) { + try { + process.removeListener(sig, sigListeners[sig]) + } catch (er) {} + }) + process.emit = originalProcessEmit + process.reallyExit = originalProcessReallyExit + emitter.count -= 1 + } + module.exports.unload = unload + + var emit = function emit (event, code, signal) { + /* istanbul ignore if */ + if (emitter.emitted[event]) { + return + } + emitter.emitted[event] = true + emitter.emit(event, code, signal) + } + + // { : , ... } + var sigListeners = {} + signals.forEach(function (sig) { + sigListeners[sig] = function listener () { + /* istanbul ignore if */ + if (!processOk(global.process)) { + return + } + // If there are no other listeners, an exit is coming! + // Simplest way: remove us and then re-send the signal. + // We know that this will kill the process, so we can + // safely emit now. + var listeners = process.listeners(sig) + if (listeners.length === emitter.count) { + unload() + emit('exit', null, sig) + /* istanbul ignore next */ + emit('afterexit', null, sig) + /* istanbul ignore next */ + if (isWin && sig === 'SIGHUP') { + // "SIGHUP" throws an `ENOSYS` error on Windows, + // so use a supported signal instead + sig = 'SIGINT' + } + /* istanbul ignore next */ + process.kill(process.pid, sig) + } + } + }) + + module.exports.signals = function () { + return signals + } + + var loaded = false + + var load = function load () { + if (loaded || !processOk(global.process)) { + return + } + loaded = true + + // This is the number of onSignalExit's that are in play. + // It's important so that we can count the correct number of + // listeners on signals, and don't wait for the other one to + // handle it instead of us. + emitter.count += 1 + + signals = signals.filter(function (sig) { + try { + process.on(sig, sigListeners[sig]) + return true + } catch (er) { + return false + } + }) + + process.emit = processEmit + process.reallyExit = processReallyExit + } + module.exports.load = load + + var originalProcessReallyExit = process.reallyExit + var processReallyExit = function processReallyExit (code) { + /* istanbul ignore if */ + if (!processOk(global.process)) { + return + } + process.exitCode = code || /* istanbul ignore next */ 0 + emit('exit', process.exitCode, null) + /* istanbul ignore next */ + emit('afterexit', process.exitCode, null) + /* istanbul ignore next */ + originalProcessReallyExit.call(process, process.exitCode) + } + + var originalProcessEmit = process.emit + var processEmit = function processEmit (ev, arg) { + if (ev === 'exit' && processOk(global.process)) { + /* istanbul ignore else */ + if (arg !== undefined) { + process.exitCode = arg + } + var ret = originalProcessEmit.apply(this, arguments) + /* istanbul ignore next */ + emit('exit', process.exitCode, null) + /* istanbul ignore next */ + emit('afterexit', process.exitCode, null) + /* istanbul ignore next */ + return ret + } else { + return originalProcessEmit.apply(this, arguments) + } + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/signal-exit/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/signal-exit/package.json new file mode 100644 index 0000000000000000000000000000000000000000..e1a00311f9fbe5bff5ccc01bd1d5fdbff12c34f6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/signal-exit/package.json @@ -0,0 +1,38 @@ +{ + "name": "signal-exit", + "version": "3.0.7", + "description": "when you want to fire an event no matter how a process exits.", + "main": "index.js", + "scripts": { + "test": "tap", + "snap": "tap", + "preversion": "npm test", + "postversion": "npm publish", + "prepublishOnly": "git push origin --follow-tags" + }, + "files": [ + "index.js", + "signals.js" + ], + "repository": { + "type": "git", + "url": "https://github.com/tapjs/signal-exit.git" + }, + "keywords": [ + "signal", + "exit" + ], + "author": "Ben Coe ", + "license": "ISC", + "bugs": { + "url": "https://github.com/tapjs/signal-exit/issues" + }, + "homepage": "https://github.com/tapjs/signal-exit", + "devDependencies": { + "chai": "^3.5.0", + "coveralls": "^3.1.1", + "nyc": "^15.1.0", + "standard-version": "^9.3.1", + "tap": "^15.1.1" + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/signal-exit/signals.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/signal-exit/signals.js new file mode 100644 index 0000000000000000000000000000000000000000..3bd67a8a554e30dddb9854997ab9485ac01e90dc --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/signal-exit/signals.js @@ -0,0 +1,53 @@ +// This is not the set of all possible signals. +// +// It IS, however, the set of all signals that trigger +// an exit on either Linux or BSD systems. Linux is a +// superset of the signal names supported on BSD, and +// the unknown signals just fail to register, so we can +// catch that easily enough. +// +// Don't bother with SIGKILL. It's uncatchable, which +// means that we can't fire any callbacks anyway. +// +// If a user does happen to register a handler on a non- +// fatal signal like SIGWINCH or something, and then +// exit, it'll end up firing `process.emit('exit')`, so +// the handler will be fired anyway. +// +// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised +// artificially, inherently leave the process in a +// state from which it is not safe to try and enter JS +// listeners. +module.exports = [ + 'SIGABRT', + 'SIGALRM', + 'SIGHUP', + 'SIGINT', + 'SIGTERM' +] + +if (process.platform !== 'win32') { + module.exports.push( + 'SIGVTALRM', + 'SIGXCPU', + 'SIGXFSZ', + 'SIGUSR2', + 'SIGTRAP', + 'SIGSYS', + 'SIGQUIT', + 'SIGIOT' + // should detect profiler and enable/disable accordingly. + // see #21 + // 'SIGPROF' + ) +} + +if (process.platform === 'linux') { + module.exports.push( + 'SIGIO', + 'SIGPOLL', + 'SIGPWR', + 'SIGSTKFLT', + 'SIGUNUSED' + ) +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/strip-ansi/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/strip-ansi/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..907fccc29269ebcd49141fa8a4513be3b6a8d270 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/strip-ansi/index.d.ts @@ -0,0 +1,17 @@ +/** +Strip [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code) from a string. + +@example +``` +import stripAnsi = require('strip-ansi'); + +stripAnsi('\u001B[4mUnicorn\u001B[0m'); +//=> 'Unicorn' + +stripAnsi('\u001B]8;;https://github.com\u0007Click\u001B]8;;\u0007'); +//=> 'Click' +``` +*/ +declare function stripAnsi(string: string): string; + +export = stripAnsi; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/strip-ansi/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/strip-ansi/index.js new file mode 100644 index 0000000000000000000000000000000000000000..9a593dfcd1fd5c9e627d9ff2ed85a88df9a41a99 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/strip-ansi/index.js @@ -0,0 +1,4 @@ +'use strict'; +const ansiRegex = require('ansi-regex'); + +module.exports = string => typeof string === 'string' ? string.replace(ansiRegex(), '') : string; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/strip-ansi/license b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/strip-ansi/license new file mode 100644 index 0000000000000000000000000000000000000000..e7af2f77107d73046421ef56c4684cbfdd3c1e89 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/strip-ansi/license @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) Sindre Sorhus (sindresorhus.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/strip-ansi/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/strip-ansi/package.json new file mode 100644 index 0000000000000000000000000000000000000000..1a41108d42831c9c156fdcc4e6cd8c2539983ccd --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/strip-ansi/package.json @@ -0,0 +1,54 @@ +{ + "name": "strip-ansi", + "version": "6.0.1", + "description": "Strip ANSI escape codes from a string", + "license": "MIT", + "repository": "chalk/strip-ansi", + "author": { + "name": "Sindre Sorhus", + "email": "sindresorhus@gmail.com", + "url": "sindresorhus.com" + }, + "engines": { + "node": ">=8" + }, + "scripts": { + "test": "xo && ava && tsd" + }, + "files": [ + "index.js", + "index.d.ts" + ], + "keywords": [ + "strip", + "trim", + "remove", + "ansi", + "styles", + "color", + "colour", + "colors", + "terminal", + "console", + "string", + "tty", + "escape", + "formatting", + "rgb", + "256", + "shell", + "xterm", + "log", + "logging", + "command-line", + "text" + ], + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "devDependencies": { + "ava": "^2.4.0", + "tsd": "^0.10.0", + "xo": "^0.25.3" + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/strip-ansi/readme.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/strip-ansi/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..7c4b56d46ddc72a3a627a5fd8f3dfcad8c9b599e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/strip-ansi/readme.md @@ -0,0 +1,46 @@ +# strip-ansi [![Build Status](https://travis-ci.org/chalk/strip-ansi.svg?branch=master)](https://travis-ci.org/chalk/strip-ansi) + +> Strip [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code) from a string + + +## Install + +``` +$ npm install strip-ansi +``` + + +## Usage + +```js +const stripAnsi = require('strip-ansi'); + +stripAnsi('\u001B[4mUnicorn\u001B[0m'); +//=> 'Unicorn' + +stripAnsi('\u001B]8;;https://github.com\u0007Click\u001B]8;;\u0007'); +//=> 'Click' +``` + + +## strip-ansi for enterprise + +Available as part of the Tidelift Subscription. + +The maintainers of strip-ansi and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-strip-ansi?utm_source=npm-strip-ansi&utm_medium=referral&utm_campaign=enterprise&utm_term=repo) + + +## Related + +- [strip-ansi-cli](https://github.com/chalk/strip-ansi-cli) - CLI for this module +- [strip-ansi-stream](https://github.com/chalk/strip-ansi-stream) - Streaming version of this module +- [has-ansi](https://github.com/chalk/has-ansi) - Check if a string has ANSI escape codes +- [ansi-regex](https://github.com/chalk/ansi-regex) - Regular expression for matching ANSI escape codes +- [chalk](https://github.com/chalk/chalk) - Terminal string styling done right + + +## Maintainers + +- [Sindre Sorhus](https://github.com/sindresorhus) +- [Josh Junon](https://github.com/qix-) + diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/supports-color/browser.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/supports-color/browser.js new file mode 100644 index 0000000000000000000000000000000000000000..f097aecd76a090174e5c3371234043d1ddc5d5fd --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/supports-color/browser.js @@ -0,0 +1,24 @@ +/* eslint-env browser */ +'use strict'; + +function getChromeVersion() { + const matches = /(Chrome|Chromium)\/(?\d+)\./.exec(navigator.userAgent); + + if (!matches) { + return; + } + + return Number.parseInt(matches.groups.chromeVersion, 10); +} + +const colorSupport = getChromeVersion() >= 69 ? { + level: 1, + hasBasic: true, + has256: false, + has16m: false +} : false; + +module.exports = { + stdout: colorSupport, + stderr: colorSupport +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/supports-color/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/supports-color/index.js new file mode 100644 index 0000000000000000000000000000000000000000..2dd2fcb0b057d0de56990ad41692550183830c09 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/supports-color/index.js @@ -0,0 +1,152 @@ +'use strict'; +const os = require('os'); +const tty = require('tty'); +const hasFlag = require('has-flag'); + +const {env} = process; + +let flagForceColor; +if (hasFlag('no-color') || + hasFlag('no-colors') || + hasFlag('color=false') || + hasFlag('color=never')) { + flagForceColor = 0; +} else if (hasFlag('color') || + hasFlag('colors') || + hasFlag('color=true') || + hasFlag('color=always')) { + flagForceColor = 1; +} + +function envForceColor() { + if ('FORCE_COLOR' in env) { + if (env.FORCE_COLOR === 'true') { + return 1; + } + + if (env.FORCE_COLOR === 'false') { + return 0; + } + + return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3); + } +} + +function translateLevel(level) { + if (level === 0) { + return false; + } + + return { + level, + hasBasic: true, + has256: level >= 2, + has16m: level >= 3 + }; +} + +function supportsColor(haveStream, {streamIsTTY, sniffFlags = true} = {}) { + const noFlagForceColor = envForceColor(); + if (noFlagForceColor !== undefined) { + flagForceColor = noFlagForceColor; + } + + const forceColor = sniffFlags ? flagForceColor : noFlagForceColor; + + if (forceColor === 0) { + return 0; + } + + if (sniffFlags) { + if (hasFlag('color=16m') || + hasFlag('color=full') || + hasFlag('color=truecolor')) { + return 3; + } + + if (hasFlag('color=256')) { + return 2; + } + } + + if (haveStream && !streamIsTTY && forceColor === undefined) { + return 0; + } + + const min = forceColor || 0; + + if (env.TERM === 'dumb') { + return min; + } + + if (process.platform === 'win32') { + // Windows 10 build 10586 is the first Windows release that supports 256 colors. + // Windows 10 build 14931 is the first release that supports 16m/TrueColor. + const osRelease = os.release().split('.'); + if ( + Number(osRelease[0]) >= 10 && + Number(osRelease[2]) >= 10586 + ) { + return Number(osRelease[2]) >= 14931 ? 3 : 2; + } + + return 1; + } + + if ('CI' in env) { + if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE', 'DRONE'].some(sign => sign in env) || env.CI_NAME === 'codeship') { + return 1; + } + + return min; + } + + if ('TEAMCITY_VERSION' in env) { + return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0; + } + + if (env.COLORTERM === 'truecolor') { + return 3; + } + + if ('TERM_PROGRAM' in env) { + const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10); + + switch (env.TERM_PROGRAM) { + case 'iTerm.app': + return version >= 3 ? 3 : 2; + case 'Apple_Terminal': + return 2; + // No default + } + } + + if (/-256(color)?$/i.test(env.TERM)) { + return 2; + } + + if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) { + return 1; + } + + if ('COLORTERM' in env) { + return 1; + } + + return min; +} + +function getSupportLevel(stream, options = {}) { + const level = supportsColor(stream, { + streamIsTTY: stream && stream.isTTY, + ...options + }); + + return translateLevel(level); +} + +module.exports = { + supportsColor: getSupportLevel, + stdout: getSupportLevel({isTTY: tty.isatty(1)}), + stderr: getSupportLevel({isTTY: tty.isatty(2)}) +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/supports-color/license b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/supports-color/license new file mode 100644 index 0000000000000000000000000000000000000000..fa7ceba3eb4a9657a9db7f3ffca4e4e97a9019de --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/supports-color/license @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) Sindre Sorhus (https://sindresorhus.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/supports-color/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/supports-color/package.json new file mode 100644 index 0000000000000000000000000000000000000000..a97bf2a108df2dc34563500e109b98e910169684 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/supports-color/package.json @@ -0,0 +1,58 @@ +{ + "name": "supports-color", + "version": "8.1.1", + "description": "Detect whether a terminal supports color", + "license": "MIT", + "repository": "chalk/supports-color", + "funding": "https://github.com/chalk/supports-color?sponsor=1", + "author": { + "name": "Sindre Sorhus", + "email": "sindresorhus@gmail.com", + "url": "https://sindresorhus.com" + }, + "engines": { + "node": ">=10" + }, + "scripts": { + "test": "xo && ava" + }, + "files": [ + "index.js", + "browser.js" + ], + "exports": { + "node": "./index.js", + "default": "./browser.js" + }, + "keywords": [ + "color", + "colour", + "colors", + "terminal", + "console", + "cli", + "ansi", + "styles", + "tty", + "rgb", + "256", + "shell", + "xterm", + "command-line", + "support", + "supports", + "capability", + "detect", + "truecolor", + "16m" + ], + "dependencies": { + "has-flag": "^4.0.0" + }, + "devDependencies": { + "ava": "^2.4.0", + "import-fresh": "^3.2.2", + "xo": "^0.35.0" + }, + "browser": "browser.js" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/supports-color/readme.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/supports-color/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..3eedd1caa40a0db02f9266e7efdb1c9c46837063 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/supports-color/readme.md @@ -0,0 +1,77 @@ +# supports-color + +> Detect whether a terminal supports color + +## Install + +``` +$ npm install supports-color +``` + +## Usage + +```js +const supportsColor = require('supports-color'); + +if (supportsColor.stdout) { + console.log('Terminal stdout supports color'); +} + +if (supportsColor.stdout.has256) { + console.log('Terminal stdout supports 256 colors'); +} + +if (supportsColor.stderr.has16m) { + console.log('Terminal stderr supports 16 million colors (truecolor)'); +} +``` + +## API + +Returns an `Object` with a `stdout` and `stderr` property for testing either streams. Each property is an `Object`, or `false` if color is not supported. + +The `stdout`/`stderr` objects specifies a level of support for color through a `.level` property and a corresponding flag: + +- `.level = 1` and `.hasBasic = true`: Basic color support (16 colors) +- `.level = 2` and `.has256 = true`: 256 color support +- `.level = 3` and `.has16m = true`: Truecolor support (16 million colors) + +### `require('supports-color').supportsColor(stream, options?)` + +Additionally, `supports-color` exposes the `.supportsColor()` function that takes an arbitrary write stream (e.g. `process.stdout`) and an optional options object to (re-)evaluate color support for an arbitrary stream. + +For example, `require('supports-color').stdout` is the equivalent of `require('supports-color').supportsColor(process.stdout)`. + +The options object supports a single boolean property `sniffFlags`. By default it is `true`, which instructs `supportsColor()` to sniff `process.argv` for the multitude of `--color` flags (see _Info_ below). If `false`, then `process.argv` is not considered when determining color support. + +## Info + +It obeys the `--color` and `--no-color` CLI flags. + +For situations where using `--color` is not possible, use the environment variable `FORCE_COLOR=1` (level 1), `FORCE_COLOR=2` (level 2), or `FORCE_COLOR=3` (level 3) to forcefully enable color, or `FORCE_COLOR=0` to forcefully disable. The use of `FORCE_COLOR` overrides all other color support checks. + +Explicit 256/Truecolor mode can be enabled using the `--color=256` and `--color=16m` flags, respectively. + +## Related + +- [supports-color-cli](https://github.com/chalk/supports-color-cli) - CLI for this module +- [chalk](https://github.com/chalk/chalk) - Terminal string styling done right + +## Maintainers + +- [Sindre Sorhus](https://github.com/sindresorhus) +- [Josh Junon](https://github.com/qix-) + +--- + +
+ + Get professional support for this package with a Tidelift subscription + +
+ + Tidelift helps make open source sustainable for maintainers while giving companies
assurances about security, maintenance, and licensing for their dependencies. + +
+ +--- diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/write-file-atomic/LICENSE.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/write-file-atomic/LICENSE.md new file mode 100644 index 0000000000000000000000000000000000000000..95e65a7706e0e9702fa110e3e59fcf001cda2daa --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/write-file-atomic/LICENSE.md @@ -0,0 +1,6 @@ +Copyright (c) 2015, Rebecca Turner + +Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. + +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. + diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/write-file-atomic/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/write-file-atomic/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2d9ef6024559fb8b1c57e359120dd38416111244 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/write-file-atomic/README.md @@ -0,0 +1,91 @@ +write-file-atomic +----------------- + +This is an extension for node's `fs.writeFile` that makes its operation +atomic and allows you set ownership (uid/gid of the file). + +### `writeFileAtomic(filename, data, [options], [callback])` + +#### Description: + +Atomically and asynchronously writes data to a file, replacing the file if it already +exists. data can be a string or a buffer. + +#### Options: +* filename **String** +* data **String** | **Buffer** +* options **Object** | **String** + * chown **Object** default, uid & gid of existing file, if any + * uid **Number** + * gid **Number** + * encoding **String** | **Null** default = 'utf8' + * fsync **Boolean** default = true + * mode **Number** default, from existing file, if any + * tmpfileCreated **Function** called when the tmpfile is created +* callback **Function** + +#### Usage: + +```js +var writeFileAtomic = require('write-file-atomic') +writeFileAtomic(filename, data, [options], [callback]) +``` + +The file is initially named `filename + "." + murmurhex(__filename, process.pid, ++invocations)`. +Note that `require('worker_threads').threadId` is used in addition to `process.pid` if running inside of a worker thread. +If writeFile completes successfully then, if passed the **chown** option it will change +the ownership of the file. Finally it renames the file back to the filename you specified. If +it encounters errors at any of these steps it will attempt to unlink the temporary file and then +pass the error back to the caller. +If multiple writes are concurrently issued to the same file, the write operations are put into a queue and serialized in the order they were called, using Promises. Writes to different files are still executed in parallel. + +If provided, the **chown** option requires both **uid** and **gid** properties or else +you'll get an error. If **chown** is not specified it will default to using +the owner of the previous file. To prevent chown from being ran you can +also pass `false`, in which case the file will be created with the current user's credentials. + +If **mode** is not specified, it will default to using the permissions from +an existing file, if any. Expicitly setting this to `false` remove this default, resulting +in a file created with the system default permissions. + +If options is a String, it's assumed to be the **encoding** option. The **encoding** option is ignored if **data** is a buffer. It defaults to 'utf8'. + +If the **fsync** option is **false**, writeFile will skip the final fsync call. + +If the **tmpfileCreated** option is specified it will be called with the name of the tmpfile when created. + +Example: + +```javascript +writeFileAtomic('message.txt', 'Hello Node', {chown:{uid:100,gid:50}}, function (err) { + if (err) throw err; + console.log('It\'s saved!'); +}); +``` + +This function also supports async/await: + +```javascript +(async () => { + try { + await writeFileAtomic('message.txt', 'Hello Node', {chown:{uid:100,gid:50}}); + console.log('It\'s saved!'); + } catch (err) { + console.error(err); + process.exit(1); + } +})(); +``` + +### `writeFileAtomicSync(filename, data, [options])` + +#### Description: + +The synchronous version of **writeFileAtomic**. + +#### Usage: +```js +var writeFileAtomicSync = require('write-file-atomic').sync +writeFileAtomicSync(filename, data, [options]) +``` + diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/write-file-atomic/lib/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/write-file-atomic/lib/index.js new file mode 100644 index 0000000000000000000000000000000000000000..9d79d797a553fe58875787cc20c9fa687268f67e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/write-file-atomic/lib/index.js @@ -0,0 +1,267 @@ +'use strict' +module.exports = writeFile +module.exports.sync = writeFileSync +module.exports._getTmpname = getTmpname // for testing +module.exports._cleanupOnExit = cleanupOnExit + +const fs = require('fs') +const MurmurHash3 = require('imurmurhash') +const onExit = require('signal-exit') +const path = require('path') +const { promisify } = require('util') +const activeFiles = {} + +// if we run inside of a worker_thread, `process.pid` is not unique +/* istanbul ignore next */ +const threadId = (function getId () { + try { + const workerThreads = require('worker_threads') + + /// if we are in main thread, this is set to `0` + return workerThreads.threadId + } catch (e) { + // worker_threads are not available, fallback to 0 + return 0 + } +})() + +let invocations = 0 +function getTmpname (filename) { + return filename + '.' + + MurmurHash3(__filename) + .hash(String(process.pid)) + .hash(String(threadId)) + .hash(String(++invocations)) + .result() +} + +function cleanupOnExit (tmpfile) { + return () => { + try { + fs.unlinkSync(typeof tmpfile === 'function' ? tmpfile() : tmpfile) + } catch { + // ignore errors + } + } +} + +function serializeActiveFile (absoluteName) { + return new Promise(resolve => { + // make a queue if it doesn't already exist + if (!activeFiles[absoluteName]) { + activeFiles[absoluteName] = [] + } + + activeFiles[absoluteName].push(resolve) // add this job to the queue + if (activeFiles[absoluteName].length === 1) { + resolve() + } // kick off the first one + }) +} + +// https://github.com/isaacs/node-graceful-fs/blob/master/polyfills.js#L315-L342 +function isChownErrOk (err) { + if (err.code === 'ENOSYS') { + return true + } + + const nonroot = !process.getuid || process.getuid() !== 0 + if (nonroot) { + if (err.code === 'EINVAL' || err.code === 'EPERM') { + return true + } + } + + return false +} + +async function writeFileAsync (filename, data, options = {}) { + if (typeof options === 'string') { + options = { encoding: options } + } + + let fd + let tmpfile + /* istanbul ignore next -- The closure only gets called when onExit triggers */ + const removeOnExitHandler = onExit(cleanupOnExit(() => tmpfile)) + const absoluteName = path.resolve(filename) + + try { + await serializeActiveFile(absoluteName) + const truename = await promisify(fs.realpath)(filename).catch(() => filename) + tmpfile = getTmpname(truename) + + if (!options.mode || !options.chown) { + // Either mode or chown is not explicitly set + // Default behavior is to copy it from original file + const stats = await promisify(fs.stat)(truename).catch(() => {}) + if (stats) { + if (options.mode == null) { + options.mode = stats.mode + } + + if (options.chown == null && process.getuid) { + options.chown = { uid: stats.uid, gid: stats.gid } + } + } + } + + fd = await promisify(fs.open)(tmpfile, 'w', options.mode) + if (options.tmpfileCreated) { + await options.tmpfileCreated(tmpfile) + } + if (ArrayBuffer.isView(data)) { + await promisify(fs.write)(fd, data, 0, data.length, 0) + } else if (data != null) { + await promisify(fs.write)(fd, String(data), 0, String(options.encoding || 'utf8')) + } + + if (options.fsync !== false) { + await promisify(fs.fsync)(fd) + } + + await promisify(fs.close)(fd) + fd = null + + if (options.chown) { + await promisify(fs.chown)(tmpfile, options.chown.uid, options.chown.gid).catch(err => { + if (!isChownErrOk(err)) { + throw err + } + }) + } + + if (options.mode) { + await promisify(fs.chmod)(tmpfile, options.mode).catch(err => { + if (!isChownErrOk(err)) { + throw err + } + }) + } + + await promisify(fs.rename)(tmpfile, truename) + } finally { + if (fd) { + await promisify(fs.close)(fd).catch( + /* istanbul ignore next */ + () => {} + ) + } + removeOnExitHandler() + await promisify(fs.unlink)(tmpfile).catch(() => {}) + activeFiles[absoluteName].shift() // remove the element added by serializeSameFile + if (activeFiles[absoluteName].length > 0) { + activeFiles[absoluteName][0]() // start next job if one is pending + } else { + delete activeFiles[absoluteName] + } + } +} + +async function writeFile (filename, data, options, callback) { + if (options instanceof Function) { + callback = options + options = {} + } + + const promise = writeFileAsync(filename, data, options) + if (callback) { + try { + const result = await promise + return callback(result) + } catch (err) { + return callback(err) + } + } + + return promise +} + +function writeFileSync (filename, data, options) { + if (typeof options === 'string') { + options = { encoding: options } + } else if (!options) { + options = {} + } + try { + filename = fs.realpathSync(filename) + } catch (ex) { + // it's ok, it'll happen on a not yet existing file + } + const tmpfile = getTmpname(filename) + + if (!options.mode || !options.chown) { + // Either mode or chown is not explicitly set + // Default behavior is to copy it from original file + try { + const stats = fs.statSync(filename) + options = Object.assign({}, options) + if (!options.mode) { + options.mode = stats.mode + } + if (!options.chown && process.getuid) { + options.chown = { uid: stats.uid, gid: stats.gid } + } + } catch (ex) { + // ignore stat errors + } + } + + let fd + const cleanup = cleanupOnExit(tmpfile) + const removeOnExitHandler = onExit(cleanup) + + let threw = true + try { + fd = fs.openSync(tmpfile, 'w', options.mode || 0o666) + if (options.tmpfileCreated) { + options.tmpfileCreated(tmpfile) + } + if (ArrayBuffer.isView(data)) { + fs.writeSync(fd, data, 0, data.length, 0) + } else if (data != null) { + fs.writeSync(fd, String(data), 0, String(options.encoding || 'utf8')) + } + if (options.fsync !== false) { + fs.fsyncSync(fd) + } + + fs.closeSync(fd) + fd = null + + if (options.chown) { + try { + fs.chownSync(tmpfile, options.chown.uid, options.chown.gid) + } catch (err) { + if (!isChownErrOk(err)) { + throw err + } + } + } + + if (options.mode) { + try { + fs.chmodSync(tmpfile, options.mode) + } catch (err) { + if (!isChownErrOk(err)) { + throw err + } + } + } + + fs.renameSync(tmpfile, filename) + threw = false + } finally { + if (fd) { + try { + fs.closeSync(fd) + } catch (ex) { + // ignore close errors at this stage, error may have closed fd already. + } + } + removeOnExitHandler() + if (threw) { + cleanup() + } + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/write-file-atomic/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/write-file-atomic/package.json new file mode 100644 index 0000000000000000000000000000000000000000..86e2a0fbadfeb67c0f8e3da266a22e1daf3c8c9c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/node_modules/write-file-atomic/package.json @@ -0,0 +1,55 @@ +{ + "name": "write-file-atomic", + "version": "4.0.2", + "description": "Write files in an atomic fashion w/configurable ownership", + "main": "./lib/index.js", + "scripts": { + "test": "tap", + "posttest": "npm run lint", + "lint": "eslint \"**/*.js\"", + "postlint": "template-oss-check", + "preversion": "npm test", + "postversion": "npm publish", + "prepublishOnly": "git push origin --follow-tags", + "lintfix": "npm run lint -- --fix", + "snap": "tap", + "template-oss-apply": "template-oss-apply --force" + }, + "repository": { + "type": "git", + "url": "https://github.com/npm/write-file-atomic.git" + }, + "keywords": [ + "writeFile", + "atomic" + ], + "author": "GitHub Inc.", + "license": "ISC", + "bugs": { + "url": "https://github.com/npm/write-file-atomic/issues" + }, + "homepage": "https://github.com/npm/write-file-atomic", + "dependencies": { + "imurmurhash": "^0.1.4", + "signal-exit": "^3.0.7" + }, + "devDependencies": { + "@npmcli/eslint-config": "^3.0.1", + "@npmcli/template-oss": "3.5.0", + "mkdirp": "^1.0.4", + "rimraf": "^3.0.2", + "tap": "^16.0.1" + }, + "files": [ + "bin/", + "lib/" + ], + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + }, + "templateOSS": { + "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.", + "windowsCI": false, + "version": "3.5.0" + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/package.json new file mode 100644 index 0000000000000000000000000000000000000000..5e5410ef7873fc68863dbde3dca56c8be82ce04a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/core/package.json @@ -0,0 +1,102 @@ +{ + "name": "@jest/core", + "description": "Delightful JavaScript Testing.", + "version": "29.7.0", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "dependencies": { + "@jest/console": "^29.7.0", + "@jest/reporters": "^29.7.0", + "@jest/test-result": "^29.7.0", + "@jest/transform": "^29.7.0", + "@jest/types": "^29.6.3", + "@types/node": "*", + "ansi-escapes": "^4.2.1", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "exit": "^0.1.2", + "graceful-fs": "^4.2.9", + "jest-changed-files": "^29.7.0", + "jest-config": "^29.7.0", + "jest-haste-map": "^29.7.0", + "jest-message-util": "^29.7.0", + "jest-regex-util": "^29.6.3", + "jest-resolve": "^29.7.0", + "jest-resolve-dependencies": "^29.7.0", + "jest-runner": "^29.7.0", + "jest-runtime": "^29.7.0", + "jest-snapshot": "^29.7.0", + "jest-util": "^29.7.0", + "jest-validate": "^29.7.0", + "jest-watcher": "^29.7.0", + "micromatch": "^4.0.4", + "pretty-format": "^29.7.0", + "slash": "^3.0.0", + "strip-ansi": "^6.0.0" + }, + "devDependencies": { + "@jest/test-sequencer": "^29.7.0", + "@jest/test-utils": "^29.7.0", + "@types/exit": "^0.1.30", + "@types/graceful-fs": "^4.1.3", + "@types/micromatch": "^4.0.1" + }, + "peerDependencies": { + "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" + }, + "peerDependenciesMeta": { + "node-notifier": { + "optional": true + } + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/jest-core" + }, + "bugs": { + "url": "https://github.com/jestjs/jest/issues" + }, + "homepage": "https://jestjs.io/", + "license": "MIT", + "keywords": [ + "ava", + "babel", + "coverage", + "easy", + "expect", + "facebook", + "immersive", + "instant", + "jasmine", + "jest", + "jsdom", + "mocha", + "mocking", + "painless", + "qunit", + "runner", + "sandboxed", + "snapshot", + "tap", + "tape", + "test", + "testing", + "typescript", + "watch" + ], + "publishConfig": { + "access": "public" + }, + "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/environment/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/environment/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/environment/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/environment/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/environment/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1837e6ac01f7e6d73f7b82844b20e8c59f14fa77 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/environment/build/index.d.ts @@ -0,0 +1,418 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/// + +import type {Circus} from '@jest/types'; +import type {Config} from '@jest/types'; +import type {Context} from 'vm'; +import type {Global} from '@jest/types'; +import type {LegacyFakeTimers} from '@jest/fake-timers'; +import type {Mocked} from 'jest-mock'; +import type {ModernFakeTimers} from '@jest/fake-timers'; +import type {ModuleMocker} from 'jest-mock'; + +export declare type EnvironmentContext = { + console: Console; + docblockPragmas: Record>; + testPath: string; +}; + +export declare interface Jest { + /** + * Advances all timers by `msToRun` milliseconds. All pending "macro-tasks" + * that have been queued via `setTimeout()` or `setInterval()`, and would be + * executed within this time frame will be executed. + */ + advanceTimersByTime(msToRun: number): void; + /** + * Advances all timers by `msToRun` milliseconds, firing callbacks if necessary. + * + * @remarks + * Not available when using legacy fake timers implementation. + */ + advanceTimersByTimeAsync(msToRun: number): Promise; + /** + * Advances all timers by the needed milliseconds so that only the next + * timeouts/intervals will run. Optionally, you can provide steps, so it will + * run steps amount of next timeouts/intervals. + */ + advanceTimersToNextTimer(steps?: number): void; + /** + * Advances the clock to the the moment of the first scheduled timer, firing it. + * Optionally, you can provide steps, so it will run steps amount of + * next timeouts/intervals. + * + * @remarks + * Not available when using legacy fake timers implementation. + */ + advanceTimersToNextTimerAsync(steps?: number): Promise; + /** + * Disables automatic mocking in the module loader. + */ + autoMockOff(): Jest; + /** + * Enables automatic mocking in the module loader. + */ + autoMockOn(): Jest; + /** + * Clears the `mock.calls`, `mock.instances`, `mock.contexts` and `mock.results` properties of + * all mocks. Equivalent to calling `.mockClear()` on every mocked function. + */ + clearAllMocks(): Jest; + /** + * Removes any pending timers from the timer system. If any timers have been + * scheduled, they will be cleared and will never have the opportunity to + * execute in the future. + */ + clearAllTimers(): void; + /** + * Given the name of a module, use the automatic mocking system to generate a + * mocked version of the module for you. + * + * This is useful when you want to create a manual mock that extends the + * automatic mock's behavior. + */ + createMockFromModule(moduleName: string): Mocked; + /** + * Indicates that the module system should never return a mocked version of + * the specified module and its dependencies. + */ + deepUnmock(moduleName: string): Jest; + /** + * Disables automatic mocking in the module loader. + * + * After this method is called, all `require()`s will return the real + * versions of each module (rather than a mocked version). + */ + disableAutomock(): Jest; + /** + * When using `babel-jest`, calls to `jest.mock()` will automatically be hoisted + * to the top of the code block. Use this method if you want to explicitly + * avoid this behavior. + */ + doMock( + moduleName: string, + moduleFactory?: () => T, + options?: { + virtual?: boolean; + }, + ): Jest; + /** + * When using `babel-jest`, calls to `jest.unmock()` will automatically be hoisted + * to the top of the code block. Use this method if you want to explicitly + * avoid this behavior. + */ + dontMock(moduleName: string): Jest; + /** + * Enables automatic mocking in the module loader. + */ + enableAutomock(): Jest; + /** + * Creates a mock function. Optionally takes a mock implementation. + */ + fn: ModuleMocker['fn']; + /** + * Given the name of a module, use the automatic mocking system to generate a + * mocked version of the module for you. + * + * This is useful when you want to create a manual mock that extends the + * automatic mock's behavior. + * + * @deprecated Use `jest.createMockFromModule()` instead + */ + genMockFromModule(moduleName: string): Mocked; + /** + * When mocking time, `Date.now()` will also be mocked. If you for some reason + * need access to the real current time, you can invoke this function. + * + * @remarks + * Not available when using legacy fake timers implementation. + */ + getRealSystemTime(): number; + /** + * Retrieves the seed value. It will be randomly generated for each test run + * or can be manually set via the `--seed` CLI argument. + */ + getSeed(): number; + /** + * Returns the number of fake timers still left to run. + */ + getTimerCount(): number; + /** + * Returns `true` if test environment has been torn down. + * + * @example + * ```js + * if (jest.isEnvironmentTornDown()) { + * // The Jest environment has been torn down, so stop doing work + * return; + * } + * ``` + */ + isEnvironmentTornDown(): boolean; + /** + * Determines if the given function is a mocked function. + */ + isMockFunction: ModuleMocker['isMockFunction']; + /** + * `jest.isolateModules()` goes a step further than `jest.resetModules()` and + * creates a sandbox registry for the modules that are loaded inside the callback + * function. This is useful to isolate specific modules for every test so that + * local module state doesn't conflict between tests. + */ + isolateModules(fn: () => void): Jest; + /** + * `jest.isolateModulesAsync()` is the equivalent of `jest.isolateModules()`, but for + * async functions to be wrapped. The caller is expected to `await` the completion of + * `isolateModulesAsync`. + */ + isolateModulesAsync(fn: () => Promise): Promise; + /** + * Mocks a module with an auto-mocked version when it is being required. + */ + mock( + moduleName: string, + moduleFactory?: () => T, + options?: { + virtual?: boolean; + }, + ): Jest; + /** + * Mocks a module with the provided module factory when it is being imported. + */ + unstable_mockModule( + moduleName: string, + moduleFactory: () => T | Promise, + options?: { + virtual?: boolean; + }, + ): Jest; + /** + * Wraps types of the `source` object and its deep members with type definitions + * of Jest mock function. Pass `{shallow: true}` option to disable the deeply + * mocked behavior. + */ + mocked: ModuleMocker['mocked']; + /** + * Returns the current time in ms of the fake timer clock. + */ + now(): number; + /** + * Replaces property on an object with another value. + * + * @remarks + * For mocking functions or 'get' or 'set' accessors, use `jest.spyOn()` instead. + */ + replaceProperty: ModuleMocker['replaceProperty']; + /** + * Returns the actual module instead of a mock, bypassing all checks on + * whether the module should receive a mock implementation or not. + * + * @example + * ```js + * jest.mock('../myModule', () => { + * // Require the original module to not be mocked... + * const originalModule = jest.requireActual('../myModule'); + * + * return { + * __esModule: true, // Use it when dealing with esModules + * ...originalModule, + * getRandom: jest.fn().mockReturnValue(10), + * }; + * }); + * + * const getRandom = require('../myModule').getRandom; + * + * getRandom(); // Always returns 10 + * ``` + */ + requireActual(moduleName: string): T; + /** + * Returns a mock module instead of the actual module, bypassing all checks + * on whether the module should be required normally or not. + */ + requireMock(moduleName: string): T; + /** + * Resets the state of all mocks. Equivalent to calling `.mockReset()` on + * every mocked function. + */ + resetAllMocks(): Jest; + /** + * Resets the module registry - the cache of all required modules. This is + * useful to isolate modules where local state might conflict between tests. + */ + resetModules(): Jest; + /** + * Restores all mocks and replaced properties back to their original value. + * Equivalent to calling `.mockRestore()` on every mocked function + * and `.restore()` on every replaced property. + * + * Beware that `jest.restoreAllMocks()` only works when the mock was created + * with `jest.spyOn()`; other mocks will require you to manually restore them. + */ + restoreAllMocks(): Jest; + /** + * Runs failed tests n-times until they pass or until the max number of + * retries is exhausted. + * + * If `logErrorsBeforeRetry` is enabled, Jest will log the error(s) that caused + * the test to fail to the console, providing visibility on why a retry occurred. + * retries is exhausted. + * + * @remarks + * Only available with `jest-circus` runner. + */ + retryTimes( + numRetries: number, + options?: { + logErrorsBeforeRetry?: boolean; + }, + ): Jest; + /** + * Exhausts tasks queued by `setImmediate()`. + * + * @remarks + * Only available when using legacy fake timers implementation. + */ + runAllImmediates(): void; + /** + * Exhausts the micro-task queue (usually interfaced in node via + * `process.nextTick()`). + */ + runAllTicks(): void; + /** + * Exhausts the macro-task queue (i.e., all tasks queued by `setTimeout()` + * and `setInterval()`). + */ + runAllTimers(): void; + /** + * Exhausts the macro-task queue (i.e., all tasks queued by `setTimeout()` + * and `setInterval()`). + * + * @remarks + * If new timers are added while it is executing they will be run as well. + * @remarks + * Not available when using legacy fake timers implementation. + */ + runAllTimersAsync(): Promise; + /** + * Executes only the macro-tasks that are currently pending (i.e., only the + * tasks that have been queued by `setTimeout()` or `setInterval()` up to this + * point). If any of the currently pending macro-tasks schedule new + * macro-tasks, those new tasks will not be executed by this call. + */ + runOnlyPendingTimers(): void; + /** + * Executes only the macro-tasks that are currently pending (i.e., only the + * tasks that have been queued by `setTimeout()` or `setInterval()` up to this + * point). If any of the currently pending macro-tasks schedule new + * macro-tasks, those new tasks will not be executed by this call. + * + * @remarks + * Not available when using legacy fake timers implementation. + */ + runOnlyPendingTimersAsync(): Promise; + /** + * Explicitly supplies the mock object that the module system should return + * for the specified module. + * + * @remarks + * It is recommended to use `jest.mock()` instead. The `jest.mock()` API's second + * argument is a module factory instead of the expected exported module object. + */ + setMock(moduleName: string, moduleExports: unknown): Jest; + /** + * Set the current system time used by fake timers. Simulates a user changing + * the system clock while your program is running. It affects the current time, + * but it does not in itself cause e.g. timers to fire; they will fire exactly + * as they would have done without the call to `jest.setSystemTime()`. + * + * @remarks + * Not available when using legacy fake timers implementation. + */ + setSystemTime(now?: number | Date): void; + /** + * Set the default timeout interval for tests and before/after hooks in + * milliseconds. + * + * @remarks + * The default timeout interval is 5 seconds if this method is not called. + */ + setTimeout(timeout: number): Jest; + /** + * Creates a mock function similar to `jest.fn()` but also tracks calls to + * `object[methodName]`. + * + * Optional third argument of `accessType` can be either 'get' or 'set', which + * proves to be useful when you want to spy on a getter or a setter, respectively. + * + * @remarks + * By default, `jest.spyOn()` also calls the spied method. This is different + * behavior from most other test libraries. + */ + spyOn: ModuleMocker['spyOn']; + /** + * Indicates that the module system should never return a mocked version of + * the specified module from `require()` (e.g. that it should always return the + * real module). + */ + unmock(moduleName: string): Jest; + /** + * Instructs Jest to use fake versions of the global date, performance, + * time and timer APIs. Fake timers implementation is backed by + * [`@sinonjs/fake-timers`](https://github.com/sinonjs/fake-timers). + * + * @remarks + * Calling `jest.useFakeTimers()` once again in the same test file would reinstall + * fake timers using the provided options. + */ + useFakeTimers( + fakeTimersConfig?: Config.FakeTimersConfig | Config.LegacyFakeTimersConfig, + ): Jest; + /** + * Instructs Jest to restore the original implementations of the global date, + * performance, time and timer APIs. + */ + useRealTimers(): Jest; +} + +export declare class JestEnvironment { + constructor(config: JestEnvironmentConfig, context: EnvironmentContext); + global: Global.Global; + fakeTimers: LegacyFakeTimers | null; + fakeTimersModern: ModernFakeTimers | null; + moduleMocker: ModuleMocker | null; + getVmContext(): Context | null; + setup(): Promise; + teardown(): Promise; + handleTestEvent?: Circus.EventHandler; + exportConditions?: () => Array; +} + +export declare interface JestEnvironmentConfig { + projectConfig: Config.ProjectConfig; + globalConfig: Config.GlobalConfig; +} + +export declare interface JestImportMeta extends ImportMeta { + jest: Jest; +} + +export declare type Module = NodeModule; + +export declare type ModuleWrapper = ( + this: Module['exports'], + module: Module, + exports: Module['exports'], + require: Module['require'], + __dirname: string, + __filename: Module['filename'], + jest?: Jest, + ...sandboxInjectedGlobals: Array +) => unknown; + +export {}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/environment/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/environment/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..ad9a93a7c160f02945911772460eb8a1bcb003db --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/environment/build/index.js @@ -0,0 +1 @@ +'use strict'; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/environment/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/environment/package.json new file mode 100644 index 0000000000000000000000000000000000000000..293360300c159287f7e849a8e9995ff876c80a7d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/environment/package.json @@ -0,0 +1,32 @@ +{ + "name": "@jest/environment", + "version": "29.7.0", + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/jest-environment" + }, + "license": "MIT", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "dependencies": { + "@jest/fake-timers": "^29.7.0", + "@jest/types": "^29.6.3", + "@types/node": "*", + "jest-mock": "^29.7.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "publishConfig": { + "access": "public" + }, + "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/README.md new file mode 100644 index 0000000000000000000000000000000000000000..12ae8b2f0fea33cc73c457f7962be67255cfc522 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/README.md @@ -0,0 +1,5 @@ +# `@jest/expect-utils` + +This module exports some utils for the `expect` function used in [Jest](https://jestjs.io/). + +You probably don't want to use this package directly. E.g. if you're writing [custom matcher](https://jestjs.io/docs/expect#expectextendmatchers), you should use the injected [`this.equals`](https://jestjs.io/docs/expect#thisequalsa-b). diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/build/immutableUtils.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/build/immutableUtils.js new file mode 100644 index 0000000000000000000000000000000000000000..f61ee6cbb6e46d0c94ec0ebadfdfcaf461a3b1ae --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/build/immutableUtils.js @@ -0,0 +1,66 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.isImmutableList = isImmutableList; +exports.isImmutableOrderedKeyed = isImmutableOrderedKeyed; +exports.isImmutableOrderedSet = isImmutableOrderedSet; +exports.isImmutableRecord = isImmutableRecord; +exports.isImmutableUnorderedKeyed = isImmutableUnorderedKeyed; +exports.isImmutableUnorderedSet = isImmutableUnorderedSet; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + */ + +// SENTINEL constants are from https://github.com/immutable-js/immutable-js/tree/main/src/predicates +const IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@'; +const IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@'; +const IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@'; +const IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@'; +const IS_RECORD_SYMBOL = '@@__IMMUTABLE_RECORD__@@'; +function isObjectLiteral(source) { + return source != null && typeof source === 'object' && !Array.isArray(source); +} +function isImmutableUnorderedKeyed(source) { + return Boolean( + source && + isObjectLiteral(source) && + source[IS_KEYED_SENTINEL] && + !source[IS_ORDERED_SENTINEL] + ); +} +function isImmutableUnorderedSet(source) { + return Boolean( + source && + isObjectLiteral(source) && + source[IS_SET_SENTINEL] && + !source[IS_ORDERED_SENTINEL] + ); +} +function isImmutableList(source) { + return Boolean(source && isObjectLiteral(source) && source[IS_LIST_SENTINEL]); +} +function isImmutableOrderedKeyed(source) { + return Boolean( + source && + isObjectLiteral(source) && + source[IS_KEYED_SENTINEL] && + source[IS_ORDERED_SENTINEL] + ); +} +function isImmutableOrderedSet(source) { + return Boolean( + source && + isObjectLiteral(source) && + source[IS_SET_SENTINEL] && + source[IS_ORDERED_SENTINEL] + ); +} +function isImmutableRecord(source) { + return Boolean(source && isObjectLiteral(source) && source[IS_RECORD_SYMBOL]); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..53cae2e30e5fe90be18739cd15256de5f06980ed --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/build/index.d.ts @@ -0,0 +1,94 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +export declare const arrayBufferEquality: ( + a: unknown, + b: unknown, +) => boolean | undefined; + +export declare function emptyObject(obj: unknown): boolean; + +export declare const equals: EqualsFunction; + +export declare type EqualsFunction = ( + a: unknown, + b: unknown, + customTesters?: Array, + strictCheck?: boolean, +) => boolean; + +export declare const getObjectKeys: (object: object) => Array; + +export declare const getObjectSubset: ( + object: any, + subset: any, + customTesters?: Array, + seenReferences?: WeakMap, +) => any; + +declare type GetPath = { + hasEndProp?: boolean; + endPropIsDefined?: boolean; + lastTraversedObject: unknown; + traversedPath: Array; + value?: unknown; +}; + +export declare const getPath: ( + object: Record, + propertyPath: string | Array, +) => GetPath; + +export declare function isA(typeName: string, value: unknown): value is T; + +export declare const isError: (value: unknown) => value is Error; + +export declare const isOneline: ( + expected: unknown, + received: unknown, +) => boolean; + +export declare const iterableEquality: ( + a: any, + b: any, + customTesters?: Array, + aStack?: Array, + bStack?: Array, +) => boolean | undefined; + +export declare const partition: ( + items: T[], + predicate: (arg: T) => boolean, +) => [T[], T[]]; + +export declare const pathAsArray: (propertyPath: string) => Array; + +export declare const sparseArrayEquality: ( + a: unknown, + b: unknown, + customTesters?: Array, +) => boolean | undefined; + +export declare const subsetEquality: ( + object: unknown, + subset: unknown, + customTesters?: Array, +) => boolean | undefined; + +export declare type Tester = ( + this: TesterContext, + a: any, + b: any, + customTesters: Array, +) => boolean | undefined; + +export declare interface TesterContext { + equals: EqualsFunction; +} + +export declare const typeEquality: (a: any, b: any) => boolean | undefined; + +export {}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..e84aca98edff4df695db24f5fdca3259f6cf78a0 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/build/index.js @@ -0,0 +1,34 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +var _exportNames = { + equals: true, + isA: true +}; +Object.defineProperty(exports, 'equals', { + enumerable: true, + get: function () { + return _jasmineUtils.equals; + } +}); +Object.defineProperty(exports, 'isA', { + enumerable: true, + get: function () { + return _jasmineUtils.isA; + } +}); +var _jasmineUtils = require('./jasmineUtils'); +var _utils = require('./utils'); +Object.keys(_utils).forEach(function (key) { + if (key === 'default' || key === '__esModule') return; + if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; + if (key in exports && exports[key] === _utils[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _utils[key]; + } + }); +}); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/build/jasmineUtils.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/build/jasmineUtils.js new file mode 100644 index 0000000000000000000000000000000000000000..d643ede8adda40902caaf74854ac1fd0ba1bb851 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/build/jasmineUtils.js @@ -0,0 +1,218 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.equals = void 0; +exports.isA = isA; +/* +Copyright (c) 2008-2016 Pivotal Labs + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +*/ + +// Extracted out of jasmine 2.5.2 +const equals = (a, b, customTesters, strictCheck) => { + customTesters = customTesters || []; + return eq(a, b, [], [], customTesters, strictCheck); +}; +exports.equals = equals; +function isAsymmetric(obj) { + return !!obj && isA('Function', obj.asymmetricMatch); +} +function asymmetricMatch(a, b) { + const asymmetricA = isAsymmetric(a); + const asymmetricB = isAsymmetric(b); + if (asymmetricA && asymmetricB) { + return undefined; + } + if (asymmetricA) { + return a.asymmetricMatch(b); + } + if (asymmetricB) { + return b.asymmetricMatch(a); + } +} + +// Equality function lovingly adapted from isEqual in +// [Underscore](http://underscorejs.org) +function eq(a, b, aStack, bStack, customTesters, strictCheck) { + let result = true; + const asymmetricResult = asymmetricMatch(a, b); + if (asymmetricResult !== undefined) { + return asymmetricResult; + } + const testerContext = { + equals + }; + for (let i = 0; i < customTesters.length; i++) { + const customTesterResult = customTesters[i].call( + testerContext, + a, + b, + customTesters + ); + if (customTesterResult !== undefined) { + return customTesterResult; + } + } + if (a instanceof Error && b instanceof Error) { + return a.message == b.message; + } + if (Object.is(a, b)) { + return true; + } + // A strict comparison is necessary because `null == undefined`. + if (a === null || b === null) { + return a === b; + } + const className = Object.prototype.toString.call(a); + if (className != Object.prototype.toString.call(b)) { + return false; + } + switch (className) { + case '[object Boolean]': + case '[object String]': + case '[object Number]': + if (typeof a !== typeof b) { + // One is a primitive, one a `new Primitive()` + return false; + } else if (typeof a !== 'object' && typeof b !== 'object') { + // both are proper primitives + return Object.is(a, b); + } else { + // both are `new Primitive()`s + return Object.is(a.valueOf(), b.valueOf()); + } + case '[object Date]': + // Coerce dates to numeric primitive values. Dates are compared by their + // millisecond representations. Note that invalid dates with millisecond representations + // of `NaN` are not equivalent. + return +a == +b; + // RegExps are compared by their source patterns and flags. + case '[object RegExp]': + return a.source === b.source && a.flags === b.flags; + } + if (typeof a !== 'object' || typeof b !== 'object') { + return false; + } + + // Use DOM3 method isEqualNode (IE>=9) + if (isDomNode(a) && isDomNode(b)) { + return a.isEqualNode(b); + } + + // Used to detect circular references. + let length = aStack.length; + while (length--) { + // Linear search. Performance is inversely proportional to the number of + // unique nested structures. + // circular references at same depth are equal + // circular reference is not equal to non-circular one + if (aStack[length] === a) { + return bStack[length] === b; + } else if (bStack[length] === b) { + return false; + } + } + // Add the first object to the stack of traversed objects. + aStack.push(a); + bStack.push(b); + // Recursively compare objects and arrays. + // Compare array lengths to determine if a deep comparison is necessary. + if (strictCheck && className == '[object Array]' && a.length !== b.length) { + return false; + } + + // Deep compare objects. + const aKeys = keys(a, hasKey); + let key; + const bKeys = keys(b, hasKey); + // Add keys corresponding to asymmetric matchers if they miss in non strict check mode + if (!strictCheck) { + for (let index = 0; index !== bKeys.length; ++index) { + key = bKeys[index]; + if ((isAsymmetric(b[key]) || b[key] === undefined) && !hasKey(a, key)) { + aKeys.push(key); + } + } + for (let index = 0; index !== aKeys.length; ++index) { + key = aKeys[index]; + if ((isAsymmetric(a[key]) || a[key] === undefined) && !hasKey(b, key)) { + bKeys.push(key); + } + } + } + + // Ensure that both objects contain the same number of properties before comparing deep equality. + let size = aKeys.length; + if (bKeys.length !== size) { + return false; + } + while (size--) { + key = aKeys[size]; + + // Deep compare each member + if (strictCheck) + result = + hasKey(b, key) && + eq(a[key], b[key], aStack, bStack, customTesters, strictCheck); + else + result = + (hasKey(b, key) || isAsymmetric(a[key]) || a[key] === undefined) && + eq(a[key], b[key], aStack, bStack, customTesters, strictCheck); + if (!result) { + return false; + } + } + // Remove the first object from the stack of traversed objects. + aStack.pop(); + bStack.pop(); + return result; +} +function keys(obj, hasKey) { + const keys = []; + for (const key in obj) { + if (hasKey(obj, key)) { + keys.push(key); + } + } + return keys.concat( + Object.getOwnPropertySymbols(obj).filter( + symbol => Object.getOwnPropertyDescriptor(obj, symbol).enumerable + ) + ); +} +function hasKey(obj, key) { + return Object.prototype.hasOwnProperty.call(obj, key); +} +function isA(typeName, value) { + return Object.prototype.toString.apply(value) === `[object ${typeName}]`; +} +function isDomNode(obj) { + return ( + obj !== null && + typeof obj === 'object' && + typeof obj.nodeType === 'number' && + typeof obj.nodeName === 'string' && + typeof obj.isEqualNode === 'function' + ); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/build/types.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/build/types.js new file mode 100644 index 0000000000000000000000000000000000000000..ad9a93a7c160f02945911772460eb8a1bcb003db --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/build/types.js @@ -0,0 +1 @@ +'use strict'; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/build/utils.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/build/utils.js new file mode 100644 index 0000000000000000000000000000000000000000..be3a8c279ef3b9ad1ceb8dfafb8cfc157ff710bc --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/build/utils.js @@ -0,0 +1,462 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.arrayBufferEquality = void 0; +exports.emptyObject = emptyObject; +exports.typeEquality = + exports.subsetEquality = + exports.sparseArrayEquality = + exports.pathAsArray = + exports.partition = + exports.iterableEquality = + exports.isOneline = + exports.isError = + exports.getPath = + exports.getObjectSubset = + exports.getObjectKeys = + void 0; +var _jestGetType = require('jest-get-type'); +var _immutableUtils = require('./immutableUtils'); +var _jasmineUtils = require('./jasmineUtils'); +var Symbol = globalThis['jest-symbol-do-not-touch'] || globalThis.Symbol; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + */ +/** + * Checks if `hasOwnProperty(object, key)` up the prototype chain, stopping at `Object.prototype`. + */ +const hasPropertyInObject = (object, key) => { + const shouldTerminate = + !object || typeof object !== 'object' || object === Object.prototype; + if (shouldTerminate) { + return false; + } + return ( + Object.prototype.hasOwnProperty.call(object, key) || + hasPropertyInObject(Object.getPrototypeOf(object), key) + ); +}; + +// Retrieves an object's keys for evaluation by getObjectSubset. This evaluates +// the prototype chain for string keys but not for symbols. (Otherwise, it +// could find values such as a Set or Map's Symbol.toStringTag, with unexpected +// results.) +const getObjectKeys = object => [ + ...Object.keys(object), + ...Object.getOwnPropertySymbols(object) +]; +exports.getObjectKeys = getObjectKeys; +const getPath = (object, propertyPath) => { + if (!Array.isArray(propertyPath)) { + propertyPath = pathAsArray(propertyPath); + } + if (propertyPath.length) { + const lastProp = propertyPath.length === 1; + const prop = propertyPath[0]; + const newObject = object[prop]; + if (!lastProp && (newObject === null || newObject === undefined)) { + // This is not the last prop in the chain. If we keep recursing it will + // hit a `can't access property X of undefined | null`. At this point we + // know that the chain has broken and we can return right away. + return { + hasEndProp: false, + lastTraversedObject: object, + traversedPath: [] + }; + } + const result = getPath(newObject, propertyPath.slice(1)); + if (result.lastTraversedObject === null) { + result.lastTraversedObject = object; + } + result.traversedPath.unshift(prop); + if (lastProp) { + // Does object have the property with an undefined value? + // Although primitive values support bracket notation (above) + // they would throw TypeError for in operator (below). + result.endPropIsDefined = + !(0, _jestGetType.isPrimitive)(object) && prop in object; + result.hasEndProp = newObject !== undefined || result.endPropIsDefined; + if (!result.hasEndProp) { + result.traversedPath.shift(); + } + } + return result; + } + return { + lastTraversedObject: null, + traversedPath: [], + value: object + }; +}; + +// Strip properties from object that are not present in the subset. Useful for +// printing the diff for toMatchObject() without adding unrelated noise. +/* eslint-disable @typescript-eslint/explicit-module-boundary-types */ +exports.getPath = getPath; +const getObjectSubset = ( + object, + subset, + customTesters = [], + seenReferences = new WeakMap() +) => { + /* eslint-enable @typescript-eslint/explicit-module-boundary-types */ + if (Array.isArray(object)) { + if (Array.isArray(subset) && subset.length === object.length) { + // The map method returns correct subclass of subset. + return subset.map((sub, i) => + getObjectSubset(object[i], sub, customTesters) + ); + } + } else if (object instanceof Date) { + return object; + } else if (isObject(object) && isObject(subset)) { + if ( + (0, _jasmineUtils.equals)(object, subset, [ + ...customTesters, + iterableEquality, + subsetEquality + ]) + ) { + // Avoid unnecessary copy which might return Object instead of subclass. + return subset; + } + const trimmed = {}; + seenReferences.set(object, trimmed); + getObjectKeys(object) + .filter(key => hasPropertyInObject(subset, key)) + .forEach(key => { + trimmed[key] = seenReferences.has(object[key]) + ? seenReferences.get(object[key]) + : getObjectSubset( + object[key], + subset[key], + customTesters, + seenReferences + ); + }); + if (getObjectKeys(trimmed).length > 0) { + return trimmed; + } + } + return object; +}; +exports.getObjectSubset = getObjectSubset; +const IteratorSymbol = Symbol.iterator; +const hasIterator = object => !!(object != null && object[IteratorSymbol]); + +/* eslint-disable @typescript-eslint/explicit-module-boundary-types */ +const iterableEquality = ( + a, + b, + customTesters = [] /* eslint-enable @typescript-eslint/explicit-module-boundary-types */, + aStack = [], + bStack = [] +) => { + if ( + typeof a !== 'object' || + typeof b !== 'object' || + Array.isArray(a) || + Array.isArray(b) || + !hasIterator(a) || + !hasIterator(b) + ) { + return undefined; + } + if (a.constructor !== b.constructor) { + return false; + } + let length = aStack.length; + while (length--) { + // Linear search. Performance is inversely proportional to the number of + // unique nested structures. + // circular references at same depth are equal + // circular reference is not equal to non-circular one + if (aStack[length] === a) { + return bStack[length] === b; + } + } + aStack.push(a); + bStack.push(b); + const iterableEqualityWithStack = (a, b) => + iterableEquality( + a, + b, + [...filteredCustomTesters], + [...aStack], + [...bStack] + ); + + // Replace any instance of iterableEquality with the new + // iterableEqualityWithStack so we can do circular detection + const filteredCustomTesters = [ + ...customTesters.filter(t => t !== iterableEquality), + iterableEqualityWithStack + ]; + if (a.size !== undefined) { + if (a.size !== b.size) { + return false; + } else if ( + (0, _jasmineUtils.isA)('Set', a) || + (0, _immutableUtils.isImmutableUnorderedSet)(a) + ) { + let allFound = true; + for (const aValue of a) { + if (!b.has(aValue)) { + let has = false; + for (const bValue of b) { + const isEqual = (0, _jasmineUtils.equals)( + aValue, + bValue, + filteredCustomTesters + ); + if (isEqual === true) { + has = true; + } + } + if (has === false) { + allFound = false; + break; + } + } + } + // Remove the first value from the stack of traversed values. + aStack.pop(); + bStack.pop(); + return allFound; + } else if ( + (0, _jasmineUtils.isA)('Map', a) || + (0, _immutableUtils.isImmutableUnorderedKeyed)(a) + ) { + let allFound = true; + for (const aEntry of a) { + if ( + !b.has(aEntry[0]) || + !(0, _jasmineUtils.equals)( + aEntry[1], + b.get(aEntry[0]), + filteredCustomTesters + ) + ) { + let has = false; + for (const bEntry of b) { + const matchedKey = (0, _jasmineUtils.equals)( + aEntry[0], + bEntry[0], + filteredCustomTesters + ); + let matchedValue = false; + if (matchedKey === true) { + matchedValue = (0, _jasmineUtils.equals)( + aEntry[1], + bEntry[1], + filteredCustomTesters + ); + } + if (matchedValue === true) { + has = true; + } + } + if (has === false) { + allFound = false; + break; + } + } + } + // Remove the first value from the stack of traversed values. + aStack.pop(); + bStack.pop(); + return allFound; + } + } + const bIterator = b[IteratorSymbol](); + for (const aValue of a) { + const nextB = bIterator.next(); + if ( + nextB.done || + !(0, _jasmineUtils.equals)(aValue, nextB.value, filteredCustomTesters) + ) { + return false; + } + } + if (!bIterator.next().done) { + return false; + } + if ( + !(0, _immutableUtils.isImmutableList)(a) && + !(0, _immutableUtils.isImmutableOrderedKeyed)(a) && + !(0, _immutableUtils.isImmutableOrderedSet)(a) && + !(0, _immutableUtils.isImmutableRecord)(a) + ) { + const aEntries = Object.entries(a); + const bEntries = Object.entries(b); + if (!(0, _jasmineUtils.equals)(aEntries, bEntries)) { + return false; + } + } + + // Remove the first value from the stack of traversed values. + aStack.pop(); + bStack.pop(); + return true; +}; +exports.iterableEquality = iterableEquality; +const isObject = a => a !== null && typeof a === 'object'; +const isObjectWithKeys = a => + isObject(a) && + !(a instanceof Error) && + !(a instanceof Array) && + !(a instanceof Date); +const subsetEquality = (object, subset, customTesters = []) => { + const filteredCustomTesters = customTesters.filter(t => t !== subsetEquality); + + // subsetEquality needs to keep track of the references + // it has already visited to avoid infinite loops in case + // there are circular references in the subset passed to it. + const subsetEqualityWithContext = + (seenReferences = new WeakMap()) => + (object, subset) => { + if (!isObjectWithKeys(subset)) { + return undefined; + } + return getObjectKeys(subset).every(key => { + if (isObjectWithKeys(subset[key])) { + if (seenReferences.has(subset[key])) { + return (0, _jasmineUtils.equals)( + object[key], + subset[key], + filteredCustomTesters + ); + } + seenReferences.set(subset[key], true); + } + const result = + object != null && + hasPropertyInObject(object, key) && + (0, _jasmineUtils.equals)(object[key], subset[key], [ + ...filteredCustomTesters, + subsetEqualityWithContext(seenReferences) + ]); + // The main goal of using seenReference is to avoid circular node on tree. + // It will only happen within a parent and its child, not a node and nodes next to it (same level) + // We should keep the reference for a parent and its child only + // Thus we should delete the reference immediately so that it doesn't interfere + // other nodes within the same level on tree. + seenReferences.delete(subset[key]); + return result; + }); + }; + return subsetEqualityWithContext()(object, subset); +}; + +// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types +exports.subsetEquality = subsetEquality; +const typeEquality = (a, b) => { + if ( + a == null || + b == null || + a.constructor === b.constructor || + // Since Jest globals are different from Node globals, + // constructors are different even between arrays when comparing properties of mock objects. + // Both of them should be able to compare correctly when they are array-to-array. + // https://github.com/jestjs/jest/issues/2549 + (Array.isArray(a) && Array.isArray(b)) + ) { + return undefined; + } + return false; +}; +exports.typeEquality = typeEquality; +const arrayBufferEquality = (a, b) => { + if (!(a instanceof ArrayBuffer) || !(b instanceof ArrayBuffer)) { + return undefined; + } + const dataViewA = new DataView(a); + const dataViewB = new DataView(b); + + // Buffers are not equal when they do not have the same byte length + if (dataViewA.byteLength !== dataViewB.byteLength) { + return false; + } + + // Check if every byte value is equal to each other + for (let i = 0; i < dataViewA.byteLength; i++) { + if (dataViewA.getUint8(i) !== dataViewB.getUint8(i)) { + return false; + } + } + return true; +}; +exports.arrayBufferEquality = arrayBufferEquality; +const sparseArrayEquality = (a, b, customTesters = []) => { + if (!Array.isArray(a) || !Array.isArray(b)) { + return undefined; + } + + // A sparse array [, , 1] will have keys ["2"] whereas [undefined, undefined, 1] will have keys ["0", "1", "2"] + const aKeys = Object.keys(a); + const bKeys = Object.keys(b); + return ( + (0, _jasmineUtils.equals)( + a, + b, + customTesters.filter(t => t !== sparseArrayEquality), + true + ) && (0, _jasmineUtils.equals)(aKeys, bKeys) + ); +}; +exports.sparseArrayEquality = sparseArrayEquality; +const partition = (items, predicate) => { + const result = [[], []]; + items.forEach(item => result[predicate(item) ? 0 : 1].push(item)); + return result; +}; +exports.partition = partition; +const pathAsArray = propertyPath => { + const properties = []; + if (propertyPath === '') { + properties.push(''); + return properties; + } + + // will match everything that's not a dot or a bracket, and "" for consecutive dots. + const pattern = RegExp('[^.[\\]]+|(?=(?:\\.)(?:\\.|$))', 'g'); + + // Because the regex won't match a dot in the beginning of the path, if present. + if (propertyPath[0] === '.') { + properties.push(''); + } + propertyPath.replace(pattern, match => { + properties.push(match); + return match; + }); + return properties; +}; + +// Copied from https://github.com/graingert/angular.js/blob/a43574052e9775cbc1d7dd8a086752c979b0f020/src/Angular.js#L685-L693 +exports.pathAsArray = pathAsArray; +const isError = value => { + switch (Object.prototype.toString.call(value)) { + case '[object Error]': + case '[object Exception]': + case '[object DOMException]': + return true; + default: + return value instanceof Error; + } +}; +exports.isError = isError; +function emptyObject(obj) { + return obj && typeof obj === 'object' ? !Object.keys(obj).length : false; +} +const MULTILINE_REGEXP = /[\r\n]/; +const isOneline = (expected, received) => + typeof expected === 'string' && + typeof received === 'string' && + (!MULTILINE_REGEXP.test(expected) || !MULTILINE_REGEXP.test(received)); +exports.isOneline = isOneline; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/package.json new file mode 100644 index 0000000000000000000000000000000000000000..c5c483fed72f945e19ffada78551d9671323c0d2 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect-utils/package.json @@ -0,0 +1,35 @@ +{ + "name": "@jest/expect-utils", + "version": "29.7.0", + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/expect-utils" + }, + "license": "MIT", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "dependencies": { + "jest-get-type": "^29.6.3" + }, + "devDependencies": { + "@tsd/typescript": "^5.0.4", + "immutable": "^4.0.0", + "jest-matcher-utils": "^29.7.0", + "tsd-lite": "^0.7.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "publishConfig": { + "access": "public" + }, + "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect/README.md new file mode 100644 index 0000000000000000000000000000000000000000..81cf1b41a8bb1ba31d5ebfd445f7d089c5a2b046 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect/README.md @@ -0,0 +1,5 @@ +# @jest/expect + +This package extends `expect` library with `jest-snapshot` matchers. It exports `jestExpect` object, which can be used as standalone replacement of `expect`. + +The `jestExpect` function used in [Jest](https://jestjs.io/). You can find its documentation [on Jest's website](https://jestjs.io/docs/expect). diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1b6964638042b98b9fec71ef464bbcf383f666e0 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect/build/index.d.ts @@ -0,0 +1,68 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +import type {addSerializer} from 'jest-snapshot'; +import {AsymmetricMatchers} from 'expect'; +import type {BaseExpect} from 'expect'; +import {MatcherContext} from 'expect'; +import {MatcherFunction} from 'expect'; +import {MatcherFunctionWithContext} from 'expect'; +import {Matchers} from 'expect'; +import {MatcherState} from 'expect'; +import {MatcherUtils} from 'expect'; +import type {SnapshotMatchers} from 'jest-snapshot'; + +export {AsymmetricMatchers}; + +declare type Inverse = { + /** + * Inverse next matcher. If you know how to test something, `.not` lets you test its opposite. + */ + not: Matchers; +}; + +export declare type JestExpect = { + (actual: T): JestMatchers & + Inverse> & + PromiseMatchers; + addSnapshotSerializer: typeof addSerializer; +} & BaseExpect & + AsymmetricMatchers & + Inverse>; + +export declare const jestExpect: JestExpect; + +declare type JestMatchers, T> = Matchers & + SnapshotMatchers; + +export {MatcherContext}; + +export {MatcherFunction}; + +export {MatcherFunctionWithContext}; + +export {Matchers}; + +export {MatcherState}; + +export {MatcherUtils}; + +declare type PromiseMatchers = { + /** + * Unwraps the reason of a rejected promise so any other matcher can be chained. + * If the promise is fulfilled the assertion fails. + */ + rejects: JestMatchers, T> & + Inverse, T>>; + /** + * Unwraps the value of a fulfilled promise so any other matcher can be chained. + * If the promise is rejected the assertion fails. + */ + resolves: JestMatchers, T> & + Inverse, T>>; +}; + +export {}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..bc1cc9386c9074961807f953ecc970edc1948a0b --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect/build/index.js @@ -0,0 +1,40 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.jestExpect = void 0; +function _expect() { + const data = require('expect'); + _expect = function () { + return data; + }; + return data; +} +function _jestSnapshot() { + const data = require('jest-snapshot'); + _jestSnapshot = function () { + return data; + }; + return data; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function createJestExpect() { + _expect().expect.extend({ + toMatchInlineSnapshot: _jestSnapshot().toMatchInlineSnapshot, + toMatchSnapshot: _jestSnapshot().toMatchSnapshot, + toThrowErrorMatchingInlineSnapshot: + _jestSnapshot().toThrowErrorMatchingInlineSnapshot, + toThrowErrorMatchingSnapshot: _jestSnapshot().toThrowErrorMatchingSnapshot + }); + _expect().expect.addSnapshotSerializer = _jestSnapshot().addSerializer; + return _expect().expect; +} +const jestExpect = createJestExpect(); +exports.jestExpect = jestExpect; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect/build/types.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect/build/types.js new file mode 100644 index 0000000000000000000000000000000000000000..ad9a93a7c160f02945911772460eb8a1bcb003db --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect/build/types.js @@ -0,0 +1 @@ +'use strict'; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect/package.json new file mode 100644 index 0000000000000000000000000000000000000000..c6a363134b2ce5b24717c285b3f375905cc7263e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/expect/package.json @@ -0,0 +1,34 @@ +{ + "name": "@jest/expect", + "version": "29.7.0", + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/jest-expect" + }, + "license": "MIT", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "dependencies": { + "expect": "^29.7.0", + "jest-snapshot": "^29.7.0" + }, + "devDependencies": { + "@tsd/typescript": "^5.0.4", + "tsd-lite": "^0.7.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "publishConfig": { + "access": "public" + }, + "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/fake-timers/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/fake-timers/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/fake-timers/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/fake-timers/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/fake-timers/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5a2b4c98ff43556608f21d4e4319119fd137bbdc --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/fake-timers/build/index.d.ts @@ -0,0 +1,110 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +import type {Config} from '@jest/types'; +import type {ModuleMocker} from 'jest-mock'; +import {StackTraceConfig} from 'jest-message-util'; + +declare type Callback = (...args: Array) => void; + +export declare class LegacyFakeTimers { + private _cancelledTicks; + private readonly _config; + private _disposed; + private _fakeTimerAPIs; + private _fakingTime; + private _global; + private _immediates; + private readonly _maxLoops; + private readonly _moduleMocker; + private _now; + private _ticks; + private readonly _timerAPIs; + private _timers; + private _uuidCounter; + private readonly _timerConfig; + constructor({ + global, + moduleMocker, + timerConfig, + config, + maxLoops, + }: { + global: typeof globalThis; + moduleMocker: ModuleMocker; + timerConfig: TimerConfig; + config: StackTraceConfig; + maxLoops?: number; + }); + clearAllTimers(): void; + dispose(): void; + reset(): void; + now(): number; + runAllTicks(): void; + runAllImmediates(): void; + private _runImmediate; + runAllTimers(): void; + runOnlyPendingTimers(): void; + advanceTimersToNextTimer(steps?: number): void; + advanceTimersByTime(msToRun: number): void; + runWithRealTimers(cb: Callback): void; + useRealTimers(): void; + useFakeTimers(): void; + getTimerCount(): number; + private _checkFakeTimers; + private _createMocks; + private _fakeClearTimer; + private _fakeClearImmediate; + private _fakeNextTick; + private _fakeRequestAnimationFrame; + private _fakeSetImmediate; + private _fakeSetInterval; + private _fakeSetTimeout; + private _getNextTimerHandleAndExpiry; + private _runTimerHandle; +} + +export declare class ModernFakeTimers { + private _clock; + private readonly _config; + private _fakingTime; + private readonly _global; + private readonly _fakeTimers; + constructor({ + global, + config, + }: { + global: typeof globalThis; + config: Config.ProjectConfig; + }); + clearAllTimers(): void; + dispose(): void; + runAllTimers(): void; + runAllTimersAsync(): Promise; + runOnlyPendingTimers(): void; + runOnlyPendingTimersAsync(): Promise; + advanceTimersToNextTimer(steps?: number): void; + advanceTimersToNextTimerAsync(steps?: number): Promise; + advanceTimersByTime(msToRun: number): void; + advanceTimersByTimeAsync(msToRun: number): Promise; + runAllTicks(): void; + useRealTimers(): void; + useFakeTimers(fakeTimersConfig?: Config.FakeTimersConfig): void; + reset(): void; + setSystemTime(now?: number | Date): void; + getRealSystemTime(): number; + now(): number; + getTimerCount(): number; + private _checkFakeTimers; + private _toSinonFakeTimersConfig; +} + +declare type TimerConfig = { + idToRef: (id: number) => Ref; + refToId: (ref: Ref) => number | void; +}; + +export {}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/fake-timers/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/fake-timers/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..776d3e535d2f69ef80f8118825d2bf65fdb5fa9a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/fake-timers/build/index.js @@ -0,0 +1,22 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +Object.defineProperty(exports, 'LegacyFakeTimers', { + enumerable: true, + get: function () { + return _legacyFakeTimers.default; + } +}); +Object.defineProperty(exports, 'ModernFakeTimers', { + enumerable: true, + get: function () { + return _modernFakeTimers.default; + } +}); +var _legacyFakeTimers = _interopRequireDefault(require('./legacyFakeTimers')); +var _modernFakeTimers = _interopRequireDefault(require('./modernFakeTimers')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/fake-timers/build/legacyFakeTimers.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/fake-timers/build/legacyFakeTimers.js new file mode 100644 index 0000000000000000000000000000000000000000..3bbf36c91fcb89b0b161defff51d1a96c0a863aa --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/fake-timers/build/legacyFakeTimers.js @@ -0,0 +1,545 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _util() { + const data = require('util'); + _util = function () { + return data; + }; + return data; +} +function _jestMessageUtil() { + const data = require('jest-message-util'); + _jestMessageUtil = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +/* eslint-disable local/prefer-spread-eventually */ + +const MS_IN_A_YEAR = 31536000000; +class FakeTimers { + _cancelledTicks; + _config; + _disposed; + _fakeTimerAPIs; + _fakingTime = false; + _global; + _immediates; + _maxLoops; + _moduleMocker; + _now; + _ticks; + _timerAPIs; + _timers; + _uuidCounter; + _timerConfig; + constructor({global, moduleMocker, timerConfig, config, maxLoops}) { + this._global = global; + this._timerConfig = timerConfig; + this._config = config; + this._maxLoops = maxLoops || 100000; + this._uuidCounter = 1; + this._moduleMocker = moduleMocker; + + // Store original timer APIs for future reference + this._timerAPIs = { + cancelAnimationFrame: global.cancelAnimationFrame, + clearImmediate: global.clearImmediate, + clearInterval: global.clearInterval, + clearTimeout: global.clearTimeout, + nextTick: global.process && global.process.nextTick, + requestAnimationFrame: global.requestAnimationFrame, + setImmediate: global.setImmediate, + setInterval: global.setInterval, + setTimeout: global.setTimeout + }; + this._disposed = false; + this.reset(); + } + clearAllTimers() { + this._immediates = []; + this._timers.clear(); + } + dispose() { + this._disposed = true; + this.clearAllTimers(); + } + reset() { + this._cancelledTicks = {}; + this._now = 0; + this._ticks = []; + this._immediates = []; + this._timers = new Map(); + } + now() { + if (this._fakingTime) { + return this._now; + } + return Date.now(); + } + runAllTicks() { + this._checkFakeTimers(); + // Only run a generous number of ticks and then bail. + // This is just to help avoid recursive loops + let i; + for (i = 0; i < this._maxLoops; i++) { + const tick = this._ticks.shift(); + if (tick === undefined) { + break; + } + if ( + !Object.prototype.hasOwnProperty.call(this._cancelledTicks, tick.uuid) + ) { + // Callback may throw, so update the map prior calling. + this._cancelledTicks[tick.uuid] = true; + tick.callback(); + } + } + if (i === this._maxLoops) { + throw new Error( + `Ran ${this._maxLoops} ticks, and there are still more! ` + + "Assuming we've hit an infinite recursion and bailing out..." + ); + } + } + runAllImmediates() { + this._checkFakeTimers(); + // Only run a generous number of immediates and then bail. + let i; + for (i = 0; i < this._maxLoops; i++) { + const immediate = this._immediates.shift(); + if (immediate === undefined) { + break; + } + this._runImmediate(immediate); + } + if (i === this._maxLoops) { + throw new Error( + `Ran ${this._maxLoops} immediates, and there are still more! Assuming ` + + "we've hit an infinite recursion and bailing out..." + ); + } + } + _runImmediate(immediate) { + try { + immediate.callback(); + } finally { + this._fakeClearImmediate(immediate.uuid); + } + } + runAllTimers() { + this._checkFakeTimers(); + this.runAllTicks(); + this.runAllImmediates(); + + // Only run a generous number of timers and then bail. + // This is just to help avoid recursive loops + let i; + for (i = 0; i < this._maxLoops; i++) { + const nextTimerHandleAndExpiry = this._getNextTimerHandleAndExpiry(); + + // If there are no more timer handles, stop! + if (nextTimerHandleAndExpiry === null) { + break; + } + const [nextTimerHandle, expiry] = nextTimerHandleAndExpiry; + this._now = expiry; + this._runTimerHandle(nextTimerHandle); + + // Some of the immediate calls could be enqueued + // during the previous handling of the timers, we should + // run them as well. + if (this._immediates.length) { + this.runAllImmediates(); + } + if (this._ticks.length) { + this.runAllTicks(); + } + } + if (i === this._maxLoops) { + throw new Error( + `Ran ${this._maxLoops} timers, and there are still more! ` + + "Assuming we've hit an infinite recursion and bailing out..." + ); + } + } + runOnlyPendingTimers() { + // We need to hold the current shape of `this._timers` because existing + // timers can add new ones to the map and hence would run more than necessary. + // See https://github.com/jestjs/jest/pull/4608 for details + const timerEntries = Array.from(this._timers.entries()); + this._checkFakeTimers(); + this._immediates.forEach(this._runImmediate, this); + timerEntries + .sort(([, left], [, right]) => left.expiry - right.expiry) + .forEach(([timerHandle, timer]) => { + this._now = timer.expiry; + this._runTimerHandle(timerHandle); + }); + } + advanceTimersToNextTimer(steps = 1) { + if (steps < 1) { + return; + } + const nextExpiry = Array.from(this._timers.values()).reduce( + (minExpiry, timer) => { + if (minExpiry === null || timer.expiry < minExpiry) return timer.expiry; + return minExpiry; + }, + null + ); + if (nextExpiry !== null) { + this.advanceTimersByTime(nextExpiry - this._now); + this.advanceTimersToNextTimer(steps - 1); + } + } + advanceTimersByTime(msToRun) { + this._checkFakeTimers(); + // Only run a generous number of timers and then bail. + // This is just to help avoid recursive loops + let i; + for (i = 0; i < this._maxLoops; i++) { + const timerHandleAndExpiry = this._getNextTimerHandleAndExpiry(); + + // If there are no more timer handles, stop! + if (timerHandleAndExpiry === null) { + break; + } + const [timerHandle, nextTimerExpiry] = timerHandleAndExpiry; + if (this._now + msToRun < nextTimerExpiry) { + // There are no timers between now and the target we're running to + break; + } else { + msToRun -= nextTimerExpiry - this._now; + this._now = nextTimerExpiry; + this._runTimerHandle(timerHandle); + } + } + + // Advance the clock by whatever time we still have left to run + this._now += msToRun; + if (i === this._maxLoops) { + throw new Error( + `Ran ${this._maxLoops} timers, and there are still more! ` + + "Assuming we've hit an infinite recursion and bailing out..." + ); + } + } + runWithRealTimers(cb) { + const prevClearImmediate = this._global.clearImmediate; + const prevClearInterval = this._global.clearInterval; + const prevClearTimeout = this._global.clearTimeout; + const prevNextTick = this._global.process.nextTick; + const prevSetImmediate = this._global.setImmediate; + const prevSetInterval = this._global.setInterval; + const prevSetTimeout = this._global.setTimeout; + this.useRealTimers(); + let cbErr = null; + let errThrown = false; + try { + cb(); + } catch (e) { + errThrown = true; + cbErr = e; + } + this._global.clearImmediate = prevClearImmediate; + this._global.clearInterval = prevClearInterval; + this._global.clearTimeout = prevClearTimeout; + this._global.process.nextTick = prevNextTick; + this._global.setImmediate = prevSetImmediate; + this._global.setInterval = prevSetInterval; + this._global.setTimeout = prevSetTimeout; + if (errThrown) { + throw cbErr; + } + } + useRealTimers() { + const global = this._global; + if (typeof global.cancelAnimationFrame === 'function') { + (0, _jestUtil().setGlobal)( + global, + 'cancelAnimationFrame', + this._timerAPIs.cancelAnimationFrame + ); + } + if (typeof global.clearImmediate === 'function') { + (0, _jestUtil().setGlobal)( + global, + 'clearImmediate', + this._timerAPIs.clearImmediate + ); + } + (0, _jestUtil().setGlobal)( + global, + 'clearInterval', + this._timerAPIs.clearInterval + ); + (0, _jestUtil().setGlobal)( + global, + 'clearTimeout', + this._timerAPIs.clearTimeout + ); + if (typeof global.requestAnimationFrame === 'function') { + (0, _jestUtil().setGlobal)( + global, + 'requestAnimationFrame', + this._timerAPIs.requestAnimationFrame + ); + } + if (typeof global.setImmediate === 'function') { + (0, _jestUtil().setGlobal)( + global, + 'setImmediate', + this._timerAPIs.setImmediate + ); + } + (0, _jestUtil().setGlobal)( + global, + 'setInterval', + this._timerAPIs.setInterval + ); + (0, _jestUtil().setGlobal)( + global, + 'setTimeout', + this._timerAPIs.setTimeout + ); + global.process.nextTick = this._timerAPIs.nextTick; + this._fakingTime = false; + } + useFakeTimers() { + this._createMocks(); + const global = this._global; + if (typeof global.cancelAnimationFrame === 'function') { + (0, _jestUtil().setGlobal)( + global, + 'cancelAnimationFrame', + this._fakeTimerAPIs.cancelAnimationFrame + ); + } + if (typeof global.clearImmediate === 'function') { + (0, _jestUtil().setGlobal)( + global, + 'clearImmediate', + this._fakeTimerAPIs.clearImmediate + ); + } + (0, _jestUtil().setGlobal)( + global, + 'clearInterval', + this._fakeTimerAPIs.clearInterval + ); + (0, _jestUtil().setGlobal)( + global, + 'clearTimeout', + this._fakeTimerAPIs.clearTimeout + ); + if (typeof global.requestAnimationFrame === 'function') { + (0, _jestUtil().setGlobal)( + global, + 'requestAnimationFrame', + this._fakeTimerAPIs.requestAnimationFrame + ); + } + if (typeof global.setImmediate === 'function') { + (0, _jestUtil().setGlobal)( + global, + 'setImmediate', + this._fakeTimerAPIs.setImmediate + ); + } + (0, _jestUtil().setGlobal)( + global, + 'setInterval', + this._fakeTimerAPIs.setInterval + ); + (0, _jestUtil().setGlobal)( + global, + 'setTimeout', + this._fakeTimerAPIs.setTimeout + ); + global.process.nextTick = this._fakeTimerAPIs.nextTick; + this._fakingTime = true; + } + getTimerCount() { + this._checkFakeTimers(); + return this._timers.size + this._immediates.length + this._ticks.length; + } + _checkFakeTimers() { + if (!this._fakingTime) { + this._global.console.warn( + 'A function to advance timers was called but the timers APIs are not mocked ' + + 'with fake timers. Call `jest.useFakeTimers({legacyFakeTimers: true})` ' + + 'in this test file or enable fake timers for all tests by setting ' + + "{'enableGlobally': true, 'legacyFakeTimers': true} in " + + `Jest configuration file.\nStack Trace:\n${(0, + _jestMessageUtil().formatStackTrace)( + new Error().stack, + this._config, + { + noStackTrace: false + } + )}` + ); + } + } + _createMocks() { + const fn = implementation => this._moduleMocker.fn(implementation); + const promisifiableFakeSetTimeout = fn(this._fakeSetTimeout.bind(this)); + // @ts-expect-error: no index + promisifiableFakeSetTimeout[_util().promisify.custom] = (delay, arg) => + new Promise(resolve => promisifiableFakeSetTimeout(resolve, delay, arg)); + this._fakeTimerAPIs = { + cancelAnimationFrame: fn(this._fakeClearTimer.bind(this)), + clearImmediate: fn(this._fakeClearImmediate.bind(this)), + clearInterval: fn(this._fakeClearTimer.bind(this)), + clearTimeout: fn(this._fakeClearTimer.bind(this)), + nextTick: fn(this._fakeNextTick.bind(this)), + requestAnimationFrame: fn(this._fakeRequestAnimationFrame.bind(this)), + setImmediate: fn(this._fakeSetImmediate.bind(this)), + setInterval: fn(this._fakeSetInterval.bind(this)), + setTimeout: promisifiableFakeSetTimeout + }; + } + _fakeClearTimer(timerRef) { + const uuid = this._timerConfig.refToId(timerRef); + if (uuid) { + this._timers.delete(String(uuid)); + } + } + _fakeClearImmediate(uuid) { + this._immediates = this._immediates.filter( + immediate => immediate.uuid !== uuid + ); + } + _fakeNextTick(callback, ...args) { + if (this._disposed) { + return; + } + const uuid = String(this._uuidCounter++); + this._ticks.push({ + callback: () => callback.apply(null, args), + uuid + }); + const cancelledTicks = this._cancelledTicks; + this._timerAPIs.nextTick(() => { + if (!Object.prototype.hasOwnProperty.call(cancelledTicks, uuid)) { + // Callback may throw, so update the map prior calling. + cancelledTicks[uuid] = true; + callback.apply(null, args); + } + }); + } + _fakeRequestAnimationFrame(callback) { + return this._fakeSetTimeout(() => { + // TODO: Use performance.now() once it's mocked + callback(this._now); + }, 1000 / 60); + } + _fakeSetImmediate(callback, ...args) { + if (this._disposed) { + return null; + } + const uuid = String(this._uuidCounter++); + this._immediates.push({ + callback: () => callback.apply(null, args), + uuid + }); + this._timerAPIs.setImmediate(() => { + if (!this._disposed) { + if (this._immediates.find(x => x.uuid === uuid)) { + try { + callback.apply(null, args); + } finally { + this._fakeClearImmediate(uuid); + } + } + } + }); + return uuid; + } + _fakeSetInterval(callback, intervalDelay, ...args) { + if (this._disposed) { + return null; + } + if (intervalDelay == null) { + intervalDelay = 0; + } + const uuid = this._uuidCounter++; + this._timers.set(String(uuid), { + callback: () => callback.apply(null, args), + expiry: this._now + intervalDelay, + interval: intervalDelay, + type: 'interval' + }); + return this._timerConfig.idToRef(uuid); + } + _fakeSetTimeout(callback, delay, ...args) { + if (this._disposed) { + return null; + } + + // eslint-disable-next-line no-bitwise + delay = Number(delay) | 0; + const uuid = this._uuidCounter++; + this._timers.set(String(uuid), { + callback: () => callback.apply(null, args), + expiry: this._now + delay, + interval: undefined, + type: 'timeout' + }); + return this._timerConfig.idToRef(uuid); + } + _getNextTimerHandleAndExpiry() { + let nextTimerHandle = null; + let soonestTime = MS_IN_A_YEAR; + this._timers.forEach((timer, uuid) => { + if (timer.expiry < soonestTime) { + soonestTime = timer.expiry; + nextTimerHandle = uuid; + } + }); + if (nextTimerHandle === null) { + return null; + } + return [nextTimerHandle, soonestTime]; + } + _runTimerHandle(timerHandle) { + const timer = this._timers.get(timerHandle); + if (!timer) { + // Timer has been cleared - we'll hit this when a timer is cleared within + // another timer in runOnlyPendingTimers + return; + } + switch (timer.type) { + case 'timeout': + this._timers.delete(timerHandle); + timer.callback(); + break; + case 'interval': + timer.expiry = this._now + (timer.interval || 0); + timer.callback(); + break; + default: + throw new Error(`Unexpected timer type: ${timer.type}`); + } + } +} +exports.default = FakeTimers; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/fake-timers/build/modernFakeTimers.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/fake-timers/build/modernFakeTimers.js new file mode 100644 index 0000000000000000000000000000000000000000..d9518a91d0f8c5e15be7623b1e61a2348d8d675d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/fake-timers/build/modernFakeTimers.js @@ -0,0 +1,191 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _fakeTimers() { + const data = require('@sinonjs/fake-timers'); + _fakeTimers = function () { + return data; + }; + return data; +} +function _jestMessageUtil() { + const data = require('jest-message-util'); + _jestMessageUtil = function () { + return data; + }; + return data; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class FakeTimers { + _clock; + _config; + _fakingTime; + _global; + _fakeTimers; + constructor({global, config}) { + this._global = global; + this._config = config; + this._fakingTime = false; + this._fakeTimers = (0, _fakeTimers().withGlobal)(global); + } + clearAllTimers() { + if (this._fakingTime) { + this._clock.reset(); + } + } + dispose() { + this.useRealTimers(); + } + runAllTimers() { + if (this._checkFakeTimers()) { + this._clock.runAll(); + } + } + async runAllTimersAsync() { + if (this._checkFakeTimers()) { + await this._clock.runAllAsync(); + } + } + runOnlyPendingTimers() { + if (this._checkFakeTimers()) { + this._clock.runToLast(); + } + } + async runOnlyPendingTimersAsync() { + if (this._checkFakeTimers()) { + await this._clock.runToLastAsync(); + } + } + advanceTimersToNextTimer(steps = 1) { + if (this._checkFakeTimers()) { + for (let i = steps; i > 0; i--) { + this._clock.next(); + // Fire all timers at this point: https://github.com/sinonjs/fake-timers/issues/250 + this._clock.tick(0); + if (this._clock.countTimers() === 0) { + break; + } + } + } + } + async advanceTimersToNextTimerAsync(steps = 1) { + if (this._checkFakeTimers()) { + for (let i = steps; i > 0; i--) { + await this._clock.nextAsync(); + // Fire all timers at this point: https://github.com/sinonjs/fake-timers/issues/250 + await this._clock.tickAsync(0); + if (this._clock.countTimers() === 0) { + break; + } + } + } + } + advanceTimersByTime(msToRun) { + if (this._checkFakeTimers()) { + this._clock.tick(msToRun); + } + } + async advanceTimersByTimeAsync(msToRun) { + if (this._checkFakeTimers()) { + await this._clock.tickAsync(msToRun); + } + } + runAllTicks() { + if (this._checkFakeTimers()) { + // @ts-expect-error - doesn't exist? + this._clock.runMicrotasks(); + } + } + useRealTimers() { + if (this._fakingTime) { + this._clock.uninstall(); + this._fakingTime = false; + } + } + useFakeTimers(fakeTimersConfig) { + if (this._fakingTime) { + this._clock.uninstall(); + } + this._clock = this._fakeTimers.install( + this._toSinonFakeTimersConfig(fakeTimersConfig) + ); + this._fakingTime = true; + } + reset() { + if (this._checkFakeTimers()) { + const {now} = this._clock; + this._clock.reset(); + this._clock.setSystemTime(now); + } + } + setSystemTime(now) { + if (this._checkFakeTimers()) { + this._clock.setSystemTime(now); + } + } + getRealSystemTime() { + return Date.now(); + } + now() { + if (this._fakingTime) { + return this._clock.now; + } + return Date.now(); + } + getTimerCount() { + if (this._checkFakeTimers()) { + return this._clock.countTimers(); + } + return 0; + } + _checkFakeTimers() { + if (!this._fakingTime) { + this._global.console.warn( + 'A function to advance timers was called but the timers APIs are not replaced ' + + 'with fake timers. Call `jest.useFakeTimers()` in this test file or enable ' + + "fake timers for all tests by setting 'fakeTimers': {'enableGlobally': true} " + + `in Jest configuration file.\nStack Trace:\n${(0, + _jestMessageUtil().formatStackTrace)( + new Error().stack, + this._config, + { + noStackTrace: false + } + )}` + ); + } + return this._fakingTime; + } + _toSinonFakeTimersConfig(fakeTimersConfig = {}) { + fakeTimersConfig = { + ...this._config.fakeTimers, + ...fakeTimersConfig + }; + const advanceTimeDelta = + typeof fakeTimersConfig.advanceTimers === 'number' + ? fakeTimersConfig.advanceTimers + : undefined; + const toFake = new Set(Object.keys(this._fakeTimers.timers)); + fakeTimersConfig.doNotFake?.forEach(nameOfFakeableAPI => { + toFake.delete(nameOfFakeableAPI); + }); + return { + advanceTimeDelta, + loopLimit: fakeTimersConfig.timerLimit || 100_000, + now: fakeTimersConfig.now ?? Date.now(), + shouldAdvanceTime: Boolean(fakeTimersConfig.advanceTimers), + shouldClearNativeTimers: true, + toFake: Array.from(toFake) + }; + } +} +exports.default = FakeTimers; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/fake-timers/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/fake-timers/package.json new file mode 100644 index 0000000000000000000000000000000000000000..9890454753e6d50fe7eebfc1b62dc47a083cb580 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/fake-timers/package.json @@ -0,0 +1,38 @@ +{ + "name": "@jest/fake-timers", + "version": "29.7.0", + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/jest-fake-timers" + }, + "license": "MIT", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "dependencies": { + "@jest/types": "^29.6.3", + "@sinonjs/fake-timers": "^10.0.2", + "@types/node": "*", + "jest-message-util": "^29.7.0", + "jest-mock": "^29.7.0", + "jest-util": "^29.7.0" + }, + "devDependencies": { + "@jest/test-utils": "^29.7.0", + "@types/sinonjs__fake-timers": "^8.1.2" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "publishConfig": { + "access": "public" + }, + "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/globals/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/globals/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/globals/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/globals/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/globals/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..456044cee05ce78ffe1cb4e9d028374b2c18a77d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/globals/build/index.d.ts @@ -0,0 +1,71 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +import type { Jest } from '@jest/environment'; +import type { JestExpect } from '@jest/expect'; +import type { Global } from '@jest/types'; +import type { ClassLike, FunctionLike, Mock as JestMock, Mocked as JestMocked, MockedClass as JestMockedClass, MockedFunction as JestMockedFunction, MockedObject as JestMockedObject, Replaced as JestReplaced, Spied as JestSpied, SpiedClass as JestSpiedClass, SpiedFunction as JestSpiedFunction, SpiedGetter as JestSpiedGetter, SpiedSetter as JestSpiedSetter, UnknownFunction } from 'jest-mock'; +export declare const expect: JestExpect; +export declare const it: Global.GlobalAdditions['it']; +export declare const test: Global.GlobalAdditions['test']; +export declare const fit: Global.GlobalAdditions['fit']; +export declare const xit: Global.GlobalAdditions['xit']; +export declare const xtest: Global.GlobalAdditions['xtest']; +export declare const describe: Global.GlobalAdditions['describe']; +export declare const xdescribe: Global.GlobalAdditions['xdescribe']; +export declare const fdescribe: Global.GlobalAdditions['fdescribe']; +export declare const beforeAll: Global.GlobalAdditions['beforeAll']; +export declare const beforeEach: Global.GlobalAdditions['beforeEach']; +export declare const afterEach: Global.GlobalAdditions['afterEach']; +export declare const afterAll: Global.GlobalAdditions['afterAll']; +declare const jest: Jest; +declare namespace jest { + /** + * Constructs the type of a mock function, e.g. the return type of `jest.fn()`. + */ + type Mock = JestMock; + /** + * Wraps a class, function or object type with Jest mock type definitions. + */ + type Mocked = JestMocked; + /** + * Wraps a class type with Jest mock type definitions. + */ + type MockedClass = JestMockedClass; + /** + * Wraps a function type with Jest mock type definitions. + */ + type MockedFunction = JestMockedFunction; + /** + * Wraps an object type with Jest mock type definitions. + */ + type MockedObject = JestMockedObject; + /** + * Constructs the type of a replaced property. + */ + type Replaced = JestReplaced; + /** + * Constructs the type of a spied class or function. + */ + type Spied = JestSpied; + /** + * Constructs the type of a spied class. + */ + type SpiedClass = JestSpiedClass; + /** + * Constructs the type of a spied function. + */ + type SpiedFunction = JestSpiedFunction; + /** + * Constructs the type of a spied getter. + */ + type SpiedGetter = JestSpiedGetter; + /** + * Constructs the type of a spied setter. + */ + type SpiedSetter = JestSpiedSetter; +} +export { jest }; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/globals/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/globals/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..ebd57915b2790fc93e46e10844d039b2a558977d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/globals/build/index.js @@ -0,0 +1,14 @@ +'use strict'; + +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// eslint-disable-next-line @typescript-eslint/no-namespace + +throw new Error( + 'Do not import `@jest/globals` outside of the Jest test environment' +); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/globals/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/globals/package.json new file mode 100644 index 0000000000000000000000000000000000000000..0cd7d62e26dbdee24b95e60d6d9c9e39c07d73b9 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/globals/package.json @@ -0,0 +1,32 @@ +{ + "name": "@jest/globals", + "version": "29.7.0", + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/jest-globals" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "license": "MIT", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "dependencies": { + "@jest/environment": "^29.7.0", + "@jest/expect": "^29.7.0", + "@jest/types": "^29.6.3", + "jest-mock": "^29.7.0" + }, + "publishConfig": { + "access": "public" + }, + "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/assets/jest_logo.png b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/assets/jest_logo.png new file mode 100644 index 0000000000000000000000000000000000000000..56647a1ca3717406b9b159a8c0acbf7f5e43564a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/assets/jest_logo.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:029c63c6836c21478bf6ea3bd2f89e8249c3f054b0cb00147ba16e93a535b537 +size 3030 diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/BaseReporter.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/BaseReporter.js new file mode 100644 index 0000000000000000000000000000000000000000..83ce850a1aaf224fe66473a3acabcbdd74f3f245 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/BaseReporter.js @@ -0,0 +1,48 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const {remove: preRunMessageRemove} = _jestUtil().preRunMessage; +class BaseReporter { + _error; + log(message) { + process.stderr.write(`${message}\n`); + } + onRunStart(_results, _options) { + preRunMessageRemove(process.stderr); + } + + /* eslint-disable @typescript-eslint/no-empty-function */ + onTestCaseResult(_test, _testCaseResult) {} + onTestResult(_test, _testResult, _results) {} + onTestStart(_test) {} + onRunComplete(_testContexts, _aggregatedResults) {} + /* eslint-enable */ + + _setError(error) { + this._error = error; + } + + // Return an error that occurred during reporting. This error will + // define whether the test run was successful or failed. + getLastError() { + return this._error; + } +} +exports.default = BaseReporter; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/CoverageReporter.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/CoverageReporter.js new file mode 100644 index 0000000000000000000000000000000000000000..48ba4feb38349cb1a5671635ebf5841bbf5c31fa --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/CoverageReporter.js @@ -0,0 +1,561 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _v8Coverage() { + const data = require('@bcoe/v8-coverage'); + _v8Coverage = function () { + return data; + }; + return data; +} +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _glob() { + const data = _interopRequireDefault(require('glob')); + _glob = function () { + return data; + }; + return data; +} +function fs() { + const data = _interopRequireWildcard(require('graceful-fs')); + fs = function () { + return data; + }; + return data; +} +function _istanbulLibCoverage() { + const data = _interopRequireDefault(require('istanbul-lib-coverage')); + _istanbulLibCoverage = function () { + return data; + }; + return data; +} +function _istanbulLibReport() { + const data = _interopRequireDefault(require('istanbul-lib-report')); + _istanbulLibReport = function () { + return data; + }; + return data; +} +function _istanbulLibSourceMaps() { + const data = _interopRequireDefault(require('istanbul-lib-source-maps')); + _istanbulLibSourceMaps = function () { + return data; + }; + return data; +} +function _istanbulReports() { + const data = _interopRequireDefault(require('istanbul-reports')); + _istanbulReports = function () { + return data; + }; + return data; +} +function _v8ToIstanbul() { + const data = _interopRequireDefault(require('v8-to-istanbul')); + _v8ToIstanbul = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +function _jestWorker() { + const data = require('jest-worker'); + _jestWorker = function () { + return data; + }; + return data; +} +var _BaseReporter = _interopRequireDefault(require('./BaseReporter')); +var _getWatermarks = _interopRequireDefault(require('./getWatermarks')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const FAIL_COLOR = _chalk().default.bold.red; +const RUNNING_TEST_COLOR = _chalk().default.bold.dim; +class CoverageReporter extends _BaseReporter.default { + _context; + _coverageMap; + _globalConfig; + _sourceMapStore; + _v8CoverageResults; + static filename = __filename; + constructor(globalConfig, context) { + super(); + this._context = context; + this._coverageMap = _istanbulLibCoverage().default.createCoverageMap({}); + this._globalConfig = globalConfig; + this._sourceMapStore = + _istanbulLibSourceMaps().default.createSourceMapStore(); + this._v8CoverageResults = []; + } + onTestResult(_test, testResult) { + if (testResult.v8Coverage) { + this._v8CoverageResults.push(testResult.v8Coverage); + return; + } + if (testResult.coverage) { + this._coverageMap.merge(testResult.coverage); + } + } + async onRunComplete(testContexts, aggregatedResults) { + await this._addUntestedFiles(testContexts); + const {map, reportContext} = await this._getCoverageResult(); + try { + const coverageReporters = this._globalConfig.coverageReporters || []; + if (!this._globalConfig.useStderr && coverageReporters.length < 1) { + coverageReporters.push('text-summary'); + } + coverageReporters.forEach(reporter => { + let additionalOptions = {}; + if (Array.isArray(reporter)) { + [reporter, additionalOptions] = reporter; + } + _istanbulReports() + .default.create(reporter, { + maxCols: process.stdout.columns || Infinity, + ...additionalOptions + }) + .execute(reportContext); + }); + aggregatedResults.coverageMap = map; + } catch (e) { + console.error( + _chalk().default.red(` + Failed to write coverage reports: + ERROR: ${e.toString()} + STACK: ${e.stack} + `) + ); + } + this._checkThreshold(map); + } + async _addUntestedFiles(testContexts) { + const files = []; + testContexts.forEach(context => { + const config = context.config; + if ( + this._globalConfig.collectCoverageFrom && + this._globalConfig.collectCoverageFrom.length + ) { + context.hasteFS + .matchFilesWithGlob( + this._globalConfig.collectCoverageFrom, + config.rootDir + ) + .forEach(filePath => + files.push({ + config, + path: filePath + }) + ); + } + }); + if (!files.length) { + return; + } + if (_jestUtil().isInteractive) { + process.stderr.write( + RUNNING_TEST_COLOR('Running coverage on untested files...') + ); + } + let worker; + if (this._globalConfig.maxWorkers <= 1) { + worker = require('./CoverageWorker'); + } else { + worker = new (_jestWorker().Worker)(require.resolve('./CoverageWorker'), { + enableWorkerThreads: this._globalConfig.workerThreads, + exposedMethods: ['worker'], + forkOptions: { + serialization: 'json' + }, + maxRetries: 2, + numWorkers: this._globalConfig.maxWorkers + }); + } + const instrumentation = files.map(async fileObj => { + const filename = fileObj.path; + const config = fileObj.config; + const hasCoverageData = this._v8CoverageResults.some(v8Res => + v8Res.some(innerRes => innerRes.result.url === filename) + ); + if ( + !hasCoverageData && + !this._coverageMap.data[filename] && + 'worker' in worker + ) { + try { + const result = await worker.worker({ + config, + context: { + changedFiles: + this._context.changedFiles && + Array.from(this._context.changedFiles), + sourcesRelatedToTestsInChangedFiles: + this._context.sourcesRelatedToTestsInChangedFiles && + Array.from(this._context.sourcesRelatedToTestsInChangedFiles) + }, + globalConfig: this._globalConfig, + path: filename + }); + if (result) { + if (result.kind === 'V8Coverage') { + this._v8CoverageResults.push([ + { + codeTransformResult: undefined, + result: result.result + } + ]); + } else { + this._coverageMap.addFileCoverage(result.coverage); + } + } + } catch (error) { + console.error( + _chalk().default.red( + [ + `Failed to collect coverage from ${filename}`, + `ERROR: ${error.message}`, + `STACK: ${error.stack}` + ].join('\n') + ) + ); + } + } + }); + try { + await Promise.all(instrumentation); + } catch { + // Do nothing; errors were reported earlier to the console. + } + if (_jestUtil().isInteractive) { + (0, _jestUtil().clearLine)(process.stderr); + } + if (worker && 'end' in worker && typeof worker.end === 'function') { + await worker.end(); + } + } + _checkThreshold(map) { + const {coverageThreshold} = this._globalConfig; + if (coverageThreshold) { + function check(name, thresholds, actuals) { + return ['statements', 'branches', 'lines', 'functions'].reduce( + (errors, key) => { + const actual = actuals[key].pct; + const actualUncovered = actuals[key].total - actuals[key].covered; + const threshold = thresholds[key]; + if (threshold !== undefined) { + if (threshold < 0) { + if (threshold * -1 < actualUncovered) { + errors.push( + `Jest: Uncovered count for ${key} (${actualUncovered}) ` + + `exceeds ${name} threshold (${-1 * threshold})` + ); + } + } else if (actual < threshold) { + errors.push( + `Jest: "${name}" coverage threshold for ${key} (${threshold}%) not met: ${actual}%` + ); + } + } + return errors; + }, + [] + ); + } + const THRESHOLD_GROUP_TYPES = { + GLOB: 'glob', + GLOBAL: 'global', + PATH: 'path' + }; + const coveredFiles = map.files(); + const thresholdGroups = Object.keys(coverageThreshold); + const groupTypeByThresholdGroup = {}; + const filesByGlob = {}; + const coveredFilesSortedIntoThresholdGroup = coveredFiles.reduce( + (files, file) => { + const pathOrGlobMatches = thresholdGroups.reduce( + (agg, thresholdGroup) => { + // Preserve trailing slash, but not required if root dir + // See https://github.com/jestjs/jest/issues/12703 + const resolvedThresholdGroup = path().resolve(thresholdGroup); + const suffix = + (thresholdGroup.endsWith(path().sep) || + (process.platform === 'win32' && + thresholdGroup.endsWith('/'))) && + !resolvedThresholdGroup.endsWith(path().sep) + ? path().sep + : ''; + const absoluteThresholdGroup = `${resolvedThresholdGroup}${suffix}`; + + // The threshold group might be a path: + + if (file.indexOf(absoluteThresholdGroup) === 0) { + groupTypeByThresholdGroup[thresholdGroup] = + THRESHOLD_GROUP_TYPES.PATH; + return agg.concat([[file, thresholdGroup]]); + } + + // If the threshold group is not a path it might be a glob: + + // Note: glob.sync is slow. By memoizing the files matching each glob + // (rather than recalculating it for each covered file) we save a tonne + // of execution time. + if (filesByGlob[absoluteThresholdGroup] === undefined) { + filesByGlob[absoluteThresholdGroup] = _glob() + .default.sync(absoluteThresholdGroup) + .map(filePath => path().resolve(filePath)); + } + if (filesByGlob[absoluteThresholdGroup].indexOf(file) > -1) { + groupTypeByThresholdGroup[thresholdGroup] = + THRESHOLD_GROUP_TYPES.GLOB; + return agg.concat([[file, thresholdGroup]]); + } + return agg; + }, + [] + ); + if (pathOrGlobMatches.length > 0) { + return files.concat(pathOrGlobMatches); + } + + // Neither a glob or a path? Toss it in global if there's a global threshold: + if (thresholdGroups.indexOf(THRESHOLD_GROUP_TYPES.GLOBAL) > -1) { + groupTypeByThresholdGroup[THRESHOLD_GROUP_TYPES.GLOBAL] = + THRESHOLD_GROUP_TYPES.GLOBAL; + return files.concat([[file, THRESHOLD_GROUP_TYPES.GLOBAL]]); + } + + // A covered file that doesn't have a threshold: + return files.concat([[file, undefined]]); + }, + [] + ); + const getFilesInThresholdGroup = thresholdGroup => + coveredFilesSortedIntoThresholdGroup + .filter(fileAndGroup => fileAndGroup[1] === thresholdGroup) + .map(fileAndGroup => fileAndGroup[0]); + function combineCoverage(filePaths) { + return filePaths + .map(filePath => map.fileCoverageFor(filePath)) + .reduce((combinedCoverage, nextFileCoverage) => { + if (combinedCoverage === undefined || combinedCoverage === null) { + return nextFileCoverage.toSummary(); + } + return combinedCoverage.merge(nextFileCoverage.toSummary()); + }, undefined); + } + let errors = []; + thresholdGroups.forEach(thresholdGroup => { + switch (groupTypeByThresholdGroup[thresholdGroup]) { + case THRESHOLD_GROUP_TYPES.GLOBAL: { + const coverage = combineCoverage( + getFilesInThresholdGroup(THRESHOLD_GROUP_TYPES.GLOBAL) + ); + if (coverage) { + errors = errors.concat( + check( + thresholdGroup, + coverageThreshold[thresholdGroup], + coverage + ) + ); + } + break; + } + case THRESHOLD_GROUP_TYPES.PATH: { + const coverage = combineCoverage( + getFilesInThresholdGroup(thresholdGroup) + ); + if (coverage) { + errors = errors.concat( + check( + thresholdGroup, + coverageThreshold[thresholdGroup], + coverage + ) + ); + } + break; + } + case THRESHOLD_GROUP_TYPES.GLOB: + getFilesInThresholdGroup(thresholdGroup).forEach( + fileMatchingGlob => { + errors = errors.concat( + check( + fileMatchingGlob, + coverageThreshold[thresholdGroup], + map.fileCoverageFor(fileMatchingGlob).toSummary() + ) + ); + } + ); + break; + default: + // If the file specified by path is not found, error is returned. + if (thresholdGroup !== THRESHOLD_GROUP_TYPES.GLOBAL) { + errors = errors.concat( + `Jest: Coverage data for ${thresholdGroup} was not found.` + ); + } + // Sometimes all files in the coverage data are matched by + // PATH and GLOB threshold groups in which case, don't error when + // the global threshold group doesn't match any files. + } + }); + + errors = errors.filter( + err => err !== undefined && err !== null && err.length > 0 + ); + if (errors.length > 0) { + this.log(`${FAIL_COLOR(errors.join('\n'))}`); + this._setError(new Error(errors.join('\n'))); + } + } + } + async _getCoverageResult() { + if (this._globalConfig.coverageProvider === 'v8') { + const mergedCoverages = (0, _v8Coverage().mergeProcessCovs)( + this._v8CoverageResults.map(cov => ({ + result: cov.map(r => r.result) + })) + ); + const fileTransforms = new Map(); + this._v8CoverageResults.forEach(res => + res.forEach(r => { + if (r.codeTransformResult && !fileTransforms.has(r.result.url)) { + fileTransforms.set(r.result.url, r.codeTransformResult); + } + }) + ); + const transformedCoverage = await Promise.all( + mergedCoverages.result.map(async res => { + const fileTransform = fileTransforms.get(res.url); + let sourcemapContent = undefined; + if ( + fileTransform?.sourceMapPath && + fs().existsSync(fileTransform.sourceMapPath) + ) { + sourcemapContent = JSON.parse( + fs().readFileSync(fileTransform.sourceMapPath, 'utf8') + ); + } + const converter = (0, _v8ToIstanbul().default)( + res.url, + fileTransform?.wrapperLength ?? 0, + fileTransform && sourcemapContent + ? { + originalSource: fileTransform.originalCode, + source: fileTransform.code, + sourceMap: { + sourcemap: { + file: res.url, + ...sourcemapContent + } + } + } + : { + source: fs().readFileSync(res.url, 'utf8') + } + ); + await converter.load(); + converter.applyCoverage(res.functions); + const istanbulData = converter.toIstanbul(); + return istanbulData; + }) + ); + const map = _istanbulLibCoverage().default.createCoverageMap({}); + transformedCoverage.forEach(res => map.merge(res)); + const reportContext = _istanbulLibReport().default.createContext({ + coverageMap: map, + dir: this._globalConfig.coverageDirectory, + watermarks: (0, _getWatermarks.default)(this._globalConfig) + }); + return { + map, + reportContext + }; + } + const map = await this._sourceMapStore.transformCoverage(this._coverageMap); + const reportContext = _istanbulLibReport().default.createContext({ + coverageMap: map, + dir: this._globalConfig.coverageDirectory, + sourceFinder: this._sourceMapStore.sourceFinder, + watermarks: (0, _getWatermarks.default)(this._globalConfig) + }); + return { + map, + reportContext + }; + } +} +exports.default = CoverageReporter; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/CoverageWorker.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/CoverageWorker.js new file mode 100644 index 0000000000000000000000000000000000000000..685fcfacbe5719c48a358d363b9b9846917a60cd --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/CoverageWorker.js @@ -0,0 +1,89 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.worker = worker; +function _exit() { + const data = _interopRequireDefault(require('exit')); + _exit = function () { + return data; + }; + return data; +} +function fs() { + const data = _interopRequireWildcard(require('graceful-fs')); + fs = function () { + return data; + }; + return data; +} +var _generateEmptyCoverage = _interopRequireDefault( + require('./generateEmptyCoverage') +); +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// Make sure uncaught errors are logged before we exit. +process.on('uncaughtException', err => { + console.error(err.stack); + (0, _exit().default)(1); +}); +function worker({config, globalConfig, path, context}) { + return (0, _generateEmptyCoverage.default)( + fs().readFileSync(path, 'utf8'), + path, + globalConfig, + config, + context.changedFiles && new Set(context.changedFiles), + context.sourcesRelatedToTestsInChangedFiles && + new Set(context.sourcesRelatedToTestsInChangedFiles) + ); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/DefaultReporter.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/DefaultReporter.js new file mode 100644 index 0000000000000000000000000000000000000000..eb1c0e06c3728cd015b8a9cfa24a92b9b6ce8a21 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/DefaultReporter.js @@ -0,0 +1,229 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _console() { + const data = require('@jest/console'); + _console = function () { + return data; + }; + return data; +} +function _jestMessageUtil() { + const data = require('jest-message-util'); + _jestMessageUtil = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +var _BaseReporter = _interopRequireDefault(require('./BaseReporter')); +var _Status = _interopRequireDefault(require('./Status')); +var _getResultHeader = _interopRequireDefault(require('./getResultHeader')); +var _getSnapshotStatus = _interopRequireDefault(require('./getSnapshotStatus')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const TITLE_BULLET = _chalk().default.bold('\u25cf '); +class DefaultReporter extends _BaseReporter.default { + _clear; // ANSI clear sequence for the last printed status + _err; + _globalConfig; + _out; + _status; + _bufferedOutput; + static filename = __filename; + constructor(globalConfig) { + super(); + this._globalConfig = globalConfig; + this._clear = ''; + this._out = process.stdout.write.bind(process.stdout); + this._err = process.stderr.write.bind(process.stderr); + this._status = new _Status.default(globalConfig); + this._bufferedOutput = new Set(); + this.__wrapStdio(process.stdout); + this.__wrapStdio(process.stderr); + this._status.onChange(() => { + this.__clearStatus(); + this.__printStatus(); + }); + } + __wrapStdio(stream) { + const write = stream.write.bind(stream); + let buffer = []; + let timeout = null; + const flushBufferedOutput = () => { + const string = buffer.join(''); + buffer = []; + + // This is to avoid conflicts between random output and status text + this.__clearStatus(); + if (string) { + write(string); + } + this.__printStatus(); + this._bufferedOutput.delete(flushBufferedOutput); + }; + this._bufferedOutput.add(flushBufferedOutput); + const debouncedFlush = () => { + // If the process blows up no errors would be printed. + // There should be a smart way to buffer stderr, but for now + // we just won't buffer it. + if (stream === process.stderr) { + flushBufferedOutput(); + } else { + if (!timeout) { + timeout = setTimeout(() => { + flushBufferedOutput(); + timeout = null; + }, 100); + } + } + }; + stream.write = chunk => { + buffer.push(chunk); + debouncedFlush(); + return true; + }; + } + + // Don't wait for the debounced call and flush all output immediately. + forceFlushBufferedOutput() { + for (const flushBufferedOutput of this._bufferedOutput) { + flushBufferedOutput(); + } + } + __clearStatus() { + if (_jestUtil().isInteractive) { + if (this._globalConfig.useStderr) { + this._err(this._clear); + } else { + this._out(this._clear); + } + } + } + __printStatus() { + const {content, clear} = this._status.get(); + this._clear = clear; + if (_jestUtil().isInteractive) { + if (this._globalConfig.useStderr) { + this._err(content); + } else { + this._out(content); + } + } + } + onRunStart(aggregatedResults, options) { + this._status.runStarted(aggregatedResults, options); + } + onTestStart(test) { + this._status.testStarted(test.path, test.context.config); + } + onTestCaseResult(test, testCaseResult) { + this._status.addTestCaseResult(test, testCaseResult); + } + onRunComplete() { + this.forceFlushBufferedOutput(); + this._status.runFinished(); + process.stdout.write = this._out; + process.stderr.write = this._err; + (0, _jestUtil().clearLine)(process.stderr); + } + onTestResult(test, testResult, aggregatedResults) { + this.testFinished(test.context.config, testResult, aggregatedResults); + if (!testResult.skipped) { + this.printTestFileHeader( + testResult.testFilePath, + test.context.config, + testResult + ); + this.printTestFileFailureMessage( + testResult.testFilePath, + test.context.config, + testResult + ); + } + this.forceFlushBufferedOutput(); + } + testFinished(config, testResult, aggregatedResults) { + this._status.testFinished(config, testResult, aggregatedResults); + } + printTestFileHeader(testPath, config, result) { + // log retry errors if any exist + result.testResults.forEach(testResult => { + const testRetryReasons = testResult.retryReasons; + if (testRetryReasons && testRetryReasons.length > 0) { + this.log( + `${_chalk().default.reset.inverse.bold.yellow( + ' LOGGING RETRY ERRORS ' + )} ${_chalk().default.bold(testResult.fullName)}` + ); + testRetryReasons.forEach((retryReasons, index) => { + let {message, stack} = (0, + _jestMessageUtil().separateMessageFromStack)(retryReasons); + stack = this._globalConfig.noStackTrace + ? '' + : _chalk().default.dim( + (0, _jestMessageUtil().formatStackTrace)( + stack, + config, + this._globalConfig, + testPath + ) + ); + message = (0, _jestMessageUtil().indentAllLines)(message); + this.log( + `${_chalk().default.reset.inverse.bold.blueBright( + ` RETRY ${index + 1} ` + )}\n` + ); + this.log(`${message}\n${stack}\n`); + }); + } + }); + this.log((0, _getResultHeader.default)(result, this._globalConfig, config)); + if (result.console) { + this.log( + ` ${TITLE_BULLET}Console\n\n${(0, _console().getConsoleOutput)( + result.console, + config, + this._globalConfig + )}` + ); + } + } + printTestFileFailureMessage(_testPath, _config, result) { + if (result.failureMessage) { + this.log(result.failureMessage); + } + const didUpdate = this._globalConfig.updateSnapshot === 'all'; + const snapshotStatuses = (0, _getSnapshotStatus.default)( + result.snapshot, + didUpdate + ); + snapshotStatuses.forEach(this.log); + } +} +exports.default = DefaultReporter; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/GitHubActionsReporter.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/GitHubActionsReporter.js new file mode 100644 index 0000000000000000000000000000000000000000..1e99a7d384bedc0f20a8961db91d2c829a40e775 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/GitHubActionsReporter.js @@ -0,0 +1,381 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _stripAnsi() { + const data = _interopRequireDefault(require('strip-ansi')); + _stripAnsi = function () { + return data; + }; + return data; +} +function _jestMessageUtil() { + const data = require('jest-message-util'); + _jestMessageUtil = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +var _BaseReporter = _interopRequireDefault(require('./BaseReporter')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const titleSeparator = ' \u203A '; +const ICONS = _jestUtil().specialChars.ICONS; +class GitHubActionsReporter extends _BaseReporter.default { + static filename = __filename; + options; + constructor( + _globalConfig, + reporterOptions = { + silent: true + } + ) { + super(); + this.options = { + silent: + typeof reporterOptions.silent === 'boolean' + ? reporterOptions.silent + : true + }; + } + onTestResult(test, testResult, aggregatedResults) { + this.generateAnnotations(test, testResult); + if (!this.options.silent) { + this.printFullResult(test.context, testResult); + } + if (this.isLastTestSuite(aggregatedResults)) { + this.printFailedTestLogs(test, aggregatedResults); + } + } + generateAnnotations({context}, {testResults}) { + testResults.forEach(result => { + const title = [...result.ancestorTitles, result.title].join( + titleSeparator + ); + result.retryReasons?.forEach((retryReason, index) => { + this.#createAnnotation({ + ...this.#getMessageDetails(retryReason, context.config), + title: `RETRY ${index + 1}: ${title}`, + type: 'warning' + }); + }); + result.failureMessages.forEach(failureMessage => { + this.#createAnnotation({ + ...this.#getMessageDetails(failureMessage, context.config), + title, + type: 'error' + }); + }); + }); + } + #getMessageDetails(failureMessage, config) { + const {message, stack} = (0, _jestMessageUtil().separateMessageFromStack)( + failureMessage + ); + const stackLines = (0, _jestMessageUtil().getStackTraceLines)(stack); + const topFrame = (0, _jestMessageUtil().getTopFrame)(stackLines); + const normalizedStackLines = stackLines.map(line => + (0, _jestMessageUtil().formatPath)(line, config) + ); + const messageText = [message, ...normalizedStackLines].join('\n'); + return { + file: topFrame?.file, + line: topFrame?.line, + message: messageText + }; + } + #createAnnotation({file, line, message, title, type}) { + message = (0, _stripAnsi().default)( + // copied from: https://github.com/actions/toolkit/blob/main/packages/core/src/command.ts + message.replace(/%/g, '%25').replace(/\r/g, '%0D').replace(/\n/g, '%0A') + ); + this.log( + `\n::${type} file=${file},line=${line},title=${title}::${message}` + ); + } + isLastTestSuite(results) { + const passedTestSuites = results.numPassedTestSuites; + const failedTestSuites = results.numFailedTestSuites; + const totalTestSuites = results.numTotalTestSuites; + const computedTotal = passedTestSuites + failedTestSuites; + if (computedTotal < totalTestSuites) { + return false; + } else if (computedTotal === totalTestSuites) { + return true; + } else { + throw new Error( + `Sum(${computedTotal}) of passed (${passedTestSuites}) and failed (${failedTestSuites}) test suites is greater than the total number of test suites (${totalTestSuites}). Please report the bug at https://github.com/jestjs/jest/issues` + ); + } + } + printFullResult(context, results) { + const rootDir = context.config.rootDir; + let testDir = results.testFilePath.replace(rootDir, ''); + testDir = testDir.slice(1, testDir.length); + const resultTree = this.getResultTree( + results.testResults, + testDir, + results.perfStats + ); + this.printResultTree(resultTree); + } + arrayEqual(a1, a2) { + if (a1.length !== a2.length) { + return false; + } + for (let index = 0; index < a1.length; index++) { + const element = a1[index]; + if (element !== a2[index]) { + return false; + } + } + return true; + } + arrayChild(a1, a2) { + if (a1.length - a2.length !== 1) { + return false; + } + for (let index = 0; index < a2.length; index++) { + const element = a2[index]; + if (element !== a1[index]) { + return false; + } + } + return true; + } + getResultTree(suiteResult, testPath, suitePerf) { + const root = { + children: [], + name: testPath, + passed: true, + performanceInfo: suitePerf + }; + const branches = []; + suiteResult.forEach(element => { + if (element.ancestorTitles.length === 0) { + if (element.status === 'failed') { + root.passed = false; + } + const duration = element.duration || 1; + root.children.push({ + children: [], + duration, + name: element.title, + status: element.status + }); + } else { + let alreadyInserted = false; + for (let index = 0; index < branches.length; index++) { + if ( + this.arrayEqual(branches[index], element.ancestorTitles.slice(0, 1)) + ) { + alreadyInserted = true; + break; + } + } + if (!alreadyInserted) { + branches.push(element.ancestorTitles.slice(0, 1)); + } + } + }); + branches.forEach(element => { + const newChild = this.getResultChildren(suiteResult, element); + if (!newChild.passed) { + root.passed = false; + } + root.children.push(newChild); + }); + return root; + } + getResultChildren(suiteResult, ancestors) { + const node = { + children: [], + name: ancestors[ancestors.length - 1], + passed: true + }; + const branches = []; + suiteResult.forEach(element => { + let duration = element.duration; + if (!duration || isNaN(duration)) { + duration = 1; + } + if (this.arrayEqual(element.ancestorTitles, ancestors)) { + if (element.status === 'failed') { + node.passed = false; + } + node.children.push({ + children: [], + duration, + name: element.title, + status: element.status + }); + } else if ( + this.arrayChild( + element.ancestorTitles.slice(0, ancestors.length + 1), + ancestors + ) + ) { + let alreadyInserted = false; + for (let index = 0; index < branches.length; index++) { + if ( + this.arrayEqual( + branches[index], + element.ancestorTitles.slice(0, ancestors.length + 1) + ) + ) { + alreadyInserted = true; + break; + } + } + if (!alreadyInserted) { + branches.push(element.ancestorTitles.slice(0, ancestors.length + 1)); + } + } + }); + branches.forEach(element => { + const newChild = this.getResultChildren(suiteResult, element); + if (!newChild.passed) { + node.passed = false; + } + node.children.push(newChild); + }); + return node; + } + printResultTree(resultTree) { + let perfMs; + if (resultTree.performanceInfo.slow) { + perfMs = ` (${_chalk().default.red.inverse( + `${resultTree.performanceInfo.runtime} ms` + )})`; + } else { + perfMs = ` (${resultTree.performanceInfo.runtime} ms)`; + } + if (resultTree.passed) { + this.startGroup( + `${_chalk().default.bold.green.inverse('PASS')} ${ + resultTree.name + }${perfMs}` + ); + resultTree.children.forEach(child => { + this.recursivePrintResultTree(child, true, 1); + }); + this.endGroup(); + } else { + this.log( + ` ${_chalk().default.bold.red.inverse('FAIL')} ${ + resultTree.name + }${perfMs}` + ); + resultTree.children.forEach(child => { + this.recursivePrintResultTree(child, false, 1); + }); + } + } + recursivePrintResultTree(resultTree, alreadyGrouped, depth) { + if (resultTree.children.length === 0) { + if (!('duration' in resultTree)) { + throw new Error('Expected a leaf. Got a node.'); + } + let numberSpaces = depth; + if (!alreadyGrouped) { + numberSpaces++; + } + const spaces = ' '.repeat(numberSpaces); + let resultSymbol; + switch (resultTree.status) { + case 'passed': + resultSymbol = _chalk().default.green(ICONS.success); + break; + case 'failed': + resultSymbol = _chalk().default.red(ICONS.failed); + break; + case 'todo': + resultSymbol = _chalk().default.magenta(ICONS.todo); + break; + case 'pending': + case 'skipped': + resultSymbol = _chalk().default.yellow(ICONS.pending); + break; + } + this.log( + `${spaces + resultSymbol} ${resultTree.name} (${ + resultTree.duration + } ms)` + ); + } else { + if (!('passed' in resultTree)) { + throw new Error('Expected a node. Got a leaf'); + } + if (resultTree.passed) { + if (alreadyGrouped) { + this.log(' '.repeat(depth) + resultTree.name); + resultTree.children.forEach(child => { + this.recursivePrintResultTree(child, true, depth + 1); + }); + } else { + this.startGroup(' '.repeat(depth) + resultTree.name); + resultTree.children.forEach(child => { + this.recursivePrintResultTree(child, true, depth + 1); + }); + this.endGroup(); + } + } else { + this.log(' '.repeat(depth + 1) + resultTree.name); + resultTree.children.forEach(child => { + this.recursivePrintResultTree(child, false, depth + 1); + }); + } + } + } + printFailedTestLogs(context, testResults) { + const rootDir = context.context.config.rootDir; + const results = testResults.testResults; + let written = false; + results.forEach(result => { + let testDir = result.testFilePath; + testDir = testDir.replace(rootDir, ''); + testDir = testDir.slice(1, testDir.length); + if (result.failureMessage) { + if (!written) { + this.log(''); + written = true; + } + this.startGroup(`Errors thrown in ${testDir}`); + this.log(result.failureMessage); + this.endGroup(); + } + }); + return written; + } + startGroup(title) { + this.log(`::group::${title}`); + } + endGroup() { + this.log('::endgroup::'); + } +} +exports.default = GitHubActionsReporter; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/NotifyReporter.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/NotifyReporter.js new file mode 100644 index 0000000000000000000000000000000000000000..fec46abcbfb2bc90439463bb01309ccd24ebef60 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/NotifyReporter.js @@ -0,0 +1,218 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function util() { + const data = _interopRequireWildcard(require('util')); + util = function () { + return data; + }; + return data; +} +function _exit() { + const data = _interopRequireDefault(require('exit')); + _exit = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +var _BaseReporter = _interopRequireDefault(require('./BaseReporter')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const isDarwin = process.platform === 'darwin'; +const icon = path().resolve(__dirname, '../assets/jest_logo.png'); +class NotifyReporter extends _BaseReporter.default { + _notifier = loadNotifier(); + _globalConfig; + _context; + static filename = __filename; + constructor(globalConfig, context) { + super(); + this._globalConfig = globalConfig; + this._context = context; + } + onRunComplete(testContexts, result) { + const success = + result.numFailedTests === 0 && result.numRuntimeErrorTestSuites === 0; + const firstContext = testContexts.values().next(); + const hasteFS = + firstContext && firstContext.value && firstContext.value.hasteFS; + let packageName; + if (hasteFS != null) { + // assuming root package.json is the first one + const [filePath] = hasteFS.matchFiles('package.json'); + packageName = + filePath != null + ? hasteFS.getModuleName(filePath) + : this._globalConfig.rootDir; + } else { + packageName = this._globalConfig.rootDir; + } + packageName = packageName != null ? `${packageName} - ` : ''; + const notifyMode = this._globalConfig.notifyMode; + const statusChanged = + this._context.previousSuccess !== success || this._context.firstRun; + const testsHaveRun = result.numTotalTests !== 0; + if ( + testsHaveRun && + success && + (notifyMode === 'always' || + notifyMode === 'success' || + notifyMode === 'success-change' || + (notifyMode === 'change' && statusChanged) || + (notifyMode === 'failure-change' && statusChanged)) + ) { + const title = util().format('%s%d%% Passed', packageName, 100); + const message = `${isDarwin ? '\u2705 ' : ''}${(0, _jestUtil().pluralize)( + 'test', + result.numPassedTests + )} passed`; + this._notifier.notify({ + hint: 'int:transient:1', + icon, + message, + timeout: false, + title + }); + } else if ( + testsHaveRun && + !success && + (notifyMode === 'always' || + notifyMode === 'failure' || + notifyMode === 'failure-change' || + (notifyMode === 'change' && statusChanged) || + (notifyMode === 'success-change' && statusChanged)) + ) { + const failed = result.numFailedTests / result.numTotalTests; + const title = util().format( + '%s%d%% Failed', + packageName, + Math.ceil(Number.isNaN(failed) ? 0 : failed * 100) + ); + const message = util().format( + `${isDarwin ? '\u26D4\uFE0F ' : ''}%d of %d tests failed`, + result.numFailedTests, + result.numTotalTests + ); + const watchMode = this._globalConfig.watch || this._globalConfig.watchAll; + const restartAnswer = 'Run again'; + const quitAnswer = 'Exit tests'; + if (!watchMode) { + this._notifier.notify({ + hint: 'int:transient:1', + icon, + message, + timeout: false, + title + }); + } else { + this._notifier.notify( + { + // @ts-expect-error - not all options are supported by all systems (specifically `actions` and `hint`) + actions: [restartAnswer, quitAnswer], + closeLabel: 'Close', + hint: 'int:transient:1', + icon, + message, + timeout: false, + title + }, + (err, _, metadata) => { + if (err || !metadata) { + return; + } + if (metadata.activationValue === quitAnswer) { + (0, _exit().default)(0); + return; + } + if ( + metadata.activationValue === restartAnswer && + this._context.startRun + ) { + this._context.startRun(this._globalConfig); + } + } + ); + } + } + this._context.previousSuccess = success; + this._context.firstRun = false; + } +} +exports.default = NotifyReporter; +function loadNotifier() { + try { + return require('node-notifier'); + } catch (err) { + if (err.code !== 'MODULE_NOT_FOUND') { + throw err; + } + throw Error( + 'notify reporter requires optional peer dependency "node-notifier" but it was not found' + ); + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/Status.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/Status.js new file mode 100644 index 0000000000000000000000000000000000000000..1e751df8bb10113612e3c00137b04cf1ca74b411 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/Status.js @@ -0,0 +1,214 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _stringLength() { + const data = _interopRequireDefault(require('string-length')); + _stringLength = function () { + return data; + }; + return data; +} +var _getSummary = _interopRequireDefault(require('./getSummary')); +var _printDisplayName = _interopRequireDefault(require('./printDisplayName')); +var _trimAndFormatPath = _interopRequireDefault(require('./trimAndFormatPath')); +var _wrapAnsiString = _interopRequireDefault(require('./wrapAnsiString')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const RUNNING_TEXT = ' RUNS '; +const RUNNING = `${_chalk().default.reset.inverse.yellow.bold(RUNNING_TEXT)} `; + +/** + * This class is a perf optimization for sorting the list of currently + * running tests. It tries to keep tests in the same positions without + * shifting the whole list. + */ +class CurrentTestList { + _array; + constructor() { + this._array = []; + } + add(testPath, config) { + const index = this._array.indexOf(null); + const record = { + config, + testPath + }; + if (index !== -1) { + this._array[index] = record; + } else { + this._array.push(record); + } + } + delete(testPath) { + const record = this._array.find( + record => record !== null && record.testPath === testPath + ); + this._array[this._array.indexOf(record || null)] = null; + } + get() { + return this._array; + } +} +/** + * A class that generates the CLI status of currently running tests + * and also provides an ANSI escape sequence to remove status lines + * from the terminal. + */ +class Status { + _cache; + _callback; + _currentTests; + _currentTestCases; + _done; + _emitScheduled; + _estimatedTime; + _interval; + _aggregatedResults; + _showStatus; + constructor(_globalConfig) { + this._globalConfig = _globalConfig; + this._cache = null; + this._currentTests = new CurrentTestList(); + this._currentTestCases = []; + this._done = false; + this._emitScheduled = false; + this._estimatedTime = 0; + this._showStatus = false; + } + onChange(callback) { + this._callback = callback; + } + runStarted(aggregatedResults, options) { + this._estimatedTime = (options && options.estimatedTime) || 0; + this._showStatus = options && options.showStatus; + this._interval = setInterval(() => this._tick(), 1000); + this._aggregatedResults = aggregatedResults; + this._debouncedEmit(); + } + runFinished() { + this._done = true; + if (this._interval) clearInterval(this._interval); + this._emit(); + } + addTestCaseResult(test, testCaseResult) { + this._currentTestCases.push({ + test, + testCaseResult + }); + if (!this._showStatus) { + this._emit(); + } else { + this._debouncedEmit(); + } + } + testStarted(testPath, config) { + this._currentTests.add(testPath, config); + if (!this._showStatus) { + this._emit(); + } else { + this._debouncedEmit(); + } + } + testFinished(_config, testResult, aggregatedResults) { + const {testFilePath} = testResult; + this._aggregatedResults = aggregatedResults; + this._currentTests.delete(testFilePath); + this._currentTestCases = this._currentTestCases.filter(({test}) => { + if (_config !== test.context.config) { + return true; + } + return test.path !== testFilePath; + }); + this._debouncedEmit(); + } + get() { + if (this._cache) { + return this._cache; + } + if (this._done) { + return { + clear: '', + content: '' + }; + } + const width = process.stdout.columns; + let content = '\n'; + this._currentTests.get().forEach(record => { + if (record) { + const {config, testPath} = record; + const projectDisplayName = config.displayName + ? `${(0, _printDisplayName.default)(config)} ` + : ''; + const prefix = RUNNING + projectDisplayName; + content += `${(0, _wrapAnsiString.default)( + prefix + + (0, _trimAndFormatPath.default)( + (0, _stringLength().default)(prefix), + config, + testPath, + width + ), + width + )}\n`; + } + }); + if (this._showStatus && this._aggregatedResults) { + content += `\n${(0, _getSummary.default)(this._aggregatedResults, { + currentTestCases: this._currentTestCases, + estimatedTime: this._estimatedTime, + roundTime: true, + seed: this._globalConfig.seed, + showSeed: this._globalConfig.showSeed, + width + })}`; + } + let height = 0; + for (let i = 0; i < content.length; i++) { + if (content[i] === '\n') { + height++; + } + } + const clear = '\r\x1B[K\r\x1B[1A'.repeat(height); + return (this._cache = { + clear, + content + }); + } + _emit() { + this._cache = null; + if (this._callback) this._callback(); + } + _debouncedEmit() { + if (!this._emitScheduled) { + // Perf optimization to avoid two separate renders When + // one test finishes and another test starts executing. + this._emitScheduled = true; + setTimeout(() => { + this._emit(); + this._emitScheduled = false; + }, 100); + } + } + _tick() { + this._debouncedEmit(); + } +} +exports.default = Status; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/SummaryReporter.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/SummaryReporter.js new file mode 100644 index 0000000000000000000000000000000000000000..da1bffac9bec8ca8eb22990084d1483d130c722e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/SummaryReporter.js @@ -0,0 +1,239 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +var _BaseReporter = _interopRequireDefault(require('./BaseReporter')); +var _getResultHeader = _interopRequireDefault(require('./getResultHeader')); +var _getSnapshotSummary = _interopRequireDefault( + require('./getSnapshotSummary') +); +var _getSummary = _interopRequireDefault(require('./getSummary')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const NPM_EVENTS = new Set([ + 'prepublish', + 'publish', + 'postpublish', + 'preinstall', + 'install', + 'postinstall', + 'preuninstall', + 'uninstall', + 'postuninstall', + 'preversion', + 'version', + 'postversion', + 'pretest', + 'test', + 'posttest', + 'prestop', + 'stop', + 'poststop', + 'prestart', + 'start', + 'poststart', + 'prerestart', + 'restart', + 'postrestart' +]); +const {npm_config_user_agent, npm_lifecycle_event, npm_lifecycle_script} = + process.env; +class SummaryReporter extends _BaseReporter.default { + _estimatedTime; + _globalConfig; + _summaryThreshold; + static filename = __filename; + constructor(globalConfig, options) { + super(); + this._globalConfig = globalConfig; + this._estimatedTime = 0; + this._validateOptions(options); + this._summaryThreshold = options?.summaryThreshold ?? 20; + } + _validateOptions(options) { + if ( + options?.summaryThreshold && + typeof options.summaryThreshold !== 'number' + ) { + throw new TypeError('The option summaryThreshold should be a number'); + } + } + + // If we write more than one character at a time it is possible that + // Node.js exits in the middle of printing the result. This was first observed + // in Node.js 0.10 and still persists in Node.js 6.7+. + // Let's print the test failure summary character by character which is safer + // when hundreds of tests are failing. + _write(string) { + for (let i = 0; i < string.length; i++) { + process.stderr.write(string.charAt(i)); + } + } + onRunStart(aggregatedResults, options) { + super.onRunStart(aggregatedResults, options); + this._estimatedTime = options.estimatedTime; + } + onRunComplete(testContexts, aggregatedResults) { + const {numTotalTestSuites, testResults, wasInterrupted} = aggregatedResults; + if (numTotalTestSuites) { + const lastResult = testResults[testResults.length - 1]; + // Print a newline if the last test did not fail to line up newlines + // similar to when an error would have been thrown in the test. + if ( + !this._globalConfig.verbose && + lastResult && + !lastResult.numFailingTests && + !lastResult.testExecError + ) { + this.log(''); + } + this._printSummary(aggregatedResults, this._globalConfig); + this._printSnapshotSummary( + aggregatedResults.snapshot, + this._globalConfig + ); + let message = (0, _getSummary.default)(aggregatedResults, { + estimatedTime: this._estimatedTime, + seed: this._globalConfig.seed, + showSeed: this._globalConfig.showSeed + }); + if (!this._globalConfig.silent) { + message += `\n${ + wasInterrupted + ? _chalk().default.bold.red('Test run was interrupted.') + : this._getTestSummary(testContexts, this._globalConfig) + }`; + } + this.log(message); + } + } + _printSnapshotSummary(snapshots, globalConfig) { + if ( + snapshots.added || + snapshots.filesRemoved || + snapshots.unchecked || + snapshots.unmatched || + snapshots.updated + ) { + let updateCommand; + const event = npm_lifecycle_event || ''; + const prefix = NPM_EVENTS.has(event) ? '' : 'run '; + const isYarn = + typeof npm_config_user_agent === 'string' && + npm_config_user_agent.includes('yarn'); + const client = isYarn ? 'yarn' : 'npm'; + const scriptUsesJest = + typeof npm_lifecycle_script === 'string' && + npm_lifecycle_script.includes('jest'); + if (globalConfig.watch || globalConfig.watchAll) { + updateCommand = 'press `u`'; + } else if (event && scriptUsesJest) { + updateCommand = `run \`${`${client} ${prefix}${event}${ + isYarn ? '' : ' --' + }`} -u\``; + } else { + updateCommand = 're-run jest with `-u`'; + } + const snapshotSummary = (0, _getSnapshotSummary.default)( + snapshots, + globalConfig, + updateCommand + ); + snapshotSummary.forEach(this.log); + this.log(''); // print empty line + } + } + + _printSummary(aggregatedResults, globalConfig) { + // If there were any failing tests and there was a large number of tests + // executed, re-print the failing results at the end of execution output. + const failedTests = aggregatedResults.numFailedTests; + const runtimeErrors = aggregatedResults.numRuntimeErrorTestSuites; + if ( + failedTests + runtimeErrors > 0 && + aggregatedResults.numTotalTestSuites > this._summaryThreshold + ) { + this.log(_chalk().default.bold('Summary of all failing tests')); + aggregatedResults.testResults.forEach(testResult => { + const {failureMessage} = testResult; + if (failureMessage) { + this._write( + `${(0, _getResultHeader.default)( + testResult, + globalConfig + )}\n${failureMessage}\n` + ); + } + }); + this.log(''); // print empty line + } + } + + _getTestSummary(testContexts, globalConfig) { + const getMatchingTestsInfo = () => { + const prefix = globalConfig.findRelatedTests + ? ' related to files matching ' + : ' matching '; + return ( + _chalk().default.dim(prefix) + + (0, _jestUtil().testPathPatternToRegExp)( + globalConfig.testPathPattern + ).toString() + ); + }; + let testInfo = ''; + if (globalConfig.runTestsByPath) { + testInfo = _chalk().default.dim(' within paths'); + } else if (globalConfig.onlyChanged) { + testInfo = _chalk().default.dim(' related to changed files'); + } else if (globalConfig.testPathPattern) { + testInfo = getMatchingTestsInfo(); + } + let nameInfo = ''; + if (globalConfig.runTestsByPath) { + nameInfo = ` ${globalConfig.nonFlagArgs.map(p => `"${p}"`).join(', ')}`; + } else if (globalConfig.testNamePattern) { + nameInfo = `${_chalk().default.dim(' with tests matching ')}"${ + globalConfig.testNamePattern + }"`; + } + const contextInfo = + testContexts.size > 1 + ? _chalk().default.dim(' in ') + + testContexts.size + + _chalk().default.dim(' projects') + : ''; + return ( + _chalk().default.dim('Ran all test suites') + + testInfo + + nameInfo + + contextInfo + + _chalk().default.dim('.') + ); + } +} +exports.default = SummaryReporter; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/VerboseReporter.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/VerboseReporter.js new file mode 100644 index 0000000000000000000000000000000000000000..09461c20121f99ed34f15ac15062fe1d4f4d6fc8 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/VerboseReporter.js @@ -0,0 +1,175 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +var _DefaultReporter = _interopRequireDefault(require('./DefaultReporter')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const {ICONS} = _jestUtil().specialChars; +class VerboseReporter extends _DefaultReporter.default { + _globalConfig; + static filename = __filename; + constructor(globalConfig) { + super(globalConfig); + this._globalConfig = globalConfig; + } + + // Verbose mode is for debugging. Buffering of output is undesirable. + // See https://github.com/jestjs/jest/issues/8208 + __wrapStdio(stream) { + const write = stream.write.bind(stream); + stream.write = chunk => { + this.__clearStatus(); + write(chunk); + this.__printStatus(); + return true; + }; + } + static filterTestResults(testResults) { + return testResults.filter(({status}) => status !== 'pending'); + } + static groupTestsBySuites(testResults) { + const root = { + suites: [], + tests: [], + title: '' + }; + testResults.forEach(testResult => { + let targetSuite = root; + + // Find the target suite for this test, + // creating nested suites as necessary. + for (const title of testResult.ancestorTitles) { + let matchingSuite = targetSuite.suites.find(s => s.title === title); + if (!matchingSuite) { + matchingSuite = { + suites: [], + tests: [], + title + }; + targetSuite.suites.push(matchingSuite); + } + targetSuite = matchingSuite; + } + targetSuite.tests.push(testResult); + }); + return root; + } + onTestResult(test, result, aggregatedResults) { + super.testFinished(test.context.config, result, aggregatedResults); + if (!result.skipped) { + this.printTestFileHeader( + result.testFilePath, + test.context.config, + result + ); + if (!result.testExecError && !result.skipped) { + this._logTestResults(result.testResults); + } + this.printTestFileFailureMessage( + result.testFilePath, + test.context.config, + result + ); + } + super.forceFlushBufferedOutput(); + } + _logTestResults(testResults) { + this._logSuite(VerboseReporter.groupTestsBySuites(testResults), 0); + this._logLine(); + } + _logSuite(suite, indentLevel) { + if (suite.title) { + this._logLine(suite.title, indentLevel); + } + this._logTests(suite.tests, indentLevel + 1); + suite.suites.forEach(suite => this._logSuite(suite, indentLevel + 1)); + } + _getIcon(status) { + if (status === 'failed') { + return _chalk().default.red(ICONS.failed); + } else if (status === 'pending') { + return _chalk().default.yellow(ICONS.pending); + } else if (status === 'todo') { + return _chalk().default.magenta(ICONS.todo); + } else { + return _chalk().default.green(ICONS.success); + } + } + _logTest(test, indentLevel) { + const status = this._getIcon(test.status); + const time = test.duration + ? ` (${(0, _jestUtil().formatTime)(Math.round(test.duration))})` + : ''; + this._logLine( + `${status} ${_chalk().default.dim(test.title + time)}`, + indentLevel + ); + } + _logTests(tests, indentLevel) { + if (this._globalConfig.expand) { + tests.forEach(test => this._logTest(test, indentLevel)); + } else { + const summedTests = tests.reduce( + (result, test) => { + if (test.status === 'pending') { + result.pending.push(test); + } else if (test.status === 'todo') { + result.todo.push(test); + } else { + this._logTest(test, indentLevel); + } + return result; + }, + { + pending: [], + todo: [] + } + ); + if (summedTests.pending.length > 0) { + summedTests.pending.forEach(this._logTodoOrPendingTest(indentLevel)); + } + if (summedTests.todo.length > 0) { + summedTests.todo.forEach(this._logTodoOrPendingTest(indentLevel)); + } + } + } + _logTodoOrPendingTest(indentLevel) { + return test => { + const printedTestStatus = + test.status === 'pending' ? 'skipped' : test.status; + const icon = this._getIcon(test.status); + const text = _chalk().default.dim(`${printedTestStatus} ${test.title}`); + this._logLine(`${icon} ${text}`, indentLevel); + }; + } + _logLine(str, indentLevel) { + const indentation = ' '.repeat(indentLevel || 0); + this.log(indentation + (str || '')); + } +} +exports.default = VerboseReporter; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/formatTestPath.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/formatTestPath.js new file mode 100644 index 0000000000000000000000000000000000000000..a7b53dea761f26e4bc609cc904ab26f7cbb6bbcb --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/formatTestPath.js @@ -0,0 +1,84 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = formatTestPath; +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _slash() { + const data = _interopRequireDefault(require('slash')); + _slash = function () { + return data; + }; + return data; +} +var _relativePath = _interopRequireDefault(require('./relativePath')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function formatTestPath(config, testPath) { + const {dirname, basename} = (0, _relativePath.default)(config, testPath); + return (0, _slash().default)( + _chalk().default.dim(dirname + path().sep) + _chalk().default.bold(basename) + ); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/generateEmptyCoverage.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/generateEmptyCoverage.js new file mode 100644 index 0000000000000000000000000000000000000000..32d6a9e4acaa1114f0e8db761abc0e571e44676b --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/generateEmptyCoverage.js @@ -0,0 +1,151 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = generateEmptyCoverage; +function fs() { + const data = _interopRequireWildcard(require('graceful-fs')); + fs = function () { + return data; + }; + return data; +} +function _istanbulLibCoverage() { + const data = require('istanbul-lib-coverage'); + _istanbulLibCoverage = function () { + return data; + }; + return data; +} +function _istanbulLibInstrument() { + const data = require('istanbul-lib-instrument'); + _istanbulLibInstrument = function () { + return data; + }; + return data; +} +function _transform() { + const data = require('@jest/transform'); + _transform = function () { + return data; + }; + return data; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +async function generateEmptyCoverage( + source, + filename, + globalConfig, + config, + changedFiles, + sourcesRelatedToTestsInChangedFiles +) { + const coverageOptions = { + changedFiles, + collectCoverage: globalConfig.collectCoverage, + collectCoverageFrom: globalConfig.collectCoverageFrom, + coverageProvider: globalConfig.coverageProvider, + sourcesRelatedToTestsInChangedFiles + }; + let coverageWorkerResult = null; + if ((0, _transform().shouldInstrument)(filename, coverageOptions, config)) { + if (coverageOptions.coverageProvider === 'v8') { + const stat = fs().statSync(filename); + return { + kind: 'V8Coverage', + result: { + functions: [ + { + functionName: '(empty-report)', + isBlockCoverage: true, + ranges: [ + { + count: 0, + endOffset: stat.size, + startOffset: 0 + } + ] + } + ], + scriptId: '0', + url: filename + } + }; + } + const scriptTransformer = await (0, _transform().createScriptTransformer)( + config + ); + + // Transform file with instrumentation to make sure initial coverage data is well mapped to original code. + const {code} = await scriptTransformer.transformSourceAsync( + filename, + source, + { + instrument: true, + supportsDynamicImport: true, + supportsExportNamespaceFrom: true, + supportsStaticESM: true, + supportsTopLevelAwait: true + } + ); + // TODO: consider passing AST + const extracted = (0, _istanbulLibInstrument().readInitialCoverage)(code); + // Check extracted initial coverage is not null, this can happen when using /* istanbul ignore file */ + if (extracted) { + coverageWorkerResult = { + coverage: (0, _istanbulLibCoverage().createFileCoverage)( + extracted.coverageData + ), + kind: 'BabelCoverage' + }; + } + } + return coverageWorkerResult; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/getResultHeader.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/getResultHeader.js new file mode 100644 index 0000000000000000000000000000000000000000..4cb4d445df70c6b4ee5da1f166a8bbee58af72fd --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/getResultHeader.js @@ -0,0 +1,65 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getResultHeader; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +var _formatTestPath = _interopRequireDefault(require('./formatTestPath')); +var _printDisplayName = _interopRequireDefault(require('./printDisplayName')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const LONG_TEST_COLOR = _chalk().default.reset.bold.bgRed; +// Explicitly reset for these messages since they can get written out in the +// middle of error logging +const FAIL_TEXT = 'FAIL'; +const PASS_TEXT = 'PASS'; +const FAIL = _chalk().default.supportsColor + ? _chalk().default.reset.inverse.bold.red(` ${FAIL_TEXT} `) + : FAIL_TEXT; +const PASS = _chalk().default.supportsColor + ? _chalk().default.reset.inverse.bold.green(` ${PASS_TEXT} `) + : PASS_TEXT; +function getResultHeader(result, globalConfig, projectConfig) { + const testPath = result.testFilePath; + const status = + result.numFailingTests > 0 || result.testExecError ? FAIL : PASS; + const testDetail = []; + if (result.perfStats?.slow) { + const runTime = result.perfStats.runtime / 1000; + testDetail.push(LONG_TEST_COLOR((0, _jestUtil().formatTime)(runTime, 0))); + } + if (result.memoryUsage) { + const toMB = bytes => Math.floor(bytes / 1024 / 1024); + testDetail.push(`${toMB(result.memoryUsage)} MB heap size`); + } + const projectDisplayName = + projectConfig && projectConfig.displayName + ? `${(0, _printDisplayName.default)(projectConfig)} ` + : ''; + return `${status} ${projectDisplayName}${(0, _formatTestPath.default)( + projectConfig ?? globalConfig, + testPath + )}${testDetail.length ? ` (${testDetail.join(', ')})` : ''}`; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/getSnapshotStatus.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/getSnapshotStatus.js new file mode 100644 index 0000000000000000000000000000000000000000..411f664a13309e1756e91eb259af99fdf0d6bf1b --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/getSnapshotStatus.js @@ -0,0 +1,92 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getSnapshotStatus; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const ARROW = ' \u203A '; +const DOT = ' \u2022 '; +const FAIL_COLOR = _chalk().default.bold.red; +const SNAPSHOT_ADDED = _chalk().default.bold.green; +const SNAPSHOT_UPDATED = _chalk().default.bold.green; +const SNAPSHOT_OUTDATED = _chalk().default.bold.yellow; +function getSnapshotStatus(snapshot, afterUpdate) { + const statuses = []; + if (snapshot.added) { + statuses.push( + SNAPSHOT_ADDED( + `${ + ARROW + (0, _jestUtil().pluralize)('snapshot', snapshot.added) + } written.` + ) + ); + } + if (snapshot.updated) { + statuses.push( + SNAPSHOT_UPDATED( + `${ + ARROW + (0, _jestUtil().pluralize)('snapshot', snapshot.updated) + } updated.` + ) + ); + } + if (snapshot.unmatched) { + statuses.push( + FAIL_COLOR( + `${ + ARROW + (0, _jestUtil().pluralize)('snapshot', snapshot.unmatched) + } failed.` + ) + ); + } + if (snapshot.unchecked) { + if (afterUpdate) { + statuses.push( + SNAPSHOT_UPDATED( + `${ + ARROW + (0, _jestUtil().pluralize)('snapshot', snapshot.unchecked) + } removed.` + ) + ); + } else { + statuses.push( + `${SNAPSHOT_OUTDATED( + `${ + ARROW + (0, _jestUtil().pluralize)('snapshot', snapshot.unchecked) + } obsolete` + )}.` + ); + } + snapshot.uncheckedKeys.forEach(key => { + statuses.push(` ${DOT}${key}`); + }); + } + if (snapshot.fileDeleted) { + statuses.push(SNAPSHOT_UPDATED(`${ARROW}snapshot file removed.`)); + } + return statuses; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/getSnapshotSummary.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/getSnapshotSummary.js new file mode 100644 index 0000000000000000000000000000000000000000..5d665056b7e1451b5cd26f989c5e3d82f5c21248 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/getSnapshotSummary.js @@ -0,0 +1,169 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getSnapshotSummary; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +var _formatTestPath = _interopRequireDefault(require('./formatTestPath')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const ARROW = ' \u203A '; +const DOWN_ARROW = ' \u21B3 '; +const DOT = ' \u2022 '; +const FAIL_COLOR = _chalk().default.bold.red; +const OBSOLETE_COLOR = _chalk().default.bold.yellow; +const SNAPSHOT_ADDED = _chalk().default.bold.green; +const SNAPSHOT_NOTE = _chalk().default.dim; +const SNAPSHOT_REMOVED = _chalk().default.bold.green; +const SNAPSHOT_SUMMARY = _chalk().default.bold; +const SNAPSHOT_UPDATED = _chalk().default.bold.green; +function getSnapshotSummary(snapshots, globalConfig, updateCommand) { + const summary = []; + summary.push(SNAPSHOT_SUMMARY('Snapshot Summary')); + if (snapshots.added) { + summary.push( + `${SNAPSHOT_ADDED( + `${ + ARROW + (0, _jestUtil().pluralize)('snapshot', snapshots.added) + } written ` + )}from ${(0, _jestUtil().pluralize)('test suite', snapshots.filesAdded)}.` + ); + } + if (snapshots.unmatched) { + summary.push( + `${FAIL_COLOR( + `${ARROW}${(0, _jestUtil().pluralize)( + 'snapshot', + snapshots.unmatched + )} failed` + )} from ${(0, _jestUtil().pluralize)( + 'test suite', + snapshots.filesUnmatched + )}. ${SNAPSHOT_NOTE( + `Inspect your code changes or ${updateCommand} to update them.` + )}` + ); + } + if (snapshots.updated) { + summary.push( + `${SNAPSHOT_UPDATED( + `${ + ARROW + (0, _jestUtil().pluralize)('snapshot', snapshots.updated) + } updated ` + )}from ${(0, _jestUtil().pluralize)( + 'test suite', + snapshots.filesUpdated + )}.` + ); + } + if (snapshots.filesRemoved) { + if (snapshots.didUpdate) { + summary.push( + `${SNAPSHOT_REMOVED( + `${ARROW}${(0, _jestUtil().pluralize)( + 'snapshot file', + snapshots.filesRemoved + )} removed ` + )}from ${(0, _jestUtil().pluralize)( + 'test suite', + snapshots.filesRemoved + )}.` + ); + } else { + summary.push( + `${OBSOLETE_COLOR( + `${ARROW}${(0, _jestUtil().pluralize)( + 'snapshot file', + snapshots.filesRemoved + )} obsolete ` + )}from ${(0, _jestUtil().pluralize)( + 'test suite', + snapshots.filesRemoved + )}. ${SNAPSHOT_NOTE( + `To remove ${ + snapshots.filesRemoved === 1 ? 'it' : 'them all' + }, ${updateCommand}.` + )}` + ); + } + } + if (snapshots.filesRemovedList && snapshots.filesRemovedList.length) { + const [head, ...tail] = snapshots.filesRemovedList; + summary.push( + ` ${DOWN_ARROW} ${DOT}${(0, _formatTestPath.default)( + globalConfig, + head + )}` + ); + tail.forEach(key => { + summary.push( + ` ${DOT}${(0, _formatTestPath.default)(globalConfig, key)}` + ); + }); + } + if (snapshots.unchecked) { + if (snapshots.didUpdate) { + summary.push( + `${SNAPSHOT_REMOVED( + `${ARROW}${(0, _jestUtil().pluralize)( + 'snapshot', + snapshots.unchecked + )} removed ` + )}from ${(0, _jestUtil().pluralize)( + 'test suite', + snapshots.uncheckedKeysByFile.length + )}.` + ); + } else { + summary.push( + `${OBSOLETE_COLOR( + `${ARROW}${(0, _jestUtil().pluralize)( + 'snapshot', + snapshots.unchecked + )} obsolete ` + )}from ${(0, _jestUtil().pluralize)( + 'test suite', + snapshots.uncheckedKeysByFile.length + )}. ${SNAPSHOT_NOTE( + `To remove ${ + snapshots.unchecked === 1 ? 'it' : 'them all' + }, ${updateCommand}.` + )}` + ); + } + snapshots.uncheckedKeysByFile.forEach(uncheckedFile => { + summary.push( + ` ${DOWN_ARROW}${(0, _formatTestPath.default)( + globalConfig, + uncheckedFile.filePath + )}` + ); + uncheckedFile.keys.forEach(key => { + summary.push(` ${DOT}${key}`); + }); + }); + } + return summary; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/getSummary.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/getSummary.js new file mode 100644 index 0000000000000000000000000000000000000000..aae461ed5808e78c36a2fa0eeb2af185542b5027 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/getSummary.js @@ -0,0 +1,206 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.PROGRESS_BAR_WIDTH = void 0; +exports.default = getSummary; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const PROGRESS_BAR_WIDTH = 40; +exports.PROGRESS_BAR_WIDTH = PROGRESS_BAR_WIDTH; +function getValuesCurrentTestCases(currentTestCases = []) { + let numFailingTests = 0; + let numPassingTests = 0; + let numPendingTests = 0; + let numTodoTests = 0; + let numTotalTests = 0; + currentTestCases.forEach(testCase => { + switch (testCase.testCaseResult.status) { + case 'failed': { + numFailingTests++; + break; + } + case 'passed': { + numPassingTests++; + break; + } + case 'skipped': { + numPendingTests++; + break; + } + case 'todo': { + numTodoTests++; + break; + } + } + numTotalTests++; + }); + return { + numFailingTests, + numPassingTests, + numPendingTests, + numTodoTests, + numTotalTests + }; +} +function renderTime(runTime, estimatedTime, width) { + // If we are more than one second over the estimated time, highlight it. + const renderedTime = + estimatedTime && runTime >= estimatedTime + 1 + ? _chalk().default.bold.yellow((0, _jestUtil().formatTime)(runTime, 0)) + : (0, _jestUtil().formatTime)(runTime, 0); + let time = `${_chalk().default.bold('Time:')} ${renderedTime}`; + if (runTime < estimatedTime) { + time += `, estimated ${(0, _jestUtil().formatTime)(estimatedTime, 0)}`; + } + + // Only show a progress bar if the test run is actually going to take + // some time. + if (estimatedTime > 2 && runTime < estimatedTime && width) { + const availableWidth = Math.min(PROGRESS_BAR_WIDTH, width); + const length = Math.min( + Math.floor((runTime / estimatedTime) * availableWidth), + availableWidth + ); + if (availableWidth >= 2) { + time += `\n${_chalk().default.green('█').repeat(length)}${_chalk() + .default.white('█') + .repeat(availableWidth - length)}`; + } + } + return time; +} +function getSummary(aggregatedResults, options) { + let runTime = (Date.now() - aggregatedResults.startTime) / 1000; + if (options && options.roundTime) { + runTime = Math.floor(runTime); + } + const valuesForCurrentTestCases = getValuesCurrentTestCases( + options?.currentTestCases + ); + const estimatedTime = (options && options.estimatedTime) || 0; + const snapshotResults = aggregatedResults.snapshot; + const snapshotsAdded = snapshotResults.added; + const snapshotsFailed = snapshotResults.unmatched; + const snapshotsOutdated = snapshotResults.unchecked; + const snapshotsFilesRemoved = snapshotResults.filesRemoved; + const snapshotsDidUpdate = snapshotResults.didUpdate; + const snapshotsPassed = snapshotResults.matched; + const snapshotsTotal = snapshotResults.total; + const snapshotsUpdated = snapshotResults.updated; + const suitesFailed = aggregatedResults.numFailedTestSuites; + const suitesPassed = aggregatedResults.numPassedTestSuites; + const suitesPending = aggregatedResults.numPendingTestSuites; + const suitesRun = suitesFailed + suitesPassed; + const suitesTotal = aggregatedResults.numTotalTestSuites; + const testsFailed = aggregatedResults.numFailedTests; + const testsPassed = aggregatedResults.numPassedTests; + const testsPending = aggregatedResults.numPendingTests; + const testsTodo = aggregatedResults.numTodoTests; + const testsTotal = aggregatedResults.numTotalTests; + const width = (options && options.width) || 0; + const optionalLines = []; + if (options?.showSeed === true) { + const {seed} = options; + if (seed === undefined) { + throw new Error('Attempted to display seed but seed value is undefined'); + } + optionalLines.push(`${_chalk().default.bold('Seed: ') + seed}`); + } + const suites = `${ + _chalk().default.bold('Test Suites: ') + + (suitesFailed + ? `${_chalk().default.bold.red(`${suitesFailed} failed`)}, ` + : '') + + (suitesPending + ? `${_chalk().default.bold.yellow(`${suitesPending} skipped`)}, ` + : '') + + (suitesPassed + ? `${_chalk().default.bold.green(`${suitesPassed} passed`)}, ` + : '') + + (suitesRun !== suitesTotal ? `${suitesRun} of ${suitesTotal}` : suitesTotal) + } total`; + const updatedTestsFailed = + testsFailed + valuesForCurrentTestCases.numFailingTests; + const updatedTestsPending = + testsPending + valuesForCurrentTestCases.numPendingTests; + const updatedTestsTodo = testsTodo + valuesForCurrentTestCases.numTodoTests; + const updatedTestsPassed = + testsPassed + valuesForCurrentTestCases.numPassingTests; + const updatedTestsTotal = + testsTotal + valuesForCurrentTestCases.numTotalTests; + const tests = `${ + _chalk().default.bold('Tests: ') + + (updatedTestsFailed > 0 + ? `${_chalk().default.bold.red(`${updatedTestsFailed} failed`)}, ` + : '') + + (updatedTestsPending > 0 + ? `${_chalk().default.bold.yellow(`${updatedTestsPending} skipped`)}, ` + : '') + + (updatedTestsTodo > 0 + ? `${_chalk().default.bold.magenta(`${updatedTestsTodo} todo`)}, ` + : '') + + (updatedTestsPassed > 0 + ? `${_chalk().default.bold.green(`${updatedTestsPassed} passed`)}, ` + : '') + }${updatedTestsTotal} total`; + const snapshots = `${ + _chalk().default.bold('Snapshots: ') + + (snapshotsFailed + ? `${_chalk().default.bold.red(`${snapshotsFailed} failed`)}, ` + : '') + + (snapshotsOutdated && !snapshotsDidUpdate + ? `${_chalk().default.bold.yellow(`${snapshotsOutdated} obsolete`)}, ` + : '') + + (snapshotsOutdated && snapshotsDidUpdate + ? `${_chalk().default.bold.green(`${snapshotsOutdated} removed`)}, ` + : '') + + (snapshotsFilesRemoved && !snapshotsDidUpdate + ? `${_chalk().default.bold.yellow( + `${(0, _jestUtil().pluralize)( + 'file', + snapshotsFilesRemoved + )} obsolete` + )}, ` + : '') + + (snapshotsFilesRemoved && snapshotsDidUpdate + ? `${_chalk().default.bold.green( + `${(0, _jestUtil().pluralize)('file', snapshotsFilesRemoved)} removed` + )}, ` + : '') + + (snapshotsUpdated + ? `${_chalk().default.bold.green(`${snapshotsUpdated} updated`)}, ` + : '') + + (snapshotsAdded + ? `${_chalk().default.bold.green(`${snapshotsAdded} written`)}, ` + : '') + + (snapshotsPassed + ? `${_chalk().default.bold.green(`${snapshotsPassed} passed`)}, ` + : '') + }${snapshotsTotal} total`; + const time = renderTime(runTime, estimatedTime, width); + return [...optionalLines, suites, tests, snapshots, time].join('\n'); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/getWatermarks.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/getWatermarks.js new file mode 100644 index 0000000000000000000000000000000000000000..2d8cdd79b05dc92cb8f58286373e5589ea3558f8 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/getWatermarks.js @@ -0,0 +1,38 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getWatermarks; +function _istanbulLibReport() { + const data = _interopRequireDefault(require('istanbul-lib-report')); + _istanbulLibReport = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function getWatermarks(config) { + const defaultWatermarks = _istanbulLibReport().default.getDefaultWatermarks(); + const {coverageThreshold} = config; + if (!coverageThreshold || !coverageThreshold.global) { + return defaultWatermarks; + } + const keys = ['branches', 'functions', 'lines', 'statements']; + return keys.reduce((watermarks, key) => { + const value = coverageThreshold.global[key]; + if (value !== undefined) { + watermarks[key][1] = value; + } + return watermarks; + }, defaultWatermarks); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e78fb54b6fe23d5a5e00afe3806e3549dac829c3 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/index.d.ts @@ -0,0 +1,325 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/// + +import {AggregatedResult} from '@jest/test-result'; +import type {AssertionResult} from '@jest/test-result'; +import type {Circus} from '@jest/types'; +import {Config} from '@jest/types'; +import {SnapshotSummary} from '@jest/test-result'; +import type {Suite} from '@jest/test-result'; +import {Test} from '@jest/test-result'; +import {TestCaseResult} from '@jest/test-result'; +import {TestContext} from '@jest/test-result'; +import {TestResult} from '@jest/test-result'; + +export {AggregatedResult}; + +export declare class BaseReporter implements Reporter { + private _error?; + log(message: string): void; + onRunStart( + _results?: AggregatedResult, + _options?: ReporterOnStartOptions, + ): void; + onTestCaseResult(_test: Test, _testCaseResult: TestCaseResult): void; + onTestResult( + _test?: Test, + _testResult?: TestResult, + _results?: AggregatedResult, + ): void; + onTestStart(_test?: Test): void; + onRunComplete( + _testContexts?: Set, + _aggregatedResults?: AggregatedResult, + ): Promise | void; + protected _setError(error: Error): void; + getLastError(): Error | undefined; +} + +export {Config}; + +export declare class CoverageReporter extends BaseReporter { + private readonly _context; + private readonly _coverageMap; + private readonly _globalConfig; + private readonly _sourceMapStore; + private readonly _v8CoverageResults; + static readonly filename: string; + constructor(globalConfig: Config.GlobalConfig, context: ReporterContext); + onTestResult(_test: Test, testResult: TestResult): void; + onRunComplete( + testContexts: Set, + aggregatedResults: AggregatedResult, + ): Promise; + private _addUntestedFiles; + private _checkThreshold; + private _getCoverageResult; +} + +export declare class DefaultReporter extends BaseReporter { + private _clear; + private readonly _err; + protected _globalConfig: Config.GlobalConfig; + private readonly _out; + private readonly _status; + private readonly _bufferedOutput; + static readonly filename: string; + constructor(globalConfig: Config.GlobalConfig); + protected __wrapStdio( + stream: NodeJS.WritableStream | NodeJS.WriteStream, + ): void; + forceFlushBufferedOutput(): void; + protected __clearStatus(): void; + protected __printStatus(): void; + onRunStart( + aggregatedResults: AggregatedResult, + options: ReporterOnStartOptions, + ): void; + onTestStart(test: Test): void; + onTestCaseResult(test: Test, testCaseResult: TestCaseResult): void; + onRunComplete(): void; + onTestResult( + test: Test, + testResult: TestResult, + aggregatedResults: AggregatedResult, + ): void; + testFinished( + config: Config.ProjectConfig, + testResult: TestResult, + aggregatedResults: AggregatedResult, + ): void; + printTestFileHeader( + testPath: string, + config: Config.ProjectConfig, + result: TestResult, + ): void; + printTestFileFailureMessage( + _testPath: string, + _config: Config.ProjectConfig, + result: TestResult, + ): void; +} + +declare function formatTestPath( + config: Config.GlobalConfig | Config.ProjectConfig, + testPath: string, +): string; + +declare function getResultHeader( + result: TestResult, + globalConfig: Config.GlobalConfig, + projectConfig?: Config.ProjectConfig, +): string; + +declare function getSnapshotStatus( + snapshot: TestResult['snapshot'], + afterUpdate: boolean, +): Array; + +declare function getSnapshotSummary( + snapshots: SnapshotSummary, + globalConfig: Config.GlobalConfig, + updateCommand: string, +): Array; + +declare function getSummary( + aggregatedResults: AggregatedResult, + options?: SummaryOptions, +): string; + +export declare class GitHubActionsReporter extends BaseReporter { + #private; + static readonly filename: string; + private readonly options; + constructor( + _globalConfig: Config.GlobalConfig, + reporterOptions?: { + silent?: boolean; + }, + ); + onTestResult( + test: Test, + testResult: TestResult, + aggregatedResults: AggregatedResult, + ): void; + private generateAnnotations; + private isLastTestSuite; + private printFullResult; + private arrayEqual; + private arrayChild; + private getResultTree; + private getResultChildren; + private printResultTree; + private recursivePrintResultTree; + private printFailedTestLogs; + private startGroup; + private endGroup; +} + +export declare class NotifyReporter extends BaseReporter { + private readonly _notifier; + private readonly _globalConfig; + private _context; + static readonly filename: string; + constructor(globalConfig: Config.GlobalConfig, context: ReporterContext); + onRunComplete(testContexts: Set, result: AggregatedResult): void; +} + +declare function printDisplayName(config: Config.ProjectConfig): string; + +declare function relativePath( + config: Config.GlobalConfig | Config.ProjectConfig, + testPath: string, +): { + basename: string; + dirname: string; +}; + +export declare interface Reporter { + readonly onTestResult?: ( + test: Test, + testResult: TestResult, + aggregatedResult: AggregatedResult, + ) => Promise | void; + readonly onTestFileResult?: ( + test: Test, + testResult: TestResult, + aggregatedResult: AggregatedResult, + ) => Promise | void; + /** + * Called before running a spec (prior to `before` hooks) + * Not called for `skipped` and `todo` specs + */ + readonly onTestCaseStart?: ( + test: Test, + testCaseStartInfo: Circus.TestCaseStartInfo, + ) => Promise | void; + readonly onTestCaseResult?: ( + test: Test, + testCaseResult: TestCaseResult, + ) => Promise | void; + readonly onRunStart?: ( + results: AggregatedResult, + options: ReporterOnStartOptions, + ) => Promise | void; + readonly onTestStart?: (test: Test) => Promise | void; + readonly onTestFileStart?: (test: Test) => Promise | void; + readonly onRunComplete?: ( + testContexts: Set, + results: AggregatedResult, + ) => Promise | void; + readonly getLastError?: () => Error | void; +} + +export declare type ReporterContext = { + firstRun: boolean; + previousSuccess: boolean; + changedFiles?: Set; + sourcesRelatedToTestsInChangedFiles?: Set; + startRun?: (globalConfig: Config.GlobalConfig) => unknown; +}; + +export declare type ReporterOnStartOptions = { + estimatedTime: number; + showStatus: boolean; +}; + +export {SnapshotSummary}; + +export declare type SummaryOptions = { + currentTestCases?: Array<{ + test: Test; + testCaseResult: TestCaseResult; + }>; + estimatedTime?: number; + roundTime?: boolean; + width?: number; + showSeed?: boolean; + seed?: number; +}; + +export declare class SummaryReporter extends BaseReporter { + private _estimatedTime; + private readonly _globalConfig; + private readonly _summaryThreshold; + static readonly filename: string; + constructor( + globalConfig: Config.GlobalConfig, + options?: SummaryReporterOptions, + ); + private _validateOptions; + private _write; + onRunStart( + aggregatedResults: AggregatedResult, + options: ReporterOnStartOptions, + ): void; + onRunComplete( + testContexts: Set, + aggregatedResults: AggregatedResult, + ): void; + private _printSnapshotSummary; + private _printSummary; + private _getTestSummary; +} + +export declare type SummaryReporterOptions = { + summaryThreshold?: number; +}; + +export {Test}; + +export {TestCaseResult}; + +export {TestContext}; + +export {TestResult}; + +declare function trimAndFormatPath( + pad: number, + config: Config.ProjectConfig | Config.GlobalConfig, + testPath: string, + columns: number, +): string; + +export declare const utils: { + formatTestPath: typeof formatTestPath; + getResultHeader: typeof getResultHeader; + getSnapshotStatus: typeof getSnapshotStatus; + getSnapshotSummary: typeof getSnapshotSummary; + getSummary: typeof getSummary; + printDisplayName: typeof printDisplayName; + relativePath: typeof relativePath; + trimAndFormatPath: typeof trimAndFormatPath; +}; + +export declare class VerboseReporter extends DefaultReporter { + protected _globalConfig: Config.GlobalConfig; + static readonly filename: string; + constructor(globalConfig: Config.GlobalConfig); + protected __wrapStdio( + stream: NodeJS.WritableStream | NodeJS.WriteStream, + ): void; + static filterTestResults( + testResults: Array, + ): Array; + static groupTestsBySuites(testResults: Array): Suite; + onTestResult( + test: Test, + result: TestResult, + aggregatedResults: AggregatedResult, + ): void; + private _logTestResults; + private _logSuite; + private _getIcon; + private _logTest; + private _logTests; + private _logTodoOrPendingTest; + private _logLine; +} + +export {}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..8da383a70c041bee07f7cf859e6ad4fb3a5a56e6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/index.js @@ -0,0 +1,88 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +Object.defineProperty(exports, 'BaseReporter', { + enumerable: true, + get: function () { + return _BaseReporter.default; + } +}); +Object.defineProperty(exports, 'CoverageReporter', { + enumerable: true, + get: function () { + return _CoverageReporter.default; + } +}); +Object.defineProperty(exports, 'DefaultReporter', { + enumerable: true, + get: function () { + return _DefaultReporter.default; + } +}); +Object.defineProperty(exports, 'GitHubActionsReporter', { + enumerable: true, + get: function () { + return _GitHubActionsReporter.default; + } +}); +Object.defineProperty(exports, 'NotifyReporter', { + enumerable: true, + get: function () { + return _NotifyReporter.default; + } +}); +Object.defineProperty(exports, 'SummaryReporter', { + enumerable: true, + get: function () { + return _SummaryReporter.default; + } +}); +Object.defineProperty(exports, 'VerboseReporter', { + enumerable: true, + get: function () { + return _VerboseReporter.default; + } +}); +exports.utils = void 0; +var _formatTestPath = _interopRequireDefault(require('./formatTestPath')); +var _getResultHeader = _interopRequireDefault(require('./getResultHeader')); +var _getSnapshotStatus = _interopRequireDefault(require('./getSnapshotStatus')); +var _getSnapshotSummary = _interopRequireDefault( + require('./getSnapshotSummary') +); +var _getSummary = _interopRequireDefault(require('./getSummary')); +var _printDisplayName = _interopRequireDefault(require('./printDisplayName')); +var _relativePath = _interopRequireDefault(require('./relativePath')); +var _trimAndFormatPath = _interopRequireDefault(require('./trimAndFormatPath')); +var _BaseReporter = _interopRequireDefault(require('./BaseReporter')); +var _CoverageReporter = _interopRequireDefault(require('./CoverageReporter')); +var _DefaultReporter = _interopRequireDefault(require('./DefaultReporter')); +var _GitHubActionsReporter = _interopRequireDefault( + require('./GitHubActionsReporter') +); +var _NotifyReporter = _interopRequireDefault(require('./NotifyReporter')); +var _SummaryReporter = _interopRequireDefault(require('./SummaryReporter')); +var _VerboseReporter = _interopRequireDefault(require('./VerboseReporter')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const utils = { + formatTestPath: _formatTestPath.default, + getResultHeader: _getResultHeader.default, + getSnapshotStatus: _getSnapshotStatus.default, + getSnapshotSummary: _getSnapshotSummary.default, + getSummary: _getSummary.default, + printDisplayName: _printDisplayName.default, + relativePath: _relativePath.default, + trimAndFormatPath: _trimAndFormatPath.default +}; +exports.utils = utils; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/printDisplayName.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/printDisplayName.js new file mode 100644 index 0000000000000000000000000000000000000000..148cc0c0b4ce4d82e50dabb81bd15d74358db4b8 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/printDisplayName.js @@ -0,0 +1,35 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = printDisplayName; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function printDisplayName(config) { + const {displayName} = config; + const white = _chalk().default.reset.inverse.white; + if (!displayName) { + return ''; + } + const {name, color} = displayName; + const chosenColor = _chalk().default.reset.inverse[color] + ? _chalk().default.reset.inverse[color] + : white; + return _chalk().default.supportsColor ? chosenColor(` ${name} `) : name; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/relativePath.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/relativePath.js new file mode 100644 index 0000000000000000000000000000000000000000..38c1b3812d84960ac2b406f440b8966cc44d28f1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/relativePath.js @@ -0,0 +1,72 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = relativePath; +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function relativePath(config, testPath) { + // this function can be called with ProjectConfigs or GlobalConfigs. GlobalConfigs + // do not have config.cwd, only config.rootDir. Try using config.cwd, fallback + // to config.rootDir. (Also, some unit just use config.rootDir, which is ok) + testPath = path().relative(config.cwd || config.rootDir, testPath); + const dirname = path().dirname(testPath); + const basename = path().basename(testPath); + return { + basename, + dirname + }; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/trimAndFormatPath.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/trimAndFormatPath.js new file mode 100644 index 0000000000000000000000000000000000000000..844410e81fea07dedae4640ecaad058510f961ce --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/trimAndFormatPath.js @@ -0,0 +1,118 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = trimAndFormatPath; +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _slash() { + const data = _interopRequireDefault(require('slash')); + _slash = function () { + return data; + }; + return data; +} +var _relativePath = _interopRequireDefault(require('./relativePath')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function trimAndFormatPath(pad, config, testPath, columns) { + const maxLength = columns - pad; + const relative = (0, _relativePath.default)(config, testPath); + const {basename} = relative; + let {dirname} = relative; + + // length is ok + if ((dirname + path().sep + basename).length <= maxLength) { + return (0, _slash().default)( + _chalk().default.dim(dirname + path().sep) + + _chalk().default.bold(basename) + ); + } + + // we can fit trimmed dirname and full basename + const basenameLength = basename.length; + if (basenameLength + 4 < maxLength) { + const dirnameLength = maxLength - 4 - basenameLength; + dirname = `...${dirname.slice( + dirname.length - dirnameLength, + dirname.length + )}`; + return (0, _slash().default)( + _chalk().default.dim(dirname + path().sep) + + _chalk().default.bold(basename) + ); + } + if (basenameLength + 4 === maxLength) { + return (0, _slash().default)( + _chalk().default.dim(`...${path().sep}`) + _chalk().default.bold(basename) + ); + } + + // can't fit dirname, but can fit trimmed basename + return (0, _slash().default)( + _chalk().default.bold( + `...${basename.slice(basename.length - maxLength - 4, basename.length)}` + ) + ); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/types.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/types.js new file mode 100644 index 0000000000000000000000000000000000000000..ad9a93a7c160f02945911772460eb8a1bcb003db --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/types.js @@ -0,0 +1 @@ +'use strict'; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/wrapAnsiString.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/wrapAnsiString.js new file mode 100644 index 0000000000000000000000000000000000000000..85f3cdf898ff3e1a1474892a0d3d04e7a816e69a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/build/wrapAnsiString.js @@ -0,0 +1,69 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = wrapAnsiString; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// word-wrap a string that contains ANSI escape sequences. +// ANSI escape sequences do not add to the string length. +function wrapAnsiString(string, terminalWidth) { + if (terminalWidth === 0) { + // if the terminal width is zero, don't bother word-wrapping + return string; + } + const ANSI_REGEXP = /[\u001b\u009b]\[\d{1,2}m/gu; + const tokens = []; + let lastIndex = 0; + let match; + while ((match = ANSI_REGEXP.exec(string))) { + const ansi = match[0]; + const index = match.index; + if (index != lastIndex) { + tokens.push(['string', string.slice(lastIndex, index)]); + } + tokens.push(['ansi', ansi]); + lastIndex = index + ansi.length; + } + if (lastIndex != string.length - 1) { + tokens.push(['string', string.slice(lastIndex, string.length)]); + } + let lastLineLength = 0; + return tokens + .reduce( + (lines, [kind, token]) => { + if (kind === 'string') { + if (lastLineLength + token.length > terminalWidth) { + while (token.length) { + const chunk = token.slice(0, terminalWidth - lastLineLength); + const remaining = token.slice( + terminalWidth - lastLineLength, + token.length + ); + lines[lines.length - 1] += chunk; + lastLineLength += chunk.length; + token = remaining; + if (token.length) { + lines.push(''); + lastLineLength = 0; + } + } + } else { + lines[lines.length - 1] += token; + lastLineLength += token.length; + } + } else { + lines[lines.length - 1] += token; + } + return lines; + }, + [''] + ) + .join('\n'); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/.bin/semver b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/.bin/semver new file mode 100644 index 0000000000000000000000000000000000000000..16e6872b5778b5c43af2cefec45471c090be89b9 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/.bin/semver @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a3ed56435cbd4b3f07a80c4a343edd86d787f89bf2cee0105bdf68cb653ba2a0 +size 4717 diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/build/ScriptTransformer.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/build/ScriptTransformer.js new file mode 100644 index 0000000000000000000000000000000000000000..0fe4bdac076757cc9666446a5b543ce0d16bc179 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/build/ScriptTransformer.js @@ -0,0 +1,1000 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.createScriptTransformer = createScriptTransformer; +exports.createTranspilingRequire = createTranspilingRequire; +function _crypto() { + const data = require('crypto'); + _crypto = function () { + return data; + }; + return data; +} +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _core() { + const data = require('@babel/core'); + _core = function () { + return data; + }; + return data; +} +function _babelPluginIstanbul() { + const data = _interopRequireDefault(require('babel-plugin-istanbul')); + _babelPluginIstanbul = function () { + return data; + }; + return data; +} +function _convertSourceMap() { + const data = require('convert-source-map'); + _convertSourceMap = function () { + return data; + }; + return data; +} +function _fastJsonStableStringify() { + const data = _interopRequireDefault(require('fast-json-stable-stringify')); + _fastJsonStableStringify = function () { + return data; + }; + return data; +} +function fs() { + const data = _interopRequireWildcard(require('graceful-fs')); + fs = function () { + return data; + }; + return data; +} +function _pirates() { + const data = require('pirates'); + _pirates = function () { + return data; + }; + return data; +} +function _slash() { + const data = _interopRequireDefault(require('slash')); + _slash = function () { + return data; + }; + return data; +} +function _writeFileAtomic() { + const data = require('write-file-atomic'); + _writeFileAtomic = function () { + return data; + }; + return data; +} +function _jestHasteMap() { + const data = _interopRequireDefault(require('jest-haste-map')); + _jestHasteMap = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +var _enhanceUnexpectedTokenMessage = _interopRequireDefault( + require('./enhanceUnexpectedTokenMessage') +); +var _runtimeErrorsAndWarnings = require('./runtimeErrorsAndWarnings'); +var _shouldInstrument = _interopRequireDefault(require('./shouldInstrument')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// @ts-expect-error: should just be `require.resolve`, but the tests mess that up + +// Use `require` to avoid TS rootDir +const {version: VERSION} = require('../package.json'); +// This data structure is used to avoid recalculating some data every time that +// we need to transform a file. Since ScriptTransformer is instantiated for each +// file we need to keep this object in the local scope of this module. +const projectCaches = new Map(); + +// To reset the cache for specific changesets (rather than package version). +const CACHE_VERSION = '1'; +async function waitForPromiseWithCleanup(promise, cleanup) { + try { + await promise; + } finally { + cleanup(); + } +} + +// type predicate +function isTransformerFactory(t) { + return typeof t.createTransformer === 'function'; +} +class ScriptTransformer { + _cache; + _transformCache = new Map(); + _transformsAreLoaded = false; + constructor(_config, _cacheFS) { + this._config = _config; + this._cacheFS = _cacheFS; + const configString = (0, _fastJsonStableStringify().default)(this._config); + let projectCache = projectCaches.get(configString); + if (!projectCache) { + projectCache = { + configString, + ignorePatternsRegExp: calcIgnorePatternRegExp(this._config), + transformRegExp: calcTransformRegExp(this._config), + transformedFiles: new Map() + }; + projectCaches.set(configString, projectCache); + } + this._cache = projectCache; + } + _buildCacheKeyFromFileInfo( + fileData, + filename, + transformOptions, + transformerCacheKey + ) { + if (transformerCacheKey != null) { + return (0, _crypto().createHash)('sha1') + .update(transformerCacheKey) + .update(CACHE_VERSION) + .digest('hex') + .substring(0, 32); + } + return (0, _crypto().createHash)('sha1') + .update(fileData) + .update(transformOptions.configString) + .update(transformOptions.instrument ? 'instrument' : '') + .update(filename) + .update(CACHE_VERSION) + .digest('hex') + .substring(0, 32); + } + _buildTransformCacheKey(pattern, filepath) { + return pattern + filepath; + } + _getCacheKey(fileData, filename, options) { + const configString = this._cache.configString; + const {transformer, transformerConfig = {}} = + this._getTransformer(filename) ?? {}; + let transformerCacheKey = undefined; + const transformOptions = { + ...options, + cacheFS: this._cacheFS, + config: this._config, + configString, + transformerConfig + }; + if (typeof transformer?.getCacheKey === 'function') { + transformerCacheKey = transformer.getCacheKey( + fileData, + filename, + transformOptions + ); + } + return this._buildCacheKeyFromFileInfo( + fileData, + filename, + transformOptions, + transformerCacheKey + ); + } + async _getCacheKeyAsync(fileData, filename, options) { + const configString = this._cache.configString; + const {transformer, transformerConfig = {}} = + this._getTransformer(filename) ?? {}; + let transformerCacheKey = undefined; + const transformOptions = { + ...options, + cacheFS: this._cacheFS, + config: this._config, + configString, + transformerConfig + }; + if (transformer) { + const getCacheKey = + transformer.getCacheKeyAsync ?? transformer.getCacheKey; + if (typeof getCacheKey === 'function') { + transformerCacheKey = await getCacheKey( + fileData, + filename, + transformOptions + ); + } + } + return this._buildCacheKeyFromFileInfo( + fileData, + filename, + transformOptions, + transformerCacheKey + ); + } + _createCachedFilename(filename, cacheKey) { + const HasteMapClass = _jestHasteMap().default.getStatic(this._config); + const baseCacheDir = HasteMapClass.getCacheFilePath( + this._config.cacheDirectory, + `jest-transform-cache-${this._config.id}`, + VERSION + ); + // Create sub folders based on the cacheKey to avoid creating one + // directory with many files. + const cacheDir = path().join(baseCacheDir, cacheKey[0] + cacheKey[1]); + const cacheFilenamePrefix = path() + .basename(filename, path().extname(filename)) + .replace(/\W/g, ''); + return (0, _slash().default)( + path().join(cacheDir, `${cacheFilenamePrefix}_${cacheKey}`) + ); + } + _getFileCachePath(filename, content, options) { + const cacheKey = this._getCacheKey(content, filename, options); + return this._createCachedFilename(filename, cacheKey); + } + async _getFileCachePathAsync(filename, content, options) { + const cacheKey = await this._getCacheKeyAsync(content, filename, options); + return this._createCachedFilename(filename, cacheKey); + } + _getTransformPatternAndPath(filename) { + const transformEntry = this._cache.transformRegExp; + if (transformEntry == null) { + return undefined; + } + for (let i = 0; i < transformEntry.length; i++) { + const [transformRegExp, transformPath] = transformEntry[i]; + if (transformRegExp.test(filename)) { + return [transformRegExp.source, transformPath]; + } + } + return undefined; + } + _getTransformPath(filename) { + const transformInfo = this._getTransformPatternAndPath(filename); + if (!Array.isArray(transformInfo)) { + return undefined; + } + return transformInfo[1]; + } + async loadTransformers() { + await Promise.all( + this._config.transform.map( + async ([transformPattern, transformPath, transformerConfig], i) => { + let transformer = await (0, _jestUtil().requireOrImportModule)( + transformPath + ); + if (transformer == null) { + throw new Error( + (0, _runtimeErrorsAndWarnings.makeInvalidTransformerError)( + transformPath + ) + ); + } + if (isTransformerFactory(transformer)) { + transformer = await transformer.createTransformer( + transformerConfig + ); + } + if ( + typeof transformer.process !== 'function' && + typeof transformer.processAsync !== 'function' + ) { + throw new Error( + (0, _runtimeErrorsAndWarnings.makeInvalidTransformerError)( + transformPath + ) + ); + } + const res = { + transformer, + transformerConfig + }; + const transformCacheKey = this._buildTransformCacheKey( + this._cache.transformRegExp?.[i]?.[0].source ?? + new RegExp(transformPattern).source, + transformPath + ); + this._transformCache.set(transformCacheKey, res); + } + ) + ); + this._transformsAreLoaded = true; + } + _getTransformer(filename) { + if (!this._transformsAreLoaded) { + throw new Error( + 'Jest: Transformers have not been loaded yet - make sure to run `loadTransformers` and wait for it to complete before starting to transform files' + ); + } + if (this._config.transform.length === 0) { + return null; + } + const transformPatternAndPath = this._getTransformPatternAndPath(filename); + if (!Array.isArray(transformPatternAndPath)) { + return null; + } + const [transformPattern, transformPath] = transformPatternAndPath; + const transformCacheKey = this._buildTransformCacheKey( + transformPattern, + transformPath + ); + const transformer = this._transformCache.get(transformCacheKey); + if (transformer !== undefined) { + return transformer; + } + throw new Error( + `Jest was unable to load the transformer defined for ${filename}. This is a bug in Jest, please open up an issue` + ); + } + _instrumentFile(filename, input, canMapToInput, options) { + const inputCode = typeof input === 'string' ? input : input.code; + const inputMap = typeof input === 'string' ? null : input.map; + const result = (0, _core().transformSync)(inputCode, { + auxiliaryCommentBefore: ' istanbul ignore next ', + babelrc: false, + caller: { + name: '@jest/transform', + supportsDynamicImport: options.supportsDynamicImport, + supportsExportNamespaceFrom: options.supportsExportNamespaceFrom, + supportsStaticESM: options.supportsStaticESM, + supportsTopLevelAwait: options.supportsTopLevelAwait + }, + configFile: false, + filename, + plugins: [ + [ + _babelPluginIstanbul().default, + { + compact: false, + // files outside `cwd` will not be instrumented + cwd: this._config.rootDir, + exclude: [], + extension: false, + inputSourceMap: inputMap, + useInlineSourceMaps: false + } + ] + ], + sourceMaps: canMapToInput ? 'both' : false + }); + if (result?.code != null) { + return result; + } + return input; + } + _buildTransformResult( + filename, + cacheFilePath, + content, + transformer, + shouldCallTransform, + options, + processed, + sourceMapPath + ) { + let transformed = { + code: content, + map: null + }; + if (transformer && shouldCallTransform) { + if (processed != null && typeof processed.code === 'string') { + transformed = processed; + } else { + const transformPath = this._getTransformPath(filename); + (0, _jestUtil().invariant)(transformPath); + throw new Error( + (0, _runtimeErrorsAndWarnings.makeInvalidReturnValueError)( + transformPath + ) + ); + } + } + if (transformed.map == null || transformed.map === '') { + try { + //Could be a potential freeze here. + //See: https://github.com/jestjs/jest/pull/5177#discussion_r158883570 + const inlineSourceMap = (0, _convertSourceMap().fromSource)( + transformed.code + ); + if (inlineSourceMap) { + transformed.map = inlineSourceMap.toObject(); + } + } catch { + const transformPath = this._getTransformPath(filename); + (0, _jestUtil().invariant)(transformPath); + console.warn( + (0, _runtimeErrorsAndWarnings.makeInvalidSourceMapWarning)( + filename, + transformPath + ) + ); + } + } + + // That means that the transform has a custom instrumentation + // logic and will handle it based on `config.collectCoverage` option + const transformWillInstrument = + shouldCallTransform && transformer && transformer.canInstrument; + + // Apply instrumentation to the code if necessary, keeping the instrumented code and new map + let map = transformed.map; + let code; + if (transformWillInstrument !== true && options.instrument) { + /** + * We can map the original source code to the instrumented code ONLY if + * - the process of transforming the code produced a source map e.g. ts-jest + * - we did not transform the source code + * + * Otherwise we cannot make any statements about how the instrumented code corresponds to the original code, + * and we should NOT emit any source maps + * + */ + const shouldEmitSourceMaps = + (transformer != null && map != null) || transformer == null; + const instrumented = this._instrumentFile( + filename, + transformed, + shouldEmitSourceMaps, + options + ); + code = + typeof instrumented === 'string' ? instrumented : instrumented.code; + map = typeof instrumented === 'string' ? null : instrumented.map; + } else { + code = transformed.code; + } + if (map != null) { + const sourceMapContent = + typeof map === 'string' ? map : JSON.stringify(map); + (0, _jestUtil().invariant)( + sourceMapPath, + 'We should always have default sourceMapPath' + ); + writeCacheFile(sourceMapPath, sourceMapContent); + } else { + sourceMapPath = null; + } + writeCodeCacheFile(cacheFilePath, code); + return { + code, + originalCode: content, + sourceMapPath + }; + } + transformSource(filepath, content, options) { + const filename = (0, _jestUtil().tryRealpath)(filepath); + const {transformer, transformerConfig = {}} = + this._getTransformer(filename) ?? {}; + const cacheFilePath = this._getFileCachePath(filename, content, options); + const sourceMapPath = `${cacheFilePath}.map`; + // Ignore cache if `config.cache` is set (--no-cache) + const code = this._config.cache ? readCodeCacheFile(cacheFilePath) : null; + if (code != null) { + // This is broken: we return the code, and a path for the source map + // directly from the cache. But, nothing ensures the source map actually + // matches that source code. They could have gotten out-of-sync in case + // two separate processes write concurrently to the same cache files. + return { + code, + originalCode: content, + sourceMapPath + }; + } + let processed = null; + let shouldCallTransform = false; + if (transformer && this.shouldTransform(filename)) { + shouldCallTransform = true; + assertSyncTransformer(transformer, this._getTransformPath(filename)); + processed = transformer.process(content, filename, { + ...options, + cacheFS: this._cacheFS, + config: this._config, + configString: this._cache.configString, + transformerConfig + }); + } + (0, _jestUtil().createDirectory)(path().dirname(cacheFilePath)); + return this._buildTransformResult( + filename, + cacheFilePath, + content, + transformer, + shouldCallTransform, + options, + processed, + sourceMapPath + ); + } + async transformSourceAsync(filepath, content, options) { + const filename = (0, _jestUtil().tryRealpath)(filepath); + const {transformer, transformerConfig = {}} = + this._getTransformer(filename) ?? {}; + const cacheFilePath = await this._getFileCachePathAsync( + filename, + content, + options + ); + const sourceMapPath = `${cacheFilePath}.map`; + // Ignore cache if `config.cache` is set (--no-cache) + const code = this._config.cache ? readCodeCacheFile(cacheFilePath) : null; + if (code != null) { + // This is broken: we return the code, and a path for the source map + // directly from the cache. But, nothing ensures the source map actually + // matches that source code. They could have gotten out-of-sync in case + // two separate processes write concurrently to the same cache files. + return { + code, + originalCode: content, + sourceMapPath + }; + } + let processed = null; + let shouldCallTransform = false; + if (transformer && this.shouldTransform(filename)) { + shouldCallTransform = true; + const process = transformer.processAsync ?? transformer.process; + + // This is probably dead code since `_getTransformerAsync` already asserts this + (0, _jestUtil().invariant)( + typeof process === 'function', + 'A transformer must always export either a `process` or `processAsync`' + ); + processed = await process(content, filename, { + ...options, + cacheFS: this._cacheFS, + config: this._config, + configString: this._cache.configString, + transformerConfig + }); + } + (0, _jestUtil().createDirectory)(path().dirname(cacheFilePath)); + return this._buildTransformResult( + filename, + cacheFilePath, + content, + transformer, + shouldCallTransform, + options, + processed, + sourceMapPath + ); + } + async _transformAndBuildScriptAsync( + filename, + options, + transformOptions, + fileSource + ) { + const {isInternalModule} = options; + let fileContent = fileSource ?? this._cacheFS.get(filename); + if (fileContent == null) { + fileContent = fs().readFileSync(filename, 'utf8'); + this._cacheFS.set(filename, fileContent); + } + const content = stripShebang(fileContent); + let code = content; + let sourceMapPath = null; + const willTransform = + isInternalModule !== true && + (transformOptions.instrument || this.shouldTransform(filename)); + try { + if (willTransform) { + const transformedSource = await this.transformSourceAsync( + filename, + content, + transformOptions + ); + code = transformedSource.code; + sourceMapPath = transformedSource.sourceMapPath; + } + return { + code, + originalCode: content, + sourceMapPath + }; + } catch (e) { + if (!(e instanceof Error)) { + throw e; + } + throw (0, _enhanceUnexpectedTokenMessage.default)(e); + } + } + _transformAndBuildScript(filename, options, transformOptions, fileSource) { + const {isInternalModule} = options; + let fileContent = fileSource ?? this._cacheFS.get(filename); + if (fileContent == null) { + fileContent = fs().readFileSync(filename, 'utf8'); + this._cacheFS.set(filename, fileContent); + } + const content = stripShebang(fileContent); + let code = content; + let sourceMapPath = null; + const willTransform = + isInternalModule !== true && + (transformOptions.instrument || this.shouldTransform(filename)); + try { + if (willTransform) { + const transformedSource = this.transformSource( + filename, + content, + transformOptions + ); + code = transformedSource.code; + sourceMapPath = transformedSource.sourceMapPath; + } + return { + code, + originalCode: content, + sourceMapPath + }; + } catch (e) { + if (!(e instanceof Error)) { + throw e; + } + throw (0, _enhanceUnexpectedTokenMessage.default)(e); + } + } + async transformAsync(filename, options, fileSource) { + const instrument = + options.coverageProvider === 'babel' && + (0, _shouldInstrument.default)(filename, options, this._config); + const scriptCacheKey = getScriptCacheKey(filename, instrument); + let result = this._cache.transformedFiles.get(scriptCacheKey); + if (result) { + return result; + } + result = await this._transformAndBuildScriptAsync( + filename, + options, + { + ...options, + instrument + }, + fileSource + ); + if (scriptCacheKey) { + this._cache.transformedFiles.set(scriptCacheKey, result); + } + return result; + } + transform(filename, options, fileSource) { + const instrument = + options.coverageProvider === 'babel' && + (0, _shouldInstrument.default)(filename, options, this._config); + const scriptCacheKey = getScriptCacheKey(filename, instrument); + let result = this._cache.transformedFiles.get(scriptCacheKey); + if (result) { + return result; + } + result = this._transformAndBuildScript( + filename, + options, + { + ...options, + instrument + }, + fileSource + ); + if (scriptCacheKey) { + this._cache.transformedFiles.set(scriptCacheKey, result); + } + return result; + } + transformJson(filename, options, fileSource) { + const {isInternalModule} = options; + const willTransform = + isInternalModule !== true && this.shouldTransform(filename); + if (willTransform) { + const {code: transformedJsonSource} = this.transformSource( + filename, + fileSource, + { + ...options, + instrument: false + } + ); + return transformedJsonSource; + } + return fileSource; + } + async requireAndTranspileModule( + moduleName, + callback, + options = { + applyInteropRequireDefault: true, + instrument: false, + supportsDynamicImport: false, + supportsExportNamespaceFrom: false, + supportsStaticESM: false, + supportsTopLevelAwait: false + } + ) { + let transforming = false; + const {applyInteropRequireDefault, ...transformOptions} = options; + const revertHook = (0, _pirates().addHook)( + (code, filename) => { + try { + transforming = true; + return ( + this.transformSource(filename, code, transformOptions).code || code + ); + } finally { + transforming = false; + } + }, + { + // Exclude `mjs` extension when addHook because pirates don't support hijack es module + exts: this._config.moduleFileExtensions + .filter(ext => ext !== 'mjs') + .map(ext => `.${ext}`), + ignoreNodeModules: false, + matcher: filename => { + if (transforming) { + // Don't transform any dependency required by the transformer itself + return false; + } + return this.shouldTransform(filename); + } + } + ); + try { + const module = await (0, _jestUtil().requireOrImportModule)( + moduleName, + applyInteropRequireDefault + ); + if (!callback) { + revertHook(); + return module; + } + const cbResult = callback(module); + if ((0, _jestUtil().isPromise)(cbResult)) { + return await waitForPromiseWithCleanup(cbResult, revertHook).then( + () => module + ); + } + return module; + } finally { + revertHook(); + } + } + shouldTransform(filename) { + const ignoreRegexp = this._cache.ignorePatternsRegExp; + const isIgnored = ignoreRegexp ? ignoreRegexp.test(filename) : false; + return this._config.transform.length !== 0 && !isIgnored; + } +} + +// TODO: do we need to define the generics twice? +async function createTranspilingRequire(config) { + const transformer = await createScriptTransformer(config); + return async function requireAndTranspileModule( + resolverPath, + applyInteropRequireDefault = false + ) { + const transpiledModule = await transformer.requireAndTranspileModule( + resolverPath, + // eslint-disable-next-line @typescript-eslint/no-empty-function + () => {}, + { + applyInteropRequireDefault, + instrument: false, + supportsDynamicImport: false, + // this might be true, depending on node version. + supportsExportNamespaceFrom: false, + supportsStaticESM: false, + supportsTopLevelAwait: false + } + ); + return transpiledModule; + }; +} +const removeFile = path => { + try { + fs().unlinkSync(path); + } catch {} +}; +const stripShebang = content => { + // If the file data starts with a shebang remove it. Leaves the empty line + // to keep stack trace line numbers correct. + if (content.startsWith('#!')) { + return content.replace(/^#!.*/, ''); + } else { + return content; + } +}; + +/** + * This is like `writeCacheFile` but with an additional sanity checksum. We + * cannot use the same technique for source maps because we expose source map + * cache file paths directly to callsites, with the expectation they can read + * it right away. This is not a great system, because source map cache file + * could get corrupted, out-of-sync, etc. + */ +function writeCodeCacheFile(cachePath, code) { + const checksum = (0, _crypto().createHash)('sha1') + .update(code) + .digest('hex') + .substring(0, 32); + writeCacheFile(cachePath, `${checksum}\n${code}`); +} + +/** + * Read counterpart of `writeCodeCacheFile`. We verify that the content of the + * file matches the checksum, in case some kind of corruption happened. This + * could happen if an older version of `jest-runtime` writes non-atomically to + * the same cache, for example. + */ +function readCodeCacheFile(cachePath) { + const content = readCacheFile(cachePath); + if (content == null) { + return null; + } + const code = content.substring(33); + const checksum = (0, _crypto().createHash)('sha1') + .update(code) + .digest('hex') + .substring(0, 32); + if (checksum === content.substring(0, 32)) { + return code; + } + return null; +} + +/** + * Writing to the cache atomically relies on 'rename' being atomic on most + * file systems. Doing atomic write reduces the risk of corruption by avoiding + * two processes to write to the same file at the same time. It also reduces + * the risk of reading a file that's being overwritten at the same time. + */ +const writeCacheFile = (cachePath, fileData) => { + try { + (0, _writeFileAtomic().sync)(cachePath, fileData, { + encoding: 'utf8', + fsync: false + }); + } catch (e) { + if (!(e instanceof Error)) { + throw e; + } + if (cacheWriteErrorSafeToIgnore(e, cachePath)) { + return; + } + e.message = `jest: failed to cache transform results in: ${cachePath}\nFailure message: ${e.message}`; + removeFile(cachePath); + throw e; + } +}; + +/** + * On Windows, renames are not atomic, leading to EPERM exceptions when two + * processes attempt to rename to the same target file at the same time. + * If the target file exists we can be reasonably sure another process has + * legitimately won a cache write race and ignore the error. + */ +const cacheWriteErrorSafeToIgnore = (e, cachePath) => + process.platform === 'win32' && + e.code === 'EPERM' && + fs().existsSync(cachePath); +const readCacheFile = cachePath => { + if (!fs().existsSync(cachePath)) { + return null; + } + let fileData; + try { + fileData = fs().readFileSync(cachePath, 'utf8'); + } catch (e) { + if (!(e instanceof Error)) { + throw e; + } + // on windows write-file-atomic is not atomic which can + // result in this error + if (e.code === 'ENOENT' && process.platform === 'win32') { + return null; + } + e.message = `jest: failed to read cache file: ${cachePath}\nFailure message: ${e.message}`; + removeFile(cachePath); + throw e; + } + if (fileData == null) { + // We must have somehow created the file but failed to write to it, + // let's delete it and retry. + removeFile(cachePath); + } + return fileData; +}; +const getScriptCacheKey = (filename, instrument) => { + const mtime = fs().statSync(filename).mtime; + return `${filename}_${mtime.getTime()}${instrument ? '_instrumented' : ''}`; +}; +const calcIgnorePatternRegExp = config => { + if ( + config.transformIgnorePatterns == null || + config.transformIgnorePatterns.length === 0 + ) { + return undefined; + } + return new RegExp(config.transformIgnorePatterns.join('|')); +}; +const calcTransformRegExp = config => { + if (!config.transform.length) { + return undefined; + } + const transformRegexp = []; + for (let i = 0; i < config.transform.length; i++) { + transformRegexp.push([ + new RegExp(config.transform[i][0]), + config.transform[i][1], + config.transform[i][2] + ]); + } + return transformRegexp; +}; +function assertSyncTransformer(transformer, name) { + (0, _jestUtil().invariant)(name); + (0, _jestUtil().invariant)( + typeof transformer.process === 'function', + (0, _runtimeErrorsAndWarnings.makeInvalidSyncTransformerError)(name) + ); +} +async function createScriptTransformer(config, cacheFS = new Map()) { + const transformer = new ScriptTransformer(config, cacheFS); + await transformer.loadTransformers(); + return transformer; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/build/enhanceUnexpectedTokenMessage.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/build/enhanceUnexpectedTokenMessage.js new file mode 100644 index 0000000000000000000000000000000000000000..d0498e696837756aa57b9ca8ab58526620493533 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/build/enhanceUnexpectedTokenMessage.js @@ -0,0 +1,76 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = handlePotentialSyntaxError; +exports.enhanceUnexpectedTokenMessage = enhanceUnexpectedTokenMessage; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const DOT = ' \u2022 '; +function handlePotentialSyntaxError(e) { + if (e.codeFrame != null) { + e.stack = `${e.message}\n${e.codeFrame}`; + } + if ( + // `instanceof` might come from the wrong context + e.name === 'SyntaxError' && + !e.message.includes(' expected') + ) { + throw enhanceUnexpectedTokenMessage(e); + } + return e; +} +function enhanceUnexpectedTokenMessage(e) { + e.stack = `${_chalk().default.bold.red( + 'Jest encountered an unexpected token' + )} + +Jest failed to parse a file. This happens e.g. when your code or its dependencies use non-standard JavaScript syntax, or when Jest is not configured to support such syntax. + +Out of the box Jest supports Babel, which will be used to transform your files into valid JS based on your Babel configuration. + +By default "node_modules" folder is ignored by transformers. + +Here's what you can do: +${DOT}If you are trying to use ECMAScript Modules, see ${_chalk().default.underline( + 'https://jestjs.io/docs/ecmascript-modules' + )} for how to enable it. +${DOT}If you are trying to use TypeScript, see ${_chalk().default.underline( + 'https://jestjs.io/docs/getting-started#using-typescript' + )} +${DOT}To have some of your "node_modules" files transformed, you can specify a custom ${_chalk().default.bold( + '"transformIgnorePatterns"' + )} in your config. +${DOT}If you need a custom transformation specify a ${_chalk().default.bold( + '"transform"' + )} option in your config. +${DOT}If you simply want to mock your non-JS modules (e.g. binary assets) you can stub them out with the ${_chalk().default.bold( + '"moduleNameMapper"' + )} config option. + +You'll find more details and examples of these config options in the docs: +${_chalk().default.cyan('https://jestjs.io/docs/configuration')} +For information about custom transformations, see: +${_chalk().default.cyan('https://jestjs.io/docs/code-transformation')} + +${_chalk().default.bold.red('Details:')} + +${e.stack ?? ''}`.trimRight(); + return e; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a5065488fc379a12c4385fda5a34a2b403333291 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/build/index.d.ts @@ -0,0 +1,240 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +import type {Config} from '@jest/types'; +import type {EncodedSourceMap} from '@jridgewell/trace-mapping'; +import type {TransformTypes} from '@jest/types'; + +export declare interface AsyncTransformer { + /** + * Indicates if the transformer is capable of instrumenting the code for code coverage. + * + * If V8 coverage is _not_ active, and this is `true`, Jest will assume the code is instrumented. + * If V8 coverage is _not_ active, and this is `false`. Jest will instrument the code returned by this transformer using Babel. + */ + canInstrument?: boolean; + getCacheKey?: ( + sourceText: string, + sourcePath: string, + options: TransformOptions, + ) => string; + getCacheKeyAsync?: ( + sourceText: string, + sourcePath: string, + options: TransformOptions, + ) => Promise; + process?: ( + sourceText: string, + sourcePath: string, + options: TransformOptions, + ) => TransformedSource; + processAsync: ( + sourceText: string, + sourcePath: string, + options: TransformOptions, + ) => Promise; +} + +export declare interface CallerTransformOptions { + supportsDynamicImport: boolean; + supportsExportNamespaceFrom: boolean; + supportsStaticESM: boolean; + supportsTopLevelAwait: boolean; +} + +export declare function createScriptTransformer( + config: Config.ProjectConfig, + cacheFS?: StringMap, +): Promise; + +export declare function createTranspilingRequire( + config: Config.ProjectConfig, +): Promise< + ( + resolverPath: string, + applyInteropRequireDefault?: boolean, + ) => Promise +>; + +declare interface ErrorWithCodeFrame extends Error { + codeFrame?: string; +} + +declare interface FixedRawSourceMap extends Omit { + version: number; +} + +export declare function handlePotentialSyntaxError( + e: ErrorWithCodeFrame, +): ErrorWithCodeFrame; + +declare interface ReducedTransformOptions extends CallerTransformOptions { + instrument: boolean; +} + +declare interface RequireAndTranspileModuleOptions + extends ReducedTransformOptions { + applyInteropRequireDefault: boolean; +} + +export declare type ScriptTransformer = ScriptTransformer_2; + +declare class ScriptTransformer_2 { + private readonly _config; + private readonly _cacheFS; + private readonly _cache; + private readonly _transformCache; + private _transformsAreLoaded; + constructor(_config: Config.ProjectConfig, _cacheFS: StringMap); + private _buildCacheKeyFromFileInfo; + private _buildTransformCacheKey; + private _getCacheKey; + private _getCacheKeyAsync; + private _createCachedFilename; + private _getFileCachePath; + private _getFileCachePathAsync; + private _getTransformPatternAndPath; + private _getTransformPath; + loadTransformers(): Promise; + private _getTransformer; + private _instrumentFile; + private _buildTransformResult; + transformSource( + filepath: string, + content: string, + options: ReducedTransformOptions, + ): TransformResult; + transformSourceAsync( + filepath: string, + content: string, + options: ReducedTransformOptions, + ): Promise; + private _transformAndBuildScriptAsync; + private _transformAndBuildScript; + transformAsync( + filename: string, + options: TransformationOptions, + fileSource?: string, + ): Promise; + transform( + filename: string, + options: TransformationOptions, + fileSource?: string, + ): TransformResult; + transformJson( + filename: string, + options: TransformationOptions, + fileSource: string, + ): string; + requireAndTranspileModule( + moduleName: string, + callback?: (module: ModuleType) => void | Promise, + options?: RequireAndTranspileModuleOptions, + ): Promise; + shouldTransform(filename: string): boolean; +} + +export declare function shouldInstrument( + filename: string, + options: ShouldInstrumentOptions, + config: Config.ProjectConfig, + loadedFilenames?: Array, +): boolean; + +export declare interface ShouldInstrumentOptions + extends Pick< + Config.GlobalConfig, + 'collectCoverage' | 'collectCoverageFrom' | 'coverageProvider' + > { + changedFiles?: Set; + sourcesRelatedToTestsInChangedFiles?: Set; +} + +declare type StringMap = Map; + +export declare interface SyncTransformer { + /** + * Indicates if the transformer is capable of instrumenting the code for code coverage. + * + * If V8 coverage is _not_ active, and this is `true`, Jest will assume the code is instrumented. + * If V8 coverage is _not_ active, and this is `false`. Jest will instrument the code returned by this transformer using Babel. + */ + canInstrument?: boolean; + getCacheKey?: ( + sourceText: string, + sourcePath: string, + options: TransformOptions, + ) => string; + getCacheKeyAsync?: ( + sourceText: string, + sourcePath: string, + options: TransformOptions, + ) => Promise; + process: ( + sourceText: string, + sourcePath: string, + options: TransformOptions, + ) => TransformedSource; + processAsync?: ( + sourceText: string, + sourcePath: string, + options: TransformOptions, + ) => Promise; +} + +export declare interface TransformationOptions + extends ShouldInstrumentOptions, + CallerTransformOptions { + isInternalModule?: boolean; +} + +export declare type TransformedSource = { + code: string; + map?: FixedRawSourceMap | string | null; +}; + +/** + * We have both sync (`process`) and async (`processAsync`) code transformation, which both can be provided. + * `require` will always use `process`, and `import` will use `processAsync` if it exists, otherwise fall back to `process`. + * Meaning, if you use `import` exclusively you do not need `process`, but in most cases supplying both makes sense: + * Jest transpiles on demand rather than ahead of time, so the sync one needs to exist. + * + * For more info on the sync vs async model, see https://jestjs.io/docs/code-transformation#writing-custom-transformers + */ +declare type Transformer_2 = + | SyncTransformer + | AsyncTransformer; +export {Transformer_2 as Transformer}; + +export declare type TransformerCreator< + X extends Transformer_2, + TransformerConfig = unknown, +> = (transformerConfig?: TransformerConfig) => X | Promise; + +/** + * Instead of having your custom transformer implement the Transformer interface + * directly, you can choose to export a factory function to dynamically create + * transformers. This is to allow having a transformer config in your jest config. + */ +export declare type TransformerFactory = { + createTransformer: TransformerCreator; +}; + +export declare interface TransformOptions + extends ReducedTransformOptions { + /** Cached file system which is used by `jest-runtime` to improve performance. */ + cacheFS: StringMap; + /** Jest configuration of currently running project. */ + config: Config.ProjectConfig; + /** Stringified version of the `config` - useful in cache busting. */ + configString: string; + /** Transformer configuration passed through `transform` option by the user. */ + transformerConfig: TransformerConfig; +} + +export declare type TransformResult = TransformTypes.TransformResult; + +export {}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..7b2d0303af5b6095f8cf55717c647ab0b05c4dd5 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/build/index.js @@ -0,0 +1,37 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +Object.defineProperty(exports, 'createScriptTransformer', { + enumerable: true, + get: function () { + return _ScriptTransformer.createScriptTransformer; + } +}); +Object.defineProperty(exports, 'createTranspilingRequire', { + enumerable: true, + get: function () { + return _ScriptTransformer.createTranspilingRequire; + } +}); +Object.defineProperty(exports, 'handlePotentialSyntaxError', { + enumerable: true, + get: function () { + return _enhanceUnexpectedTokenMessage.default; + } +}); +Object.defineProperty(exports, 'shouldInstrument', { + enumerable: true, + get: function () { + return _shouldInstrument.default; + } +}); +var _ScriptTransformer = require('./ScriptTransformer'); +var _shouldInstrument = _interopRequireDefault(require('./shouldInstrument')); +var _enhanceUnexpectedTokenMessage = _interopRequireDefault( + require('./enhanceUnexpectedTokenMessage') +); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/build/runtimeErrorsAndWarnings.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/build/runtimeErrorsAndWarnings.js new file mode 100644 index 0000000000000000000000000000000000000000..eba96778f2af706494fdff36382a5aa7b40752fe --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/build/runtimeErrorsAndWarnings.js @@ -0,0 +1,94 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.makeInvalidTransformerError = + exports.makeInvalidSyncTransformerError = + exports.makeInvalidSourceMapWarning = + exports.makeInvalidReturnValueError = + void 0; +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + _chalk = function () { + return data; + }; + return data; +} +function _slash() { + const data = _interopRequireDefault(require('slash')); + _slash = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const BULLET = '\u25cf '; +const DOCUMENTATION_NOTE = ` ${_chalk().default.bold( + 'Code Transformation Documentation:' +)} + https://jestjs.io/docs/code-transformation +`; +const UPGRADE_NOTE = ` ${_chalk().default.bold( + 'This error may be caused by a breaking change in Jest 28:' +)} + https://jestjs.io/docs/28.x/upgrading-to-jest28#transformer +`; +const makeInvalidReturnValueError = transformPath => + _chalk().default.red( + [ + _chalk().default.bold(`${BULLET}Invalid return value:`), + ' `process()` or/and `processAsync()` method of code transformer found at ', + ` "${(0, _slash().default)(transformPath)}" `, + ' should return an object or a Promise resolving to an object. The object ', + ' must have `code` property with a string of processed code.', + '' + ].join('\n') + + UPGRADE_NOTE + + DOCUMENTATION_NOTE + ); +exports.makeInvalidReturnValueError = makeInvalidReturnValueError; +const makeInvalidSourceMapWarning = (filename, transformPath) => + _chalk().default.yellow( + [ + _chalk().default.bold(`${BULLET}Invalid source map:`), + ` The source map for "${(0, _slash().default)( + filename + )}" returned by "${(0, _slash().default)(transformPath)}" is invalid.`, + ' Proceeding without source mapping for that file.' + ].join('\n') + ); +exports.makeInvalidSourceMapWarning = makeInvalidSourceMapWarning; +const makeInvalidSyncTransformerError = transformPath => + _chalk().default.red( + [ + _chalk().default.bold(`${BULLET}Invalid synchronous transformer module:`), + ` "${(0, _slash().default)( + transformPath + )}" specified in the "transform" object of Jest configuration`, + ' must export a `process` function.', + '' + ].join('\n') + DOCUMENTATION_NOTE + ); +exports.makeInvalidSyncTransformerError = makeInvalidSyncTransformerError; +const makeInvalidTransformerError = transformPath => + _chalk().default.red( + [ + _chalk().default.bold(`${BULLET}Invalid transformer module:`), + ` "${(0, _slash().default)( + transformPath + )}" specified in the "transform" object of Jest configuration`, + ' must export a `process` or `processAsync` or `createTransformer` function.', + '' + ].join('\n') + DOCUMENTATION_NOTE + ); +exports.makeInvalidTransformerError = makeInvalidTransformerError; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/build/shouldInstrument.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/build/shouldInstrument.js new file mode 100644 index 0000000000000000000000000000000000000000..8ba5d94b01764ed153b6e00f36cdb725dab2eb98 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/build/shouldInstrument.js @@ -0,0 +1,177 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = shouldInstrument; +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _micromatch() { + const data = _interopRequireDefault(require('micromatch')); + _micromatch = function () { + return data; + }; + return data; +} +function _jestRegexUtil() { + const data = require('jest-regex-util'); + _jestRegexUtil = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const MOCKS_PATTERN = new RegExp( + (0, _jestRegexUtil().escapePathForRegex)( + `${path().sep}__mocks__${path().sep}` + ) +); +const cachedRegexes = new Map(); +const getRegex = regexStr => { + if (!cachedRegexes.has(regexStr)) { + cachedRegexes.set(regexStr, new RegExp(regexStr)); + } + const regex = cachedRegexes.get(regexStr); + + // prevent stateful regexes from breaking, just in case + regex.lastIndex = 0; + return regex; +}; +function shouldInstrument(filename, options, config, loadedFilenames) { + if (!options.collectCoverage) { + return false; + } + if ( + config.forceCoverageMatch.length && + _micromatch().default.any(filename, config.forceCoverageMatch) + ) { + return true; + } + if ( + !config.testPathIgnorePatterns.some(pattern => + getRegex(pattern).test(filename) + ) + ) { + if (config.testRegex.some(regex => new RegExp(regex).test(filename))) { + return false; + } + if ( + (0, _jestUtil().globsToMatcher)(config.testMatch)( + (0, _jestUtil().replacePathSepForGlob)(filename) + ) + ) { + return false; + } + } + if ( + options.collectCoverageFrom.length === 0 && + loadedFilenames != null && + !loadedFilenames.includes(filename) + ) { + return false; + } + if ( + // still cover if `only` is specified + options.collectCoverageFrom.length && + !(0, _jestUtil().globsToMatcher)(options.collectCoverageFrom)( + (0, _jestUtil().replacePathSepForGlob)( + path().relative(config.rootDir, filename) + ) + ) + ) { + return false; + } + if ( + config.coveragePathIgnorePatterns.some(pattern => !!filename.match(pattern)) + ) { + return false; + } + if (config.globalSetup === filename) { + return false; + } + if (config.globalTeardown === filename) { + return false; + } + if (config.setupFiles.includes(filename)) { + return false; + } + if (config.setupFilesAfterEnv.includes(filename)) { + return false; + } + if (MOCKS_PATTERN.test(filename)) { + return false; + } + if (options.changedFiles && !options.changedFiles.has(filename)) { + if (!options.sourcesRelatedToTestsInChangedFiles) { + return false; + } + if (!options.sourcesRelatedToTestsInChangedFiles.has(filename)) { + return false; + } + } + if (filename.endsWith('.json')) { + return false; + } + return true; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/build/types.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/build/types.js new file mode 100644 index 0000000000000000000000000000000000000000..ad9a93a7c160f02945911772460eb8a1bcb003db --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/build/types.js @@ -0,0 +1 @@ +'use strict'; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/package.json new file mode 100644 index 0000000000000000000000000000000000000000..20d4209bcb3352d84e12d79a2da5fcdc8bea57e9 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/@jest/transform/package.json @@ -0,0 +1,52 @@ +{ + "name": "@jest/transform", + "version": "29.7.0", + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/jest-transform" + }, + "license": "MIT", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "dependencies": { + "@babel/core": "^7.11.6", + "@jest/types": "^29.6.3", + "@jridgewell/trace-mapping": "^0.3.18", + "babel-plugin-istanbul": "^6.1.1", + "chalk": "^4.0.0", + "convert-source-map": "^2.0.0", + "fast-json-stable-stringify": "^2.1.0", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^29.7.0", + "jest-regex-util": "^29.6.3", + "jest-util": "^29.7.0", + "micromatch": "^4.0.4", + "pirates": "^4.0.4", + "slash": "^3.0.0", + "write-file-atomic": "^4.0.2" + }, + "devDependencies": { + "@jest/test-utils": "^29.7.0", + "@types/babel__core": "^7.1.14", + "@types/convert-source-map": "^2.0.0", + "@types/graceful-fs": "^4.1.3", + "@types/micromatch": "^4.0.1", + "@types/write-file-atomic": "^4.0.0", + "dedent": "^1.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "publishConfig": { + "access": "public" + }, + "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/ansi-regex/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/ansi-regex/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2dbf6af2b6f3b5701c83caaea7ed2210192023a8 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/ansi-regex/index.d.ts @@ -0,0 +1,37 @@ +declare namespace ansiRegex { + interface Options { + /** + Match only the first ANSI escape. + + @default false + */ + onlyFirst: boolean; + } +} + +/** +Regular expression for matching ANSI escape codes. + +@example +``` +import ansiRegex = require('ansi-regex'); + +ansiRegex().test('\u001B[4mcake\u001B[0m'); +//=> true + +ansiRegex().test('cake'); +//=> false + +'\u001B[4mcake\u001B[0m'.match(ansiRegex()); +//=> ['\u001B[4m', '\u001B[0m'] + +'\u001B[4mcake\u001B[0m'.match(ansiRegex({onlyFirst: true})); +//=> ['\u001B[4m'] + +'\u001B]8;;https://github.com\u0007click\u001B]8;;\u0007'.match(ansiRegex()); +//=> ['\u001B]8;;https://github.com\u0007', '\u001B]8;;\u0007'] +``` +*/ +declare function ansiRegex(options?: ansiRegex.Options): RegExp; + +export = ansiRegex; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/ansi-regex/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/ansi-regex/index.js new file mode 100644 index 0000000000000000000000000000000000000000..616ff837d3ff01e028c208062fc699c7f1c8d418 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/ansi-regex/index.js @@ -0,0 +1,10 @@ +'use strict'; + +module.exports = ({onlyFirst = false} = {}) => { + const pattern = [ + '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)', + '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))' + ].join('|'); + + return new RegExp(pattern, onlyFirst ? undefined : 'g'); +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/ansi-regex/license b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/ansi-regex/license new file mode 100644 index 0000000000000000000000000000000000000000..e7af2f77107d73046421ef56c4684cbfdd3c1e89 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/ansi-regex/license @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) Sindre Sorhus (sindresorhus.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/ansi-regex/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/ansi-regex/package.json new file mode 100644 index 0000000000000000000000000000000000000000..017f53116a9e2805ccb12efc3c7fcd7e4384735d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/ansi-regex/package.json @@ -0,0 +1,55 @@ +{ + "name": "ansi-regex", + "version": "5.0.1", + "description": "Regular expression for matching ANSI escape codes", + "license": "MIT", + "repository": "chalk/ansi-regex", + "author": { + "name": "Sindre Sorhus", + "email": "sindresorhus@gmail.com", + "url": "sindresorhus.com" + }, + "engines": { + "node": ">=8" + }, + "scripts": { + "test": "xo && ava && tsd", + "view-supported": "node fixtures/view-codes.js" + }, + "files": [ + "index.js", + "index.d.ts" + ], + "keywords": [ + "ansi", + "styles", + "color", + "colour", + "colors", + "terminal", + "console", + "cli", + "string", + "tty", + "escape", + "formatting", + "rgb", + "256", + "shell", + "xterm", + "command-line", + "text", + "regex", + "regexp", + "re", + "match", + "test", + "find", + "pattern" + ], + "devDependencies": { + "ava": "^2.4.0", + "tsd": "^0.9.0", + "xo": "^0.25.3" + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/ansi-regex/readme.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/ansi-regex/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..4d848bc36f6b862e5db3effa59ebed515730284e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/ansi-regex/readme.md @@ -0,0 +1,78 @@ +# ansi-regex + +> Regular expression for matching [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code) + + +## Install + +``` +$ npm install ansi-regex +``` + + +## Usage + +```js +const ansiRegex = require('ansi-regex'); + +ansiRegex().test('\u001B[4mcake\u001B[0m'); +//=> true + +ansiRegex().test('cake'); +//=> false + +'\u001B[4mcake\u001B[0m'.match(ansiRegex()); +//=> ['\u001B[4m', '\u001B[0m'] + +'\u001B[4mcake\u001B[0m'.match(ansiRegex({onlyFirst: true})); +//=> ['\u001B[4m'] + +'\u001B]8;;https://github.com\u0007click\u001B]8;;\u0007'.match(ansiRegex()); +//=> ['\u001B]8;;https://github.com\u0007', '\u001B]8;;\u0007'] +``` + + +## API + +### ansiRegex(options?) + +Returns a regex for matching ANSI escape codes. + +#### options + +Type: `object` + +##### onlyFirst + +Type: `boolean`
+Default: `false` *(Matches any ANSI escape codes in a string)* + +Match only the first ANSI escape. + + +## FAQ + +### Why do you test for codes not in the ECMA 48 standard? + +Some of the codes we run as a test are codes that we acquired finding various lists of non-standard or manufacturer specific codes. We test for both standard and non-standard codes, as most of them follow the same or similar format and can be safely matched in strings without the risk of removing actual string content. There are a few non-standard control codes that do not follow the traditional format (i.e. they end in numbers) thus forcing us to exclude them from the test because we cannot reliably match them. + +On the historical side, those ECMA standards were established in the early 90's whereas the VT100, for example, was designed in the mid/late 70's. At that point in time, control codes were still pretty ungoverned and engineers used them for a multitude of things, namely to activate hardware ports that may have been proprietary. Somewhere else you see a similar 'anarchy' of codes is in the x86 architecture for processors; there are a ton of "interrupts" that can mean different things on certain brands of processors, most of which have been phased out. + + +## Maintainers + +- [Sindre Sorhus](https://github.com/sindresorhus) +- [Josh Junon](https://github.com/qix-) + + +--- + +
+ + Get professional support for this package with a Tidelift subscription + +
+ + Tidelift helps make open source sustainable for maintainers while giving companies
assurances about security, maintenance, and licensing for their dependencies. + +
diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/CHANGELOG.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..aa57d4f1aec33b3fd3edc98bc50c74c0a3d2ba3e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/CHANGELOG.md @@ -0,0 +1,320 @@ +# Changelog + +All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines. + +### [6.1.1](https://www.github.com/istanbuljs/babel-plugin-istanbul/compare/v6.1.0...v6.1.1) (2021-10-16) + + +### Bug Fixes + +* **build:** first automated publication ([9a1b893](https://www.github.com/istanbuljs/babel-plugin-istanbul/commit/9a1b89342565d1127a011e31262520b057120531)) + +## [6.1.0](https://www.github.com/istanbuljs/babel-plugin-istanbul/compare/v6.0.0...v6.1.0) (2021-10-16) + + +### Features + +* **instrumenter:** instrumenter with fixes for branchMap instrumentation ([#265](https://www.github.com/istanbuljs/babel-plugin-istanbul/issues/265)) ([1e9ec62](https://www.github.com/istanbuljs/babel-plugin-istanbul/commit/1e9ec62b50c9d2224e7bb0ccb071fd10b80e018f)) + +## [6.0.0](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v5.2.0...v6.0.0) (2019-12-20) + + +### ⚠ BREAKING CHANGES + +* Drop node.js 6 (#226) + +### Features + +* Add support for instrumenter options ([#227](https://github.com/istanbuljs/babel-plugin-istanbul/issues/227)) ([fe08f5b](https://github.com/istanbuljs/babel-plugin-istanbul/commit/fe08f5b8282136c7ed9375fa32148586bd6a7e28)), closes [#208](https://github.com/istanbuljs/babel-plugin-istanbul/issues/208) [#212](https://github.com/istanbuljs/babel-plugin-istanbul/issues/212) +* Drop node.js 6 ([#226](https://github.com/istanbuljs/babel-plugin-istanbul/issues/226)) ([93db21a](https://github.com/istanbuljs/babel-plugin-istanbul/commit/93db21aa2bbdbb06fb784f52c24a7847fad6be92)), closes [#209](https://github.com/istanbuljs/babel-plugin-istanbul/issues/209) + +## [5.2.0](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v5.1.4...v5.2.0) (2019-07-18) + + +### Bug Fixes + +* Print explicit error if use with babel 6 is attempted ([#207](https://github.com/istanbuljs/babel-plugin-istanbul/issues/207)) ([a12cf16](https://github.com/istanbuljs/babel-plugin-istanbul/commit/a12cf16)) + + +### Features + +* Support turning off node_modules default exclude via flag ([#172](https://github.com/istanbuljs/babel-plugin-istanbul/issues/172)) ([a314f06](https://github.com/istanbuljs/babel-plugin-istanbul/commit/a314f06)) + + + +## [5.1.4](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v5.1.3...v5.1.4) (2019-04-25) + + + +## [5.1.3](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v5.1.2...v5.1.3) (2019-04-23) + + +### Bug Fixes + +* Revert [#192](https://github.com/istanbuljs/babel-plugin-istanbul/issues/192) ([201a933](https://github.com/istanbuljs/babel-plugin-istanbul/commit/201a933)) due to regression detailed at [#201](https://github.com/istanbuljs/babel-plugin-istanbul/issues/201) + + + +## [5.1.2](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v5.1.1...v5.1.2) (2019-04-10) + + +### Bug Fixes + +* Ensure correct scope references after traversal ([#192](https://github.com/istanbuljs/babel-plugin-istanbul/issues/192)) ([201a933](https://github.com/istanbuljs/babel-plugin-istanbul/commit/201a933)) + + + + +## [5.1.1](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v5.1.0...v5.1.1) (2019-01-11) + + +### Bug Fixes + +* respect changes of cwd in options ([#171](https://github.com/istanbuljs/babel-plugin-istanbul/issues/171)) ([adec723](https://github.com/istanbuljs/babel-plugin-istanbul/commit/adec723)) + + + + +# [5.1.0](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v5.0.1...v5.1.0) (2018-09-07) + + +### Features + +* Bump dependencies. ([b509649](https://github.com/istanbuljs/babel-plugin-istanbul/commit/b509649)) + + + + +## [5.0.1](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v5.0.0...v5.0.1) (2018-07-24) + + + + +# [5.0.0](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v4.1.6...v5.0.0) (2018-06-27) + + +### Features + +* upgrade to babel 7 and newest istanbul libraries ([#158](https://github.com/istanbuljs/babel-plugin-istanbul/issues/158)) ([a9e1564](https://github.com/istanbuljs/babel-plugin-istanbul/commit/a9e1564)) + + +### BREAKING CHANGES + +* Drop node 4 support, upgrade to babel 7, stop shipping @babel/plugin-syntax-object-rest-spread + + + + +## 4.1.6 (2018-03-09) + +* chore: explicit update of istanbul dependencies (#149) ([77b6eb7](https://github.com/istanbuljs/babel-plugin-istanbul/commit/77b6eb7)), closes [#149](https://github.com/istanbuljs/babel-plugin-istanbul/issues/149) +* chore(package): update coveralls to version 3.0.0 (#133) ([7045a03](https://github.com/istanbuljs/babel-plugin-istanbul/commit/7045a03)), closes [#133](https://github.com/istanbuljs/babel-plugin-istanbul/issues/133) +* chore(package): update mocha to version 4.0.0 (#134) ([38176ba](https://github.com/istanbuljs/babel-plugin-istanbul/commit/38176ba)), closes [#134](https://github.com/istanbuljs/babel-plugin-istanbul/issues/134) +* fix: babel-preset-es2015 => babel-preset-env (#138) ([18fe954](https://github.com/istanbuljs/babel-plugin-istanbul/commit/18fe954)), closes [#138](https://github.com/istanbuljs/babel-plugin-istanbul/issues/138) +* fix: include object-spread-syntax plugin (#141) ([428a952](https://github.com/istanbuljs/babel-plugin-istanbul/commit/428a952)), closes [#141](https://github.com/istanbuljs/babel-plugin-istanbul/issues/141) + + + + +## [4.1.5](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v4.1.2...v4.1.5) (2017-08-23) + + + + +## [4.1.4](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v4.1.3...v4.1.4) (2017-05-27) + + + + +## [4.1.3](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v4.1.1...v4.1.3) (2017-04-29) + + + + +## [4.1.2](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v4.1.1...v4.1.2) (2017-03-27) + + + + +## [4.1.1](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v4.1.0...v4.1.1) (2017-03-22) + + +### Bug Fixes + +* explicit upgrade to patched version of istanbul-lib-instrument ([db8ecbe](https://github.com/istanbuljs/babel-plugin-istanbul/commit/db8ecbe)) + + + + +# [4.1.0](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v4.0.0...v4.1.0) (2017-03-21) + + +### Features + +* add includeUntested option to expose coverage of all instrumented files ([#80](https://github.com/istanbuljs/babel-plugin-istanbul/issues/80)) ([b078bbd](https://github.com/istanbuljs/babel-plugin-istanbul/commit/b078bbd)) + + + + +# [4.0.0](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v3.1.2...v4.0.0) (2017-02-07) + + +### Bug Fixes + +* load configuration from process.env.NYC_CONFIG if present ([#93](https://github.com/istanbuljs/babel-plugin-istanbul/issues/93)) ([e902924](https://github.com/istanbuljs/babel-plugin-istanbul/commit/e902924)) + + +### Features + +* drop Node 0.10 and 0.12 support, upgrade dependencies to reflect this ([#88](https://github.com/istanbuljs/babel-plugin-istanbul/issues/88)) ([594c03a](https://github.com/istanbuljs/babel-plugin-istanbul/commit/594c03a)) +* we can now use the language feature Object.assign ([#92](https://github.com/istanbuljs/babel-plugin-istanbul/issues/92)) ([f77db2a](https://github.com/istanbuljs/babel-plugin-istanbul/commit/f77db2a)) + + +### BREAKING CHANGES + +* I've updated dependencies and dropped Node 0.10 and Node 0.12 support. + + + + +## [3.1.2](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v3.1.1...v3.1.2) (2017-01-04) + + +### Bug Fixes + +* address regression related to export const foo = () => {} ([#79](https://github.com/istanbuljs/babel-plugin-istanbul/issues/79)) ([f870a8f](https://github.com/istanbuljs/babel-plugin-istanbul/commit/f870a8f)) + + + + +## [3.1.1](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v3.1.0...v3.1.1) (2017-01-02) + + + + +# [3.1.0](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v3.0.0...v3.1.0) (2016-12-27) + + +### Bug Fixes + +* upgrade a bunch of core dependencies ([#77](https://github.com/istanbuljs/babel-plugin-istanbul/issues/77)) ([e764330](https://github.com/istanbuljs/babel-plugin-istanbul/commit/e764330)) + + +### Features + +* accept source map input for the visitor ([#75](https://github.com/istanbuljs/babel-plugin-istanbul/issues/75)) ([437e90b](https://github.com/istanbuljs/babel-plugin-istanbul/commit/437e90b)) + + + + +# [3.0.0](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v2.0.3...v3.0.0) (2016-11-14) + + +### Chores + +* **package:** update test-exclude to version 3.0.0 ([#68](https://github.com/istanbuljs/babel-plugin-istanbul/issues/68)) ([0396385](https://github.com/istanbuljs/babel-plugin-istanbul/commit/0396385)) + + +### BREAKING CHANGES + +* package: test-exclude now adds `**/node_modules/**` as exclude rule by default. + + + + +## [2.0.3](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v2.0.2...v2.0.3) (2016-10-17) + + +### Bug Fixes + +* force istanbul-lib-instrument with variable hoisting fix ([#64](https://github.com/istanbuljs/babel-plugin-istanbul/issues/64)) ([209a0cf](https://github.com/istanbuljs/babel-plugin-istanbul/commit/209a0cf)) +* switch deprecated lodash.assign for object-assign ([#58](https://github.com/istanbuljs/babel-plugin-istanbul/issues/58)) ([6e051fc](https://github.com/istanbuljs/babel-plugin-istanbul/commit/6e051fc)) + + + + +## [2.0.2](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v2.0.1...v2.0.2) (2016-09-08) + + +### Bug Fixes + +* take realpath of cwd, whether or not set in env ([#37](https://github.com/istanbuljs/babel-plugin-istanbul/issues/37)) ([6274d83](https://github.com/istanbuljs/babel-plugin-istanbul/commit/6274d83)) + + + + +## [2.0.1](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v2.0.0...v2.0.1) (2016-09-02) + + +### Bug Fixes + +* update istanbul-lib-instrument ([573e0d4](https://github.com/istanbuljs/babel-plugin-istanbul/commit/573e0d4)) + + + + +# [2.0.0](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v1.1.0...v2.0.0) (2016-08-14) + + +### Chores + +* upgrade to version of test-exclude with new exclude rules ([#35](https://github.com/istanbuljs/babel-plugin-istanbul/issues/35)) ([220ce2b](https://github.com/istanbuljs/babel-plugin-istanbul/commit/220ce2b)) + + +### BREAKING CHANGES + +* see https://github.com/istanbuljs/test-exclude/blob/master/CHANGELOG.md#breaking-changes + + + + +# [1.1.0](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v1.0.3...v1.1.0) (2016-07-21) + + +### Bug Fixes + +* upgrade to istanbul-lib-instrument with faster babel-generator ([#18](https://github.com/istanbuljs/babel-plugin-istanbul/issues/18)) ([d33263c](https://github.com/istanbuljs/babel-plugin-istanbul/commit/d33263c)) + + +### Features + +* allow exclude/include options to be passed as Babel plugin config ([#16](https://github.com/istanbuljs/babel-plugin-istanbul/issues/16)) ([cf68421](https://github.com/istanbuljs/babel-plugin-istanbul/commit/cf68421)) + + + + +## [1.0.3](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v1.0.2...v1.0.3) (2016-07-09) + + +### Bug Fixes + +* keep using NYC_CWD if available ([#10](https://github.com/istanbuljs/babel-plugin-istanbul/issues/10)) ([db0352b](https://github.com/istanbuljs/babel-plugin-istanbul/commit/db0352b)) + + + + +## [1.0.2](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v1.0.1...v1.0.2) (2016-07-03) + + +### Bug Fixes + +* take realpath of process.cwd(), fixes [#7](https://github.com/istanbuljs/babel-plugin-istanbul/issues/7) ([#8](https://github.com/istanbuljs/babel-plugin-istanbul/issues/8)) ([e8d3785](https://github.com/istanbuljs/babel-plugin-istanbul/commit/e8d3785)), closes [#7](https://github.com/istanbuljs/babel-plugin-istanbul/issues/7) [#8](https://github.com/istanbuljs/babel-plugin-istanbul/issues/8) + + + + +## [1.0.1](https://github.com/istanbuljs/babel-plugin-istanbul/compare/v1.0.0...v1.0.1) (2016-06-30) + + +### Bug Fixes + +* upgrade to version of istanbul-lib-instrument that fixes some out of bounds issues ([#6](https://github.com/istanbuljs/babel-plugin-istanbul/issues/6)) ([a949065](https://github.com/istanbuljs/babel-plugin-istanbul/commit/a949065)), closes [#6](https://github.com/istanbuljs/babel-plugin-istanbul/issues/6) + + + +# 1.0.0 (2016-06-26) + + +### Features + +* port functionality from __coverage__, get ready for first release ([#2](https://github.com/istanbuljs/babel-plugin-istanbul/issues/2)) ([2a8ee44](https://github.com/istanbuljs/babel-plugin-istanbul/commit/2a8ee44)) diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..22f21ab994030c471bbe1ea9cc9c59ed10fa7f56 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/LICENSE @@ -0,0 +1,27 @@ +Copyright (c) 2016, Istanbul Code Coverage +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +* Neither the name of babel-plugin-istanbul nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a027e9b78223e042fa95bd119e8250250850359b --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/README.md @@ -0,0 +1,135 @@ +# babel-plugin-istanbul + +[![Coverage Status](https://coveralls.io/repos/github/istanbuljs/babel-plugin-istanbul/badge.svg?branch=master)](https://coveralls.io/github/istanbuljs/babel-plugin-istanbul?branch=master) +[![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow.svg)](https://conventionalcommits.org) +[![community slack](http://devtoolscommunity.herokuapp.com/badge.svg)](http://devtoolscommunity.herokuapp.com) + +_Having problems? want to contribute? join our [community slack](http://devtoolscommunity.herokuapp.com)_. + +A Babel plugin that instruments your code with Istanbul coverage. +It can instantly be used with [karma-coverage](https://github.com/karma-runner/karma-coverage) and mocha on Node.js (through [nyc](https://github.com/bcoe/nyc)). + +__Note:__ This plugin does not generate any report or save any data to any file; +it only adds instrumenting code to your JavaScript source code. +To integrate with testing tools, please see the [Integrations](#integrations) section. + +## Usage + +Install it: + +``` +npm install --save-dev babel-plugin-istanbul +``` + +Add it to `.babelrc` in test mode: + +```js +{ + "env": { + "test": { + "plugins": [ "istanbul" ] + } + } +} +``` + +Optionally, use [cross-env](https://www.npmjs.com/package/cross-env) to set +`NODE_ENV=test`: + +```json +{ + "scripts": { + "test": "cross-env NODE_ENV=test nyc --reporter=lcov --reporter=text mocha test/*.js" + } +} +``` + +## Integrations + +### karma + +It _just works_ with Karma. First, make sure that the code is already transpiled by Babel (either using `karma-babel-preprocessor`, `karma-webpack`, or `karma-browserify`). Then, simply set up [karma-coverage](https://github.com/karma-runner/karma-coverage) according to the docs, but __don’t add the `coverage` preprocessor.__ This plugin has already instrumented your code, and Karma should pick it up automatically. + +It has been tested with [bemusic/bemuse](https://codecov.io/github/bemusic/bemuse) project, which contains ~2400 statements. + +### mocha on node.js (through nyc) + +Configure Mocha to transpile JavaScript code using Babel, then you can run your tests with [`nyc`](https://github.com/bcoe/nyc), which will collect all the coverage report. + +babel-plugin-istanbul respects the `include`/`exclude` configuration options from nyc, +but you also need to __configure NYC not to instrument your code__ by adding these settings in your `package.json`: + +```js + "nyc": { + "sourceMap": false, + "instrument": false + }, +``` + +## Ignoring files + +You don't want to cover your test files as this will skew your coverage results. You can configure this by providing plugin options matching nyc's [`exclude`/`include` rules](https://github.com/bcoe/nyc#excluding-files): + +```json +{ + "env": { + "test": { + "plugins": [ + ["istanbul", { + "exclude": [ + "**/*.spec.js" + ] + }] + ] + } + } +} +``` + +If you don't provide options in your Babel config, the plugin will look for `exclude`/`include` config under an `"nyc"` key in `package.json`. + +You can also use [istanbul's ignore hints](https://github.com/gotwarlost/istanbul/blob/master/ignoring-code-for-coverage.md#ignoring-code-for-coverage-purposes) to specify specific lines of code to skip instrumenting. + +## Source Maps + +By default, this plugin will pick up inline source maps and attach them to the instrumented code such that code coverage can be remapped back to the original source, even for multi-step build processes. This can be memory intensive. Set `useInlineSourceMaps` to prevent this behavior. + +```json +{ + "env": { + "test": { + "plugins": [ + ["istanbul", { + "useInlineSourceMaps": false + }] + ] + } + } +} +``` + +If you're instrumenting code programatically, you can pass a source map explicitly. +```js +import babelPluginIstanbul from 'babel-plugin-istanbul'; + +function instrument(sourceCode, sourceMap, fileName) { + return babel.transform(sourceCode, { + filename, + plugins: [ + [babelPluginIstanbul, { + inputSourceMap: sourceMap + }] + ] + }) +} +``` + +## Credit where credit is due + +The approach used in `babel-plugin-istanbul` was inspired by [Thai Pangsakulyanont](https://github.com/dtinth)'s original library [`babel-plugin-__coverage__`](https://github.com/dtinth/babel-plugin-__coverage__). + +## `babel-plugin-istanbul` for enterprise + +Available as part of the Tidelift Subscription. + +The maintainers of `babel-plugin-istanbul` and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-babel-plugin-istanbul?utm_source=npm-babel-plugin-istanbul&utm_medium=referral&utm_campaign=enterprise&utm_term=repo) diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/lib/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/lib/index.js new file mode 100644 index 0000000000000000000000000000000000000000..8cf743330be881aebef098b71d83ad97883f2a15 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/lib/index.js @@ -0,0 +1,170 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _path = _interopRequireDefault(require("path")); + +var _fs = require("fs"); + +var _child_process = require("child_process"); + +var _helperPluginUtils = require("@babel/helper-plugin-utils"); + +var _istanbulLibInstrument = require("istanbul-lib-instrument"); + +var _testExclude = _interopRequireDefault(require("test-exclude")); + +var _schema = _interopRequireDefault(require("@istanbuljs/schema")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function getRealpath(n) { + try { + return (0, _fs.realpathSync)(n) || + /* istanbul ignore next */ + n; + } catch (e) { + /* istanbul ignore next */ + return n; + } +} + +const memoize = new Map(); +/* istanbul ignore next */ + +const memosep = _path.default.sep === '/' ? ':' : ';'; + +function loadNycConfig(cwd, opts) { + let memokey = cwd; + const args = [_path.default.resolve(__dirname, 'load-nyc-config-sync.js'), cwd]; + + if ('nycrcPath' in opts) { + args.push(opts.nycrcPath); + memokey += memosep + opts.nycrcPath; + } + /* execFileSync is expensive, avoid it if possible! */ + + + if (memoize.has(memokey)) { + return memoize.get(memokey); + } + + const result = JSON.parse((0, _child_process.execFileSync)(process.execPath, args)); + const error = result['load-nyc-config-sync-error']; + + if (error) { + throw new Error(error); + } + + const config = { ..._schema.default.defaults.babelPluginIstanbul, + cwd, + ...result + }; + memoize.set(memokey, config); + return config; +} + +function findConfig(opts) { + const cwd = getRealpath(opts.cwd || process.env.NYC_CWD || + /* istanbul ignore next */ + process.cwd()); + const keys = Object.keys(opts); + const ignored = Object.keys(opts).filter(s => s === 'nycrcPath' || s === 'cwd'); + + if (keys.length > ignored.length) { + // explicitly configuring options in babel + // takes precedence. + return { ..._schema.default.defaults.babelPluginIstanbul, + cwd, + ...opts + }; + } + + if (ignored.length === 0 && process.env.NYC_CONFIG) { + // defaults were already applied by nyc + return JSON.parse(process.env.NYC_CONFIG); + } + + return loadNycConfig(cwd, opts); +} + +function makeShouldSkip() { + let exclude; + return function shouldSkip(file, nycConfig) { + if (!exclude || exclude.cwd !== nycConfig.cwd) { + exclude = new _testExclude.default({ + cwd: nycConfig.cwd, + include: nycConfig.include, + exclude: nycConfig.exclude, + extension: nycConfig.extension, + // Make sure this is true unless explicitly set to `false`. `undefined` is still `true`. + excludeNodeModules: nycConfig.excludeNodeModules !== false + }); + } + + return !exclude.shouldInstrument(file); + }; +} + +var _default = (0, _helperPluginUtils.declare)(api => { + api.assertVersion(7); + const shouldSkip = makeShouldSkip(); + const t = api.types; + return { + visitor: { + Program: { + enter(path) { + this.__dv__ = null; + this.nycConfig = findConfig(this.opts); + const realPath = getRealpath(this.file.opts.filename); + + if (shouldSkip(realPath, this.nycConfig)) { + return; + } + + let { + inputSourceMap + } = this.opts; + + if (this.opts.useInlineSourceMaps !== false) { + if (!inputSourceMap && this.file.inputMap) { + inputSourceMap = this.file.inputMap.sourcemap; + } + } + + const visitorOptions = {}; + Object.entries(_schema.default.defaults.instrumentVisitor).forEach(([name, defaultValue]) => { + if (name in this.nycConfig) { + visitorOptions[name] = this.nycConfig[name]; + } else { + visitorOptions[name] = _schema.default.defaults.instrumentVisitor[name]; + } + }); + this.__dv__ = (0, _istanbulLibInstrument.programVisitor)(t, realPath, { ...visitorOptions, + inputSourceMap + }); + + this.__dv__.enter(path); + }, + + exit(path) { + if (!this.__dv__) { + return; + } + + const result = this.__dv__.exit(path); + + if (this.opts.onCover) { + this.opts.onCover(getRealpath(this.file.opts.filename), result.fileCoverage); + } + } + + } + } + }; +}); + +exports.default = _default; \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/lib/load-nyc-config-sync.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/lib/load-nyc-config-sync.js new file mode 100644 index 0000000000000000000000000000000000000000..790679384e1cb337b4bf8532d881f6c00fd02836 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/lib/load-nyc-config-sync.js @@ -0,0 +1,20 @@ +#!/usr/bin/env node +'use strict'; + +const { + loadNycConfig +} = require('@istanbuljs/load-nyc-config'); + +async function main() { + const [cwd, nycrcPath] = process.argv.slice(2); + console.log(JSON.stringify(await loadNycConfig({ + cwd, + nycrcPath + }))); +} + +main().catch(error => { + console.log(JSON.stringify({ + 'load-nyc-config-sync-error': error.message + })); +}); \ No newline at end of file diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/CHANGELOG.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..8b8ac0592155e7a3e22a1e03ebc6cc1b65a87274 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/CHANGELOG.md @@ -0,0 +1,631 @@ +# Change Log + +All notable changes to this project will be documented in this file. +See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. + +## [5.2.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument-v5.2.0...istanbul-lib-instrument-v5.2.1) (2022-10-05) + + +### Bug Fixes + +* handle error when inputSourceMap is not a plain object ([#662](https://github.com/istanbuljs/istanbuljs/issues/662)) ([3e3611f](https://github.com/istanbuljs/istanbuljs/commit/3e3611f0efffefd5f87e6cbccd840e9f33aaf43e)) + +## [5.2.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument-v5.1.0...istanbul-lib-instrument-v5.2.0) (2022-02-21) + + +### Features + +* exclude Empty Object and Arrays in Truthy Detection ([#666](https://github.com/istanbuljs/istanbuljs/issues/666)) ([e279684](https://github.com/istanbuljs/istanbuljs/commit/e279684e735f4b7dbe2b632cde2515f6862099de)) + +## [5.1.0](https://www.github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument-v5.0.4...istanbul-lib-instrument-v5.1.0) (2021-10-27) + + +### Features + +* option to evaluate logical truthiness, for applications such as fuzzing ([#629](https://www.github.com/istanbuljs/istanbuljs/issues/629)) ([a743b84](https://www.github.com/istanbuljs/istanbuljs/commit/a743b8442e977f0c77ffa282eed7ac84ca200d1f)) + +### [5.0.4](https://www.github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument-v5.0.3...istanbul-lib-instrument-v5.0.4) (2021-10-16) + + +### Bug Fixes + +* **magic-value:** make incrementing magic value a manual step ([#641](https://www.github.com/istanbuljs/istanbuljs/issues/641)) ([823010b](https://www.github.com/istanbuljs/istanbuljs/commit/823010b821cf81bd91377d75fc83f0875925db66)) + +### [5.0.3](https://www.github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument-v5.0.2...istanbul-lib-instrument-v5.0.3) (2021-10-06) + + +### Bug Fixes + +* coverage.branchMap else location. ([#633](https://www.github.com/istanbuljs/istanbuljs/issues/633)) ([eb4b4ec](https://www.github.com/istanbuljs/istanbuljs/commit/eb4b4ec8f4b858655a66b0033fcc662f44ef4cc9)) + +### [5.0.2](https://www.github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument-v5.0.1...istanbul-lib-instrument-v5.0.2) (2021-09-13) + + +### Bug Fixes + +* **build:** verfiy automated publication ([b232690](https://www.github.com/istanbuljs/istanbuljs/commit/b232690193f4b524332046c96dd1cdc6e881c6c7)) + +### [5.0.1](https://www.github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument-v5.0.0...istanbul-lib-instrument-v5.0.1) (2021-09-13) + + +### Bug Fixes + +* **build:** verfiy automated publication ([74c96bd](https://www.github.com/istanbuljs/istanbuljs/commit/74c96bdc4224a06e2e1166ebd9adf8faf28438b1)) + +## [5.0.0](https://www.github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument-v4.0.3...istanbul-lib-instrument-v5.0.0) (2021-09-13) + + +### ⚠ BREAKING CHANGES + +* istanbul-lib-instrument no longer uses babel + +### Code Refactoring + +* istanbul-lib-instrument no longer uses babel ([8d3badb](https://www.github.com/istanbuljs/istanbuljs/commit/8d3badb8f6c9a4bed9af8e19c3ac6459ebd7267b)) + +## [4.0.3](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@4.0.2...istanbul-lib-instrument@4.0.3) (2020-05-09) + + +### Bug Fixes + +* Prevent readInitialCoverage from reading babel config ([#562](https://github.com/istanbuljs/istanbuljs/issues/562)) ([49b4745](https://github.com/istanbuljs/istanbuljs/commit/49b474525c15e703642916011bd86f663aca0c3d)) + + + + + +## [4.0.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@4.0.1...istanbul-lib-instrument@4.0.2) (2020-05-06) + + +### Bug Fixes + +* Add ts-ignore to reassignment of generated function ([#557](https://github.com/istanbuljs/istanbuljs/issues/557)) ([817efb0](https://github.com/istanbuljs/istanbuljs/commit/817efb04fc161efae426b2231a0221606b09f559)) +* Use @babel/core for all babel imports. ([#555](https://github.com/istanbuljs/istanbuljs/issues/555)) ([a99a13e](https://github.com/istanbuljs/istanbuljs/commit/a99a13ee6931fc124a2a723c3f511cdbcb0aa81d)) + + + + + +## [4.0.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@4.0.0...istanbul-lib-instrument@4.0.1) (2020-02-03) + + +### Bug Fixes + +* Always call coverage initialization function ([#524](https://github.com/istanbuljs/istanbuljs/issues/524)) ([c6536c1](https://github.com/istanbuljs/istanbuljs/commit/c6536c14bf0663ca7e0493dd40ea132b05352594)) + + + + + +# [4.0.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@4.0.0-alpha.3...istanbul-lib-instrument@4.0.0) (2019-12-20) + +**Note:** Version bump only for package istanbul-lib-instrument + + + + + +# [4.0.0-alpha.3](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@4.0.0-alpha.2...istanbul-lib-instrument@4.0.0-alpha.3) (2019-12-07) + +**Note:** Version bump only for package istanbul-lib-instrument + + + + + +# [4.0.0-alpha.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@4.0.0-alpha.1...istanbul-lib-instrument@4.0.0-alpha.2) (2019-11-01) + + +### Bug Fixes + +* Produce properly merged source-maps when inputSourceMap is provided ([#487](https://github.com/istanbuljs/istanbuljs/issues/487)) ([8f8c88e](https://github.com/istanbuljs/istanbuljs/commit/8f8c88e3a2add4c08729e41e356aa7981dc69d4d)) + + + + + +# [4.0.0-alpha.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@4.0.0-alpha.0...istanbul-lib-instrument@4.0.0-alpha.1) (2019-10-06) + + +### Bug Fixes + +* Eliminate babel hoisting of the coverage variable ([#481](https://github.com/istanbuljs/istanbuljs/issues/481)) ([8dfbcba](https://github.com/istanbuljs/istanbuljs/commit/8dfbcba)), closes [#92](https://github.com/istanbuljs/istanbuljs/issues/92) +* Honor ignore hints in chained if statements ([#469](https://github.com/istanbuljs/istanbuljs/issues/469)) ([a629770](https://github.com/istanbuljs/istanbuljs/commit/a629770)), closes [#468](https://github.com/istanbuljs/istanbuljs/issues/468) +* Populate lastFileCoverage for already instrumented files ([#470](https://github.com/istanbuljs/istanbuljs/issues/470)) ([ea6d779](https://github.com/istanbuljs/istanbuljs/commit/ea6d779)), closes [istanbuljs/nyc#594](https://github.com/istanbuljs/nyc/issues/594) + + +### Features + +* Use @istanbuljs/schema to pull defaults ([#485](https://github.com/istanbuljs/istanbuljs/issues/485)) ([87e27f3](https://github.com/istanbuljs/istanbuljs/commit/87e27f3)), closes [#460](https://github.com/istanbuljs/istanbuljs/issues/460) + + +### BREAKING CHANGES + +* The defaults for `autoWrap`, `preserveComments`, +`esModules` and `produceSourceMap` are now true. This applies only to +the stand-alone instrumenter, the visitor does not use these options. +* The `flow` and `jsx` parser plugins are no longer +enabled by default. This applies only to the stand-alone instrumenter, +the visitor does not use this option. +* The `plugins` option of the stand-alone instrumenter +has been renamed to `parserPlugins` to match nyc. + + + + + +# [4.0.0-alpha.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@3.3.0...istanbul-lib-instrument@4.0.0-alpha.0) (2019-06-19) + + +### Features + +* Update dependencies, require Node.js 8 ([#401](https://github.com/istanbuljs/istanbuljs/issues/401)) ([bf3a539](https://github.com/istanbuljs/istanbuljs/commit/bf3a539)) + + +### BREAKING CHANGES + +* Node.js 8 is now required + + + + + +# [3.3.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@3.2.0...istanbul-lib-instrument@3.3.0) (2019-04-24) + + +### Features + +* Enable classProperties and classPrivateProperties parsers and coverage. ([#379](https://github.com/istanbuljs/istanbuljs/issues/379)) ([c09dc38](https://github.com/istanbuljs/istanbuljs/commit/c09dc38)) + + + + + +# [3.2.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@3.1.2...istanbul-lib-instrument@3.2.0) (2019-04-09) + + +### Features + +* Add bigInt and importMeta to default parser plugins. ([#356](https://github.com/istanbuljs/istanbuljs/issues/356)) ([fb4d6ed](https://github.com/istanbuljs/istanbuljs/commit/fb4d6ed)), closes [#338](https://github.com/istanbuljs/istanbuljs/issues/338) + + + + + +## [3.1.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@3.1.1...istanbul-lib-instrument@3.1.2) (2019-04-03) + + +### Bug Fixes + +* Be more friendly to ts-node. ([#352](https://github.com/istanbuljs/istanbuljs/issues/352)) ([40d15f5](https://github.com/istanbuljs/istanbuljs/commit/40d15f5)), closes [#336](https://github.com/istanbuljs/istanbuljs/issues/336) + + + + + +## [3.1.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@3.1.0...istanbul-lib-instrument@3.1.1) (2019-03-12) + + +### Bug Fixes + +* Honor istanbul ignore next hints placed before export statement. ([#298](https://github.com/istanbuljs/istanbuljs/issues/298)) ([f24795d](https://github.com/istanbuljs/istanbuljs/commit/f24795d)), closes [#297](https://github.com/istanbuljs/istanbuljs/issues/297) + + + + + +# [3.1.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@3.0.1...istanbul-lib-instrument@3.1.0) (2019-01-26) + + +### Features + +* dont skip for loop initialization instrumentation ([#188](https://github.com/istanbuljs/istanbuljs/issues/188)) ([2e0258e](https://github.com/istanbuljs/istanbuljs/commit/2e0258e)) +* New options coverageGlobalScope and coverageGlobalScopeFunc. ([#200](https://github.com/istanbuljs/istanbuljs/issues/200)) ([25509c7](https://github.com/istanbuljs/istanbuljs/commit/25509c7)), closes [#199](https://github.com/istanbuljs/istanbuljs/issues/199) + + + + + + +## [3.0.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@3.0.0...istanbul-lib-instrument@3.0.1) (2018-12-25) + + + + +**Note:** Version bump only for package istanbul-lib-instrument + + +# [3.0.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.3.2...istanbul-lib-instrument@3.0.0) (2018-09-06) + + +### Chores + +* Update test for babel 7. ([#218](https://github.com/istanbuljs/istanbuljs/issues/218)) ([9cf4d43](https://github.com/istanbuljs/istanbuljs/commit/9cf4d43)), closes [#205](https://github.com/istanbuljs/istanbuljs/issues/205) + + +### Features + +* Add option plugins ([#205](https://github.com/istanbuljs/istanbuljs/issues/205)) ([312f81f](https://github.com/istanbuljs/istanbuljs/commit/312f81f)) +* Update babel to 7.0.0. ([#215](https://github.com/istanbuljs/istanbuljs/issues/215)) ([8a96613](https://github.com/istanbuljs/istanbuljs/commit/8a96613)) + + +### BREAKING CHANGES + +* was added which requires an option for the `decorators` +plugin. Add it to get tests working again, commit updated api.md. + + + + + +## [2.3.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.3.1...istanbul-lib-instrument@2.3.2) (2018-07-24) + + + + +**Note:** Version bump only for package istanbul-lib-instrument + + +## [2.3.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.3.0...istanbul-lib-instrument@2.3.1) (2018-07-07) + + +### Bug Fixes + +* Don't ignore src/visitor.js for self test. ([#194](https://github.com/istanbuljs/istanbuljs/issues/194)) ([71b815d](https://github.com/istanbuljs/istanbuljs/commit/71b815d)) + + + + + +# [2.3.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.2.1...istanbul-lib-instrument@2.3.0) (2018-06-27) + + +### Features + +* update pinned babel version to latest release. ([#189](https://github.com/istanbuljs/istanbuljs/issues/189)) ([ac8ec07](https://github.com/istanbuljs/istanbuljs/commit/ac8ec07)) + + + + + +## [2.2.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.2.0...istanbul-lib-instrument@2.2.1) (2018-06-26) + + +### Bug Fixes + +* Instrument ObjectMethod's. ([#182](https://github.com/istanbuljs/istanbuljs/issues/182)) ([126f09d](https://github.com/istanbuljs/istanbuljs/commit/126f09d)) +* update default args test guard to work on supported versions. ([#185](https://github.com/istanbuljs/istanbuljs/issues/185)) ([955511a](https://github.com/istanbuljs/istanbuljs/commit/955511a)) + + + + + +# [2.2.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.0.2...istanbul-lib-instrument@2.2.0) (2018-06-06) + + +### Features + +* add support for optional catch binding ([#175](https://github.com/istanbuljs/istanbuljs/issues/175)) ([088dd9f](https://github.com/istanbuljs/istanbuljs/commit/088dd9f)) + + + + + +# [2.1.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.0.2...istanbul-lib-instrument@2.1.0) (2018-05-31) + + +### Features + +* add support for optional catch binding ([#175](https://github.com/istanbuljs/istanbuljs/issues/175)) ([088dd9f](https://github.com/istanbuljs/istanbuljs/commit/088dd9f)) + + + + + +## [2.0.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.0.1...istanbul-lib-instrument@2.0.2) (2018-05-31) + + + + +**Note:** Version bump only for package istanbul-lib-instrument + + +## [2.0.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.0.0...istanbul-lib-instrument@2.0.1) (2018-05-31) + + +### Bug Fixes + +* should import [@babel](https://github.com/babel)/template ([85a0d1a](https://github.com/istanbuljs/istanbuljs/commit/85a0d1a)) + + + + + +# [2.0.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.10.1...istanbul-lib-instrument@2.0.0) (2018-05-31) + + +### Bug Fixes + +* parenthesize superClass on non-idetifier case ([#158](https://github.com/istanbuljs/istanbuljs/issues/158)) ([6202c88](https://github.com/istanbuljs/istanbuljs/commit/6202c88)) + + +### Chores + +* upgrade babel in instrumenter ([#174](https://github.com/istanbuljs/istanbuljs/issues/174)) ([ce23e91](https://github.com/istanbuljs/istanbuljs/commit/ce23e91)) + + +### BREAKING CHANGES + +* babel@7 drops Node@4 support + + + + + +## [1.10.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.10.0...istanbul-lib-instrument@1.10.1) (2018-03-09) + + +### Bug Fixes + +* default value for ignorelassMethods ([#151](https://github.com/istanbuljs/istanbuljs/issues/151)) ([5dd88e8](https://github.com/istanbuljs/istanbuljs/commit/5dd88e8)) + + + + + +# [1.10.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.9.2...istanbul-lib-instrument@1.10.0) (2018-03-04) + + +### Features + +* allows an array of ignored method names to be provided ([#127](https://github.com/istanbuljs/istanbuljs/issues/127)) ([67918e2](https://github.com/istanbuljs/istanbuljs/commit/67918e2)) + + + + + +## [1.9.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.9.1...istanbul-lib-instrument@1.9.2) (2018-02-13) + + +### Bug Fixes + +* compatibility with babel 7 ([#135](https://github.com/istanbuljs/istanbuljs/issues/135)) ([6cac849](https://github.com/istanbuljs/istanbuljs/commit/6cac849)) +* handle instrumentation when a function is called Function ([#131](https://github.com/istanbuljs/istanbuljs/issues/131)) ([b12a07e](https://github.com/istanbuljs/istanbuljs/commit/b12a07e)) +* proper passing of the preserveComments option to babel ([#122](https://github.com/istanbuljs/istanbuljs/issues/122)) ([470bb0e](https://github.com/istanbuljs/istanbuljs/commit/470bb0e)) +* update instrument, account for lack of arrow expression ([#119](https://github.com/istanbuljs/istanbuljs/issues/119)) ([#125](https://github.com/istanbuljs/istanbuljs/issues/125)) ([0968206](https://github.com/istanbuljs/istanbuljs/commit/0968206)) + + + + + +## [1.9.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.9.0...istanbul-lib-instrument@1.9.1) (2017-10-22) + + +### Bug Fixes + +* address issue with class instrumentation ([#111](https://github.com/istanbuljs/istanbuljs/issues/111)) ([cbd1c14](https://github.com/istanbuljs/istanbuljs/commit/cbd1c14)) + + + + + +# [1.9.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.8.0...istanbul-lib-instrument@1.9.0) (2017-10-21) + + +### Bug Fixes + +* support conditional expression for superClass ([#106](https://github.com/istanbuljs/istanbuljs/issues/106)) ([aae256f](https://github.com/istanbuljs/istanbuljs/commit/aae256f)) + + +### Features + +* add support for ignoring entire files ([#108](https://github.com/istanbuljs/istanbuljs/issues/108)) ([f12da65](https://github.com/istanbuljs/istanbuljs/commit/f12da65)) + + + + + +# [1.8.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.7.5...istanbul-lib-instrument@1.8.0) (2017-09-05) + + +### Features + +* add support for object-spread syntax ([#82](https://github.com/istanbuljs/istanbuljs/issues/82)) ([28d5566](https://github.com/istanbuljs/istanbuljs/commit/28d5566)) + + + + + +## [1.7.5](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.7.4...istanbul-lib-instrument@1.7.5) (2017-08-23) + + +### Bug Fixes + +* name of function is now preserved or named exports ([#79](https://github.com/istanbuljs/istanbuljs/issues/79)) ([2ce8974](https://github.com/istanbuljs/istanbuljs/commit/2ce8974)) + + + + + +## [1.7.4](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.7.3...istanbul-lib-instrument@1.7.4) (2017-07-16) + + +### Bug Fixes + +* update increment operator to appropriate expression type ([#74](https://github.com/istanbuljs/istanbuljs/issues/74)) ([dc69e66](https://github.com/istanbuljs/istanbuljs/commit/dc69e66)) + + + + + +## [1.7.3](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.7.2...istanbul-lib-instrument@1.7.3) (2017-06-25) + + + + + +## [1.7.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.7.1...istanbul-lib-instrument@1.7.2) (2017-05-27) + + +### Bug Fixes + +* hoist statement counter for class variables, so that name is preserved ([#60](https://github.com/istanbuljs/istanbuljs/issues/60)) ([120d221](https://github.com/istanbuljs/istanbuljs/commit/120d221)) + + + + + +## [1.7.1](https://github.com/istanbuljs/istanbul-lib-instrument/compare/istanbul-lib-instrument@1.7.0...istanbul-lib-instrument@1.7.1) (2017-04-29) + + +### Bug Fixes + +* don't instrument a file if it has already been instrumented ([#38](https://github.com/istanbuljs/istanbuljs/issues/38)) ([9c38e4e](https://github.com/istanbuljs/istanbul-lib-instrument/commit/9c38e4e)) + + + + + +# [1.7.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/istanbul-lib-instrument@1.6.2...istanbul-lib-instrument@1.7.0) (2017-03-27) + + +### Features + +* use extended babylon support; adding features such as jsx ([#22](https://github.com/istanbuljs/istanbuljs/issues/22)) ([11c2438](https://github.com/istanbuljs/istanbul-lib-instrument/commit/11c2438)) + + +## [1.6.2](https://github.com/istanbuljs/istanbul-lib-instrument/compare/istanbul-lib-instrument@1.6.1...istanbul-lib-instrument@1.6.2) (2017-03-22) + + +### Bug Fixes + +* loc is sometimes not defined, so loc.start fails see [#99](https://github.com/istanbuljs/istanbuljs/issues/99) ([#18](https://github.com/istanbuljs/istanbuljs/issues/18)) ([df85ba6](https://github.com/istanbuljs/istanbul-lib-instrument/commit/df85ba6)) + + +## [1.6.1](https://github.com/istanbuljs/istanbul-lib-instrument/compare/istanbul-lib-instrument@1.6.0...istanbul-lib-instrument@1.6.1) (2017-03-21) + + +# [1.6.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/istanbul-lib-instrument@1.4.2...istanbul-lib-instrument@1.6.0) (2017-03-21) + + +### Features + +* adds line number property back to coverage.json ([b03b927](https://github.com/istanbuljs/istanbul-lib-instrument/commit/b03b927)) + + +## [1.4.2](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.4.1...v1.4.2) (2017-01-04) + + +### Bug Fixes + +* only hoist counter for a smaller subset of function declarations ([9f8931e](https://github.com/istanbuljs/istanbul-lib-instrument/commit/9f8931e)) + + + + +## [1.4.1](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.4.0...v1.4.1) (2017-01-04) + + +### Bug Fixes + +* address regression discussed in https://github.com/istanbuljs/babel-plugin-istanbul/issues/78 ([#40](https://github.com/istanbuljs/istanbul-lib-instrument/issues/40)) ([7f458a3](https://github.com/istanbuljs/istanbul-lib-instrument/commit/7f458a3)) + + + + +# [1.4.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.3.1...v1.4.0) (2017-01-02) + + +### Features + +* preserve inferred function names ([#38](https://github.com/istanbuljs/istanbul-lib-instrument/issues/38)) ([312666e](https://github.com/istanbuljs/istanbul-lib-instrument/commit/312666e)) + + + + +## [1.3.1](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.3.0...v1.3.1) (2016-12-27) + + +### Bug Fixes + +* function declaration assignment now retains function name ([#33](https://github.com/istanbuljs/istanbul-lib-instrument/issues/33)) ([2d781da](https://github.com/istanbuljs/istanbul-lib-instrument/commit/2d781da)) + + + + +# [1.3.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.2.0...v1.3.0) (2016-11-10) + + +### Features + +* allow an input source-map to be passed to instrumentSync() ([#23](https://github.com/istanbuljs/istanbul-lib-instrument/issues/23)) ([b08e4f5](https://github.com/istanbuljs/istanbul-lib-instrument/commit/b08e4f5)) + + + + +# [1.2.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.4...v1.2.0) (2016-10-25) + + +### Features + +* implement function to extract empty coverage data from an instrumented file ([#28](https://github.com/istanbuljs/istanbul-lib-instrument/issues/28)) ([06d0ef6](https://github.com/istanbuljs/istanbul-lib-instrument/commit/06d0ef6)) + + + + +## [1.1.4](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.3...v1.1.4) (2016-10-17) + + +### Bug Fixes + +* hoist coverage variable to very top of file ([#26](https://github.com/istanbuljs/istanbul-lib-instrument/issues/26)) ([0225e8c](https://github.com/istanbuljs/istanbul-lib-instrument/commit/0225e8c)) + + + + +## [1.1.3](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.2...v1.1.3) (2016-09-13) + + +### Performance Improvements + +* simplify coverage variable naming https://github.com/istanbuljs/istanbul-lib-instrument/pull/24 ([7252aae](https://github.com/istanbuljs/istanbul-lib-instrument/commit/7252aae)) + + + + +## [1.1.2](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.1...v1.1.2) (2016-09-08) + + +### Performance Improvements + +* use zero-based numeric indices for much faster instrumented code ([#22](https://github.com/istanbuljs/istanbul-lib-instrument/issues/22)) ([5b401f5](https://github.com/istanbuljs/istanbul-lib-instrument/commit/5b401f5)) + + + + +## [1.1.1](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.0...v1.1.1) (2016-08-30) + + +### Bug Fixes + +* upgrade istanbul-lib-coverage ([eb9b1f6](https://github.com/istanbuljs/istanbul-lib-instrument/commit/eb9b1f6)) + + + + +# [1.1.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.0-alpha.4...v1.1.0) (2016-08-11) + + +### Bug Fixes + +* guard against invalid loc ([#16](https://github.com/istanbuljs/istanbul-lib-instrument/issues/16)) ([23ebfc3](https://github.com/istanbuljs/istanbul-lib-instrument/commit/23ebfc3)) + + + + +# [1.1.0-alpha.4](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.0.0-alpha.5...v1.1.0-alpha.4) (2016-07-20) + + +### Bug Fixes + +* require more performant babel-generator ([#15](https://github.com/istanbuljs/istanbul-lib-instrument/issues/15)) ([21b2563](https://github.com/istanbuljs/istanbul-lib-instrument/commit/21b2563)) diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..d55d2916eb85ce7dff3bd1e309b9e4045f9a9c8f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/LICENSE @@ -0,0 +1,24 @@ +Copyright 2012-2015 Yahoo! Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of the Yahoo! Inc. nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL YAHOO! INC. BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/README.md new file mode 100644 index 0000000000000000000000000000000000000000..902831cfb69282f6cfd558e9c84efad0f14fcd3f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/README.md @@ -0,0 +1,22 @@ +## istanbul-lib-instrument + +[![Build Status](https://travis-ci.org/istanbuljs/istanbul-lib-instrument.svg?branch=master)](https://travis-ci.org/istanbuljs/istanbul-lib-instrument) + +Istanbul instrumenter library. + +Version 1.1.x now implements instrumentation using `Babel`. The implementation is inspired +by prior art by @dtinth as demonstrated in the `__coverage__` babel plugin. + +It provides 2 "modes" of instrumentation. + +- The old API that is mostly unchanged (except for incompatibilities noted) and + performs the instrumentation using babel as a library. + +- A `programVisitor` function for the Babel AST that can be used by a Babel plugin + to emit instrumentation for ES6 code directly without any source map + processing. This is the preferred path for babel users. The Babel plugin is + called `babel-plugin-istanbul`. + +Incompatibilities and changes to instrumentation behavior can be found in +[v0-changes.md](v0-changes.md). + diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/package.json new file mode 100644 index 0000000000000000000000000000000000000000..bcf03e2e623038500d4845f3ed4a008459464fae --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/package.json @@ -0,0 +1,50 @@ +{ + "name": "istanbul-lib-instrument", + "version": "5.2.1", + "description": "Core istanbul API for JS code coverage", + "author": "Krishnan Anantheswaran ", + "main": "src/index.js", + "files": [ + "src" + ], + "scripts": { + "test": "nyc mocha" + }, + "dependencies": { + "@babel/core": "^7.12.3", + "@babel/parser": "^7.14.7", + "@istanbuljs/schema": "^0.1.2", + "istanbul-lib-coverage": "^3.2.0", + "semver": "^6.3.0" + }, + "devDependencies": { + "@babel/cli": "^7.7.5", + "chai": "^4.2.0", + "clone": "^2.1.2", + "debug": "^4.1.1", + "documentation": "^12.1.4", + "js-yaml": "^3.13.1", + "mocha": "^6.2.3", + "nopt": "^4.0.1", + "nyc": "^15.1.0" + }, + "license": "BSD-3-Clause", + "bugs": { + "url": "https://github.com/istanbuljs/istanbuljs/issues" + }, + "homepage": "https://istanbul.js.org/", + "repository": { + "type": "git", + "url": "git+ssh://git@github.com/istanbuljs/istanbuljs.git", + "directory": "packages/istanbul-lib-instrument" + }, + "keywords": [ + "coverage", + "istanbul", + "js", + "instrumentation" + ], + "engines": { + "node": ">=8" + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/src/constants.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/src/constants.js new file mode 100644 index 0000000000000000000000000000000000000000..2cd402bc0811e8fe1f0a7909774a296dfbcb0aeb --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/src/constants.js @@ -0,0 +1,14 @@ +const { createHash } = require('crypto'); +const { name } = require('../package.json'); +// TODO: increment this version if there are schema changes +// that are not backwards compatible: +const VERSION = '4'; + +const SHA = 'sha1'; +module.exports = { + SHA, + MAGIC_KEY: '_coverageSchema', + MAGIC_VALUE: createHash(SHA) + .update(name + '@' + VERSION) + .digest('hex') +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/src/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/src/index.js new file mode 100644 index 0000000000000000000000000000000000000000..33d2a4c1a6cef000dc5c62bdef80402d55081241 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/src/index.js @@ -0,0 +1,21 @@ +const { defaults } = require('@istanbuljs/schema'); +const Instrumenter = require('./instrumenter'); +const programVisitor = require('./visitor'); +const readInitialCoverage = require('./read-coverage'); + +/** + * createInstrumenter creates a new instrumenter with the + * supplied options. + * @param {Object} opts - instrumenter options. See the documentation + * for the Instrumenter class. + */ +function createInstrumenter(opts) { + return new Instrumenter(opts); +} + +module.exports = { + createInstrumenter, + programVisitor, + readInitialCoverage, + defaultOpts: defaults.instrumenter +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/src/instrumenter.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/src/instrumenter.js new file mode 100644 index 0000000000000000000000000000000000000000..3322e6eb295d632a609ca950cefbcd6c6ae4776f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/src/instrumenter.js @@ -0,0 +1,162 @@ +/* + Copyright 2012-2015, Yahoo Inc. + Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms. + */ +const { transformSync } = require('@babel/core'); +const { defaults } = require('@istanbuljs/schema'); +const programVisitor = require('./visitor'); +const readInitialCoverage = require('./read-coverage'); + +/** + * Instrumenter is the public API for the instrument library. + * It is typically used for ES5 code. For ES6 code that you + * are already running under `babel` use the coverage plugin + * instead. + * @param {Object} opts optional. + * @param {string} [opts.coverageVariable=__coverage__] name of global coverage variable. + * @param {boolean} [opts.reportLogic=false] report boolean value of logical expressions. + * @param {boolean} [opts.preserveComments=false] preserve comments in output. + * @param {boolean} [opts.compact=true] generate compact code. + * @param {boolean} [opts.esModules=false] set to true to instrument ES6 modules. + * @param {boolean} [opts.autoWrap=false] set to true to allow `return` statements outside of functions. + * @param {boolean} [opts.produceSourceMap=false] set to true to produce a source map for the instrumented code. + * @param {Array} [opts.ignoreClassMethods=[]] set to array of class method names to ignore for coverage. + * @param {Function} [opts.sourceMapUrlCallback=null] a callback function that is called when a source map URL + * is found in the original code. This function is called with the source file name and the source map URL. + * @param {boolean} [opts.debug=false] - turn debugging on. + * @param {array} [opts.parserPlugins] - set babel parser plugins, see @istanbuljs/schema for defaults. + * @param {string} [opts.coverageGlobalScope=this] the global coverage variable scope. + * @param {boolean} [opts.coverageGlobalScopeFunc=true] use an evaluated function to find coverageGlobalScope. + */ +class Instrumenter { + constructor(opts = {}) { + this.opts = { + ...defaults.instrumenter, + ...opts + }; + this.fileCoverage = null; + this.sourceMap = null; + } + /** + * instrument the supplied code and track coverage against the supplied + * filename. It throws if invalid code is passed to it. ES5 and ES6 syntax + * is supported. To instrument ES6 modules, make sure that you set the + * `esModules` property to `true` when creating the instrumenter. + * + * @param {string} code - the code to instrument + * @param {string} filename - the filename against which to track coverage. + * @param {object} [inputSourceMap] - the source map that maps the not instrumented code back to it's original form. + * Is assigned to the coverage object and therefore, is available in the json output and can be used to remap the + * coverage to the untranspiled source. + * @returns {string} the instrumented code. + */ + instrumentSync(code, filename, inputSourceMap) { + if (typeof code !== 'string') { + throw new Error('Code must be a string'); + } + filename = filename || String(new Date().getTime()) + '.js'; + const { opts } = this; + let output = {}; + const babelOpts = { + configFile: false, + babelrc: false, + ast: true, + filename: filename || String(new Date().getTime()) + '.js', + inputSourceMap, + sourceMaps: opts.produceSourceMap, + compact: opts.compact, + comments: opts.preserveComments, + parserOpts: { + allowReturnOutsideFunction: opts.autoWrap, + sourceType: opts.esModules ? 'module' : 'script', + plugins: opts.parserPlugins + }, + plugins: [ + [ + ({ types }) => { + const ee = programVisitor(types, filename, { + coverageVariable: opts.coverageVariable, + reportLogic: opts.reportLogic, + coverageGlobalScope: opts.coverageGlobalScope, + coverageGlobalScopeFunc: + opts.coverageGlobalScopeFunc, + ignoreClassMethods: opts.ignoreClassMethods, + inputSourceMap + }); + + return { + visitor: { + Program: { + enter: ee.enter, + exit(path) { + output = ee.exit(path); + } + } + } + }; + } + ] + ] + }; + + const codeMap = transformSync(code, babelOpts); + + if (!output || !output.fileCoverage) { + const initialCoverage = + readInitialCoverage(codeMap.ast) || + /* istanbul ignore next: paranoid check */ {}; + this.fileCoverage = initialCoverage.coverageData; + this.sourceMap = inputSourceMap; + return code; + } + + this.fileCoverage = output.fileCoverage; + this.sourceMap = codeMap.map; + const cb = this.opts.sourceMapUrlCallback; + if (cb && output.sourceMappingURL) { + cb(filename, output.sourceMappingURL); + } + + return codeMap.code; + } + /** + * callback-style instrument method that calls back with an error + * as opposed to throwing one. Note that in the current implementation, + * the callback will be called in the same process tick and is not asynchronous. + * + * @param {string} code - the code to instrument + * @param {string} filename - the filename against which to track coverage. + * @param {Function} callback - the callback + * @param {Object} inputSourceMap - the source map that maps the not instrumented code back to it's original form. + * Is assigned to the coverage object and therefore, is available in the json output and can be used to remap the + * coverage to the untranspiled source. + */ + instrument(code, filename, callback, inputSourceMap) { + if (!callback && typeof filename === 'function') { + callback = filename; + filename = null; + } + try { + const out = this.instrumentSync(code, filename, inputSourceMap); + callback(null, out); + } catch (ex) { + callback(ex); + } + } + /** + * returns the file coverage object for the last file instrumented. + * @returns {Object} the file coverage object. + */ + lastFileCoverage() { + return this.fileCoverage; + } + /** + * returns the source map produced for the last file instrumented. + * @returns {null|Object} the source map object. + */ + lastSourceMap() { + return this.sourceMap; + } +} + +module.exports = Instrumenter; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/src/read-coverage.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/src/read-coverage.js new file mode 100644 index 0000000000000000000000000000000000000000..5b76dbb1d57328b1494ec6dad5f5618d91ef1e2e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/src/read-coverage.js @@ -0,0 +1,77 @@ +const { parseSync, traverse } = require('@babel/core'); +const { defaults } = require('@istanbuljs/schema'); +const { MAGIC_KEY, MAGIC_VALUE } = require('./constants'); + +function getAst(code) { + if (typeof code === 'object' && typeof code.type === 'string') { + // Assume code is already a babel ast. + return code; + } + + if (typeof code !== 'string') { + throw new Error('Code must be a string'); + } + + // Parse as leniently as possible + return parseSync(code, { + babelrc: false, + configFile: false, + parserOpts: { + allowAwaitOutsideFunction: true, + allowImportExportEverywhere: true, + allowReturnOutsideFunction: true, + allowSuperOutsideMethod: true, + sourceType: 'script', + plugins: defaults.instrumenter.parserPlugins + } + }); +} + +module.exports = function readInitialCoverage(code) { + const ast = getAst(code); + + let covScope; + traverse(ast, { + ObjectProperty(path) { + const { node } = path; + if ( + !node.computed && + path.get('key').isIdentifier() && + node.key.name === MAGIC_KEY + ) { + const magicValue = path.get('value').evaluate(); + if (!magicValue.confident || magicValue.value !== MAGIC_VALUE) { + return; + } + covScope = + path.scope.getFunctionParent() || + path.scope.getProgramParent(); + path.stop(); + } + } + }); + + if (!covScope) { + return null; + } + + const result = {}; + + for (const key of ['path', 'hash', 'gcv', 'coverageData']) { + const binding = covScope.getOwnBinding(key); + if (!binding) { + return null; + } + const valuePath = binding.path.get('init'); + const value = valuePath.evaluate(); + if (!value.confident) { + return null; + } + result[key] = value.value; + } + + delete result.coverageData[MAGIC_KEY]; + delete result.coverageData.hash; + + return result; +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/src/source-coverage.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/src/source-coverage.js new file mode 100644 index 0000000000000000000000000000000000000000..ec3f234d5d11b21297c4b7da44d2fd60c212f31c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/src/source-coverage.js @@ -0,0 +1,135 @@ +const { classes } = require('istanbul-lib-coverage'); + +function cloneLocation(loc) { + return { + start: { + line: loc && loc.start.line, + column: loc && loc.start.column + }, + end: { + line: loc && loc.end.line, + column: loc && loc.end.column + } + }; +} +/** + * SourceCoverage provides mutation methods to manipulate the structure of + * a file coverage object. Used by the instrumenter to create a full coverage + * object for a file incrementally. + * + * @private + * @param pathOrObj {String|Object} - see the argument for {@link FileCoverage} + * @extends FileCoverage + * @constructor + */ +class SourceCoverage extends classes.FileCoverage { + constructor(pathOrObj) { + super(pathOrObj); + this.meta = { + last: { + s: 0, + f: 0, + b: 0 + } + }; + } + + newStatement(loc) { + const s = this.meta.last.s; + this.data.statementMap[s] = cloneLocation(loc); + this.data.s[s] = 0; + this.meta.last.s += 1; + return s; + } + + newFunction(name, decl, loc) { + const f = this.meta.last.f; + name = name || '(anonymous_' + f + ')'; + this.data.fnMap[f] = { + name, + decl: cloneLocation(decl), + loc: cloneLocation(loc), + // DEPRECATED: some legacy reports require this info. + line: loc && loc.start.line + }; + this.data.f[f] = 0; + this.meta.last.f += 1; + return f; + } + + newBranch(type, loc, isReportLogic = false) { + const b = this.meta.last.b; + this.data.b[b] = []; + this.data.branchMap[b] = { + loc: cloneLocation(loc), + type, + locations: [], + // DEPRECATED: some legacy reports require this info. + line: loc && loc.start.line + }; + this.meta.last.b += 1; + this.maybeNewBranchTrue(type, b, isReportLogic); + return b; + } + + maybeNewBranchTrue(type, name, isReportLogic) { + if (!isReportLogic) { + return; + } + if (type !== 'binary-expr') { + return; + } + this.data.bT = this.data.bT || {}; + this.data.bT[name] = []; + } + + addBranchPath(name, location) { + const bMeta = this.data.branchMap[name]; + const counts = this.data.b[name]; + + /* istanbul ignore if: paranoid check */ + if (!bMeta) { + throw new Error('Invalid branch ' + name); + } + bMeta.locations.push(cloneLocation(location)); + counts.push(0); + this.maybeAddBranchTrue(name); + return counts.length - 1; + } + + maybeAddBranchTrue(name) { + if (!this.data.bT) { + return; + } + const countsTrue = this.data.bT[name]; + if (!countsTrue) { + return; + } + countsTrue.push(0); + } + + /** + * Assigns an input source map to the coverage that can be used + * to remap the coverage output to the original source + * @param sourceMap {object} the source map + */ + inputSourceMap(sourceMap) { + this.data.inputSourceMap = sourceMap; + } + + freeze() { + // prune empty branches + const map = this.data.branchMap; + const branches = this.data.b; + const branchesT = this.data.bT || {}; + Object.keys(map).forEach(b => { + if (map[b].locations.length === 0) { + delete map[b]; + delete branches[b]; + delete branchesT[b]; + } + }); + } +} + +module.exports = { SourceCoverage }; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/src/visitor.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/src/visitor.js new file mode 100644 index 0000000000000000000000000000000000000000..46c71290d05c04c8f07a4421e9aab6cdbd74ec6e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/src/visitor.js @@ -0,0 +1,843 @@ +const { createHash } = require('crypto'); +const { template } = require('@babel/core'); +const { defaults } = require('@istanbuljs/schema'); +const { SourceCoverage } = require('./source-coverage'); +const { SHA, MAGIC_KEY, MAGIC_VALUE } = require('./constants'); + +// pattern for istanbul to ignore a section +const COMMENT_RE = /^\s*istanbul\s+ignore\s+(if|else|next)(?=\W|$)/; +// pattern for istanbul to ignore the whole file +const COMMENT_FILE_RE = /^\s*istanbul\s+ignore\s+(file)(?=\W|$)/; +// source map URL pattern +const SOURCE_MAP_RE = /[#@]\s*sourceMappingURL=(.*)\s*$/m; + +// generate a variable name from hashing the supplied file path +function genVar(filename) { + const hash = createHash(SHA); + hash.update(filename); + return 'cov_' + parseInt(hash.digest('hex').substr(0, 12), 16).toString(36); +} + +// VisitState holds the state of the visitor, provides helper functions +// and is the `this` for the individual coverage visitors. +class VisitState { + constructor( + types, + sourceFilePath, + inputSourceMap, + ignoreClassMethods = [], + reportLogic = false + ) { + this.varName = genVar(sourceFilePath); + this.attrs = {}; + this.nextIgnore = null; + this.cov = new SourceCoverage(sourceFilePath); + + if (typeof inputSourceMap !== 'undefined') { + this.cov.inputSourceMap(inputSourceMap); + } + this.ignoreClassMethods = ignoreClassMethods; + this.types = types; + this.sourceMappingURL = null; + this.reportLogic = reportLogic; + } + + // should we ignore the node? Yes, if specifically ignoring + // or if the node is generated. + shouldIgnore(path) { + return this.nextIgnore || !path.node.loc; + } + + // extract the ignore comment hint (next|if|else) or null + hintFor(node) { + let hint = null; + if (node.leadingComments) { + node.leadingComments.forEach(c => { + const v = ( + c.value || /* istanbul ignore next: paranoid check */ '' + ).trim(); + const groups = v.match(COMMENT_RE); + if (groups) { + hint = groups[1]; + } + }); + } + return hint; + } + + // extract a source map URL from comments and keep track of it + maybeAssignSourceMapURL(node) { + const extractURL = comments => { + if (!comments) { + return; + } + comments.forEach(c => { + const v = ( + c.value || /* istanbul ignore next: paranoid check */ '' + ).trim(); + const groups = v.match(SOURCE_MAP_RE); + if (groups) { + this.sourceMappingURL = groups[1]; + } + }); + }; + extractURL(node.leadingComments); + extractURL(node.trailingComments); + } + + // for these expressions the statement counter needs to be hoisted, so + // function name inference can be preserved + counterNeedsHoisting(path) { + return ( + path.isFunctionExpression() || + path.isArrowFunctionExpression() || + path.isClassExpression() + ); + } + + // all the generic stuff that needs to be done on enter for every node + onEnter(path) { + const n = path.node; + + this.maybeAssignSourceMapURL(n); + + // if already ignoring, nothing more to do + if (this.nextIgnore !== null) { + return; + } + // check hint to see if ignore should be turned on + const hint = this.hintFor(n); + if (hint === 'next') { + this.nextIgnore = n; + return; + } + // else check custom node attribute set by a prior visitor + if (this.getAttr(path.node, 'skip-all') !== null) { + this.nextIgnore = n; + } + + // else check for ignored class methods + if ( + path.isFunctionExpression() && + this.ignoreClassMethods.some( + name => path.node.id && name === path.node.id.name + ) + ) { + this.nextIgnore = n; + return; + } + if ( + path.isClassMethod() && + this.ignoreClassMethods.some(name => name === path.node.key.name) + ) { + this.nextIgnore = n; + return; + } + } + + // all the generic stuff on exit of a node, + // including reseting ignores and custom node attrs + onExit(path) { + // restore ignore status, if needed + if (path.node === this.nextIgnore) { + this.nextIgnore = null; + } + // nuke all attributes for the node + delete path.node.__cov__; + } + + // set a node attribute for the supplied node + setAttr(node, name, value) { + node.__cov__ = node.__cov__ || {}; + node.__cov__[name] = value; + } + + // retrieve a node attribute for the supplied node or null + getAttr(node, name) { + const c = node.__cov__; + if (!c) { + return null; + } + return c[name]; + } + + // + increase(type, id, index) { + const T = this.types; + const wrap = + index !== null + ? // If `index` present, turn `x` into `x[index]`. + x => T.memberExpression(x, T.numericLiteral(index), true) + : x => x; + return T.updateExpression( + '++', + wrap( + T.memberExpression( + T.memberExpression( + T.callExpression(T.identifier(this.varName), []), + T.identifier(type) + ), + T.numericLiteral(id), + true + ) + ) + ); + } + + // Reads the logic expression conditions and conditionally increments truthy counter. + increaseTrue(type, id, index, node) { + const T = this.types; + const tempName = `${this.varName}_temp`; + + return T.sequenceExpression([ + T.assignmentExpression( + '=', + T.memberExpression( + T.callExpression(T.identifier(this.varName), []), + T.identifier(tempName) + ), + node // Only evaluates once. + ), + T.parenthesizedExpression( + T.conditionalExpression( + this.validateTrueNonTrivial(T, tempName), + this.increase(type, id, index), + T.nullLiteral() + ) + ), + T.memberExpression( + T.callExpression(T.identifier(this.varName), []), + T.identifier(tempName) + ) + ]); + } + + validateTrueNonTrivial(T, tempName) { + return T.logicalExpression( + '&&', + T.memberExpression( + T.callExpression(T.identifier(this.varName), []), + T.identifier(tempName) + ), + T.logicalExpression( + '&&', + T.parenthesizedExpression( + T.logicalExpression( + '||', + T.unaryExpression( + '!', + T.callExpression( + T.memberExpression( + T.identifier('Array'), + T.identifier('isArray') + ), + [ + T.memberExpression( + T.callExpression( + T.identifier(this.varName), + [] + ), + T.identifier(tempName) + ) + ] + ) + ), + T.memberExpression( + T.memberExpression( + T.callExpression( + T.identifier(this.varName), + [] + ), + T.identifier(tempName) + ), + T.identifier('length') + ) + ) + ), + T.parenthesizedExpression( + T.logicalExpression( + '||', + T.binaryExpression( + '!==', + T.callExpression( + T.memberExpression( + T.identifier('Object'), + T.identifier('getPrototypeOf') + ), + [ + T.memberExpression( + T.callExpression( + T.identifier(this.varName), + [] + ), + T.identifier(tempName) + ) + ] + ), + T.memberExpression( + T.identifier('Object'), + T.identifier('prototype') + ) + ), + T.memberExpression( + T.callExpression( + T.memberExpression( + T.identifier('Object'), + T.identifier('values') + ), + [ + T.memberExpression( + T.callExpression( + T.identifier(this.varName), + [] + ), + T.identifier(tempName) + ) + ] + ), + T.identifier('length') + ) + ) + ) + ) + ); + } + + insertCounter(path, increment) { + const T = this.types; + if (path.isBlockStatement()) { + path.node.body.unshift(T.expressionStatement(increment)); + } else if (path.isStatement()) { + path.insertBefore(T.expressionStatement(increment)); + } else if ( + this.counterNeedsHoisting(path) && + T.isVariableDeclarator(path.parentPath) + ) { + // make an attempt to hoist the statement counter, so that + // function names are maintained. + const parent = path.parentPath.parentPath; + if (parent && T.isExportNamedDeclaration(parent.parentPath)) { + parent.parentPath.insertBefore( + T.expressionStatement(increment) + ); + } else if ( + parent && + (T.isProgram(parent.parentPath) || + T.isBlockStatement(parent.parentPath)) + ) { + parent.insertBefore(T.expressionStatement(increment)); + } else { + path.replaceWith(T.sequenceExpression([increment, path.node])); + } + } /* istanbul ignore else: not expected */ else if ( + path.isExpression() + ) { + path.replaceWith(T.sequenceExpression([increment, path.node])); + } else { + console.error( + 'Unable to insert counter for node type:', + path.node.type + ); + } + } + + insertStatementCounter(path) { + /* istanbul ignore if: paranoid check */ + if (!(path.node && path.node.loc)) { + return; + } + const index = this.cov.newStatement(path.node.loc); + const increment = this.increase('s', index, null); + this.insertCounter(path, increment); + } + + insertFunctionCounter(path) { + const T = this.types; + /* istanbul ignore if: paranoid check */ + if (!(path.node && path.node.loc)) { + return; + } + const n = path.node; + + let dloc = null; + // get location for declaration + switch (n.type) { + case 'FunctionDeclaration': + case 'FunctionExpression': + /* istanbul ignore else: paranoid check */ + if (n.id) { + dloc = n.id.loc; + } + break; + } + if (!dloc) { + dloc = { + start: n.loc.start, + end: { line: n.loc.start.line, column: n.loc.start.column + 1 } + }; + } + + const name = path.node.id ? path.node.id.name : path.node.name; + const index = this.cov.newFunction(name, dloc, path.node.body.loc); + const increment = this.increase('f', index, null); + const body = path.get('body'); + /* istanbul ignore else: not expected */ + if (body.isBlockStatement()) { + body.node.body.unshift(T.expressionStatement(increment)); + } else { + console.error( + 'Unable to process function body node type:', + path.node.type + ); + } + } + + getBranchIncrement(branchName, loc) { + const index = this.cov.addBranchPath(branchName, loc); + return this.increase('b', branchName, index); + } + + getBranchLogicIncrement(path, branchName, loc) { + const index = this.cov.addBranchPath(branchName, loc); + return [ + this.increase('b', branchName, index), + this.increaseTrue('bT', branchName, index, path.node) + ]; + } + + insertBranchCounter(path, branchName, loc) { + const increment = this.getBranchIncrement( + branchName, + loc || path.node.loc + ); + this.insertCounter(path, increment); + } + + findLeaves(node, accumulator, parent, property) { + if (!node) { + return; + } + if (node.type === 'LogicalExpression') { + const hint = this.hintFor(node); + if (hint !== 'next') { + this.findLeaves(node.left, accumulator, node, 'left'); + this.findLeaves(node.right, accumulator, node, 'right'); + } + } else { + accumulator.push({ + node, + parent, + property + }); + } + } +} + +// generic function that takes a set of visitor methods and +// returns a visitor object with `enter` and `exit` properties, +// such that: +// +// * standard entry processing is done +// * the supplied visitors are called only when ignore is not in effect +// This relieves them from worrying about ignore states and generated nodes. +// * standard exit processing is done +// +function entries(...enter) { + // the enter function + const wrappedEntry = function(path, node) { + this.onEnter(path); + if (this.shouldIgnore(path)) { + return; + } + enter.forEach(e => { + e.call(this, path, node); + }); + }; + const exit = function(path, node) { + this.onExit(path, node); + }; + return { + enter: wrappedEntry, + exit + }; +} + +function coverStatement(path) { + this.insertStatementCounter(path); +} + +/* istanbul ignore next: no node.js support */ +function coverAssignmentPattern(path) { + const n = path.node; + const b = this.cov.newBranch('default-arg', n.loc); + this.insertBranchCounter(path.get('right'), b); +} + +function coverFunction(path) { + this.insertFunctionCounter(path); +} + +function coverVariableDeclarator(path) { + this.insertStatementCounter(path.get('init')); +} + +function coverClassPropDeclarator(path) { + this.insertStatementCounter(path.get('value')); +} + +function makeBlock(path) { + const T = this.types; + if (!path.node) { + path.replaceWith(T.blockStatement([])); + } + if (!path.isBlockStatement()) { + path.replaceWith(T.blockStatement([path.node])); + path.node.loc = path.node.body[0].loc; + path.node.body[0].leadingComments = path.node.leadingComments; + path.node.leadingComments = undefined; + } +} + +function blockProp(prop) { + return function(path) { + makeBlock.call(this, path.get(prop)); + }; +} + +function makeParenthesizedExpressionForNonIdentifier(path) { + const T = this.types; + if (path.node && !path.isIdentifier()) { + path.replaceWith(T.parenthesizedExpression(path.node)); + } +} + +function parenthesizedExpressionProp(prop) { + return function(path) { + makeParenthesizedExpressionForNonIdentifier.call(this, path.get(prop)); + }; +} + +function convertArrowExpression(path) { + const n = path.node; + const T = this.types; + if (!T.isBlockStatement(n.body)) { + const bloc = n.body.loc; + if (n.expression === true) { + n.expression = false; + } + n.body = T.blockStatement([T.returnStatement(n.body)]); + // restore body location + n.body.loc = bloc; + // set up the location for the return statement so it gets + // instrumented + n.body.body[0].loc = bloc; + } +} + +function coverIfBranches(path) { + const n = path.node; + const hint = this.hintFor(n); + const ignoreIf = hint === 'if'; + const ignoreElse = hint === 'else'; + const branch = this.cov.newBranch('if', n.loc); + + if (ignoreIf) { + this.setAttr(n.consequent, 'skip-all', true); + } else { + this.insertBranchCounter(path.get('consequent'), branch, n.loc); + } + if (ignoreElse) { + this.setAttr(n.alternate, 'skip-all', true); + } else { + this.insertBranchCounter(path.get('alternate'), branch); + } +} + +function createSwitchBranch(path) { + const b = this.cov.newBranch('switch', path.node.loc); + this.setAttr(path.node, 'branchName', b); +} + +function coverSwitchCase(path) { + const T = this.types; + const b = this.getAttr(path.parentPath.node, 'branchName'); + /* istanbul ignore if: paranoid check */ + if (b === null) { + throw new Error('Unable to get switch branch name'); + } + const increment = this.getBranchIncrement(b, path.node.loc); + path.node.consequent.unshift(T.expressionStatement(increment)); +} + +function coverTernary(path) { + const n = path.node; + const branch = this.cov.newBranch('cond-expr', path.node.loc); + const cHint = this.hintFor(n.consequent); + const aHint = this.hintFor(n.alternate); + + if (cHint !== 'next') { + this.insertBranchCounter(path.get('consequent'), branch); + } + if (aHint !== 'next') { + this.insertBranchCounter(path.get('alternate'), branch); + } +} + +function coverLogicalExpression(path) { + const T = this.types; + if (path.parentPath.node.type === 'LogicalExpression') { + return; // already processed + } + const leaves = []; + this.findLeaves(path.node, leaves); + const b = this.cov.newBranch( + 'binary-expr', + path.node.loc, + this.reportLogic + ); + for (let i = 0; i < leaves.length; i += 1) { + const leaf = leaves[i]; + const hint = this.hintFor(leaf.node); + if (hint === 'next') { + continue; + } + + if (this.reportLogic) { + const increment = this.getBranchLogicIncrement( + leaf, + b, + leaf.node.loc + ); + if (!increment[0]) { + continue; + } + leaf.parent[leaf.property] = T.sequenceExpression([ + increment[0], + increment[1] + ]); + continue; + } + + const increment = this.getBranchIncrement(b, leaf.node.loc); + if (!increment) { + continue; + } + leaf.parent[leaf.property] = T.sequenceExpression([ + increment, + leaf.node + ]); + } +} + +const codeVisitor = { + ArrowFunctionExpression: entries(convertArrowExpression, coverFunction), + AssignmentPattern: entries(coverAssignmentPattern), + BlockStatement: entries(), // ignore processing only + ExportDefaultDeclaration: entries(), // ignore processing only + ExportNamedDeclaration: entries(), // ignore processing only + ClassMethod: entries(coverFunction), + ClassDeclaration: entries(parenthesizedExpressionProp('superClass')), + ClassProperty: entries(coverClassPropDeclarator), + ClassPrivateProperty: entries(coverClassPropDeclarator), + ObjectMethod: entries(coverFunction), + ExpressionStatement: entries(coverStatement), + BreakStatement: entries(coverStatement), + ContinueStatement: entries(coverStatement), + DebuggerStatement: entries(coverStatement), + ReturnStatement: entries(coverStatement), + ThrowStatement: entries(coverStatement), + TryStatement: entries(coverStatement), + VariableDeclaration: entries(), // ignore processing only + VariableDeclarator: entries(coverVariableDeclarator), + IfStatement: entries( + blockProp('consequent'), + blockProp('alternate'), + coverStatement, + coverIfBranches + ), + ForStatement: entries(blockProp('body'), coverStatement), + ForInStatement: entries(blockProp('body'), coverStatement), + ForOfStatement: entries(blockProp('body'), coverStatement), + WhileStatement: entries(blockProp('body'), coverStatement), + DoWhileStatement: entries(blockProp('body'), coverStatement), + SwitchStatement: entries(createSwitchBranch, coverStatement), + SwitchCase: entries(coverSwitchCase), + WithStatement: entries(blockProp('body'), coverStatement), + FunctionDeclaration: entries(coverFunction), + FunctionExpression: entries(coverFunction), + LabeledStatement: entries(coverStatement), + ConditionalExpression: entries(coverTernary), + LogicalExpression: entries(coverLogicalExpression) +}; +const globalTemplateAlteredFunction = template(` + var Function = (function(){}).constructor; + var global = (new Function(GLOBAL_COVERAGE_SCOPE))(); +`); +const globalTemplateFunction = template(` + var global = (new Function(GLOBAL_COVERAGE_SCOPE))(); +`); +const globalTemplateVariable = template(` + var global = GLOBAL_COVERAGE_SCOPE; +`); +// the template to insert at the top of the program. +const coverageTemplate = template( + ` + function COVERAGE_FUNCTION () { + var path = PATH; + var hash = HASH; + GLOBAL_COVERAGE_TEMPLATE + var gcv = GLOBAL_COVERAGE_VAR; + var coverageData = INITIAL; + var coverage = global[gcv] || (global[gcv] = {}); + if (!coverage[path] || coverage[path].hash !== hash) { + coverage[path] = coverageData; + } + + var actualCoverage = coverage[path]; + { + // @ts-ignore + COVERAGE_FUNCTION = function () { + return actualCoverage; + } + } + + return actualCoverage; + } +`, + { preserveComments: true } +); +// the rewire plugin (and potentially other babel middleware) +// may cause files to be instrumented twice, see: +// https://github.com/istanbuljs/babel-plugin-istanbul/issues/94 +// we should only instrument code for coverage the first time +// it's run through istanbul-lib-instrument. +function alreadyInstrumented(path, visitState) { + return path.scope.hasBinding(visitState.varName); +} +function shouldIgnoreFile(programNode) { + return ( + programNode.parent && + programNode.parent.comments.some(c => COMMENT_FILE_RE.test(c.value)) + ); +} + +/** + * programVisitor is a `babel` adaptor for instrumentation. + * It returns an object with two methods `enter` and `exit`. + * These should be assigned to or called from `Program` entry and exit functions + * in a babel visitor. + * These functions do not make assumptions about the state set by Babel and thus + * can be used in a context other than a Babel plugin. + * + * The exit function returns an object that currently has the following keys: + * + * `fileCoverage` - the file coverage object created for the source file. + * `sourceMappingURL` - any source mapping URL found when processing the file. + * + * @param {Object} types - an instance of babel-types. + * @param {string} sourceFilePath - the path to source file. + * @param {Object} opts - additional options. + * @param {string} [opts.coverageVariable=__coverage__] the global coverage variable name. + * @param {boolean} [opts.reportLogic=false] report boolean value of logical expressions. + * @param {string} [opts.coverageGlobalScope=this] the global coverage variable scope. + * @param {boolean} [opts.coverageGlobalScopeFunc=true] use an evaluated function to find coverageGlobalScope. + * @param {Array} [opts.ignoreClassMethods=[]] names of methods to ignore by default on classes. + * @param {object} [opts.inputSourceMap=undefined] the input source map, that maps the uninstrumented code back to the + * original code. + */ +function programVisitor(types, sourceFilePath = 'unknown.js', opts = {}) { + const T = types; + opts = { + ...defaults.instrumentVisitor, + ...opts + }; + const visitState = new VisitState( + types, + sourceFilePath, + opts.inputSourceMap, + opts.ignoreClassMethods, + opts.reportLogic + ); + return { + enter(path) { + if (shouldIgnoreFile(path.find(p => p.isProgram()))) { + return; + } + if (alreadyInstrumented(path, visitState)) { + return; + } + path.traverse(codeVisitor, visitState); + }, + exit(path) { + if (alreadyInstrumented(path, visitState)) { + return; + } + visitState.cov.freeze(); + const coverageData = visitState.cov.toJSON(); + if (shouldIgnoreFile(path.find(p => p.isProgram()))) { + return { + fileCoverage: coverageData, + sourceMappingURL: visitState.sourceMappingURL + }; + } + coverageData[MAGIC_KEY] = MAGIC_VALUE; + const hash = createHash(SHA) + .update(JSON.stringify(coverageData)) + .digest('hex'); + coverageData.hash = hash; + if ( + coverageData.inputSourceMap && + Object.getPrototypeOf(coverageData.inputSourceMap) !== + Object.prototype + ) { + coverageData.inputSourceMap = { + ...coverageData.inputSourceMap + }; + } + const coverageNode = T.valueToNode(coverageData); + delete coverageData[MAGIC_KEY]; + delete coverageData.hash; + let gvTemplate; + if (opts.coverageGlobalScopeFunc) { + if (path.scope.getBinding('Function')) { + gvTemplate = globalTemplateAlteredFunction({ + GLOBAL_COVERAGE_SCOPE: T.stringLiteral( + 'return ' + opts.coverageGlobalScope + ) + }); + } else { + gvTemplate = globalTemplateFunction({ + GLOBAL_COVERAGE_SCOPE: T.stringLiteral( + 'return ' + opts.coverageGlobalScope + ) + }); + } + } else { + gvTemplate = globalTemplateVariable({ + GLOBAL_COVERAGE_SCOPE: opts.coverageGlobalScope + }); + } + const cv = coverageTemplate({ + GLOBAL_COVERAGE_VAR: T.stringLiteral(opts.coverageVariable), + GLOBAL_COVERAGE_TEMPLATE: gvTemplate, + COVERAGE_FUNCTION: T.identifier(visitState.varName), + PATH: T.stringLiteral(sourceFilePath), + INITIAL: coverageNode, + HASH: T.stringLiteral(hash) + }); + // explicitly call this.varName to ensure coverage is always initialized + path.node.body.unshift( + T.expressionStatement( + T.callExpression(T.identifier(visitState.varName), []) + ) + ); + path.node.body.unshift(cv); + return { + fileCoverage: coverageData, + sourceMappingURL: visitState.sourceMappingURL + }; + } + }; +} + +module.exports = programVisitor; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/package.json new file mode 100644 index 0000000000000000000000000000000000000000..2b58513921d40cba72ce6fefff035085bb766168 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/babel-plugin-istanbul/package.json @@ -0,0 +1,71 @@ +{ + "name": "babel-plugin-istanbul", + "version": "6.1.1", + "author": "Thai Pangsakulyanont @dtinth", + "license": "BSD-3-Clause", + "description": "A babel plugin that adds istanbul instrumentation to ES6 code", + "main": "lib/index.js", + "files": [ + "lib" + ], + "dependencies": { + "@babel/helper-plugin-utils": "^7.0.0", + "@istanbuljs/load-nyc-config": "^1.0.0", + "@istanbuljs/schema": "^0.1.2", + "istanbul-lib-instrument": "^5.0.4", + "test-exclude": "^6.0.0" + }, + "devDependencies": { + "@babel/cli": "^7.7.5", + "@babel/core": "^7.7.5", + "@babel/plugin-transform-modules-commonjs": "^7.7.5", + "@babel/register": "^7.7.4", + "chai": "^4.2.0", + "coveralls": "^3.0.9", + "cross-env": "^6.0.3", + "mocha": "^6.2.2", + "nyc": "^15.0.0", + "pmock": "^0.2.3", + "standard": "^14.3.1" + }, + "scripts": { + "coverage": "nyc report --reporter=text-lcov | coveralls", + "release": "babel src --out-dir lib", + "pretest": "standard && npm run release", + "test": "cross-env NODE_ENV=test nyc --reporter=lcov --reporter=text mocha --timeout 5000 test/*.js", + "prepublish": "npm test && npm run release" + }, + "standard": { + "ignore": [ + "fixtures/*.js" + ] + }, + "repository": { + "type": "git", + "url": "git+https://github.com/istanbuljs/babel-plugin-istanbul.git" + }, + "keywords": [ + "istanbul", + "babel", + "plugin", + "instrumentation" + ], + "nyc": { + "include": [ + "src/*.js", + "fixtures/should-cover.js" + ], + "require": [ + "@babel/register" + ], + "sourceMap": false, + "instrument": false + }, + "bugs": { + "url": "https://github.com/istanbuljs/babel-plugin-istanbul/issues" + }, + "homepage": "https://github.com/istanbuljs/babel-plugin-istanbul#readme", + "engines": { + "node": ">=8" + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/glob/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/glob/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..42ca266df1d523bb9ae66a8cf8893325ac43159d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/glob/LICENSE @@ -0,0 +1,21 @@ +The ISC License + +Copyright (c) Isaac Z. Schlueter and Contributors + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +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. + +## Glob Logo + +Glob's logo created by Tanya Brassie , licensed +under a Creative Commons Attribution-ShareAlike 4.0 International License +https://creativecommons.org/licenses/by-sa/4.0/ diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/glob/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/glob/README.md new file mode 100644 index 0000000000000000000000000000000000000000..83f0c83a0c19ed8350aaad037acc28195542e4c4 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/glob/README.md @@ -0,0 +1,378 @@ +# Glob + +Match files using the patterns the shell uses, like stars and stuff. + +[![Build Status](https://travis-ci.org/isaacs/node-glob.svg?branch=master)](https://travis-ci.org/isaacs/node-glob/) [![Build Status](https://ci.appveyor.com/api/projects/status/kd7f3yftf7unxlsx?svg=true)](https://ci.appveyor.com/project/isaacs/node-glob) [![Coverage Status](https://coveralls.io/repos/isaacs/node-glob/badge.svg?branch=master&service=github)](https://coveralls.io/github/isaacs/node-glob?branch=master) + +This is a glob implementation in JavaScript. It uses the `minimatch` +library to do its matching. + +![a fun cartoon logo made of glob characters](logo/glob.png) + +## Usage + +Install with npm + +``` +npm i glob +``` + +```javascript +var glob = require("glob") + +// options is optional +glob("**/*.js", options, function (er, files) { + // files is an array of filenames. + // If the `nonull` option is set, and nothing + // was found, then files is ["**/*.js"] + // er is an error object or null. +}) +``` + +## Glob Primer + +"Globs" are the patterns you type when you do stuff like `ls *.js` on +the command line, or put `build/*` in a `.gitignore` file. + +Before parsing the path part patterns, braced sections are expanded +into a set. Braced sections start with `{` and end with `}`, with any +number of comma-delimited sections within. Braced sections may contain +slash characters, so `a{/b/c,bcd}` would expand into `a/b/c` and `abcd`. + +The following characters have special magic meaning when used in a +path portion: + +* `*` Matches 0 or more characters in a single path portion +* `?` Matches 1 character +* `[...]` Matches a range of characters, similar to a RegExp range. + If the first character of the range is `!` or `^` then it matches + any character not in the range. +* `!(pattern|pattern|pattern)` Matches anything that does not match + any of the patterns provided. +* `?(pattern|pattern|pattern)` Matches zero or one occurrence of the + patterns provided. +* `+(pattern|pattern|pattern)` Matches one or more occurrences of the + patterns provided. +* `*(a|b|c)` Matches zero or more occurrences of the patterns provided +* `@(pattern|pat*|pat?erN)` Matches exactly one of the patterns + provided +* `**` If a "globstar" is alone in a path portion, then it matches + zero or more directories and subdirectories searching for matches. + It does not crawl symlinked directories. + +### Dots + +If a file or directory path portion has a `.` as the first character, +then it will not match any glob pattern unless that pattern's +corresponding path part also has a `.` as its first character. + +For example, the pattern `a/.*/c` would match the file at `a/.b/c`. +However the pattern `a/*/c` would not, because `*` does not start with +a dot character. + +You can make glob treat dots as normal characters by setting +`dot:true` in the options. + +### Basename Matching + +If you set `matchBase:true` in the options, and the pattern has no +slashes in it, then it will seek for any file anywhere in the tree +with a matching basename. For example, `*.js` would match +`test/simple/basic.js`. + +### Empty Sets + +If no matching files are found, then an empty array is returned. This +differs from the shell, where the pattern itself is returned. For +example: + + $ echo a*s*d*f + a*s*d*f + +To get the bash-style behavior, set the `nonull:true` in the options. + +### See Also: + +* `man sh` +* `man bash` (Search for "Pattern Matching") +* `man 3 fnmatch` +* `man 5 gitignore` +* [minimatch documentation](https://github.com/isaacs/minimatch) + +## glob.hasMagic(pattern, [options]) + +Returns `true` if there are any special characters in the pattern, and +`false` otherwise. + +Note that the options affect the results. If `noext:true` is set in +the options object, then `+(a|b)` will not be considered a magic +pattern. If the pattern has a brace expansion, like `a/{b/c,x/y}` +then that is considered magical, unless `nobrace:true` is set in the +options. + +## glob(pattern, [options], cb) + +* `pattern` `{String}` Pattern to be matched +* `options` `{Object}` +* `cb` `{Function}` + * `err` `{Error | null}` + * `matches` `{Array}` filenames found matching the pattern + +Perform an asynchronous glob search. + +## glob.sync(pattern, [options]) + +* `pattern` `{String}` Pattern to be matched +* `options` `{Object}` +* return: `{Array}` filenames found matching the pattern + +Perform a synchronous glob search. + +## Class: glob.Glob + +Create a Glob object by instantiating the `glob.Glob` class. + +```javascript +var Glob = require("glob").Glob +var mg = new Glob(pattern, options, cb) +``` + +It's an EventEmitter, and starts walking the filesystem to find matches +immediately. + +### new glob.Glob(pattern, [options], [cb]) + +* `pattern` `{String}` pattern to search for +* `options` `{Object}` +* `cb` `{Function}` Called when an error occurs, or matches are found + * `err` `{Error | null}` + * `matches` `{Array}` filenames found matching the pattern + +Note that if the `sync` flag is set in the options, then matches will +be immediately available on the `g.found` member. + +### Properties + +* `minimatch` The minimatch object that the glob uses. +* `options` The options object passed in. +* `aborted` Boolean which is set to true when calling `abort()`. There + is no way at this time to continue a glob search after aborting, but + you can re-use the statCache to avoid having to duplicate syscalls. +* `cache` Convenience object. Each field has the following possible + values: + * `false` - Path does not exist + * `true` - Path exists + * `'FILE'` - Path exists, and is not a directory + * `'DIR'` - Path exists, and is a directory + * `[file, entries, ...]` - Path exists, is a directory, and the + array value is the results of `fs.readdir` +* `statCache` Cache of `fs.stat` results, to prevent statting the same + path multiple times. +* `symlinks` A record of which paths are symbolic links, which is + relevant in resolving `**` patterns. +* `realpathCache` An optional object which is passed to `fs.realpath` + to minimize unnecessary syscalls. It is stored on the instantiated + Glob object, and may be re-used. + +### Events + +* `end` When the matching is finished, this is emitted with all the + matches found. If the `nonull` option is set, and no match was found, + then the `matches` list contains the original pattern. The matches + are sorted, unless the `nosort` flag is set. +* `match` Every time a match is found, this is emitted with the specific + thing that matched. It is not deduplicated or resolved to a realpath. +* `error` Emitted when an unexpected error is encountered, or whenever + any fs error occurs if `options.strict` is set. +* `abort` When `abort()` is called, this event is raised. + +### Methods + +* `pause` Temporarily stop the search +* `resume` Resume the search +* `abort` Stop the search forever + +### Options + +All the options that can be passed to Minimatch can also be passed to +Glob to change pattern matching behavior. Also, some have been added, +or have glob-specific ramifications. + +All options are false by default, unless otherwise noted. + +All options are added to the Glob object, as well. + +If you are running many `glob` operations, you can pass a Glob object +as the `options` argument to a subsequent operation to shortcut some +`stat` and `readdir` calls. At the very least, you may pass in shared +`symlinks`, `statCache`, `realpathCache`, and `cache` options, so that +parallel glob operations will be sped up by sharing information about +the filesystem. + +* `cwd` The current working directory in which to search. Defaults + to `process.cwd()`. +* `root` The place where patterns starting with `/` will be mounted + onto. Defaults to `path.resolve(options.cwd, "/")` (`/` on Unix + systems, and `C:\` or some such on Windows.) +* `dot` Include `.dot` files in normal matches and `globstar` matches. + Note that an explicit dot in a portion of the pattern will always + match dot files. +* `nomount` By default, a pattern starting with a forward-slash will be + "mounted" onto the root setting, so that a valid filesystem path is + returned. Set this flag to disable that behavior. +* `mark` Add a `/` character to directory matches. Note that this + requires additional stat calls. +* `nosort` Don't sort the results. +* `stat` Set to true to stat *all* results. This reduces performance + somewhat, and is completely unnecessary, unless `readdir` is presumed + to be an untrustworthy indicator of file existence. +* `silent` When an unusual error is encountered when attempting to + read a directory, a warning will be printed to stderr. Set the + `silent` option to true to suppress these warnings. +* `strict` When an unusual error is encountered when attempting to + read a directory, the process will just continue on in search of + other matches. Set the `strict` option to raise an error in these + cases. +* `cache` See `cache` property above. Pass in a previously generated + cache object to save some fs calls. +* `statCache` A cache of results of filesystem information, to prevent + unnecessary stat calls. While it should not normally be necessary + to set this, you may pass the statCache from one glob() call to the + options object of another, if you know that the filesystem will not + change between calls. (See "Race Conditions" below.) +* `symlinks` A cache of known symbolic links. You may pass in a + previously generated `symlinks` object to save `lstat` calls when + resolving `**` matches. +* `sync` DEPRECATED: use `glob.sync(pattern, opts)` instead. +* `nounique` In some cases, brace-expanded patterns can result in the + same file showing up multiple times in the result set. By default, + this implementation prevents duplicates in the result set. Set this + flag to disable that behavior. +* `nonull` Set to never return an empty set, instead returning a set + containing the pattern itself. This is the default in glob(3). +* `debug` Set to enable debug logging in minimatch and glob. +* `nobrace` Do not expand `{a,b}` and `{1..3}` brace sets. +* `noglobstar` Do not match `**` against multiple filenames. (Ie, + treat it as a normal `*` instead.) +* `noext` Do not match `+(a|b)` "extglob" patterns. +* `nocase` Perform a case-insensitive match. Note: on + case-insensitive filesystems, non-magic patterns will match by + default, since `stat` and `readdir` will not raise errors. +* `matchBase` Perform a basename-only match if the pattern does not + contain any slash characters. That is, `*.js` would be treated as + equivalent to `**/*.js`, matching all js files in all directories. +* `nodir` Do not match directories, only files. (Note: to match + *only* directories, simply put a `/` at the end of the pattern.) +* `ignore` Add a pattern or an array of glob patterns to exclude matches. + Note: `ignore` patterns are *always* in `dot:true` mode, regardless + of any other settings. +* `follow` Follow symlinked directories when expanding `**` patterns. + Note that this can result in a lot of duplicate references in the + presence of cyclic links. +* `realpath` Set to true to call `fs.realpath` on all of the results. + In the case of a symlink that cannot be resolved, the full absolute + path to the matched entry is returned (though it will usually be a + broken symlink) +* `absolute` Set to true to always receive absolute paths for matched + files. Unlike `realpath`, this also affects the values returned in + the `match` event. +* `fs` File-system object with Node's `fs` API. By default, the built-in + `fs` module will be used. Set to a volume provided by a library like + `memfs` to avoid using the "real" file-system. + +## Comparisons to other fnmatch/glob implementations + +While strict compliance with the existing standards is a worthwhile +goal, some discrepancies exist between node-glob and other +implementations, and are intentional. + +The double-star character `**` is supported by default, unless the +`noglobstar` flag is set. This is supported in the manner of bsdglob +and bash 4.3, where `**` only has special significance if it is the only +thing in a path part. That is, `a/**/b` will match `a/x/y/b`, but +`a/**b` will not. + +Note that symlinked directories are not crawled as part of a `**`, +though their contents may match against subsequent portions of the +pattern. This prevents infinite loops and duplicates and the like. + +If an escaped pattern has no matches, and the `nonull` flag is set, +then glob returns the pattern as-provided, rather than +interpreting the character escapes. For example, +`glob.match([], "\\*a\\?")` will return `"\\*a\\?"` rather than +`"*a?"`. This is akin to setting the `nullglob` option in bash, except +that it does not resolve escaped pattern characters. + +If brace expansion is not disabled, then it is performed before any +other interpretation of the glob pattern. Thus, a pattern like +`+(a|{b),c)}`, which would not be valid in bash or zsh, is expanded +**first** into the set of `+(a|b)` and `+(a|c)`, and those patterns are +checked for validity. Since those two are valid, matching proceeds. + +### Comments and Negation + +Previously, this module let you mark a pattern as a "comment" if it +started with a `#` character, or a "negated" pattern if it started +with a `!` character. + +These options were deprecated in version 5, and removed in version 6. + +To specify things that should not match, use the `ignore` option. + +## Windows + +**Please only use forward-slashes in glob expressions.** + +Though windows uses either `/` or `\` as its path separator, only `/` +characters are used by this glob implementation. You must use +forward-slashes **only** in glob expressions. Back-slashes will always +be interpreted as escape characters, not path separators. + +Results from absolute patterns such as `/foo/*` are mounted onto the +root setting using `path.join`. On windows, this will by default result +in `/foo/*` matching `C:\foo\bar.txt`. + +## Race Conditions + +Glob searching, by its very nature, is susceptible to race conditions, +since it relies on directory walking and such. + +As a result, it is possible that a file that exists when glob looks for +it may have been deleted or modified by the time it returns the result. + +As part of its internal implementation, this program caches all stat +and readdir calls that it makes, in order to cut down on system +overhead. However, this also makes it even more susceptible to races, +especially if the cache or statCache objects are reused between glob +calls. + +Users are thus advised not to use a glob result as a guarantee of +filesystem state in the face of rapid changes. For the vast majority +of operations, this is never a problem. + +## Glob Logo +Glob's logo was created by [Tanya Brassie](http://tanyabrassie.com/). Logo files can be found [here](https://github.com/isaacs/node-glob/tree/master/logo). + +The logo is licensed under a [Creative Commons Attribution-ShareAlike 4.0 International License](https://creativecommons.org/licenses/by-sa/4.0/). + +## Contributing + +Any change to behavior (including bugfixes) must come with a test. + +Patches that fail tests or reduce performance will be rejected. + +``` +# to run tests +npm test + +# to re-generate test fixtures +npm run test-regen + +# to benchmark against bash/zsh +npm run bench + +# to profile javascript +npm run prof +``` + +![](oh-my-glob.gif) diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/glob/common.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/glob/common.js new file mode 100644 index 0000000000000000000000000000000000000000..424c46e1dab1be6b6e357b0620d3efbc059ee0b8 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/glob/common.js @@ -0,0 +1,238 @@ +exports.setopts = setopts +exports.ownProp = ownProp +exports.makeAbs = makeAbs +exports.finish = finish +exports.mark = mark +exports.isIgnored = isIgnored +exports.childrenIgnored = childrenIgnored + +function ownProp (obj, field) { + return Object.prototype.hasOwnProperty.call(obj, field) +} + +var fs = require("fs") +var path = require("path") +var minimatch = require("minimatch") +var isAbsolute = require("path-is-absolute") +var Minimatch = minimatch.Minimatch + +function alphasort (a, b) { + return a.localeCompare(b, 'en') +} + +function setupIgnores (self, options) { + self.ignore = options.ignore || [] + + if (!Array.isArray(self.ignore)) + self.ignore = [self.ignore] + + if (self.ignore.length) { + self.ignore = self.ignore.map(ignoreMap) + } +} + +// ignore patterns are always in dot:true mode. +function ignoreMap (pattern) { + var gmatcher = null + if (pattern.slice(-3) === '/**') { + var gpattern = pattern.replace(/(\/\*\*)+$/, '') + gmatcher = new Minimatch(gpattern, { dot: true }) + } + + return { + matcher: new Minimatch(pattern, { dot: true }), + gmatcher: gmatcher + } +} + +function setopts (self, pattern, options) { + if (!options) + options = {} + + // base-matching: just use globstar for that. + if (options.matchBase && -1 === pattern.indexOf("/")) { + if (options.noglobstar) { + throw new Error("base matching requires globstar") + } + pattern = "**/" + pattern + } + + self.silent = !!options.silent + self.pattern = pattern + self.strict = options.strict !== false + self.realpath = !!options.realpath + self.realpathCache = options.realpathCache || Object.create(null) + self.follow = !!options.follow + self.dot = !!options.dot + self.mark = !!options.mark + self.nodir = !!options.nodir + if (self.nodir) + self.mark = true + self.sync = !!options.sync + self.nounique = !!options.nounique + self.nonull = !!options.nonull + self.nosort = !!options.nosort + self.nocase = !!options.nocase + self.stat = !!options.stat + self.noprocess = !!options.noprocess + self.absolute = !!options.absolute + self.fs = options.fs || fs + + self.maxLength = options.maxLength || Infinity + self.cache = options.cache || Object.create(null) + self.statCache = options.statCache || Object.create(null) + self.symlinks = options.symlinks || Object.create(null) + + setupIgnores(self, options) + + self.changedCwd = false + var cwd = process.cwd() + if (!ownProp(options, "cwd")) + self.cwd = cwd + else { + self.cwd = path.resolve(options.cwd) + self.changedCwd = self.cwd !== cwd + } + + self.root = options.root || path.resolve(self.cwd, "/") + self.root = path.resolve(self.root) + if (process.platform === "win32") + self.root = self.root.replace(/\\/g, "/") + + // TODO: is an absolute `cwd` supposed to be resolved against `root`? + // e.g. { cwd: '/test', root: __dirname } === path.join(__dirname, '/test') + self.cwdAbs = isAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd) + if (process.platform === "win32") + self.cwdAbs = self.cwdAbs.replace(/\\/g, "/") + self.nomount = !!options.nomount + + // disable comments and negation in Minimatch. + // Note that they are not supported in Glob itself anyway. + options.nonegate = true + options.nocomment = true + // always treat \ in patterns as escapes, not path separators + options.allowWindowsEscape = false + + self.minimatch = new Minimatch(pattern, options) + self.options = self.minimatch.options +} + +function finish (self) { + var nou = self.nounique + var all = nou ? [] : Object.create(null) + + for (var i = 0, l = self.matches.length; i < l; i ++) { + var matches = self.matches[i] + if (!matches || Object.keys(matches).length === 0) { + if (self.nonull) { + // do like the shell, and spit out the literal glob + var literal = self.minimatch.globSet[i] + if (nou) + all.push(literal) + else + all[literal] = true + } + } else { + // had matches + var m = Object.keys(matches) + if (nou) + all.push.apply(all, m) + else + m.forEach(function (m) { + all[m] = true + }) + } + } + + if (!nou) + all = Object.keys(all) + + if (!self.nosort) + all = all.sort(alphasort) + + // at *some* point we statted all of these + if (self.mark) { + for (var i = 0; i < all.length; i++) { + all[i] = self._mark(all[i]) + } + if (self.nodir) { + all = all.filter(function (e) { + var notDir = !(/\/$/.test(e)) + var c = self.cache[e] || self.cache[makeAbs(self, e)] + if (notDir && c) + notDir = c !== 'DIR' && !Array.isArray(c) + return notDir + }) + } + } + + if (self.ignore.length) + all = all.filter(function(m) { + return !isIgnored(self, m) + }) + + self.found = all +} + +function mark (self, p) { + var abs = makeAbs(self, p) + var c = self.cache[abs] + var m = p + if (c) { + var isDir = c === 'DIR' || Array.isArray(c) + var slash = p.slice(-1) === '/' + + if (isDir && !slash) + m += '/' + else if (!isDir && slash) + m = m.slice(0, -1) + + if (m !== p) { + var mabs = makeAbs(self, m) + self.statCache[mabs] = self.statCache[abs] + self.cache[mabs] = self.cache[abs] + } + } + + return m +} + +// lotta situps... +function makeAbs (self, f) { + var abs = f + if (f.charAt(0) === '/') { + abs = path.join(self.root, f) + } else if (isAbsolute(f) || f === '') { + abs = f + } else if (self.changedCwd) { + abs = path.resolve(self.cwd, f) + } else { + abs = path.resolve(f) + } + + if (process.platform === 'win32') + abs = abs.replace(/\\/g, '/') + + return abs +} + + +// Return true, if pattern ends with globstar '**', for the accompanying parent directory. +// Ex:- If node_modules/** is the pattern, add 'node_modules' to ignore list along with it's contents +function isIgnored (self, path) { + if (!self.ignore.length) + return false + + return self.ignore.some(function(item) { + return item.matcher.match(path) || !!(item.gmatcher && item.gmatcher.match(path)) + }) +} + +function childrenIgnored (self, path) { + if (!self.ignore.length) + return false + + return self.ignore.some(function(item) { + return !!(item.gmatcher && item.gmatcher.match(path)) + }) +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/glob/glob.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/glob/glob.js new file mode 100644 index 0000000000000000000000000000000000000000..37a4d7e60775a381e843d26bebe568270e9c4388 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/glob/glob.js @@ -0,0 +1,790 @@ +// Approach: +// +// 1. Get the minimatch set +// 2. For each pattern in the set, PROCESS(pattern, false) +// 3. Store matches per-set, then uniq them +// +// PROCESS(pattern, inGlobStar) +// Get the first [n] items from pattern that are all strings +// Join these together. This is PREFIX. +// If there is no more remaining, then stat(PREFIX) and +// add to matches if it succeeds. END. +// +// If inGlobStar and PREFIX is symlink and points to dir +// set ENTRIES = [] +// else readdir(PREFIX) as ENTRIES +// If fail, END +// +// with ENTRIES +// If pattern[n] is GLOBSTAR +// // handle the case where the globstar match is empty +// // by pruning it out, and testing the resulting pattern +// PROCESS(pattern[0..n] + pattern[n+1 .. $], false) +// // handle other cases. +// for ENTRY in ENTRIES (not dotfiles) +// // attach globstar + tail onto the entry +// // Mark that this entry is a globstar match +// PROCESS(pattern[0..n] + ENTRY + pattern[n .. $], true) +// +// else // not globstar +// for ENTRY in ENTRIES (not dotfiles, unless pattern[n] is dot) +// Test ENTRY against pattern[n] +// If fails, continue +// If passes, PROCESS(pattern[0..n] + item + pattern[n+1 .. $]) +// +// Caveat: +// Cache all stats and readdirs results to minimize syscall. Since all +// we ever care about is existence and directory-ness, we can just keep +// `true` for files, and [children,...] for directories, or `false` for +// things that don't exist. + +module.exports = glob + +var rp = require('fs.realpath') +var minimatch = require('minimatch') +var Minimatch = minimatch.Minimatch +var inherits = require('inherits') +var EE = require('events').EventEmitter +var path = require('path') +var assert = require('assert') +var isAbsolute = require('path-is-absolute') +var globSync = require('./sync.js') +var common = require('./common.js') +var setopts = common.setopts +var ownProp = common.ownProp +var inflight = require('inflight') +var util = require('util') +var childrenIgnored = common.childrenIgnored +var isIgnored = common.isIgnored + +var once = require('once') + +function glob (pattern, options, cb) { + if (typeof options === 'function') cb = options, options = {} + if (!options) options = {} + + if (options.sync) { + if (cb) + throw new TypeError('callback provided to sync glob') + return globSync(pattern, options) + } + + return new Glob(pattern, options, cb) +} + +glob.sync = globSync +var GlobSync = glob.GlobSync = globSync.GlobSync + +// old api surface +glob.glob = glob + +function extend (origin, add) { + if (add === null || typeof add !== 'object') { + return origin + } + + var keys = Object.keys(add) + var i = keys.length + while (i--) { + origin[keys[i]] = add[keys[i]] + } + return origin +} + +glob.hasMagic = function (pattern, options_) { + var options = extend({}, options_) + options.noprocess = true + + var g = new Glob(pattern, options) + var set = g.minimatch.set + + if (!pattern) + return false + + if (set.length > 1) + return true + + for (var j = 0; j < set[0].length; j++) { + if (typeof set[0][j] !== 'string') + return true + } + + return false +} + +glob.Glob = Glob +inherits(Glob, EE) +function Glob (pattern, options, cb) { + if (typeof options === 'function') { + cb = options + options = null + } + + if (options && options.sync) { + if (cb) + throw new TypeError('callback provided to sync glob') + return new GlobSync(pattern, options) + } + + if (!(this instanceof Glob)) + return new Glob(pattern, options, cb) + + setopts(this, pattern, options) + this._didRealPath = false + + // process each pattern in the minimatch set + var n = this.minimatch.set.length + + // The matches are stored as {: true,...} so that + // duplicates are automagically pruned. + // Later, we do an Object.keys() on these. + // Keep them as a list so we can fill in when nonull is set. + this.matches = new Array(n) + + if (typeof cb === 'function') { + cb = once(cb) + this.on('error', cb) + this.on('end', function (matches) { + cb(null, matches) + }) + } + + var self = this + this._processing = 0 + + this._emitQueue = [] + this._processQueue = [] + this.paused = false + + if (this.noprocess) + return this + + if (n === 0) + return done() + + var sync = true + for (var i = 0; i < n; i ++) { + this._process(this.minimatch.set[i], i, false, done) + } + sync = false + + function done () { + --self._processing + if (self._processing <= 0) { + if (sync) { + process.nextTick(function () { + self._finish() + }) + } else { + self._finish() + } + } + } +} + +Glob.prototype._finish = function () { + assert(this instanceof Glob) + if (this.aborted) + return + + if (this.realpath && !this._didRealpath) + return this._realpath() + + common.finish(this) + this.emit('end', this.found) +} + +Glob.prototype._realpath = function () { + if (this._didRealpath) + return + + this._didRealpath = true + + var n = this.matches.length + if (n === 0) + return this._finish() + + var self = this + for (var i = 0; i < this.matches.length; i++) + this._realpathSet(i, next) + + function next () { + if (--n === 0) + self._finish() + } +} + +Glob.prototype._realpathSet = function (index, cb) { + var matchset = this.matches[index] + if (!matchset) + return cb() + + var found = Object.keys(matchset) + var self = this + var n = found.length + + if (n === 0) + return cb() + + var set = this.matches[index] = Object.create(null) + found.forEach(function (p, i) { + // If there's a problem with the stat, then it means that + // one or more of the links in the realpath couldn't be + // resolved. just return the abs value in that case. + p = self._makeAbs(p) + rp.realpath(p, self.realpathCache, function (er, real) { + if (!er) + set[real] = true + else if (er.syscall === 'stat') + set[p] = true + else + self.emit('error', er) // srsly wtf right here + + if (--n === 0) { + self.matches[index] = set + cb() + } + }) + }) +} + +Glob.prototype._mark = function (p) { + return common.mark(this, p) +} + +Glob.prototype._makeAbs = function (f) { + return common.makeAbs(this, f) +} + +Glob.prototype.abort = function () { + this.aborted = true + this.emit('abort') +} + +Glob.prototype.pause = function () { + if (!this.paused) { + this.paused = true + this.emit('pause') + } +} + +Glob.prototype.resume = function () { + if (this.paused) { + this.emit('resume') + this.paused = false + if (this._emitQueue.length) { + var eq = this._emitQueue.slice(0) + this._emitQueue.length = 0 + for (var i = 0; i < eq.length; i ++) { + var e = eq[i] + this._emitMatch(e[0], e[1]) + } + } + if (this._processQueue.length) { + var pq = this._processQueue.slice(0) + this._processQueue.length = 0 + for (var i = 0; i < pq.length; i ++) { + var p = pq[i] + this._processing-- + this._process(p[0], p[1], p[2], p[3]) + } + } + } +} + +Glob.prototype._process = function (pattern, index, inGlobStar, cb) { + assert(this instanceof Glob) + assert(typeof cb === 'function') + + if (this.aborted) + return + + this._processing++ + if (this.paused) { + this._processQueue.push([pattern, index, inGlobStar, cb]) + return + } + + //console.error('PROCESS %d', this._processing, pattern) + + // Get the first [n] parts of pattern that are all strings. + var n = 0 + while (typeof pattern[n] === 'string') { + n ++ + } + // now n is the index of the first one that is *not* a string. + + // see if there's anything else + var prefix + switch (n) { + // if not, then this is rather simple + case pattern.length: + this._processSimple(pattern.join('/'), index, cb) + return + + case 0: + // pattern *starts* with some non-trivial item. + // going to readdir(cwd), but not include the prefix in matches. + prefix = null + break + + default: + // pattern has some string bits in the front. + // whatever it starts with, whether that's 'absolute' like /foo/bar, + // or 'relative' like '../baz' + prefix = pattern.slice(0, n).join('/') + break + } + + var remain = pattern.slice(n) + + // get the list of entries. + var read + if (prefix === null) + read = '.' + else if (isAbsolute(prefix) || + isAbsolute(pattern.map(function (p) { + return typeof p === 'string' ? p : '[*]' + }).join('/'))) { + if (!prefix || !isAbsolute(prefix)) + prefix = '/' + prefix + read = prefix + } else + read = prefix + + var abs = this._makeAbs(read) + + //if ignored, skip _processing + if (childrenIgnored(this, read)) + return cb() + + var isGlobStar = remain[0] === minimatch.GLOBSTAR + if (isGlobStar) + this._processGlobStar(prefix, read, abs, remain, index, inGlobStar, cb) + else + this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb) +} + +Glob.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar, cb) { + var self = this + this._readdir(abs, inGlobStar, function (er, entries) { + return self._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb) + }) +} + +Glob.prototype._processReaddir2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) { + + // if the abs isn't a dir, then nothing can match! + if (!entries) + return cb() + + // It will only match dot entries if it starts with a dot, or if + // dot is set. Stuff like @(.foo|.bar) isn't allowed. + var pn = remain[0] + var negate = !!this.minimatch.negate + var rawGlob = pn._glob + var dotOk = this.dot || rawGlob.charAt(0) === '.' + + var matchedEntries = [] + for (var i = 0; i < entries.length; i++) { + var e = entries[i] + if (e.charAt(0) !== '.' || dotOk) { + var m + if (negate && !prefix) { + m = !e.match(pn) + } else { + m = e.match(pn) + } + if (m) + matchedEntries.push(e) + } + } + + //console.error('prd2', prefix, entries, remain[0]._glob, matchedEntries) + + var len = matchedEntries.length + // If there are no matched entries, then nothing matches. + if (len === 0) + return cb() + + // if this is the last remaining pattern bit, then no need for + // an additional stat *unless* the user has specified mark or + // stat explicitly. We know they exist, since readdir returned + // them. + + if (remain.length === 1 && !this.mark && !this.stat) { + if (!this.matches[index]) + this.matches[index] = Object.create(null) + + for (var i = 0; i < len; i ++) { + var e = matchedEntries[i] + if (prefix) { + if (prefix !== '/') + e = prefix + '/' + e + else + e = prefix + e + } + + if (e.charAt(0) === '/' && !this.nomount) { + e = path.join(this.root, e) + } + this._emitMatch(index, e) + } + // This was the last one, and no stats were needed + return cb() + } + + // now test all matched entries as stand-ins for that part + // of the pattern. + remain.shift() + for (var i = 0; i < len; i ++) { + var e = matchedEntries[i] + var newPattern + if (prefix) { + if (prefix !== '/') + e = prefix + '/' + e + else + e = prefix + e + } + this._process([e].concat(remain), index, inGlobStar, cb) + } + cb() +} + +Glob.prototype._emitMatch = function (index, e) { + if (this.aborted) + return + + if (isIgnored(this, e)) + return + + if (this.paused) { + this._emitQueue.push([index, e]) + return + } + + var abs = isAbsolute(e) ? e : this._makeAbs(e) + + if (this.mark) + e = this._mark(e) + + if (this.absolute) + e = abs + + if (this.matches[index][e]) + return + + if (this.nodir) { + var c = this.cache[abs] + if (c === 'DIR' || Array.isArray(c)) + return + } + + this.matches[index][e] = true + + var st = this.statCache[abs] + if (st) + this.emit('stat', e, st) + + this.emit('match', e) +} + +Glob.prototype._readdirInGlobStar = function (abs, cb) { + if (this.aborted) + return + + // follow all symlinked directories forever + // just proceed as if this is a non-globstar situation + if (this.follow) + return this._readdir(abs, false, cb) + + var lstatkey = 'lstat\0' + abs + var self = this + var lstatcb = inflight(lstatkey, lstatcb_) + + if (lstatcb) + self.fs.lstat(abs, lstatcb) + + function lstatcb_ (er, lstat) { + if (er && er.code === 'ENOENT') + return cb() + + var isSym = lstat && lstat.isSymbolicLink() + self.symlinks[abs] = isSym + + // If it's not a symlink or a dir, then it's definitely a regular file. + // don't bother doing a readdir in that case. + if (!isSym && lstat && !lstat.isDirectory()) { + self.cache[abs] = 'FILE' + cb() + } else + self._readdir(abs, false, cb) + } +} + +Glob.prototype._readdir = function (abs, inGlobStar, cb) { + if (this.aborted) + return + + cb = inflight('readdir\0'+abs+'\0'+inGlobStar, cb) + if (!cb) + return + + //console.error('RD %j %j', +inGlobStar, abs) + if (inGlobStar && !ownProp(this.symlinks, abs)) + return this._readdirInGlobStar(abs, cb) + + if (ownProp(this.cache, abs)) { + var c = this.cache[abs] + if (!c || c === 'FILE') + return cb() + + if (Array.isArray(c)) + return cb(null, c) + } + + var self = this + self.fs.readdir(abs, readdirCb(this, abs, cb)) +} + +function readdirCb (self, abs, cb) { + return function (er, entries) { + if (er) + self._readdirError(abs, er, cb) + else + self._readdirEntries(abs, entries, cb) + } +} + +Glob.prototype._readdirEntries = function (abs, entries, cb) { + if (this.aborted) + return + + // if we haven't asked to stat everything, then just + // assume that everything in there exists, so we can avoid + // having to stat it a second time. + if (!this.mark && !this.stat) { + for (var i = 0; i < entries.length; i ++) { + var e = entries[i] + if (abs === '/') + e = abs + e + else + e = abs + '/' + e + this.cache[e] = true + } + } + + this.cache[abs] = entries + return cb(null, entries) +} + +Glob.prototype._readdirError = function (f, er, cb) { + if (this.aborted) + return + + // handle errors, and cache the information + switch (er.code) { + case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205 + case 'ENOTDIR': // totally normal. means it *does* exist. + var abs = this._makeAbs(f) + this.cache[abs] = 'FILE' + if (abs === this.cwdAbs) { + var error = new Error(er.code + ' invalid cwd ' + this.cwd) + error.path = this.cwd + error.code = er.code + this.emit('error', error) + this.abort() + } + break + + case 'ENOENT': // not terribly unusual + case 'ELOOP': + case 'ENAMETOOLONG': + case 'UNKNOWN': + this.cache[this._makeAbs(f)] = false + break + + default: // some unusual error. Treat as failure. + this.cache[this._makeAbs(f)] = false + if (this.strict) { + this.emit('error', er) + // If the error is handled, then we abort + // if not, we threw out of here + this.abort() + } + if (!this.silent) + console.error('glob error', er) + break + } + + return cb() +} + +Glob.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar, cb) { + var self = this + this._readdir(abs, inGlobStar, function (er, entries) { + self._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb) + }) +} + + +Glob.prototype._processGlobStar2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) { + //console.error('pgs2', prefix, remain[0], entries) + + // no entries means not a dir, so it can never have matches + // foo.txt/** doesn't match foo.txt + if (!entries) + return cb() + + // test without the globstar, and with every child both below + // and replacing the globstar. + var remainWithoutGlobStar = remain.slice(1) + var gspref = prefix ? [ prefix ] : [] + var noGlobStar = gspref.concat(remainWithoutGlobStar) + + // the noGlobStar pattern exits the inGlobStar state + this._process(noGlobStar, index, false, cb) + + var isSym = this.symlinks[abs] + var len = entries.length + + // If it's a symlink, and we're in a globstar, then stop + if (isSym && inGlobStar) + return cb() + + for (var i = 0; i < len; i++) { + var e = entries[i] + if (e.charAt(0) === '.' && !this.dot) + continue + + // these two cases enter the inGlobStar state + var instead = gspref.concat(entries[i], remainWithoutGlobStar) + this._process(instead, index, true, cb) + + var below = gspref.concat(entries[i], remain) + this._process(below, index, true, cb) + } + + cb() +} + +Glob.prototype._processSimple = function (prefix, index, cb) { + // XXX review this. Shouldn't it be doing the mounting etc + // before doing stat? kinda weird? + var self = this + this._stat(prefix, function (er, exists) { + self._processSimple2(prefix, index, er, exists, cb) + }) +} +Glob.prototype._processSimple2 = function (prefix, index, er, exists, cb) { + + //console.error('ps2', prefix, exists) + + if (!this.matches[index]) + this.matches[index] = Object.create(null) + + // If it doesn't exist, then just mark the lack of results + if (!exists) + return cb() + + if (prefix && isAbsolute(prefix) && !this.nomount) { + var trail = /[\/\\]$/.test(prefix) + if (prefix.charAt(0) === '/') { + prefix = path.join(this.root, prefix) + } else { + prefix = path.resolve(this.root, prefix) + if (trail) + prefix += '/' + } + } + + if (process.platform === 'win32') + prefix = prefix.replace(/\\/g, '/') + + // Mark this as a match + this._emitMatch(index, prefix) + cb() +} + +// Returns either 'DIR', 'FILE', or false +Glob.prototype._stat = function (f, cb) { + var abs = this._makeAbs(f) + var needDir = f.slice(-1) === '/' + + if (f.length > this.maxLength) + return cb() + + if (!this.stat && ownProp(this.cache, abs)) { + var c = this.cache[abs] + + if (Array.isArray(c)) + c = 'DIR' + + // It exists, but maybe not how we need it + if (!needDir || c === 'DIR') + return cb(null, c) + + if (needDir && c === 'FILE') + return cb() + + // otherwise we have to stat, because maybe c=true + // if we know it exists, but not what it is. + } + + var exists + var stat = this.statCache[abs] + if (stat !== undefined) { + if (stat === false) + return cb(null, stat) + else { + var type = stat.isDirectory() ? 'DIR' : 'FILE' + if (needDir && type === 'FILE') + return cb() + else + return cb(null, type, stat) + } + } + + var self = this + var statcb = inflight('stat\0' + abs, lstatcb_) + if (statcb) + self.fs.lstat(abs, statcb) + + function lstatcb_ (er, lstat) { + if (lstat && lstat.isSymbolicLink()) { + // If it's a symlink, then treat it as the target, unless + // the target does not exist, then treat it as a file. + return self.fs.stat(abs, function (er, stat) { + if (er) + self._stat2(f, abs, null, lstat, cb) + else + self._stat2(f, abs, er, stat, cb) + }) + } else { + self._stat2(f, abs, er, lstat, cb) + } + } +} + +Glob.prototype._stat2 = function (f, abs, er, stat, cb) { + if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) { + this.statCache[abs] = false + return cb() + } + + var needDir = f.slice(-1) === '/' + this.statCache[abs] = stat + + if (abs.slice(-1) === '/' && stat && !stat.isDirectory()) + return cb(null, false, stat) + + var c = true + if (stat) + c = stat.isDirectory() ? 'DIR' : 'FILE' + this.cache[abs] = this.cache[abs] || c + + if (needDir && c === 'FILE') + return cb() + + return cb(null, c, stat) +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/glob/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/glob/package.json new file mode 100644 index 0000000000000000000000000000000000000000..5940b649b7e65a9eed64a674c0248f78e6287d6b --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/glob/package.json @@ -0,0 +1,55 @@ +{ + "author": "Isaac Z. Schlueter (http://blog.izs.me/)", + "name": "glob", + "description": "a little globber", + "version": "7.2.3", + "publishConfig": { + "tag": "v7-legacy" + }, + "repository": { + "type": "git", + "url": "git://github.com/isaacs/node-glob.git" + }, + "main": "glob.js", + "files": [ + "glob.js", + "sync.js", + "common.js" + ], + "engines": { + "node": "*" + }, + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "devDependencies": { + "memfs": "^3.2.0", + "mkdirp": "0", + "rimraf": "^2.2.8", + "tap": "^15.0.6", + "tick": "0.0.6" + }, + "tap": { + "before": "test/00-setup.js", + "after": "test/zz-cleanup.js", + "jobs": 1 + }, + "scripts": { + "prepublish": "npm run benchclean", + "profclean": "rm -f v8.log profile.txt", + "test": "tap", + "test-regen": "npm run profclean && TEST_REGEN=1 node test/00-setup.js", + "bench": "bash benchmark.sh", + "prof": "bash prof.sh && cat profile.txt", + "benchclean": "node benchclean.js" + }, + "license": "ISC", + "funding": { + "url": "https://github.com/sponsors/isaacs" + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/glob/sync.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/glob/sync.js new file mode 100644 index 0000000000000000000000000000000000000000..2c4f480192d28d3aabc2a7697b6352131ff3c339 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/glob/sync.js @@ -0,0 +1,486 @@ +module.exports = globSync +globSync.GlobSync = GlobSync + +var rp = require('fs.realpath') +var minimatch = require('minimatch') +var Minimatch = minimatch.Minimatch +var Glob = require('./glob.js').Glob +var util = require('util') +var path = require('path') +var assert = require('assert') +var isAbsolute = require('path-is-absolute') +var common = require('./common.js') +var setopts = common.setopts +var ownProp = common.ownProp +var childrenIgnored = common.childrenIgnored +var isIgnored = common.isIgnored + +function globSync (pattern, options) { + if (typeof options === 'function' || arguments.length === 3) + throw new TypeError('callback provided to sync glob\n'+ + 'See: https://github.com/isaacs/node-glob/issues/167') + + return new GlobSync(pattern, options).found +} + +function GlobSync (pattern, options) { + if (!pattern) + throw new Error('must provide pattern') + + if (typeof options === 'function' || arguments.length === 3) + throw new TypeError('callback provided to sync glob\n'+ + 'See: https://github.com/isaacs/node-glob/issues/167') + + if (!(this instanceof GlobSync)) + return new GlobSync(pattern, options) + + setopts(this, pattern, options) + + if (this.noprocess) + return this + + var n = this.minimatch.set.length + this.matches = new Array(n) + for (var i = 0; i < n; i ++) { + this._process(this.minimatch.set[i], i, false) + } + this._finish() +} + +GlobSync.prototype._finish = function () { + assert.ok(this instanceof GlobSync) + if (this.realpath) { + var self = this + this.matches.forEach(function (matchset, index) { + var set = self.matches[index] = Object.create(null) + for (var p in matchset) { + try { + p = self._makeAbs(p) + var real = rp.realpathSync(p, self.realpathCache) + set[real] = true + } catch (er) { + if (er.syscall === 'stat') + set[self._makeAbs(p)] = true + else + throw er + } + } + }) + } + common.finish(this) +} + + +GlobSync.prototype._process = function (pattern, index, inGlobStar) { + assert.ok(this instanceof GlobSync) + + // Get the first [n] parts of pattern that are all strings. + var n = 0 + while (typeof pattern[n] === 'string') { + n ++ + } + // now n is the index of the first one that is *not* a string. + + // See if there's anything else + var prefix + switch (n) { + // if not, then this is rather simple + case pattern.length: + this._processSimple(pattern.join('/'), index) + return + + case 0: + // pattern *starts* with some non-trivial item. + // going to readdir(cwd), but not include the prefix in matches. + prefix = null + break + + default: + // pattern has some string bits in the front. + // whatever it starts with, whether that's 'absolute' like /foo/bar, + // or 'relative' like '../baz' + prefix = pattern.slice(0, n).join('/') + break + } + + var remain = pattern.slice(n) + + // get the list of entries. + var read + if (prefix === null) + read = '.' + else if (isAbsolute(prefix) || + isAbsolute(pattern.map(function (p) { + return typeof p === 'string' ? p : '[*]' + }).join('/'))) { + if (!prefix || !isAbsolute(prefix)) + prefix = '/' + prefix + read = prefix + } else + read = prefix + + var abs = this._makeAbs(read) + + //if ignored, skip processing + if (childrenIgnored(this, read)) + return + + var isGlobStar = remain[0] === minimatch.GLOBSTAR + if (isGlobStar) + this._processGlobStar(prefix, read, abs, remain, index, inGlobStar) + else + this._processReaddir(prefix, read, abs, remain, index, inGlobStar) +} + + +GlobSync.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar) { + var entries = this._readdir(abs, inGlobStar) + + // if the abs isn't a dir, then nothing can match! + if (!entries) + return + + // It will only match dot entries if it starts with a dot, or if + // dot is set. Stuff like @(.foo|.bar) isn't allowed. + var pn = remain[0] + var negate = !!this.minimatch.negate + var rawGlob = pn._glob + var dotOk = this.dot || rawGlob.charAt(0) === '.' + + var matchedEntries = [] + for (var i = 0; i < entries.length; i++) { + var e = entries[i] + if (e.charAt(0) !== '.' || dotOk) { + var m + if (negate && !prefix) { + m = !e.match(pn) + } else { + m = e.match(pn) + } + if (m) + matchedEntries.push(e) + } + } + + var len = matchedEntries.length + // If there are no matched entries, then nothing matches. + if (len === 0) + return + + // if this is the last remaining pattern bit, then no need for + // an additional stat *unless* the user has specified mark or + // stat explicitly. We know they exist, since readdir returned + // them. + + if (remain.length === 1 && !this.mark && !this.stat) { + if (!this.matches[index]) + this.matches[index] = Object.create(null) + + for (var i = 0; i < len; i ++) { + var e = matchedEntries[i] + if (prefix) { + if (prefix.slice(-1) !== '/') + e = prefix + '/' + e + else + e = prefix + e + } + + if (e.charAt(0) === '/' && !this.nomount) { + e = path.join(this.root, e) + } + this._emitMatch(index, e) + } + // This was the last one, and no stats were needed + return + } + + // now test all matched entries as stand-ins for that part + // of the pattern. + remain.shift() + for (var i = 0; i < len; i ++) { + var e = matchedEntries[i] + var newPattern + if (prefix) + newPattern = [prefix, e] + else + newPattern = [e] + this._process(newPattern.concat(remain), index, inGlobStar) + } +} + + +GlobSync.prototype._emitMatch = function (index, e) { + if (isIgnored(this, e)) + return + + var abs = this._makeAbs(e) + + if (this.mark) + e = this._mark(e) + + if (this.absolute) { + e = abs + } + + if (this.matches[index][e]) + return + + if (this.nodir) { + var c = this.cache[abs] + if (c === 'DIR' || Array.isArray(c)) + return + } + + this.matches[index][e] = true + + if (this.stat) + this._stat(e) +} + + +GlobSync.prototype._readdirInGlobStar = function (abs) { + // follow all symlinked directories forever + // just proceed as if this is a non-globstar situation + if (this.follow) + return this._readdir(abs, false) + + var entries + var lstat + var stat + try { + lstat = this.fs.lstatSync(abs) + } catch (er) { + if (er.code === 'ENOENT') { + // lstat failed, doesn't exist + return null + } + } + + var isSym = lstat && lstat.isSymbolicLink() + this.symlinks[abs] = isSym + + // If it's not a symlink or a dir, then it's definitely a regular file. + // don't bother doing a readdir in that case. + if (!isSym && lstat && !lstat.isDirectory()) + this.cache[abs] = 'FILE' + else + entries = this._readdir(abs, false) + + return entries +} + +GlobSync.prototype._readdir = function (abs, inGlobStar) { + var entries + + if (inGlobStar && !ownProp(this.symlinks, abs)) + return this._readdirInGlobStar(abs) + + if (ownProp(this.cache, abs)) { + var c = this.cache[abs] + if (!c || c === 'FILE') + return null + + if (Array.isArray(c)) + return c + } + + try { + return this._readdirEntries(abs, this.fs.readdirSync(abs)) + } catch (er) { + this._readdirError(abs, er) + return null + } +} + +GlobSync.prototype._readdirEntries = function (abs, entries) { + // if we haven't asked to stat everything, then just + // assume that everything in there exists, so we can avoid + // having to stat it a second time. + if (!this.mark && !this.stat) { + for (var i = 0; i < entries.length; i ++) { + var e = entries[i] + if (abs === '/') + e = abs + e + else + e = abs + '/' + e + this.cache[e] = true + } + } + + this.cache[abs] = entries + + // mark and cache dir-ness + return entries +} + +GlobSync.prototype._readdirError = function (f, er) { + // handle errors, and cache the information + switch (er.code) { + case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205 + case 'ENOTDIR': // totally normal. means it *does* exist. + var abs = this._makeAbs(f) + this.cache[abs] = 'FILE' + if (abs === this.cwdAbs) { + var error = new Error(er.code + ' invalid cwd ' + this.cwd) + error.path = this.cwd + error.code = er.code + throw error + } + break + + case 'ENOENT': // not terribly unusual + case 'ELOOP': + case 'ENAMETOOLONG': + case 'UNKNOWN': + this.cache[this._makeAbs(f)] = false + break + + default: // some unusual error. Treat as failure. + this.cache[this._makeAbs(f)] = false + if (this.strict) + throw er + if (!this.silent) + console.error('glob error', er) + break + } +} + +GlobSync.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar) { + + var entries = this._readdir(abs, inGlobStar) + + // no entries means not a dir, so it can never have matches + // foo.txt/** doesn't match foo.txt + if (!entries) + return + + // test without the globstar, and with every child both below + // and replacing the globstar. + var remainWithoutGlobStar = remain.slice(1) + var gspref = prefix ? [ prefix ] : [] + var noGlobStar = gspref.concat(remainWithoutGlobStar) + + // the noGlobStar pattern exits the inGlobStar state + this._process(noGlobStar, index, false) + + var len = entries.length + var isSym = this.symlinks[abs] + + // If it's a symlink, and we're in a globstar, then stop + if (isSym && inGlobStar) + return + + for (var i = 0; i < len; i++) { + var e = entries[i] + if (e.charAt(0) === '.' && !this.dot) + continue + + // these two cases enter the inGlobStar state + var instead = gspref.concat(entries[i], remainWithoutGlobStar) + this._process(instead, index, true) + + var below = gspref.concat(entries[i], remain) + this._process(below, index, true) + } +} + +GlobSync.prototype._processSimple = function (prefix, index) { + // XXX review this. Shouldn't it be doing the mounting etc + // before doing stat? kinda weird? + var exists = this._stat(prefix) + + if (!this.matches[index]) + this.matches[index] = Object.create(null) + + // If it doesn't exist, then just mark the lack of results + if (!exists) + return + + if (prefix && isAbsolute(prefix) && !this.nomount) { + var trail = /[\/\\]$/.test(prefix) + if (prefix.charAt(0) === '/') { + prefix = path.join(this.root, prefix) + } else { + prefix = path.resolve(this.root, prefix) + if (trail) + prefix += '/' + } + } + + if (process.platform === 'win32') + prefix = prefix.replace(/\\/g, '/') + + // Mark this as a match + this._emitMatch(index, prefix) +} + +// Returns either 'DIR', 'FILE', or false +GlobSync.prototype._stat = function (f) { + var abs = this._makeAbs(f) + var needDir = f.slice(-1) === '/' + + if (f.length > this.maxLength) + return false + + if (!this.stat && ownProp(this.cache, abs)) { + var c = this.cache[abs] + + if (Array.isArray(c)) + c = 'DIR' + + // It exists, but maybe not how we need it + if (!needDir || c === 'DIR') + return c + + if (needDir && c === 'FILE') + return false + + // otherwise we have to stat, because maybe c=true + // if we know it exists, but not what it is. + } + + var exists + var stat = this.statCache[abs] + if (!stat) { + var lstat + try { + lstat = this.fs.lstatSync(abs) + } catch (er) { + if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) { + this.statCache[abs] = false + return false + } + } + + if (lstat && lstat.isSymbolicLink()) { + try { + stat = this.fs.statSync(abs) + } catch (er) { + stat = lstat + } + } else { + stat = lstat + } + } + + this.statCache[abs] = stat + + var c = true + if (stat) + c = stat.isDirectory() ? 'DIR' : 'FILE' + + this.cache[abs] = this.cache[abs] || c + + if (needDir && c === 'FILE') + return false + + return c +} + +GlobSync.prototype._mark = function (p) { + return common.mark(this, p) +} + +GlobSync.prototype._makeAbs = function (f) { + return common.makeAbs(this, f) +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/HasteFS.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/HasteFS.js new file mode 100644 index 0000000000000000000000000000000000000000..09384ba521fade5c0719499780ff31edb785a946 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/HasteFS.js @@ -0,0 +1,139 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +var _constants = _interopRequireDefault(require('./constants')); +var fastPath = _interopRequireWildcard(require('./lib/fast_path')); +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class HasteFS { + _rootDir; + _files; + constructor({rootDir, files}) { + this._rootDir = rootDir; + this._files = files; + } + getModuleName(file) { + const fileMetadata = this._getFileData(file); + return (fileMetadata && fileMetadata[_constants.default.ID]) || null; + } + getSize(file) { + const fileMetadata = this._getFileData(file); + return (fileMetadata && fileMetadata[_constants.default.SIZE]) || null; + } + getDependencies(file) { + const fileMetadata = this._getFileData(file); + if (fileMetadata) { + return fileMetadata[_constants.default.DEPENDENCIES] + ? fileMetadata[_constants.default.DEPENDENCIES].split( + _constants.default.DEPENDENCY_DELIM + ) + : []; + } else { + return null; + } + } + getSha1(file) { + const fileMetadata = this._getFileData(file); + return (fileMetadata && fileMetadata[_constants.default.SHA1]) || null; + } + exists(file) { + return this._getFileData(file) != null; + } + getAllFiles() { + return Array.from(this.getAbsoluteFileIterator()); + } + getFileIterator() { + return this._files.keys(); + } + *getAbsoluteFileIterator() { + for (const file of this.getFileIterator()) { + yield fastPath.resolve(this._rootDir, file); + } + } + matchFiles(pattern) { + if (!(pattern instanceof RegExp)) { + pattern = new RegExp(pattern); + } + const files = []; + for (const file of this.getAbsoluteFileIterator()) { + if (pattern.test(file)) { + files.push(file); + } + } + return files; + } + matchFilesWithGlob(globs, root) { + const files = new Set(); + const matcher = (0, _jestUtil().globsToMatcher)(globs); + for (const file of this.getAbsoluteFileIterator()) { + const filePath = root ? fastPath.relative(root, file) : file; + if (matcher((0, _jestUtil().replacePathSepForGlob)(filePath))) { + files.add(file); + } + } + return files; + } + _getFileData(file) { + const relativePath = fastPath.relative(this._rootDir, file); + return this._files.get(relativePath); + } +} +exports.default = HasteFS; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/ModuleMap.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/ModuleMap.js new file mode 100644 index 0000000000000000000000000000000000000000..5ddd1fd8c26289d7702347ecefe986c55c99a6dc --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/ModuleMap.js @@ -0,0 +1,249 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +var _constants = _interopRequireDefault(require('./constants')); +var fastPath = _interopRequireWildcard(require('./lib/fast_path')); +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const EMPTY_OBJ = {}; +const EMPTY_MAP = new Map(); +class ModuleMap { + static DuplicateHasteCandidatesError; + _raw; + json; + static mapToArrayRecursive(map) { + let arr = Array.from(map); + if (arr[0] && arr[0][1] instanceof Map) { + arr = arr.map(el => [el[0], this.mapToArrayRecursive(el[1])]); + } + return arr; + } + static mapFromArrayRecursive(arr) { + if (arr[0] && Array.isArray(arr[1])) { + arr = arr.map(el => [el[0], this.mapFromArrayRecursive(el[1])]); + } + return new Map(arr); + } + constructor(raw) { + this._raw = raw; + } + getModule(name, platform, supportsNativePlatform, type) { + if (type == null) { + type = _constants.default.MODULE; + } + const module = this._getModuleMetadata( + name, + platform, + !!supportsNativePlatform + ); + if (module && module[_constants.default.TYPE] === type) { + const modulePath = module[_constants.default.PATH]; + return modulePath && fastPath.resolve(this._raw.rootDir, modulePath); + } + return null; + } + getPackage(name, platform, _supportsNativePlatform) { + return this.getModule(name, platform, null, _constants.default.PACKAGE); + } + getMockModule(name) { + const mockPath = + this._raw.mocks.get(name) || this._raw.mocks.get(`${name}/index`); + return mockPath && fastPath.resolve(this._raw.rootDir, mockPath); + } + getRawModuleMap() { + return { + duplicates: this._raw.duplicates, + map: this._raw.map, + mocks: this._raw.mocks, + rootDir: this._raw.rootDir + }; + } + toJSON() { + if (!this.json) { + this.json = { + duplicates: ModuleMap.mapToArrayRecursive(this._raw.duplicates), + map: Array.from(this._raw.map), + mocks: Array.from(this._raw.mocks), + rootDir: this._raw.rootDir + }; + } + return this.json; + } + static fromJSON(serializableModuleMap) { + return new ModuleMap({ + duplicates: ModuleMap.mapFromArrayRecursive( + serializableModuleMap.duplicates + ), + map: new Map(serializableModuleMap.map), + mocks: new Map(serializableModuleMap.mocks), + rootDir: serializableModuleMap.rootDir + }); + } + + /** + * When looking up a module's data, we walk through each eligible platform for + * the query. For each platform, we want to check if there are known + * duplicates for that name+platform pair. The duplication logic normally + * removes elements from the `map` object, but we want to check upfront to be + * extra sure. If metadata exists both in the `duplicates` object and the + * `map`, this would be a bug. + */ + _getModuleMetadata(name, platform, supportsNativePlatform) { + const map = this._raw.map.get(name) || EMPTY_OBJ; + const dupMap = this._raw.duplicates.get(name) || EMPTY_MAP; + if (platform != null) { + this._assertNoDuplicates( + name, + platform, + supportsNativePlatform, + dupMap.get(platform) + ); + if (map[platform] != null) { + return map[platform]; + } + } + if (supportsNativePlatform) { + this._assertNoDuplicates( + name, + _constants.default.NATIVE_PLATFORM, + supportsNativePlatform, + dupMap.get(_constants.default.NATIVE_PLATFORM) + ); + if (map[_constants.default.NATIVE_PLATFORM]) { + return map[_constants.default.NATIVE_PLATFORM]; + } + } + this._assertNoDuplicates( + name, + _constants.default.GENERIC_PLATFORM, + supportsNativePlatform, + dupMap.get(_constants.default.GENERIC_PLATFORM) + ); + if (map[_constants.default.GENERIC_PLATFORM]) { + return map[_constants.default.GENERIC_PLATFORM]; + } + return null; + } + _assertNoDuplicates(name, platform, supportsNativePlatform, relativePathSet) { + if (relativePathSet == null) { + return; + } + // Force flow refinement + const previousSet = relativePathSet; + const duplicates = new Map(); + for (const [relativePath, type] of previousSet) { + const duplicatePath = fastPath.resolve(this._raw.rootDir, relativePath); + duplicates.set(duplicatePath, type); + } + throw new DuplicateHasteCandidatesError( + name, + platform, + supportsNativePlatform, + duplicates + ); + } + static create(rootDir) { + return new ModuleMap({ + duplicates: new Map(), + map: new Map(), + mocks: new Map(), + rootDir + }); + } +} +exports.default = ModuleMap; +class DuplicateHasteCandidatesError extends Error { + hasteName; + platform; + supportsNativePlatform; + duplicatesSet; + constructor(name, platform, supportsNativePlatform, duplicatesSet) { + const platformMessage = getPlatformMessage(platform); + super( + `The name \`${name}\` was looked up in the Haste module map. It ` + + 'cannot be resolved, because there exists several different ' + + 'files, or packages, that provide a module for ' + + `that particular name and platform. ${platformMessage} You must ` + + `delete or exclude files until there remains only one of these:\n\n${Array.from( + duplicatesSet + ) + .map( + ([dupFilePath, dupFileType]) => + ` * \`${dupFilePath}\` (${getTypeMessage(dupFileType)})\n` + ) + .sort() + .join('')}` + ); + this.hasteName = name; + this.platform = platform; + this.supportsNativePlatform = supportsNativePlatform; + this.duplicatesSet = duplicatesSet; + } +} +function getPlatformMessage(platform) { + if (platform === _constants.default.GENERIC_PLATFORM) { + return 'The platform is generic (no extension).'; + } + return `The platform extension is \`${platform}\`.`; +} +function getTypeMessage(type) { + switch (type) { + case _constants.default.MODULE: + return 'module'; + case _constants.default.PACKAGE: + return 'package'; + } + return 'unknown'; +} +ModuleMap.DuplicateHasteCandidatesError = DuplicateHasteCandidatesError; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/blacklist.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/blacklist.js new file mode 100644 index 0000000000000000000000000000000000000000..ae90b1a75e09a2b04e9174b0aa3a0afc750f51f6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/blacklist.js @@ -0,0 +1,64 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// This list is compiled after the MDN list of the most common MIME types (see +// https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/ +// Complete_list_of_MIME_types). +// +// Only MIME types starting with "image/", "video/", "audio/" and "font/" are +// reflected in the list. Adding "application/" is too risky since some text +// file formats (like ".js" and ".json") have an "application/" MIME type. +// +// Feel free to add any extensions that cannot be a Haste module. + +const extensions = new Set([ + // JSONs are never haste modules, except for "package.json", which is handled. + '.json', + // Image extensions. + '.bmp', + '.gif', + '.ico', + '.jpeg', + '.jpg', + '.png', + '.svg', + '.tiff', + '.tif', + '.webp', + // Video extensions. + '.avi', + '.mp4', + '.mpeg', + '.mpg', + '.ogv', + '.webm', + '.3gp', + '.3g2', + // Audio extensions. + '.aac', + '.midi', + '.mid', + '.mp3', + '.oga', + '.wav', + '.3gp', + '.3g2', + // Font extensions. + '.eot', + '.otf', + '.ttf', + '.woff', + '.woff2' +]); +var _default = extensions; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/constants.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/constants.js new file mode 100644 index 0000000000000000000000000000000000000000..1b8804ec3e31764202e2805c82eb5d438ca22158 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/constants.js @@ -0,0 +1,46 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +/* + * This file exports a set of constants that are used for Jest's haste map + * serialization. On very large repositories, the haste map cache becomes very + * large to the point where it is the largest overhead in starting up Jest. + * + * This constant key map allows to keep the map smaller without having to build + * a custom serialization library. + */ + +/* eslint-disable sort-keys */ +const constants = { + /* dependency serialization */ + DEPENDENCY_DELIM: '\0', + /* file map attributes */ + ID: 0, + MTIME: 1, + SIZE: 2, + VISITED: 3, + DEPENDENCIES: 4, + SHA1: 5, + /* module map attributes */ + PATH: 0, + TYPE: 1, + /* module types */ + MODULE: 0, + PACKAGE: 1, + /* platforms */ + GENERIC_PLATFORM: 'g', + NATIVE_PLATFORM: 'native' +}; +/* eslint-enable */ +var _default = constants; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/crawlers/node.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/crawlers/node.js new file mode 100644 index 0000000000000000000000000000000000000000..eb90b4e1bce64ab6809d914db9122e1fc8dc151c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/crawlers/node.js @@ -0,0 +1,269 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.nodeCrawl = nodeCrawl; +function _child_process() { + const data = require('child_process'); + _child_process = function () { + return data; + }; + return data; +} +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function fs() { + const data = _interopRequireWildcard(require('graceful-fs')); + fs = function () { + return data; + }; + return data; +} +var _constants = _interopRequireDefault(require('../constants')); +var fastPath = _interopRequireWildcard(require('../lib/fast_path')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +async function hasNativeFindSupport(forceNodeFilesystemAPI) { + if (forceNodeFilesystemAPI) { + return false; + } + try { + return await new Promise(resolve => { + // Check the find binary supports the non-POSIX -iname parameter wrapped in parens. + const args = [ + '.', + '-type', + 'f', + '(', + '-iname', + '*.ts', + '-o', + '-iname', + '*.js', + ')' + ]; + const child = (0, _child_process().spawn)('find', args, { + cwd: __dirname + }); + child.on('error', () => { + resolve(false); + }); + child.on('exit', code => { + resolve(code === 0); + }); + }); + } catch { + return false; + } +} +function find(roots, extensions, ignore, enableSymlinks, callback) { + const result = []; + let activeCalls = 0; + function search(directory) { + activeCalls++; + fs().readdir( + directory, + { + withFileTypes: true + }, + (err, entries) => { + activeCalls--; + if (err) { + if (activeCalls === 0) { + callback(result); + } + return; + } + entries.forEach(entry => { + const file = path().join(directory, entry.name); + if (ignore(file)) { + return; + } + if (entry.isSymbolicLink()) { + return; + } + if (entry.isDirectory()) { + search(file); + return; + } + activeCalls++; + const stat = enableSymlinks ? fs().stat : fs().lstat; + stat(file, (err, stat) => { + activeCalls--; + + // This logic is unnecessary for node > v10.10, but leaving it in + // since we need it for backwards-compatibility still. + if (!err && stat && !stat.isSymbolicLink()) { + if (stat.isDirectory()) { + search(file); + } else { + const ext = path().extname(file).substr(1); + if (extensions.indexOf(ext) !== -1) { + result.push([file, stat.mtime.getTime(), stat.size]); + } + } + } + if (activeCalls === 0) { + callback(result); + } + }); + }); + if (activeCalls === 0) { + callback(result); + } + } + ); + } + if (roots.length > 0) { + roots.forEach(search); + } else { + callback(result); + } +} +function findNative(roots, extensions, ignore, enableSymlinks, callback) { + const args = Array.from(roots); + if (enableSymlinks) { + args.push('(', '-type', 'f', '-o', '-type', 'l', ')'); + } else { + args.push('-type', 'f'); + } + if (extensions.length) { + args.push('('); + } + extensions.forEach((ext, index) => { + if (index) { + args.push('-o'); + } + args.push('-iname'); + args.push(`*.${ext}`); + }); + if (extensions.length) { + args.push(')'); + } + const child = (0, _child_process().spawn)('find', args); + let stdout = ''; + if (child.stdout === null) { + throw new Error( + 'stdout is null - this should never happen. Please open up an issue at https://github.com/jestjs/jest' + ); + } + child.stdout.setEncoding('utf-8'); + child.stdout.on('data', data => (stdout += data)); + child.stdout.on('close', () => { + const lines = stdout + .trim() + .split('\n') + .filter(x => !ignore(x)); + const result = []; + let count = lines.length; + if (!count) { + callback([]); + } else { + lines.forEach(path => { + fs().stat(path, (err, stat) => { + // Filter out symlinks that describe directories + if (!err && stat && !stat.isDirectory()) { + result.push([path, stat.mtime.getTime(), stat.size]); + } + if (--count === 0) { + callback(result); + } + }); + }); + } + }); +} +async function nodeCrawl(options) { + const { + data, + extensions, + forceNodeFilesystemAPI, + ignore, + rootDir, + enableSymlinks, + roots + } = options; + const useNativeFind = await hasNativeFindSupport(forceNodeFilesystemAPI); + return new Promise(resolve => { + const callback = list => { + const files = new Map(); + const removedFiles = new Map(data.files); + list.forEach(fileData => { + const [filePath, mtime, size] = fileData; + const relativeFilePath = fastPath.relative(rootDir, filePath); + const existingFile = data.files.get(relativeFilePath); + if (existingFile && existingFile[_constants.default.MTIME] === mtime) { + files.set(relativeFilePath, existingFile); + } else { + // See ../constants.js; SHA-1 will always be null and fulfilled later. + files.set(relativeFilePath, ['', mtime, size, 0, '', null]); + } + removedFiles.delete(relativeFilePath); + }); + data.files = files; + resolve({ + hasteMap: data, + removedFiles + }); + }; + if (useNativeFind) { + findNative(roots, extensions, ignore, enableSymlinks, callback); + } else { + find(roots, extensions, ignore, enableSymlinks, callback); + } + }); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/crawlers/watchman.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/crawlers/watchman.js new file mode 100644 index 0000000000000000000000000000000000000000..3b2fbfffad80c05dc3b7e8ecf74f1eeef9bacff9 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/crawlers/watchman.js @@ -0,0 +1,339 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.watchmanCrawl = watchmanCrawl; +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _fbWatchman() { + const data = _interopRequireDefault(require('fb-watchman')); + _fbWatchman = function () { + return data; + }; + return data; +} +var _constants = _interopRequireDefault(require('../constants')); +var fastPath = _interopRequireWildcard(require('../lib/fast_path')); +var _normalizePathSep = _interopRequireDefault( + require('../lib/normalizePathSep') +); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const watchmanURL = 'https://facebook.github.io/watchman/docs/troubleshooting'; +function WatchmanError(error) { + error.message = + `Watchman error: ${error.message.trim()}. Make sure watchman ` + + `is running for this project. See ${watchmanURL}.`; + return error; +} + +/** + * Wrap watchman capabilityCheck method as a promise. + * + * @param client watchman client + * @param caps capabilities to verify + * @returns a promise resolving to a list of verified capabilities + */ +async function capabilityCheck(client, caps) { + return new Promise((resolve, reject) => { + client.capabilityCheck( + // @ts-expect-error: incorrectly typed + caps, + (error, response) => { + if (error) { + reject(error); + } else { + resolve(response); + } + } + ); + }); +} +async function watchmanCrawl(options) { + const fields = ['name', 'exists', 'mtime_ms', 'size']; + const {data, extensions, ignore, rootDir, roots} = options; + const defaultWatchExpression = ['allof', ['type', 'f']]; + const clocks = data.clocks; + const client = new (_fbWatchman().default.Client)(); + + // https://facebook.github.io/watchman/docs/capabilities.html + // Check adds about ~28ms + const capabilities = await capabilityCheck(client, { + // If a required capability is missing then an error will be thrown, + // we don't need this assertion, so using optional instead. + optional: ['suffix-set'] + }); + if (capabilities?.capabilities['suffix-set']) { + // If available, use the optimized `suffix-set` operation: + // https://facebook.github.io/watchman/docs/expr/suffix.html#suffix-set + defaultWatchExpression.push(['suffix', extensions]); + } else { + // Otherwise use the older and less optimal suffix tuple array + defaultWatchExpression.push([ + 'anyof', + ...extensions.map(extension => ['suffix', extension]) + ]); + } + let clientError; + client.on('error', error => (clientError = WatchmanError(error))); + const cmd = (...args) => + new Promise((resolve, reject) => + client.command(args, (error, result) => + error ? reject(WatchmanError(error)) : resolve(result) + ) + ); + if (options.computeSha1) { + const {capabilities} = await cmd('list-capabilities'); + if (capabilities.indexOf('field-content.sha1hex') !== -1) { + fields.push('content.sha1hex'); + } + } + async function getWatchmanRoots(roots) { + const watchmanRoots = new Map(); + await Promise.all( + roots.map(async root => { + const response = await cmd('watch-project', root); + const existing = watchmanRoots.get(response.watch); + // A root can only be filtered if it was never seen with a + // relative_path before. + const canBeFiltered = !existing || existing.length > 0; + if (canBeFiltered) { + if (response.relative_path) { + watchmanRoots.set( + response.watch, + (existing || []).concat(response.relative_path) + ); + } else { + // Make the filter directories an empty array to signal that this + // root was already seen and needs to be watched for all files or + // directories. + watchmanRoots.set(response.watch, []); + } + } + }) + ); + return watchmanRoots; + } + async function queryWatchmanForDirs(rootProjectDirMappings) { + const results = new Map(); + let isFresh = false; + await Promise.all( + Array.from(rootProjectDirMappings).map( + async ([root, directoryFilters]) => { + const expression = Array.from(defaultWatchExpression); + const glob = []; + if (directoryFilters.length > 0) { + expression.push([ + 'anyof', + ...directoryFilters.map(dir => ['dirname', dir]) + ]); + for (const directory of directoryFilters) { + for (const extension of extensions) { + glob.push(`${directory}/**/*.${extension}`); + } + } + } else { + for (const extension of extensions) { + glob.push(`**/*.${extension}`); + } + } + + // Jest is only going to store one type of clock; a string that + // represents a local clock. However, the Watchman crawler supports + // a second type of clock that can be written by automation outside of + // Jest, called an "scm query", which fetches changed files based on + // source control mergebases. The reason this is necessary is because + // local clocks are not portable across systems, but scm queries are. + // By using scm queries, we can create the haste map on a different + // system and import it, transforming the clock into a local clock. + const since = clocks.get(fastPath.relative(rootDir, root)); + const query = + since !== undefined + ? // Use the `since` generator if we have a clock available + { + expression, + fields, + since + } + : // Otherwise use the `glob` filter + { + expression, + fields, + glob, + glob_includedotfiles: true + }; + const response = await cmd('query', root, query); + if ('warning' in response) { + console.warn('watchman warning: ', response.warning); + } + + // When a source-control query is used, we ignore the "is fresh" + // response from Watchman because it will be true despite the query + // being incremental. + const isSourceControlQuery = + typeof since !== 'string' && + since?.scm?.['mergebase-with'] !== undefined; + if (!isSourceControlQuery) { + isFresh = isFresh || response.is_fresh_instance; + } + results.set(root, response); + } + ) + ); + return { + isFresh, + results + }; + } + let files = data.files; + let removedFiles = new Map(); + const changedFiles = new Map(); + let results; + let isFresh = false; + try { + const watchmanRoots = await getWatchmanRoots(roots); + const watchmanFileResults = await queryWatchmanForDirs(watchmanRoots); + + // Reset the file map if watchman was restarted and sends us a list of + // files. + if (watchmanFileResults.isFresh) { + files = new Map(); + removedFiles = new Map(data.files); + isFresh = true; + } + results = watchmanFileResults.results; + } finally { + client.end(); + } + if (clientError) { + throw clientError; + } + for (const [watchRoot, response] of results) { + const fsRoot = (0, _normalizePathSep.default)(watchRoot); + const relativeFsRoot = fastPath.relative(rootDir, fsRoot); + clocks.set( + relativeFsRoot, + // Ensure we persist only the local clock. + typeof response.clock === 'string' ? response.clock : response.clock.clock + ); + for (const fileData of response.files) { + const filePath = + fsRoot + path().sep + (0, _normalizePathSep.default)(fileData.name); + const relativeFilePath = fastPath.relative(rootDir, filePath); + const existingFileData = data.files.get(relativeFilePath); + + // If watchman is fresh, the removed files map starts with all files + // and we remove them as we verify they still exist. + if (isFresh && existingFileData && fileData.exists) { + removedFiles.delete(relativeFilePath); + } + if (!fileData.exists) { + // No need to act on files that do not exist and were not tracked. + if (existingFileData) { + files.delete(relativeFilePath); + + // If watchman is not fresh, we will know what specific files were + // deleted since we last ran and can track only those files. + if (!isFresh) { + removedFiles.set(relativeFilePath, existingFileData); + } + } + } else if (!ignore(filePath)) { + const mtime = + typeof fileData.mtime_ms === 'number' + ? fileData.mtime_ms + : fileData.mtime_ms.toNumber(); + const size = fileData.size; + let sha1hex = fileData['content.sha1hex']; + if (typeof sha1hex !== 'string' || sha1hex.length !== 40) { + sha1hex = undefined; + } + let nextData; + if ( + existingFileData && + existingFileData[_constants.default.MTIME] === mtime + ) { + nextData = existingFileData; + } else if ( + existingFileData && + sha1hex && + existingFileData[_constants.default.SHA1] === sha1hex + ) { + nextData = [ + existingFileData[0], + mtime, + existingFileData[2], + existingFileData[3], + existingFileData[4], + existingFileData[5] + ]; + } else { + // See ../constants.ts + nextData = ['', mtime, size, 0, '', sha1hex ?? null]; + } + files.set(relativeFilePath, nextData); + changedFiles.set(relativeFilePath, nextData); + } + } + } + data.files = files; + return { + changedFiles: isFresh ? undefined : changedFiles, + hasteMap: data, + removedFiles + }; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/getMockName.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/getMockName.js new file mode 100644 index 0000000000000000000000000000000000000000..445e0b27c057193ccebdf52d7c6bd877b1c11fb7 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/getMockName.js @@ -0,0 +1,69 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const MOCKS_PATTERN = `${path().sep}__mocks__${path().sep}`; +const getMockName = filePath => { + const mockPath = filePath.split(MOCKS_PATTERN)[1]; + return mockPath + .substring(0, mockPath.lastIndexOf(path().extname(mockPath))) + .replace(/\\/g, '/'); +}; +var _default = getMockName; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a0466fe85c1a1eeb24d85b3014166b7e2881c4e3 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/index.d.ts @@ -0,0 +1,242 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/// + +import type {Config} from '@jest/types'; +import type {Stats} from 'graceful-fs'; + +declare type ChangeEvent = { + eventsQueue: EventsQueue; + hasteFS: HasteFS; + moduleMap: ModuleMap_2; +}; + +export declare class DuplicateError extends Error { + mockPath1: string; + mockPath2: string; + constructor(mockPath1: string, mockPath2: string); +} + +declare class DuplicateHasteCandidatesError extends Error { + hasteName: string; + platform: string | null; + supportsNativePlatform: boolean; + duplicatesSet: DuplicatesSet; + constructor( + name: string, + platform: string, + supportsNativePlatform: boolean, + duplicatesSet: DuplicatesSet, + ); +} + +declare type DuplicatesIndex = Map>; + +declare type DuplicatesSet = Map; + +declare type EventsQueue = Array<{ + filePath: string; + stat: Stats | undefined; + type: string; +}>; + +declare type FileData = Map; + +declare type FileMetaData = [ + id: string, + mtime: number, + size: number, + visited: 0 | 1, + dependencies: string, + sha1: string | null | undefined, +]; + +declare class HasteFS implements IHasteFS { + private readonly _rootDir; + private readonly _files; + constructor({rootDir, files}: {rootDir: string; files: FileData}); + getModuleName(file: string): string | null; + getSize(file: string): number | null; + getDependencies(file: string): Array | null; + getSha1(file: string): string | null; + exists(file: string): boolean; + getAllFiles(): Array; + getFileIterator(): Iterable; + getAbsoluteFileIterator(): Iterable; + matchFiles(pattern: RegExp | string): Array; + matchFilesWithGlob(globs: Array, root: string | null): Set; + private _getFileData; +} + +declare type HasteMapStatic = { + getCacheFilePath( + tmpdir: string, + name: string, + ...extra: Array + ): string; + getModuleMapFromJSON(json: S): IModuleMap; +}; + +declare type HasteRegExp = RegExp | ((str: string) => boolean); + +declare type HType = { + ID: 0; + MTIME: 1; + SIZE: 2; + VISITED: 3; + DEPENDENCIES: 4; + SHA1: 5; + PATH: 0; + TYPE: 1; + MODULE: 0; + PACKAGE: 1; + GENERIC_PLATFORM: 'g'; + NATIVE_PLATFORM: 'native'; + DEPENDENCY_DELIM: '\0'; +}; + +declare type HTypeValue = HType[keyof HType]; + +export declare interface IHasteFS { + exists(path: string): boolean; + getAbsoluteFileIterator(): Iterable; + getAllFiles(): Array; + getDependencies(file: string): Array | null; + getSize(path: string): number | null; + matchFiles(pattern: RegExp | string): Array; + matchFilesWithGlob( + globs: ReadonlyArray, + root: string | null, + ): Set; +} + +export declare interface IHasteMap { + on(eventType: 'change', handler: (event: ChangeEvent) => void): void; + build(): Promise<{ + hasteFS: IHasteFS; + moduleMap: IModuleMap; + }>; +} + +declare type IJestHasteMap = HasteMapStatic & { + create(options: Options): Promise; + getStatic(config: Config.ProjectConfig): HasteMapStatic; +}; + +export declare interface IModuleMap { + getModule( + name: string, + platform?: string | null, + supportsNativePlatform?: boolean | null, + type?: HTypeValue | null, + ): string | null; + getPackage( + name: string, + platform: string | null | undefined, + _supportsNativePlatform: boolean | null, + ): string | null; + getMockModule(name: string): string | undefined; + getRawModuleMap(): RawModuleMap; + toJSON(): S; +} + +declare const JestHasteMap: IJestHasteMap; +export default JestHasteMap; + +declare type MockData = Map; + +export declare const ModuleMap: { + create: (rootPath: string) => IModuleMap; +}; + +declare class ModuleMap_2 implements IModuleMap { + static DuplicateHasteCandidatesError: typeof DuplicateHasteCandidatesError; + private readonly _raw; + private json; + private static mapToArrayRecursive; + private static mapFromArrayRecursive; + constructor(raw: RawModuleMap); + getModule( + name: string, + platform?: string | null, + supportsNativePlatform?: boolean | null, + type?: HTypeValue | null, + ): string | null; + getPackage( + name: string, + platform: string | null | undefined, + _supportsNativePlatform: boolean | null, + ): string | null; + getMockModule(name: string): string | undefined; + getRawModuleMap(): RawModuleMap; + toJSON(): SerializableModuleMap; + static fromJSON(serializableModuleMap: SerializableModuleMap): ModuleMap_2; + /** + * When looking up a module's data, we walk through each eligible platform for + * the query. For each platform, we want to check if there are known + * duplicates for that name+platform pair. The duplication logic normally + * removes elements from the `map` object, but we want to check upfront to be + * extra sure. If metadata exists both in the `duplicates` object and the + * `map`, this would be a bug. + */ + private _getModuleMetadata; + private _assertNoDuplicates; + static create(rootDir: string): ModuleMap_2; +} + +declare type ModuleMapData = Map; + +declare type ModuleMapItem = { + [platform: string]: ModuleMetaData; +}; + +declare type ModuleMetaData = [path: string, type: number]; + +declare type Options = { + cacheDirectory?: string; + computeDependencies?: boolean; + computeSha1?: boolean; + console?: Console; + dependencyExtractor?: string | null; + enableSymlinks?: boolean; + extensions: Array; + forceNodeFilesystemAPI?: boolean; + hasteImplModulePath?: string; + hasteMapModulePath?: string; + id: string; + ignorePattern?: HasteRegExp; + maxWorkers: number; + mocksPattern?: string; + platforms: Array; + resetCache?: boolean; + retainAllFiles: boolean; + rootDir: string; + roots: Array; + skipPackageJson?: boolean; + throwOnModuleCollision?: boolean; + useWatchman?: boolean; + watch?: boolean; + workerThreads?: boolean; +}; + +declare type RawModuleMap = { + rootDir: string; + duplicates: DuplicatesIndex; + map: ModuleMapData; + mocks: MockData; +}; + +export declare type SerializableModuleMap = { + duplicates: ReadonlyArray<[string, [string, [string, [string, number]]]]>; + map: ReadonlyArray<[string, ValueType]>; + mocks: ReadonlyArray<[string, ValueType]>; + rootDir: string; +}; + +declare type ValueType = T extends Map ? V : never; + +export {}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..d8a3b5eca24acbbc2bb4d4adeede73fac8d01bda --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/index.js @@ -0,0 +1,1107 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = exports.ModuleMap = exports.DuplicateError = void 0; +function _crypto() { + const data = require('crypto'); + _crypto = function () { + return data; + }; + return data; +} +function _events() { + const data = require('events'); + _events = function () { + return data; + }; + return data; +} +function _os() { + const data = require('os'); + _os = function () { + return data; + }; + return data; +} +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _v() { + const data = require('v8'); + _v = function () { + return data; + }; + return data; +} +function _gracefulFs() { + const data = require('graceful-fs'); + _gracefulFs = function () { + return data; + }; + return data; +} +function _jestRegexUtil() { + const data = require('jest-regex-util'); + _jestRegexUtil = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +function _jestWorker() { + const data = require('jest-worker'); + _jestWorker = function () { + return data; + }; + return data; +} +var _HasteFS = _interopRequireDefault(require('./HasteFS')); +var _ModuleMap = _interopRequireDefault(require('./ModuleMap')); +var _constants = _interopRequireDefault(require('./constants')); +var _node = require('./crawlers/node'); +var _watchman = require('./crawlers/watchman'); +var _getMockName = _interopRequireDefault(require('./getMockName')); +var fastPath = _interopRequireWildcard(require('./lib/fast_path')); +var _getPlatformExtension = _interopRequireDefault( + require('./lib/getPlatformExtension') +); +var _isWatchmanInstalled = _interopRequireDefault( + require('./lib/isWatchmanInstalled') +); +var _normalizePathSep = _interopRequireDefault( + require('./lib/normalizePathSep') +); +var _FSEventsWatcher = require('./watchers/FSEventsWatcher'); +var _NodeWatcher = _interopRequireDefault(require('./watchers/NodeWatcher')); +var _WatchmanWatcher = _interopRequireDefault( + require('./watchers/WatchmanWatcher') +); +var _worker = require('./worker'); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// @ts-expect-error: not converted to TypeScript - it's a fork: https://github.com/jestjs/jest/pull/10919 + +// @ts-expect-error: not converted to TypeScript - it's a fork: https://github.com/jestjs/jest/pull/5387 + +// TypeScript doesn't like us importing from outside `rootDir`, but it doesn't +// understand `require`. +const {version: VERSION} = require('../package.json'); +const ModuleMap = _ModuleMap.default; +exports.ModuleMap = ModuleMap; +const CHANGE_INTERVAL = 30; +const MAX_WAIT_TIME = 240000; +const NODE_MODULES = `${path().sep}node_modules${path().sep}`; +const PACKAGE_JSON = `${path().sep}package.json`; +const VCS_DIRECTORIES = ['.git', '.hg', '.sl'] + .map(vcs => + (0, _jestRegexUtil().escapePathForRegex)(path().sep + vcs + path().sep) + ) + .join('|'); + +/** + * HasteMap is a JavaScript implementation of Facebook's haste module system. + * + * This implementation is inspired by https://github.com/facebook/node-haste + * and was built with for high-performance in large code repositories with + * hundreds of thousands of files. This implementation is scalable and provides + * predictable performance. + * + * Because the haste map creation and synchronization is critical to startup + * performance and most tasks are blocked by I/O this class makes heavy use of + * synchronous operations. It uses worker processes for parallelizing file + * access and metadata extraction. + * + * The data structures created by `jest-haste-map` can be used directly from the + * cache without further processing. The metadata objects in the `files` and + * `map` objects contain cross-references: a metadata object from one can look + * up the corresponding metadata object in the other map. Note that in most + * projects, the number of files will be greater than the number of haste + * modules one module can refer to many files based on platform extensions. + * + * type HasteMap = { + * clocks: WatchmanClocks, + * files: {[filepath: string]: FileMetaData}, + * map: {[id: string]: ModuleMapItem}, + * mocks: {[id: string]: string}, + * } + * + * // Watchman clocks are used for query synchronization and file system deltas. + * type WatchmanClocks = {[filepath: string]: string}; + * + * type FileMetaData = { + * id: ?string, // used to look up module metadata objects in `map`. + * mtime: number, // check for outdated files. + * size: number, // size of the file in bytes. + * visited: boolean, // whether the file has been parsed or not. + * dependencies: Array, // all relative dependencies of this file. + * sha1: ?string, // SHA-1 of the file, if requested via options. + * }; + * + * // Modules can be targeted to a specific platform based on the file name. + * // Example: platform.ios.js and Platform.android.js will both map to the same + * // `Platform` module. The platform should be specified during resolution. + * type ModuleMapItem = {[platform: string]: ModuleMetaData}; + * + * // + * type ModuleMetaData = { + * path: string, // the path to look up the file object in `files`. + * type: string, // the module type (either `package` or `module`). + * }; + * + * Note that the data structures described above are conceptual only. The actual + * implementation uses arrays and constant keys for metadata storage. Instead of + * `{id: 'flatMap', mtime: 3421, size: 42, visited: true, dependencies: []}` the real + * representation is similar to `['flatMap', 3421, 42, 1, []]` to save storage space + * and reduce parse and write time of a big JSON blob. + * + * The HasteMap is created as follows: + * 1. read data from the cache or create an empty structure. + * + * 2. crawl the file system. + * * empty cache: crawl the entire file system. + * * cache available: + * * if watchman is available: get file system delta changes. + * * if watchman is unavailable: crawl the entire file system. + * * build metadata objects for every file. This builds the `files` part of + * the `HasteMap`. + * + * 3. parse and extract metadata from changed files. + * * this is done in parallel over worker processes to improve performance. + * * the worst case is to parse all files. + * * the best case is no file system access and retrieving all data from + * the cache. + * * the average case is a small number of changed files. + * + * 4. serialize the new `HasteMap` in a cache file. + * Worker processes can directly access the cache through `HasteMap.read()`. + * + */ +class HasteMap extends _events().EventEmitter { + _buildPromise = null; + _cachePath = ''; + _changeInterval; + _console; + _isWatchmanInstalledPromise = null; + _options; + _watchers = []; + _worker = null; + static getStatic(config) { + if (config.haste.hasteMapModulePath) { + return require(config.haste.hasteMapModulePath); + } + return HasteMap; + } + static async create(options) { + if (options.hasteMapModulePath) { + const CustomHasteMap = require(options.hasteMapModulePath); + return new CustomHasteMap(options); + } + const hasteMap = new HasteMap(options); + await hasteMap.setupCachePath(options); + return hasteMap; + } + constructor(options) { + super(); + this._options = { + cacheDirectory: options.cacheDirectory || (0, _os().tmpdir)(), + computeDependencies: options.computeDependencies ?? true, + computeSha1: options.computeSha1 || false, + dependencyExtractor: options.dependencyExtractor || null, + enableSymlinks: options.enableSymlinks || false, + extensions: options.extensions, + forceNodeFilesystemAPI: !!options.forceNodeFilesystemAPI, + hasteImplModulePath: options.hasteImplModulePath, + id: options.id, + maxWorkers: options.maxWorkers, + mocksPattern: options.mocksPattern + ? new RegExp(options.mocksPattern) + : null, + platforms: options.platforms, + resetCache: options.resetCache, + retainAllFiles: options.retainAllFiles, + rootDir: options.rootDir, + roots: Array.from(new Set(options.roots)), + skipPackageJson: !!options.skipPackageJson, + throwOnModuleCollision: !!options.throwOnModuleCollision, + useWatchman: options.useWatchman ?? true, + watch: !!options.watch, + workerThreads: options.workerThreads + }; + this._console = options.console || globalThis.console; + if (options.ignorePattern) { + if (options.ignorePattern instanceof RegExp) { + this._options.ignorePattern = new RegExp( + options.ignorePattern.source.concat(`|${VCS_DIRECTORIES}`), + options.ignorePattern.flags + ); + } else { + throw new Error( + 'jest-haste-map: the `ignorePattern` option must be a RegExp' + ); + } + } else { + this._options.ignorePattern = new RegExp(VCS_DIRECTORIES); + } + if (this._options.enableSymlinks && this._options.useWatchman) { + throw new Error( + 'jest-haste-map: enableSymlinks config option was set, but ' + + 'is incompatible with watchman.\n' + + 'Set either `enableSymlinks` to false or `useWatchman` to false.' + ); + } + } + async setupCachePath(options) { + const rootDirHash = (0, _crypto().createHash)('sha1') + .update(options.rootDir) + .digest('hex') + .substring(0, 32); + let hasteImplHash = ''; + let dependencyExtractorHash = ''; + if (options.hasteImplModulePath) { + const hasteImpl = require(options.hasteImplModulePath); + if (hasteImpl.getCacheKey) { + hasteImplHash = String(hasteImpl.getCacheKey()); + } + } + if (options.dependencyExtractor) { + const dependencyExtractor = await (0, _jestUtil().requireOrImportModule)( + options.dependencyExtractor, + false + ); + if (dependencyExtractor.getCacheKey) { + dependencyExtractorHash = String(dependencyExtractor.getCacheKey()); + } + } + this._cachePath = HasteMap.getCacheFilePath( + this._options.cacheDirectory, + `haste-map-${this._options.id}-${rootDirHash}`, + VERSION, + this._options.id, + this._options.roots + .map(root => fastPath.relative(options.rootDir, root)) + .join(':'), + this._options.extensions.join(':'), + this._options.platforms.join(':'), + this._options.computeSha1.toString(), + options.mocksPattern || '', + (options.ignorePattern || '').toString(), + hasteImplHash, + dependencyExtractorHash, + this._options.computeDependencies.toString() + ); + } + static getCacheFilePath(tmpdir, id, ...extra) { + const hash = (0, _crypto().createHash)('sha1').update(extra.join('')); + return path().join( + tmpdir, + `${id.replace(/\W/g, '-')}-${hash.digest('hex').substring(0, 32)}` + ); + } + static getModuleMapFromJSON(json) { + return _ModuleMap.default.fromJSON(json); + } + getCacheFilePath() { + return this._cachePath; + } + build() { + if (!this._buildPromise) { + this._buildPromise = (async () => { + const data = await this._buildFileMap(); + + // Persist when we don't know if files changed (changedFiles undefined) + // or when we know a file was changed or deleted. + let hasteMap; + if ( + data.changedFiles === undefined || + data.changedFiles.size > 0 || + data.removedFiles.size > 0 + ) { + hasteMap = await this._buildHasteMap(data); + this._persist(hasteMap); + } else { + hasteMap = data.hasteMap; + } + const rootDir = this._options.rootDir; + const hasteFS = new _HasteFS.default({ + files: hasteMap.files, + rootDir + }); + const moduleMap = new _ModuleMap.default({ + duplicates: hasteMap.duplicates, + map: hasteMap.map, + mocks: hasteMap.mocks, + rootDir + }); + const __hasteMapForTest = + (process.env.NODE_ENV === 'test' && hasteMap) || null; + await this._watch(hasteMap); + return { + __hasteMapForTest, + hasteFS, + moduleMap + }; + })(); + } + return this._buildPromise; + } + + /** + * 1. read data from the cache or create an empty structure. + */ + read() { + let hasteMap; + try { + hasteMap = (0, _v().deserialize)( + (0, _gracefulFs().readFileSync)(this._cachePath) + ); + } catch { + hasteMap = this._createEmptyMap(); + } + return hasteMap; + } + readModuleMap() { + const data = this.read(); + return new _ModuleMap.default({ + duplicates: data.duplicates, + map: data.map, + mocks: data.mocks, + rootDir: this._options.rootDir + }); + } + + /** + * 2. crawl the file system. + */ + async _buildFileMap() { + let hasteMap; + try { + const read = this._options.resetCache ? this._createEmptyMap : this.read; + hasteMap = read.call(this); + } catch { + hasteMap = this._createEmptyMap(); + } + return this._crawl(hasteMap); + } + + /** + * 3. parse and extract metadata from changed files. + */ + _processFile(hasteMap, map, mocks, filePath, workerOptions) { + const rootDir = this._options.rootDir; + const setModule = (id, module) => { + let moduleMap = map.get(id); + if (!moduleMap) { + moduleMap = Object.create(null); + map.set(id, moduleMap); + } + const platform = + (0, _getPlatformExtension.default)( + module[_constants.default.PATH], + this._options.platforms + ) || _constants.default.GENERIC_PLATFORM; + const existingModule = moduleMap[platform]; + if ( + existingModule && + existingModule[_constants.default.PATH] !== + module[_constants.default.PATH] + ) { + const method = this._options.throwOnModuleCollision ? 'error' : 'warn'; + this._console[method]( + [ + `jest-haste-map: Haste module naming collision: ${id}`, + ' The following files share their name; please adjust your hasteImpl:', + ` * ${path().sep}${ + existingModule[_constants.default.PATH] + }`, + ` * ${path().sep}${module[_constants.default.PATH]}`, + '' + ].join('\n') + ); + if (this._options.throwOnModuleCollision) { + throw new DuplicateError( + existingModule[_constants.default.PATH], + module[_constants.default.PATH] + ); + } + + // We do NOT want consumers to use a module that is ambiguous. + delete moduleMap[platform]; + if (Object.keys(moduleMap).length === 1) { + map.delete(id); + } + let dupsByPlatform = hasteMap.duplicates.get(id); + if (dupsByPlatform == null) { + dupsByPlatform = new Map(); + hasteMap.duplicates.set(id, dupsByPlatform); + } + const dups = new Map([ + [module[_constants.default.PATH], module[_constants.default.TYPE]], + [ + existingModule[_constants.default.PATH], + existingModule[_constants.default.TYPE] + ] + ]); + dupsByPlatform.set(platform, dups); + return; + } + const dupsByPlatform = hasteMap.duplicates.get(id); + if (dupsByPlatform != null) { + const dups = dupsByPlatform.get(platform); + if (dups != null) { + dups.set( + module[_constants.default.PATH], + module[_constants.default.TYPE] + ); + } + return; + } + moduleMap[platform] = module; + }; + const relativeFilePath = fastPath.relative(rootDir, filePath); + const fileMetadata = hasteMap.files.get(relativeFilePath); + if (!fileMetadata) { + throw new Error( + 'jest-haste-map: File to process was not found in the haste map.' + ); + } + const moduleMetadata = hasteMap.map.get( + fileMetadata[_constants.default.ID] + ); + const computeSha1 = + this._options.computeSha1 && !fileMetadata[_constants.default.SHA1]; + + // Callback called when the response from the worker is successful. + const workerReply = metadata => { + // `1` for truthy values instead of `true` to save cache space. + fileMetadata[_constants.default.VISITED] = 1; + const metadataId = metadata.id; + const metadataModule = metadata.module; + if (metadataId && metadataModule) { + fileMetadata[_constants.default.ID] = metadataId; + setModule(metadataId, metadataModule); + } + fileMetadata[_constants.default.DEPENDENCIES] = metadata.dependencies + ? metadata.dependencies.join(_constants.default.DEPENDENCY_DELIM) + : ''; + if (computeSha1) { + fileMetadata[_constants.default.SHA1] = metadata.sha1; + } + }; + + // Callback called when the response from the worker is an error. + const workerError = error => { + if (typeof error !== 'object' || !error.message || !error.stack) { + error = new Error(error); + error.stack = ''; // Remove stack for stack-less errors. + } + + if (!['ENOENT', 'EACCES'].includes(error.code)) { + throw error; + } + + // If a file cannot be read we remove it from the file list and + // ignore the failure silently. + hasteMap.files.delete(relativeFilePath); + }; + + // If we retain all files in the virtual HasteFS representation, we avoid + // reading them if they aren't important (node_modules). + if (this._options.retainAllFiles && filePath.includes(NODE_MODULES)) { + if (computeSha1) { + return this._getWorker(workerOptions) + .getSha1({ + computeDependencies: this._options.computeDependencies, + computeSha1, + dependencyExtractor: this._options.dependencyExtractor, + filePath, + hasteImplModulePath: this._options.hasteImplModulePath, + rootDir + }) + .then(workerReply, workerError); + } + return null; + } + if ( + this._options.mocksPattern && + this._options.mocksPattern.test(filePath) + ) { + const mockPath = (0, _getMockName.default)(filePath); + const existingMockPath = mocks.get(mockPath); + if (existingMockPath) { + const secondMockPath = fastPath.relative(rootDir, filePath); + if (existingMockPath !== secondMockPath) { + const method = this._options.throwOnModuleCollision + ? 'error' + : 'warn'; + this._console[method]( + [ + `jest-haste-map: duplicate manual mock found: ${mockPath}`, + ' The following files share their name; please delete one of them:', + ` * ${path().sep}${existingMockPath}`, + ` * ${path().sep}${secondMockPath}`, + '' + ].join('\n') + ); + if (this._options.throwOnModuleCollision) { + throw new DuplicateError(existingMockPath, secondMockPath); + } + } + } + mocks.set(mockPath, relativeFilePath); + } + if (fileMetadata[_constants.default.VISITED]) { + if (!fileMetadata[_constants.default.ID]) { + return null; + } + if (moduleMetadata != null) { + const platform = + (0, _getPlatformExtension.default)( + filePath, + this._options.platforms + ) || _constants.default.GENERIC_PLATFORM; + const module = moduleMetadata[platform]; + if (module == null) { + return null; + } + const moduleId = fileMetadata[_constants.default.ID]; + let modulesByPlatform = map.get(moduleId); + if (!modulesByPlatform) { + modulesByPlatform = Object.create(null); + map.set(moduleId, modulesByPlatform); + } + modulesByPlatform[platform] = module; + return null; + } + } + return this._getWorker(workerOptions) + .worker({ + computeDependencies: this._options.computeDependencies, + computeSha1, + dependencyExtractor: this._options.dependencyExtractor, + filePath, + hasteImplModulePath: this._options.hasteImplModulePath, + rootDir + }) + .then(workerReply, workerError); + } + _buildHasteMap(data) { + const {removedFiles, changedFiles, hasteMap} = data; + + // If any files were removed or we did not track what files changed, process + // every file looking for changes. Otherwise, process only changed files. + let map; + let mocks; + let filesToProcess; + if (changedFiles === undefined || removedFiles.size) { + map = new Map(); + mocks = new Map(); + filesToProcess = hasteMap.files; + } else { + map = hasteMap.map; + mocks = hasteMap.mocks; + filesToProcess = changedFiles; + } + for (const [relativeFilePath, fileMetadata] of removedFiles) { + this._recoverDuplicates( + hasteMap, + relativeFilePath, + fileMetadata[_constants.default.ID] + ); + } + const promises = []; + for (const relativeFilePath of filesToProcess.keys()) { + if ( + this._options.skipPackageJson && + relativeFilePath.endsWith(PACKAGE_JSON) + ) { + continue; + } + // SHA-1, if requested, should already be present thanks to the crawler. + const filePath = fastPath.resolve( + this._options.rootDir, + relativeFilePath + ); + const promise = this._processFile(hasteMap, map, mocks, filePath); + if (promise) { + promises.push(promise); + } + } + return Promise.all(promises).then( + () => { + this._cleanup(); + hasteMap.map = map; + hasteMap.mocks = mocks; + return hasteMap; + }, + error => { + this._cleanup(); + throw error; + } + ); + } + _cleanup() { + const worker = this._worker; + if (worker && 'end' in worker) { + worker.end(); + } + this._worker = null; + } + + /** + * 4. serialize the new `HasteMap` in a cache file. + */ + _persist(hasteMap) { + (0, _gracefulFs().writeFileSync)( + this._cachePath, + (0, _v().serialize)(hasteMap) + ); + } + + /** + * Creates workers or parses files and extracts metadata in-process. + */ + _getWorker( + options = { + forceInBand: false + } + ) { + if (!this._worker) { + if (options.forceInBand || this._options.maxWorkers <= 1) { + this._worker = { + getSha1: _worker.getSha1, + worker: _worker.worker + }; + } else { + this._worker = new (_jestWorker().Worker)(require.resolve('./worker'), { + enableWorkerThreads: this._options.workerThreads, + exposedMethods: ['getSha1', 'worker'], + forkOptions: { + serialization: 'json' + }, + maxRetries: 3, + numWorkers: this._options.maxWorkers + }); + } + } + return this._worker; + } + async _crawl(hasteMap) { + const options = this._options; + const ignore = this._ignore.bind(this); + const crawl = (await this._shouldUseWatchman()) + ? _watchman.watchmanCrawl + : _node.nodeCrawl; + const crawlerOptions = { + computeSha1: options.computeSha1, + data: hasteMap, + enableSymlinks: options.enableSymlinks, + extensions: options.extensions, + forceNodeFilesystemAPI: options.forceNodeFilesystemAPI, + ignore, + rootDir: options.rootDir, + roots: options.roots + }; + const retry = error => { + if (crawl === _watchman.watchmanCrawl) { + this._console.warn( + 'jest-haste-map: Watchman crawl failed. Retrying once with node ' + + 'crawler.\n' + + " Usually this happens when watchman isn't running. Create an " + + "empty `.watchmanconfig` file in your project's root folder or " + + 'initialize a git or hg repository in your project.\n' + + ` ${error}` + ); + return (0, _node.nodeCrawl)(crawlerOptions).catch(e => { + throw new Error( + 'Crawler retry failed:\n' + + ` Original error: ${error.message}\n` + + ` Retry error: ${e.message}\n` + ); + }); + } + throw error; + }; + try { + return await crawl(crawlerOptions); + } catch (error) { + return retry(error); + } + } + + /** + * Watch mode + */ + async _watch(hasteMap) { + if (!this._options.watch) { + return Promise.resolve(); + } + + // In watch mode, we'll only warn about module collisions and we'll retain + // all files, even changes to node_modules. + this._options.throwOnModuleCollision = false; + this._options.retainAllFiles = true; + + // WatchmanWatcher > FSEventsWatcher > sane.NodeWatcher + const Watcher = (await this._shouldUseWatchman()) + ? _WatchmanWatcher.default + : _FSEventsWatcher.FSEventsWatcher.isSupported() + ? _FSEventsWatcher.FSEventsWatcher + : _NodeWatcher.default; + const extensions = this._options.extensions; + const ignorePattern = this._options.ignorePattern; + const rootDir = this._options.rootDir; + let changeQueue = Promise.resolve(); + let eventsQueue = []; + // We only need to copy the entire haste map once on every "frame". + let mustCopy = true; + const createWatcher = root => { + const watcher = new Watcher(root, { + dot: true, + glob: extensions.map(extension => `**/*.${extension}`), + ignored: ignorePattern + }); + return new Promise((resolve, reject) => { + const rejectTimeout = setTimeout( + () => reject(new Error('Failed to start watch mode.')), + MAX_WAIT_TIME + ); + watcher.once('ready', () => { + clearTimeout(rejectTimeout); + watcher.on('all', onChange); + resolve(watcher); + }); + }); + }; + const emitChange = () => { + if (eventsQueue.length) { + mustCopy = true; + const changeEvent = { + eventsQueue, + hasteFS: new _HasteFS.default({ + files: hasteMap.files, + rootDir + }), + moduleMap: new _ModuleMap.default({ + duplicates: hasteMap.duplicates, + map: hasteMap.map, + mocks: hasteMap.mocks, + rootDir + }) + }; + this.emit('change', changeEvent); + eventsQueue = []; + } + }; + const onChange = (type, filePath, root, stat) => { + filePath = path().join(root, (0, _normalizePathSep.default)(filePath)); + if ( + (stat && stat.isDirectory()) || + this._ignore(filePath) || + !extensions.some(extension => filePath.endsWith(extension)) + ) { + return; + } + const relativeFilePath = fastPath.relative(rootDir, filePath); + const fileMetadata = hasteMap.files.get(relativeFilePath); + + // The file has been accessed, not modified + if ( + type === 'change' && + fileMetadata && + stat && + fileMetadata[_constants.default.MTIME] === stat.mtime.getTime() + ) { + return; + } + changeQueue = changeQueue + .then(() => { + // If we get duplicate events for the same file, ignore them. + if ( + eventsQueue.find( + event => + event.type === type && + event.filePath === filePath && + ((!event.stat && !stat) || + (!!event.stat && + !!stat && + event.stat.mtime.getTime() === stat.mtime.getTime())) + ) + ) { + return null; + } + if (mustCopy) { + mustCopy = false; + hasteMap = { + clocks: new Map(hasteMap.clocks), + duplicates: new Map(hasteMap.duplicates), + files: new Map(hasteMap.files), + map: new Map(hasteMap.map), + mocks: new Map(hasteMap.mocks) + }; + } + const add = () => { + eventsQueue.push({ + filePath, + stat, + type + }); + return null; + }; + const fileMetadata = hasteMap.files.get(relativeFilePath); + + // If it's not an addition, delete the file and all its metadata + if (fileMetadata != null) { + const moduleName = fileMetadata[_constants.default.ID]; + const platform = + (0, _getPlatformExtension.default)( + filePath, + this._options.platforms + ) || _constants.default.GENERIC_PLATFORM; + hasteMap.files.delete(relativeFilePath); + let moduleMap = hasteMap.map.get(moduleName); + if (moduleMap != null) { + // We are forced to copy the object because jest-haste-map exposes + // the map as an immutable entity. + moduleMap = copy(moduleMap); + delete moduleMap[platform]; + if (Object.keys(moduleMap).length === 0) { + hasteMap.map.delete(moduleName); + } else { + hasteMap.map.set(moduleName, moduleMap); + } + } + if ( + this._options.mocksPattern && + this._options.mocksPattern.test(filePath) + ) { + const mockName = (0, _getMockName.default)(filePath); + hasteMap.mocks.delete(mockName); + } + this._recoverDuplicates(hasteMap, relativeFilePath, moduleName); + } + + // If the file was added or changed, + // parse it and update the haste map. + if (type === 'add' || type === 'change') { + (0, _jestUtil().invariant)( + stat, + 'since the file exists or changed, it should have stats' + ); + const fileMetadata = [ + '', + stat.mtime.getTime(), + stat.size, + 0, + '', + null + ]; + hasteMap.files.set(relativeFilePath, fileMetadata); + const promise = this._processFile( + hasteMap, + hasteMap.map, + hasteMap.mocks, + filePath, + { + forceInBand: true + } + ); + // Cleanup + this._cleanup(); + if (promise) { + return promise.then(add); + } else { + // If a file in node_modules has changed, + // emit an event regardless. + add(); + } + } else { + add(); + } + return null; + }) + .catch(error => { + this._console.error( + `jest-haste-map: watch error:\n ${error.stack}\n` + ); + }); + }; + this._changeInterval = setInterval(emitChange, CHANGE_INTERVAL); + return Promise.all(this._options.roots.map(createWatcher)).then( + watchers => { + this._watchers = watchers; + } + ); + } + + /** + * This function should be called when the file under `filePath` is removed + * or changed. When that happens, we want to figure out if that file was + * part of a group of files that had the same ID. If it was, we want to + * remove it from the group. Furthermore, if there is only one file + * remaining in the group, then we want to restore that single file as the + * correct resolution for its ID, and cleanup the duplicates index. + */ + _recoverDuplicates(hasteMap, relativeFilePath, moduleName) { + let dupsByPlatform = hasteMap.duplicates.get(moduleName); + if (dupsByPlatform == null) { + return; + } + const platform = + (0, _getPlatformExtension.default)( + relativeFilePath, + this._options.platforms + ) || _constants.default.GENERIC_PLATFORM; + let dups = dupsByPlatform.get(platform); + if (dups == null) { + return; + } + dupsByPlatform = copyMap(dupsByPlatform); + hasteMap.duplicates.set(moduleName, dupsByPlatform); + dups = copyMap(dups); + dupsByPlatform.set(platform, dups); + dups.delete(relativeFilePath); + if (dups.size !== 1) { + return; + } + const uniqueModule = dups.entries().next().value; + if (!uniqueModule) { + return; + } + let dedupMap = hasteMap.map.get(moduleName); + if (!dedupMap) { + dedupMap = Object.create(null); + hasteMap.map.set(moduleName, dedupMap); + } + dedupMap[platform] = uniqueModule; + dupsByPlatform.delete(platform); + if (dupsByPlatform.size === 0) { + hasteMap.duplicates.delete(moduleName); + } + } + async end() { + if (this._changeInterval) { + clearInterval(this._changeInterval); + } + if (!this._watchers.length) { + return; + } + await Promise.all(this._watchers.map(watcher => watcher.close())); + this._watchers = []; + } + + /** + * Helpers + */ + _ignore(filePath) { + const ignorePattern = this._options.ignorePattern; + const ignoreMatched = + ignorePattern instanceof RegExp + ? ignorePattern.test(filePath) + : ignorePattern && ignorePattern(filePath); + return ( + ignoreMatched || + (!this._options.retainAllFiles && filePath.includes(NODE_MODULES)) + ); + } + async _shouldUseWatchman() { + if (!this._options.useWatchman) { + return false; + } + if (!this._isWatchmanInstalledPromise) { + this._isWatchmanInstalledPromise = (0, _isWatchmanInstalled.default)(); + } + return this._isWatchmanInstalledPromise; + } + _createEmptyMap() { + return { + clocks: new Map(), + duplicates: new Map(), + files: new Map(), + map: new Map(), + mocks: new Map() + }; + } + static H = _constants.default; +} +class DuplicateError extends Error { + mockPath1; + mockPath2; + constructor(mockPath1, mockPath2) { + super('Duplicated files or mocks. Please check the console for more info'); + this.mockPath1 = mockPath1; + this.mockPath2 = mockPath2; + } +} +exports.DuplicateError = DuplicateError; +function copy(object) { + return Object.assign(Object.create(null), object); +} +function copyMap(input) { + return new Map(input); +} + +// Export the smallest API surface required by Jest + +const JestHasteMap = HasteMap; +var _default = JestHasteMap; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/lib/dependencyExtractor.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/lib/dependencyExtractor.js new file mode 100644 index 0000000000000000000000000000000000000000..9a2a14f8525fd8f92975e1cddf189f77440cb06a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/lib/dependencyExtractor.js @@ -0,0 +1,84 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.extractor = void 0; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const NOT_A_DOT = '(? `([\`'"])([^'"\`]*?)(?:\\${pos})`; +const WORD_SEPARATOR = '\\b'; +const LEFT_PARENTHESIS = '\\('; +const RIGHT_PARENTHESIS = '\\)'; +const WHITESPACE = '\\s*'; +const OPTIONAL_COMMA = '(:?,\\s*)?'; +function createRegExp(parts, flags) { + return new RegExp(parts.join(''), flags); +} +function alternatives(...parts) { + return `(?:${parts.join('|')})`; +} +function functionCallStart(...names) { + return [ + NOT_A_DOT, + WORD_SEPARATOR, + alternatives(...names), + WHITESPACE, + LEFT_PARENTHESIS, + WHITESPACE + ]; +} +const BLOCK_COMMENT_RE = /\/\*[^]*?\*\//g; +const LINE_COMMENT_RE = /\/\/.*/g; +const REQUIRE_OR_DYNAMIC_IMPORT_RE = createRegExp( + [ + ...functionCallStart('require', 'import'), + CAPTURE_STRING_LITERAL(1), + WHITESPACE, + OPTIONAL_COMMA, + RIGHT_PARENTHESIS + ], + 'g' +); +const IMPORT_OR_EXPORT_RE = createRegExp( + [ + '\\b(?:import|export)\\s+(?!type(?:of)?\\s+)(?:[^\'"]+\\s+from\\s+)?', + CAPTURE_STRING_LITERAL(1) + ], + 'g' +); +const JEST_EXTENSIONS_RE = createRegExp( + [ + ...functionCallStart( + 'jest\\s*\\.\\s*(?:requireActual|requireMock|genMockFromModule|createMockFromModule)' + ), + CAPTURE_STRING_LITERAL(1), + WHITESPACE, + OPTIONAL_COMMA, + RIGHT_PARENTHESIS + ], + 'g' +); +const extractor = { + extract(code) { + const dependencies = new Set(); + const addDependency = (match, _, dep) => { + dependencies.add(dep); + return match; + }; + code + .replace(BLOCK_COMMENT_RE, '') + .replace(LINE_COMMENT_RE, '') + .replace(IMPORT_OR_EXPORT_RE, addDependency) + .replace(REQUIRE_OR_DYNAMIC_IMPORT_RE, addDependency) + .replace(JEST_EXTENSIONS_RE, addDependency); + return dependencies; + } +}; +exports.extractor = extractor; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/lib/fast_path.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/lib/fast_path.js new file mode 100644 index 0000000000000000000000000000000000000000..f82787ccb387f40d71dbcc00f1931481fb961294 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/lib/fast_path.js @@ -0,0 +1,76 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.relative = relative; +exports.resolve = resolve; +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// rootDir and filename must be absolute paths (resolved) +function relative(rootDir, filename) { + return filename.indexOf(rootDir + path().sep) === 0 + ? filename.substring(rootDir.length + 1) + : path().relative(rootDir, filename); +} +const INDIRECTION_FRAGMENT = `..${path().sep}`; + +// rootDir must be an absolute path and relativeFilename must be simple +// (e.g.: foo/bar or ../foo/bar, but never ./foo or foo/../bar) +function resolve(rootDir, relativeFilename) { + return relativeFilename.indexOf(INDIRECTION_FRAGMENT) === 0 + ? path().resolve(rootDir, relativeFilename) + : rootDir + path().sep + relativeFilename; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/lib/getPlatformExtension.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/lib/getPlatformExtension.js new file mode 100644 index 0000000000000000000000000000000000000000..2e1d2045e9a75313216b97f1d251d4d6ad075d70 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/lib/getPlatformExtension.js @@ -0,0 +1,30 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getPlatformExtension; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const SUPPORTED_PLATFORM_EXTS = new Set(['android', 'ios', 'native', 'web']); + +// Extract platform extension: index.ios.js -> ios +function getPlatformExtension(file, platforms) { + const last = file.lastIndexOf('.'); + const secondToLast = file.lastIndexOf('.', last - 1); + if (secondToLast === -1) { + return null; + } + const platform = file.substring(secondToLast + 1, last); + // If an overriding platform array is passed, check that first + + if (platforms && platforms.indexOf(platform) !== -1) { + return platform; + } + return SUPPORTED_PLATFORM_EXTS.has(platform) ? platform : null; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/lib/isWatchmanInstalled.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/lib/isWatchmanInstalled.js new file mode 100644 index 0000000000000000000000000000000000000000..b04abb24e117f96eb98c4be5e11f7836d2e49cf6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/lib/isWatchmanInstalled.js @@ -0,0 +1,37 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = isWatchmanInstalled; +function _child_process() { + const data = require('child_process'); + _child_process = function () { + return data; + }; + return data; +} +function _util() { + const data = require('util'); + _util = function () { + return data; + }; + return data; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +async function isWatchmanInstalled() { + try { + await (0, _util().promisify)(_child_process().execFile)('watchman', [ + '--version' + ]); + return true; + } catch { + return false; + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/lib/normalizePathSep.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/lib/normalizePathSep.js new file mode 100644 index 0000000000000000000000000000000000000000..ad8cd1fe42f1074edb7d64774301d1c025817b9c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/lib/normalizePathSep.js @@ -0,0 +1,68 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +let normalizePathSep; +if (path().sep === '/') { + normalizePathSep = filePath => filePath; +} else { + normalizePathSep = filePath => filePath.replace(/\//g, path().sep); +} +var _default = normalizePathSep; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/types.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/types.js new file mode 100644 index 0000000000000000000000000000000000000000..ad9a93a7c160f02945911772460eb8a1bcb003db --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/types.js @@ -0,0 +1 @@ +'use strict'; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/watchers/FSEventsWatcher.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/watchers/FSEventsWatcher.js new file mode 100644 index 0000000000000000000000000000000000000000..a8b59d7f382b290ed9e09593c439c17137d8fb3e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/watchers/FSEventsWatcher.js @@ -0,0 +1,244 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.FSEventsWatcher = void 0; +function _events() { + const data = require('events'); + _events = function () { + return data; + }; + return data; +} +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _anymatch() { + const data = _interopRequireDefault(require('anymatch')); + _anymatch = function () { + return data; + }; + return data; +} +function fs() { + const data = _interopRequireWildcard(require('graceful-fs')); + fs = function () { + return data; + }; + return data; +} +function _micromatch() { + const data = _interopRequireDefault(require('micromatch')); + _micromatch = function () { + return data; + }; + return data; +} +function _walker() { + const data = _interopRequireDefault(require('walker')); + _walker = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + */ + +// @ts-expect-error no types + +// eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error, @typescript-eslint/ban-ts-comment +// @ts-ignore: this is for CI which runs linux and might not have this +let fsevents = null; +try { + fsevents = require('fsevents'); +} catch { + // Optional dependency, only supported on Darwin. +} +const CHANGE_EVENT = 'change'; +const DELETE_EVENT = 'delete'; +const ADD_EVENT = 'add'; +const ALL_EVENT = 'all'; +/** + * Export `FSEventsWatcher` class. + * Watches `dir`. + */ +class FSEventsWatcher extends _events().EventEmitter { + root; + ignored; + glob; + dot; + hasIgnore; + doIgnore; + fsEventsWatchStopper; + _tracked; + static isSupported() { + return fsevents !== null; + } + static normalizeProxy(callback) { + return (filepath, stats) => callback(path().normalize(filepath), stats); + } + static recReaddir( + dir, + dirCallback, + fileCallback, + endCallback, + errorCallback, + ignored + ) { + (0, _walker().default)(dir) + .filterDir( + currentDir => !ignored || !(0, _anymatch().default)(ignored, currentDir) + ) + .on('dir', FSEventsWatcher.normalizeProxy(dirCallback)) + .on('file', FSEventsWatcher.normalizeProxy(fileCallback)) + .on('error', errorCallback) + .on('end', () => { + endCallback(); + }); + } + constructor(dir, opts) { + if (!fsevents) { + throw new Error( + '`fsevents` unavailable (this watcher can only be used on Darwin)' + ); + } + super(); + this.dot = opts.dot || false; + this.ignored = opts.ignored; + this.glob = Array.isArray(opts.glob) ? opts.glob : [opts.glob]; + this.hasIgnore = + Boolean(opts.ignored) && !(Array.isArray(opts) && opts.length > 0); + this.doIgnore = opts.ignored + ? (0, _anymatch().default)(opts.ignored) + : () => false; + this.root = path().resolve(dir); + this.fsEventsWatchStopper = fsevents.watch( + this.root, + this.handleEvent.bind(this) + ); + this._tracked = new Set(); + FSEventsWatcher.recReaddir( + this.root, + filepath => { + this._tracked.add(filepath); + }, + filepath => { + this._tracked.add(filepath); + }, + this.emit.bind(this, 'ready'), + this.emit.bind(this, 'error'), + this.ignored + ); + } + + /** + * End watching. + */ + async close(callback) { + await this.fsEventsWatchStopper(); + this.removeAllListeners(); + if (typeof callback === 'function') { + process.nextTick(() => callback()); + } + } + isFileIncluded(relativePath) { + if (this.doIgnore(relativePath)) { + return false; + } + return this.glob.length + ? (0, _micromatch().default)([relativePath], this.glob, { + dot: this.dot + }).length > 0 + : this.dot || + (0, _micromatch().default)([relativePath], '**/*').length > 0; + } + handleEvent(filepath) { + const relativePath = path().relative(this.root, filepath); + if (!this.isFileIncluded(relativePath)) { + return; + } + fs().lstat(filepath, (error, stat) => { + if (error && error.code !== 'ENOENT') { + this.emit('error', error); + return; + } + if (error) { + // Ignore files that aren't tracked and don't exist. + if (!this._tracked.has(filepath)) { + return; + } + this._emit(DELETE_EVENT, relativePath); + this._tracked.delete(filepath); + return; + } + if (this._tracked.has(filepath)) { + this._emit(CHANGE_EVENT, relativePath, stat); + } else { + this._tracked.add(filepath); + this._emit(ADD_EVENT, relativePath, stat); + } + }); + } + + /** + * Emit events. + */ + _emit(type, file, stat) { + this.emit(type, file, this.root, stat); + this.emit(ALL_EVENT, type, file, this.root, stat); + } +} +exports.FSEventsWatcher = FSEventsWatcher; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/watchers/NodeWatcher.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/watchers/NodeWatcher.js new file mode 100644 index 0000000000000000000000000000000000000000..62cface561db0cc60322174036216ef867cd86da --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/watchers/NodeWatcher.js @@ -0,0 +1,369 @@ +// vendored from https://github.com/amasad/sane/blob/64ff3a870c42e84f744086884bf55a4f9c22d376/src/node_watcher.js + +'use strict'; + +const EventEmitter = require('events').EventEmitter; +const fs = require('fs'); +const platform = require('os').platform(); +const path = require('path'); +const common = require('./common'); + +/** + * Constants + */ + +const DEFAULT_DELAY = common.DEFAULT_DELAY; +const CHANGE_EVENT = common.CHANGE_EVENT; +const DELETE_EVENT = common.DELETE_EVENT; +const ADD_EVENT = common.ADD_EVENT; +const ALL_EVENT = common.ALL_EVENT; + +/** + * Export `NodeWatcher` class. + * Watches `dir`. + * + * @class NodeWatcher + * @param {String} dir + * @param {Object} opts + * @public + */ + +module.exports = class NodeWatcher extends EventEmitter { + constructor(dir, opts) { + super(); + common.assignOptions(this, opts); + this.watched = Object.create(null); + this.changeTimers = Object.create(null); + this.dirRegistery = Object.create(null); + this.root = path.resolve(dir); + this.watchdir = this.watchdir.bind(this); + this.register = this.register.bind(this); + this.checkedEmitError = this.checkedEmitError.bind(this); + this.watchdir(this.root); + common.recReaddir( + this.root, + this.watchdir, + this.register, + this.emit.bind(this, 'ready'), + this.checkedEmitError, + this.ignored + ); + } + + /** + * Register files that matches our globs to know what to type of event to + * emit in the future. + * + * Registery looks like the following: + * + * dirRegister => Map { + * dirpath => Map { + * filename => true + * } + * } + * + * @param {string} filepath + * @return {boolean} whether or not we have registered the file. + * @private + */ + + register(filepath) { + const relativePath = path.relative(this.root, filepath); + if ( + !common.isFileIncluded(this.globs, this.dot, this.doIgnore, relativePath) + ) { + return false; + } + const dir = path.dirname(filepath); + if (!this.dirRegistery[dir]) { + this.dirRegistery[dir] = Object.create(null); + } + const filename = path.basename(filepath); + this.dirRegistery[dir][filename] = true; + return true; + } + + /** + * Removes a file from the registery. + * + * @param {string} filepath + * @private + */ + + unregister(filepath) { + const dir = path.dirname(filepath); + if (this.dirRegistery[dir]) { + const filename = path.basename(filepath); + delete this.dirRegistery[dir][filename]; + } + } + + /** + * Removes a dir from the registery. + * + * @param {string} dirpath + * @private + */ + + unregisterDir(dirpath) { + if (this.dirRegistery[dirpath]) { + delete this.dirRegistery[dirpath]; + } + } + + /** + * Checks if a file or directory exists in the registery. + * + * @param {string} fullpath + * @return {boolean} + * @private + */ + + registered(fullpath) { + const dir = path.dirname(fullpath); + return ( + this.dirRegistery[fullpath] || + (this.dirRegistery[dir] && + this.dirRegistery[dir][path.basename(fullpath)]) + ); + } + + /** + * Emit "error" event if it's not an ignorable event + * + * @param error + * @private + */ + checkedEmitError(error) { + if (!isIgnorableFileError(error)) { + this.emit('error', error); + } + } + + /** + * Watch a directory. + * + * @param {string} dir + * @private + */ + + watchdir(dir) { + if (this.watched[dir]) { + return; + } + const watcher = fs.watch( + dir, + { + persistent: true + }, + this.normalizeChange.bind(this, dir) + ); + this.watched[dir] = watcher; + watcher.on('error', this.checkedEmitError); + if (this.root !== dir) { + this.register(dir); + } + } + + /** + * Stop watching a directory. + * + * @param {string} dir + * @private + */ + + stopWatching(dir) { + if (this.watched[dir]) { + this.watched[dir].close(); + delete this.watched[dir]; + } + } + + /** + * End watching. + * + * @public + */ + + close() { + Object.keys(this.watched).forEach(this.stopWatching, this); + this.removeAllListeners(); + return Promise.resolve(); + } + + /** + * On some platforms, as pointed out on the fs docs (most likely just win32) + * the file argument might be missing from the fs event. Try to detect what + * change by detecting if something was deleted or the most recent file change. + * + * @param {string} dir + * @param {string} event + * @param {string} file + * @public + */ + + detectChangedFile(dir, event, callback) { + if (!this.dirRegistery[dir]) { + return; + } + let found = false; + let closest = { + mtime: 0 + }; + let c = 0; + Object.keys(this.dirRegistery[dir]).forEach(function (file, i, arr) { + fs.lstat(path.join(dir, file), (error, stat) => { + if (found) { + return; + } + if (error) { + if (isIgnorableFileError(error)) { + found = true; + callback(file); + } else { + this.emit('error', error); + } + } else { + if (stat.mtime > closest.mtime) { + stat.file = file; + closest = stat; + } + if (arr.length === ++c) { + callback(closest.file); + } + } + }); + }, this); + } + + /** + * Normalize fs events and pass it on to be processed. + * + * @param {string} dir + * @param {string} event + * @param {string} file + * @public + */ + + normalizeChange(dir, event, file) { + if (!file) { + this.detectChangedFile(dir, event, actualFile => { + if (actualFile) { + this.processChange(dir, event, actualFile); + } + }); + } else { + this.processChange(dir, event, path.normalize(file)); + } + } + + /** + * Process changes. + * + * @param {string} dir + * @param {string} event + * @param {string} file + * @public + */ + + processChange(dir, event, file) { + const fullPath = path.join(dir, file); + const relativePath = path.join(path.relative(this.root, dir), file); + fs.lstat(fullPath, (error, stat) => { + if (error && error.code !== 'ENOENT') { + this.emit('error', error); + } else if (!error && stat.isDirectory()) { + // win32 emits usless change events on dirs. + if (event !== 'change') { + this.watchdir(fullPath); + if ( + common.isFileIncluded( + this.globs, + this.dot, + this.doIgnore, + relativePath + ) + ) { + this.emitEvent(ADD_EVENT, relativePath, stat); + } + } + } else { + const registered = this.registered(fullPath); + if (error && error.code === 'ENOENT') { + this.unregister(fullPath); + this.stopWatching(fullPath); + this.unregisterDir(fullPath); + if (registered) { + this.emitEvent(DELETE_EVENT, relativePath); + } + } else if (registered) { + this.emitEvent(CHANGE_EVENT, relativePath, stat); + } else { + if (this.register(fullPath)) { + this.emitEvent(ADD_EVENT, relativePath, stat); + } + } + } + }); + } + + /** + * Triggers a 'change' event after debounding it to take care of duplicate + * events on os x. + * + * @private + */ + + emitEvent(type, file, stat) { + const key = `${type}-${file}`; + const addKey = `${ADD_EVENT}-${file}`; + if (type === CHANGE_EVENT && this.changeTimers[addKey]) { + // Ignore the change event that is immediately fired after an add event. + // (This happens on Linux). + return; + } + clearTimeout(this.changeTimers[key]); + this.changeTimers[key] = setTimeout(() => { + delete this.changeTimers[key]; + if (type === ADD_EVENT && stat.isDirectory()) { + // Recursively emit add events and watch for sub-files/folders + common.recReaddir( + path.resolve(this.root, file), + function emitAddDir(dir, stats) { + this.watchdir(dir); + this.rawEmitEvent(ADD_EVENT, path.relative(this.root, dir), stats); + }.bind(this), + function emitAddFile(file, stats) { + this.register(file); + this.rawEmitEvent(ADD_EVENT, path.relative(this.root, file), stats); + }.bind(this), + function endCallback() {}, + this.checkedEmitError, + this.ignored + ); + } else { + this.rawEmitEvent(type, file, stat); + } + }, DEFAULT_DELAY); + } + + /** + * Actually emit the events + */ + rawEmitEvent(type, file, stat) { + this.emit(type, file, this.root, stat); + this.emit(ALL_EVENT, type, file, this.root, stat); + } +}; +/** + * Determine if a given FS error can be ignored + * + * @private + */ +function isIgnorableFileError(error) { + return ( + error.code === 'ENOENT' || + // Workaround Windows node issue #4337. + (error.code === 'EPERM' && platform === 'win32') + ); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/watchers/RecrawlWarning.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/watchers/RecrawlWarning.js new file mode 100644 index 0000000000000000000000000000000000000000..5b1b6d3528dbce198dc624289ec893fd4ccf5607 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/watchers/RecrawlWarning.js @@ -0,0 +1,49 @@ +// vendored from https://github.com/amasad/sane/blob/64ff3a870c42e84f744086884bf55a4f9c22d376/src/utils/recrawl-warning-dedupe.js + +'use strict'; + +class RecrawlWarning { + constructor(root, count) { + this.root = root; + this.count = count; + } + static findByRoot(root) { + for (let i = 0; i < this.RECRAWL_WARNINGS.length; i++) { + const warning = this.RECRAWL_WARNINGS[i]; + if (warning.root === root) { + return warning; + } + } + return undefined; + } + static isRecrawlWarningDupe(warningMessage) { + if (typeof warningMessage !== 'string') { + return false; + } + const match = warningMessage.match(this.REGEXP); + if (!match) { + return false; + } + const count = Number(match[1]); + const root = match[2]; + const warning = this.findByRoot(root); + if (warning) { + // only keep the highest count, assume count to either stay the same or + // increase. + if (warning.count >= count) { + return true; + } else { + // update the existing warning to the latest (highest) count + warning.count = count; + return false; + } + } else { + this.RECRAWL_WARNINGS.push(new RecrawlWarning(root, count)); + return false; + } + } +} +RecrawlWarning.RECRAWL_WARNINGS = []; +RecrawlWarning.REGEXP = + /Recrawled this watch (\d+) times, most recently because:\n([^:]+)/; +module.exports = RecrawlWarning; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/watchers/WatchmanWatcher.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/watchers/WatchmanWatcher.js new file mode 100644 index 0000000000000000000000000000000000000000..7b341687fb8c17d09cfc2bc9ed9901cce388b796 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/watchers/WatchmanWatcher.js @@ -0,0 +1,383 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = WatchmanWatcher; +function _assert() { + const data = require('assert'); + _assert = function () { + return data; + }; + return data; +} +function _events() { + const data = require('events'); + _events = function () { + return data; + }; + return data; +} +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _fbWatchman() { + const data = _interopRequireDefault(require('fb-watchman')); + _fbWatchman = function () { + return data; + }; + return data; +} +function _gracefulFs() { + const data = _interopRequireDefault(require('graceful-fs')); + _gracefulFs = function () { + return data; + }; + return data; +} +var _RecrawlWarning = _interopRequireDefault(require('./RecrawlWarning')); +var _common = _interopRequireDefault(require('./common')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const CHANGE_EVENT = _common.default.CHANGE_EVENT; +const DELETE_EVENT = _common.default.DELETE_EVENT; +const ADD_EVENT = _common.default.ADD_EVENT; +const ALL_EVENT = _common.default.ALL_EVENT; +const SUB_NAME = 'sane-sub'; + +/** + * Watches `dir`. + * + * @class PollWatcher + * @param String dir + * @param {Object} opts + * @public + */ + +function WatchmanWatcher(dir, opts) { + _common.default.assignOptions(this, opts); + this.root = path().resolve(dir); + this.init(); +} +Object.setPrototypeOf( + WatchmanWatcher.prototype, + _events().EventEmitter.prototype +); + +/** + * Run the watchman `watch` command on the root and subscribe to changes. + * + * @private + */ + +WatchmanWatcher.prototype.init = function () { + if (this.client) { + this.client.removeAllListeners(); + } + const self = this; + this.client = new (_fbWatchman().default.Client)(); + this.client.on('error', error => { + self.emit('error', error); + }); + this.client.on('subscription', this.handleChangeEvent.bind(this)); + this.client.on('end', () => { + console.warn('[sane] Warning: Lost connection to watchman, reconnecting..'); + self.init(); + }); + this.watchProjectInfo = null; + function getWatchRoot() { + return self.watchProjectInfo ? self.watchProjectInfo.root : self.root; + } + function onCapability(error, resp) { + if (handleError(self, error)) { + // The Watchman watcher is unusable on this system, we cannot continue + return; + } + handleWarning(resp); + self.capabilities = resp.capabilities; + if (self.capabilities.relative_root) { + self.client.command(['watch-project', getWatchRoot()], onWatchProject); + } else { + self.client.command(['watch', getWatchRoot()], onWatch); + } + } + function onWatchProject(error, resp) { + if (handleError(self, error)) { + return; + } + handleWarning(resp); + self.watchProjectInfo = { + relativePath: resp.relative_path ? resp.relative_path : '', + root: resp.watch + }; + self.client.command(['clock', getWatchRoot()], onClock); + } + function onWatch(error, resp) { + if (handleError(self, error)) { + return; + } + handleWarning(resp); + self.client.command(['clock', getWatchRoot()], onClock); + } + function onClock(error, resp) { + if (handleError(self, error)) { + return; + } + handleWarning(resp); + const options = { + fields: ['name', 'exists', 'new'], + since: resp.clock + }; + + // If the server has the wildmatch capability available it supports + // the recursive **/*.foo style match and we can offload our globs + // to the watchman server. This saves both on data size to be + // communicated back to us and compute for evaluating the globs + // in our node process. + if (self.capabilities.wildmatch) { + if (self.globs.length === 0) { + if (!self.dot) { + // Make sure we honor the dot option if even we're not using globs. + options.expression = [ + 'match', + '**', + 'wholename', + { + includedotfiles: false + } + ]; + } + } else { + options.expression = ['anyof']; + for (const i in self.globs) { + options.expression.push([ + 'match', + self.globs[i], + 'wholename', + { + includedotfiles: self.dot + } + ]); + } + } + } + if (self.capabilities.relative_root) { + options.relative_root = self.watchProjectInfo.relativePath; + } + self.client.command( + ['subscribe', getWatchRoot(), SUB_NAME, options], + onSubscribe + ); + } + function onSubscribe(error, resp) { + if (handleError(self, error)) { + return; + } + handleWarning(resp); + self.emit('ready'); + } + self.client.capabilityCheck( + { + optional: ['wildmatch', 'relative_root'] + }, + onCapability + ); +}; + +/** + * Handles a change event coming from the subscription. + * + * @param {Object} resp + * @private + */ + +WatchmanWatcher.prototype.handleChangeEvent = function (resp) { + _assert().strict.equal( + resp.subscription, + SUB_NAME, + 'Invalid subscription event.' + ); + if (resp.is_fresh_instance) { + this.emit('fresh_instance'); + } + if (resp.is_fresh_instance) { + this.emit('fresh_instance'); + } + if (Array.isArray(resp.files)) { + resp.files.forEach(this.handleFileChange, this); + } +}; + +/** + * Handles a single change event record. + * + * @param {Object} changeDescriptor + * @private + */ + +WatchmanWatcher.prototype.handleFileChange = function (changeDescriptor) { + const self = this; + let absPath; + let relativePath; + if (this.capabilities.relative_root) { + relativePath = changeDescriptor.name; + absPath = path().join( + this.watchProjectInfo.root, + this.watchProjectInfo.relativePath, + relativePath + ); + } else { + absPath = path().join(this.root, changeDescriptor.name); + relativePath = changeDescriptor.name; + } + if ( + !(self.capabilities.wildmatch && !this.hasIgnore) && + !_common.default.isFileIncluded( + this.globs, + this.dot, + this.doIgnore, + relativePath + ) + ) { + return; + } + if (!changeDescriptor.exists) { + self.emitEvent(DELETE_EVENT, relativePath, self.root); + } else { + _gracefulFs().default.lstat(absPath, (error, stat) => { + // Files can be deleted between the event and the lstat call + // the most reliable thing to do here is to ignore the event. + if (error && error.code === 'ENOENT') { + return; + } + if (handleError(self, error)) { + return; + } + const eventType = changeDescriptor.new ? ADD_EVENT : CHANGE_EVENT; + + // Change event on dirs are mostly useless. + if (!(eventType === CHANGE_EVENT && stat.isDirectory())) { + self.emitEvent(eventType, relativePath, self.root, stat); + } + }); + } +}; + +/** + * Dispatches the event. + * + * @param {string} eventType + * @param {string} filepath + * @param {string} root + * @param {fs.Stat} stat + * @private + */ + +WatchmanWatcher.prototype.emitEvent = function ( + eventType, + filepath, + root, + stat +) { + this.emit(eventType, filepath, root, stat); + this.emit(ALL_EVENT, eventType, filepath, root, stat); +}; + +/** + * Closes the watcher. + * + */ + +WatchmanWatcher.prototype.close = function () { + this.client.removeAllListeners(); + this.client.end(); + return Promise.resolve(); +}; + +/** + * Handles an error and returns true if exists. + * + * @param {WatchmanWatcher} self + * @param {Error} error + * @private + */ + +function handleError(self, error) { + if (error != null) { + self.emit('error', error); + return true; + } else { + return false; + } +} + +/** + * Handles a warning in the watchman resp object. + * + * @param {object} resp + * @private + */ + +function handleWarning(resp) { + if ('warning' in resp) { + if (_RecrawlWarning.default.isRecrawlWarningDupe(resp.warning)) { + return true; + } + console.warn(resp.warning); + return true; + } else { + return false; + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/watchers/common.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/watchers/common.js new file mode 100644 index 0000000000000000000000000000000000000000..b8fa0c30bdaa10b46e6c70eb9b4f29072b6f97f5 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/watchers/common.js @@ -0,0 +1,111 @@ +// vendored from https://github.com/amasad/sane/blob/64ff3a870c42e84f744086884bf55a4f9c22d376/src/common.js + +'use strict'; + +const platform = require('os').platform(); +const path = require('path'); +const anymatch = require('anymatch'); +const micromatch = require('micromatch'); +const walker = require('walker'); + +/** + * Constants + */ + +exports.DEFAULT_DELAY = 100; +exports.CHANGE_EVENT = 'change'; +exports.DELETE_EVENT = 'delete'; +exports.ADD_EVENT = 'add'; +exports.ALL_EVENT = 'all'; + +/** + * Assigns options to the watcher. + * + * @param {NodeWatcher|PollWatcher|WatchmanWatcher} watcher + * @param {?object} opts + * @return {boolean} + * @public + */ + +exports.assignOptions = function (watcher, opts) { + opts = opts || {}; + watcher.globs = opts.glob || []; + watcher.dot = opts.dot || false; + watcher.ignored = opts.ignored || false; + if (!Array.isArray(watcher.globs)) { + watcher.globs = [watcher.globs]; + } + watcher.hasIgnore = + Boolean(opts.ignored) && !(Array.isArray(opts) && opts.length > 0); + watcher.doIgnore = opts.ignored ? anymatch(opts.ignored) : () => false; + if (opts.watchman && opts.watchmanPath) { + watcher.watchmanPath = opts.watchmanPath; + } + return opts; +}; + +/** + * Checks a file relative path against the globs array. + * + * @param {array} globs + * @param {string} relativePath + * @return {boolean} + * @public + */ + +exports.isFileIncluded = function (globs, dot, doIgnore, relativePath) { + if (doIgnore(relativePath)) { + return false; + } + return globs.length + ? micromatch.some(relativePath, globs, { + dot + }) + : dot || micromatch.some(relativePath, '**/*'); +}; + +/** + * Traverse a directory recursively calling `callback` on every directory. + * + * @param {string} dir + * @param {function} dirCallback + * @param {function} fileCallback + * @param {function} endCallback + * @param {*} ignored + * @public + */ + +exports.recReaddir = function ( + dir, + dirCallback, + fileCallback, + endCallback, + errorCallback, + ignored +) { + walker(dir) + .filterDir(currentDir => !anymatch(ignored, currentDir)) + .on('dir', normalizeProxy(dirCallback)) + .on('file', normalizeProxy(fileCallback)) + .on('error', errorCallback) + .on('end', () => { + if (platform === 'win32') { + setTimeout(endCallback, 1000); + } else { + endCallback(); + } + }); +}; + +/** + * Returns a callback that when called will normalize a path and call the + * original callback + * + * @param {function} callback + * @return {function} + * @private + */ + +function normalizeProxy(callback) { + return (filepath, stats) => callback(path.normalize(filepath), stats); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/worker.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/worker.js new file mode 100644 index 0000000000000000000000000000000000000000..7f27df08d7251b1ddc23737ad525ae1f01734729 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/build/worker.js @@ -0,0 +1,180 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.getSha1 = getSha1; +exports.worker = worker; +function _crypto() { + const data = require('crypto'); + _crypto = function () { + return data; + }; + return data; +} +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function fs() { + const data = _interopRequireWildcard(require('graceful-fs')); + fs = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +var _blacklist = _interopRequireDefault(require('./blacklist')); +var _constants = _interopRequireDefault(require('./constants')); +var _dependencyExtractor = require('./lib/dependencyExtractor'); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const PACKAGE_JSON = `${path().sep}package.json`; +let hasteImpl = null; +let hasteImplModulePath = null; +function sha1hex(content) { + return (0, _crypto().createHash)('sha1').update(content).digest('hex'); +} +async function worker(data) { + if ( + data.hasteImplModulePath && + data.hasteImplModulePath !== hasteImplModulePath + ) { + if (hasteImpl) { + throw new Error('jest-haste-map: hasteImplModulePath changed'); + } + hasteImplModulePath = data.hasteImplModulePath; + hasteImpl = require(hasteImplModulePath); + } + let content; + let dependencies; + let id; + let module; + let sha1; + const {computeDependencies, computeSha1, rootDir, filePath} = data; + const getContent = () => { + if (content === undefined) { + content = fs().readFileSync(filePath, 'utf8'); + } + return content; + }; + if (filePath.endsWith(PACKAGE_JSON)) { + // Process a package.json that is returned as a PACKAGE type with its name. + try { + const fileData = JSON.parse(getContent()); + if (fileData.name) { + const relativeFilePath = path().relative(rootDir, filePath); + id = fileData.name; + module = [relativeFilePath, _constants.default.PACKAGE]; + } + } catch (err) { + throw new Error(`Cannot parse ${filePath} as JSON: ${err.message}`); + } + } else if ( + !_blacklist.default.has(filePath.substring(filePath.lastIndexOf('.'))) + ) { + // Process a random file that is returned as a MODULE. + if (hasteImpl) { + id = hasteImpl.getHasteName(filePath); + } + if (computeDependencies) { + const content = getContent(); + const extractor = data.dependencyExtractor + ? await (0, _jestUtil().requireOrImportModule)( + data.dependencyExtractor, + false + ) + : _dependencyExtractor.extractor; + dependencies = Array.from( + extractor.extract( + content, + filePath, + _dependencyExtractor.extractor.extract + ) + ); + } + if (id) { + const relativeFilePath = path().relative(rootDir, filePath); + module = [relativeFilePath, _constants.default.MODULE]; + } + } + + // If a SHA-1 is requested on update, compute it. + if (computeSha1) { + sha1 = sha1hex(content || fs().readFileSync(filePath)); + } + return { + dependencies, + id, + module, + sha1 + }; +} +async function getSha1(data) { + const sha1 = data.computeSha1 + ? sha1hex(fs().readFileSync(data.filePath)) + : null; + return { + dependencies: undefined, + id: undefined, + module: undefined, + sha1 + }; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/package.json new file mode 100644 index 0000000000000000000000000000000000000000..ee459fdff926c11c17110c05124251fdfa0fd26e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-haste-map/package.json @@ -0,0 +1,47 @@ +{ + "name": "jest-haste-map", + "version": "29.7.0", + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/jest-haste-map" + }, + "license": "MIT", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "dependencies": { + "@jest/types": "^29.6.3", + "@types/graceful-fs": "^4.1.3", + "@types/node": "*", + "anymatch": "^3.0.3", + "fb-watchman": "^2.0.0", + "graceful-fs": "^4.2.9", + "jest-regex-util": "^29.6.3", + "jest-util": "^29.7.0", + "jest-worker": "^29.7.0", + "micromatch": "^4.0.4", + "walker": "^1.0.8" + }, + "devDependencies": { + "@types/fb-watchman": "^2.0.0", + "@types/micromatch": "^4.0.1", + "slash": "^3.0.0" + }, + "optionalDependencies": { + "fsevents": "^2.3.2" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "publishConfig": { + "access": "public" + }, + "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-regex-util/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-regex-util/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-regex-util/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-regex-util/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-regex-util/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8de7081045133753a839e978a29a0c0d612fa6c0 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-regex-util/build/index.d.ts @@ -0,0 +1,20 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + */ +export declare const escapePathForRegex: (dir: string) => string; + +export declare const escapeStrForRegex: (string: string) => string; + +export declare const replacePathSepForRegex: (string: string) => string; + +export {}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-regex-util/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-regex-util/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..0bb27016d51ed693d3c951f27cd2e8d84997a661 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-regex-util/build/index.js @@ -0,0 +1,40 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.replacePathSepForRegex = + exports.escapeStrForRegex = + exports.escapePathForRegex = + void 0; +var _path = require('path'); +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + */ + +const escapePathForRegex = dir => { + if (_path.sep === '\\') { + // Replace "\" with "/" so it's not escaped by escapeStrForRegex. + // replacePathSepForRegex will convert it back. + dir = dir.replace(/\\/g, '/'); + } + return replacePathSepForRegex(escapeStrForRegex(dir)); +}; +exports.escapePathForRegex = escapePathForRegex; +const escapeStrForRegex = string => + string.replace(/[[\]{}()*+?.\\^$|]/g, '\\$&'); +exports.escapeStrForRegex = escapeStrForRegex; +const replacePathSepForRegex = string => { + if (_path.sep === '\\') { + return string.replace( + /(\/|(.)?\\(?![[\]{}()*+?.^$|\\]))/g, + (_match, _, p2) => (p2 && p2 !== '\\' ? `${p2}\\\\` : '\\\\') + ); + } + return string; +}; +exports.replacePathSepForRegex = replacePathSepForRegex; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-regex-util/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-regex-util/package.json new file mode 100644 index 0000000000000000000000000000000000000000..ed8bc70707d3fc647eaf310d5cd0060b5cfbdb9d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-regex-util/package.json @@ -0,0 +1,29 @@ +{ + "name": "jest-regex-util", + "version": "29.6.3", + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/jest-regex-util" + }, + "devDependencies": { + "@types/node": "*" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "license": "MIT", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "publishConfig": { + "access": "public" + }, + "gitHead": "fb7d95c8af6e0d65a8b65348433d8a0ea0725b5b" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f9e1131c95e794f7399c3fd25354ec19d20a8b96 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/README.md @@ -0,0 +1,272 @@ +# jest-worker + +Module for executing heavy tasks under forked processes in parallel, by providing a `Promise` based interface, minimum overhead, and bound workers. + +The module works by providing an absolute path of the module to be loaded in all forked processes. All methods are exposed on the parent process as promises, so they can be `await`'ed. Child (worker) methods can either be synchronous or asynchronous. + +The module also implements support for bound workers. Binding a worker means that, based on certain parameters, the same task will always be executed by the same worker. The way bound workers work is by using the returned string of the `computeWorkerKey` method. If the string was used before for a task, the call will be queued to the related worker that processed the task earlier; if not, it will be executed by the first available worker, then sticked to the worker that executed it; so the next time it will be processed by the same worker. If you have no preference on the worker executing the task, but you have defined a `computeWorkerKey` method because you want _some_ of the tasks to be sticked, you can return `null` from it. + +The list of exposed methods can be explicitly provided via the `exposedMethods` option. If it is not provided, it will be obtained by requiring the child module into the main process, and analyzed via reflection. Check the "minimal example" section for a valid one. + +## Install + +```sh +yarn add jest-worker +``` + +## Example + +This example covers the minimal usage: + +### File `parent.js` + +```js +import {Worker as JestWorker} from 'jest-worker'; + +async function main() { + const worker = new JestWorker(require.resolve('./worker')); + const result = await worker.hello('Alice'); // "Hello, Alice" +} + +main(); +``` + +### File `worker.js` + +```js +export function hello(param) { + return `Hello, ${param}`; +} +``` + +## Experimental worker + +Node shipped with [`worker_threads`](https://nodejs.org/api/worker_threads.html), a "threading API" that uses `SharedArrayBuffers` to communicate between the main process and its child threads. This feature can significantly improve the communication time between parent and child processes in `jest-worker`. + +To use `worker_threads` instead of default `child_process` you have to pass `enableWorkerThreads: true` when instantiating the worker. + +## API + +The `Worker` export is a constructor that is initialized by passing the worker path, plus an options object. + +### `workerPath: string | URL` (required) + +Node module name or absolute path or file URL of the file to be loaded in the child processes. You can use `require.resolve` to transform a relative path into an absolute one. + +### `options: Object` (optional) + +#### `computeWorkerKey: (method: string, ...args: Array) => string | null` (optional) + +Every time a method exposed via the API is called, `computeWorkerKey` is also called in order to bound the call to a worker. This is useful for workers that are able to cache the result or part of it. You bound calls to a worker by making `computeWorkerKey` return the same identifier for all different calls. If you do not want to bind the call to any worker, return `null`. + +The callback you provide is called with the method name, plus all the rest of the arguments of the call. Thus, you have full control to decide what to return. Check a practical example on bound workers under the "bound worker usage" section. + +By default, no process is bound to any worker. + +#### `enableWorkerThreads: boolean` (optional) + +By default, `jest-worker` will use `child_process` threads to spawn new Node.js processes. If you prefer [`worker_threads`](https://nodejs.org/api/worker_threads.html) instead, pass `enableWorkerThreads: true`. + +#### `exposedMethods: ReadonlyArray` (optional) + +List of method names that can be called on the child processes from the parent process. You cannot expose any method named like a public `Worker` method, or starting with `_`. If you use method auto-discovery, then these methods will not be exposed, even if they exist. + +#### `forkOptions: ForkOptions` (optional) + +Allow customizing all options passed to `child_process.fork`. By default, some values are set (`cwd`, `env`, `execArgv` and `serialization`), but you can override them and customize the rest. For a list of valid values, check [the Node documentation](https://nodejs.org/api/child_process.html#child_process_child_process_fork_modulepath_args_options). + +#### `idleMemoryLimit: number` (optional) + +Specifies the memory limit for workers before they are recycled and is primarily a work-around for [this issue](https://github.com/jestjs/jest/issues/11956); + +After the worker has executed a task the memory usage of it is checked. If it exceeds the value specified the worker is killed and restarted. If no limit is set this process does not occur. The limit can be specified in 2 ways: + +- `<= 1` - The value is assumed to be a percentage of system memory. So 0.5 sets the memory limit of the worker to half of the total system memory +- `\> 1` - Assumed to be a fixed byte value. Because of the previous rule if you wanted a value of 1 byte (I don't know why) you could use `1.1`. + +#### `maxRetries: number` (optional) + +Maximum amount of times that a dead child can be re-spawned, per call. Defaults to `3`, pass `Infinity` to allow endless retries. + +#### `numWorkers: number` (optional) + +Amount of workers to spawn. Defaults to the number of CPUs minus 1. + +#### `resourceLimits: ResourceLimits` (optional) + +The `resourceLimits` option which will be passed to `worker_threads` workers. + +#### `silent: Boolean` (optional) + +Set to false for `stdout` and `stderr` to be logged to console. + +By default this is true. + +#### `setupArgs: Array` (optional) + +The arguments that will be passed to the `setup` method during initialization. + +#### `taskQueue: TaskQueue` (optional) + +The task queue defines in which order tasks (method calls) are processed by the workers. `jest-worker` ships with a `FifoQueue` and `PriorityQueue`: + +- `FifoQueue` (default): Processes the method calls (tasks) in the call order. +- `PriorityQueue`: Processes the method calls by a computed priority in natural ordering (lower priorities first). Tasks with the same priority are processed in any order (FIFO not guaranteed). The constructor accepts a single argument, the function that is passed the name of the called function and the arguments and returns a numerical value for the priority: `new require('jest-worker').PriorityQueue((method, filename) => filename.length)`. + +#### `WorkerPool: new (workerPath: string, options?: WorkerPoolOptions) => WorkerPoolInterface` (optional) + +Provide a custom WorkerPool class to be used for spawning child processes. + +#### `workerSchedulingPolicy: 'round-robin' | 'in-order'` (optional) + +Specifies the policy how tasks are assigned to workers if multiple workers are _idle_: + +- `round-robin` (default): The task will be sequentially distributed onto the workers. The first task is assigned to the worker 1, the second to the worker 2, to ensure that the work is distributed across workers. +- `in-order`: The task will be assigned to the first free worker starting with worker 1 and only assign the work to worker 2 if the worker 1 is busy. + +Tasks are always assigned to the first free worker as soon as tasks start to queue up. The scheduling policy does not define the task scheduling which is always first-in, first-out. + +## JestWorker + +### Methods + +The returned `JestWorker` instance has all the exposed methods, plus some additional ones to interact with the workers itself: + +#### `getStdout(): Readable` + +Returns a `ReadableStream` where the standard output of all workers is piped. Note that the `silent` option of the child workers must be set to `true` to make it work. This is the default set by `jest-worker`, but keep it in mind when overriding options through `forkOptions`. + +#### `getStderr(): Readable` + +Returns a `ReadableStream` where the standard error of all workers is piped. Note that the `silent` option of the child workers must be set to `true` to make it work. This is the default set by `jest-worker`, but keep it in mind when overriding options through `forkOptions`. + +#### `start()` + +Starts up every worker and calls their `setup` function, if it exists. Returns a `Promise` which resolves when all workers are running and have completed their `setup`. + +This is useful if you want to start up all your workers eagerly before they are used to call any other functions. + +#### `end()` + +Finishes the workers by killing all workers. No further calls can be done to the `Worker` instance. + +Returns a `Promise` that resolves with `{ forceExited: boolean }` once all workers are dead. If `forceExited` is `true`, at least one of the workers did not exit gracefully, which likely happened because it executed a leaky task that left handles open. This should be avoided, force exiting workers is a last resort to prevent creating lots of orphans. + +**Note:** + +`await`ing the `end()` Promise immediately after the workers are no longer needed before proceeding to do other useful things in your program may not be a good idea. If workers have to be force exited, `jest-worker` may go through multiple stages of force exiting (e.g. SIGTERM, later SIGKILL) and give the worker overall around 1 second time to exit on its own. During this time, your program will wait, even though it may not be necessary that all workers are dead before continuing execution. + +Consider deliberately leaving this Promise floating (unhandled resolution). After your program has done the rest of its work and is about to exit, the Node process will wait for the Promise to resolve after all workers are dead as the last event loop task. That way you parallelized computation time of your program and waiting time and you didn't delay the outputs of your program unnecessarily. + +### Worker IDs + +Each worker has a unique id (index that starts with `'1'`), which is available inside the worker as `process.env.JEST_WORKER_ID`. + +## Setting up and tearing down the child process + +The child process can define two special methods (both of them can be asynchronous): + +- `setup()`: If defined, it's executed before the first call to any method in the child. +- `teardown()`: If defined, it's executed when the farm ends. + +# More examples + +## Standard usage + +This example covers the standard usage: + +### File `parent.js` + +```js +import {Worker as JestWorker} from 'jest-worker'; + +async function main() { + const myWorker = new JestWorker(require.resolve('./worker'), { + exposedMethods: ['foo', 'bar', 'getWorkerId'], + numWorkers: 4, + }); + + console.log(await myWorker.foo('Alice')); // "Hello from foo: Alice" + console.log(await myWorker.bar('Bob')); // "Hello from bar: Bob" + console.log(await myWorker.getWorkerId()); // "3" -> this message has sent from the 3rd worker + + const {forceExited} = await myWorker.end(); + if (forceExited) { + console.error('Workers failed to exit gracefully'); + } +} + +main(); +``` + +### File `worker.js` + +```js +export function foo(param) { + return `Hello from foo: ${param}`; +} + +export function bar(param) { + return `Hello from bar: ${param}`; +} + +export function getWorkerId() { + return process.env.JEST_WORKER_ID; +} +``` + +## Bound worker usage: + +This example covers the usage with a `computeWorkerKey` method: + +### File `parent.js` + +```js +import {Worker as JestWorker} from 'jest-worker'; + +async function main() { + const myWorker = new JestWorker(require.resolve('./worker'), { + computeWorkerKey: (method, filename) => filename, + }); + + // Transform the given file, within the first available worker. + console.log(await myWorker.transform('/tmp/foo.js')); + + // Wait a bit. + await sleep(10000); + + // Transform the same file again. Will immediately return because the + // transformed file is cached in the worker, and `computeWorkerKey` ensures + // the same worker that processed the file the first time will process it now. + console.log(await myWorker.transform('/tmp/foo.js')); + + const {forceExited} = await myWorker.end(); + if (forceExited) { + console.error('Workers failed to exit gracefully'); + } +} + +main(); +``` + +### File `worker.js` + +```js +import babel from '@babel/core'; + +const cache = Object.create(null); + +export function transform(filename) { + if (cache[filename]) { + return cache[filename]; + } + + // jest-worker can handle both immediate results and thenables. If a + // thenable is returned, it will be await'ed until it resolves. + return babel.transformFileAsync(filename).then(result => { + cache[filename] = result; + + return result; + }); +} +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/Farm.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/Farm.js new file mode 100644 index 0000000000000000000000000000000000000000..bb9accf675771738ace59536349701701db1183e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/Farm.js @@ -0,0 +1,152 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +var _FifoQueue = _interopRequireDefault(require('./FifoQueue')); +var _types = require('./types'); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class Farm { + _computeWorkerKey; + _workerSchedulingPolicy; + _cacheKeys = Object.create(null); + _locks = []; + _offset = 0; + _taskQueue; + constructor(_numOfWorkers, _callback, options = {}) { + this._numOfWorkers = _numOfWorkers; + this._callback = _callback; + this._computeWorkerKey = options.computeWorkerKey; + this._workerSchedulingPolicy = + options.workerSchedulingPolicy ?? 'round-robin'; + this._taskQueue = options.taskQueue ?? new _FifoQueue.default(); + } + doWork(method, ...args) { + const customMessageListeners = new Set(); + const addCustomMessageListener = listener => { + customMessageListeners.add(listener); + return () => { + customMessageListeners.delete(listener); + }; + }; + const onCustomMessage = message => { + customMessageListeners.forEach(listener => listener(message)); + }; + const promise = new Promise( + // Bind args to this function so it won't reference to the parent scope. + // This prevents a memory leak in v8, because otherwise the function will + // retain args for the closure. + ((args, resolve, reject) => { + const computeWorkerKey = this._computeWorkerKey; + const request = [_types.CHILD_MESSAGE_CALL, false, method, args]; + let worker = null; + let hash = null; + if (computeWorkerKey) { + hash = computeWorkerKey.call(this, method, ...args); + worker = hash == null ? null : this._cacheKeys[hash]; + } + const onStart = worker => { + if (hash != null) { + this._cacheKeys[hash] = worker; + } + }; + const onEnd = (error, result) => { + customMessageListeners.clear(); + if (error) { + reject(error); + } else { + resolve(result); + } + }; + const task = { + onCustomMessage, + onEnd, + onStart, + request + }; + if (worker) { + this._taskQueue.enqueue(task, worker.getWorkerId()); + this._process(worker.getWorkerId()); + } else { + this._push(task); + } + }).bind(null, args) + ); + promise.UNSTABLE_onCustomMessage = addCustomMessageListener; + return promise; + } + _process(workerId) { + if (this._isLocked(workerId)) { + return this; + } + const task = this._taskQueue.dequeue(workerId); + if (!task) { + return this; + } + if (task.request[1]) { + throw new Error('Queue implementation returned processed task'); + } + + // Reference the task object outside so it won't be retained by onEnd, + // and other properties of the task object, such as task.request can be + // garbage collected. + let taskOnEnd = task.onEnd; + const onEnd = (error, result) => { + if (taskOnEnd) { + taskOnEnd(error, result); + } + taskOnEnd = null; + this._unlock(workerId); + this._process(workerId); + }; + task.request[1] = true; + this._lock(workerId); + this._callback( + workerId, + task.request, + task.onStart, + onEnd, + task.onCustomMessage + ); + return this; + } + _push(task) { + this._taskQueue.enqueue(task); + const offset = this._getNextWorkerOffset(); + for (let i = 0; i < this._numOfWorkers; i++) { + this._process((offset + i) % this._numOfWorkers); + if (task.request[1]) { + break; + } + } + return this; + } + _getNextWorkerOffset() { + switch (this._workerSchedulingPolicy) { + case 'in-order': + return 0; + case 'round-robin': + return this._offset++; + } + } + _lock(workerId) { + this._locks[workerId] = true; + } + _unlock(workerId) { + this._locks[workerId] = false; + } + _isLocked(workerId) { + return this._locks[workerId]; + } +} +exports.default = Farm; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/FifoQueue.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/FifoQueue.js new file mode 100644 index 0000000000000000000000000000000000000000..1831e024b876617bd0bd00bf904b222e831016b3 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/FifoQueue.js @@ -0,0 +1,89 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +/** + * First-in, First-out task queue that manages a dedicated pool + * for each worker as well as a shared queue. The FIFO ordering is guaranteed + * across the worker specific and shared queue. + */ +class FifoQueue { + _workerQueues = []; + _sharedQueue = new InternalQueue(); + enqueue(task, workerId) { + if (workerId == null) { + this._sharedQueue.enqueue(task); + return; + } + let workerQueue = this._workerQueues[workerId]; + if (workerQueue == null) { + workerQueue = this._workerQueues[workerId] = new InternalQueue(); + } + const sharedTop = this._sharedQueue.peekLast(); + const item = { + previousSharedTask: sharedTop, + task + }; + workerQueue.enqueue(item); + } + dequeue(workerId) { + const workerTop = this._workerQueues[workerId]?.peek(); + const sharedTaskIsProcessed = + workerTop?.previousSharedTask?.request[1] ?? true; + + // Process the top task from the shared queue if + // - there's no task in the worker specific queue or + // - if the non-worker-specific task after which this worker specific task + // has been queued wasn't processed yet + if (workerTop != null && sharedTaskIsProcessed) { + return this._workerQueues[workerId]?.dequeue()?.task ?? null; + } + return this._sharedQueue.dequeue(); + } +} +exports.default = FifoQueue; +/** + * FIFO queue for a single worker / shared queue. + */ +class InternalQueue { + _head = null; + _last = null; + enqueue(value) { + const item = { + next: null, + value + }; + if (this._last == null) { + this._head = item; + } else { + this._last.next = item; + } + this._last = item; + } + dequeue() { + if (this._head == null) { + return null; + } + const item = this._head; + this._head = item.next; + if (this._head == null) { + this._last = null; + } + return item.value; + } + peek() { + return this._head?.value ?? null; + } + peekLast() { + return this._last?.value ?? null; + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/PriorityQueue.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/PriorityQueue.js new file mode 100644 index 0000000000000000000000000000000000000000..6218a8ea6186fffb90656d6a914f11bf704a1ce9 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/PriorityQueue.js @@ -0,0 +1,137 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +/** + * Priority queue that processes tasks in natural ordering (lower priority first) + * according to the priority computed by the function passed in the constructor. + * + * FIFO ordering isn't guaranteed for tasks with the same priority. + * + * Worker specific tasks with the same priority as a non-worker specific task + * are always processed first. + */ +class PriorityQueue { + _queue = []; + _sharedQueue = new MinHeap(); + constructor(_computePriority) { + this._computePriority = _computePriority; + } + enqueue(task, workerId) { + if (workerId == null) { + this._enqueue(task, this._sharedQueue); + } else { + const queue = this._getWorkerQueue(workerId); + this._enqueue(task, queue); + } + } + _enqueue(task, queue) { + const item = { + priority: this._computePriority(task.request[2], ...task.request[3]), + task + }; + queue.add(item); + } + dequeue(workerId) { + const workerQueue = this._getWorkerQueue(workerId); + const workerTop = workerQueue.peek(); + const sharedTop = this._sharedQueue.peek(); + + // use the task from the worker queue if there's no task in the shared queue + // or if the priority of the worker queue is smaller or equal to the + // priority of the top task in the shared queue. The tasks of the + // worker specific queue are preferred because no other worker can pick this + // specific task up. + if ( + sharedTop == null || + (workerTop != null && workerTop.priority <= sharedTop.priority) + ) { + return workerQueue.poll()?.task ?? null; + } + return this._sharedQueue.poll().task; + } + _getWorkerQueue(workerId) { + let queue = this._queue[workerId]; + if (queue == null) { + queue = this._queue[workerId] = new MinHeap(); + } + return queue; + } +} +exports.default = PriorityQueue; +class MinHeap { + _heap = []; + peek() { + return this._heap[0] ?? null; + } + add(item) { + const nodes = this._heap; + nodes.push(item); + if (nodes.length === 1) { + return; + } + let currentIndex = nodes.length - 1; + + // Bubble up the added node as long as the parent is bigger + while (currentIndex > 0) { + const parentIndex = Math.floor((currentIndex + 1) / 2) - 1; + const parent = nodes[parentIndex]; + if (parent.priority <= item.priority) { + break; + } + nodes[currentIndex] = parent; + nodes[parentIndex] = item; + currentIndex = parentIndex; + } + } + poll() { + const nodes = this._heap; + const result = nodes[0]; + const lastElement = nodes.pop(); + + // heap was empty or removed the last element + if (result == null || nodes.length === 0) { + return result ?? null; + } + let index = 0; + nodes[0] = lastElement ?? null; + const element = nodes[0]; + while (true) { + let swapIndex = null; + const rightChildIndex = (index + 1) * 2; + const leftChildIndex = rightChildIndex - 1; + const rightChild = nodes[rightChildIndex]; + const leftChild = nodes[leftChildIndex]; + + // if the left child is smaller, swap with the left + if (leftChild != null && leftChild.priority < element.priority) { + swapIndex = leftChildIndex; + } + + // If the right child is smaller or the right child is smaller than the left + // then swap with the right child + if ( + rightChild != null && + rightChild.priority < (swapIndex == null ? element : leftChild).priority + ) { + swapIndex = rightChildIndex; + } + if (swapIndex == null) { + break; + } + nodes[index] = nodes[swapIndex]; + nodes[swapIndex] = element; + index = swapIndex; + } + return result; + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/WorkerPool.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/WorkerPool.js new file mode 100644 index 0000000000000000000000000000000000000000..b1e439d2c53e7a33a6431a9b066d91816252d30e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/WorkerPool.js @@ -0,0 +1,34 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +var _BaseWorkerPool = _interopRequireDefault(require('./base/BaseWorkerPool')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class WorkerPool extends _BaseWorkerPool.default { + send(workerId, request, onStart, onEnd, onCustomMessage) { + this.restartWorkerIfShutDown(workerId); + this.getWorkerById(workerId).send(request, onStart, onEnd, onCustomMessage); + } + createWorker(workerOptions) { + let Worker; + if (this._options.enableWorkerThreads) { + Worker = require('./workers/NodeThreadsWorker').default; + } else { + Worker = require('./workers/ChildProcessWorker').default; + } + return new Worker(workerOptions); + } +} +var _default = WorkerPool; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/base/BaseWorkerPool.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/base/BaseWorkerPool.js new file mode 100644 index 0000000000000000000000000000000000000000..b49d061d78d293f256c7dff0bd123d73479e69df --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/base/BaseWorkerPool.js @@ -0,0 +1,156 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _mergeStream() { + const data = _interopRequireDefault(require('merge-stream')); + _mergeStream = function () { + return data; + }; + return data; +} +var _types = require('../types'); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// How long to wait for the child process to terminate +// after CHILD_MESSAGE_END before sending force exiting. +const FORCE_EXIT_DELAY = 500; + +/* istanbul ignore next */ +// eslint-disable-next-line @typescript-eslint/no-empty-function +const emptyMethod = () => {}; +class BaseWorkerPool { + _stderr; + _stdout; + _options; + _workers; + _workerPath; + constructor(workerPath, options) { + this._options = options; + this._workerPath = workerPath; + this._workers = new Array(options.numWorkers); + const stdout = (0, _mergeStream().default)(); + const stderr = (0, _mergeStream().default)(); + const {forkOptions, maxRetries, resourceLimits, setupArgs} = options; + for (let i = 0; i < options.numWorkers; i++) { + const workerOptions = { + forkOptions, + idleMemoryLimit: this._options.idleMemoryLimit, + maxRetries, + resourceLimits, + setupArgs, + workerId: i, + workerPath + }; + const worker = this.createWorker(workerOptions); + const workerStdout = worker.getStdout(); + const workerStderr = worker.getStderr(); + if (workerStdout) { + stdout.add(workerStdout); + } + if (workerStderr) { + stderr.add(workerStderr); + } + this._workers[i] = worker; + } + this._stdout = stdout; + this._stderr = stderr; + } + getStderr() { + return this._stderr; + } + getStdout() { + return this._stdout; + } + getWorkers() { + return this._workers; + } + getWorkerById(workerId) { + return this._workers[workerId]; + } + restartWorkerIfShutDown(workerId) { + if (this._workers[workerId].state === _types.WorkerStates.SHUT_DOWN) { + const {forkOptions, maxRetries, resourceLimits, setupArgs} = + this._options; + const workerOptions = { + forkOptions, + idleMemoryLimit: this._options.idleMemoryLimit, + maxRetries, + resourceLimits, + setupArgs, + workerId, + workerPath: this._workerPath + }; + const worker = this.createWorker(workerOptions); + this._workers[workerId] = worker; + } + } + createWorker(_workerOptions) { + throw Error('Missing method createWorker in WorkerPool'); + } + async start() { + await Promise.all( + this._workers.map(async worker => { + await worker.waitForWorkerReady(); + await new Promise((resolve, reject) => { + worker.send( + [_types.CHILD_MESSAGE_CALL_SETUP], + emptyMethod, + error => { + if (error) { + reject(error); + } else { + resolve(); + } + }, + emptyMethod + ); + }); + }) + ); + } + async end() { + // We do not cache the request object here. If so, it would only be only + // processed by one of the workers, and we want them all to close. + const workerExitPromises = this._workers.map(async worker => { + worker.send( + [_types.CHILD_MESSAGE_END, false], + emptyMethod, + emptyMethod, + emptyMethod + ); + + // Schedule a force exit in case worker fails to exit gracefully so + // await worker.waitForExit() never takes longer than FORCE_EXIT_DELAY + let forceExited = false; + const forceExitTimeout = setTimeout(() => { + worker.forceExit(); + forceExited = true; + }, FORCE_EXIT_DELAY); + await worker.waitForExit(); + // Worker ideally exited gracefully, don't send force exit then + clearTimeout(forceExitTimeout); + return forceExited; + }); + const workerExits = await Promise.all(workerExitPromises); + return workerExits.reduce( + (result, forceExited) => ({ + forceExited: result.forceExited || forceExited + }), + { + forceExited: false + } + ); + } +} +exports.default = BaseWorkerPool; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8f25376839df6060786fa173cc4f6753e8f43d4d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/index.d.ts @@ -0,0 +1,355 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/// + +import type {ForkOptions} from 'child_process'; +import type {ResourceLimits} from 'worker_threads'; + +declare const CHILD_MESSAGE_CALL = 1; + +declare const CHILD_MESSAGE_CALL_SETUP = 4; + +declare const CHILD_MESSAGE_END = 2; + +declare const CHILD_MESSAGE_INITIALIZE = 0; + +declare const CHILD_MESSAGE_MEM_USAGE = 3; + +declare type ChildMessage = + | ChildMessageInitialize + | ChildMessageCall + | ChildMessageEnd + | ChildMessageMemUsage + | ChildMessageCallSetup; + +declare type ChildMessageCall = [ + type: typeof CHILD_MESSAGE_CALL, + isProcessed: boolean, + methodName: string, + args: Array, +]; + +declare type ChildMessageCallSetup = [type: typeof CHILD_MESSAGE_CALL_SETUP]; + +declare type ChildMessageEnd = [ + type: typeof CHILD_MESSAGE_END, + isProcessed: boolean, +]; + +declare type ChildMessageInitialize = [ + type: typeof CHILD_MESSAGE_INITIALIZE, + isProcessed: boolean, + fileName: string, + setupArgs: Array, + workerId: string | undefined, +]; + +declare type ChildMessageMemUsage = [type: typeof CHILD_MESSAGE_MEM_USAGE]; + +declare type ComputeTaskPriorityCallback = ( + method: string, + ...args: Array +) => number; + +declare type ExcludeReservedKeys = Exclude; + +/** + * First-in, First-out task queue that manages a dedicated pool + * for each worker as well as a shared queue. The FIFO ordering is guaranteed + * across the worker specific and shared queue. + */ +export declare class FifoQueue implements TaskQueue { + private _workerQueues; + private readonly _sharedQueue; + enqueue(task: QueueChildMessage, workerId?: number): void; + dequeue(workerId: number): QueueChildMessage | null; +} + +declare type FunctionLike = (...args: any) => unknown; + +declare type HeapItem = { + priority: number; +}; + +export declare type JestWorkerFarm> = + Worker_2 & WorkerModule; + +export declare function messageParent( + message: unknown, + parentProcess?: NodeJS.Process, +): void; + +declare type MethodLikeKeys = { + [K in keyof T]: T[K] extends FunctionLike ? K : never; +}[keyof T]; + +declare class MinHeap { + private readonly _heap; + peek(): TItem | null; + add(item: TItem): void; + poll(): TItem | null; +} + +declare type OnCustomMessage = (message: Array | unknown) => void; + +declare type OnEnd = (err: Error | null, result: unknown) => void; + +declare type OnStart = (worker: WorkerInterface) => void; + +declare type OnStateChangeHandler = ( + state: WorkerStates, + oldState: WorkerStates, +) => void; + +declare type PoolExitResult = { + forceExited: boolean; +}; + +/** + * Priority queue that processes tasks in natural ordering (lower priority first) + * according to the priority computed by the function passed in the constructor. + * + * FIFO ordering isn't guaranteed for tasks with the same priority. + * + * Worker specific tasks with the same priority as a non-worker specific task + * are always processed first. + */ +export declare class PriorityQueue implements TaskQueue { + private readonly _computePriority; + private _queue; + private readonly _sharedQueue; + constructor(_computePriority: ComputeTaskPriorityCallback); + enqueue(task: QueueChildMessage, workerId?: number): void; + _enqueue(task: QueueChildMessage, queue: MinHeap): void; + dequeue(workerId: number): QueueChildMessage | null; + _getWorkerQueue(workerId: number): MinHeap; +} + +export declare interface PromiseWithCustomMessage extends Promise { + UNSTABLE_onCustomMessage?: (listener: OnCustomMessage) => () => void; +} + +declare type Promisify = ReturnType extends Promise< + infer R +> + ? (...args: Parameters) => Promise + : (...args: Parameters) => Promise>; + +declare type QueueChildMessage = { + request: ChildMessageCall; + onStart: OnStart; + onEnd: OnEnd; + onCustomMessage: OnCustomMessage; +}; + +declare type QueueItem = { + task: QueueChildMessage; + priority: number; +}; + +declare type ReservedKeys = + | 'end' + | 'getStderr' + | 'getStdout' + | 'setup' + | 'teardown'; + +export declare interface TaskQueue { + /** + * Enqueues the task in the queue for the specified worker or adds it to the + * queue shared by all workers + * @param task the task to queue + * @param workerId the id of the worker that should process this task or undefined + * if there's no preference. + */ + enqueue(task: QueueChildMessage, workerId?: number): void; + /** + * Dequeues the next item from the queue for the specified worker + * @param workerId the id of the worker for which the next task should be retrieved + */ + dequeue(workerId: number): QueueChildMessage | null; +} + +/** + * The Jest farm (publicly called "Worker") is a class that allows you to queue + * methods across multiple child processes, in order to parallelize work. This + * is done by providing an absolute path to a module that will be loaded on each + * of the child processes, and bridged to the main process. + * + * Bridged methods are specified by using the "exposedMethods" property of the + * "options" object. This is an array of strings, where each of them corresponds + * to the exported name in the loaded module. + * + * You can also control the amount of workers by using the "numWorkers" property + * of the "options" object, and the settings passed to fork the process through + * the "forkOptions" property. The amount of workers defaults to the amount of + * CPUS minus one. + * + * Queueing calls can be done in two ways: + * - Standard method: calls will be redirected to the first available worker, + * so they will get executed as soon as they can. + * + * - Sticky method: if a "computeWorkerKey" method is provided within the + * config, the resulting string of this method will be used as a key. + * Every time this key is returned, it is guaranteed that your job will be + * processed by the same worker. This is specially useful if your workers + * are caching results. + */ +declare class Worker_2 { + private _ending; + private readonly _farm; + private readonly _options; + private readonly _workerPool; + constructor(workerPath: string | URL, options?: WorkerFarmOptions); + private _bindExposedWorkerMethods; + private _callFunctionWithArgs; + getStderr(): NodeJS.ReadableStream; + getStdout(): NodeJS.ReadableStream; + start(): Promise; + end(): Promise; +} +export {Worker_2 as Worker}; + +declare type WorkerCallback = ( + workerId: number, + request: ChildMessage, + onStart: OnStart, + onEnd: OnEnd, + onCustomMessage: OnCustomMessage, +) => void; + +declare enum WorkerEvents { + STATE_CHANGE = 'state-change', +} + +export declare type WorkerFarmOptions = { + computeWorkerKey?: (method: string, ...args: Array) => string | null; + enableWorkerThreads?: boolean; + exposedMethods?: ReadonlyArray; + forkOptions?: ForkOptions; + maxRetries?: number; + numWorkers?: number; + resourceLimits?: ResourceLimits; + setupArgs?: Array; + taskQueue?: TaskQueue; + WorkerPool?: new ( + workerPath: string, + options?: WorkerPoolOptions, + ) => WorkerPoolInterface; + workerSchedulingPolicy?: WorkerSchedulingPolicy; + idleMemoryLimit?: number; +}; + +declare interface WorkerInterface { + get state(): WorkerStates; + send( + request: ChildMessage, + onProcessStart: OnStart, + onProcessEnd: OnEnd, + onCustomMessage: OnCustomMessage, + ): void; + waitForExit(): Promise; + forceExit(): void; + getWorkerId(): number; + getStderr(): NodeJS.ReadableStream | null; + getStdout(): NodeJS.ReadableStream | null; + /** + * Some system level identifier for the worker. IE, process id, thread id, etc. + */ + getWorkerSystemId(): number; + getMemoryUsage(): Promise; + /** + * Checks to see if the child worker is actually running. + */ + isWorkerRunning(): boolean; + /** + * When the worker child is started and ready to start handling requests. + * + * @remarks + * This mostly exists to help with testing so that you don't check the status + * of things like isWorkerRunning before it actually is. + */ + waitForWorkerReady(): Promise; +} + +declare type WorkerModule = { + [K in keyof T as Extract< + ExcludeReservedKeys, + MethodLikeKeys + >]: T[K] extends FunctionLike ? Promisify : never; +}; + +declare type WorkerOptions_2 = { + forkOptions: ForkOptions; + resourceLimits: ResourceLimits; + setupArgs: Array; + maxRetries: number; + workerId: number; + workerData?: unknown; + workerPath: string; + /** + * After a job has executed the memory usage it should return to. + * + * @remarks + * Note this is different from ResourceLimits in that it checks at idle, after + * a job is complete. So you could have a resource limit of 500MB but an idle + * limit of 50MB. The latter will only trigger if after a job has completed the + * memory usage hasn't returned back down under 50MB. + */ + idleMemoryLimit?: number; + /** + * This mainly exists so the path can be changed during testing. + * https://github.com/jestjs/jest/issues/9543 + */ + childWorkerPath?: string; + /** + * This is useful for debugging individual tests allowing you to see + * the raw output of the worker. + */ + silent?: boolean; + /** + * Used to immediately bind event handlers. + */ + on?: { + [WorkerEvents.STATE_CHANGE]: + | OnStateChangeHandler + | ReadonlyArray; + }; +}; + +export declare interface WorkerPoolInterface { + getStderr(): NodeJS.ReadableStream; + getStdout(): NodeJS.ReadableStream; + getWorkers(): Array; + createWorker(options: WorkerOptions_2): WorkerInterface; + send: WorkerCallback; + start(): Promise; + end(): Promise; +} + +export declare type WorkerPoolOptions = { + setupArgs: Array; + forkOptions: ForkOptions; + resourceLimits: ResourceLimits; + maxRetries: number; + numWorkers: number; + enableWorkerThreads: boolean; + idleMemoryLimit?: number; +}; + +declare type WorkerSchedulingPolicy = 'round-robin' | 'in-order'; + +declare enum WorkerStates { + STARTING = 'starting', + OK = 'ok', + OUT_OF_MEMORY = 'oom', + RESTARTING = 'restarting', + SHUTTING_DOWN = 'shutting-down', + SHUT_DOWN = 'shut-down', +} + +export {}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..6e840cc2a2655d83001096adbb16931d8041677a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/index.js @@ -0,0 +1,192 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +Object.defineProperty(exports, 'FifoQueue', { + enumerable: true, + get: function () { + return _FifoQueue.default; + } +}); +Object.defineProperty(exports, 'PriorityQueue', { + enumerable: true, + get: function () { + return _PriorityQueue.default; + } +}); +exports.Worker = void 0; +Object.defineProperty(exports, 'messageParent', { + enumerable: true, + get: function () { + return _messageParent.default; + } +}); +function _os() { + const data = require('os'); + _os = function () { + return data; + }; + return data; +} +function _path() { + const data = require('path'); + _path = function () { + return data; + }; + return data; +} +function _url() { + const data = require('url'); + _url = function () { + return data; + }; + return data; +} +var _Farm = _interopRequireDefault(require('./Farm')); +var _WorkerPool = _interopRequireDefault(require('./WorkerPool')); +var _PriorityQueue = _interopRequireDefault(require('./PriorityQueue')); +var _FifoQueue = _interopRequireDefault(require('./FifoQueue')); +var _messageParent = _interopRequireDefault(require('./workers/messageParent')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function getExposedMethods(workerPath, options) { + let exposedMethods = options.exposedMethods; + + // If no methods list is given, try getting it by auto-requiring the module. + if (!exposedMethods) { + const module = require(workerPath); + exposedMethods = Object.keys(module).filter( + name => typeof module[name] === 'function' + ); + if (typeof module === 'function') { + exposedMethods = [...exposedMethods, 'default']; + } + } + return exposedMethods; +} +function getNumberOfCpus() { + return typeof _os().availableParallelism === 'function' + ? (0, _os().availableParallelism)() + : (0, _os().cpus)().length; +} + +/** + * The Jest farm (publicly called "Worker") is a class that allows you to queue + * methods across multiple child processes, in order to parallelize work. This + * is done by providing an absolute path to a module that will be loaded on each + * of the child processes, and bridged to the main process. + * + * Bridged methods are specified by using the "exposedMethods" property of the + * "options" object. This is an array of strings, where each of them corresponds + * to the exported name in the loaded module. + * + * You can also control the amount of workers by using the "numWorkers" property + * of the "options" object, and the settings passed to fork the process through + * the "forkOptions" property. The amount of workers defaults to the amount of + * CPUS minus one. + * + * Queueing calls can be done in two ways: + * - Standard method: calls will be redirected to the first available worker, + * so they will get executed as soon as they can. + * + * - Sticky method: if a "computeWorkerKey" method is provided within the + * config, the resulting string of this method will be used as a key. + * Every time this key is returned, it is guaranteed that your job will be + * processed by the same worker. This is specially useful if your workers + * are caching results. + */ +class Worker { + _ending; + _farm; + _options; + _workerPool; + constructor(workerPath, options) { + this._options = { + ...options + }; + this._ending = false; + if (typeof workerPath !== 'string') { + workerPath = workerPath.href; + } + if (workerPath.startsWith('file:')) { + workerPath = (0, _url().fileURLToPath)(workerPath); + } else if (!(0, _path().isAbsolute)(workerPath)) { + throw new Error(`'workerPath' must be absolute, got '${workerPath}'`); + } + const workerPoolOptions = { + enableWorkerThreads: this._options.enableWorkerThreads ?? false, + forkOptions: this._options.forkOptions ?? {}, + idleMemoryLimit: this._options.idleMemoryLimit, + maxRetries: this._options.maxRetries ?? 3, + numWorkers: + this._options.numWorkers ?? Math.max(getNumberOfCpus() - 1, 1), + resourceLimits: this._options.resourceLimits ?? {}, + setupArgs: this._options.setupArgs ?? [] + }; + if (this._options.WorkerPool) { + this._workerPool = new this._options.WorkerPool( + workerPath, + workerPoolOptions + ); + } else { + this._workerPool = new _WorkerPool.default(workerPath, workerPoolOptions); + } + this._farm = new _Farm.default( + workerPoolOptions.numWorkers, + this._workerPool.send.bind(this._workerPool), + { + computeWorkerKey: this._options.computeWorkerKey, + taskQueue: this._options.taskQueue, + workerSchedulingPolicy: this._options.workerSchedulingPolicy + } + ); + this._bindExposedWorkerMethods(workerPath, this._options); + } + _bindExposedWorkerMethods(workerPath, options) { + getExposedMethods(workerPath, options).forEach(name => { + if (name.startsWith('_')) { + return; + } + + // eslint-disable-next-line no-prototype-builtins + if (this.constructor.prototype.hasOwnProperty(name)) { + throw new TypeError(`Cannot define a method called ${name}`); + } + + // @ts-expect-error: dynamic extension of the class instance is expected. + this[name] = this._callFunctionWithArgs.bind(this, name); + }); + } + _callFunctionWithArgs(method, ...args) { + if (this._ending) { + throw new Error('Farm is ended, no more calls can be done to it'); + } + return this._farm.doWork(method, ...args); + } + getStderr() { + return this._workerPool.getStderr(); + } + getStdout() { + return this._workerPool.getStdout(); + } + async start() { + await this._workerPool.start(); + } + async end() { + if (this._ending) { + throw new Error('Farm is ended, no more calls can be done to it'); + } + this._ending = true; + return this._workerPool.end(); + } +} +exports.Worker = Worker; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/types.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/types.js new file mode 100644 index 0000000000000000000000000000000000000000..feedb0b71bc9c2654c00c828a89ce358deb7edd6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/types.js @@ -0,0 +1,72 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.WorkerStates = + exports.WorkerEvents = + exports.PARENT_MESSAGE_SETUP_ERROR = + exports.PARENT_MESSAGE_OK = + exports.PARENT_MESSAGE_MEM_USAGE = + exports.PARENT_MESSAGE_CUSTOM = + exports.PARENT_MESSAGE_CLIENT_ERROR = + exports.CHILD_MESSAGE_MEM_USAGE = + exports.CHILD_MESSAGE_INITIALIZE = + exports.CHILD_MESSAGE_END = + exports.CHILD_MESSAGE_CALL_SETUP = + exports.CHILD_MESSAGE_CALL = + void 0; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// Because of the dynamic nature of a worker communication process, all messages +// coming from any of the other processes cannot be typed. Thus, many types +// include "unknown" as a TS type, which is (unfortunately) correct here. + +const CHILD_MESSAGE_INITIALIZE = 0; +exports.CHILD_MESSAGE_INITIALIZE = CHILD_MESSAGE_INITIALIZE; +const CHILD_MESSAGE_CALL = 1; +exports.CHILD_MESSAGE_CALL = CHILD_MESSAGE_CALL; +const CHILD_MESSAGE_END = 2; +exports.CHILD_MESSAGE_END = CHILD_MESSAGE_END; +const CHILD_MESSAGE_MEM_USAGE = 3; +exports.CHILD_MESSAGE_MEM_USAGE = CHILD_MESSAGE_MEM_USAGE; +const CHILD_MESSAGE_CALL_SETUP = 4; +exports.CHILD_MESSAGE_CALL_SETUP = CHILD_MESSAGE_CALL_SETUP; +const PARENT_MESSAGE_OK = 0; +exports.PARENT_MESSAGE_OK = PARENT_MESSAGE_OK; +const PARENT_MESSAGE_CLIENT_ERROR = 1; +exports.PARENT_MESSAGE_CLIENT_ERROR = PARENT_MESSAGE_CLIENT_ERROR; +const PARENT_MESSAGE_SETUP_ERROR = 2; +exports.PARENT_MESSAGE_SETUP_ERROR = PARENT_MESSAGE_SETUP_ERROR; +const PARENT_MESSAGE_CUSTOM = 3; +exports.PARENT_MESSAGE_CUSTOM = PARENT_MESSAGE_CUSTOM; +const PARENT_MESSAGE_MEM_USAGE = 4; + +// Option objects. + +// Messages passed from the parent to the children. + +// Messages passed from the children to the parent. + +// Queue types. +exports.PARENT_MESSAGE_MEM_USAGE = PARENT_MESSAGE_MEM_USAGE; +let WorkerStates = /*#__PURE__*/ (function (WorkerStates) { + WorkerStates['STARTING'] = 'starting'; + WorkerStates['OK'] = 'ok'; + WorkerStates['OUT_OF_MEMORY'] = 'oom'; + WorkerStates['RESTARTING'] = 'restarting'; + WorkerStates['SHUTTING_DOWN'] = 'shutting-down'; + WorkerStates['SHUT_DOWN'] = 'shut-down'; + return WorkerStates; +})({}); +exports.WorkerStates = WorkerStates; +let WorkerEvents = /*#__PURE__*/ (function (WorkerEvents) { + WorkerEvents['STATE_CHANGE'] = 'state-change'; + return WorkerEvents; +})({}); +exports.WorkerEvents = WorkerEvents; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/workers/ChildProcessWorker.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/workers/ChildProcessWorker.js new file mode 100644 index 0000000000000000000000000000000000000000..6a9d1f369ba05a7891793baf29d48b6e49946ff6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/workers/ChildProcessWorker.js @@ -0,0 +1,490 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = exports.SIGKILL_DELAY = void 0; +function _child_process() { + const data = require('child_process'); + _child_process = function () { + return data; + }; + return data; +} +function _os() { + const data = require('os'); + _os = function () { + return data; + }; + return data; +} +function _mergeStream() { + const data = _interopRequireDefault(require('merge-stream')); + _mergeStream = function () { + return data; + }; + return data; +} +function _supportsColor() { + const data = require('supports-color'); + _supportsColor = function () { + return data; + }; + return data; +} +var _types = require('../types'); +var _WorkerAbstract = _interopRequireDefault(require('./WorkerAbstract')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const SIGNAL_BASE_EXIT_CODE = 128; +const SIGKILL_EXIT_CODE = SIGNAL_BASE_EXIT_CODE + 9; +const SIGTERM_EXIT_CODE = SIGNAL_BASE_EXIT_CODE + 15; + +// How long to wait after SIGTERM before sending SIGKILL +const SIGKILL_DELAY = 500; + +/** + * This class wraps the child process and provides a nice interface to + * communicate with. It takes care of: + * + * - Re-spawning the process if it dies. + * - Queues calls while the worker is busy. + * - Re-sends the requests if the worker blew up. + * + * The reason for queueing them here (since childProcess.send also has an + * internal queue) is because the worker could be doing asynchronous work, and + * this would lead to the child process to read its receiving buffer and start a + * second call. By queueing calls here, we don't send the next call to the + * children until we receive the result of the previous one. + * + * As soon as a request starts to be processed by a worker, its "processed" + * field is changed to "true", so that other workers which might encounter the + * same call skip it. + */ +exports.SIGKILL_DELAY = SIGKILL_DELAY; +class ChildProcessWorker extends _WorkerAbstract.default { + _child; + _options; + _request; + _retries; + _onProcessEnd; + _onCustomMessage; + _stdout; + _stderr; + _stderrBuffer = []; + _memoryUsagePromise; + _resolveMemoryUsage; + _childIdleMemoryUsage; + _childIdleMemoryUsageLimit; + _memoryUsageCheck = false; + _childWorkerPath; + constructor(options) { + super(options); + this._options = options; + this._request = null; + this._stdout = null; + this._stderr = null; + this._childIdleMemoryUsage = null; + this._childIdleMemoryUsageLimit = options.idleMemoryLimit || null; + this._childWorkerPath = + options.childWorkerPath || require.resolve('./processChild'); + this.state = _types.WorkerStates.STARTING; + this.initialize(); + } + initialize() { + if ( + this.state === _types.WorkerStates.OUT_OF_MEMORY || + this.state === _types.WorkerStates.SHUTTING_DOWN || + this.state === _types.WorkerStates.SHUT_DOWN + ) { + return; + } + if (this._child && this._child.connected) { + this._child.kill('SIGKILL'); + } + this.state = _types.WorkerStates.STARTING; + const forceColor = _supportsColor().stdout + ? { + FORCE_COLOR: '1' + } + : {}; + const silent = this._options.silent ?? true; + if (!silent) { + // NOTE: Detecting an out of memory crash is independent of idle memory usage monitoring. We want to + // monitor for a crash occurring so that it can be handled as required and so we can tell the difference + // between an OOM crash and another kind of crash. We need to do this because if a worker crashes due to + // an OOM event sometimes it isn't seen by the worker pool and it just sits there waiting for the worker + // to respond and it never will. + console.warn('Unable to detect out of memory event if silent === false'); + } + this._stderrBuffer = []; + const options = { + cwd: process.cwd(), + env: { + ...process.env, + JEST_WORKER_ID: String(this._options.workerId + 1), + // 0-indexed workerId, 1-indexed JEST_WORKER_ID + ...forceColor + }, + // Suppress --debug / --inspect flags while preserving others (like --harmony). + execArgv: process.execArgv.filter(v => !/^--(debug|inspect)/.test(v)), + // default to advanced serialization in order to match worker threads + serialization: 'advanced', + silent, + ...this._options.forkOptions + }; + this._child = (0, _child_process().fork)( + this._childWorkerPath, + [], + options + ); + if (this._child.stdout) { + if (!this._stdout) { + // We need to add a permanent stream to the merged stream to prevent it + // from ending when the subprocess stream ends + this._stdout = (0, _mergeStream().default)(this._getFakeStream()); + } + this._stdout.add(this._child.stdout); + } + if (this._child.stderr) { + if (!this._stderr) { + // We need to add a permanent stream to the merged stream to prevent it + // from ending when the subprocess stream ends + this._stderr = (0, _mergeStream().default)(this._getFakeStream()); + } + this._stderr.add(this._child.stderr); + this._child.stderr.on('data', this.stderrDataHandler.bind(this)); + } + this._child.on('message', this._onMessage.bind(this)); + this._child.on('exit', this._onExit.bind(this)); + this._child.on('disconnect', this._onDisconnect.bind(this)); + this._child.send([ + _types.CHILD_MESSAGE_INITIALIZE, + false, + this._options.workerPath, + this._options.setupArgs + ]); + this._retries++; + + // If we exceeded the amount of retries, we will emulate an error reply + // coming from the child. This avoids code duplication related with cleaning + // the queue, and scheduling the next call. + if (this._retries > this._options.maxRetries) { + const error = new Error( + `Jest worker encountered ${this._retries} child process exceptions, exceeding retry limit` + ); + this._onMessage([ + _types.PARENT_MESSAGE_CLIENT_ERROR, + error.name, + error.message, + error.stack, + { + type: 'WorkerError' + } + ]); + + // Clear the request so we don't keep executing it. + this._request = null; + } + this.state = _types.WorkerStates.OK; + if (this._resolveWorkerReady) { + this._resolveWorkerReady(); + } + } + stderrDataHandler(chunk) { + if (chunk) { + this._stderrBuffer.push(Buffer.from(chunk)); + } + this._detectOutOfMemoryCrash(); + if (this.state === _types.WorkerStates.OUT_OF_MEMORY) { + this._workerReadyPromise = undefined; + this._resolveWorkerReady = undefined; + this.killChild(); + this._shutdown(); + } + } + _detectOutOfMemoryCrash() { + try { + const bufferStr = Buffer.concat(this._stderrBuffer).toString('utf8'); + if ( + bufferStr.includes('heap out of memory') || + bufferStr.includes('allocation failure;') || + bufferStr.includes('Last few GCs') + ) { + if ( + this.state === _types.WorkerStates.OK || + this.state === _types.WorkerStates.STARTING + ) { + this.state = _types.WorkerStates.OUT_OF_MEMORY; + } + } + } catch (err) { + console.error('Error looking for out of memory crash', err); + } + } + _onDisconnect() { + this._workerReadyPromise = undefined; + this._resolveWorkerReady = undefined; + this._detectOutOfMemoryCrash(); + if (this.state === _types.WorkerStates.OUT_OF_MEMORY) { + this.killChild(); + this._shutdown(); + } + } + _onMessage(response) { + // Ignore messages not intended for us + if (!Array.isArray(response)) return; + + // TODO: Add appropriate type check + let error; + switch (response[0]) { + case _types.PARENT_MESSAGE_OK: + this._onProcessEnd(null, response[1]); + break; + case _types.PARENT_MESSAGE_CLIENT_ERROR: + error = response[4]; + if (error != null && typeof error === 'object') { + const extra = error; + // @ts-expect-error: no index + const NativeCtor = globalThis[response[1]]; + const Ctor = typeof NativeCtor === 'function' ? NativeCtor : Error; + error = new Ctor(response[2]); + error.type = response[1]; + error.stack = response[3]; + for (const key in extra) { + error[key] = extra[key]; + } + } + this._onProcessEnd(error, null); + break; + case _types.PARENT_MESSAGE_SETUP_ERROR: + error = new Error(`Error when calling setup: ${response[2]}`); + error.type = response[1]; + error.stack = response[3]; + this._onProcessEnd(error, null); + break; + case _types.PARENT_MESSAGE_CUSTOM: + this._onCustomMessage(response[1]); + break; + case _types.PARENT_MESSAGE_MEM_USAGE: + this._childIdleMemoryUsage = response[1]; + if (this._resolveMemoryUsage) { + this._resolveMemoryUsage(response[1]); + this._resolveMemoryUsage = undefined; + this._memoryUsagePromise = undefined; + } + this._performRestartIfRequired(); + break; + default: + // Ignore messages not intended for us + break; + } + } + _performRestartIfRequired() { + if (this._memoryUsageCheck) { + this._memoryUsageCheck = false; + let limit = this._childIdleMemoryUsageLimit; + + // TODO: At some point it would make sense to make use of + // stringToBytes found in jest-config, however as this + // package does not have any dependencies on an other jest + // packages that can wait until some other time. + if (limit && limit > 0 && limit <= 1) { + limit = Math.floor((0, _os().totalmem)() * limit); + } else if (limit) { + limit = Math.floor(limit); + } + if ( + limit && + this._childIdleMemoryUsage && + this._childIdleMemoryUsage > limit + ) { + this.state = _types.WorkerStates.RESTARTING; + this.killChild(); + } + } + } + _onExit(exitCode, signal) { + this._workerReadyPromise = undefined; + this._resolveWorkerReady = undefined; + this._detectOutOfMemoryCrash(); + if (exitCode !== 0 && this.state === _types.WorkerStates.OUT_OF_MEMORY) { + this._onProcessEnd( + new Error('Jest worker ran out of memory and crashed'), + null + ); + this._shutdown(); + } else if ( + (exitCode !== 0 && + exitCode !== null && + exitCode !== SIGTERM_EXIT_CODE && + exitCode !== SIGKILL_EXIT_CODE && + this.state !== _types.WorkerStates.SHUTTING_DOWN) || + this.state === _types.WorkerStates.RESTARTING + ) { + this.state = _types.WorkerStates.RESTARTING; + this.initialize(); + if (this._request) { + this._child.send(this._request); + } + } else { + // At this point, it's not clear why the child process exited. There could + // be several reasons: + // + // 1. The child process exited successfully after finishing its work. + // This is the most likely case. + // 2. The child process crashed in a manner that wasn't caught through + // any of the heuristic-based checks above. + // 3. The child process was killed by another process or daemon unrelated + // to Jest. For example, oom-killer on Linux may have picked the child + // process to kill because overall system memory is constrained. + // + // If there's a pending request to the child process in any of those + // situations, the request still needs to be handled in some manner before + // entering the shutdown phase. Otherwise the caller expecting a response + // from the worker will never receive indication that something unexpected + // happened and hang forever. + // + // In normal operation, the request is handled and cleared before the + // child process exits. If it's still present, it's not clear what + // happened and probably best to throw an error. In practice, this usually + // happens when the child process is killed externally. + // + // There's a reasonable argument that the child process should be retried + // with request re-sent in this scenario. However, if the problem was due + // to situations such as oom-killer attempting to free up system + // resources, retrying would exacerbate the problem. + const isRequestStillPending = !!this._request; + if (isRequestStillPending) { + // If a signal is present, we can be reasonably confident the process + // was killed externally. Log this fact so it's more clear to users that + // something went wrong externally, rather than a bug in Jest itself. + const error = new Error( + signal != null + ? `A jest worker process (pid=${this._child.pid}) was terminated by another process: signal=${signal}, exitCode=${exitCode}. Operating system logs may contain more information on why this occurred.` + : `A jest worker process (pid=${this._child.pid}) crashed for an unknown reason: exitCode=${exitCode}` + ); + this._onProcessEnd(error, null); + } + this._shutdown(); + } + } + send(request, onProcessStart, onProcessEnd, onCustomMessage) { + this._stderrBuffer = []; + onProcessStart(this); + this._onProcessEnd = (...args) => { + const hasRequest = !!this._request; + + // Clean the request to avoid sending past requests to workers that fail + // while waiting for a new request (timers, unhandled rejections...) + this._request = null; + if ( + this._childIdleMemoryUsageLimit && + this._child.connected && + hasRequest + ) { + this.checkMemoryUsage(); + } + return onProcessEnd(...args); + }; + this._onCustomMessage = (...arg) => onCustomMessage(...arg); + this._request = request; + this._retries = 0; + // eslint-disable-next-line @typescript-eslint/no-empty-function + this._child.send(request, () => {}); + } + waitForExit() { + return this._exitPromise; + } + killChild() { + // We store a reference so that there's no way we can accidentally + // kill a new worker that has been spawned. + const childToKill = this._child; + childToKill.kill('SIGTERM'); + return setTimeout(() => childToKill.kill('SIGKILL'), SIGKILL_DELAY); + } + forceExit() { + this.state = _types.WorkerStates.SHUTTING_DOWN; + const sigkillTimeout = this.killChild(); + this._exitPromise.then(() => clearTimeout(sigkillTimeout)); + } + getWorkerId() { + return this._options.workerId; + } + + /** + * Gets the process id of the worker. + * + * @returns Process id. + */ + getWorkerSystemId() { + return this._child.pid; + } + getStdout() { + return this._stdout; + } + getStderr() { + return this._stderr; + } + + /** + * Gets the last reported memory usage. + * + * @returns Memory usage in bytes. + */ + getMemoryUsage() { + if (!this._memoryUsagePromise) { + let rejectCallback; + const promise = new Promise((resolve, reject) => { + this._resolveMemoryUsage = resolve; + rejectCallback = reject; + }); + this._memoryUsagePromise = promise; + if (!this._child.connected && rejectCallback) { + rejectCallback(new Error('Child process is not running.')); + this._memoryUsagePromise = undefined; + this._resolveMemoryUsage = undefined; + return promise; + } + this._child.send([_types.CHILD_MESSAGE_MEM_USAGE], err => { + if (err && rejectCallback) { + this._memoryUsagePromise = undefined; + this._resolveMemoryUsage = undefined; + rejectCallback(err); + } + }); + return promise; + } + return this._memoryUsagePromise; + } + + /** + * Gets updated memory usage and restarts if required + */ + checkMemoryUsage() { + if (this._childIdleMemoryUsageLimit) { + this._memoryUsageCheck = true; + this._child.send([_types.CHILD_MESSAGE_MEM_USAGE], err => { + if (err) { + console.error('Unable to check memory usage', err); + } + }); + } else { + console.warn( + 'Memory usage of workers can only be checked if a limit is set' + ); + } + } + isWorkerRunning() { + return this._child.connected && !this._child.killed; + } +} +exports.default = ChildProcessWorker; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/workers/NodeThreadsWorker.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/workers/NodeThreadsWorker.js new file mode 100644 index 0000000000000000000000000000000000000000..e25247a6ddc65fe9a91eb36aae37657de8b6e8c6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/workers/NodeThreadsWorker.js @@ -0,0 +1,359 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _os() { + const data = require('os'); + _os = function () { + return data; + }; + return data; +} +function _worker_threads() { + const data = require('worker_threads'); + _worker_threads = function () { + return data; + }; + return data; +} +function _mergeStream() { + const data = _interopRequireDefault(require('merge-stream')); + _mergeStream = function () { + return data; + }; + return data; +} +var _types = require('../types'); +var _WorkerAbstract = _interopRequireDefault(require('./WorkerAbstract')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class ExperimentalWorker extends _WorkerAbstract.default { + _worker; + _options; + _request; + _retries; + _onProcessEnd; + _onCustomMessage; + _stdout; + _stderr; + _memoryUsagePromise; + _resolveMemoryUsage; + _childWorkerPath; + _childIdleMemoryUsage; + _childIdleMemoryUsageLimit; + _memoryUsageCheck = false; + constructor(options) { + super(options); + this._options = options; + this._request = null; + this._stdout = null; + this._stderr = null; + this._childWorkerPath = + options.childWorkerPath || require.resolve('./threadChild'); + this._childIdleMemoryUsage = null; + this._childIdleMemoryUsageLimit = options.idleMemoryLimit || null; + this.initialize(); + } + initialize() { + if ( + this.state === _types.WorkerStates.OUT_OF_MEMORY || + this.state === _types.WorkerStates.SHUTTING_DOWN || + this.state === _types.WorkerStates.SHUT_DOWN + ) { + return; + } + if (this._worker) { + this._worker.terminate(); + } + this.state = _types.WorkerStates.STARTING; + this._worker = new (_worker_threads().Worker)(this._childWorkerPath, { + eval: false, + resourceLimits: this._options.resourceLimits, + stderr: true, + stdout: true, + workerData: this._options.workerData, + ...this._options.forkOptions + }); + if (this._worker.stdout) { + if (!this._stdout) { + // We need to add a permanent stream to the merged stream to prevent it + // from ending when the subprocess stream ends + this._stdout = (0, _mergeStream().default)(this._getFakeStream()); + } + this._stdout.add(this._worker.stdout); + } + if (this._worker.stderr) { + if (!this._stderr) { + // We need to add a permanent stream to the merged stream to prevent it + // from ending when the subprocess stream ends + this._stderr = (0, _mergeStream().default)(this._getFakeStream()); + } + this._stderr.add(this._worker.stderr); + } + + // This can be useful for debugging. + if (!(this._options.silent ?? true)) { + this._worker.stdout.setEncoding('utf8'); + // eslint-disable-next-line no-console + this._worker.stdout.on('data', console.log); + this._worker.stderr.setEncoding('utf8'); + this._worker.stderr.on('data', console.error); + } + this._worker.on('message', this._onMessage.bind(this)); + this._worker.on('exit', this._onExit.bind(this)); + this._worker.on('error', this._onError.bind(this)); + this._worker.postMessage([ + _types.CHILD_MESSAGE_INITIALIZE, + false, + this._options.workerPath, + this._options.setupArgs, + String(this._options.workerId + 1) // 0-indexed workerId, 1-indexed JEST_WORKER_ID + ]); + + this._retries++; + + // If we exceeded the amount of retries, we will emulate an error reply + // coming from the child. This avoids code duplication related with cleaning + // the queue, and scheduling the next call. + if (this._retries > this._options.maxRetries) { + const error = new Error('Call retries were exceeded'); + this._onMessage([ + _types.PARENT_MESSAGE_CLIENT_ERROR, + error.name, + error.message, + error.stack, + { + type: 'WorkerError' + } + ]); + } + this.state = _types.WorkerStates.OK; + if (this._resolveWorkerReady) { + this._resolveWorkerReady(); + } + } + _onError(error) { + if (error.message.includes('heap out of memory')) { + this.state = _types.WorkerStates.OUT_OF_MEMORY; + + // Threads don't behave like processes, they don't crash when they run out of + // memory. But for consistency we want them to behave like processes so we call + // terminate to simulate a crash happening that was not planned + this._worker.terminate(); + } + } + _onMessage(response) { + // Ignore messages not intended for us + if (!Array.isArray(response)) return; + let error; + switch (response[0]) { + case _types.PARENT_MESSAGE_OK: + this._onProcessEnd(null, response[1]); + break; + case _types.PARENT_MESSAGE_CLIENT_ERROR: + error = response[4]; + if (error != null && typeof error === 'object') { + const extra = error; + // @ts-expect-error: no index + const NativeCtor = globalThis[response[1]]; + const Ctor = typeof NativeCtor === 'function' ? NativeCtor : Error; + error = new Ctor(response[2]); + error.type = response[1]; + error.stack = response[3]; + for (const key in extra) { + // @ts-expect-error: no index + error[key] = extra[key]; + } + } + this._onProcessEnd(error, null); + break; + case _types.PARENT_MESSAGE_SETUP_ERROR: + error = new Error(`Error when calling setup: ${response[2]}`); + + // @ts-expect-error: adding custom properties to errors. + error.type = response[1]; + error.stack = response[3]; + this._onProcessEnd(error, null); + break; + case _types.PARENT_MESSAGE_CUSTOM: + this._onCustomMessage(response[1]); + break; + case _types.PARENT_MESSAGE_MEM_USAGE: + this._childIdleMemoryUsage = response[1]; + if (this._resolveMemoryUsage) { + this._resolveMemoryUsage(response[1]); + this._resolveMemoryUsage = undefined; + this._memoryUsagePromise = undefined; + } + this._performRestartIfRequired(); + break; + default: + // Ignore messages not intended for us + break; + } + } + _onExit(exitCode) { + this._workerReadyPromise = undefined; + this._resolveWorkerReady = undefined; + if (exitCode !== 0 && this.state === _types.WorkerStates.OUT_OF_MEMORY) { + this._onProcessEnd( + new Error('Jest worker ran out of memory and crashed'), + null + ); + this._shutdown(); + } else if ( + (exitCode !== 0 && + this.state !== _types.WorkerStates.SHUTTING_DOWN && + this.state !== _types.WorkerStates.SHUT_DOWN) || + this.state === _types.WorkerStates.RESTARTING + ) { + this.initialize(); + if (this._request) { + this._worker.postMessage(this._request); + } + } else { + // If the worker thread exits while a request is still pending, throw an + // error. This is unexpected and tests may not have run to completion. + const isRequestStillPending = !!this._request; + if (isRequestStillPending) { + this._onProcessEnd( + new Error( + 'A Jest worker thread exited unexpectedly before finishing tests for an unknown reason. One of the ways this can happen is if process.exit() was called in testing code.' + ), + null + ); + } + this._shutdown(); + } + } + waitForExit() { + return this._exitPromise; + } + forceExit() { + this.state = _types.WorkerStates.SHUTTING_DOWN; + this._worker.terminate(); + } + send(request, onProcessStart, onProcessEnd, onCustomMessage) { + onProcessStart(this); + this._onProcessEnd = (...args) => { + const hasRequest = !!this._request; + + // Clean the request to avoid sending past requests to workers that fail + // while waiting for a new request (timers, unhandled rejections...) + this._request = null; + if (this._childIdleMemoryUsageLimit && hasRequest) { + this.checkMemoryUsage(); + } + const res = onProcessEnd?.(...args); + + // Clean up the reference so related closures can be garbage collected. + onProcessEnd = null; + return res; + }; + this._onCustomMessage = (...arg) => onCustomMessage(...arg); + this._request = request; + this._retries = 0; + this._worker.postMessage(request); + } + getWorkerId() { + return this._options.workerId; + } + getStdout() { + return this._stdout; + } + getStderr() { + return this._stderr; + } + _performRestartIfRequired() { + if (this._memoryUsageCheck) { + this._memoryUsageCheck = false; + let limit = this._childIdleMemoryUsageLimit; + + // TODO: At some point it would make sense to make use of + // stringToBytes found in jest-config, however as this + // package does not have any dependencies on an other jest + // packages that can wait until some other time. + if (limit && limit > 0 && limit <= 1) { + limit = Math.floor((0, _os().totalmem)() * limit); + } else if (limit) { + limit = Math.floor(limit); + } + if ( + limit && + this._childIdleMemoryUsage && + this._childIdleMemoryUsage > limit + ) { + this.state = _types.WorkerStates.RESTARTING; + this._worker.terminate(); + } + } + } + + /** + * Gets the last reported memory usage. + * + * @returns Memory usage in bytes. + */ + getMemoryUsage() { + if (!this._memoryUsagePromise) { + let rejectCallback; + const promise = new Promise((resolve, reject) => { + this._resolveMemoryUsage = resolve; + rejectCallback = reject; + }); + this._memoryUsagePromise = promise; + if (!this._worker.threadId) { + rejectCallback(new Error('Child process is not running.')); + this._memoryUsagePromise = undefined; + this._resolveMemoryUsage = undefined; + return promise; + } + try { + this._worker.postMessage([_types.CHILD_MESSAGE_MEM_USAGE]); + } catch (err) { + this._memoryUsagePromise = undefined; + this._resolveMemoryUsage = undefined; + rejectCallback(err); + } + return promise; + } + return this._memoryUsagePromise; + } + + /** + * Gets updated memory usage and restarts if required + */ + checkMemoryUsage() { + if (this._childIdleMemoryUsageLimit) { + this._memoryUsageCheck = true; + this._worker.postMessage([_types.CHILD_MESSAGE_MEM_USAGE]); + } else { + console.warn( + 'Memory usage of workers can only be checked if a limit is set' + ); + } + } + + /** + * Gets the thread id of the worker. + * + * @returns Thread id. + */ + getWorkerSystemId() { + return this._worker.threadId; + } + isWorkerRunning() { + return this._worker.threadId >= 0; + } +} +exports.default = ExperimentalWorker; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/workers/WorkerAbstract.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/workers/WorkerAbstract.js new file mode 100644 index 0000000000000000000000000000000000000000..1bd32f52a215464659b169d6839329324bfc8cd3 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/workers/WorkerAbstract.js @@ -0,0 +1,135 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _stream() { + const data = require('stream'); + _stream = function () { + return data; + }; + return data; +} +var _types = require('../types'); +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class WorkerAbstract extends _stream().EventEmitter { + /** + * DO NOT WRITE TO THIS DIRECTLY. + * Use this.state getter/setters so events are emitted correctly. + */ + #state = _types.WorkerStates.STARTING; + _fakeStream = null; + _exitPromise; + _resolveExitPromise; + _workerReadyPromise; + _resolveWorkerReady; + get state() { + return this.#state; + } + set state(value) { + if (this.#state !== value) { + const oldState = this.#state; + this.#state = value; + this.emit(_types.WorkerEvents.STATE_CHANGE, value, oldState); + } + } + constructor(options) { + super(); + if (typeof options.on === 'object') { + for (const [event, handlers] of Object.entries(options.on)) { + // Can't do Array.isArray on a ReadonlyArray. + // https://github.com/microsoft/TypeScript/issues/17002 + if (typeof handlers === 'function') { + super.on(event, handlers); + } else { + for (const handler of handlers) { + super.on(event, handler); + } + } + } + } + this._exitPromise = new Promise(resolve => { + this._resolveExitPromise = resolve; + }); + this._exitPromise.then(() => { + this.state = _types.WorkerStates.SHUT_DOWN; + }); + } + + /** + * Wait for the worker child process to be ready to handle requests. + * + * @returns Promise which resolves when ready. + */ + waitForWorkerReady() { + if (!this._workerReadyPromise) { + this._workerReadyPromise = new Promise((resolve, reject) => { + let settled = false; + let to; + switch (this.state) { + case _types.WorkerStates.OUT_OF_MEMORY: + case _types.WorkerStates.SHUTTING_DOWN: + case _types.WorkerStates.SHUT_DOWN: + settled = true; + reject( + new Error( + `Worker state means it will never be ready: ${this.state}` + ) + ); + break; + case _types.WorkerStates.STARTING: + case _types.WorkerStates.RESTARTING: + this._resolveWorkerReady = () => { + settled = true; + resolve(); + if (to) { + clearTimeout(to); + } + }; + break; + case _types.WorkerStates.OK: + settled = true; + resolve(); + break; + } + if (!settled) { + to = setTimeout(() => { + if (!settled) { + reject(new Error('Timeout starting worker')); + } + }, 500); + } + }); + } + return this._workerReadyPromise; + } + + /** + * Used to shut down the current working instance once the children have been + * killed off. + */ + _shutdown() { + this.state === _types.WorkerStates.SHUT_DOWN; + + // End the permanent stream so the merged stream end too + if (this._fakeStream) { + this._fakeStream.end(); + this._fakeStream = null; + } + this._resolveExitPromise(); + } + _getFakeStream() { + if (!this._fakeStream) { + this._fakeStream = new (_stream().PassThrough)(); + } + return this._fakeStream; + } +} +exports.default = WorkerAbstract; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/workers/messageParent.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/workers/messageParent.js new file mode 100644 index 0000000000000000000000000000000000000000..62e2ccec5716b6909dbb9a41081d4f9a7dcd364f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/workers/messageParent.js @@ -0,0 +1,33 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = messageParent; +function _worker_threads() { + const data = require('worker_threads'); + _worker_threads = function () { + return data; + }; + return data; +} +var _types = require('../types'); +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function messageParent(message, parentProcess = process) { + if (!_worker_threads().isMainThread && _worker_threads().parentPort != null) { + _worker_threads().parentPort.postMessage([ + _types.PARENT_MESSAGE_CUSTOM, + message + ]); + } else if (typeof parentProcess.send === 'function') { + parentProcess.send([_types.PARENT_MESSAGE_CUSTOM, message]); + } else { + throw new Error('"messageParent" can only be used inside a worker'); + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/workers/processChild.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/workers/processChild.js new file mode 100644 index 0000000000000000000000000000000000000000..1a47f23c1b4fe56a3504d25e99514ed4218ae7a2 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/workers/processChild.js @@ -0,0 +1,159 @@ +'use strict'; + +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +var _types = require('../types'); +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +let file = null; +let setupArgs = []; +let initialized = false; + +/** + * This file is a small bootstrapper for workers. It sets up the communication + * between the worker and the parent process, interpreting parent messages and + * sending results back. + * + * The file loaded will be lazily initialized the first time any of the workers + * is called. This is done for optimal performance: if the farm is initialized, + * but no call is made to it, child Node processes will be consuming the least + * possible amount of memory. + * + * If an invalid message is detected, the child will exit (by throwing) with a + * non-zero exit code. + */ +const messageListener = request => { + switch (request[0]) { + case _types.CHILD_MESSAGE_INITIALIZE: + const init = request; + file = init[2]; + setupArgs = init[3]; + break; + case _types.CHILD_MESSAGE_CALL: + const call = request; + execMethod(call[2], call[3]); + break; + case _types.CHILD_MESSAGE_END: + end(); + break; + case _types.CHILD_MESSAGE_MEM_USAGE: + reportMemoryUsage(); + break; + case _types.CHILD_MESSAGE_CALL_SETUP: + if (initialized) { + reportSuccess(void 0); + } else { + const main = require(file); + initialized = true; + if (main.setup) { + execFunction( + main.setup, + main, + setupArgs, + reportSuccess, + reportInitializeError + ); + } else { + reportSuccess(void 0); + } + } + break; + default: + throw new TypeError( + `Unexpected request from parent process: ${request[0]}` + ); + } +}; +process.on('message', messageListener); +function reportSuccess(result) { + if (!process || !process.send) { + throw new Error('Child can only be used on a forked process'); + } + process.send([_types.PARENT_MESSAGE_OK, result]); +} +function reportClientError(error) { + return reportError(error, _types.PARENT_MESSAGE_CLIENT_ERROR); +} +function reportInitializeError(error) { + return reportError(error, _types.PARENT_MESSAGE_SETUP_ERROR); +} +function reportMemoryUsage() { + if (!process || !process.send) { + throw new Error('Child can only be used on a forked process'); + } + const msg = [_types.PARENT_MESSAGE_MEM_USAGE, process.memoryUsage().heapUsed]; + process.send(msg); +} +function reportError(error, type) { + if (!process || !process.send) { + throw new Error('Child can only be used on a forked process'); + } + if (error == null) { + error = new Error('"null" or "undefined" thrown'); + } + process.send([ + type, + error.constructor && error.constructor.name, + error.message, + error.stack, + typeof error === 'object' + ? { + ...error + } + : error + ]); +} +function end() { + const main = require(file); + if (!main.teardown) { + exitProcess(); + return; + } + execFunction(main.teardown, main, [], exitProcess, exitProcess); +} +function exitProcess() { + // Clean up open handles so the process ideally exits gracefully + process.removeListener('message', messageListener); +} +function execMethod(method, args) { + const main = require(file); + let fn; + if (method === 'default') { + fn = main.__esModule ? main.default : main; + } else { + fn = main[method]; + } + function execHelper() { + execFunction(fn, main, args, reportSuccess, reportClientError); + } + if (initialized || !main.setup) { + execHelper(); + return; + } + initialized = true; + execFunction(main.setup, main, setupArgs, execHelper, reportInitializeError); +} +function execFunction(fn, ctx, args, onResult, onError) { + let result; + try { + result = fn.apply(ctx, args); + } catch (err) { + onError(err); + return; + } + if ((0, _jestUtil().isPromise)(result)) { + result.then(onResult, onError); + } else { + onResult(result); + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/workers/threadChild.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/workers/threadChild.js new file mode 100644 index 0000000000000000000000000000000000000000..16aca004efd020a1456354299a3a606cdf0e4bc7 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/build/workers/threadChild.js @@ -0,0 +1,177 @@ +'use strict'; + +function _worker_threads() { + const data = require('worker_threads'); + _worker_threads = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +var _types = require('../types'); +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +let file = null; +let setupArgs = []; +let initialized = false; + +/** + * This file is a small bootstrapper for workers. It sets up the communication + * between the worker and the parent process, interpreting parent messages and + * sending results back. + * + * The file loaded will be lazily initialized the first time any of the workers + * is called. This is done for optimal performance: if the farm is initialized, + * but no call is made to it, child Node processes will be consuming the least + * possible amount of memory. + * + * If an invalid message is detected, the child will exit (by throwing) with a + * non-zero exit code. + */ +const messageListener = request => { + switch (request[0]) { + case _types.CHILD_MESSAGE_INITIALIZE: + const init = request; + file = init[2]; + setupArgs = init[3]; + process.env.JEST_WORKER_ID = init[4]; + break; + case _types.CHILD_MESSAGE_CALL: + const call = request; + execMethod(call[2], call[3]); + break; + case _types.CHILD_MESSAGE_END: + end(); + break; + case _types.CHILD_MESSAGE_MEM_USAGE: + reportMemoryUsage(); + break; + case _types.CHILD_MESSAGE_CALL_SETUP: + if (initialized) { + reportSuccess(void 0); + } else { + const main = require(file); + initialized = true; + if (main.setup) { + execFunction( + main.setup, + main, + setupArgs, + reportSuccess, + reportInitializeError + ); + } else { + reportSuccess(void 0); + } + } + break; + default: + throw new TypeError( + `Unexpected request from parent process: ${request[0]}` + ); + } +}; +_worker_threads().parentPort.on('message', messageListener); +function reportMemoryUsage() { + if (_worker_threads().isMainThread) { + throw new Error('Child can only be used on a forked process'); + } + const msg = [_types.PARENT_MESSAGE_MEM_USAGE, process.memoryUsage().heapUsed]; + _worker_threads().parentPort.postMessage(msg); +} +function reportSuccess(result) { + if (_worker_threads().isMainThread) { + throw new Error('Child can only be used on a forked process'); + } + try { + _worker_threads().parentPort.postMessage([ + _types.PARENT_MESSAGE_OK, + result + ]); + } catch (err) { + // Handling it here to avoid unhandled `DataCloneError` rejection + // which is hard to distinguish on the parent side + // (such error doesn't have any message or stack trace) + reportClientError(err); + } +} +function reportClientError(error) { + return reportError(error, _types.PARENT_MESSAGE_CLIENT_ERROR); +} +function reportInitializeError(error) { + return reportError(error, _types.PARENT_MESSAGE_SETUP_ERROR); +} +function reportError(error, type) { + if (_worker_threads().isMainThread) { + throw new Error('Child can only be used on a forked process'); + } + if (error == null) { + error = new Error('"null" or "undefined" thrown'); + } + _worker_threads().parentPort.postMessage([ + type, + error.constructor && error.constructor.name, + error.message, + error.stack, + typeof error === 'object' + ? { + ...error + } + : error + ]); +} +function end() { + const main = require(file); + if (!main.teardown) { + exitProcess(); + return; + } + execFunction(main.teardown, main, [], exitProcess, exitProcess); +} +function exitProcess() { + // Clean up open handles so the worker ideally exits gracefully + _worker_threads().parentPort.removeListener('message', messageListener); +} +function execMethod(method, args) { + const main = require(file); + let fn; + if (method === 'default') { + fn = main.__esModule ? main.default : main; + } else { + fn = main[method]; + } + function execHelper() { + execFunction(fn, main, args, reportSuccess, reportClientError); + } + if (initialized || !main.setup) { + execHelper(); + return; + } + initialized = true; + execFunction(main.setup, main, setupArgs, execHelper, reportInitializeError); +} +function execFunction(fn, ctx, args, onResult, onError) { + let result; + try { + result = fn.apply(ctx, args); + } catch (err) { + onError(err); + return; + } + if ((0, _jestUtil().isPromise)(result)) { + result.then(onResult, onError); + } else { + onResult(result); + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/package.json new file mode 100644 index 0000000000000000000000000000000000000000..6975f97288e35f38ad274485dd358e4d04f4ba9f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/jest-worker/package.json @@ -0,0 +1,42 @@ +{ + "name": "jest-worker", + "version": "29.7.0", + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/jest-worker" + }, + "license": "MIT", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "dependencies": { + "@types/node": "*", + "jest-util": "^29.7.0", + "merge-stream": "^2.0.0", + "supports-color": "^8.0.0" + }, + "devDependencies": { + "@babel/core": "^7.11.6", + "@tsd/typescript": "^5.0.4", + "@types/merge-stream": "^1.1.2", + "@types/supports-color": "^8.1.0", + "get-stream": "^6.0.0", + "jest-leak-detector": "^29.7.0", + "tsd-lite": "^0.7.0", + "worker-farm": "^1.6.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "publishConfig": { + "access": "public" + }, + "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/minimatch/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/minimatch/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..19129e315fe593965a2fdd50ec0d1253bcbd2ece --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/minimatch/LICENSE @@ -0,0 +1,15 @@ +The ISC License + +Copyright (c) Isaac Z. Schlueter and Contributors + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +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. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/minimatch/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/minimatch/README.md new file mode 100644 index 0000000000000000000000000000000000000000..33ede1d6eef25201cc1c14aab2bf3932ebb62d21 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/minimatch/README.md @@ -0,0 +1,230 @@ +# minimatch + +A minimal matching utility. + +[![Build Status](https://travis-ci.org/isaacs/minimatch.svg?branch=master)](http://travis-ci.org/isaacs/minimatch) + + +This is the matching library used internally by npm. + +It works by converting glob expressions into JavaScript `RegExp` +objects. + +## Usage + +```javascript +var minimatch = require("minimatch") + +minimatch("bar.foo", "*.foo") // true! +minimatch("bar.foo", "*.bar") // false! +minimatch("bar.foo", "*.+(bar|foo)", { debug: true }) // true, and noisy! +``` + +## Features + +Supports these glob features: + +* Brace Expansion +* Extended glob matching +* "Globstar" `**` matching + +See: + +* `man sh` +* `man bash` +* `man 3 fnmatch` +* `man 5 gitignore` + +## Minimatch Class + +Create a minimatch object by instantiating the `minimatch.Minimatch` class. + +```javascript +var Minimatch = require("minimatch").Minimatch +var mm = new Minimatch(pattern, options) +``` + +### Properties + +* `pattern` The original pattern the minimatch object represents. +* `options` The options supplied to the constructor. +* `set` A 2-dimensional array of regexp or string expressions. + Each row in the + array corresponds to a brace-expanded pattern. Each item in the row + corresponds to a single path-part. For example, the pattern + `{a,b/c}/d` would expand to a set of patterns like: + + [ [ a, d ] + , [ b, c, d ] ] + + If a portion of the pattern doesn't have any "magic" in it + (that is, it's something like `"foo"` rather than `fo*o?`), then it + will be left as a string rather than converted to a regular + expression. + +* `regexp` Created by the `makeRe` method. A single regular expression + expressing the entire pattern. This is useful in cases where you wish + to use the pattern somewhat like `fnmatch(3)` with `FNM_PATH` enabled. +* `negate` True if the pattern is negated. +* `comment` True if the pattern is a comment. +* `empty` True if the pattern is `""`. + +### Methods + +* `makeRe` Generate the `regexp` member if necessary, and return it. + Will return `false` if the pattern is invalid. +* `match(fname)` Return true if the filename matches the pattern, or + false otherwise. +* `matchOne(fileArray, patternArray, partial)` Take a `/`-split + filename, and match it against a single row in the `regExpSet`. This + method is mainly for internal use, but is exposed so that it can be + used by a glob-walker that needs to avoid excessive filesystem calls. + +All other methods are internal, and will be called as necessary. + +### minimatch(path, pattern, options) + +Main export. Tests a path against the pattern using the options. + +```javascript +var isJS = minimatch(file, "*.js", { matchBase: true }) +``` + +### minimatch.filter(pattern, options) + +Returns a function that tests its +supplied argument, suitable for use with `Array.filter`. Example: + +```javascript +var javascripts = fileList.filter(minimatch.filter("*.js", {matchBase: true})) +``` + +### minimatch.match(list, pattern, options) + +Match against the list of +files, in the style of fnmatch or glob. If nothing is matched, and +options.nonull is set, then return a list containing the pattern itself. + +```javascript +var javascripts = minimatch.match(fileList, "*.js", {matchBase: true})) +``` + +### minimatch.makeRe(pattern, options) + +Make a regular expression object from the pattern. + +## Options + +All options are `false` by default. + +### debug + +Dump a ton of stuff to stderr. + +### nobrace + +Do not expand `{a,b}` and `{1..3}` brace sets. + +### noglobstar + +Disable `**` matching against multiple folder names. + +### dot + +Allow patterns to match filenames starting with a period, even if +the pattern does not explicitly have a period in that spot. + +Note that by default, `a/**/b` will **not** match `a/.d/b`, unless `dot` +is set. + +### noext + +Disable "extglob" style patterns like `+(a|b)`. + +### nocase + +Perform a case-insensitive match. + +### nonull + +When a match is not found by `minimatch.match`, return a list containing +the pattern itself if this option is set. When not set, an empty list +is returned if there are no matches. + +### matchBase + +If set, then patterns without slashes will be matched +against the basename of the path if it contains slashes. For example, +`a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`. + +### nocomment + +Suppress the behavior of treating `#` at the start of a pattern as a +comment. + +### nonegate + +Suppress the behavior of treating a leading `!` character as negation. + +### flipNegate + +Returns from negate expressions the same as if they were not negated. +(Ie, true on a hit, false on a miss.) + +### partial + +Compare a partial path to a pattern. As long as the parts of the path that +are present are not contradicted by the pattern, it will be treated as a +match. This is useful in applications where you're walking through a +folder structure, and don't yet have the full path, but want to ensure that +you do not walk down paths that can never be a match. + +For example, + +```js +minimatch('/a/b', '/a/*/c/d', { partial: true }) // true, might be /a/b/c/d +minimatch('/a/b', '/**/d', { partial: true }) // true, might be /a/b/.../d +minimatch('/x/y/z', '/a/**/z', { partial: true }) // false, because x !== a +``` + +### allowWindowsEscape + +Windows path separator `\` is by default converted to `/`, which +prohibits the usage of `\` as a escape character. This flag skips that +behavior and allows using the escape character. + +## Comparisons to other fnmatch/glob implementations + +While strict compliance with the existing standards is a worthwhile +goal, some discrepancies exist between minimatch and other +implementations, and are intentional. + +If the pattern starts with a `!` character, then it is negated. Set the +`nonegate` flag to suppress this behavior, and treat leading `!` +characters normally. This is perhaps relevant if you wish to start the +pattern with a negative extglob pattern like `!(a|B)`. Multiple `!` +characters at the start of a pattern will negate the pattern multiple +times. + +If a pattern starts with `#`, then it is treated as a comment, and +will not match anything. Use `\#` to match a literal `#` at the +start of a line, or set the `nocomment` flag to suppress this behavior. + +The double-star character `**` is supported by default, unless the +`noglobstar` flag is set. This is supported in the manner of bsdglob +and bash 4.1, where `**` only has special significance if it is the only +thing in a path part. That is, `a/**/b` will match `a/x/y/b`, but +`a/**b` will not. + +If an escaped pattern has no matches, and the `nonull` flag is set, +then minimatch.match returns the pattern as-provided, rather than +interpreting the character escapes. For example, +`minimatch.match([], "\\*a\\?")` will return `"\\*a\\?"` rather than +`"*a?"`. This is akin to setting the `nullglob` option in bash, except +that it does not resolve escaped pattern characters. + +If brace expansion is not disabled, then it is performed before any +other interpretation of the glob pattern. Thus, a pattern like +`+(a|{b),c)}`, which would not be valid in bash or zsh, is expanded +**first** into the set of `+(a|b)` and `+(a|c)`, and those patterns are +checked for validity. Since those two are valid, matching proceeds. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/minimatch/minimatch.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/minimatch/minimatch.js new file mode 100644 index 0000000000000000000000000000000000000000..fda45ade7cfc351fbcd76877d50b4b5f643c37a3 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/minimatch/minimatch.js @@ -0,0 +1,947 @@ +module.exports = minimatch +minimatch.Minimatch = Minimatch + +var path = (function () { try { return require('path') } catch (e) {}}()) || { + sep: '/' +} +minimatch.sep = path.sep + +var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {} +var expand = require('brace-expansion') + +var plTypes = { + '!': { open: '(?:(?!(?:', close: '))[^/]*?)'}, + '?': { open: '(?:', close: ')?' }, + '+': { open: '(?:', close: ')+' }, + '*': { open: '(?:', close: ')*' }, + '@': { open: '(?:', close: ')' } +} + +// any single thing other than / +// don't need to escape / when using new RegExp() +var qmark = '[^/]' + +// * => any number of characters +var star = qmark + '*?' + +// ** when dots are allowed. Anything goes, except .. and . +// not (^ or / followed by one or two dots followed by $ or /), +// followed by anything, any number of times. +var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?' + +// not a ^ or / followed by a dot, +// followed by anything, any number of times. +var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?' + +// characters that need to be escaped in RegExp. +var reSpecials = charSet('().*{}+?[]^$\\!') + +// "abc" -> { a:true, b:true, c:true } +function charSet (s) { + return s.split('').reduce(function (set, c) { + set[c] = true + return set + }, {}) +} + +// normalizes slashes. +var slashSplit = /\/+/ + +minimatch.filter = filter +function filter (pattern, options) { + options = options || {} + return function (p, i, list) { + return minimatch(p, pattern, options) + } +} + +function ext (a, b) { + b = b || {} + var t = {} + Object.keys(a).forEach(function (k) { + t[k] = a[k] + }) + Object.keys(b).forEach(function (k) { + t[k] = b[k] + }) + return t +} + +minimatch.defaults = function (def) { + if (!def || typeof def !== 'object' || !Object.keys(def).length) { + return minimatch + } + + var orig = minimatch + + var m = function minimatch (p, pattern, options) { + return orig(p, pattern, ext(def, options)) + } + + m.Minimatch = function Minimatch (pattern, options) { + return new orig.Minimatch(pattern, ext(def, options)) + } + m.Minimatch.defaults = function defaults (options) { + return orig.defaults(ext(def, options)).Minimatch + } + + m.filter = function filter (pattern, options) { + return orig.filter(pattern, ext(def, options)) + } + + m.defaults = function defaults (options) { + return orig.defaults(ext(def, options)) + } + + m.makeRe = function makeRe (pattern, options) { + return orig.makeRe(pattern, ext(def, options)) + } + + m.braceExpand = function braceExpand (pattern, options) { + return orig.braceExpand(pattern, ext(def, options)) + } + + m.match = function (list, pattern, options) { + return orig.match(list, pattern, ext(def, options)) + } + + return m +} + +Minimatch.defaults = function (def) { + return minimatch.defaults(def).Minimatch +} + +function minimatch (p, pattern, options) { + assertValidPattern(pattern) + + if (!options) options = {} + + // shortcut: comments match nothing. + if (!options.nocomment && pattern.charAt(0) === '#') { + return false + } + + return new Minimatch(pattern, options).match(p) +} + +function Minimatch (pattern, options) { + if (!(this instanceof Minimatch)) { + return new Minimatch(pattern, options) + } + + assertValidPattern(pattern) + + if (!options) options = {} + + pattern = pattern.trim() + + // windows support: need to use /, not \ + if (!options.allowWindowsEscape && path.sep !== '/') { + pattern = pattern.split(path.sep).join('/') + } + + this.options = options + this.set = [] + this.pattern = pattern + this.regexp = null + this.negate = false + this.comment = false + this.empty = false + this.partial = !!options.partial + + // make the set of regexps etc. + this.make() +} + +Minimatch.prototype.debug = function () {} + +Minimatch.prototype.make = make +function make () { + var pattern = this.pattern + var options = this.options + + // empty patterns and comments match nothing. + if (!options.nocomment && pattern.charAt(0) === '#') { + this.comment = true + return + } + if (!pattern) { + this.empty = true + return + } + + // step 1: figure out negation, etc. + this.parseNegate() + + // step 2: expand braces + var set = this.globSet = this.braceExpand() + + if (options.debug) this.debug = function debug() { console.error.apply(console, arguments) } + + this.debug(this.pattern, set) + + // step 3: now we have a set, so turn each one into a series of path-portion + // matching patterns. + // These will be regexps, except in the case of "**", which is + // set to the GLOBSTAR object for globstar behavior, + // and will not contain any / characters + set = this.globParts = set.map(function (s) { + return s.split(slashSplit) + }) + + this.debug(this.pattern, set) + + // glob --> regexps + set = set.map(function (s, si, set) { + return s.map(this.parse, this) + }, this) + + this.debug(this.pattern, set) + + // filter out everything that didn't compile properly. + set = set.filter(function (s) { + return s.indexOf(false) === -1 + }) + + this.debug(this.pattern, set) + + this.set = set +} + +Minimatch.prototype.parseNegate = parseNegate +function parseNegate () { + var pattern = this.pattern + var negate = false + var options = this.options + var negateOffset = 0 + + if (options.nonegate) return + + for (var i = 0, l = pattern.length + ; i < l && pattern.charAt(i) === '!' + ; i++) { + negate = !negate + negateOffset++ + } + + if (negateOffset) this.pattern = pattern.substr(negateOffset) + this.negate = negate +} + +// Brace expansion: +// a{b,c}d -> abd acd +// a{b,}c -> abc ac +// a{0..3}d -> a0d a1d a2d a3d +// a{b,c{d,e}f}g -> abg acdfg acefg +// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg +// +// Invalid sets are not expanded. +// a{2..}b -> a{2..}b +// a{b}c -> a{b}c +minimatch.braceExpand = function (pattern, options) { + return braceExpand(pattern, options) +} + +Minimatch.prototype.braceExpand = braceExpand + +function braceExpand (pattern, options) { + if (!options) { + if (this instanceof Minimatch) { + options = this.options + } else { + options = {} + } + } + + pattern = typeof pattern === 'undefined' + ? this.pattern : pattern + + assertValidPattern(pattern) + + // Thanks to Yeting Li for + // improving this regexp to avoid a ReDOS vulnerability. + if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) { + // shortcut. no need to expand. + return [pattern] + } + + return expand(pattern) +} + +var MAX_PATTERN_LENGTH = 1024 * 64 +var assertValidPattern = function (pattern) { + if (typeof pattern !== 'string') { + throw new TypeError('invalid pattern') + } + + if (pattern.length > MAX_PATTERN_LENGTH) { + throw new TypeError('pattern is too long') + } +} + +// parse a component of the expanded set. +// At this point, no pattern may contain "/" in it +// so we're going to return a 2d array, where each entry is the full +// pattern, split on '/', and then turned into a regular expression. +// A regexp is made at the end which joins each array with an +// escaped /, and another full one which joins each regexp with |. +// +// Following the lead of Bash 4.1, note that "**" only has special meaning +// when it is the *only* thing in a path portion. Otherwise, any series +// of * is equivalent to a single *. Globstar behavior is enabled by +// default, and can be disabled by setting options.noglobstar. +Minimatch.prototype.parse = parse +var SUBPARSE = {} +function parse (pattern, isSub) { + assertValidPattern(pattern) + + var options = this.options + + // shortcuts + if (pattern === '**') { + if (!options.noglobstar) + return GLOBSTAR + else + pattern = '*' + } + if (pattern === '') return '' + + var re = '' + var hasMagic = !!options.nocase + var escaping = false + // ? => one single character + var patternListStack = [] + var negativeLists = [] + var stateChar + var inClass = false + var reClassStart = -1 + var classStart = -1 + // . and .. never match anything that doesn't start with ., + // even when options.dot is set. + var patternStart = pattern.charAt(0) === '.' ? '' // anything + // not (start or / followed by . or .. followed by / or end) + : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))' + : '(?!\\.)' + var self = this + + function clearStateChar () { + if (stateChar) { + // we had some state-tracking character + // that wasn't consumed by this pass. + switch (stateChar) { + case '*': + re += star + hasMagic = true + break + case '?': + re += qmark + hasMagic = true + break + default: + re += '\\' + stateChar + break + } + self.debug('clearStateChar %j %j', stateChar, re) + stateChar = false + } + } + + for (var i = 0, len = pattern.length, c + ; (i < len) && (c = pattern.charAt(i)) + ; i++) { + this.debug('%s\t%s %s %j', pattern, i, re, c) + + // skip over any that are escaped. + if (escaping && reSpecials[c]) { + re += '\\' + c + escaping = false + continue + } + + switch (c) { + /* istanbul ignore next */ + case '/': { + // completely not allowed, even escaped. + // Should already be path-split by now. + return false + } + + case '\\': + clearStateChar() + escaping = true + continue + + // the various stateChar values + // for the "extglob" stuff. + case '?': + case '*': + case '+': + case '@': + case '!': + this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c) + + // all of those are literals inside a class, except that + // the glob [!a] means [^a] in regexp + if (inClass) { + this.debug(' in class') + if (c === '!' && i === classStart + 1) c = '^' + re += c + continue + } + + // if we already have a stateChar, then it means + // that there was something like ** or +? in there. + // Handle the stateChar, then proceed with this one. + self.debug('call clearStateChar %j', stateChar) + clearStateChar() + stateChar = c + // if extglob is disabled, then +(asdf|foo) isn't a thing. + // just clear the statechar *now*, rather than even diving into + // the patternList stuff. + if (options.noext) clearStateChar() + continue + + case '(': + if (inClass) { + re += '(' + continue + } + + if (!stateChar) { + re += '\\(' + continue + } + + patternListStack.push({ + type: stateChar, + start: i - 1, + reStart: re.length, + open: plTypes[stateChar].open, + close: plTypes[stateChar].close + }) + // negation is (?:(?!js)[^/]*) + re += stateChar === '!' ? '(?:(?!(?:' : '(?:' + this.debug('plType %j %j', stateChar, re) + stateChar = false + continue + + case ')': + if (inClass || !patternListStack.length) { + re += '\\)' + continue + } + + clearStateChar() + hasMagic = true + var pl = patternListStack.pop() + // negation is (?:(?!js)[^/]*) + // The others are (?:) + re += pl.close + if (pl.type === '!') { + negativeLists.push(pl) + } + pl.reEnd = re.length + continue + + case '|': + if (inClass || !patternListStack.length || escaping) { + re += '\\|' + escaping = false + continue + } + + clearStateChar() + re += '|' + continue + + // these are mostly the same in regexp and glob + case '[': + // swallow any state-tracking char before the [ + clearStateChar() + + if (inClass) { + re += '\\' + c + continue + } + + inClass = true + classStart = i + reClassStart = re.length + re += c + continue + + case ']': + // a right bracket shall lose its special + // meaning and represent itself in + // a bracket expression if it occurs + // first in the list. -- POSIX.2 2.8.3.2 + if (i === classStart + 1 || !inClass) { + re += '\\' + c + escaping = false + continue + } + + // handle the case where we left a class open. + // "[z-a]" is valid, equivalent to "\[z-a\]" + // split where the last [ was, make sure we don't have + // an invalid re. if so, re-walk the contents of the + // would-be class to re-translate any characters that + // were passed through as-is + // TODO: It would probably be faster to determine this + // without a try/catch and a new RegExp, but it's tricky + // to do safely. For now, this is safe and works. + var cs = pattern.substring(classStart + 1, i) + try { + RegExp('[' + cs + ']') + } catch (er) { + // not a valid class! + var sp = this.parse(cs, SUBPARSE) + re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]' + hasMagic = hasMagic || sp[1] + inClass = false + continue + } + + // finish up the class. + hasMagic = true + inClass = false + re += c + continue + + default: + // swallow any state char that wasn't consumed + clearStateChar() + + if (escaping) { + // no need + escaping = false + } else if (reSpecials[c] + && !(c === '^' && inClass)) { + re += '\\' + } + + re += c + + } // switch + } // for + + // handle the case where we left a class open. + // "[abc" is valid, equivalent to "\[abc" + if (inClass) { + // split where the last [ was, and escape it + // this is a huge pita. We now have to re-walk + // the contents of the would-be class to re-translate + // any characters that were passed through as-is + cs = pattern.substr(classStart + 1) + sp = this.parse(cs, SUBPARSE) + re = re.substr(0, reClassStart) + '\\[' + sp[0] + hasMagic = hasMagic || sp[1] + } + + // handle the case where we had a +( thing at the *end* + // of the pattern. + // each pattern list stack adds 3 chars, and we need to go through + // and escape any | chars that were passed through as-is for the regexp. + // Go through and escape them, taking care not to double-escape any + // | chars that were already escaped. + for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) { + var tail = re.slice(pl.reStart + pl.open.length) + this.debug('setting tail', re, pl) + // maybe some even number of \, then maybe 1 \, followed by a | + tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) { + if (!$2) { + // the | isn't already escaped, so escape it. + $2 = '\\' + } + + // need to escape all those slashes *again*, without escaping the + // one that we need for escaping the | character. As it works out, + // escaping an even number of slashes can be done by simply repeating + // it exactly after itself. That's why this trick works. + // + // I am sorry that you have to see this. + return $1 + $1 + $2 + '|' + }) + + this.debug('tail=%j\n %s', tail, tail, pl, re) + var t = pl.type === '*' ? star + : pl.type === '?' ? qmark + : '\\' + pl.type + + hasMagic = true + re = re.slice(0, pl.reStart) + t + '\\(' + tail + } + + // handle trailing things that only matter at the very end. + clearStateChar() + if (escaping) { + // trailing \\ + re += '\\\\' + } + + // only need to apply the nodot start if the re starts with + // something that could conceivably capture a dot + var addPatternStart = false + switch (re.charAt(0)) { + case '[': case '.': case '(': addPatternStart = true + } + + // Hack to work around lack of negative lookbehind in JS + // A pattern like: *.!(x).!(y|z) needs to ensure that a name + // like 'a.xyz.yz' doesn't match. So, the first negative + // lookahead, has to look ALL the way ahead, to the end of + // the pattern. + for (var n = negativeLists.length - 1; n > -1; n--) { + var nl = negativeLists[n] + + var nlBefore = re.slice(0, nl.reStart) + var nlFirst = re.slice(nl.reStart, nl.reEnd - 8) + var nlLast = re.slice(nl.reEnd - 8, nl.reEnd) + var nlAfter = re.slice(nl.reEnd) + + nlLast += nlAfter + + // Handle nested stuff like *(*.js|!(*.json)), where open parens + // mean that we should *not* include the ) in the bit that is considered + // "after" the negated section. + var openParensBefore = nlBefore.split('(').length - 1 + var cleanAfter = nlAfter + for (i = 0; i < openParensBefore; i++) { + cleanAfter = cleanAfter.replace(/\)[+*?]?/, '') + } + nlAfter = cleanAfter + + var dollar = '' + if (nlAfter === '' && isSub !== SUBPARSE) { + dollar = '$' + } + var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast + re = newRe + } + + // if the re is not "" at this point, then we need to make sure + // it doesn't match against an empty path part. + // Otherwise a/* will match a/, which it should not. + if (re !== '' && hasMagic) { + re = '(?=.)' + re + } + + if (addPatternStart) { + re = patternStart + re + } + + // parsing just a piece of a larger pattern. + if (isSub === SUBPARSE) { + return [re, hasMagic] + } + + // skip the regexp for non-magical patterns + // unescape anything in it, though, so that it'll be + // an exact match against a file etc. + if (!hasMagic) { + return globUnescape(pattern) + } + + var flags = options.nocase ? 'i' : '' + try { + var regExp = new RegExp('^' + re + '$', flags) + } catch (er) /* istanbul ignore next - should be impossible */ { + // If it was an invalid regular expression, then it can't match + // anything. This trick looks for a character after the end of + // the string, which is of course impossible, except in multi-line + // mode, but it's not a /m regex. + return new RegExp('$.') + } + + regExp._glob = pattern + regExp._src = re + + return regExp +} + +minimatch.makeRe = function (pattern, options) { + return new Minimatch(pattern, options || {}).makeRe() +} + +Minimatch.prototype.makeRe = makeRe +function makeRe () { + if (this.regexp || this.regexp === false) return this.regexp + + // at this point, this.set is a 2d array of partial + // pattern strings, or "**". + // + // It's better to use .match(). This function shouldn't + // be used, really, but it's pretty convenient sometimes, + // when you just want to work with a regex. + var set = this.set + + if (!set.length) { + this.regexp = false + return this.regexp + } + var options = this.options + + var twoStar = options.noglobstar ? star + : options.dot ? twoStarDot + : twoStarNoDot + var flags = options.nocase ? 'i' : '' + + var re = set.map(function (pattern) { + return pattern.map(function (p) { + return (p === GLOBSTAR) ? twoStar + : (typeof p === 'string') ? regExpEscape(p) + : p._src + }).join('\\\/') + }).join('|') + + // must match entire pattern + // ending in a * or ** will make it less strict. + re = '^(?:' + re + ')$' + + // can match anything, as long as it's not this. + if (this.negate) re = '^(?!' + re + ').*$' + + try { + this.regexp = new RegExp(re, flags) + } catch (ex) /* istanbul ignore next - should be impossible */ { + this.regexp = false + } + return this.regexp +} + +minimatch.match = function (list, pattern, options) { + options = options || {} + var mm = new Minimatch(pattern, options) + list = list.filter(function (f) { + return mm.match(f) + }) + if (mm.options.nonull && !list.length) { + list.push(pattern) + } + return list +} + +Minimatch.prototype.match = function match (f, partial) { + if (typeof partial === 'undefined') partial = this.partial + this.debug('match', f, this.pattern) + // short-circuit in the case of busted things. + // comments, etc. + if (this.comment) return false + if (this.empty) return f === '' + + if (f === '/' && partial) return true + + var options = this.options + + // windows: need to use /, not \ + if (path.sep !== '/') { + f = f.split(path.sep).join('/') + } + + // treat the test path as a set of pathparts. + f = f.split(slashSplit) + this.debug(this.pattern, 'split', f) + + // just ONE of the pattern sets in this.set needs to match + // in order for it to be valid. If negating, then just one + // match means that we have failed. + // Either way, return on the first hit. + + var set = this.set + this.debug(this.pattern, 'set', set) + + // Find the basename of the path by looking for the last non-empty segment + var filename + var i + for (i = f.length - 1; i >= 0; i--) { + filename = f[i] + if (filename) break + } + + for (i = 0; i < set.length; i++) { + var pattern = set[i] + var file = f + if (options.matchBase && pattern.length === 1) { + file = [filename] + } + var hit = this.matchOne(file, pattern, partial) + if (hit) { + if (options.flipNegate) return true + return !this.negate + } + } + + // didn't get any hits. this is success if it's a negative + // pattern, failure otherwise. + if (options.flipNegate) return false + return this.negate +} + +// set partial to true to test if, for example, +// "/a/b" matches the start of "/*/b/*/d" +// Partial means, if you run out of file before you run +// out of pattern, then that's fine, as long as all +// the parts match. +Minimatch.prototype.matchOne = function (file, pattern, partial) { + var options = this.options + + this.debug('matchOne', + { 'this': this, file: file, pattern: pattern }) + + this.debug('matchOne', file.length, pattern.length) + + for (var fi = 0, + pi = 0, + fl = file.length, + pl = pattern.length + ; (fi < fl) && (pi < pl) + ; fi++, pi++) { + this.debug('matchOne loop') + var p = pattern[pi] + var f = file[fi] + + this.debug(pattern, p, f) + + // should be impossible. + // some invalid regexp stuff in the set. + /* istanbul ignore if */ + if (p === false) return false + + if (p === GLOBSTAR) { + this.debug('GLOBSTAR', [pattern, p, f]) + + // "**" + // a/**/b/**/c would match the following: + // a/b/x/y/z/c + // a/x/y/z/b/c + // a/b/x/b/x/c + // a/b/c + // To do this, take the rest of the pattern after + // the **, and see if it would match the file remainder. + // If so, return success. + // If not, the ** "swallows" a segment, and try again. + // This is recursively awful. + // + // a/**/b/**/c matching a/b/x/y/z/c + // - a matches a + // - doublestar + // - matchOne(b/x/y/z/c, b/**/c) + // - b matches b + // - doublestar + // - matchOne(x/y/z/c, c) -> no + // - matchOne(y/z/c, c) -> no + // - matchOne(z/c, c) -> no + // - matchOne(c, c) yes, hit + var fr = fi + var pr = pi + 1 + if (pr === pl) { + this.debug('** at the end') + // a ** at the end will just swallow the rest. + // We have found a match. + // however, it will not swallow /.x, unless + // options.dot is set. + // . and .. are *never* matched by **, for explosively + // exponential reasons. + for (; fi < fl; fi++) { + if (file[fi] === '.' || file[fi] === '..' || + (!options.dot && file[fi].charAt(0) === '.')) return false + } + return true + } + + // ok, let's see if we can swallow whatever we can. + while (fr < fl) { + var swallowee = file[fr] + + this.debug('\nglobstar while', file, fr, pattern, pr, swallowee) + + // XXX remove this slice. Just pass the start index. + if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) { + this.debug('globstar found match!', fr, fl, swallowee) + // found a match. + return true + } else { + // can't swallow "." or ".." ever. + // can only swallow ".foo" when explicitly asked. + if (swallowee === '.' || swallowee === '..' || + (!options.dot && swallowee.charAt(0) === '.')) { + this.debug('dot detected!', file, fr, pattern, pr) + break + } + + // ** swallows a segment, and continue. + this.debug('globstar swallow a segment, and continue') + fr++ + } + } + + // no match was found. + // However, in partial mode, we can't say this is necessarily over. + // If there's more *pattern* left, then + /* istanbul ignore if */ + if (partial) { + // ran out of file + this.debug('\n>>> no match, partial?', file, fr, pattern, pr) + if (fr === fl) return true + } + return false + } + + // something other than ** + // non-magic patterns just have to match exactly + // patterns with magic have been turned into regexps. + var hit + if (typeof p === 'string') { + hit = f === p + this.debug('string match', p, f, hit) + } else { + hit = f.match(p) + this.debug('pattern match', p, f, hit) + } + + if (!hit) return false + } + + // Note: ending in / means that we'll get a final "" + // at the end of the pattern. This can only match a + // corresponding "" at the end of the file. + // If the file ends in /, then it can only match a + // a pattern that ends in /, unless the pattern just + // doesn't have any more for it. But, a/b/ should *not* + // match "a/b/*", even though "" matches against the + // [^/]*? pattern, except in partial mode, where it might + // simply not be reached yet. + // However, a/b/ should still satisfy a/* + + // now either we fell off the end of the pattern, or we're done. + if (fi === fl && pi === pl) { + // ran out of pattern and filename at the same time. + // an exact hit! + return true + } else if (fi === fl) { + // ran out of file, but still had pattern left. + // this is ok if we're doing the match as part of + // a glob fs traversal. + return partial + } else /* istanbul ignore else */ if (pi === pl) { + // ran out of pattern, still have file left. + // this is only acceptable if we're on the very last + // empty segment of a file with a trailing slash. + // a/* should match a/b/ + return (fi === fl - 1) && (file[fi] === '') + } + + // should be unreachable. + /* istanbul ignore next */ + throw new Error('wtf?') +} + +// replace stuff like \* with * +function globUnescape (s) { + return s.replace(/\\(.)/g, '$1') +} + +function regExpEscape (s) { + return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&') +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/minimatch/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/minimatch/package.json new file mode 100644 index 0000000000000000000000000000000000000000..566efdfe45cb80710f6a14075f7e360d392edbd7 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/minimatch/package.json @@ -0,0 +1,33 @@ +{ + "author": "Isaac Z. Schlueter (http://blog.izs.me)", + "name": "minimatch", + "description": "a glob matcher in javascript", + "version": "3.1.2", + "publishConfig": { + "tag": "v3-legacy" + }, + "repository": { + "type": "git", + "url": "git://github.com/isaacs/minimatch.git" + }, + "main": "minimatch.js", + "scripts": { + "test": "tap", + "preversion": "npm test", + "postversion": "npm publish", + "postpublish": "git push origin --all; git push origin --tags" + }, + "engines": { + "node": "*" + }, + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "devDependencies": { + "tap": "^15.1.6" + }, + "license": "ISC", + "files": [ + "minimatch.js" + ] +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/semver/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/semver/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..19129e315fe593965a2fdd50ec0d1253bcbd2ece --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/semver/LICENSE @@ -0,0 +1,15 @@ +The ISC License + +Copyright (c) Isaac Z. Schlueter and Contributors + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +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. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/semver/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/semver/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2293a14fdc3579558dbe9fbc50aa549657948c3e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/semver/README.md @@ -0,0 +1,443 @@ +semver(1) -- The semantic versioner for npm +=========================================== + +## Install + +```bash +npm install semver +```` + +## Usage + +As a node module: + +```js +const semver = require('semver') + +semver.valid('1.2.3') // '1.2.3' +semver.valid('a.b.c') // null +semver.clean(' =v1.2.3 ') // '1.2.3' +semver.satisfies('1.2.3', '1.x || >=2.5.0 || 5.0.0 - 7.2.3') // true +semver.gt('1.2.3', '9.8.7') // false +semver.lt('1.2.3', '9.8.7') // true +semver.minVersion('>=1.0.0') // '1.0.0' +semver.valid(semver.coerce('v2')) // '2.0.0' +semver.valid(semver.coerce('42.6.7.9.3-alpha')) // '42.6.7' +``` + +As a command-line utility: + +``` +$ semver -h + +A JavaScript implementation of the https://semver.org/ specification +Copyright Isaac Z. Schlueter + +Usage: semver [options] [ [...]] +Prints valid versions sorted by SemVer precedence + +Options: +-r --range + Print versions that match the specified range. + +-i --increment [] + Increment a version by the specified level. Level can + be one of: major, minor, patch, premajor, preminor, + prepatch, or prerelease. Default level is 'patch'. + Only one version may be specified. + +--preid + Identifier to be used to prefix premajor, preminor, + prepatch or prerelease version increments. + +-l --loose + Interpret versions and ranges loosely + +-p --include-prerelease + Always include prerelease versions in range matching + +-c --coerce + Coerce a string into SemVer if possible + (does not imply --loose) + +--rtl + Coerce version strings right to left + +--ltr + Coerce version strings left to right (default) + +Program exits successfully if any valid version satisfies +all supplied ranges, and prints all satisfying versions. + +If no satisfying versions are found, then exits failure. + +Versions are printed in ascending order, so supplying +multiple versions to the utility will just sort them. +``` + +## Versions + +A "version" is described by the `v2.0.0` specification found at +. + +A leading `"="` or `"v"` character is stripped off and ignored. + +## Ranges + +A `version range` is a set of `comparators` which specify versions +that satisfy the range. + +A `comparator` is composed of an `operator` and a `version`. The set +of primitive `operators` is: + +* `<` Less than +* `<=` Less than or equal to +* `>` Greater than +* `>=` Greater than or equal to +* `=` Equal. If no operator is specified, then equality is assumed, + so this operator is optional, but MAY be included. + +For example, the comparator `>=1.2.7` would match the versions +`1.2.7`, `1.2.8`, `2.5.3`, and `1.3.9`, but not the versions `1.2.6` +or `1.1.0`. + +Comparators can be joined by whitespace to form a `comparator set`, +which is satisfied by the **intersection** of all of the comparators +it includes. + +A range is composed of one or more comparator sets, joined by `||`. A +version matches a range if and only if every comparator in at least +one of the `||`-separated comparator sets is satisfied by the version. + +For example, the range `>=1.2.7 <1.3.0` would match the versions +`1.2.7`, `1.2.8`, and `1.2.99`, but not the versions `1.2.6`, `1.3.0`, +or `1.1.0`. + +The range `1.2.7 || >=1.2.9 <2.0.0` would match the versions `1.2.7`, +`1.2.9`, and `1.4.6`, but not the versions `1.2.8` or `2.0.0`. + +### Prerelease Tags + +If a version has a prerelease tag (for example, `1.2.3-alpha.3`) then +it will only be allowed to satisfy comparator sets if at least one +comparator with the same `[major, minor, patch]` tuple also has a +prerelease tag. + +For example, the range `>1.2.3-alpha.3` would be allowed to match the +version `1.2.3-alpha.7`, but it would *not* be satisfied by +`3.4.5-alpha.9`, even though `3.4.5-alpha.9` is technically "greater +than" `1.2.3-alpha.3` according to the SemVer sort rules. The version +range only accepts prerelease tags on the `1.2.3` version. The +version `3.4.5` *would* satisfy the range, because it does not have a +prerelease flag, and `3.4.5` is greater than `1.2.3-alpha.7`. + +The purpose for this behavior is twofold. First, prerelease versions +frequently are updated very quickly, and contain many breaking changes +that are (by the author's design) not yet fit for public consumption. +Therefore, by default, they are excluded from range matching +semantics. + +Second, a user who has opted into using a prerelease version has +clearly indicated the intent to use *that specific* set of +alpha/beta/rc versions. By including a prerelease tag in the range, +the user is indicating that they are aware of the risk. However, it +is still not appropriate to assume that they have opted into taking a +similar risk on the *next* set of prerelease versions. + +Note that this behavior can be suppressed (treating all prerelease +versions as if they were normal versions, for the purpose of range +matching) by setting the `includePrerelease` flag on the options +object to any +[functions](https://github.com/npm/node-semver#functions) that do +range matching. + +#### Prerelease Identifiers + +The method `.inc` takes an additional `identifier` string argument that +will append the value of the string as a prerelease identifier: + +```javascript +semver.inc('1.2.3', 'prerelease', 'beta') +// '1.2.4-beta.0' +``` + +command-line example: + +```bash +$ semver 1.2.3 -i prerelease --preid beta +1.2.4-beta.0 +``` + +Which then can be used to increment further: + +```bash +$ semver 1.2.4-beta.0 -i prerelease +1.2.4-beta.1 +``` + +### Advanced Range Syntax + +Advanced range syntax desugars to primitive comparators in +deterministic ways. + +Advanced ranges may be combined in the same way as primitive +comparators using white space or `||`. + +#### Hyphen Ranges `X.Y.Z - A.B.C` + +Specifies an inclusive set. + +* `1.2.3 - 2.3.4` := `>=1.2.3 <=2.3.4` + +If a partial version is provided as the first version in the inclusive +range, then the missing pieces are replaced with zeroes. + +* `1.2 - 2.3.4` := `>=1.2.0 <=2.3.4` + +If a partial version is provided as the second version in the +inclusive range, then all versions that start with the supplied parts +of the tuple are accepted, but nothing that would be greater than the +provided tuple parts. + +* `1.2.3 - 2.3` := `>=1.2.3 <2.4.0` +* `1.2.3 - 2` := `>=1.2.3 <3.0.0` + +#### X-Ranges `1.2.x` `1.X` `1.2.*` `*` + +Any of `X`, `x`, or `*` may be used to "stand in" for one of the +numeric values in the `[major, minor, patch]` tuple. + +* `*` := `>=0.0.0` (Any version satisfies) +* `1.x` := `>=1.0.0 <2.0.0` (Matching major version) +* `1.2.x` := `>=1.2.0 <1.3.0` (Matching major and minor versions) + +A partial version range is treated as an X-Range, so the special +character is in fact optional. + +* `""` (empty string) := `*` := `>=0.0.0` +* `1` := `1.x.x` := `>=1.0.0 <2.0.0` +* `1.2` := `1.2.x` := `>=1.2.0 <1.3.0` + +#### Tilde Ranges `~1.2.3` `~1.2` `~1` + +Allows patch-level changes if a minor version is specified on the +comparator. Allows minor-level changes if not. + +* `~1.2.3` := `>=1.2.3 <1.(2+1).0` := `>=1.2.3 <1.3.0` +* `~1.2` := `>=1.2.0 <1.(2+1).0` := `>=1.2.0 <1.3.0` (Same as `1.2.x`) +* `~1` := `>=1.0.0 <(1+1).0.0` := `>=1.0.0 <2.0.0` (Same as `1.x`) +* `~0.2.3` := `>=0.2.3 <0.(2+1).0` := `>=0.2.3 <0.3.0` +* `~0.2` := `>=0.2.0 <0.(2+1).0` := `>=0.2.0 <0.3.0` (Same as `0.2.x`) +* `~0` := `>=0.0.0 <(0+1).0.0` := `>=0.0.0 <1.0.0` (Same as `0.x`) +* `~1.2.3-beta.2` := `>=1.2.3-beta.2 <1.3.0` Note that prereleases in + the `1.2.3` version will be allowed, if they are greater than or + equal to `beta.2`. So, `1.2.3-beta.4` would be allowed, but + `1.2.4-beta.2` would not, because it is a prerelease of a + different `[major, minor, patch]` tuple. + +#### Caret Ranges `^1.2.3` `^0.2.5` `^0.0.4` + +Allows changes that do not modify the left-most non-zero element in the +`[major, minor, patch]` tuple. In other words, this allows patch and +minor updates for versions `1.0.0` and above, patch updates for +versions `0.X >=0.1.0`, and *no* updates for versions `0.0.X`. + +Many authors treat a `0.x` version as if the `x` were the major +"breaking-change" indicator. + +Caret ranges are ideal when an author may make breaking changes +between `0.2.4` and `0.3.0` releases, which is a common practice. +However, it presumes that there will *not* be breaking changes between +`0.2.4` and `0.2.5`. It allows for changes that are presumed to be +additive (but non-breaking), according to commonly observed practices. + +* `^1.2.3` := `>=1.2.3 <2.0.0` +* `^0.2.3` := `>=0.2.3 <0.3.0` +* `^0.0.3` := `>=0.0.3 <0.0.4` +* `^1.2.3-beta.2` := `>=1.2.3-beta.2 <2.0.0` Note that prereleases in + the `1.2.3` version will be allowed, if they are greater than or + equal to `beta.2`. So, `1.2.3-beta.4` would be allowed, but + `1.2.4-beta.2` would not, because it is a prerelease of a + different `[major, minor, patch]` tuple. +* `^0.0.3-beta` := `>=0.0.3-beta <0.0.4` Note that prereleases in the + `0.0.3` version *only* will be allowed, if they are greater than or + equal to `beta`. So, `0.0.3-pr.2` would be allowed. + +When parsing caret ranges, a missing `patch` value desugars to the +number `0`, but will allow flexibility within that value, even if the +major and minor versions are both `0`. + +* `^1.2.x` := `>=1.2.0 <2.0.0` +* `^0.0.x` := `>=0.0.0 <0.1.0` +* `^0.0` := `>=0.0.0 <0.1.0` + +A missing `minor` and `patch` values will desugar to zero, but also +allow flexibility within those values, even if the major version is +zero. + +* `^1.x` := `>=1.0.0 <2.0.0` +* `^0.x` := `>=0.0.0 <1.0.0` + +### Range Grammar + +Putting all this together, here is a Backus-Naur grammar for ranges, +for the benefit of parser authors: + +```bnf +range-set ::= range ( logical-or range ) * +logical-or ::= ( ' ' ) * '||' ( ' ' ) * +range ::= hyphen | simple ( ' ' simple ) * | '' +hyphen ::= partial ' - ' partial +simple ::= primitive | partial | tilde | caret +primitive ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial +partial ::= xr ( '.' xr ( '.' xr qualifier ? )? )? +xr ::= 'x' | 'X' | '*' | nr +nr ::= '0' | ['1'-'9'] ( ['0'-'9'] ) * +tilde ::= '~' partial +caret ::= '^' partial +qualifier ::= ( '-' pre )? ( '+' build )? +pre ::= parts +build ::= parts +parts ::= part ( '.' part ) * +part ::= nr | [-0-9A-Za-z]+ +``` + +## Functions + +All methods and classes take a final `options` object argument. All +options in this object are `false` by default. The options supported +are: + +- `loose` Be more forgiving about not-quite-valid semver strings. + (Any resulting output will always be 100% strict compliant, of + course.) For backwards compatibility reasons, if the `options` + argument is a boolean value instead of an object, it is interpreted + to be the `loose` param. +- `includePrerelease` Set to suppress the [default + behavior](https://github.com/npm/node-semver#prerelease-tags) of + excluding prerelease tagged versions from ranges unless they are + explicitly opted into. + +Strict-mode Comparators and Ranges will be strict about the SemVer +strings that they parse. + +* `valid(v)`: Return the parsed version, or null if it's not valid. +* `inc(v, release)`: Return the version incremented by the release + type (`major`, `premajor`, `minor`, `preminor`, `patch`, + `prepatch`, or `prerelease`), or null if it's not valid + * `premajor` in one call will bump the version up to the next major + version and down to a prerelease of that major version. + `preminor`, and `prepatch` work the same way. + * If called from a non-prerelease version, the `prerelease` will work the + same as `prepatch`. It increments the patch version, then makes a + prerelease. If the input version is already a prerelease it simply + increments it. +* `prerelease(v)`: Returns an array of prerelease components, or null + if none exist. Example: `prerelease('1.2.3-alpha.1') -> ['alpha', 1]` +* `major(v)`: Return the major version number. +* `minor(v)`: Return the minor version number. +* `patch(v)`: Return the patch version number. +* `intersects(r1, r2, loose)`: Return true if the two supplied ranges + or comparators intersect. +* `parse(v)`: Attempt to parse a string as a semantic version, returning either + a `SemVer` object or `null`. + +### Comparison + +* `gt(v1, v2)`: `v1 > v2` +* `gte(v1, v2)`: `v1 >= v2` +* `lt(v1, v2)`: `v1 < v2` +* `lte(v1, v2)`: `v1 <= v2` +* `eq(v1, v2)`: `v1 == v2` This is true if they're logically equivalent, + even if they're not the exact same string. You already know how to + compare strings. +* `neq(v1, v2)`: `v1 != v2` The opposite of `eq`. +* `cmp(v1, comparator, v2)`: Pass in a comparison string, and it'll call + the corresponding function above. `"==="` and `"!=="` do simple + string comparison, but are included for completeness. Throws if an + invalid comparison string is provided. +* `compare(v1, v2)`: Return `0` if `v1 == v2`, or `1` if `v1` is greater, or `-1` if + `v2` is greater. Sorts in ascending order if passed to `Array.sort()`. +* `rcompare(v1, v2)`: The reverse of compare. Sorts an array of versions + in descending order when passed to `Array.sort()`. +* `compareBuild(v1, v2)`: The same as `compare` but considers `build` when two versions + are equal. Sorts in ascending order if passed to `Array.sort()`. + `v2` is greater. Sorts in ascending order if passed to `Array.sort()`. +* `diff(v1, v2)`: Returns difference between two versions by the release type + (`major`, `premajor`, `minor`, `preminor`, `patch`, `prepatch`, or `prerelease`), + or null if the versions are the same. + +### Comparators + +* `intersects(comparator)`: Return true if the comparators intersect + +### Ranges + +* `validRange(range)`: Return the valid range or null if it's not valid +* `satisfies(version, range)`: Return true if the version satisfies the + range. +* `maxSatisfying(versions, range)`: Return the highest version in the list + that satisfies the range, or `null` if none of them do. +* `minSatisfying(versions, range)`: Return the lowest version in the list + that satisfies the range, or `null` if none of them do. +* `minVersion(range)`: Return the lowest version that can possibly match + the given range. +* `gtr(version, range)`: Return `true` if version is greater than all the + versions possible in the range. +* `ltr(version, range)`: Return `true` if version is less than all the + versions possible in the range. +* `outside(version, range, hilo)`: Return true if the version is outside + the bounds of the range in either the high or low direction. The + `hilo` argument must be either the string `'>'` or `'<'`. (This is + the function called by `gtr` and `ltr`.) +* `intersects(range)`: Return true if any of the ranges comparators intersect + +Note that, since ranges may be non-contiguous, a version might not be +greater than a range, less than a range, *or* satisfy a range! For +example, the range `1.2 <1.2.9 || >2.0.0` would have a hole from `1.2.9` +until `2.0.0`, so the version `1.2.10` would not be greater than the +range (because `2.0.1` satisfies, which is higher), nor less than the +range (since `1.2.8` satisfies, which is lower), and it also does not +satisfy the range. + +If you want to know if a version satisfies or does not satisfy a +range, use the `satisfies(version, range)` function. + +### Coercion + +* `coerce(version, options)`: Coerces a string to semver if possible + +This aims to provide a very forgiving translation of a non-semver string to +semver. It looks for the first digit in a string, and consumes all +remaining characters which satisfy at least a partial semver (e.g., `1`, +`1.2`, `1.2.3`) up to the max permitted length (256 characters). Longer +versions are simply truncated (`4.6.3.9.2-alpha2` becomes `4.6.3`). All +surrounding text is simply ignored (`v3.4 replaces v3.3.1` becomes +`3.4.0`). Only text which lacks digits will fail coercion (`version one` +is not valid). The maximum length for any semver component considered for +coercion is 16 characters; longer components will be ignored +(`10000000000000000.4.7.4` becomes `4.7.4`). The maximum value for any +semver component is `Integer.MAX_SAFE_INTEGER || (2**53 - 1)`; higher value +components are invalid (`9999999999999999.4.7.4` is likely invalid). + +If the `options.rtl` flag is set, then `coerce` will return the right-most +coercible tuple that does not share an ending index with a longer coercible +tuple. For example, `1.2.3.4` will return `2.3.4` in rtl mode, not +`4.0.0`. `1.2.3/4` will return `4.0.0`, because the `4` is not a part of +any other overlapping SemVer tuple. + +### Clean + +* `clean(version)`: Clean a string to be a valid semver if possible + +This will return a cleaned and trimmed semver version. If the provided version is not valid a null will be returned. This does not work for ranges. + +ex. +* `s.clean(' = v 2.1.5foo')`: `null` +* `s.clean(' = v 2.1.5foo', { loose: true })`: `'2.1.5-foo'` +* `s.clean(' = v 2.1.5-foo')`: `null` +* `s.clean(' = v 2.1.5-foo', { loose: true })`: `'2.1.5-foo'` +* `s.clean('=v2.1.5')`: `'2.1.5'` +* `s.clean(' =v2.1.5')`: `2.1.5` +* `s.clean(' 2.1.5 ')`: `'2.1.5'` +* `s.clean('~1.0.0')`: `null` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/semver/bin/semver.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/semver/bin/semver.js new file mode 100644 index 0000000000000000000000000000000000000000..666034a75d8442be9bb2d9c55c3909b55a093cb5 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/semver/bin/semver.js @@ -0,0 +1,174 @@ +#!/usr/bin/env node +// Standalone semver comparison program. +// Exits successfully and prints matching version(s) if +// any supplied version is valid and passes all tests. + +var argv = process.argv.slice(2) + +var versions = [] + +var range = [] + +var inc = null + +var version = require('../package.json').version + +var loose = false + +var includePrerelease = false + +var coerce = false + +var rtl = false + +var identifier + +var semver = require('../semver') + +var reverse = false + +var options = {} + +main() + +function main () { + if (!argv.length) return help() + while (argv.length) { + var a = argv.shift() + var indexOfEqualSign = a.indexOf('=') + if (indexOfEqualSign !== -1) { + a = a.slice(0, indexOfEqualSign) + argv.unshift(a.slice(indexOfEqualSign + 1)) + } + switch (a) { + case '-rv': case '-rev': case '--rev': case '--reverse': + reverse = true + break + case '-l': case '--loose': + loose = true + break + case '-p': case '--include-prerelease': + includePrerelease = true + break + case '-v': case '--version': + versions.push(argv.shift()) + break + case '-i': case '--inc': case '--increment': + switch (argv[0]) { + case 'major': case 'minor': case 'patch': case 'prerelease': + case 'premajor': case 'preminor': case 'prepatch': + inc = argv.shift() + break + default: + inc = 'patch' + break + } + break + case '--preid': + identifier = argv.shift() + break + case '-r': case '--range': + range.push(argv.shift()) + break + case '-c': case '--coerce': + coerce = true + break + case '--rtl': + rtl = true + break + case '--ltr': + rtl = false + break + case '-h': case '--help': case '-?': + return help() + default: + versions.push(a) + break + } + } + + var options = { loose: loose, includePrerelease: includePrerelease, rtl: rtl } + + versions = versions.map(function (v) { + return coerce ? (semver.coerce(v, options) || { version: v }).version : v + }).filter(function (v) { + return semver.valid(v) + }) + if (!versions.length) return fail() + if (inc && (versions.length !== 1 || range.length)) { return failInc() } + + for (var i = 0, l = range.length; i < l; i++) { + versions = versions.filter(function (v) { + return semver.satisfies(v, range[i], options) + }) + if (!versions.length) return fail() + } + return success(versions) +} + +function failInc () { + console.error('--inc can only be used on a single version with no range') + fail() +} + +function fail () { process.exit(1) } + +function success () { + var compare = reverse ? 'rcompare' : 'compare' + versions.sort(function (a, b) { + return semver[compare](a, b, options) + }).map(function (v) { + return semver.clean(v, options) + }).map(function (v) { + return inc ? semver.inc(v, inc, options, identifier) : v + }).forEach(function (v, i, _) { console.log(v) }) +} + +function help () { + console.log(['SemVer ' + version, + '', + 'A JavaScript implementation of the https://semver.org/ specification', + 'Copyright Isaac Z. Schlueter', + '', + 'Usage: semver [options] [ [...]]', + 'Prints valid versions sorted by SemVer precedence', + '', + 'Options:', + '-r --range ', + ' Print versions that match the specified range.', + '', + '-i --increment []', + ' Increment a version by the specified level. Level can', + ' be one of: major, minor, patch, premajor, preminor,', + " prepatch, or prerelease. Default level is 'patch'.", + ' Only one version may be specified.', + '', + '--preid ', + ' Identifier to be used to prefix premajor, preminor,', + ' prepatch or prerelease version increments.', + '', + '-l --loose', + ' Interpret versions and ranges loosely', + '', + '-p --include-prerelease', + ' Always include prerelease versions in range matching', + '', + '-c --coerce', + ' Coerce a string into SemVer if possible', + ' (does not imply --loose)', + '', + '--rtl', + ' Coerce version strings right to left', + '', + '--ltr', + ' Coerce version strings left to right (default)', + '', + 'Program exits successfully if any valid version satisfies', + 'all supplied ranges, and prints all satisfying versions.', + '', + 'If no satisfying versions are found, then exits failure.', + '', + 'Versions are printed in ascending order, so supplying', + 'multiple versions to the utility will just sort them.' + ].join('\n')) +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/semver/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/semver/package.json new file mode 100644 index 0000000000000000000000000000000000000000..6b970a629ffe81d300d6b0469fa9b1992ca24c8e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/semver/package.json @@ -0,0 +1,38 @@ +{ + "name": "semver", + "version": "6.3.1", + "description": "The semantic version parser used by npm.", + "main": "semver.js", + "scripts": { + "test": "tap test/ --100 --timeout=30", + "lint": "echo linting disabled", + "postlint": "template-oss-check", + "template-oss-apply": "template-oss-apply --force", + "lintfix": "npm run lint -- --fix", + "snap": "tap test/ --100 --timeout=30", + "posttest": "npm run lint" + }, + "devDependencies": { + "@npmcli/template-oss": "4.17.0", + "tap": "^12.7.0" + }, + "license": "ISC", + "repository": { + "type": "git", + "url": "https://github.com/npm/node-semver.git" + }, + "bin": { + "semver": "./bin/semver.js" + }, + "files": [ + "bin", + "range.bnf", + "semver.js" + ], + "author": "GitHub Inc.", + "templateOSS": { + "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.", + "content": "./scripts/template-oss", + "version": "4.17.0" + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/semver/range.bnf b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/semver/range.bnf new file mode 100644 index 0000000000000000000000000000000000000000..d4c6ae0d76c9ac0c10c93062e5ff9cec277b07cd --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/semver/range.bnf @@ -0,0 +1,16 @@ +range-set ::= range ( logical-or range ) * +logical-or ::= ( ' ' ) * '||' ( ' ' ) * +range ::= hyphen | simple ( ' ' simple ) * | '' +hyphen ::= partial ' - ' partial +simple ::= primitive | partial | tilde | caret +primitive ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial +partial ::= xr ( '.' xr ( '.' xr qualifier ? )? )? +xr ::= 'x' | 'X' | '*' | nr +nr ::= '0' | [1-9] ( [0-9] ) * +tilde ::= '~' partial +caret ::= '^' partial +qualifier ::= ( '-' pre )? ( '+' build )? +pre ::= parts +build ::= parts +parts ::= part ( '.' part ) * +part ::= nr | [-0-9A-Za-z]+ diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/semver/semver.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/semver/semver.js new file mode 100644 index 0000000000000000000000000000000000000000..39319c13cac27d65d88d34dac95470a6494a0dae --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/semver/semver.js @@ -0,0 +1,1643 @@ +exports = module.exports = SemVer + +var debug +/* istanbul ignore next */ +if (typeof process === 'object' && + process.env && + process.env.NODE_DEBUG && + /\bsemver\b/i.test(process.env.NODE_DEBUG)) { + debug = function () { + var args = Array.prototype.slice.call(arguments, 0) + args.unshift('SEMVER') + console.log.apply(console, args) + } +} else { + debug = function () {} +} + +// Note: this is the semver.org version of the spec that it implements +// Not necessarily the package version of this code. +exports.SEMVER_SPEC_VERSION = '2.0.0' + +var MAX_LENGTH = 256 +var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || + /* istanbul ignore next */ 9007199254740991 + +// Max safe segment length for coercion. +var MAX_SAFE_COMPONENT_LENGTH = 16 + +var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6 + +// The actual regexps go on exports.re +var re = exports.re = [] +var safeRe = exports.safeRe = [] +var src = exports.src = [] +var t = exports.tokens = {} +var R = 0 + +function tok (n) { + t[n] = R++ +} + +var LETTERDASHNUMBER = '[a-zA-Z0-9-]' + +// Replace some greedy regex tokens to prevent regex dos issues. These regex are +// used internally via the safeRe object since all inputs in this library get +// normalized first to trim and collapse all extra whitespace. The original +// regexes are exported for userland consumption and lower level usage. A +// future breaking change could export the safer regex only with a note that +// all input should have extra whitespace removed. +var safeRegexReplacements = [ + ['\\s', 1], + ['\\d', MAX_LENGTH], + [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH], +] + +function makeSafeRe (value) { + for (var i = 0; i < safeRegexReplacements.length; i++) { + var token = safeRegexReplacements[i][0] + var max = safeRegexReplacements[i][1] + value = value + .split(token + '*').join(token + '{0,' + max + '}') + .split(token + '+').join(token + '{1,' + max + '}') + } + return value +} + +// The following Regular Expressions can be used for tokenizing, +// validating, and parsing SemVer version strings. + +// ## Numeric Identifier +// A single `0`, or a non-zero digit followed by zero or more digits. + +tok('NUMERICIDENTIFIER') +src[t.NUMERICIDENTIFIER] = '0|[1-9]\\d*' +tok('NUMERICIDENTIFIERLOOSE') +src[t.NUMERICIDENTIFIERLOOSE] = '\\d+' + +// ## Non-numeric Identifier +// Zero or more digits, followed by a letter or hyphen, and then zero or +// more letters, digits, or hyphens. + +tok('NONNUMERICIDENTIFIER') +src[t.NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-]' + LETTERDASHNUMBER + '*' + +// ## Main Version +// Three dot-separated numeric identifiers. + +tok('MAINVERSION') +src[t.MAINVERSION] = '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + + '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + + '(' + src[t.NUMERICIDENTIFIER] + ')' + +tok('MAINVERSIONLOOSE') +src[t.MAINVERSIONLOOSE] = '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')' + +// ## Pre-release Version Identifier +// A numeric identifier, or a non-numeric identifier. + +tok('PRERELEASEIDENTIFIER') +src[t.PRERELEASEIDENTIFIER] = '(?:' + src[t.NUMERICIDENTIFIER] + + '|' + src[t.NONNUMERICIDENTIFIER] + ')' + +tok('PRERELEASEIDENTIFIERLOOSE') +src[t.PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[t.NUMERICIDENTIFIERLOOSE] + + '|' + src[t.NONNUMERICIDENTIFIER] + ')' + +// ## Pre-release Version +// Hyphen, followed by one or more dot-separated pre-release version +// identifiers. + +tok('PRERELEASE') +src[t.PRERELEASE] = '(?:-(' + src[t.PRERELEASEIDENTIFIER] + + '(?:\\.' + src[t.PRERELEASEIDENTIFIER] + ')*))' + +tok('PRERELEASELOOSE') +src[t.PRERELEASELOOSE] = '(?:-?(' + src[t.PRERELEASEIDENTIFIERLOOSE] + + '(?:\\.' + src[t.PRERELEASEIDENTIFIERLOOSE] + ')*))' + +// ## Build Metadata Identifier +// Any combination of digits, letters, or hyphens. + +tok('BUILDIDENTIFIER') +src[t.BUILDIDENTIFIER] = LETTERDASHNUMBER + '+' + +// ## Build Metadata +// Plus sign, followed by one or more period-separated build metadata +// identifiers. + +tok('BUILD') +src[t.BUILD] = '(?:\\+(' + src[t.BUILDIDENTIFIER] + + '(?:\\.' + src[t.BUILDIDENTIFIER] + ')*))' + +// ## Full Version String +// A main version, followed optionally by a pre-release version and +// build metadata. + +// Note that the only major, minor, patch, and pre-release sections of +// the version string are capturing groups. The build metadata is not a +// capturing group, because it should not ever be used in version +// comparison. + +tok('FULL') +tok('FULLPLAIN') +src[t.FULLPLAIN] = 'v?' + src[t.MAINVERSION] + + src[t.PRERELEASE] + '?' + + src[t.BUILD] + '?' + +src[t.FULL] = '^' + src[t.FULLPLAIN] + '$' + +// like full, but allows v1.2.3 and =1.2.3, which people do sometimes. +// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty +// common in the npm registry. +tok('LOOSEPLAIN') +src[t.LOOSEPLAIN] = '[v=\\s]*' + src[t.MAINVERSIONLOOSE] + + src[t.PRERELEASELOOSE] + '?' + + src[t.BUILD] + '?' + +tok('LOOSE') +src[t.LOOSE] = '^' + src[t.LOOSEPLAIN] + '$' + +tok('GTLT') +src[t.GTLT] = '((?:<|>)?=?)' + +// Something like "2.*" or "1.2.x". +// Note that "x.x" is a valid xRange identifer, meaning "any version" +// Only the first item is strictly required. +tok('XRANGEIDENTIFIERLOOSE') +src[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + '|x|X|\\*' +tok('XRANGEIDENTIFIER') +src[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + '|x|X|\\*' + +tok('XRANGEPLAIN') +src[t.XRANGEPLAIN] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIER] + ')' + + '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + + '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + + '(?:' + src[t.PRERELEASE] + ')?' + + src[t.BUILD] + '?' + + ')?)?' + +tok('XRANGEPLAINLOOSE') +src[t.XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + + '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + + '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + + '(?:' + src[t.PRERELEASELOOSE] + ')?' + + src[t.BUILD] + '?' + + ')?)?' + +tok('XRANGE') +src[t.XRANGE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAIN] + '$' +tok('XRANGELOOSE') +src[t.XRANGELOOSE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAINLOOSE] + '$' + +// Coercion. +// Extract anything that could conceivably be a part of a valid semver +tok('COERCE') +src[t.COERCE] = '(^|[^\\d])' + + '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' + + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + + '(?:$|[^\\d])' +tok('COERCERTL') +re[t.COERCERTL] = new RegExp(src[t.COERCE], 'g') +safeRe[t.COERCERTL] = new RegExp(makeSafeRe(src[t.COERCE]), 'g') + +// Tilde ranges. +// Meaning is "reasonably at or greater than" +tok('LONETILDE') +src[t.LONETILDE] = '(?:~>?)' + +tok('TILDETRIM') +src[t.TILDETRIM] = '(\\s*)' + src[t.LONETILDE] + '\\s+' +re[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], 'g') +safeRe[t.TILDETRIM] = new RegExp(makeSafeRe(src[t.TILDETRIM]), 'g') +var tildeTrimReplace = '$1~' + +tok('TILDE') +src[t.TILDE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAIN] + '$' +tok('TILDELOOSE') +src[t.TILDELOOSE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + '$' + +// Caret ranges. +// Meaning is "at least and backwards compatible with" +tok('LONECARET') +src[t.LONECARET] = '(?:\\^)' + +tok('CARETTRIM') +src[t.CARETTRIM] = '(\\s*)' + src[t.LONECARET] + '\\s+' +re[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], 'g') +safeRe[t.CARETTRIM] = new RegExp(makeSafeRe(src[t.CARETTRIM]), 'g') +var caretTrimReplace = '$1^' + +tok('CARET') +src[t.CARET] = '^' + src[t.LONECARET] + src[t.XRANGEPLAIN] + '$' +tok('CARETLOOSE') +src[t.CARETLOOSE] = '^' + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + '$' + +// A simple gt/lt/eq thing, or just "" to indicate "any version" +tok('COMPARATORLOOSE') +src[t.COMPARATORLOOSE] = '^' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + ')$|^$' +tok('COMPARATOR') +src[t.COMPARATOR] = '^' + src[t.GTLT] + '\\s*(' + src[t.FULLPLAIN] + ')$|^$' + +// An expression to strip any whitespace between the gtlt and the thing +// it modifies, so that `> 1.2.3` ==> `>1.2.3` +tok('COMPARATORTRIM') +src[t.COMPARATORTRIM] = '(\\s*)' + src[t.GTLT] + + '\\s*(' + src[t.LOOSEPLAIN] + '|' + src[t.XRANGEPLAIN] + ')' + +// this one has to use the /g flag +re[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], 'g') +safeRe[t.COMPARATORTRIM] = new RegExp(makeSafeRe(src[t.COMPARATORTRIM]), 'g') +var comparatorTrimReplace = '$1$2$3' + +// Something like `1.2.3 - 1.2.4` +// Note that these all use the loose form, because they'll be +// checked against either the strict or loose comparator form +// later. +tok('HYPHENRANGE') +src[t.HYPHENRANGE] = '^\\s*(' + src[t.XRANGEPLAIN] + ')' + + '\\s+-\\s+' + + '(' + src[t.XRANGEPLAIN] + ')' + + '\\s*$' + +tok('HYPHENRANGELOOSE') +src[t.HYPHENRANGELOOSE] = '^\\s*(' + src[t.XRANGEPLAINLOOSE] + ')' + + '\\s+-\\s+' + + '(' + src[t.XRANGEPLAINLOOSE] + ')' + + '\\s*$' + +// Star ranges basically just allow anything at all. +tok('STAR') +src[t.STAR] = '(<|>)?=?\\s*\\*' + +// Compile to actual regexp objects. +// All are flag-free, unless they were created above with a flag. +for (var i = 0; i < R; i++) { + debug(i, src[i]) + if (!re[i]) { + re[i] = new RegExp(src[i]) + + // Replace all greedy whitespace to prevent regex dos issues. These regex are + // used internally via the safeRe object since all inputs in this library get + // normalized first to trim and collapse all extra whitespace. The original + // regexes are exported for userland consumption and lower level usage. A + // future breaking change could export the safer regex only with a note that + // all input should have extra whitespace removed. + safeRe[i] = new RegExp(makeSafeRe(src[i])) + } +} + +exports.parse = parse +function parse (version, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + if (version instanceof SemVer) { + return version + } + + if (typeof version !== 'string') { + return null + } + + if (version.length > MAX_LENGTH) { + return null + } + + var r = options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL] + if (!r.test(version)) { + return null + } + + try { + return new SemVer(version, options) + } catch (er) { + return null + } +} + +exports.valid = valid +function valid (version, options) { + var v = parse(version, options) + return v ? v.version : null +} + +exports.clean = clean +function clean (version, options) { + var s = parse(version.trim().replace(/^[=v]+/, ''), options) + return s ? s.version : null +} + +exports.SemVer = SemVer + +function SemVer (version, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + if (version instanceof SemVer) { + if (version.loose === options.loose) { + return version + } else { + version = version.version + } + } else if (typeof version !== 'string') { + throw new TypeError('Invalid Version: ' + version) + } + + if (version.length > MAX_LENGTH) { + throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters') + } + + if (!(this instanceof SemVer)) { + return new SemVer(version, options) + } + + debug('SemVer', version, options) + this.options = options + this.loose = !!options.loose + + var m = version.trim().match(options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL]) + + if (!m) { + throw new TypeError('Invalid Version: ' + version) + } + + this.raw = version + + // these are actually numbers + this.major = +m[1] + this.minor = +m[2] + this.patch = +m[3] + + if (this.major > MAX_SAFE_INTEGER || this.major < 0) { + throw new TypeError('Invalid major version') + } + + if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) { + throw new TypeError('Invalid minor version') + } + + if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) { + throw new TypeError('Invalid patch version') + } + + // numberify any prerelease numeric ids + if (!m[4]) { + this.prerelease = [] + } else { + this.prerelease = m[4].split('.').map(function (id) { + if (/^[0-9]+$/.test(id)) { + var num = +id + if (num >= 0 && num < MAX_SAFE_INTEGER) { + return num + } + } + return id + }) + } + + this.build = m[5] ? m[5].split('.') : [] + this.format() +} + +SemVer.prototype.format = function () { + this.version = this.major + '.' + this.minor + '.' + this.patch + if (this.prerelease.length) { + this.version += '-' + this.prerelease.join('.') + } + return this.version +} + +SemVer.prototype.toString = function () { + return this.version +} + +SemVer.prototype.compare = function (other) { + debug('SemVer.compare', this.version, this.options, other) + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + return this.compareMain(other) || this.comparePre(other) +} + +SemVer.prototype.compareMain = function (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + return compareIdentifiers(this.major, other.major) || + compareIdentifiers(this.minor, other.minor) || + compareIdentifiers(this.patch, other.patch) +} + +SemVer.prototype.comparePre = function (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + // NOT having a prerelease is > having one + if (this.prerelease.length && !other.prerelease.length) { + return -1 + } else if (!this.prerelease.length && other.prerelease.length) { + return 1 + } else if (!this.prerelease.length && !other.prerelease.length) { + return 0 + } + + var i = 0 + do { + var a = this.prerelease[i] + var b = other.prerelease[i] + debug('prerelease compare', i, a, b) + if (a === undefined && b === undefined) { + return 0 + } else if (b === undefined) { + return 1 + } else if (a === undefined) { + return -1 + } else if (a === b) { + continue + } else { + return compareIdentifiers(a, b) + } + } while (++i) +} + +SemVer.prototype.compareBuild = function (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + var i = 0 + do { + var a = this.build[i] + var b = other.build[i] + debug('prerelease compare', i, a, b) + if (a === undefined && b === undefined) { + return 0 + } else if (b === undefined) { + return 1 + } else if (a === undefined) { + return -1 + } else if (a === b) { + continue + } else { + return compareIdentifiers(a, b) + } + } while (++i) +} + +// preminor will bump the version up to the next minor release, and immediately +// down to pre-release. premajor and prepatch work the same way. +SemVer.prototype.inc = function (release, identifier) { + switch (release) { + case 'premajor': + this.prerelease.length = 0 + this.patch = 0 + this.minor = 0 + this.major++ + this.inc('pre', identifier) + break + case 'preminor': + this.prerelease.length = 0 + this.patch = 0 + this.minor++ + this.inc('pre', identifier) + break + case 'prepatch': + // If this is already a prerelease, it will bump to the next version + // drop any prereleases that might already exist, since they are not + // relevant at this point. + this.prerelease.length = 0 + this.inc('patch', identifier) + this.inc('pre', identifier) + break + // If the input is a non-prerelease version, this acts the same as + // prepatch. + case 'prerelease': + if (this.prerelease.length === 0) { + this.inc('patch', identifier) + } + this.inc('pre', identifier) + break + + case 'major': + // If this is a pre-major version, bump up to the same major version. + // Otherwise increment major. + // 1.0.0-5 bumps to 1.0.0 + // 1.1.0 bumps to 2.0.0 + if (this.minor !== 0 || + this.patch !== 0 || + this.prerelease.length === 0) { + this.major++ + } + this.minor = 0 + this.patch = 0 + this.prerelease = [] + break + case 'minor': + // If this is a pre-minor version, bump up to the same minor version. + // Otherwise increment minor. + // 1.2.0-5 bumps to 1.2.0 + // 1.2.1 bumps to 1.3.0 + if (this.patch !== 0 || this.prerelease.length === 0) { + this.minor++ + } + this.patch = 0 + this.prerelease = [] + break + case 'patch': + // If this is not a pre-release version, it will increment the patch. + // If it is a pre-release it will bump up to the same patch version. + // 1.2.0-5 patches to 1.2.0 + // 1.2.0 patches to 1.2.1 + if (this.prerelease.length === 0) { + this.patch++ + } + this.prerelease = [] + break + // This probably shouldn't be used publicly. + // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction. + case 'pre': + if (this.prerelease.length === 0) { + this.prerelease = [0] + } else { + var i = this.prerelease.length + while (--i >= 0) { + if (typeof this.prerelease[i] === 'number') { + this.prerelease[i]++ + i = -2 + } + } + if (i === -1) { + // didn't increment anything + this.prerelease.push(0) + } + } + if (identifier) { + // 1.2.0-beta.1 bumps to 1.2.0-beta.2, + // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0 + if (this.prerelease[0] === identifier) { + if (isNaN(this.prerelease[1])) { + this.prerelease = [identifier, 0] + } + } else { + this.prerelease = [identifier, 0] + } + } + break + + default: + throw new Error('invalid increment argument: ' + release) + } + this.format() + this.raw = this.version + return this +} + +exports.inc = inc +function inc (version, release, loose, identifier) { + if (typeof (loose) === 'string') { + identifier = loose + loose = undefined + } + + try { + return new SemVer(version, loose).inc(release, identifier).version + } catch (er) { + return null + } +} + +exports.diff = diff +function diff (version1, version2) { + if (eq(version1, version2)) { + return null + } else { + var v1 = parse(version1) + var v2 = parse(version2) + var prefix = '' + if (v1.prerelease.length || v2.prerelease.length) { + prefix = 'pre' + var defaultResult = 'prerelease' + } + for (var key in v1) { + if (key === 'major' || key === 'minor' || key === 'patch') { + if (v1[key] !== v2[key]) { + return prefix + key + } + } + } + return defaultResult // may be undefined + } +} + +exports.compareIdentifiers = compareIdentifiers + +var numeric = /^[0-9]+$/ +function compareIdentifiers (a, b) { + var anum = numeric.test(a) + var bnum = numeric.test(b) + + if (anum && bnum) { + a = +a + b = +b + } + + return a === b ? 0 + : (anum && !bnum) ? -1 + : (bnum && !anum) ? 1 + : a < b ? -1 + : 1 +} + +exports.rcompareIdentifiers = rcompareIdentifiers +function rcompareIdentifiers (a, b) { + return compareIdentifiers(b, a) +} + +exports.major = major +function major (a, loose) { + return new SemVer(a, loose).major +} + +exports.minor = minor +function minor (a, loose) { + return new SemVer(a, loose).minor +} + +exports.patch = patch +function patch (a, loose) { + return new SemVer(a, loose).patch +} + +exports.compare = compare +function compare (a, b, loose) { + return new SemVer(a, loose).compare(new SemVer(b, loose)) +} + +exports.compareLoose = compareLoose +function compareLoose (a, b) { + return compare(a, b, true) +} + +exports.compareBuild = compareBuild +function compareBuild (a, b, loose) { + var versionA = new SemVer(a, loose) + var versionB = new SemVer(b, loose) + return versionA.compare(versionB) || versionA.compareBuild(versionB) +} + +exports.rcompare = rcompare +function rcompare (a, b, loose) { + return compare(b, a, loose) +} + +exports.sort = sort +function sort (list, loose) { + return list.sort(function (a, b) { + return exports.compareBuild(a, b, loose) + }) +} + +exports.rsort = rsort +function rsort (list, loose) { + return list.sort(function (a, b) { + return exports.compareBuild(b, a, loose) + }) +} + +exports.gt = gt +function gt (a, b, loose) { + return compare(a, b, loose) > 0 +} + +exports.lt = lt +function lt (a, b, loose) { + return compare(a, b, loose) < 0 +} + +exports.eq = eq +function eq (a, b, loose) { + return compare(a, b, loose) === 0 +} + +exports.neq = neq +function neq (a, b, loose) { + return compare(a, b, loose) !== 0 +} + +exports.gte = gte +function gte (a, b, loose) { + return compare(a, b, loose) >= 0 +} + +exports.lte = lte +function lte (a, b, loose) { + return compare(a, b, loose) <= 0 +} + +exports.cmp = cmp +function cmp (a, op, b, loose) { + switch (op) { + case '===': + if (typeof a === 'object') + a = a.version + if (typeof b === 'object') + b = b.version + return a === b + + case '!==': + if (typeof a === 'object') + a = a.version + if (typeof b === 'object') + b = b.version + return a !== b + + case '': + case '=': + case '==': + return eq(a, b, loose) + + case '!=': + return neq(a, b, loose) + + case '>': + return gt(a, b, loose) + + case '>=': + return gte(a, b, loose) + + case '<': + return lt(a, b, loose) + + case '<=': + return lte(a, b, loose) + + default: + throw new TypeError('Invalid operator: ' + op) + } +} + +exports.Comparator = Comparator +function Comparator (comp, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + if (comp instanceof Comparator) { + if (comp.loose === !!options.loose) { + return comp + } else { + comp = comp.value + } + } + + if (!(this instanceof Comparator)) { + return new Comparator(comp, options) + } + + comp = comp.trim().split(/\s+/).join(' ') + debug('comparator', comp, options) + this.options = options + this.loose = !!options.loose + this.parse(comp) + + if (this.semver === ANY) { + this.value = '' + } else { + this.value = this.operator + this.semver.version + } + + debug('comp', this) +} + +var ANY = {} +Comparator.prototype.parse = function (comp) { + var r = this.options.loose ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR] + var m = comp.match(r) + + if (!m) { + throw new TypeError('Invalid comparator: ' + comp) + } + + this.operator = m[1] !== undefined ? m[1] : '' + if (this.operator === '=') { + this.operator = '' + } + + // if it literally is just '>' or '' then allow anything. + if (!m[2]) { + this.semver = ANY + } else { + this.semver = new SemVer(m[2], this.options.loose) + } +} + +Comparator.prototype.toString = function () { + return this.value +} + +Comparator.prototype.test = function (version) { + debug('Comparator.test', version, this.options.loose) + + if (this.semver === ANY || version === ANY) { + return true + } + + if (typeof version === 'string') { + try { + version = new SemVer(version, this.options) + } catch (er) { + return false + } + } + + return cmp(version, this.operator, this.semver, this.options) +} + +Comparator.prototype.intersects = function (comp, options) { + if (!(comp instanceof Comparator)) { + throw new TypeError('a Comparator is required') + } + + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + var rangeTmp + + if (this.operator === '') { + if (this.value === '') { + return true + } + rangeTmp = new Range(comp.value, options) + return satisfies(this.value, rangeTmp, options) + } else if (comp.operator === '') { + if (comp.value === '') { + return true + } + rangeTmp = new Range(this.value, options) + return satisfies(comp.semver, rangeTmp, options) + } + + var sameDirectionIncreasing = + (this.operator === '>=' || this.operator === '>') && + (comp.operator === '>=' || comp.operator === '>') + var sameDirectionDecreasing = + (this.operator === '<=' || this.operator === '<') && + (comp.operator === '<=' || comp.operator === '<') + var sameSemVer = this.semver.version === comp.semver.version + var differentDirectionsInclusive = + (this.operator === '>=' || this.operator === '<=') && + (comp.operator === '>=' || comp.operator === '<=') + var oppositeDirectionsLessThan = + cmp(this.semver, '<', comp.semver, options) && + ((this.operator === '>=' || this.operator === '>') && + (comp.operator === '<=' || comp.operator === '<')) + var oppositeDirectionsGreaterThan = + cmp(this.semver, '>', comp.semver, options) && + ((this.operator === '<=' || this.operator === '<') && + (comp.operator === '>=' || comp.operator === '>')) + + return sameDirectionIncreasing || sameDirectionDecreasing || + (sameSemVer && differentDirectionsInclusive) || + oppositeDirectionsLessThan || oppositeDirectionsGreaterThan +} + +exports.Range = Range +function Range (range, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + if (range instanceof Range) { + if (range.loose === !!options.loose && + range.includePrerelease === !!options.includePrerelease) { + return range + } else { + return new Range(range.raw, options) + } + } + + if (range instanceof Comparator) { + return new Range(range.value, options) + } + + if (!(this instanceof Range)) { + return new Range(range, options) + } + + this.options = options + this.loose = !!options.loose + this.includePrerelease = !!options.includePrerelease + + // First reduce all whitespace as much as possible so we do not have to rely + // on potentially slow regexes like \s*. This is then stored and used for + // future error messages as well. + this.raw = range + .trim() + .split(/\s+/) + .join(' ') + + // First, split based on boolean or || + this.set = this.raw.split('||').map(function (range) { + return this.parseRange(range.trim()) + }, this).filter(function (c) { + // throw out any that are not relevant for whatever reason + return c.length + }) + + if (!this.set.length) { + throw new TypeError('Invalid SemVer Range: ' + this.raw) + } + + this.format() +} + +Range.prototype.format = function () { + this.range = this.set.map(function (comps) { + return comps.join(' ').trim() + }).join('||').trim() + return this.range +} + +Range.prototype.toString = function () { + return this.range +} + +Range.prototype.parseRange = function (range) { + var loose = this.options.loose + // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4` + var hr = loose ? safeRe[t.HYPHENRANGELOOSE] : safeRe[t.HYPHENRANGE] + range = range.replace(hr, hyphenReplace) + debug('hyphen replace', range) + // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5` + range = range.replace(safeRe[t.COMPARATORTRIM], comparatorTrimReplace) + debug('comparator trim', range, safeRe[t.COMPARATORTRIM]) + + // `~ 1.2.3` => `~1.2.3` + range = range.replace(safeRe[t.TILDETRIM], tildeTrimReplace) + + // `^ 1.2.3` => `^1.2.3` + range = range.replace(safeRe[t.CARETTRIM], caretTrimReplace) + + // normalize spaces + range = range.split(/\s+/).join(' ') + + // At this point, the range is completely trimmed and + // ready to be split into comparators. + + var compRe = loose ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR] + var set = range.split(' ').map(function (comp) { + return parseComparator(comp, this.options) + }, this).join(' ').split(/\s+/) + if (this.options.loose) { + // in loose mode, throw out any that are not valid comparators + set = set.filter(function (comp) { + return !!comp.match(compRe) + }) + } + set = set.map(function (comp) { + return new Comparator(comp, this.options) + }, this) + + return set +} + +Range.prototype.intersects = function (range, options) { + if (!(range instanceof Range)) { + throw new TypeError('a Range is required') + } + + return this.set.some(function (thisComparators) { + return ( + isSatisfiable(thisComparators, options) && + range.set.some(function (rangeComparators) { + return ( + isSatisfiable(rangeComparators, options) && + thisComparators.every(function (thisComparator) { + return rangeComparators.every(function (rangeComparator) { + return thisComparator.intersects(rangeComparator, options) + }) + }) + ) + }) + ) + }) +} + +// take a set of comparators and determine whether there +// exists a version which can satisfy it +function isSatisfiable (comparators, options) { + var result = true + var remainingComparators = comparators.slice() + var testComparator = remainingComparators.pop() + + while (result && remainingComparators.length) { + result = remainingComparators.every(function (otherComparator) { + return testComparator.intersects(otherComparator, options) + }) + + testComparator = remainingComparators.pop() + } + + return result +} + +// Mostly just for testing and legacy API reasons +exports.toComparators = toComparators +function toComparators (range, options) { + return new Range(range, options).set.map(function (comp) { + return comp.map(function (c) { + return c.value + }).join(' ').trim().split(' ') + }) +} + +// comprised of xranges, tildes, stars, and gtlt's at this point. +// already replaced the hyphen ranges +// turn into a set of JUST comparators. +function parseComparator (comp, options) { + debug('comp', comp, options) + comp = replaceCarets(comp, options) + debug('caret', comp) + comp = replaceTildes(comp, options) + debug('tildes', comp) + comp = replaceXRanges(comp, options) + debug('xrange', comp) + comp = replaceStars(comp, options) + debug('stars', comp) + return comp +} + +function isX (id) { + return !id || id.toLowerCase() === 'x' || id === '*' +} + +// ~, ~> --> * (any, kinda silly) +// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0 +// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0 +// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0 +// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0 +// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0 +function replaceTildes (comp, options) { + return comp.trim().split(/\s+/).map(function (comp) { + return replaceTilde(comp, options) + }).join(' ') +} + +function replaceTilde (comp, options) { + var r = options.loose ? safeRe[t.TILDELOOSE] : safeRe[t.TILDE] + return comp.replace(r, function (_, M, m, p, pr) { + debug('tilde', comp, _, M, m, p, pr) + var ret + + if (isX(M)) { + ret = '' + } else if (isX(m)) { + ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0' + } else if (isX(p)) { + // ~1.2 == >=1.2.0 <1.3.0 + ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0' + } else if (pr) { + debug('replaceTilde pr', pr) + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + M + '.' + (+m + 1) + '.0' + } else { + // ~1.2.3 == >=1.2.3 <1.3.0 + ret = '>=' + M + '.' + m + '.' + p + + ' <' + M + '.' + (+m + 1) + '.0' + } + + debug('tilde return', ret) + return ret + }) +} + +// ^ --> * (any, kinda silly) +// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0 +// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0 +// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0 +// ^1.2.3 --> >=1.2.3 <2.0.0 +// ^1.2.0 --> >=1.2.0 <2.0.0 +function replaceCarets (comp, options) { + return comp.trim().split(/\s+/).map(function (comp) { + return replaceCaret(comp, options) + }).join(' ') +} + +function replaceCaret (comp, options) { + debug('caret', comp, options) + var r = options.loose ? safeRe[t.CARETLOOSE] : safeRe[t.CARET] + return comp.replace(r, function (_, M, m, p, pr) { + debug('caret', comp, _, M, m, p, pr) + var ret + + if (isX(M)) { + ret = '' + } else if (isX(m)) { + ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0' + } else if (isX(p)) { + if (M === '0') { + ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0' + } else { + ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0' + } + } else if (pr) { + debug('replaceCaret pr', pr) + if (M === '0') { + if (m === '0') { + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + M + '.' + m + '.' + (+p + 1) + } else { + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + M + '.' + (+m + 1) + '.0' + } + } else { + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + (+M + 1) + '.0.0' + } + } else { + debug('no pr') + if (M === '0') { + if (m === '0') { + ret = '>=' + M + '.' + m + '.' + p + + ' <' + M + '.' + m + '.' + (+p + 1) + } else { + ret = '>=' + M + '.' + m + '.' + p + + ' <' + M + '.' + (+m + 1) + '.0' + } + } else { + ret = '>=' + M + '.' + m + '.' + p + + ' <' + (+M + 1) + '.0.0' + } + } + + debug('caret return', ret) + return ret + }) +} + +function replaceXRanges (comp, options) { + debug('replaceXRanges', comp, options) + return comp.split(/\s+/).map(function (comp) { + return replaceXRange(comp, options) + }).join(' ') +} + +function replaceXRange (comp, options) { + comp = comp.trim() + var r = options.loose ? safeRe[t.XRANGELOOSE] : safeRe[t.XRANGE] + return comp.replace(r, function (ret, gtlt, M, m, p, pr) { + debug('xRange', comp, ret, gtlt, M, m, p, pr) + var xM = isX(M) + var xm = xM || isX(m) + var xp = xm || isX(p) + var anyX = xp + + if (gtlt === '=' && anyX) { + gtlt = '' + } + + // if we're including prereleases in the match, then we need + // to fix this to -0, the lowest possible prerelease value + pr = options.includePrerelease ? '-0' : '' + + if (xM) { + if (gtlt === '>' || gtlt === '<') { + // nothing is allowed + ret = '<0.0.0-0' + } else { + // nothing is forbidden + ret = '*' + } + } else if (gtlt && anyX) { + // we know patch is an x, because we have any x at all. + // replace X with 0 + if (xm) { + m = 0 + } + p = 0 + + if (gtlt === '>') { + // >1 => >=2.0.0 + // >1.2 => >=1.3.0 + // >1.2.3 => >= 1.2.4 + gtlt = '>=' + if (xm) { + M = +M + 1 + m = 0 + p = 0 + } else { + m = +m + 1 + p = 0 + } + } else if (gtlt === '<=') { + // <=0.7.x is actually <0.8.0, since any 0.7.x should + // pass. Similarly, <=7.x is actually <8.0.0, etc. + gtlt = '<' + if (xm) { + M = +M + 1 + } else { + m = +m + 1 + } + } + + ret = gtlt + M + '.' + m + '.' + p + pr + } else if (xm) { + ret = '>=' + M + '.0.0' + pr + ' <' + (+M + 1) + '.0.0' + pr + } else if (xp) { + ret = '>=' + M + '.' + m + '.0' + pr + + ' <' + M + '.' + (+m + 1) + '.0' + pr + } + + debug('xRange return', ret) + + return ret + }) +} + +// Because * is AND-ed with everything else in the comparator, +// and '' means "any version", just remove the *s entirely. +function replaceStars (comp, options) { + debug('replaceStars', comp, options) + // Looseness is ignored here. star is always as loose as it gets! + return comp.trim().replace(safeRe[t.STAR], '') +} + +// This function is passed to string.replace(re[t.HYPHENRANGE]) +// M, m, patch, prerelease, build +// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5 +// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do +// 1.2 - 3.4 => >=1.2.0 <3.5.0 +function hyphenReplace ($0, + from, fM, fm, fp, fpr, fb, + to, tM, tm, tp, tpr, tb) { + if (isX(fM)) { + from = '' + } else if (isX(fm)) { + from = '>=' + fM + '.0.0' + } else if (isX(fp)) { + from = '>=' + fM + '.' + fm + '.0' + } else { + from = '>=' + from + } + + if (isX(tM)) { + to = '' + } else if (isX(tm)) { + to = '<' + (+tM + 1) + '.0.0' + } else if (isX(tp)) { + to = '<' + tM + '.' + (+tm + 1) + '.0' + } else if (tpr) { + to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr + } else { + to = '<=' + to + } + + return (from + ' ' + to).trim() +} + +// if ANY of the sets match ALL of its comparators, then pass +Range.prototype.test = function (version) { + if (!version) { + return false + } + + if (typeof version === 'string') { + try { + version = new SemVer(version, this.options) + } catch (er) { + return false + } + } + + for (var i = 0; i < this.set.length; i++) { + if (testSet(this.set[i], version, this.options)) { + return true + } + } + return false +} + +function testSet (set, version, options) { + for (var i = 0; i < set.length; i++) { + if (!set[i].test(version)) { + return false + } + } + + if (version.prerelease.length && !options.includePrerelease) { + // Find the set of versions that are allowed to have prereleases + // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0 + // That should allow `1.2.3-pr.2` to pass. + // However, `1.2.4-alpha.notready` should NOT be allowed, + // even though it's within the range set by the comparators. + for (i = 0; i < set.length; i++) { + debug(set[i].semver) + if (set[i].semver === ANY) { + continue + } + + if (set[i].semver.prerelease.length > 0) { + var allowed = set[i].semver + if (allowed.major === version.major && + allowed.minor === version.minor && + allowed.patch === version.patch) { + return true + } + } + } + + // Version has a -pre, but it's not one of the ones we like. + return false + } + + return true +} + +exports.satisfies = satisfies +function satisfies (version, range, options) { + try { + range = new Range(range, options) + } catch (er) { + return false + } + return range.test(version) +} + +exports.maxSatisfying = maxSatisfying +function maxSatisfying (versions, range, options) { + var max = null + var maxSV = null + try { + var rangeObj = new Range(range, options) + } catch (er) { + return null + } + versions.forEach(function (v) { + if (rangeObj.test(v)) { + // satisfies(v, range, options) + if (!max || maxSV.compare(v) === -1) { + // compare(max, v, true) + max = v + maxSV = new SemVer(max, options) + } + } + }) + return max +} + +exports.minSatisfying = minSatisfying +function minSatisfying (versions, range, options) { + var min = null + var minSV = null + try { + var rangeObj = new Range(range, options) + } catch (er) { + return null + } + versions.forEach(function (v) { + if (rangeObj.test(v)) { + // satisfies(v, range, options) + if (!min || minSV.compare(v) === 1) { + // compare(min, v, true) + min = v + minSV = new SemVer(min, options) + } + } + }) + return min +} + +exports.minVersion = minVersion +function minVersion (range, loose) { + range = new Range(range, loose) + + var minver = new SemVer('0.0.0') + if (range.test(minver)) { + return minver + } + + minver = new SemVer('0.0.0-0') + if (range.test(minver)) { + return minver + } + + minver = null + for (var i = 0; i < range.set.length; ++i) { + var comparators = range.set[i] + + comparators.forEach(function (comparator) { + // Clone to avoid manipulating the comparator's semver object. + var compver = new SemVer(comparator.semver.version) + switch (comparator.operator) { + case '>': + if (compver.prerelease.length === 0) { + compver.patch++ + } else { + compver.prerelease.push(0) + } + compver.raw = compver.format() + /* fallthrough */ + case '': + case '>=': + if (!minver || gt(minver, compver)) { + minver = compver + } + break + case '<': + case '<=': + /* Ignore maximum versions */ + break + /* istanbul ignore next */ + default: + throw new Error('Unexpected operation: ' + comparator.operator) + } + }) + } + + if (minver && range.test(minver)) { + return minver + } + + return null +} + +exports.validRange = validRange +function validRange (range, options) { + try { + // Return '*' instead of '' so that truthiness works. + // This will throw if it's invalid anyway + return new Range(range, options).range || '*' + } catch (er) { + return null + } +} + +// Determine if version is less than all the versions possible in the range +exports.ltr = ltr +function ltr (version, range, options) { + return outside(version, range, '<', options) +} + +// Determine if version is greater than all the versions possible in the range. +exports.gtr = gtr +function gtr (version, range, options) { + return outside(version, range, '>', options) +} + +exports.outside = outside +function outside (version, range, hilo, options) { + version = new SemVer(version, options) + range = new Range(range, options) + + var gtfn, ltefn, ltfn, comp, ecomp + switch (hilo) { + case '>': + gtfn = gt + ltefn = lte + ltfn = lt + comp = '>' + ecomp = '>=' + break + case '<': + gtfn = lt + ltefn = gte + ltfn = gt + comp = '<' + ecomp = '<=' + break + default: + throw new TypeError('Must provide a hilo val of "<" or ">"') + } + + // If it satisifes the range it is not outside + if (satisfies(version, range, options)) { + return false + } + + // From now on, variable terms are as if we're in "gtr" mode. + // but note that everything is flipped for the "ltr" function. + + for (var i = 0; i < range.set.length; ++i) { + var comparators = range.set[i] + + var high = null + var low = null + + comparators.forEach(function (comparator) { + if (comparator.semver === ANY) { + comparator = new Comparator('>=0.0.0') + } + high = high || comparator + low = low || comparator + if (gtfn(comparator.semver, high.semver, options)) { + high = comparator + } else if (ltfn(comparator.semver, low.semver, options)) { + low = comparator + } + }) + + // If the edge version comparator has a operator then our version + // isn't outside it + if (high.operator === comp || high.operator === ecomp) { + return false + } + + // If the lowest version comparator has an operator and our version + // is less than it then it isn't higher than the range + if ((!low.operator || low.operator === comp) && + ltefn(version, low.semver)) { + return false + } else if (low.operator === ecomp && ltfn(version, low.semver)) { + return false + } + } + return true +} + +exports.prerelease = prerelease +function prerelease (version, options) { + var parsed = parse(version, options) + return (parsed && parsed.prerelease.length) ? parsed.prerelease : null +} + +exports.intersects = intersects +function intersects (r1, r2, options) { + r1 = new Range(r1, options) + r2 = new Range(r2, options) + return r1.intersects(r2) +} + +exports.coerce = coerce +function coerce (version, options) { + if (version instanceof SemVer) { + return version + } + + if (typeof version === 'number') { + version = String(version) + } + + if (typeof version !== 'string') { + return null + } + + options = options || {} + + var match = null + if (!options.rtl) { + match = version.match(safeRe[t.COERCE]) + } else { + // Find the right-most coercible string that does not share + // a terminus with a more left-ward coercible string. + // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4' + // + // Walk through the string checking with a /g regexp + // Manually set the index so as to pick up overlapping matches. + // Stop when we get a match that ends at the string end, since no + // coercible string can be more right-ward without the same terminus. + var next + while ((next = safeRe[t.COERCERTL].exec(version)) && + (!match || match.index + match[0].length !== version.length) + ) { + if (!match || + next.index + next[0].length !== match.index + match[0].length) { + match = next + } + safeRe[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length + } + // leave it in a clean state + safeRe[t.COERCERTL].lastIndex = -1 + } + + if (match === null) { + return null + } + + return parse(match[2] + + '.' + (match[3] || '0') + + '.' + (match[4] || '0'), options) +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/signal-exit/LICENSE.txt b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/signal-exit/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..eead04a12162dc336a2d5029bc5101c9e430aa21 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/signal-exit/LICENSE.txt @@ -0,0 +1,16 @@ +The ISC License + +Copyright (c) 2015, Contributors + +Permission to use, copy, modify, and/or distribute this software +for any purpose with or without fee is hereby granted, provided +that the above copyright notice and this permission notice +appear in all copies. + +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. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/signal-exit/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/signal-exit/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f9c7c007d550d035f81a0c310b179fee771274b1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/signal-exit/README.md @@ -0,0 +1,39 @@ +# signal-exit + +[![Build Status](https://travis-ci.org/tapjs/signal-exit.png)](https://travis-ci.org/tapjs/signal-exit) +[![Coverage](https://coveralls.io/repos/tapjs/signal-exit/badge.svg?branch=master)](https://coveralls.io/r/tapjs/signal-exit?branch=master) +[![NPM version](https://img.shields.io/npm/v/signal-exit.svg)](https://www.npmjs.com/package/signal-exit) +[![Standard Version](https://img.shields.io/badge/release-standard%20version-brightgreen.svg)](https://github.com/conventional-changelog/standard-version) + +When you want to fire an event no matter how a process exits: + +* reaching the end of execution. +* explicitly having `process.exit(code)` called. +* having `process.kill(pid, sig)` called. +* receiving a fatal signal from outside the process + +Use `signal-exit`. + +```js +var onExit = require('signal-exit') + +onExit(function (code, signal) { + console.log('process exited!') +}) +``` + +## API + +`var remove = onExit(function (code, signal) {}, options)` + +The return value of the function is a function that will remove the +handler. + +Note that the function *only* fires for signals if the signal would +cause the process to exit. That is, there are no other listeners, and +it is a fatal signal. + +## Options + +* `alwaysLast`: Run this handler after any other signal or exit + handlers. This causes `process.emit` to be monkeypatched. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/signal-exit/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/signal-exit/index.js new file mode 100644 index 0000000000000000000000000000000000000000..93703f369265c6771ae720335b27b2014049bea5 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/signal-exit/index.js @@ -0,0 +1,202 @@ +// Note: since nyc uses this module to output coverage, any lines +// that are in the direct sync flow of nyc's outputCoverage are +// ignored, since we can never get coverage for them. +// grab a reference to node's real process object right away +var process = global.process + +const processOk = function (process) { + return process && + typeof process === 'object' && + typeof process.removeListener === 'function' && + typeof process.emit === 'function' && + typeof process.reallyExit === 'function' && + typeof process.listeners === 'function' && + typeof process.kill === 'function' && + typeof process.pid === 'number' && + typeof process.on === 'function' +} + +// some kind of non-node environment, just no-op +/* istanbul ignore if */ +if (!processOk(process)) { + module.exports = function () { + return function () {} + } +} else { + var assert = require('assert') + var signals = require('./signals.js') + var isWin = /^win/i.test(process.platform) + + var EE = require('events') + /* istanbul ignore if */ + if (typeof EE !== 'function') { + EE = EE.EventEmitter + } + + var emitter + if (process.__signal_exit_emitter__) { + emitter = process.__signal_exit_emitter__ + } else { + emitter = process.__signal_exit_emitter__ = new EE() + emitter.count = 0 + emitter.emitted = {} + } + + // Because this emitter is a global, we have to check to see if a + // previous version of this library failed to enable infinite listeners. + // I know what you're about to say. But literally everything about + // signal-exit is a compromise with evil. Get used to it. + if (!emitter.infinite) { + emitter.setMaxListeners(Infinity) + emitter.infinite = true + } + + module.exports = function (cb, opts) { + /* istanbul ignore if */ + if (!processOk(global.process)) { + return function () {} + } + assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler') + + if (loaded === false) { + load() + } + + var ev = 'exit' + if (opts && opts.alwaysLast) { + ev = 'afterexit' + } + + var remove = function () { + emitter.removeListener(ev, cb) + if (emitter.listeners('exit').length === 0 && + emitter.listeners('afterexit').length === 0) { + unload() + } + } + emitter.on(ev, cb) + + return remove + } + + var unload = function unload () { + if (!loaded || !processOk(global.process)) { + return + } + loaded = false + + signals.forEach(function (sig) { + try { + process.removeListener(sig, sigListeners[sig]) + } catch (er) {} + }) + process.emit = originalProcessEmit + process.reallyExit = originalProcessReallyExit + emitter.count -= 1 + } + module.exports.unload = unload + + var emit = function emit (event, code, signal) { + /* istanbul ignore if */ + if (emitter.emitted[event]) { + return + } + emitter.emitted[event] = true + emitter.emit(event, code, signal) + } + + // { : , ... } + var sigListeners = {} + signals.forEach(function (sig) { + sigListeners[sig] = function listener () { + /* istanbul ignore if */ + if (!processOk(global.process)) { + return + } + // If there are no other listeners, an exit is coming! + // Simplest way: remove us and then re-send the signal. + // We know that this will kill the process, so we can + // safely emit now. + var listeners = process.listeners(sig) + if (listeners.length === emitter.count) { + unload() + emit('exit', null, sig) + /* istanbul ignore next */ + emit('afterexit', null, sig) + /* istanbul ignore next */ + if (isWin && sig === 'SIGHUP') { + // "SIGHUP" throws an `ENOSYS` error on Windows, + // so use a supported signal instead + sig = 'SIGINT' + } + /* istanbul ignore next */ + process.kill(process.pid, sig) + } + } + }) + + module.exports.signals = function () { + return signals + } + + var loaded = false + + var load = function load () { + if (loaded || !processOk(global.process)) { + return + } + loaded = true + + // This is the number of onSignalExit's that are in play. + // It's important so that we can count the correct number of + // listeners on signals, and don't wait for the other one to + // handle it instead of us. + emitter.count += 1 + + signals = signals.filter(function (sig) { + try { + process.on(sig, sigListeners[sig]) + return true + } catch (er) { + return false + } + }) + + process.emit = processEmit + process.reallyExit = processReallyExit + } + module.exports.load = load + + var originalProcessReallyExit = process.reallyExit + var processReallyExit = function processReallyExit (code) { + /* istanbul ignore if */ + if (!processOk(global.process)) { + return + } + process.exitCode = code || /* istanbul ignore next */ 0 + emit('exit', process.exitCode, null) + /* istanbul ignore next */ + emit('afterexit', process.exitCode, null) + /* istanbul ignore next */ + originalProcessReallyExit.call(process, process.exitCode) + } + + var originalProcessEmit = process.emit + var processEmit = function processEmit (ev, arg) { + if (ev === 'exit' && processOk(global.process)) { + /* istanbul ignore else */ + if (arg !== undefined) { + process.exitCode = arg + } + var ret = originalProcessEmit.apply(this, arguments) + /* istanbul ignore next */ + emit('exit', process.exitCode, null) + /* istanbul ignore next */ + emit('afterexit', process.exitCode, null) + /* istanbul ignore next */ + return ret + } else { + return originalProcessEmit.apply(this, arguments) + } + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/signal-exit/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/signal-exit/package.json new file mode 100644 index 0000000000000000000000000000000000000000..e1a00311f9fbe5bff5ccc01bd1d5fdbff12c34f6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/signal-exit/package.json @@ -0,0 +1,38 @@ +{ + "name": "signal-exit", + "version": "3.0.7", + "description": "when you want to fire an event no matter how a process exits.", + "main": "index.js", + "scripts": { + "test": "tap", + "snap": "tap", + "preversion": "npm test", + "postversion": "npm publish", + "prepublishOnly": "git push origin --follow-tags" + }, + "files": [ + "index.js", + "signals.js" + ], + "repository": { + "type": "git", + "url": "https://github.com/tapjs/signal-exit.git" + }, + "keywords": [ + "signal", + "exit" + ], + "author": "Ben Coe ", + "license": "ISC", + "bugs": { + "url": "https://github.com/tapjs/signal-exit/issues" + }, + "homepage": "https://github.com/tapjs/signal-exit", + "devDependencies": { + "chai": "^3.5.0", + "coveralls": "^3.1.1", + "nyc": "^15.1.0", + "standard-version": "^9.3.1", + "tap": "^15.1.1" + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/signal-exit/signals.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/signal-exit/signals.js new file mode 100644 index 0000000000000000000000000000000000000000..3bd67a8a554e30dddb9854997ab9485ac01e90dc --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/signal-exit/signals.js @@ -0,0 +1,53 @@ +// This is not the set of all possible signals. +// +// It IS, however, the set of all signals that trigger +// an exit on either Linux or BSD systems. Linux is a +// superset of the signal names supported on BSD, and +// the unknown signals just fail to register, so we can +// catch that easily enough. +// +// Don't bother with SIGKILL. It's uncatchable, which +// means that we can't fire any callbacks anyway. +// +// If a user does happen to register a handler on a non- +// fatal signal like SIGWINCH or something, and then +// exit, it'll end up firing `process.emit('exit')`, so +// the handler will be fired anyway. +// +// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised +// artificially, inherently leave the process in a +// state from which it is not safe to try and enter JS +// listeners. +module.exports = [ + 'SIGABRT', + 'SIGALRM', + 'SIGHUP', + 'SIGINT', + 'SIGTERM' +] + +if (process.platform !== 'win32') { + module.exports.push( + 'SIGVTALRM', + 'SIGXCPU', + 'SIGXFSZ', + 'SIGUSR2', + 'SIGTRAP', + 'SIGSYS', + 'SIGQUIT', + 'SIGIOT' + // should detect profiler and enable/disable accordingly. + // see #21 + // 'SIGPROF' + ) +} + +if (process.platform === 'linux') { + module.exports.push( + 'SIGIO', + 'SIGPOLL', + 'SIGPWR', + 'SIGSTKFLT', + 'SIGUNUSED' + ) +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/strip-ansi/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/strip-ansi/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..907fccc29269ebcd49141fa8a4513be3b6a8d270 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/strip-ansi/index.d.ts @@ -0,0 +1,17 @@ +/** +Strip [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code) from a string. + +@example +``` +import stripAnsi = require('strip-ansi'); + +stripAnsi('\u001B[4mUnicorn\u001B[0m'); +//=> 'Unicorn' + +stripAnsi('\u001B]8;;https://github.com\u0007Click\u001B]8;;\u0007'); +//=> 'Click' +``` +*/ +declare function stripAnsi(string: string): string; + +export = stripAnsi; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/strip-ansi/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/strip-ansi/index.js new file mode 100644 index 0000000000000000000000000000000000000000..9a593dfcd1fd5c9e627d9ff2ed85a88df9a41a99 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/strip-ansi/index.js @@ -0,0 +1,4 @@ +'use strict'; +const ansiRegex = require('ansi-regex'); + +module.exports = string => typeof string === 'string' ? string.replace(ansiRegex(), '') : string; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/strip-ansi/license b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/strip-ansi/license new file mode 100644 index 0000000000000000000000000000000000000000..e7af2f77107d73046421ef56c4684cbfdd3c1e89 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/strip-ansi/license @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) Sindre Sorhus (sindresorhus.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/strip-ansi/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/strip-ansi/package.json new file mode 100644 index 0000000000000000000000000000000000000000..1a41108d42831c9c156fdcc4e6cd8c2539983ccd --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/strip-ansi/package.json @@ -0,0 +1,54 @@ +{ + "name": "strip-ansi", + "version": "6.0.1", + "description": "Strip ANSI escape codes from a string", + "license": "MIT", + "repository": "chalk/strip-ansi", + "author": { + "name": "Sindre Sorhus", + "email": "sindresorhus@gmail.com", + "url": "sindresorhus.com" + }, + "engines": { + "node": ">=8" + }, + "scripts": { + "test": "xo && ava && tsd" + }, + "files": [ + "index.js", + "index.d.ts" + ], + "keywords": [ + "strip", + "trim", + "remove", + "ansi", + "styles", + "color", + "colour", + "colors", + "terminal", + "console", + "string", + "tty", + "escape", + "formatting", + "rgb", + "256", + "shell", + "xterm", + "log", + "logging", + "command-line", + "text" + ], + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "devDependencies": { + "ava": "^2.4.0", + "tsd": "^0.10.0", + "xo": "^0.25.3" + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/strip-ansi/readme.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/strip-ansi/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..7c4b56d46ddc72a3a627a5fd8f3dfcad8c9b599e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/strip-ansi/readme.md @@ -0,0 +1,46 @@ +# strip-ansi [![Build Status](https://travis-ci.org/chalk/strip-ansi.svg?branch=master)](https://travis-ci.org/chalk/strip-ansi) + +> Strip [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code) from a string + + +## Install + +``` +$ npm install strip-ansi +``` + + +## Usage + +```js +const stripAnsi = require('strip-ansi'); + +stripAnsi('\u001B[4mUnicorn\u001B[0m'); +//=> 'Unicorn' + +stripAnsi('\u001B]8;;https://github.com\u0007Click\u001B]8;;\u0007'); +//=> 'Click' +``` + + +## strip-ansi for enterprise + +Available as part of the Tidelift Subscription. + +The maintainers of strip-ansi and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-strip-ansi?utm_source=npm-strip-ansi&utm_medium=referral&utm_campaign=enterprise&utm_term=repo) + + +## Related + +- [strip-ansi-cli](https://github.com/chalk/strip-ansi-cli) - CLI for this module +- [strip-ansi-stream](https://github.com/chalk/strip-ansi-stream) - Streaming version of this module +- [has-ansi](https://github.com/chalk/has-ansi) - Check if a string has ANSI escape codes +- [ansi-regex](https://github.com/chalk/ansi-regex) - Regular expression for matching ANSI escape codes +- [chalk](https://github.com/chalk/chalk) - Terminal string styling done right + + +## Maintainers + +- [Sindre Sorhus](https://github.com/sindresorhus) +- [Josh Junon](https://github.com/qix-) + diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/supports-color/browser.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/supports-color/browser.js new file mode 100644 index 0000000000000000000000000000000000000000..f097aecd76a090174e5c3371234043d1ddc5d5fd --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/supports-color/browser.js @@ -0,0 +1,24 @@ +/* eslint-env browser */ +'use strict'; + +function getChromeVersion() { + const matches = /(Chrome|Chromium)\/(?\d+)\./.exec(navigator.userAgent); + + if (!matches) { + return; + } + + return Number.parseInt(matches.groups.chromeVersion, 10); +} + +const colorSupport = getChromeVersion() >= 69 ? { + level: 1, + hasBasic: true, + has256: false, + has16m: false +} : false; + +module.exports = { + stdout: colorSupport, + stderr: colorSupport +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/supports-color/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/supports-color/index.js new file mode 100644 index 0000000000000000000000000000000000000000..2dd2fcb0b057d0de56990ad41692550183830c09 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/supports-color/index.js @@ -0,0 +1,152 @@ +'use strict'; +const os = require('os'); +const tty = require('tty'); +const hasFlag = require('has-flag'); + +const {env} = process; + +let flagForceColor; +if (hasFlag('no-color') || + hasFlag('no-colors') || + hasFlag('color=false') || + hasFlag('color=never')) { + flagForceColor = 0; +} else if (hasFlag('color') || + hasFlag('colors') || + hasFlag('color=true') || + hasFlag('color=always')) { + flagForceColor = 1; +} + +function envForceColor() { + if ('FORCE_COLOR' in env) { + if (env.FORCE_COLOR === 'true') { + return 1; + } + + if (env.FORCE_COLOR === 'false') { + return 0; + } + + return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3); + } +} + +function translateLevel(level) { + if (level === 0) { + return false; + } + + return { + level, + hasBasic: true, + has256: level >= 2, + has16m: level >= 3 + }; +} + +function supportsColor(haveStream, {streamIsTTY, sniffFlags = true} = {}) { + const noFlagForceColor = envForceColor(); + if (noFlagForceColor !== undefined) { + flagForceColor = noFlagForceColor; + } + + const forceColor = sniffFlags ? flagForceColor : noFlagForceColor; + + if (forceColor === 0) { + return 0; + } + + if (sniffFlags) { + if (hasFlag('color=16m') || + hasFlag('color=full') || + hasFlag('color=truecolor')) { + return 3; + } + + if (hasFlag('color=256')) { + return 2; + } + } + + if (haveStream && !streamIsTTY && forceColor === undefined) { + return 0; + } + + const min = forceColor || 0; + + if (env.TERM === 'dumb') { + return min; + } + + if (process.platform === 'win32') { + // Windows 10 build 10586 is the first Windows release that supports 256 colors. + // Windows 10 build 14931 is the first release that supports 16m/TrueColor. + const osRelease = os.release().split('.'); + if ( + Number(osRelease[0]) >= 10 && + Number(osRelease[2]) >= 10586 + ) { + return Number(osRelease[2]) >= 14931 ? 3 : 2; + } + + return 1; + } + + if ('CI' in env) { + if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE', 'DRONE'].some(sign => sign in env) || env.CI_NAME === 'codeship') { + return 1; + } + + return min; + } + + if ('TEAMCITY_VERSION' in env) { + return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0; + } + + if (env.COLORTERM === 'truecolor') { + return 3; + } + + if ('TERM_PROGRAM' in env) { + const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10); + + switch (env.TERM_PROGRAM) { + case 'iTerm.app': + return version >= 3 ? 3 : 2; + case 'Apple_Terminal': + return 2; + // No default + } + } + + if (/-256(color)?$/i.test(env.TERM)) { + return 2; + } + + if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) { + return 1; + } + + if ('COLORTERM' in env) { + return 1; + } + + return min; +} + +function getSupportLevel(stream, options = {}) { + const level = supportsColor(stream, { + streamIsTTY: stream && stream.isTTY, + ...options + }); + + return translateLevel(level); +} + +module.exports = { + supportsColor: getSupportLevel, + stdout: getSupportLevel({isTTY: tty.isatty(1)}), + stderr: getSupportLevel({isTTY: tty.isatty(2)}) +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/supports-color/license b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/supports-color/license new file mode 100644 index 0000000000000000000000000000000000000000..fa7ceba3eb4a9657a9db7f3ffca4e4e97a9019de --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/supports-color/license @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) Sindre Sorhus (https://sindresorhus.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/supports-color/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/supports-color/package.json new file mode 100644 index 0000000000000000000000000000000000000000..a97bf2a108df2dc34563500e109b98e910169684 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/supports-color/package.json @@ -0,0 +1,58 @@ +{ + "name": "supports-color", + "version": "8.1.1", + "description": "Detect whether a terminal supports color", + "license": "MIT", + "repository": "chalk/supports-color", + "funding": "https://github.com/chalk/supports-color?sponsor=1", + "author": { + "name": "Sindre Sorhus", + "email": "sindresorhus@gmail.com", + "url": "https://sindresorhus.com" + }, + "engines": { + "node": ">=10" + }, + "scripts": { + "test": "xo && ava" + }, + "files": [ + "index.js", + "browser.js" + ], + "exports": { + "node": "./index.js", + "default": "./browser.js" + }, + "keywords": [ + "color", + "colour", + "colors", + "terminal", + "console", + "cli", + "ansi", + "styles", + "tty", + "rgb", + "256", + "shell", + "xterm", + "command-line", + "support", + "supports", + "capability", + "detect", + "truecolor", + "16m" + ], + "dependencies": { + "has-flag": "^4.0.0" + }, + "devDependencies": { + "ava": "^2.4.0", + "import-fresh": "^3.2.2", + "xo": "^0.35.0" + }, + "browser": "browser.js" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/supports-color/readme.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/supports-color/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..3eedd1caa40a0db02f9266e7efdb1c9c46837063 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/supports-color/readme.md @@ -0,0 +1,77 @@ +# supports-color + +> Detect whether a terminal supports color + +## Install + +``` +$ npm install supports-color +``` + +## Usage + +```js +const supportsColor = require('supports-color'); + +if (supportsColor.stdout) { + console.log('Terminal stdout supports color'); +} + +if (supportsColor.stdout.has256) { + console.log('Terminal stdout supports 256 colors'); +} + +if (supportsColor.stderr.has16m) { + console.log('Terminal stderr supports 16 million colors (truecolor)'); +} +``` + +## API + +Returns an `Object` with a `stdout` and `stderr` property for testing either streams. Each property is an `Object`, or `false` if color is not supported. + +The `stdout`/`stderr` objects specifies a level of support for color through a `.level` property and a corresponding flag: + +- `.level = 1` and `.hasBasic = true`: Basic color support (16 colors) +- `.level = 2` and `.has256 = true`: 256 color support +- `.level = 3` and `.has16m = true`: Truecolor support (16 million colors) + +### `require('supports-color').supportsColor(stream, options?)` + +Additionally, `supports-color` exposes the `.supportsColor()` function that takes an arbitrary write stream (e.g. `process.stdout`) and an optional options object to (re-)evaluate color support for an arbitrary stream. + +For example, `require('supports-color').stdout` is the equivalent of `require('supports-color').supportsColor(process.stdout)`. + +The options object supports a single boolean property `sniffFlags`. By default it is `true`, which instructs `supportsColor()` to sniff `process.argv` for the multitude of `--color` flags (see _Info_ below). If `false`, then `process.argv` is not considered when determining color support. + +## Info + +It obeys the `--color` and `--no-color` CLI flags. + +For situations where using `--color` is not possible, use the environment variable `FORCE_COLOR=1` (level 1), `FORCE_COLOR=2` (level 2), or `FORCE_COLOR=3` (level 3) to forcefully enable color, or `FORCE_COLOR=0` to forcefully disable. The use of `FORCE_COLOR` overrides all other color support checks. + +Explicit 256/Truecolor mode can be enabled using the `--color=256` and `--color=16m` flags, respectively. + +## Related + +- [supports-color-cli](https://github.com/chalk/supports-color-cli) - CLI for this module +- [chalk](https://github.com/chalk/chalk) - Terminal string styling done right + +## Maintainers + +- [Sindre Sorhus](https://github.com/sindresorhus) +- [Josh Junon](https://github.com/qix-) + +--- + +
+ + Get professional support for this package with a Tidelift subscription + +
+ + Tidelift helps make open source sustainable for maintainers while giving companies
assurances about security, maintenance, and licensing for their dependencies. + +
+ +--- diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/write-file-atomic/LICENSE.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/write-file-atomic/LICENSE.md new file mode 100644 index 0000000000000000000000000000000000000000..95e65a7706e0e9702fa110e3e59fcf001cda2daa --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/write-file-atomic/LICENSE.md @@ -0,0 +1,6 @@ +Copyright (c) 2015, Rebecca Turner + +Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. + +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. + diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/write-file-atomic/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/write-file-atomic/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2d9ef6024559fb8b1c57e359120dd38416111244 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/write-file-atomic/README.md @@ -0,0 +1,91 @@ +write-file-atomic +----------------- + +This is an extension for node's `fs.writeFile` that makes its operation +atomic and allows you set ownership (uid/gid of the file). + +### `writeFileAtomic(filename, data, [options], [callback])` + +#### Description: + +Atomically and asynchronously writes data to a file, replacing the file if it already +exists. data can be a string or a buffer. + +#### Options: +* filename **String** +* data **String** | **Buffer** +* options **Object** | **String** + * chown **Object** default, uid & gid of existing file, if any + * uid **Number** + * gid **Number** + * encoding **String** | **Null** default = 'utf8' + * fsync **Boolean** default = true + * mode **Number** default, from existing file, if any + * tmpfileCreated **Function** called when the tmpfile is created +* callback **Function** + +#### Usage: + +```js +var writeFileAtomic = require('write-file-atomic') +writeFileAtomic(filename, data, [options], [callback]) +``` + +The file is initially named `filename + "." + murmurhex(__filename, process.pid, ++invocations)`. +Note that `require('worker_threads').threadId` is used in addition to `process.pid` if running inside of a worker thread. +If writeFile completes successfully then, if passed the **chown** option it will change +the ownership of the file. Finally it renames the file back to the filename you specified. If +it encounters errors at any of these steps it will attempt to unlink the temporary file and then +pass the error back to the caller. +If multiple writes are concurrently issued to the same file, the write operations are put into a queue and serialized in the order they were called, using Promises. Writes to different files are still executed in parallel. + +If provided, the **chown** option requires both **uid** and **gid** properties or else +you'll get an error. If **chown** is not specified it will default to using +the owner of the previous file. To prevent chown from being ran you can +also pass `false`, in which case the file will be created with the current user's credentials. + +If **mode** is not specified, it will default to using the permissions from +an existing file, if any. Expicitly setting this to `false` remove this default, resulting +in a file created with the system default permissions. + +If options is a String, it's assumed to be the **encoding** option. The **encoding** option is ignored if **data** is a buffer. It defaults to 'utf8'. + +If the **fsync** option is **false**, writeFile will skip the final fsync call. + +If the **tmpfileCreated** option is specified it will be called with the name of the tmpfile when created. + +Example: + +```javascript +writeFileAtomic('message.txt', 'Hello Node', {chown:{uid:100,gid:50}}, function (err) { + if (err) throw err; + console.log('It\'s saved!'); +}); +``` + +This function also supports async/await: + +```javascript +(async () => { + try { + await writeFileAtomic('message.txt', 'Hello Node', {chown:{uid:100,gid:50}}); + console.log('It\'s saved!'); + } catch (err) { + console.error(err); + process.exit(1); + } +})(); +``` + +### `writeFileAtomicSync(filename, data, [options])` + +#### Description: + +The synchronous version of **writeFileAtomic**. + +#### Usage: +```js +var writeFileAtomicSync = require('write-file-atomic').sync +writeFileAtomicSync(filename, data, [options]) +``` + diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/write-file-atomic/lib/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/write-file-atomic/lib/index.js new file mode 100644 index 0000000000000000000000000000000000000000..9d79d797a553fe58875787cc20c9fa687268f67e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/write-file-atomic/lib/index.js @@ -0,0 +1,267 @@ +'use strict' +module.exports = writeFile +module.exports.sync = writeFileSync +module.exports._getTmpname = getTmpname // for testing +module.exports._cleanupOnExit = cleanupOnExit + +const fs = require('fs') +const MurmurHash3 = require('imurmurhash') +const onExit = require('signal-exit') +const path = require('path') +const { promisify } = require('util') +const activeFiles = {} + +// if we run inside of a worker_thread, `process.pid` is not unique +/* istanbul ignore next */ +const threadId = (function getId () { + try { + const workerThreads = require('worker_threads') + + /// if we are in main thread, this is set to `0` + return workerThreads.threadId + } catch (e) { + // worker_threads are not available, fallback to 0 + return 0 + } +})() + +let invocations = 0 +function getTmpname (filename) { + return filename + '.' + + MurmurHash3(__filename) + .hash(String(process.pid)) + .hash(String(threadId)) + .hash(String(++invocations)) + .result() +} + +function cleanupOnExit (tmpfile) { + return () => { + try { + fs.unlinkSync(typeof tmpfile === 'function' ? tmpfile() : tmpfile) + } catch { + // ignore errors + } + } +} + +function serializeActiveFile (absoluteName) { + return new Promise(resolve => { + // make a queue if it doesn't already exist + if (!activeFiles[absoluteName]) { + activeFiles[absoluteName] = [] + } + + activeFiles[absoluteName].push(resolve) // add this job to the queue + if (activeFiles[absoluteName].length === 1) { + resolve() + } // kick off the first one + }) +} + +// https://github.com/isaacs/node-graceful-fs/blob/master/polyfills.js#L315-L342 +function isChownErrOk (err) { + if (err.code === 'ENOSYS') { + return true + } + + const nonroot = !process.getuid || process.getuid() !== 0 + if (nonroot) { + if (err.code === 'EINVAL' || err.code === 'EPERM') { + return true + } + } + + return false +} + +async function writeFileAsync (filename, data, options = {}) { + if (typeof options === 'string') { + options = { encoding: options } + } + + let fd + let tmpfile + /* istanbul ignore next -- The closure only gets called when onExit triggers */ + const removeOnExitHandler = onExit(cleanupOnExit(() => tmpfile)) + const absoluteName = path.resolve(filename) + + try { + await serializeActiveFile(absoluteName) + const truename = await promisify(fs.realpath)(filename).catch(() => filename) + tmpfile = getTmpname(truename) + + if (!options.mode || !options.chown) { + // Either mode or chown is not explicitly set + // Default behavior is to copy it from original file + const stats = await promisify(fs.stat)(truename).catch(() => {}) + if (stats) { + if (options.mode == null) { + options.mode = stats.mode + } + + if (options.chown == null && process.getuid) { + options.chown = { uid: stats.uid, gid: stats.gid } + } + } + } + + fd = await promisify(fs.open)(tmpfile, 'w', options.mode) + if (options.tmpfileCreated) { + await options.tmpfileCreated(tmpfile) + } + if (ArrayBuffer.isView(data)) { + await promisify(fs.write)(fd, data, 0, data.length, 0) + } else if (data != null) { + await promisify(fs.write)(fd, String(data), 0, String(options.encoding || 'utf8')) + } + + if (options.fsync !== false) { + await promisify(fs.fsync)(fd) + } + + await promisify(fs.close)(fd) + fd = null + + if (options.chown) { + await promisify(fs.chown)(tmpfile, options.chown.uid, options.chown.gid).catch(err => { + if (!isChownErrOk(err)) { + throw err + } + }) + } + + if (options.mode) { + await promisify(fs.chmod)(tmpfile, options.mode).catch(err => { + if (!isChownErrOk(err)) { + throw err + } + }) + } + + await promisify(fs.rename)(tmpfile, truename) + } finally { + if (fd) { + await promisify(fs.close)(fd).catch( + /* istanbul ignore next */ + () => {} + ) + } + removeOnExitHandler() + await promisify(fs.unlink)(tmpfile).catch(() => {}) + activeFiles[absoluteName].shift() // remove the element added by serializeSameFile + if (activeFiles[absoluteName].length > 0) { + activeFiles[absoluteName][0]() // start next job if one is pending + } else { + delete activeFiles[absoluteName] + } + } +} + +async function writeFile (filename, data, options, callback) { + if (options instanceof Function) { + callback = options + options = {} + } + + const promise = writeFileAsync(filename, data, options) + if (callback) { + try { + const result = await promise + return callback(result) + } catch (err) { + return callback(err) + } + } + + return promise +} + +function writeFileSync (filename, data, options) { + if (typeof options === 'string') { + options = { encoding: options } + } else if (!options) { + options = {} + } + try { + filename = fs.realpathSync(filename) + } catch (ex) { + // it's ok, it'll happen on a not yet existing file + } + const tmpfile = getTmpname(filename) + + if (!options.mode || !options.chown) { + // Either mode or chown is not explicitly set + // Default behavior is to copy it from original file + try { + const stats = fs.statSync(filename) + options = Object.assign({}, options) + if (!options.mode) { + options.mode = stats.mode + } + if (!options.chown && process.getuid) { + options.chown = { uid: stats.uid, gid: stats.gid } + } + } catch (ex) { + // ignore stat errors + } + } + + let fd + const cleanup = cleanupOnExit(tmpfile) + const removeOnExitHandler = onExit(cleanup) + + let threw = true + try { + fd = fs.openSync(tmpfile, 'w', options.mode || 0o666) + if (options.tmpfileCreated) { + options.tmpfileCreated(tmpfile) + } + if (ArrayBuffer.isView(data)) { + fs.writeSync(fd, data, 0, data.length, 0) + } else if (data != null) { + fs.writeSync(fd, String(data), 0, String(options.encoding || 'utf8')) + } + if (options.fsync !== false) { + fs.fsyncSync(fd) + } + + fs.closeSync(fd) + fd = null + + if (options.chown) { + try { + fs.chownSync(tmpfile, options.chown.uid, options.chown.gid) + } catch (err) { + if (!isChownErrOk(err)) { + throw err + } + } + } + + if (options.mode) { + try { + fs.chmodSync(tmpfile, options.mode) + } catch (err) { + if (!isChownErrOk(err)) { + throw err + } + } + } + + fs.renameSync(tmpfile, filename) + threw = false + } finally { + if (fd) { + try { + fs.closeSync(fd) + } catch (ex) { + // ignore close errors at this stage, error may have closed fd already. + } + } + removeOnExitHandler() + if (threw) { + cleanup() + } + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/write-file-atomic/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/write-file-atomic/package.json new file mode 100644 index 0000000000000000000000000000000000000000..86e2a0fbadfeb67c0f8e3da266a22e1daf3c8c9c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/node_modules/write-file-atomic/package.json @@ -0,0 +1,55 @@ +{ + "name": "write-file-atomic", + "version": "4.0.2", + "description": "Write files in an atomic fashion w/configurable ownership", + "main": "./lib/index.js", + "scripts": { + "test": "tap", + "posttest": "npm run lint", + "lint": "eslint \"**/*.js\"", + "postlint": "template-oss-check", + "preversion": "npm test", + "postversion": "npm publish", + "prepublishOnly": "git push origin --follow-tags", + "lintfix": "npm run lint -- --fix", + "snap": "tap", + "template-oss-apply": "template-oss-apply --force" + }, + "repository": { + "type": "git", + "url": "https://github.com/npm/write-file-atomic.git" + }, + "keywords": [ + "writeFile", + "atomic" + ], + "author": "GitHub Inc.", + "license": "ISC", + "bugs": { + "url": "https://github.com/npm/write-file-atomic/issues" + }, + "homepage": "https://github.com/npm/write-file-atomic", + "dependencies": { + "imurmurhash": "^0.1.4", + "signal-exit": "^3.0.7" + }, + "devDependencies": { + "@npmcli/eslint-config": "^3.0.1", + "@npmcli/template-oss": "3.5.0", + "mkdirp": "^1.0.4", + "rimraf": "^3.0.2", + "tap": "^16.0.1" + }, + "files": [ + "bin/", + "lib/" + ], + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + }, + "templateOSS": { + "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.", + "windowsCI": false, + "version": "3.5.0" + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/package.json new file mode 100644 index 0000000000000000000000000000000000000000..d1f63b82f9ca6a1993525a7af497f697adc51ca7 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/reporters/package.json @@ -0,0 +1,82 @@ +{ + "name": "@jest/reporters", + "description": "Jest's reporters", + "version": "29.7.0", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "dependencies": { + "@bcoe/v8-coverage": "^0.2.3", + "@jest/console": "^29.7.0", + "@jest/test-result": "^29.7.0", + "@jest/transform": "^29.7.0", + "@jest/types": "^29.6.3", + "@jridgewell/trace-mapping": "^0.3.18", + "@types/node": "*", + "chalk": "^4.0.0", + "collect-v8-coverage": "^1.0.0", + "exit": "^0.1.2", + "glob": "^7.1.3", + "graceful-fs": "^4.2.9", + "istanbul-lib-coverage": "^3.0.0", + "istanbul-lib-instrument": "^6.0.0", + "istanbul-lib-report": "^3.0.0", + "istanbul-lib-source-maps": "^4.0.0", + "istanbul-reports": "^3.1.3", + "jest-message-util": "^29.7.0", + "jest-util": "^29.7.0", + "jest-worker": "^29.7.0", + "slash": "^3.0.0", + "string-length": "^4.0.1", + "strip-ansi": "^6.0.0", + "v8-to-istanbul": "^9.0.1" + }, + "devDependencies": { + "@jest/test-utils": "^29.7.0", + "@tsd/typescript": "^5.0.4", + "@types/exit": "^0.1.30", + "@types/glob": "^7.1.1", + "@types/graceful-fs": "^4.1.3", + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-lib-instrument": "^1.7.2", + "@types/istanbul-lib-report": "^3.0.0", + "@types/istanbul-lib-source-maps": "^4.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node-notifier": "^8.0.0", + "jest-resolve": "^29.7.0", + "mock-fs": "^5.1.2", + "node-notifier": "^10.0.0", + "tsd-lite": "^0.7.0" + }, + "peerDependencies": { + "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" + }, + "peerDependenciesMeta": { + "node-notifier": { + "optional": true + } + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/jest-reporters" + }, + "bugs": { + "url": "https://github.com/jestjs/jest/issues" + }, + "homepage": "https://jestjs.io/", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/schemas/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/schemas/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/schemas/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/schemas/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/schemas/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b2a1d122925edc20525da1ea5c660cce4161f2ca --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/schemas/README.md @@ -0,0 +1,3 @@ +# `@jest/schemas` + +Experimental and currently incomplete module for JSON schemas for [Jest's](https://jestjs.io/) configuration. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/schemas/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/schemas/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..156f1978efd956532dd6c50f1ee64001daba1a51 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/schemas/build/index.d.ts @@ -0,0 +1,63 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +import {Static} from '@sinclair/typebox'; +import {TBoolean} from '@sinclair/typebox'; +import {TNull} from '@sinclair/typebox'; +import {TNumber} from '@sinclair/typebox'; +import {TObject} from '@sinclair/typebox'; +import {TReadonlyOptional} from '@sinclair/typebox'; +import {TString} from '@sinclair/typebox'; + +declare const RawSnapshotFormat: TObject<{ + callToJSON: TReadonlyOptional; + compareKeys: TReadonlyOptional; + escapeRegex: TReadonlyOptional; + escapeString: TReadonlyOptional; + highlight: TReadonlyOptional; + indent: TReadonlyOptional; + maxDepth: TReadonlyOptional; + maxWidth: TReadonlyOptional; + min: TReadonlyOptional; + printBasicPrototype: TReadonlyOptional; + printFunctionName: TReadonlyOptional; + theme: TReadonlyOptional< + TObject<{ + comment: TReadonlyOptional>; + content: TReadonlyOptional>; + prop: TReadonlyOptional>; + tag: TReadonlyOptional>; + value: TReadonlyOptional>; + }> + >; +}>; + +export declare const SnapshotFormat: TObject<{ + callToJSON: TReadonlyOptional; + compareKeys: TReadonlyOptional; + escapeRegex: TReadonlyOptional; + escapeString: TReadonlyOptional; + highlight: TReadonlyOptional; + indent: TReadonlyOptional; + maxDepth: TReadonlyOptional; + maxWidth: TReadonlyOptional; + min: TReadonlyOptional; + printBasicPrototype: TReadonlyOptional; + printFunctionName: TReadonlyOptional; + theme: TReadonlyOptional< + TObject<{ + comment: TReadonlyOptional>; + content: TReadonlyOptional>; + prop: TReadonlyOptional>; + tag: TReadonlyOptional>; + value: TReadonlyOptional>; + }> + >; +}>; + +export declare type SnapshotFormat = Static; + +export {}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/schemas/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/schemas/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..870c184402412e424048671308fb3c486d108ade --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/schemas/build/index.js @@ -0,0 +1,60 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.SnapshotFormat = void 0; +function _typebox() { + const data = require('@sinclair/typebox'); + _typebox = function () { + return data; + }; + return data; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const RawSnapshotFormat = _typebox().Type.Partial( + _typebox().Type.Object({ + callToJSON: _typebox().Type.Readonly(_typebox().Type.Boolean()), + compareKeys: _typebox().Type.Readonly(_typebox().Type.Null()), + escapeRegex: _typebox().Type.Readonly(_typebox().Type.Boolean()), + escapeString: _typebox().Type.Readonly(_typebox().Type.Boolean()), + highlight: _typebox().Type.Readonly(_typebox().Type.Boolean()), + indent: _typebox().Type.Readonly( + _typebox().Type.Number({ + minimum: 0 + }) + ), + maxDepth: _typebox().Type.Readonly( + _typebox().Type.Number({ + minimum: 0 + }) + ), + maxWidth: _typebox().Type.Readonly( + _typebox().Type.Number({ + minimum: 0 + }) + ), + min: _typebox().Type.Readonly(_typebox().Type.Boolean()), + printBasicPrototype: _typebox().Type.Readonly(_typebox().Type.Boolean()), + printFunctionName: _typebox().Type.Readonly(_typebox().Type.Boolean()), + theme: _typebox().Type.Readonly( + _typebox().Type.Partial( + _typebox().Type.Object({ + comment: _typebox().Type.Readonly(_typebox().Type.String()), + content: _typebox().Type.Readonly(_typebox().Type.String()), + prop: _typebox().Type.Readonly(_typebox().Type.String()), + tag: _typebox().Type.Readonly(_typebox().Type.String()), + value: _typebox().Type.Readonly(_typebox().Type.String()) + }) + ) + ) + }) +); +const SnapshotFormat = _typebox().Type.Strict(RawSnapshotFormat); +exports.SnapshotFormat = SnapshotFormat; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/schemas/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/schemas/package.json new file mode 100644 index 0000000000000000000000000000000000000000..db670bfa4466bac909834ca615dab54ed7928050 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/schemas/package.json @@ -0,0 +1,29 @@ +{ + "name": "@jest/schemas", + "version": "29.6.3", + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/jest-schemas" + }, + "license": "MIT", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "dependencies": { + "@sinclair/typebox": "^0.27.8" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "publishConfig": { + "access": "public" + }, + "gitHead": "fb7d95c8af6e0d65a8b65348433d8a0ea0725b5b" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/source-map/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/source-map/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/source-map/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/source-map/build/getCallsite.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/source-map/build/getCallsite.js new file mode 100644 index 0000000000000000000000000000000000000000..48f633aa181a864b3dc8ed722b7e31c12d066164 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/source-map/build/getCallsite.js @@ -0,0 +1,85 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getCallsite; +function _traceMapping() { + const data = require('@jridgewell/trace-mapping'); + _traceMapping = function () { + return data; + }; + return data; +} +function _callsites() { + const data = _interopRequireDefault(require('callsites')); + _callsites = function () { + return data; + }; + return data; +} +function _gracefulFs() { + const data = require('graceful-fs'); + _gracefulFs = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// Copied from https://github.com/rexxars/sourcemap-decorate-callsites/blob/5b9735a156964973a75dc62fd2c7f0c1975458e8/lib/index.js#L113-L158 +const addSourceMapConsumer = (callsite, tracer) => { + const getLineNumber = callsite.getLineNumber.bind(callsite); + const getColumnNumber = callsite.getColumnNumber.bind(callsite); + let position = null; + function getPosition() { + if (!position) { + position = (0, _traceMapping().originalPositionFor)(tracer, { + column: getColumnNumber() ?? -1, + line: getLineNumber() ?? -1 + }); + } + return position; + } + Object.defineProperties(callsite, { + getColumnNumber: { + value() { + const value = getPosition().column; + return value == null || value === 0 ? getColumnNumber() : value; + }, + writable: false + }, + getLineNumber: { + value() { + const value = getPosition().line; + return value == null || value === 0 ? getLineNumber() : value; + }, + writable: false + } + }); +}; +function getCallsite(level, sourceMaps) { + const levelAfterThisCall = level + 1; + const stack = (0, _callsites().default)()[levelAfterThisCall]; + const sourceMapFileName = sourceMaps?.get(stack.getFileName() ?? ''); + if (sourceMapFileName != null && sourceMapFileName !== '') { + try { + const sourceMap = (0, _gracefulFs().readFileSync)( + sourceMapFileName, + 'utf8' + ); + addSourceMapConsumer(stack, new (_traceMapping().TraceMap)(sourceMap)); + } catch { + // ignore + } + } + return stack; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/source-map/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/source-map/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7a421847a6d2542cbdfa6a98853ccdfa007dc5f3 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/source-map/build/index.d.ts @@ -0,0 +1,16 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +import callsites = require('callsites'); + +export declare function getCallsite( + level: number, + sourceMaps?: SourceMapRegistry | null, +): callsites.CallSite; + +export declare type SourceMapRegistry = Map; + +export {}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/source-map/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/source-map/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..c4f4cf9e76dae2114bfe4b5134c09befce12fd03 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/source-map/build/index.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +Object.defineProperty(exports, 'getCallsite', { + enumerable: true, + get: function () { + return _getCallsite.default; + } +}); +var _getCallsite = _interopRequireDefault(require('./getCallsite')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/source-map/build/types.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/source-map/build/types.js new file mode 100644 index 0000000000000000000000000000000000000000..ad9a93a7c160f02945911772460eb8a1bcb003db --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/source-map/build/types.js @@ -0,0 +1 @@ +'use strict'; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/source-map/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/source-map/package.json new file mode 100644 index 0000000000000000000000000000000000000000..1d014d1d517fb9e958bd95ba9220f5487d7e0888 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/source-map/package.json @@ -0,0 +1,34 @@ +{ + "name": "@jest/source-map", + "version": "29.6.3", + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/jest-source-map" + }, + "license": "MIT", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "dependencies": { + "@jridgewell/trace-mapping": "^0.3.18", + "callsites": "^3.0.0", + "graceful-fs": "^4.2.9" + }, + "devDependencies": { + "@types/graceful-fs": "^4.1.3" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "publishConfig": { + "access": "public" + }, + "gitHead": "fb7d95c8af6e0d65a8b65348433d8a0ea0725b5b" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-result/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-result/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-result/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-result/build/formatTestResults.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-result/build/formatTestResults.js new file mode 100644 index 0000000000000000000000000000000000000000..4d7be9b05d4caf556042e902b7bea8d198379185 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-result/build/formatTestResults.js @@ -0,0 +1,69 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = formatTestResults; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const formatTestResult = (testResult, codeCoverageFormatter, reporter) => { + if (testResult.testExecError) { + const now = Date.now(); + return { + assertionResults: testResult.testResults, + coverage: {}, + endTime: now, + message: testResult.failureMessage ?? testResult.testExecError.message, + name: testResult.testFilePath, + startTime: now, + status: 'failed', + summary: '' + }; + } + if (testResult.skipped) { + const now = Date.now(); + return { + assertionResults: testResult.testResults, + coverage: {}, + endTime: now, + message: testResult.failureMessage ?? '', + name: testResult.testFilePath, + startTime: now, + status: 'skipped', + summary: '' + }; + } + const allTestsExecuted = testResult.numPendingTests === 0; + const allTestsPassed = testResult.numFailingTests === 0; + return { + assertionResults: testResult.testResults, + coverage: + codeCoverageFormatter != null + ? codeCoverageFormatter(testResult.coverage, reporter) + : testResult.coverage, + endTime: testResult.perfStats.end, + message: testResult.failureMessage ?? '', + name: testResult.testFilePath, + startTime: testResult.perfStats.start, + status: allTestsPassed + ? allTestsExecuted + ? 'passed' + : 'focused' + : 'failed', + summary: '' + }; +}; +function formatTestResults(results, codeCoverageFormatter, reporter) { + const testResults = results.testResults.map(testResult => + formatTestResult(testResult, codeCoverageFormatter, reporter) + ); + return { + ...results, + testResults + }; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-result/build/helpers.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-result/build/helpers.js new file mode 100644 index 0000000000000000000000000000000000000000..54476392496e855e30f261c26fc14356501f1e25 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-result/build/helpers.js @@ -0,0 +1,175 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.makeEmptyAggregatedTestResult = + exports.createEmptyTestResult = + exports.buildFailureTestResult = + exports.addResult = + void 0; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const makeEmptyAggregatedTestResult = () => ({ + numFailedTestSuites: 0, + numFailedTests: 0, + numPassedTestSuites: 0, + numPassedTests: 0, + numPendingTestSuites: 0, + numPendingTests: 0, + numRuntimeErrorTestSuites: 0, + numTodoTests: 0, + numTotalTestSuites: 0, + numTotalTests: 0, + openHandles: [], + snapshot: { + added: 0, + didUpdate: false, + // is set only after the full run + failure: false, + filesAdded: 0, + // combines individual test results + removed files after the full run + filesRemoved: 0, + filesRemovedList: [], + filesUnmatched: 0, + filesUpdated: 0, + matched: 0, + total: 0, + unchecked: 0, + uncheckedKeysByFile: [], + unmatched: 0, + updated: 0 + }, + startTime: 0, + success: true, + testResults: [], + wasInterrupted: false +}); +exports.makeEmptyAggregatedTestResult = makeEmptyAggregatedTestResult; +const buildFailureTestResult = (testPath, err) => ({ + console: undefined, + displayName: undefined, + failureMessage: null, + leaks: false, + numFailingTests: 0, + numPassingTests: 0, + numPendingTests: 0, + numTodoTests: 0, + openHandles: [], + perfStats: { + end: 0, + runtime: 0, + slow: false, + start: 0 + }, + skipped: false, + snapshot: { + added: 0, + fileDeleted: false, + matched: 0, + unchecked: 0, + uncheckedKeys: [], + unmatched: 0, + updated: 0 + }, + testExecError: err, + testFilePath: testPath, + testResults: [] +}); + +// Add individual test result to an aggregated test result +exports.buildFailureTestResult = buildFailureTestResult; +const addResult = (aggregatedResults, testResult) => { + // `todos` are new as of Jest 24, and not all runners return it. + // Set it to `0` to avoid `NaN` + if (!testResult.numTodoTests) { + testResult.numTodoTests = 0; + } + aggregatedResults.testResults.push(testResult); + aggregatedResults.numTotalTests += + testResult.numPassingTests + + testResult.numFailingTests + + testResult.numPendingTests + + testResult.numTodoTests; + aggregatedResults.numFailedTests += testResult.numFailingTests; + aggregatedResults.numPassedTests += testResult.numPassingTests; + aggregatedResults.numPendingTests += testResult.numPendingTests; + aggregatedResults.numTodoTests += testResult.numTodoTests; + if (testResult.testExecError) { + aggregatedResults.numRuntimeErrorTestSuites++; + } + if (testResult.skipped) { + aggregatedResults.numPendingTestSuites++; + } else if (testResult.numFailingTests > 0 || testResult.testExecError) { + aggregatedResults.numFailedTestSuites++; + } else { + aggregatedResults.numPassedTestSuites++; + } + + // Snapshot data + if (testResult.snapshot.added) { + aggregatedResults.snapshot.filesAdded++; + } + if (testResult.snapshot.fileDeleted) { + aggregatedResults.snapshot.filesRemoved++; + } + if (testResult.snapshot.unmatched) { + aggregatedResults.snapshot.filesUnmatched++; + } + if (testResult.snapshot.updated) { + aggregatedResults.snapshot.filesUpdated++; + } + aggregatedResults.snapshot.added += testResult.snapshot.added; + aggregatedResults.snapshot.matched += testResult.snapshot.matched; + aggregatedResults.snapshot.unchecked += testResult.snapshot.unchecked; + if ( + testResult.snapshot.uncheckedKeys != null && + testResult.snapshot.uncheckedKeys.length > 0 + ) { + aggregatedResults.snapshot.uncheckedKeysByFile.push({ + filePath: testResult.testFilePath, + keys: testResult.snapshot.uncheckedKeys + }); + } + aggregatedResults.snapshot.unmatched += testResult.snapshot.unmatched; + aggregatedResults.snapshot.updated += testResult.snapshot.updated; + aggregatedResults.snapshot.total += + testResult.snapshot.added + + testResult.snapshot.matched + + testResult.snapshot.unmatched + + testResult.snapshot.updated; +}; +exports.addResult = addResult; +const createEmptyTestResult = () => ({ + leaks: false, + // That's legacy code, just adding it as needed for typing + numFailingTests: 0, + numPassingTests: 0, + numPendingTests: 0, + numTodoTests: 0, + openHandles: [], + perfStats: { + end: 0, + runtime: 0, + slow: false, + start: 0 + }, + skipped: false, + snapshot: { + added: 0, + fileDeleted: false, + matched: 0, + unchecked: 0, + uncheckedKeys: [], + unmatched: 0, + updated: 0 + }, + testFilePath: '', + testResults: [] +}); +exports.createEmptyTestResult = createEmptyTestResult; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-result/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-result/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0fc8cc5d38288f50e96c69a58f33bf006574b19d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-result/build/index.d.ts @@ -0,0 +1,232 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +import type {Circus} from '@jest/types'; +import type {Config} from '@jest/types'; +import type {ConsoleBuffer} from '@jest/console'; +import type {CoverageMap} from 'istanbul-lib-coverage'; +import type {CoverageMapData} from 'istanbul-lib-coverage'; +import type {IHasteFS} from 'jest-haste-map'; +import type {IModuleMap} from 'jest-haste-map'; +import type Resolver from 'jest-resolve'; +import type {TestResult as TestResult_2} from '@jest/types'; +import type {TransformTypes} from '@jest/types'; +import type {V8Coverage} from 'collect-v8-coverage'; + +export declare const addResult: ( + aggregatedResults: AggregatedResult, + testResult: TestResult, +) => void; + +export declare type AggregatedResult = AggregatedResultWithoutCoverage & { + coverageMap?: CoverageMap | null; +}; + +declare type AggregatedResultWithoutCoverage = { + numFailedTests: number; + numFailedTestSuites: number; + numPassedTests: number; + numPassedTestSuites: number; + numPendingTests: number; + numTodoTests: number; + numPendingTestSuites: number; + numRuntimeErrorTestSuites: number; + numTotalTests: number; + numTotalTestSuites: number; + openHandles: Array; + snapshot: SnapshotSummary; + startTime: number; + success: boolean; + testResults: Array; + wasInterrupted: boolean; + runExecError?: SerializableError; +}; + +export declare type AssertionLocation = { + fullName: string; + path: string; +}; + +export declare type AssertionResult = TestResult_2.AssertionResult; + +export declare const buildFailureTestResult: ( + testPath: string, + err: SerializableError, +) => TestResult; + +declare type CodeCoverageFormatter = ( + coverage: CoverageMapData | null | undefined, + reporter: CodeCoverageReporter, +) => Record | null | undefined; + +declare type CodeCoverageReporter = unknown; + +export declare const createEmptyTestResult: () => TestResult; + +export declare type FailedAssertion = { + matcherName?: string; + message?: string; + actual?: unknown; + pass?: boolean; + passed?: boolean; + expected?: unknown; + isNot?: boolean; + stack?: string; + error?: unknown; +}; + +declare type FormattedAssertionResult = Pick< + AssertionResult, + 'ancestorTitles' | 'fullName' | 'location' | 'status' | 'title' | 'duration' +> & { + failureMessages: AssertionResult['failureMessages'] | null; +}; + +declare type FormattedTestResult = { + message: string; + name: string; + summary: string; + status: 'failed' | 'passed' | 'skipped' | 'focused'; + startTime: number; + endTime: number; + coverage: unknown; + assertionResults: Array; +}; + +export declare type FormattedTestResults = { + coverageMap?: CoverageMap | null | undefined; + numFailedTests: number; + numFailedTestSuites: number; + numPassedTests: number; + numPassedTestSuites: number; + numPendingTests: number; + numPendingTestSuites: number; + numRuntimeErrorTestSuites: number; + numTotalTests: number; + numTotalTestSuites: number; + snapshot: SnapshotSummary; + startTime: number; + success: boolean; + testResults: Array; + wasInterrupted: boolean; +}; + +export declare function formatTestResults( + results: AggregatedResult, + codeCoverageFormatter?: CodeCoverageFormatter, + reporter?: CodeCoverageReporter, +): FormattedTestResults; + +export declare const makeEmptyAggregatedTestResult: () => AggregatedResult; + +export declare interface RuntimeTransformResult + extends TransformTypes.TransformResult { + wrapperLength: number; +} + +export declare type SerializableError = TestResult_2.SerializableError; + +export declare type SnapshotSummary = { + added: number; + didUpdate: boolean; + failure: boolean; + filesAdded: number; + filesRemoved: number; + filesRemovedList: Array; + filesUnmatched: number; + filesUpdated: number; + matched: number; + total: number; + unchecked: number; + uncheckedKeysByFile: Array; + unmatched: number; + updated: number; +}; + +export declare type Status = AssertionResult['status']; + +export declare type Suite = { + title: string; + suites: Array; + tests: Array; +}; + +export declare type Test = { + context: TestContext; + duration?: number; + path: string; +}; + +export declare type TestCaseResult = AssertionResult; + +export declare type TestContext = { + config: Config.ProjectConfig; + hasteFS: IHasteFS; + moduleMap: IModuleMap; + resolver: Resolver; +}; + +export declare type TestEvents = { + 'test-file-start': [Test]; + 'test-file-success': [Test, TestResult]; + 'test-file-failure': [Test, SerializableError]; + 'test-case-start': [string, Circus.TestCaseStartInfo]; + 'test-case-result': [string, AssertionResult]; +}; + +export declare type TestFileEvent< + T extends keyof TestEvents = keyof TestEvents, +> = (eventName: T, args: TestEvents[T]) => unknown; + +export declare type TestResult = { + console?: ConsoleBuffer; + coverage?: CoverageMapData; + displayName?: Config.DisplayName; + failureMessage?: string | null; + leaks: boolean; + memoryUsage?: number; + numFailingTests: number; + numPassingTests: number; + numPendingTests: number; + numTodoTests: number; + openHandles: Array; + perfStats: { + end: number; + runtime: number; + slow: boolean; + start: number; + }; + skipped: boolean; + snapshot: { + added: number; + fileDeleted: boolean; + matched: number; + unchecked: number; + uncheckedKeys: Array; + unmatched: number; + updated: number; + }; + testExecError?: SerializableError; + testFilePath: string; + testResults: Array; + v8Coverage?: V8CoverageResult; +}; + +export declare type TestResultsProcessor = ( + results: AggregatedResult, +) => AggregatedResult | Promise; + +declare type UncheckedSnapshot = { + filePath: string; + keys: Array; +}; + +export declare type V8CoverageResult = Array<{ + codeTransformResult: RuntimeTransformResult | undefined; + result: V8Coverage[number]; +}>; + +export {}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-result/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-result/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..2f7f67a5f25a5b300e02d933ec79754631312c0a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-result/build/index.js @@ -0,0 +1,40 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +Object.defineProperty(exports, 'addResult', { + enumerable: true, + get: function () { + return _helpers.addResult; + } +}); +Object.defineProperty(exports, 'buildFailureTestResult', { + enumerable: true, + get: function () { + return _helpers.buildFailureTestResult; + } +}); +Object.defineProperty(exports, 'createEmptyTestResult', { + enumerable: true, + get: function () { + return _helpers.createEmptyTestResult; + } +}); +Object.defineProperty(exports, 'formatTestResults', { + enumerable: true, + get: function () { + return _formatTestResults.default; + } +}); +Object.defineProperty(exports, 'makeEmptyAggregatedTestResult', { + enumerable: true, + get: function () { + return _helpers.makeEmptyAggregatedTestResult; + } +}); +var _formatTestResults = _interopRequireDefault(require('./formatTestResults')); +var _helpers = require('./helpers'); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-result/build/types.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-result/build/types.js new file mode 100644 index 0000000000000000000000000000000000000000..ad9a93a7c160f02945911772460eb8a1bcb003db --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-result/build/types.js @@ -0,0 +1 @@ +'use strict'; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-result/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-result/package.json new file mode 100644 index 0000000000000000000000000000000000000000..ee103d1fb24126ec98f1c318dbf41a08fbdaaf5a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-result/package.json @@ -0,0 +1,36 @@ +{ + "name": "@jest/test-result", + "version": "29.7.0", + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/jest-test-result" + }, + "license": "MIT", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "dependencies": { + "@jest/console": "^29.7.0", + "@jest/types": "^29.6.3", + "@types/istanbul-lib-coverage": "^2.0.0", + "collect-v8-coverage": "^1.0.0" + }, + "devDependencies": { + "jest-haste-map": "^29.7.0", + "jest-resolve": "^29.7.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "publishConfig": { + "access": "public" + }, + "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..665265c5cbe9a5a4b3a2303ef2592d878d88e352 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/build/index.d.ts @@ -0,0 +1,91 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +import type {AggregatedResult} from '@jest/test-result'; +import type {Test} from '@jest/test-result'; +import type {TestContext} from '@jest/test-result'; + +declare type Cache_2 = { + [key: string]: + | [testStatus: typeof FAIL | typeof SUCCESS, testDuration: number] + | undefined; +}; + +declare const FAIL = 0; + +export declare type ShardOptions = { + shardIndex: number; + shardCount: number; +}; + +declare const SUCCESS = 1; + +/** + * The TestSequencer will ultimately decide which tests should run first. + * It is responsible for storing and reading from a local cache + * map that stores context information for a given test, such as how long it + * took to run during the last run and if it has failed or not. + * Such information is used on: + * TestSequencer.sort(tests: Array) + * to sort the order of the provided tests. + * + * After the results are collected, + * TestSequencer.cacheResults(tests: Array, results: AggregatedResult) + * is called to store/update this information on the cache map. + */ +declare class TestSequencer { + private readonly _cache; + _getCachePath(testContext: TestContext): string; + _getCache(test: Test): Cache_2; + private _shardPosition; + /** + * Select tests for shard requested via --shard=shardIndex/shardCount + * Sharding is applied before sorting + * + * @param tests All tests + * @param options shardIndex and shardIndex to select + * + * @example + * ```typescript + * class CustomSequencer extends Sequencer { + * shard(tests, { shardIndex, shardCount }) { + * const shardSize = Math.ceil(tests.length / options.shardCount); + * const shardStart = shardSize * (options.shardIndex - 1); + * const shardEnd = shardSize * options.shardIndex; + * return [...tests] + * .sort((a, b) => (a.path > b.path ? 1 : -1)) + * .slice(shardStart, shardEnd); + * } + * } + * ``` + */ + shard( + tests: Array, + options: ShardOptions, + ): Array | Promise>; + /** + * Sort test to determine order of execution + * Sorting is applied after sharding + * @param tests + * + * ```typescript + * class CustomSequencer extends Sequencer { + * sort(tests) { + * const copyTests = Array.from(tests); + * return [...tests].sort((a, b) => (a.path > b.path ? 1 : -1)); + * } + * } + * ``` + */ + sort(tests: Array): Array | Promise>; + allFailedTests(tests: Array): Array | Promise>; + cacheResults(tests: Array, results: AggregatedResult): void; + private hasFailed; + private time; +} +export default TestSequencer; + +export {}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..5da7e3dca6169cc40109afe9c09113b71eb94335 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/build/index.js @@ -0,0 +1,287 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function crypto() { + const data = _interopRequireWildcard(require('crypto')); + crypto = function () { + return data; + }; + return data; +} +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function fs() { + const data = _interopRequireWildcard(require('graceful-fs')); + fs = function () { + return data; + }; + return data; +} +function _slash() { + const data = _interopRequireDefault(require('slash')); + _slash = function () { + return data; + }; + return data; +} +function _jestHasteMap() { + const data = _interopRequireDefault(require('jest-haste-map')); + _jestHasteMap = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const FAIL = 0; +const SUCCESS = 1; +/** + * The TestSequencer will ultimately decide which tests should run first. + * It is responsible for storing and reading from a local cache + * map that stores context information for a given test, such as how long it + * took to run during the last run and if it has failed or not. + * Such information is used on: + * TestSequencer.sort(tests: Array) + * to sort the order of the provided tests. + * + * After the results are collected, + * TestSequencer.cacheResults(tests: Array, results: AggregatedResult) + * is called to store/update this information on the cache map. + */ +class TestSequencer { + _cache = new Map(); + _getCachePath(testContext) { + const {config} = testContext; + const HasteMapClass = _jestHasteMap().default.getStatic(config); + return HasteMapClass.getCacheFilePath( + config.cacheDirectory, + `perf-cache-${config.id}` + ); + } + _getCache(test) { + const {context} = test; + if (!this._cache.has(context) && context.config.cache) { + const cachePath = this._getCachePath(context); + if (fs().existsSync(cachePath)) { + try { + this._cache.set( + context, + JSON.parse(fs().readFileSync(cachePath, 'utf8')) + ); + } catch {} + } + } + let cache = this._cache.get(context); + if (!cache) { + cache = {}; + this._cache.set(context, cache); + } + return cache; + } + _shardPosition(options) { + const shardRest = options.suiteLength % options.shardCount; + const ratio = options.suiteLength / options.shardCount; + return new Array(options.shardIndex) + .fill(true) + .reduce((acc, _, shardIndex) => { + const dangles = shardIndex < shardRest; + const shardSize = dangles ? Math.ceil(ratio) : Math.floor(ratio); + return acc + shardSize; + }, 0); + } + + /** + * Select tests for shard requested via --shard=shardIndex/shardCount + * Sharding is applied before sorting + * + * @param tests All tests + * @param options shardIndex and shardIndex to select + * + * @example + * ```typescript + * class CustomSequencer extends Sequencer { + * shard(tests, { shardIndex, shardCount }) { + * const shardSize = Math.ceil(tests.length / options.shardCount); + * const shardStart = shardSize * (options.shardIndex - 1); + * const shardEnd = shardSize * options.shardIndex; + * return [...tests] + * .sort((a, b) => (a.path > b.path ? 1 : -1)) + * .slice(shardStart, shardEnd); + * } + * } + * ``` + */ + shard(tests, options) { + const shardStart = this._shardPosition({ + shardCount: options.shardCount, + shardIndex: options.shardIndex - 1, + suiteLength: tests.length + }); + const shardEnd = this._shardPosition({ + shardCount: options.shardCount, + shardIndex: options.shardIndex, + suiteLength: tests.length + }); + return tests + .map(test => { + const relativeTestPath = path().posix.relative( + (0, _slash().default)(test.context.config.rootDir), + (0, _slash().default)(test.path) + ); + return { + hash: crypto() + .createHash('sha1') + .update(relativeTestPath) + .digest('hex'), + test + }; + }) + .sort((a, b) => (a.hash < b.hash ? -1 : a.hash > b.hash ? 1 : 0)) + .slice(shardStart, shardEnd) + .map(result => result.test); + } + + /** + * Sort test to determine order of execution + * Sorting is applied after sharding + * @param tests + * + * ```typescript + * class CustomSequencer extends Sequencer { + * sort(tests) { + * const copyTests = Array.from(tests); + * return [...tests].sort((a, b) => (a.path > b.path ? 1 : -1)); + * } + * } + * ``` + */ + sort(tests) { + /** + * Sorting tests is very important because it has a great impact on the + * user-perceived responsiveness and speed of the test run. + * + * If such information is on cache, tests are sorted based on: + * -> Has it failed during the last run ? + * Since it's important to provide the most expected feedback as quickly + * as possible. + * -> How long it took to run ? + * Because running long tests first is an effort to minimize worker idle + * time at the end of a long test run. + * And if that information is not available they are sorted based on file size + * since big test files usually take longer to complete. + * + * Note that a possible improvement would be to analyse other information + * from the file other than its size. + * + */ + const stats = {}; + const fileSize = ({path, context: {hasteFS}}) => + stats[path] || (stats[path] = hasteFS.getSize(path) ?? 0); + tests.forEach(test => { + test.duration = this.time(test); + }); + return tests.sort((testA, testB) => { + const failedA = this.hasFailed(testA); + const failedB = this.hasFailed(testB); + const hasTimeA = testA.duration != null; + if (failedA !== failedB) { + return failedA ? -1 : 1; + } else if (hasTimeA != (testB.duration != null)) { + // If only one of two tests has timing information, run it last + return hasTimeA ? 1 : -1; + } else if (testA.duration != null && testB.duration != null) { + return testA.duration < testB.duration ? 1 : -1; + } else { + return fileSize(testA) < fileSize(testB) ? 1 : -1; + } + }); + } + allFailedTests(tests) { + return this.sort(tests.filter(test => this.hasFailed(test))); + } + cacheResults(tests, results) { + const map = Object.create(null); + tests.forEach(test => (map[test.path] = test)); + results.testResults.forEach(testResult => { + const test = map[testResult.testFilePath]; + if (test != null && !testResult.skipped) { + const cache = this._getCache(test); + const perf = testResult.perfStats; + const testRuntime = + perf.runtime ?? test.duration ?? perf.end - perf.start; + cache[testResult.testFilePath] = [ + testResult.numFailingTests > 0 ? FAIL : SUCCESS, + testRuntime || 0 + ]; + } + }); + this._cache.forEach((cache, context) => + fs().writeFileSync(this._getCachePath(context), JSON.stringify(cache)) + ); + } + hasFailed(test) { + const cache = this._getCache(test); + return cache[test.path]?.[0] === FAIL; + } + time(test) { + const cache = this._getCache(test); + return cache[test.path]?.[1]; + } +} +exports.default = TestSequencer; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/HasteFS.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/HasteFS.js new file mode 100644 index 0000000000000000000000000000000000000000..09384ba521fade5c0719499780ff31edb785a946 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/HasteFS.js @@ -0,0 +1,139 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +var _constants = _interopRequireDefault(require('./constants')); +var fastPath = _interopRequireWildcard(require('./lib/fast_path')); +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class HasteFS { + _rootDir; + _files; + constructor({rootDir, files}) { + this._rootDir = rootDir; + this._files = files; + } + getModuleName(file) { + const fileMetadata = this._getFileData(file); + return (fileMetadata && fileMetadata[_constants.default.ID]) || null; + } + getSize(file) { + const fileMetadata = this._getFileData(file); + return (fileMetadata && fileMetadata[_constants.default.SIZE]) || null; + } + getDependencies(file) { + const fileMetadata = this._getFileData(file); + if (fileMetadata) { + return fileMetadata[_constants.default.DEPENDENCIES] + ? fileMetadata[_constants.default.DEPENDENCIES].split( + _constants.default.DEPENDENCY_DELIM + ) + : []; + } else { + return null; + } + } + getSha1(file) { + const fileMetadata = this._getFileData(file); + return (fileMetadata && fileMetadata[_constants.default.SHA1]) || null; + } + exists(file) { + return this._getFileData(file) != null; + } + getAllFiles() { + return Array.from(this.getAbsoluteFileIterator()); + } + getFileIterator() { + return this._files.keys(); + } + *getAbsoluteFileIterator() { + for (const file of this.getFileIterator()) { + yield fastPath.resolve(this._rootDir, file); + } + } + matchFiles(pattern) { + if (!(pattern instanceof RegExp)) { + pattern = new RegExp(pattern); + } + const files = []; + for (const file of this.getAbsoluteFileIterator()) { + if (pattern.test(file)) { + files.push(file); + } + } + return files; + } + matchFilesWithGlob(globs, root) { + const files = new Set(); + const matcher = (0, _jestUtil().globsToMatcher)(globs); + for (const file of this.getAbsoluteFileIterator()) { + const filePath = root ? fastPath.relative(root, file) : file; + if (matcher((0, _jestUtil().replacePathSepForGlob)(filePath))) { + files.add(file); + } + } + return files; + } + _getFileData(file) { + const relativePath = fastPath.relative(this._rootDir, file); + return this._files.get(relativePath); + } +} +exports.default = HasteFS; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/ModuleMap.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/ModuleMap.js new file mode 100644 index 0000000000000000000000000000000000000000..5ddd1fd8c26289d7702347ecefe986c55c99a6dc --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/ModuleMap.js @@ -0,0 +1,249 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +var _constants = _interopRequireDefault(require('./constants')); +var fastPath = _interopRequireWildcard(require('./lib/fast_path')); +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const EMPTY_OBJ = {}; +const EMPTY_MAP = new Map(); +class ModuleMap { + static DuplicateHasteCandidatesError; + _raw; + json; + static mapToArrayRecursive(map) { + let arr = Array.from(map); + if (arr[0] && arr[0][1] instanceof Map) { + arr = arr.map(el => [el[0], this.mapToArrayRecursive(el[1])]); + } + return arr; + } + static mapFromArrayRecursive(arr) { + if (arr[0] && Array.isArray(arr[1])) { + arr = arr.map(el => [el[0], this.mapFromArrayRecursive(el[1])]); + } + return new Map(arr); + } + constructor(raw) { + this._raw = raw; + } + getModule(name, platform, supportsNativePlatform, type) { + if (type == null) { + type = _constants.default.MODULE; + } + const module = this._getModuleMetadata( + name, + platform, + !!supportsNativePlatform + ); + if (module && module[_constants.default.TYPE] === type) { + const modulePath = module[_constants.default.PATH]; + return modulePath && fastPath.resolve(this._raw.rootDir, modulePath); + } + return null; + } + getPackage(name, platform, _supportsNativePlatform) { + return this.getModule(name, platform, null, _constants.default.PACKAGE); + } + getMockModule(name) { + const mockPath = + this._raw.mocks.get(name) || this._raw.mocks.get(`${name}/index`); + return mockPath && fastPath.resolve(this._raw.rootDir, mockPath); + } + getRawModuleMap() { + return { + duplicates: this._raw.duplicates, + map: this._raw.map, + mocks: this._raw.mocks, + rootDir: this._raw.rootDir + }; + } + toJSON() { + if (!this.json) { + this.json = { + duplicates: ModuleMap.mapToArrayRecursive(this._raw.duplicates), + map: Array.from(this._raw.map), + mocks: Array.from(this._raw.mocks), + rootDir: this._raw.rootDir + }; + } + return this.json; + } + static fromJSON(serializableModuleMap) { + return new ModuleMap({ + duplicates: ModuleMap.mapFromArrayRecursive( + serializableModuleMap.duplicates + ), + map: new Map(serializableModuleMap.map), + mocks: new Map(serializableModuleMap.mocks), + rootDir: serializableModuleMap.rootDir + }); + } + + /** + * When looking up a module's data, we walk through each eligible platform for + * the query. For each platform, we want to check if there are known + * duplicates for that name+platform pair. The duplication logic normally + * removes elements from the `map` object, but we want to check upfront to be + * extra sure. If metadata exists both in the `duplicates` object and the + * `map`, this would be a bug. + */ + _getModuleMetadata(name, platform, supportsNativePlatform) { + const map = this._raw.map.get(name) || EMPTY_OBJ; + const dupMap = this._raw.duplicates.get(name) || EMPTY_MAP; + if (platform != null) { + this._assertNoDuplicates( + name, + platform, + supportsNativePlatform, + dupMap.get(platform) + ); + if (map[platform] != null) { + return map[platform]; + } + } + if (supportsNativePlatform) { + this._assertNoDuplicates( + name, + _constants.default.NATIVE_PLATFORM, + supportsNativePlatform, + dupMap.get(_constants.default.NATIVE_PLATFORM) + ); + if (map[_constants.default.NATIVE_PLATFORM]) { + return map[_constants.default.NATIVE_PLATFORM]; + } + } + this._assertNoDuplicates( + name, + _constants.default.GENERIC_PLATFORM, + supportsNativePlatform, + dupMap.get(_constants.default.GENERIC_PLATFORM) + ); + if (map[_constants.default.GENERIC_PLATFORM]) { + return map[_constants.default.GENERIC_PLATFORM]; + } + return null; + } + _assertNoDuplicates(name, platform, supportsNativePlatform, relativePathSet) { + if (relativePathSet == null) { + return; + } + // Force flow refinement + const previousSet = relativePathSet; + const duplicates = new Map(); + for (const [relativePath, type] of previousSet) { + const duplicatePath = fastPath.resolve(this._raw.rootDir, relativePath); + duplicates.set(duplicatePath, type); + } + throw new DuplicateHasteCandidatesError( + name, + platform, + supportsNativePlatform, + duplicates + ); + } + static create(rootDir) { + return new ModuleMap({ + duplicates: new Map(), + map: new Map(), + mocks: new Map(), + rootDir + }); + } +} +exports.default = ModuleMap; +class DuplicateHasteCandidatesError extends Error { + hasteName; + platform; + supportsNativePlatform; + duplicatesSet; + constructor(name, platform, supportsNativePlatform, duplicatesSet) { + const platformMessage = getPlatformMessage(platform); + super( + `The name \`${name}\` was looked up in the Haste module map. It ` + + 'cannot be resolved, because there exists several different ' + + 'files, or packages, that provide a module for ' + + `that particular name and platform. ${platformMessage} You must ` + + `delete or exclude files until there remains only one of these:\n\n${Array.from( + duplicatesSet + ) + .map( + ([dupFilePath, dupFileType]) => + ` * \`${dupFilePath}\` (${getTypeMessage(dupFileType)})\n` + ) + .sort() + .join('')}` + ); + this.hasteName = name; + this.platform = platform; + this.supportsNativePlatform = supportsNativePlatform; + this.duplicatesSet = duplicatesSet; + } +} +function getPlatformMessage(platform) { + if (platform === _constants.default.GENERIC_PLATFORM) { + return 'The platform is generic (no extension).'; + } + return `The platform extension is \`${platform}\`.`; +} +function getTypeMessage(type) { + switch (type) { + case _constants.default.MODULE: + return 'module'; + case _constants.default.PACKAGE: + return 'package'; + } + return 'unknown'; +} +ModuleMap.DuplicateHasteCandidatesError = DuplicateHasteCandidatesError; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/blacklist.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/blacklist.js new file mode 100644 index 0000000000000000000000000000000000000000..ae90b1a75e09a2b04e9174b0aa3a0afc750f51f6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/blacklist.js @@ -0,0 +1,64 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// This list is compiled after the MDN list of the most common MIME types (see +// https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/ +// Complete_list_of_MIME_types). +// +// Only MIME types starting with "image/", "video/", "audio/" and "font/" are +// reflected in the list. Adding "application/" is too risky since some text +// file formats (like ".js" and ".json") have an "application/" MIME type. +// +// Feel free to add any extensions that cannot be a Haste module. + +const extensions = new Set([ + // JSONs are never haste modules, except for "package.json", which is handled. + '.json', + // Image extensions. + '.bmp', + '.gif', + '.ico', + '.jpeg', + '.jpg', + '.png', + '.svg', + '.tiff', + '.tif', + '.webp', + // Video extensions. + '.avi', + '.mp4', + '.mpeg', + '.mpg', + '.ogv', + '.webm', + '.3gp', + '.3g2', + // Audio extensions. + '.aac', + '.midi', + '.mid', + '.mp3', + '.oga', + '.wav', + '.3gp', + '.3g2', + // Font extensions. + '.eot', + '.otf', + '.ttf', + '.woff', + '.woff2' +]); +var _default = extensions; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/constants.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/constants.js new file mode 100644 index 0000000000000000000000000000000000000000..1b8804ec3e31764202e2805c82eb5d438ca22158 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/constants.js @@ -0,0 +1,46 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +/* + * This file exports a set of constants that are used for Jest's haste map + * serialization. On very large repositories, the haste map cache becomes very + * large to the point where it is the largest overhead in starting up Jest. + * + * This constant key map allows to keep the map smaller without having to build + * a custom serialization library. + */ + +/* eslint-disable sort-keys */ +const constants = { + /* dependency serialization */ + DEPENDENCY_DELIM: '\0', + /* file map attributes */ + ID: 0, + MTIME: 1, + SIZE: 2, + VISITED: 3, + DEPENDENCIES: 4, + SHA1: 5, + /* module map attributes */ + PATH: 0, + TYPE: 1, + /* module types */ + MODULE: 0, + PACKAGE: 1, + /* platforms */ + GENERIC_PLATFORM: 'g', + NATIVE_PLATFORM: 'native' +}; +/* eslint-enable */ +var _default = constants; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/crawlers/node.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/crawlers/node.js new file mode 100644 index 0000000000000000000000000000000000000000..eb90b4e1bce64ab6809d914db9122e1fc8dc151c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/crawlers/node.js @@ -0,0 +1,269 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.nodeCrawl = nodeCrawl; +function _child_process() { + const data = require('child_process'); + _child_process = function () { + return data; + }; + return data; +} +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function fs() { + const data = _interopRequireWildcard(require('graceful-fs')); + fs = function () { + return data; + }; + return data; +} +var _constants = _interopRequireDefault(require('../constants')); +var fastPath = _interopRequireWildcard(require('../lib/fast_path')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +async function hasNativeFindSupport(forceNodeFilesystemAPI) { + if (forceNodeFilesystemAPI) { + return false; + } + try { + return await new Promise(resolve => { + // Check the find binary supports the non-POSIX -iname parameter wrapped in parens. + const args = [ + '.', + '-type', + 'f', + '(', + '-iname', + '*.ts', + '-o', + '-iname', + '*.js', + ')' + ]; + const child = (0, _child_process().spawn)('find', args, { + cwd: __dirname + }); + child.on('error', () => { + resolve(false); + }); + child.on('exit', code => { + resolve(code === 0); + }); + }); + } catch { + return false; + } +} +function find(roots, extensions, ignore, enableSymlinks, callback) { + const result = []; + let activeCalls = 0; + function search(directory) { + activeCalls++; + fs().readdir( + directory, + { + withFileTypes: true + }, + (err, entries) => { + activeCalls--; + if (err) { + if (activeCalls === 0) { + callback(result); + } + return; + } + entries.forEach(entry => { + const file = path().join(directory, entry.name); + if (ignore(file)) { + return; + } + if (entry.isSymbolicLink()) { + return; + } + if (entry.isDirectory()) { + search(file); + return; + } + activeCalls++; + const stat = enableSymlinks ? fs().stat : fs().lstat; + stat(file, (err, stat) => { + activeCalls--; + + // This logic is unnecessary for node > v10.10, but leaving it in + // since we need it for backwards-compatibility still. + if (!err && stat && !stat.isSymbolicLink()) { + if (stat.isDirectory()) { + search(file); + } else { + const ext = path().extname(file).substr(1); + if (extensions.indexOf(ext) !== -1) { + result.push([file, stat.mtime.getTime(), stat.size]); + } + } + } + if (activeCalls === 0) { + callback(result); + } + }); + }); + if (activeCalls === 0) { + callback(result); + } + } + ); + } + if (roots.length > 0) { + roots.forEach(search); + } else { + callback(result); + } +} +function findNative(roots, extensions, ignore, enableSymlinks, callback) { + const args = Array.from(roots); + if (enableSymlinks) { + args.push('(', '-type', 'f', '-o', '-type', 'l', ')'); + } else { + args.push('-type', 'f'); + } + if (extensions.length) { + args.push('('); + } + extensions.forEach((ext, index) => { + if (index) { + args.push('-o'); + } + args.push('-iname'); + args.push(`*.${ext}`); + }); + if (extensions.length) { + args.push(')'); + } + const child = (0, _child_process().spawn)('find', args); + let stdout = ''; + if (child.stdout === null) { + throw new Error( + 'stdout is null - this should never happen. Please open up an issue at https://github.com/jestjs/jest' + ); + } + child.stdout.setEncoding('utf-8'); + child.stdout.on('data', data => (stdout += data)); + child.stdout.on('close', () => { + const lines = stdout + .trim() + .split('\n') + .filter(x => !ignore(x)); + const result = []; + let count = lines.length; + if (!count) { + callback([]); + } else { + lines.forEach(path => { + fs().stat(path, (err, stat) => { + // Filter out symlinks that describe directories + if (!err && stat && !stat.isDirectory()) { + result.push([path, stat.mtime.getTime(), stat.size]); + } + if (--count === 0) { + callback(result); + } + }); + }); + } + }); +} +async function nodeCrawl(options) { + const { + data, + extensions, + forceNodeFilesystemAPI, + ignore, + rootDir, + enableSymlinks, + roots + } = options; + const useNativeFind = await hasNativeFindSupport(forceNodeFilesystemAPI); + return new Promise(resolve => { + const callback = list => { + const files = new Map(); + const removedFiles = new Map(data.files); + list.forEach(fileData => { + const [filePath, mtime, size] = fileData; + const relativeFilePath = fastPath.relative(rootDir, filePath); + const existingFile = data.files.get(relativeFilePath); + if (existingFile && existingFile[_constants.default.MTIME] === mtime) { + files.set(relativeFilePath, existingFile); + } else { + // See ../constants.js; SHA-1 will always be null and fulfilled later. + files.set(relativeFilePath, ['', mtime, size, 0, '', null]); + } + removedFiles.delete(relativeFilePath); + }); + data.files = files; + resolve({ + hasteMap: data, + removedFiles + }); + }; + if (useNativeFind) { + findNative(roots, extensions, ignore, enableSymlinks, callback); + } else { + find(roots, extensions, ignore, enableSymlinks, callback); + } + }); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/crawlers/watchman.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/crawlers/watchman.js new file mode 100644 index 0000000000000000000000000000000000000000..3b2fbfffad80c05dc3b7e8ecf74f1eeef9bacff9 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/crawlers/watchman.js @@ -0,0 +1,339 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.watchmanCrawl = watchmanCrawl; +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _fbWatchman() { + const data = _interopRequireDefault(require('fb-watchman')); + _fbWatchman = function () { + return data; + }; + return data; +} +var _constants = _interopRequireDefault(require('../constants')); +var fastPath = _interopRequireWildcard(require('../lib/fast_path')); +var _normalizePathSep = _interopRequireDefault( + require('../lib/normalizePathSep') +); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const watchmanURL = 'https://facebook.github.io/watchman/docs/troubleshooting'; +function WatchmanError(error) { + error.message = + `Watchman error: ${error.message.trim()}. Make sure watchman ` + + `is running for this project. See ${watchmanURL}.`; + return error; +} + +/** + * Wrap watchman capabilityCheck method as a promise. + * + * @param client watchman client + * @param caps capabilities to verify + * @returns a promise resolving to a list of verified capabilities + */ +async function capabilityCheck(client, caps) { + return new Promise((resolve, reject) => { + client.capabilityCheck( + // @ts-expect-error: incorrectly typed + caps, + (error, response) => { + if (error) { + reject(error); + } else { + resolve(response); + } + } + ); + }); +} +async function watchmanCrawl(options) { + const fields = ['name', 'exists', 'mtime_ms', 'size']; + const {data, extensions, ignore, rootDir, roots} = options; + const defaultWatchExpression = ['allof', ['type', 'f']]; + const clocks = data.clocks; + const client = new (_fbWatchman().default.Client)(); + + // https://facebook.github.io/watchman/docs/capabilities.html + // Check adds about ~28ms + const capabilities = await capabilityCheck(client, { + // If a required capability is missing then an error will be thrown, + // we don't need this assertion, so using optional instead. + optional: ['suffix-set'] + }); + if (capabilities?.capabilities['suffix-set']) { + // If available, use the optimized `suffix-set` operation: + // https://facebook.github.io/watchman/docs/expr/suffix.html#suffix-set + defaultWatchExpression.push(['suffix', extensions]); + } else { + // Otherwise use the older and less optimal suffix tuple array + defaultWatchExpression.push([ + 'anyof', + ...extensions.map(extension => ['suffix', extension]) + ]); + } + let clientError; + client.on('error', error => (clientError = WatchmanError(error))); + const cmd = (...args) => + new Promise((resolve, reject) => + client.command(args, (error, result) => + error ? reject(WatchmanError(error)) : resolve(result) + ) + ); + if (options.computeSha1) { + const {capabilities} = await cmd('list-capabilities'); + if (capabilities.indexOf('field-content.sha1hex') !== -1) { + fields.push('content.sha1hex'); + } + } + async function getWatchmanRoots(roots) { + const watchmanRoots = new Map(); + await Promise.all( + roots.map(async root => { + const response = await cmd('watch-project', root); + const existing = watchmanRoots.get(response.watch); + // A root can only be filtered if it was never seen with a + // relative_path before. + const canBeFiltered = !existing || existing.length > 0; + if (canBeFiltered) { + if (response.relative_path) { + watchmanRoots.set( + response.watch, + (existing || []).concat(response.relative_path) + ); + } else { + // Make the filter directories an empty array to signal that this + // root was already seen and needs to be watched for all files or + // directories. + watchmanRoots.set(response.watch, []); + } + } + }) + ); + return watchmanRoots; + } + async function queryWatchmanForDirs(rootProjectDirMappings) { + const results = new Map(); + let isFresh = false; + await Promise.all( + Array.from(rootProjectDirMappings).map( + async ([root, directoryFilters]) => { + const expression = Array.from(defaultWatchExpression); + const glob = []; + if (directoryFilters.length > 0) { + expression.push([ + 'anyof', + ...directoryFilters.map(dir => ['dirname', dir]) + ]); + for (const directory of directoryFilters) { + for (const extension of extensions) { + glob.push(`${directory}/**/*.${extension}`); + } + } + } else { + for (const extension of extensions) { + glob.push(`**/*.${extension}`); + } + } + + // Jest is only going to store one type of clock; a string that + // represents a local clock. However, the Watchman crawler supports + // a second type of clock that can be written by automation outside of + // Jest, called an "scm query", which fetches changed files based on + // source control mergebases. The reason this is necessary is because + // local clocks are not portable across systems, but scm queries are. + // By using scm queries, we can create the haste map on a different + // system and import it, transforming the clock into a local clock. + const since = clocks.get(fastPath.relative(rootDir, root)); + const query = + since !== undefined + ? // Use the `since` generator if we have a clock available + { + expression, + fields, + since + } + : // Otherwise use the `glob` filter + { + expression, + fields, + glob, + glob_includedotfiles: true + }; + const response = await cmd('query', root, query); + if ('warning' in response) { + console.warn('watchman warning: ', response.warning); + } + + // When a source-control query is used, we ignore the "is fresh" + // response from Watchman because it will be true despite the query + // being incremental. + const isSourceControlQuery = + typeof since !== 'string' && + since?.scm?.['mergebase-with'] !== undefined; + if (!isSourceControlQuery) { + isFresh = isFresh || response.is_fresh_instance; + } + results.set(root, response); + } + ) + ); + return { + isFresh, + results + }; + } + let files = data.files; + let removedFiles = new Map(); + const changedFiles = new Map(); + let results; + let isFresh = false; + try { + const watchmanRoots = await getWatchmanRoots(roots); + const watchmanFileResults = await queryWatchmanForDirs(watchmanRoots); + + // Reset the file map if watchman was restarted and sends us a list of + // files. + if (watchmanFileResults.isFresh) { + files = new Map(); + removedFiles = new Map(data.files); + isFresh = true; + } + results = watchmanFileResults.results; + } finally { + client.end(); + } + if (clientError) { + throw clientError; + } + for (const [watchRoot, response] of results) { + const fsRoot = (0, _normalizePathSep.default)(watchRoot); + const relativeFsRoot = fastPath.relative(rootDir, fsRoot); + clocks.set( + relativeFsRoot, + // Ensure we persist only the local clock. + typeof response.clock === 'string' ? response.clock : response.clock.clock + ); + for (const fileData of response.files) { + const filePath = + fsRoot + path().sep + (0, _normalizePathSep.default)(fileData.name); + const relativeFilePath = fastPath.relative(rootDir, filePath); + const existingFileData = data.files.get(relativeFilePath); + + // If watchman is fresh, the removed files map starts with all files + // and we remove them as we verify they still exist. + if (isFresh && existingFileData && fileData.exists) { + removedFiles.delete(relativeFilePath); + } + if (!fileData.exists) { + // No need to act on files that do not exist and were not tracked. + if (existingFileData) { + files.delete(relativeFilePath); + + // If watchman is not fresh, we will know what specific files were + // deleted since we last ran and can track only those files. + if (!isFresh) { + removedFiles.set(relativeFilePath, existingFileData); + } + } + } else if (!ignore(filePath)) { + const mtime = + typeof fileData.mtime_ms === 'number' + ? fileData.mtime_ms + : fileData.mtime_ms.toNumber(); + const size = fileData.size; + let sha1hex = fileData['content.sha1hex']; + if (typeof sha1hex !== 'string' || sha1hex.length !== 40) { + sha1hex = undefined; + } + let nextData; + if ( + existingFileData && + existingFileData[_constants.default.MTIME] === mtime + ) { + nextData = existingFileData; + } else if ( + existingFileData && + sha1hex && + existingFileData[_constants.default.SHA1] === sha1hex + ) { + nextData = [ + existingFileData[0], + mtime, + existingFileData[2], + existingFileData[3], + existingFileData[4], + existingFileData[5] + ]; + } else { + // See ../constants.ts + nextData = ['', mtime, size, 0, '', sha1hex ?? null]; + } + files.set(relativeFilePath, nextData); + changedFiles.set(relativeFilePath, nextData); + } + } + } + data.files = files; + return { + changedFiles: isFresh ? undefined : changedFiles, + hasteMap: data, + removedFiles + }; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/getMockName.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/getMockName.js new file mode 100644 index 0000000000000000000000000000000000000000..445e0b27c057193ccebdf52d7c6bd877b1c11fb7 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/getMockName.js @@ -0,0 +1,69 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const MOCKS_PATTERN = `${path().sep}__mocks__${path().sep}`; +const getMockName = filePath => { + const mockPath = filePath.split(MOCKS_PATTERN)[1]; + return mockPath + .substring(0, mockPath.lastIndexOf(path().extname(mockPath))) + .replace(/\\/g, '/'); +}; +var _default = getMockName; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a0466fe85c1a1eeb24d85b3014166b7e2881c4e3 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/index.d.ts @@ -0,0 +1,242 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/// + +import type {Config} from '@jest/types'; +import type {Stats} from 'graceful-fs'; + +declare type ChangeEvent = { + eventsQueue: EventsQueue; + hasteFS: HasteFS; + moduleMap: ModuleMap_2; +}; + +export declare class DuplicateError extends Error { + mockPath1: string; + mockPath2: string; + constructor(mockPath1: string, mockPath2: string); +} + +declare class DuplicateHasteCandidatesError extends Error { + hasteName: string; + platform: string | null; + supportsNativePlatform: boolean; + duplicatesSet: DuplicatesSet; + constructor( + name: string, + platform: string, + supportsNativePlatform: boolean, + duplicatesSet: DuplicatesSet, + ); +} + +declare type DuplicatesIndex = Map>; + +declare type DuplicatesSet = Map; + +declare type EventsQueue = Array<{ + filePath: string; + stat: Stats | undefined; + type: string; +}>; + +declare type FileData = Map; + +declare type FileMetaData = [ + id: string, + mtime: number, + size: number, + visited: 0 | 1, + dependencies: string, + sha1: string | null | undefined, +]; + +declare class HasteFS implements IHasteFS { + private readonly _rootDir; + private readonly _files; + constructor({rootDir, files}: {rootDir: string; files: FileData}); + getModuleName(file: string): string | null; + getSize(file: string): number | null; + getDependencies(file: string): Array | null; + getSha1(file: string): string | null; + exists(file: string): boolean; + getAllFiles(): Array; + getFileIterator(): Iterable; + getAbsoluteFileIterator(): Iterable; + matchFiles(pattern: RegExp | string): Array; + matchFilesWithGlob(globs: Array, root: string | null): Set; + private _getFileData; +} + +declare type HasteMapStatic = { + getCacheFilePath( + tmpdir: string, + name: string, + ...extra: Array + ): string; + getModuleMapFromJSON(json: S): IModuleMap; +}; + +declare type HasteRegExp = RegExp | ((str: string) => boolean); + +declare type HType = { + ID: 0; + MTIME: 1; + SIZE: 2; + VISITED: 3; + DEPENDENCIES: 4; + SHA1: 5; + PATH: 0; + TYPE: 1; + MODULE: 0; + PACKAGE: 1; + GENERIC_PLATFORM: 'g'; + NATIVE_PLATFORM: 'native'; + DEPENDENCY_DELIM: '\0'; +}; + +declare type HTypeValue = HType[keyof HType]; + +export declare interface IHasteFS { + exists(path: string): boolean; + getAbsoluteFileIterator(): Iterable; + getAllFiles(): Array; + getDependencies(file: string): Array | null; + getSize(path: string): number | null; + matchFiles(pattern: RegExp | string): Array; + matchFilesWithGlob( + globs: ReadonlyArray, + root: string | null, + ): Set; +} + +export declare interface IHasteMap { + on(eventType: 'change', handler: (event: ChangeEvent) => void): void; + build(): Promise<{ + hasteFS: IHasteFS; + moduleMap: IModuleMap; + }>; +} + +declare type IJestHasteMap = HasteMapStatic & { + create(options: Options): Promise; + getStatic(config: Config.ProjectConfig): HasteMapStatic; +}; + +export declare interface IModuleMap { + getModule( + name: string, + platform?: string | null, + supportsNativePlatform?: boolean | null, + type?: HTypeValue | null, + ): string | null; + getPackage( + name: string, + platform: string | null | undefined, + _supportsNativePlatform: boolean | null, + ): string | null; + getMockModule(name: string): string | undefined; + getRawModuleMap(): RawModuleMap; + toJSON(): S; +} + +declare const JestHasteMap: IJestHasteMap; +export default JestHasteMap; + +declare type MockData = Map; + +export declare const ModuleMap: { + create: (rootPath: string) => IModuleMap; +}; + +declare class ModuleMap_2 implements IModuleMap { + static DuplicateHasteCandidatesError: typeof DuplicateHasteCandidatesError; + private readonly _raw; + private json; + private static mapToArrayRecursive; + private static mapFromArrayRecursive; + constructor(raw: RawModuleMap); + getModule( + name: string, + platform?: string | null, + supportsNativePlatform?: boolean | null, + type?: HTypeValue | null, + ): string | null; + getPackage( + name: string, + platform: string | null | undefined, + _supportsNativePlatform: boolean | null, + ): string | null; + getMockModule(name: string): string | undefined; + getRawModuleMap(): RawModuleMap; + toJSON(): SerializableModuleMap; + static fromJSON(serializableModuleMap: SerializableModuleMap): ModuleMap_2; + /** + * When looking up a module's data, we walk through each eligible platform for + * the query. For each platform, we want to check if there are known + * duplicates for that name+platform pair. The duplication logic normally + * removes elements from the `map` object, but we want to check upfront to be + * extra sure. If metadata exists both in the `duplicates` object and the + * `map`, this would be a bug. + */ + private _getModuleMetadata; + private _assertNoDuplicates; + static create(rootDir: string): ModuleMap_2; +} + +declare type ModuleMapData = Map; + +declare type ModuleMapItem = { + [platform: string]: ModuleMetaData; +}; + +declare type ModuleMetaData = [path: string, type: number]; + +declare type Options = { + cacheDirectory?: string; + computeDependencies?: boolean; + computeSha1?: boolean; + console?: Console; + dependencyExtractor?: string | null; + enableSymlinks?: boolean; + extensions: Array; + forceNodeFilesystemAPI?: boolean; + hasteImplModulePath?: string; + hasteMapModulePath?: string; + id: string; + ignorePattern?: HasteRegExp; + maxWorkers: number; + mocksPattern?: string; + platforms: Array; + resetCache?: boolean; + retainAllFiles: boolean; + rootDir: string; + roots: Array; + skipPackageJson?: boolean; + throwOnModuleCollision?: boolean; + useWatchman?: boolean; + watch?: boolean; + workerThreads?: boolean; +}; + +declare type RawModuleMap = { + rootDir: string; + duplicates: DuplicatesIndex; + map: ModuleMapData; + mocks: MockData; +}; + +export declare type SerializableModuleMap = { + duplicates: ReadonlyArray<[string, [string, [string, [string, number]]]]>; + map: ReadonlyArray<[string, ValueType]>; + mocks: ReadonlyArray<[string, ValueType]>; + rootDir: string; +}; + +declare type ValueType = T extends Map ? V : never; + +export {}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..d8a3b5eca24acbbc2bb4d4adeede73fac8d01bda --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/index.js @@ -0,0 +1,1107 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = exports.ModuleMap = exports.DuplicateError = void 0; +function _crypto() { + const data = require('crypto'); + _crypto = function () { + return data; + }; + return data; +} +function _events() { + const data = require('events'); + _events = function () { + return data; + }; + return data; +} +function _os() { + const data = require('os'); + _os = function () { + return data; + }; + return data; +} +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _v() { + const data = require('v8'); + _v = function () { + return data; + }; + return data; +} +function _gracefulFs() { + const data = require('graceful-fs'); + _gracefulFs = function () { + return data; + }; + return data; +} +function _jestRegexUtil() { + const data = require('jest-regex-util'); + _jestRegexUtil = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +function _jestWorker() { + const data = require('jest-worker'); + _jestWorker = function () { + return data; + }; + return data; +} +var _HasteFS = _interopRequireDefault(require('./HasteFS')); +var _ModuleMap = _interopRequireDefault(require('./ModuleMap')); +var _constants = _interopRequireDefault(require('./constants')); +var _node = require('./crawlers/node'); +var _watchman = require('./crawlers/watchman'); +var _getMockName = _interopRequireDefault(require('./getMockName')); +var fastPath = _interopRequireWildcard(require('./lib/fast_path')); +var _getPlatformExtension = _interopRequireDefault( + require('./lib/getPlatformExtension') +); +var _isWatchmanInstalled = _interopRequireDefault( + require('./lib/isWatchmanInstalled') +); +var _normalizePathSep = _interopRequireDefault( + require('./lib/normalizePathSep') +); +var _FSEventsWatcher = require('./watchers/FSEventsWatcher'); +var _NodeWatcher = _interopRequireDefault(require('./watchers/NodeWatcher')); +var _WatchmanWatcher = _interopRequireDefault( + require('./watchers/WatchmanWatcher') +); +var _worker = require('./worker'); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// @ts-expect-error: not converted to TypeScript - it's a fork: https://github.com/jestjs/jest/pull/10919 + +// @ts-expect-error: not converted to TypeScript - it's a fork: https://github.com/jestjs/jest/pull/5387 + +// TypeScript doesn't like us importing from outside `rootDir`, but it doesn't +// understand `require`. +const {version: VERSION} = require('../package.json'); +const ModuleMap = _ModuleMap.default; +exports.ModuleMap = ModuleMap; +const CHANGE_INTERVAL = 30; +const MAX_WAIT_TIME = 240000; +const NODE_MODULES = `${path().sep}node_modules${path().sep}`; +const PACKAGE_JSON = `${path().sep}package.json`; +const VCS_DIRECTORIES = ['.git', '.hg', '.sl'] + .map(vcs => + (0, _jestRegexUtil().escapePathForRegex)(path().sep + vcs + path().sep) + ) + .join('|'); + +/** + * HasteMap is a JavaScript implementation of Facebook's haste module system. + * + * This implementation is inspired by https://github.com/facebook/node-haste + * and was built with for high-performance in large code repositories with + * hundreds of thousands of files. This implementation is scalable and provides + * predictable performance. + * + * Because the haste map creation and synchronization is critical to startup + * performance and most tasks are blocked by I/O this class makes heavy use of + * synchronous operations. It uses worker processes for parallelizing file + * access and metadata extraction. + * + * The data structures created by `jest-haste-map` can be used directly from the + * cache without further processing. The metadata objects in the `files` and + * `map` objects contain cross-references: a metadata object from one can look + * up the corresponding metadata object in the other map. Note that in most + * projects, the number of files will be greater than the number of haste + * modules one module can refer to many files based on platform extensions. + * + * type HasteMap = { + * clocks: WatchmanClocks, + * files: {[filepath: string]: FileMetaData}, + * map: {[id: string]: ModuleMapItem}, + * mocks: {[id: string]: string}, + * } + * + * // Watchman clocks are used for query synchronization and file system deltas. + * type WatchmanClocks = {[filepath: string]: string}; + * + * type FileMetaData = { + * id: ?string, // used to look up module metadata objects in `map`. + * mtime: number, // check for outdated files. + * size: number, // size of the file in bytes. + * visited: boolean, // whether the file has been parsed or not. + * dependencies: Array, // all relative dependencies of this file. + * sha1: ?string, // SHA-1 of the file, if requested via options. + * }; + * + * // Modules can be targeted to a specific platform based on the file name. + * // Example: platform.ios.js and Platform.android.js will both map to the same + * // `Platform` module. The platform should be specified during resolution. + * type ModuleMapItem = {[platform: string]: ModuleMetaData}; + * + * // + * type ModuleMetaData = { + * path: string, // the path to look up the file object in `files`. + * type: string, // the module type (either `package` or `module`). + * }; + * + * Note that the data structures described above are conceptual only. The actual + * implementation uses arrays and constant keys for metadata storage. Instead of + * `{id: 'flatMap', mtime: 3421, size: 42, visited: true, dependencies: []}` the real + * representation is similar to `['flatMap', 3421, 42, 1, []]` to save storage space + * and reduce parse and write time of a big JSON blob. + * + * The HasteMap is created as follows: + * 1. read data from the cache or create an empty structure. + * + * 2. crawl the file system. + * * empty cache: crawl the entire file system. + * * cache available: + * * if watchman is available: get file system delta changes. + * * if watchman is unavailable: crawl the entire file system. + * * build metadata objects for every file. This builds the `files` part of + * the `HasteMap`. + * + * 3. parse and extract metadata from changed files. + * * this is done in parallel over worker processes to improve performance. + * * the worst case is to parse all files. + * * the best case is no file system access and retrieving all data from + * the cache. + * * the average case is a small number of changed files. + * + * 4. serialize the new `HasteMap` in a cache file. + * Worker processes can directly access the cache through `HasteMap.read()`. + * + */ +class HasteMap extends _events().EventEmitter { + _buildPromise = null; + _cachePath = ''; + _changeInterval; + _console; + _isWatchmanInstalledPromise = null; + _options; + _watchers = []; + _worker = null; + static getStatic(config) { + if (config.haste.hasteMapModulePath) { + return require(config.haste.hasteMapModulePath); + } + return HasteMap; + } + static async create(options) { + if (options.hasteMapModulePath) { + const CustomHasteMap = require(options.hasteMapModulePath); + return new CustomHasteMap(options); + } + const hasteMap = new HasteMap(options); + await hasteMap.setupCachePath(options); + return hasteMap; + } + constructor(options) { + super(); + this._options = { + cacheDirectory: options.cacheDirectory || (0, _os().tmpdir)(), + computeDependencies: options.computeDependencies ?? true, + computeSha1: options.computeSha1 || false, + dependencyExtractor: options.dependencyExtractor || null, + enableSymlinks: options.enableSymlinks || false, + extensions: options.extensions, + forceNodeFilesystemAPI: !!options.forceNodeFilesystemAPI, + hasteImplModulePath: options.hasteImplModulePath, + id: options.id, + maxWorkers: options.maxWorkers, + mocksPattern: options.mocksPattern + ? new RegExp(options.mocksPattern) + : null, + platforms: options.platforms, + resetCache: options.resetCache, + retainAllFiles: options.retainAllFiles, + rootDir: options.rootDir, + roots: Array.from(new Set(options.roots)), + skipPackageJson: !!options.skipPackageJson, + throwOnModuleCollision: !!options.throwOnModuleCollision, + useWatchman: options.useWatchman ?? true, + watch: !!options.watch, + workerThreads: options.workerThreads + }; + this._console = options.console || globalThis.console; + if (options.ignorePattern) { + if (options.ignorePattern instanceof RegExp) { + this._options.ignorePattern = new RegExp( + options.ignorePattern.source.concat(`|${VCS_DIRECTORIES}`), + options.ignorePattern.flags + ); + } else { + throw new Error( + 'jest-haste-map: the `ignorePattern` option must be a RegExp' + ); + } + } else { + this._options.ignorePattern = new RegExp(VCS_DIRECTORIES); + } + if (this._options.enableSymlinks && this._options.useWatchman) { + throw new Error( + 'jest-haste-map: enableSymlinks config option was set, but ' + + 'is incompatible with watchman.\n' + + 'Set either `enableSymlinks` to false or `useWatchman` to false.' + ); + } + } + async setupCachePath(options) { + const rootDirHash = (0, _crypto().createHash)('sha1') + .update(options.rootDir) + .digest('hex') + .substring(0, 32); + let hasteImplHash = ''; + let dependencyExtractorHash = ''; + if (options.hasteImplModulePath) { + const hasteImpl = require(options.hasteImplModulePath); + if (hasteImpl.getCacheKey) { + hasteImplHash = String(hasteImpl.getCacheKey()); + } + } + if (options.dependencyExtractor) { + const dependencyExtractor = await (0, _jestUtil().requireOrImportModule)( + options.dependencyExtractor, + false + ); + if (dependencyExtractor.getCacheKey) { + dependencyExtractorHash = String(dependencyExtractor.getCacheKey()); + } + } + this._cachePath = HasteMap.getCacheFilePath( + this._options.cacheDirectory, + `haste-map-${this._options.id}-${rootDirHash}`, + VERSION, + this._options.id, + this._options.roots + .map(root => fastPath.relative(options.rootDir, root)) + .join(':'), + this._options.extensions.join(':'), + this._options.platforms.join(':'), + this._options.computeSha1.toString(), + options.mocksPattern || '', + (options.ignorePattern || '').toString(), + hasteImplHash, + dependencyExtractorHash, + this._options.computeDependencies.toString() + ); + } + static getCacheFilePath(tmpdir, id, ...extra) { + const hash = (0, _crypto().createHash)('sha1').update(extra.join('')); + return path().join( + tmpdir, + `${id.replace(/\W/g, '-')}-${hash.digest('hex').substring(0, 32)}` + ); + } + static getModuleMapFromJSON(json) { + return _ModuleMap.default.fromJSON(json); + } + getCacheFilePath() { + return this._cachePath; + } + build() { + if (!this._buildPromise) { + this._buildPromise = (async () => { + const data = await this._buildFileMap(); + + // Persist when we don't know if files changed (changedFiles undefined) + // or when we know a file was changed or deleted. + let hasteMap; + if ( + data.changedFiles === undefined || + data.changedFiles.size > 0 || + data.removedFiles.size > 0 + ) { + hasteMap = await this._buildHasteMap(data); + this._persist(hasteMap); + } else { + hasteMap = data.hasteMap; + } + const rootDir = this._options.rootDir; + const hasteFS = new _HasteFS.default({ + files: hasteMap.files, + rootDir + }); + const moduleMap = new _ModuleMap.default({ + duplicates: hasteMap.duplicates, + map: hasteMap.map, + mocks: hasteMap.mocks, + rootDir + }); + const __hasteMapForTest = + (process.env.NODE_ENV === 'test' && hasteMap) || null; + await this._watch(hasteMap); + return { + __hasteMapForTest, + hasteFS, + moduleMap + }; + })(); + } + return this._buildPromise; + } + + /** + * 1. read data from the cache or create an empty structure. + */ + read() { + let hasteMap; + try { + hasteMap = (0, _v().deserialize)( + (0, _gracefulFs().readFileSync)(this._cachePath) + ); + } catch { + hasteMap = this._createEmptyMap(); + } + return hasteMap; + } + readModuleMap() { + const data = this.read(); + return new _ModuleMap.default({ + duplicates: data.duplicates, + map: data.map, + mocks: data.mocks, + rootDir: this._options.rootDir + }); + } + + /** + * 2. crawl the file system. + */ + async _buildFileMap() { + let hasteMap; + try { + const read = this._options.resetCache ? this._createEmptyMap : this.read; + hasteMap = read.call(this); + } catch { + hasteMap = this._createEmptyMap(); + } + return this._crawl(hasteMap); + } + + /** + * 3. parse and extract metadata from changed files. + */ + _processFile(hasteMap, map, mocks, filePath, workerOptions) { + const rootDir = this._options.rootDir; + const setModule = (id, module) => { + let moduleMap = map.get(id); + if (!moduleMap) { + moduleMap = Object.create(null); + map.set(id, moduleMap); + } + const platform = + (0, _getPlatformExtension.default)( + module[_constants.default.PATH], + this._options.platforms + ) || _constants.default.GENERIC_PLATFORM; + const existingModule = moduleMap[platform]; + if ( + existingModule && + existingModule[_constants.default.PATH] !== + module[_constants.default.PATH] + ) { + const method = this._options.throwOnModuleCollision ? 'error' : 'warn'; + this._console[method]( + [ + `jest-haste-map: Haste module naming collision: ${id}`, + ' The following files share their name; please adjust your hasteImpl:', + ` * ${path().sep}${ + existingModule[_constants.default.PATH] + }`, + ` * ${path().sep}${module[_constants.default.PATH]}`, + '' + ].join('\n') + ); + if (this._options.throwOnModuleCollision) { + throw new DuplicateError( + existingModule[_constants.default.PATH], + module[_constants.default.PATH] + ); + } + + // We do NOT want consumers to use a module that is ambiguous. + delete moduleMap[platform]; + if (Object.keys(moduleMap).length === 1) { + map.delete(id); + } + let dupsByPlatform = hasteMap.duplicates.get(id); + if (dupsByPlatform == null) { + dupsByPlatform = new Map(); + hasteMap.duplicates.set(id, dupsByPlatform); + } + const dups = new Map([ + [module[_constants.default.PATH], module[_constants.default.TYPE]], + [ + existingModule[_constants.default.PATH], + existingModule[_constants.default.TYPE] + ] + ]); + dupsByPlatform.set(platform, dups); + return; + } + const dupsByPlatform = hasteMap.duplicates.get(id); + if (dupsByPlatform != null) { + const dups = dupsByPlatform.get(platform); + if (dups != null) { + dups.set( + module[_constants.default.PATH], + module[_constants.default.TYPE] + ); + } + return; + } + moduleMap[platform] = module; + }; + const relativeFilePath = fastPath.relative(rootDir, filePath); + const fileMetadata = hasteMap.files.get(relativeFilePath); + if (!fileMetadata) { + throw new Error( + 'jest-haste-map: File to process was not found in the haste map.' + ); + } + const moduleMetadata = hasteMap.map.get( + fileMetadata[_constants.default.ID] + ); + const computeSha1 = + this._options.computeSha1 && !fileMetadata[_constants.default.SHA1]; + + // Callback called when the response from the worker is successful. + const workerReply = metadata => { + // `1` for truthy values instead of `true` to save cache space. + fileMetadata[_constants.default.VISITED] = 1; + const metadataId = metadata.id; + const metadataModule = metadata.module; + if (metadataId && metadataModule) { + fileMetadata[_constants.default.ID] = metadataId; + setModule(metadataId, metadataModule); + } + fileMetadata[_constants.default.DEPENDENCIES] = metadata.dependencies + ? metadata.dependencies.join(_constants.default.DEPENDENCY_DELIM) + : ''; + if (computeSha1) { + fileMetadata[_constants.default.SHA1] = metadata.sha1; + } + }; + + // Callback called when the response from the worker is an error. + const workerError = error => { + if (typeof error !== 'object' || !error.message || !error.stack) { + error = new Error(error); + error.stack = ''; // Remove stack for stack-less errors. + } + + if (!['ENOENT', 'EACCES'].includes(error.code)) { + throw error; + } + + // If a file cannot be read we remove it from the file list and + // ignore the failure silently. + hasteMap.files.delete(relativeFilePath); + }; + + // If we retain all files in the virtual HasteFS representation, we avoid + // reading them if they aren't important (node_modules). + if (this._options.retainAllFiles && filePath.includes(NODE_MODULES)) { + if (computeSha1) { + return this._getWorker(workerOptions) + .getSha1({ + computeDependencies: this._options.computeDependencies, + computeSha1, + dependencyExtractor: this._options.dependencyExtractor, + filePath, + hasteImplModulePath: this._options.hasteImplModulePath, + rootDir + }) + .then(workerReply, workerError); + } + return null; + } + if ( + this._options.mocksPattern && + this._options.mocksPattern.test(filePath) + ) { + const mockPath = (0, _getMockName.default)(filePath); + const existingMockPath = mocks.get(mockPath); + if (existingMockPath) { + const secondMockPath = fastPath.relative(rootDir, filePath); + if (existingMockPath !== secondMockPath) { + const method = this._options.throwOnModuleCollision + ? 'error' + : 'warn'; + this._console[method]( + [ + `jest-haste-map: duplicate manual mock found: ${mockPath}`, + ' The following files share their name; please delete one of them:', + ` * ${path().sep}${existingMockPath}`, + ` * ${path().sep}${secondMockPath}`, + '' + ].join('\n') + ); + if (this._options.throwOnModuleCollision) { + throw new DuplicateError(existingMockPath, secondMockPath); + } + } + } + mocks.set(mockPath, relativeFilePath); + } + if (fileMetadata[_constants.default.VISITED]) { + if (!fileMetadata[_constants.default.ID]) { + return null; + } + if (moduleMetadata != null) { + const platform = + (0, _getPlatformExtension.default)( + filePath, + this._options.platforms + ) || _constants.default.GENERIC_PLATFORM; + const module = moduleMetadata[platform]; + if (module == null) { + return null; + } + const moduleId = fileMetadata[_constants.default.ID]; + let modulesByPlatform = map.get(moduleId); + if (!modulesByPlatform) { + modulesByPlatform = Object.create(null); + map.set(moduleId, modulesByPlatform); + } + modulesByPlatform[platform] = module; + return null; + } + } + return this._getWorker(workerOptions) + .worker({ + computeDependencies: this._options.computeDependencies, + computeSha1, + dependencyExtractor: this._options.dependencyExtractor, + filePath, + hasteImplModulePath: this._options.hasteImplModulePath, + rootDir + }) + .then(workerReply, workerError); + } + _buildHasteMap(data) { + const {removedFiles, changedFiles, hasteMap} = data; + + // If any files were removed or we did not track what files changed, process + // every file looking for changes. Otherwise, process only changed files. + let map; + let mocks; + let filesToProcess; + if (changedFiles === undefined || removedFiles.size) { + map = new Map(); + mocks = new Map(); + filesToProcess = hasteMap.files; + } else { + map = hasteMap.map; + mocks = hasteMap.mocks; + filesToProcess = changedFiles; + } + for (const [relativeFilePath, fileMetadata] of removedFiles) { + this._recoverDuplicates( + hasteMap, + relativeFilePath, + fileMetadata[_constants.default.ID] + ); + } + const promises = []; + for (const relativeFilePath of filesToProcess.keys()) { + if ( + this._options.skipPackageJson && + relativeFilePath.endsWith(PACKAGE_JSON) + ) { + continue; + } + // SHA-1, if requested, should already be present thanks to the crawler. + const filePath = fastPath.resolve( + this._options.rootDir, + relativeFilePath + ); + const promise = this._processFile(hasteMap, map, mocks, filePath); + if (promise) { + promises.push(promise); + } + } + return Promise.all(promises).then( + () => { + this._cleanup(); + hasteMap.map = map; + hasteMap.mocks = mocks; + return hasteMap; + }, + error => { + this._cleanup(); + throw error; + } + ); + } + _cleanup() { + const worker = this._worker; + if (worker && 'end' in worker) { + worker.end(); + } + this._worker = null; + } + + /** + * 4. serialize the new `HasteMap` in a cache file. + */ + _persist(hasteMap) { + (0, _gracefulFs().writeFileSync)( + this._cachePath, + (0, _v().serialize)(hasteMap) + ); + } + + /** + * Creates workers or parses files and extracts metadata in-process. + */ + _getWorker( + options = { + forceInBand: false + } + ) { + if (!this._worker) { + if (options.forceInBand || this._options.maxWorkers <= 1) { + this._worker = { + getSha1: _worker.getSha1, + worker: _worker.worker + }; + } else { + this._worker = new (_jestWorker().Worker)(require.resolve('./worker'), { + enableWorkerThreads: this._options.workerThreads, + exposedMethods: ['getSha1', 'worker'], + forkOptions: { + serialization: 'json' + }, + maxRetries: 3, + numWorkers: this._options.maxWorkers + }); + } + } + return this._worker; + } + async _crawl(hasteMap) { + const options = this._options; + const ignore = this._ignore.bind(this); + const crawl = (await this._shouldUseWatchman()) + ? _watchman.watchmanCrawl + : _node.nodeCrawl; + const crawlerOptions = { + computeSha1: options.computeSha1, + data: hasteMap, + enableSymlinks: options.enableSymlinks, + extensions: options.extensions, + forceNodeFilesystemAPI: options.forceNodeFilesystemAPI, + ignore, + rootDir: options.rootDir, + roots: options.roots + }; + const retry = error => { + if (crawl === _watchman.watchmanCrawl) { + this._console.warn( + 'jest-haste-map: Watchman crawl failed. Retrying once with node ' + + 'crawler.\n' + + " Usually this happens when watchman isn't running. Create an " + + "empty `.watchmanconfig` file in your project's root folder or " + + 'initialize a git or hg repository in your project.\n' + + ` ${error}` + ); + return (0, _node.nodeCrawl)(crawlerOptions).catch(e => { + throw new Error( + 'Crawler retry failed:\n' + + ` Original error: ${error.message}\n` + + ` Retry error: ${e.message}\n` + ); + }); + } + throw error; + }; + try { + return await crawl(crawlerOptions); + } catch (error) { + return retry(error); + } + } + + /** + * Watch mode + */ + async _watch(hasteMap) { + if (!this._options.watch) { + return Promise.resolve(); + } + + // In watch mode, we'll only warn about module collisions and we'll retain + // all files, even changes to node_modules. + this._options.throwOnModuleCollision = false; + this._options.retainAllFiles = true; + + // WatchmanWatcher > FSEventsWatcher > sane.NodeWatcher + const Watcher = (await this._shouldUseWatchman()) + ? _WatchmanWatcher.default + : _FSEventsWatcher.FSEventsWatcher.isSupported() + ? _FSEventsWatcher.FSEventsWatcher + : _NodeWatcher.default; + const extensions = this._options.extensions; + const ignorePattern = this._options.ignorePattern; + const rootDir = this._options.rootDir; + let changeQueue = Promise.resolve(); + let eventsQueue = []; + // We only need to copy the entire haste map once on every "frame". + let mustCopy = true; + const createWatcher = root => { + const watcher = new Watcher(root, { + dot: true, + glob: extensions.map(extension => `**/*.${extension}`), + ignored: ignorePattern + }); + return new Promise((resolve, reject) => { + const rejectTimeout = setTimeout( + () => reject(new Error('Failed to start watch mode.')), + MAX_WAIT_TIME + ); + watcher.once('ready', () => { + clearTimeout(rejectTimeout); + watcher.on('all', onChange); + resolve(watcher); + }); + }); + }; + const emitChange = () => { + if (eventsQueue.length) { + mustCopy = true; + const changeEvent = { + eventsQueue, + hasteFS: new _HasteFS.default({ + files: hasteMap.files, + rootDir + }), + moduleMap: new _ModuleMap.default({ + duplicates: hasteMap.duplicates, + map: hasteMap.map, + mocks: hasteMap.mocks, + rootDir + }) + }; + this.emit('change', changeEvent); + eventsQueue = []; + } + }; + const onChange = (type, filePath, root, stat) => { + filePath = path().join(root, (0, _normalizePathSep.default)(filePath)); + if ( + (stat && stat.isDirectory()) || + this._ignore(filePath) || + !extensions.some(extension => filePath.endsWith(extension)) + ) { + return; + } + const relativeFilePath = fastPath.relative(rootDir, filePath); + const fileMetadata = hasteMap.files.get(relativeFilePath); + + // The file has been accessed, not modified + if ( + type === 'change' && + fileMetadata && + stat && + fileMetadata[_constants.default.MTIME] === stat.mtime.getTime() + ) { + return; + } + changeQueue = changeQueue + .then(() => { + // If we get duplicate events for the same file, ignore them. + if ( + eventsQueue.find( + event => + event.type === type && + event.filePath === filePath && + ((!event.stat && !stat) || + (!!event.stat && + !!stat && + event.stat.mtime.getTime() === stat.mtime.getTime())) + ) + ) { + return null; + } + if (mustCopy) { + mustCopy = false; + hasteMap = { + clocks: new Map(hasteMap.clocks), + duplicates: new Map(hasteMap.duplicates), + files: new Map(hasteMap.files), + map: new Map(hasteMap.map), + mocks: new Map(hasteMap.mocks) + }; + } + const add = () => { + eventsQueue.push({ + filePath, + stat, + type + }); + return null; + }; + const fileMetadata = hasteMap.files.get(relativeFilePath); + + // If it's not an addition, delete the file and all its metadata + if (fileMetadata != null) { + const moduleName = fileMetadata[_constants.default.ID]; + const platform = + (0, _getPlatformExtension.default)( + filePath, + this._options.platforms + ) || _constants.default.GENERIC_PLATFORM; + hasteMap.files.delete(relativeFilePath); + let moduleMap = hasteMap.map.get(moduleName); + if (moduleMap != null) { + // We are forced to copy the object because jest-haste-map exposes + // the map as an immutable entity. + moduleMap = copy(moduleMap); + delete moduleMap[platform]; + if (Object.keys(moduleMap).length === 0) { + hasteMap.map.delete(moduleName); + } else { + hasteMap.map.set(moduleName, moduleMap); + } + } + if ( + this._options.mocksPattern && + this._options.mocksPattern.test(filePath) + ) { + const mockName = (0, _getMockName.default)(filePath); + hasteMap.mocks.delete(mockName); + } + this._recoverDuplicates(hasteMap, relativeFilePath, moduleName); + } + + // If the file was added or changed, + // parse it and update the haste map. + if (type === 'add' || type === 'change') { + (0, _jestUtil().invariant)( + stat, + 'since the file exists or changed, it should have stats' + ); + const fileMetadata = [ + '', + stat.mtime.getTime(), + stat.size, + 0, + '', + null + ]; + hasteMap.files.set(relativeFilePath, fileMetadata); + const promise = this._processFile( + hasteMap, + hasteMap.map, + hasteMap.mocks, + filePath, + { + forceInBand: true + } + ); + // Cleanup + this._cleanup(); + if (promise) { + return promise.then(add); + } else { + // If a file in node_modules has changed, + // emit an event regardless. + add(); + } + } else { + add(); + } + return null; + }) + .catch(error => { + this._console.error( + `jest-haste-map: watch error:\n ${error.stack}\n` + ); + }); + }; + this._changeInterval = setInterval(emitChange, CHANGE_INTERVAL); + return Promise.all(this._options.roots.map(createWatcher)).then( + watchers => { + this._watchers = watchers; + } + ); + } + + /** + * This function should be called when the file under `filePath` is removed + * or changed. When that happens, we want to figure out if that file was + * part of a group of files that had the same ID. If it was, we want to + * remove it from the group. Furthermore, if there is only one file + * remaining in the group, then we want to restore that single file as the + * correct resolution for its ID, and cleanup the duplicates index. + */ + _recoverDuplicates(hasteMap, relativeFilePath, moduleName) { + let dupsByPlatform = hasteMap.duplicates.get(moduleName); + if (dupsByPlatform == null) { + return; + } + const platform = + (0, _getPlatformExtension.default)( + relativeFilePath, + this._options.platforms + ) || _constants.default.GENERIC_PLATFORM; + let dups = dupsByPlatform.get(platform); + if (dups == null) { + return; + } + dupsByPlatform = copyMap(dupsByPlatform); + hasteMap.duplicates.set(moduleName, dupsByPlatform); + dups = copyMap(dups); + dupsByPlatform.set(platform, dups); + dups.delete(relativeFilePath); + if (dups.size !== 1) { + return; + } + const uniqueModule = dups.entries().next().value; + if (!uniqueModule) { + return; + } + let dedupMap = hasteMap.map.get(moduleName); + if (!dedupMap) { + dedupMap = Object.create(null); + hasteMap.map.set(moduleName, dedupMap); + } + dedupMap[platform] = uniqueModule; + dupsByPlatform.delete(platform); + if (dupsByPlatform.size === 0) { + hasteMap.duplicates.delete(moduleName); + } + } + async end() { + if (this._changeInterval) { + clearInterval(this._changeInterval); + } + if (!this._watchers.length) { + return; + } + await Promise.all(this._watchers.map(watcher => watcher.close())); + this._watchers = []; + } + + /** + * Helpers + */ + _ignore(filePath) { + const ignorePattern = this._options.ignorePattern; + const ignoreMatched = + ignorePattern instanceof RegExp + ? ignorePattern.test(filePath) + : ignorePattern && ignorePattern(filePath); + return ( + ignoreMatched || + (!this._options.retainAllFiles && filePath.includes(NODE_MODULES)) + ); + } + async _shouldUseWatchman() { + if (!this._options.useWatchman) { + return false; + } + if (!this._isWatchmanInstalledPromise) { + this._isWatchmanInstalledPromise = (0, _isWatchmanInstalled.default)(); + } + return this._isWatchmanInstalledPromise; + } + _createEmptyMap() { + return { + clocks: new Map(), + duplicates: new Map(), + files: new Map(), + map: new Map(), + mocks: new Map() + }; + } + static H = _constants.default; +} +class DuplicateError extends Error { + mockPath1; + mockPath2; + constructor(mockPath1, mockPath2) { + super('Duplicated files or mocks. Please check the console for more info'); + this.mockPath1 = mockPath1; + this.mockPath2 = mockPath2; + } +} +exports.DuplicateError = DuplicateError; +function copy(object) { + return Object.assign(Object.create(null), object); +} +function copyMap(input) { + return new Map(input); +} + +// Export the smallest API surface required by Jest + +const JestHasteMap = HasteMap; +var _default = JestHasteMap; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/lib/dependencyExtractor.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/lib/dependencyExtractor.js new file mode 100644 index 0000000000000000000000000000000000000000..9a2a14f8525fd8f92975e1cddf189f77440cb06a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/lib/dependencyExtractor.js @@ -0,0 +1,84 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.extractor = void 0; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const NOT_A_DOT = '(? `([\`'"])([^'"\`]*?)(?:\\${pos})`; +const WORD_SEPARATOR = '\\b'; +const LEFT_PARENTHESIS = '\\('; +const RIGHT_PARENTHESIS = '\\)'; +const WHITESPACE = '\\s*'; +const OPTIONAL_COMMA = '(:?,\\s*)?'; +function createRegExp(parts, flags) { + return new RegExp(parts.join(''), flags); +} +function alternatives(...parts) { + return `(?:${parts.join('|')})`; +} +function functionCallStart(...names) { + return [ + NOT_A_DOT, + WORD_SEPARATOR, + alternatives(...names), + WHITESPACE, + LEFT_PARENTHESIS, + WHITESPACE + ]; +} +const BLOCK_COMMENT_RE = /\/\*[^]*?\*\//g; +const LINE_COMMENT_RE = /\/\/.*/g; +const REQUIRE_OR_DYNAMIC_IMPORT_RE = createRegExp( + [ + ...functionCallStart('require', 'import'), + CAPTURE_STRING_LITERAL(1), + WHITESPACE, + OPTIONAL_COMMA, + RIGHT_PARENTHESIS + ], + 'g' +); +const IMPORT_OR_EXPORT_RE = createRegExp( + [ + '\\b(?:import|export)\\s+(?!type(?:of)?\\s+)(?:[^\'"]+\\s+from\\s+)?', + CAPTURE_STRING_LITERAL(1) + ], + 'g' +); +const JEST_EXTENSIONS_RE = createRegExp( + [ + ...functionCallStart( + 'jest\\s*\\.\\s*(?:requireActual|requireMock|genMockFromModule|createMockFromModule)' + ), + CAPTURE_STRING_LITERAL(1), + WHITESPACE, + OPTIONAL_COMMA, + RIGHT_PARENTHESIS + ], + 'g' +); +const extractor = { + extract(code) { + const dependencies = new Set(); + const addDependency = (match, _, dep) => { + dependencies.add(dep); + return match; + }; + code + .replace(BLOCK_COMMENT_RE, '') + .replace(LINE_COMMENT_RE, '') + .replace(IMPORT_OR_EXPORT_RE, addDependency) + .replace(REQUIRE_OR_DYNAMIC_IMPORT_RE, addDependency) + .replace(JEST_EXTENSIONS_RE, addDependency); + return dependencies; + } +}; +exports.extractor = extractor; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/lib/fast_path.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/lib/fast_path.js new file mode 100644 index 0000000000000000000000000000000000000000..f82787ccb387f40d71dbcc00f1931481fb961294 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/lib/fast_path.js @@ -0,0 +1,76 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.relative = relative; +exports.resolve = resolve; +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// rootDir and filename must be absolute paths (resolved) +function relative(rootDir, filename) { + return filename.indexOf(rootDir + path().sep) === 0 + ? filename.substring(rootDir.length + 1) + : path().relative(rootDir, filename); +} +const INDIRECTION_FRAGMENT = `..${path().sep}`; + +// rootDir must be an absolute path and relativeFilename must be simple +// (e.g.: foo/bar or ../foo/bar, but never ./foo or foo/../bar) +function resolve(rootDir, relativeFilename) { + return relativeFilename.indexOf(INDIRECTION_FRAGMENT) === 0 + ? path().resolve(rootDir, relativeFilename) + : rootDir + path().sep + relativeFilename; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/lib/getPlatformExtension.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/lib/getPlatformExtension.js new file mode 100644 index 0000000000000000000000000000000000000000..2e1d2045e9a75313216b97f1d251d4d6ad075d70 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/lib/getPlatformExtension.js @@ -0,0 +1,30 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getPlatformExtension; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const SUPPORTED_PLATFORM_EXTS = new Set(['android', 'ios', 'native', 'web']); + +// Extract platform extension: index.ios.js -> ios +function getPlatformExtension(file, platforms) { + const last = file.lastIndexOf('.'); + const secondToLast = file.lastIndexOf('.', last - 1); + if (secondToLast === -1) { + return null; + } + const platform = file.substring(secondToLast + 1, last); + // If an overriding platform array is passed, check that first + + if (platforms && platforms.indexOf(platform) !== -1) { + return platform; + } + return SUPPORTED_PLATFORM_EXTS.has(platform) ? platform : null; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/lib/isWatchmanInstalled.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/lib/isWatchmanInstalled.js new file mode 100644 index 0000000000000000000000000000000000000000..b04abb24e117f96eb98c4be5e11f7836d2e49cf6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/lib/isWatchmanInstalled.js @@ -0,0 +1,37 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = isWatchmanInstalled; +function _child_process() { + const data = require('child_process'); + _child_process = function () { + return data; + }; + return data; +} +function _util() { + const data = require('util'); + _util = function () { + return data; + }; + return data; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +async function isWatchmanInstalled() { + try { + await (0, _util().promisify)(_child_process().execFile)('watchman', [ + '--version' + ]); + return true; + } catch { + return false; + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/lib/normalizePathSep.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/lib/normalizePathSep.js new file mode 100644 index 0000000000000000000000000000000000000000..ad8cd1fe42f1074edb7d64774301d1c025817b9c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/lib/normalizePathSep.js @@ -0,0 +1,68 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +let normalizePathSep; +if (path().sep === '/') { + normalizePathSep = filePath => filePath; +} else { + normalizePathSep = filePath => filePath.replace(/\//g, path().sep); +} +var _default = normalizePathSep; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/types.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/types.js new file mode 100644 index 0000000000000000000000000000000000000000..ad9a93a7c160f02945911772460eb8a1bcb003db --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/types.js @@ -0,0 +1 @@ +'use strict'; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/watchers/FSEventsWatcher.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/watchers/FSEventsWatcher.js new file mode 100644 index 0000000000000000000000000000000000000000..a8b59d7f382b290ed9e09593c439c17137d8fb3e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/watchers/FSEventsWatcher.js @@ -0,0 +1,244 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.FSEventsWatcher = void 0; +function _events() { + const data = require('events'); + _events = function () { + return data; + }; + return data; +} +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _anymatch() { + const data = _interopRequireDefault(require('anymatch')); + _anymatch = function () { + return data; + }; + return data; +} +function fs() { + const data = _interopRequireWildcard(require('graceful-fs')); + fs = function () { + return data; + }; + return data; +} +function _micromatch() { + const data = _interopRequireDefault(require('micromatch')); + _micromatch = function () { + return data; + }; + return data; +} +function _walker() { + const data = _interopRequireDefault(require('walker')); + _walker = function () { + return data; + }; + return data; +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + */ + +// @ts-expect-error no types + +// eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error, @typescript-eslint/ban-ts-comment +// @ts-ignore: this is for CI which runs linux and might not have this +let fsevents = null; +try { + fsevents = require('fsevents'); +} catch { + // Optional dependency, only supported on Darwin. +} +const CHANGE_EVENT = 'change'; +const DELETE_EVENT = 'delete'; +const ADD_EVENT = 'add'; +const ALL_EVENT = 'all'; +/** + * Export `FSEventsWatcher` class. + * Watches `dir`. + */ +class FSEventsWatcher extends _events().EventEmitter { + root; + ignored; + glob; + dot; + hasIgnore; + doIgnore; + fsEventsWatchStopper; + _tracked; + static isSupported() { + return fsevents !== null; + } + static normalizeProxy(callback) { + return (filepath, stats) => callback(path().normalize(filepath), stats); + } + static recReaddir( + dir, + dirCallback, + fileCallback, + endCallback, + errorCallback, + ignored + ) { + (0, _walker().default)(dir) + .filterDir( + currentDir => !ignored || !(0, _anymatch().default)(ignored, currentDir) + ) + .on('dir', FSEventsWatcher.normalizeProxy(dirCallback)) + .on('file', FSEventsWatcher.normalizeProxy(fileCallback)) + .on('error', errorCallback) + .on('end', () => { + endCallback(); + }); + } + constructor(dir, opts) { + if (!fsevents) { + throw new Error( + '`fsevents` unavailable (this watcher can only be used on Darwin)' + ); + } + super(); + this.dot = opts.dot || false; + this.ignored = opts.ignored; + this.glob = Array.isArray(opts.glob) ? opts.glob : [opts.glob]; + this.hasIgnore = + Boolean(opts.ignored) && !(Array.isArray(opts) && opts.length > 0); + this.doIgnore = opts.ignored + ? (0, _anymatch().default)(opts.ignored) + : () => false; + this.root = path().resolve(dir); + this.fsEventsWatchStopper = fsevents.watch( + this.root, + this.handleEvent.bind(this) + ); + this._tracked = new Set(); + FSEventsWatcher.recReaddir( + this.root, + filepath => { + this._tracked.add(filepath); + }, + filepath => { + this._tracked.add(filepath); + }, + this.emit.bind(this, 'ready'), + this.emit.bind(this, 'error'), + this.ignored + ); + } + + /** + * End watching. + */ + async close(callback) { + await this.fsEventsWatchStopper(); + this.removeAllListeners(); + if (typeof callback === 'function') { + process.nextTick(() => callback()); + } + } + isFileIncluded(relativePath) { + if (this.doIgnore(relativePath)) { + return false; + } + return this.glob.length + ? (0, _micromatch().default)([relativePath], this.glob, { + dot: this.dot + }).length > 0 + : this.dot || + (0, _micromatch().default)([relativePath], '**/*').length > 0; + } + handleEvent(filepath) { + const relativePath = path().relative(this.root, filepath); + if (!this.isFileIncluded(relativePath)) { + return; + } + fs().lstat(filepath, (error, stat) => { + if (error && error.code !== 'ENOENT') { + this.emit('error', error); + return; + } + if (error) { + // Ignore files that aren't tracked and don't exist. + if (!this._tracked.has(filepath)) { + return; + } + this._emit(DELETE_EVENT, relativePath); + this._tracked.delete(filepath); + return; + } + if (this._tracked.has(filepath)) { + this._emit(CHANGE_EVENT, relativePath, stat); + } else { + this._tracked.add(filepath); + this._emit(ADD_EVENT, relativePath, stat); + } + }); + } + + /** + * Emit events. + */ + _emit(type, file, stat) { + this.emit(type, file, this.root, stat); + this.emit(ALL_EVENT, type, file, this.root, stat); + } +} +exports.FSEventsWatcher = FSEventsWatcher; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/watchers/NodeWatcher.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/watchers/NodeWatcher.js new file mode 100644 index 0000000000000000000000000000000000000000..62cface561db0cc60322174036216ef867cd86da --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/watchers/NodeWatcher.js @@ -0,0 +1,369 @@ +// vendored from https://github.com/amasad/sane/blob/64ff3a870c42e84f744086884bf55a4f9c22d376/src/node_watcher.js + +'use strict'; + +const EventEmitter = require('events').EventEmitter; +const fs = require('fs'); +const platform = require('os').platform(); +const path = require('path'); +const common = require('./common'); + +/** + * Constants + */ + +const DEFAULT_DELAY = common.DEFAULT_DELAY; +const CHANGE_EVENT = common.CHANGE_EVENT; +const DELETE_EVENT = common.DELETE_EVENT; +const ADD_EVENT = common.ADD_EVENT; +const ALL_EVENT = common.ALL_EVENT; + +/** + * Export `NodeWatcher` class. + * Watches `dir`. + * + * @class NodeWatcher + * @param {String} dir + * @param {Object} opts + * @public + */ + +module.exports = class NodeWatcher extends EventEmitter { + constructor(dir, opts) { + super(); + common.assignOptions(this, opts); + this.watched = Object.create(null); + this.changeTimers = Object.create(null); + this.dirRegistery = Object.create(null); + this.root = path.resolve(dir); + this.watchdir = this.watchdir.bind(this); + this.register = this.register.bind(this); + this.checkedEmitError = this.checkedEmitError.bind(this); + this.watchdir(this.root); + common.recReaddir( + this.root, + this.watchdir, + this.register, + this.emit.bind(this, 'ready'), + this.checkedEmitError, + this.ignored + ); + } + + /** + * Register files that matches our globs to know what to type of event to + * emit in the future. + * + * Registery looks like the following: + * + * dirRegister => Map { + * dirpath => Map { + * filename => true + * } + * } + * + * @param {string} filepath + * @return {boolean} whether or not we have registered the file. + * @private + */ + + register(filepath) { + const relativePath = path.relative(this.root, filepath); + if ( + !common.isFileIncluded(this.globs, this.dot, this.doIgnore, relativePath) + ) { + return false; + } + const dir = path.dirname(filepath); + if (!this.dirRegistery[dir]) { + this.dirRegistery[dir] = Object.create(null); + } + const filename = path.basename(filepath); + this.dirRegistery[dir][filename] = true; + return true; + } + + /** + * Removes a file from the registery. + * + * @param {string} filepath + * @private + */ + + unregister(filepath) { + const dir = path.dirname(filepath); + if (this.dirRegistery[dir]) { + const filename = path.basename(filepath); + delete this.dirRegistery[dir][filename]; + } + } + + /** + * Removes a dir from the registery. + * + * @param {string} dirpath + * @private + */ + + unregisterDir(dirpath) { + if (this.dirRegistery[dirpath]) { + delete this.dirRegistery[dirpath]; + } + } + + /** + * Checks if a file or directory exists in the registery. + * + * @param {string} fullpath + * @return {boolean} + * @private + */ + + registered(fullpath) { + const dir = path.dirname(fullpath); + return ( + this.dirRegistery[fullpath] || + (this.dirRegistery[dir] && + this.dirRegistery[dir][path.basename(fullpath)]) + ); + } + + /** + * Emit "error" event if it's not an ignorable event + * + * @param error + * @private + */ + checkedEmitError(error) { + if (!isIgnorableFileError(error)) { + this.emit('error', error); + } + } + + /** + * Watch a directory. + * + * @param {string} dir + * @private + */ + + watchdir(dir) { + if (this.watched[dir]) { + return; + } + const watcher = fs.watch( + dir, + { + persistent: true + }, + this.normalizeChange.bind(this, dir) + ); + this.watched[dir] = watcher; + watcher.on('error', this.checkedEmitError); + if (this.root !== dir) { + this.register(dir); + } + } + + /** + * Stop watching a directory. + * + * @param {string} dir + * @private + */ + + stopWatching(dir) { + if (this.watched[dir]) { + this.watched[dir].close(); + delete this.watched[dir]; + } + } + + /** + * End watching. + * + * @public + */ + + close() { + Object.keys(this.watched).forEach(this.stopWatching, this); + this.removeAllListeners(); + return Promise.resolve(); + } + + /** + * On some platforms, as pointed out on the fs docs (most likely just win32) + * the file argument might be missing from the fs event. Try to detect what + * change by detecting if something was deleted or the most recent file change. + * + * @param {string} dir + * @param {string} event + * @param {string} file + * @public + */ + + detectChangedFile(dir, event, callback) { + if (!this.dirRegistery[dir]) { + return; + } + let found = false; + let closest = { + mtime: 0 + }; + let c = 0; + Object.keys(this.dirRegistery[dir]).forEach(function (file, i, arr) { + fs.lstat(path.join(dir, file), (error, stat) => { + if (found) { + return; + } + if (error) { + if (isIgnorableFileError(error)) { + found = true; + callback(file); + } else { + this.emit('error', error); + } + } else { + if (stat.mtime > closest.mtime) { + stat.file = file; + closest = stat; + } + if (arr.length === ++c) { + callback(closest.file); + } + } + }); + }, this); + } + + /** + * Normalize fs events and pass it on to be processed. + * + * @param {string} dir + * @param {string} event + * @param {string} file + * @public + */ + + normalizeChange(dir, event, file) { + if (!file) { + this.detectChangedFile(dir, event, actualFile => { + if (actualFile) { + this.processChange(dir, event, actualFile); + } + }); + } else { + this.processChange(dir, event, path.normalize(file)); + } + } + + /** + * Process changes. + * + * @param {string} dir + * @param {string} event + * @param {string} file + * @public + */ + + processChange(dir, event, file) { + const fullPath = path.join(dir, file); + const relativePath = path.join(path.relative(this.root, dir), file); + fs.lstat(fullPath, (error, stat) => { + if (error && error.code !== 'ENOENT') { + this.emit('error', error); + } else if (!error && stat.isDirectory()) { + // win32 emits usless change events on dirs. + if (event !== 'change') { + this.watchdir(fullPath); + if ( + common.isFileIncluded( + this.globs, + this.dot, + this.doIgnore, + relativePath + ) + ) { + this.emitEvent(ADD_EVENT, relativePath, stat); + } + } + } else { + const registered = this.registered(fullPath); + if (error && error.code === 'ENOENT') { + this.unregister(fullPath); + this.stopWatching(fullPath); + this.unregisterDir(fullPath); + if (registered) { + this.emitEvent(DELETE_EVENT, relativePath); + } + } else if (registered) { + this.emitEvent(CHANGE_EVENT, relativePath, stat); + } else { + if (this.register(fullPath)) { + this.emitEvent(ADD_EVENT, relativePath, stat); + } + } + } + }); + } + + /** + * Triggers a 'change' event after debounding it to take care of duplicate + * events on os x. + * + * @private + */ + + emitEvent(type, file, stat) { + const key = `${type}-${file}`; + const addKey = `${ADD_EVENT}-${file}`; + if (type === CHANGE_EVENT && this.changeTimers[addKey]) { + // Ignore the change event that is immediately fired after an add event. + // (This happens on Linux). + return; + } + clearTimeout(this.changeTimers[key]); + this.changeTimers[key] = setTimeout(() => { + delete this.changeTimers[key]; + if (type === ADD_EVENT && stat.isDirectory()) { + // Recursively emit add events and watch for sub-files/folders + common.recReaddir( + path.resolve(this.root, file), + function emitAddDir(dir, stats) { + this.watchdir(dir); + this.rawEmitEvent(ADD_EVENT, path.relative(this.root, dir), stats); + }.bind(this), + function emitAddFile(file, stats) { + this.register(file); + this.rawEmitEvent(ADD_EVENT, path.relative(this.root, file), stats); + }.bind(this), + function endCallback() {}, + this.checkedEmitError, + this.ignored + ); + } else { + this.rawEmitEvent(type, file, stat); + } + }, DEFAULT_DELAY); + } + + /** + * Actually emit the events + */ + rawEmitEvent(type, file, stat) { + this.emit(type, file, this.root, stat); + this.emit(ALL_EVENT, type, file, this.root, stat); + } +}; +/** + * Determine if a given FS error can be ignored + * + * @private + */ +function isIgnorableFileError(error) { + return ( + error.code === 'ENOENT' || + // Workaround Windows node issue #4337. + (error.code === 'EPERM' && platform === 'win32') + ); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/watchers/RecrawlWarning.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/watchers/RecrawlWarning.js new file mode 100644 index 0000000000000000000000000000000000000000..5b1b6d3528dbce198dc624289ec893fd4ccf5607 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/watchers/RecrawlWarning.js @@ -0,0 +1,49 @@ +// vendored from https://github.com/amasad/sane/blob/64ff3a870c42e84f744086884bf55a4f9c22d376/src/utils/recrawl-warning-dedupe.js + +'use strict'; + +class RecrawlWarning { + constructor(root, count) { + this.root = root; + this.count = count; + } + static findByRoot(root) { + for (let i = 0; i < this.RECRAWL_WARNINGS.length; i++) { + const warning = this.RECRAWL_WARNINGS[i]; + if (warning.root === root) { + return warning; + } + } + return undefined; + } + static isRecrawlWarningDupe(warningMessage) { + if (typeof warningMessage !== 'string') { + return false; + } + const match = warningMessage.match(this.REGEXP); + if (!match) { + return false; + } + const count = Number(match[1]); + const root = match[2]; + const warning = this.findByRoot(root); + if (warning) { + // only keep the highest count, assume count to either stay the same or + // increase. + if (warning.count >= count) { + return true; + } else { + // update the existing warning to the latest (highest) count + warning.count = count; + return false; + } + } else { + this.RECRAWL_WARNINGS.push(new RecrawlWarning(root, count)); + return false; + } + } +} +RecrawlWarning.RECRAWL_WARNINGS = []; +RecrawlWarning.REGEXP = + /Recrawled this watch (\d+) times, most recently because:\n([^:]+)/; +module.exports = RecrawlWarning; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/watchers/WatchmanWatcher.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/watchers/WatchmanWatcher.js new file mode 100644 index 0000000000000000000000000000000000000000..7b341687fb8c17d09cfc2bc9ed9901cce388b796 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/watchers/WatchmanWatcher.js @@ -0,0 +1,383 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = WatchmanWatcher; +function _assert() { + const data = require('assert'); + _assert = function () { + return data; + }; + return data; +} +function _events() { + const data = require('events'); + _events = function () { + return data; + }; + return data; +} +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function _fbWatchman() { + const data = _interopRequireDefault(require('fb-watchman')); + _fbWatchman = function () { + return data; + }; + return data; +} +function _gracefulFs() { + const data = _interopRequireDefault(require('graceful-fs')); + _gracefulFs = function () { + return data; + }; + return data; +} +var _RecrawlWarning = _interopRequireDefault(require('./RecrawlWarning')); +var _common = _interopRequireDefault(require('./common')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const CHANGE_EVENT = _common.default.CHANGE_EVENT; +const DELETE_EVENT = _common.default.DELETE_EVENT; +const ADD_EVENT = _common.default.ADD_EVENT; +const ALL_EVENT = _common.default.ALL_EVENT; +const SUB_NAME = 'sane-sub'; + +/** + * Watches `dir`. + * + * @class PollWatcher + * @param String dir + * @param {Object} opts + * @public + */ + +function WatchmanWatcher(dir, opts) { + _common.default.assignOptions(this, opts); + this.root = path().resolve(dir); + this.init(); +} +Object.setPrototypeOf( + WatchmanWatcher.prototype, + _events().EventEmitter.prototype +); + +/** + * Run the watchman `watch` command on the root and subscribe to changes. + * + * @private + */ + +WatchmanWatcher.prototype.init = function () { + if (this.client) { + this.client.removeAllListeners(); + } + const self = this; + this.client = new (_fbWatchman().default.Client)(); + this.client.on('error', error => { + self.emit('error', error); + }); + this.client.on('subscription', this.handleChangeEvent.bind(this)); + this.client.on('end', () => { + console.warn('[sane] Warning: Lost connection to watchman, reconnecting..'); + self.init(); + }); + this.watchProjectInfo = null; + function getWatchRoot() { + return self.watchProjectInfo ? self.watchProjectInfo.root : self.root; + } + function onCapability(error, resp) { + if (handleError(self, error)) { + // The Watchman watcher is unusable on this system, we cannot continue + return; + } + handleWarning(resp); + self.capabilities = resp.capabilities; + if (self.capabilities.relative_root) { + self.client.command(['watch-project', getWatchRoot()], onWatchProject); + } else { + self.client.command(['watch', getWatchRoot()], onWatch); + } + } + function onWatchProject(error, resp) { + if (handleError(self, error)) { + return; + } + handleWarning(resp); + self.watchProjectInfo = { + relativePath: resp.relative_path ? resp.relative_path : '', + root: resp.watch + }; + self.client.command(['clock', getWatchRoot()], onClock); + } + function onWatch(error, resp) { + if (handleError(self, error)) { + return; + } + handleWarning(resp); + self.client.command(['clock', getWatchRoot()], onClock); + } + function onClock(error, resp) { + if (handleError(self, error)) { + return; + } + handleWarning(resp); + const options = { + fields: ['name', 'exists', 'new'], + since: resp.clock + }; + + // If the server has the wildmatch capability available it supports + // the recursive **/*.foo style match and we can offload our globs + // to the watchman server. This saves both on data size to be + // communicated back to us and compute for evaluating the globs + // in our node process. + if (self.capabilities.wildmatch) { + if (self.globs.length === 0) { + if (!self.dot) { + // Make sure we honor the dot option if even we're not using globs. + options.expression = [ + 'match', + '**', + 'wholename', + { + includedotfiles: false + } + ]; + } + } else { + options.expression = ['anyof']; + for (const i in self.globs) { + options.expression.push([ + 'match', + self.globs[i], + 'wholename', + { + includedotfiles: self.dot + } + ]); + } + } + } + if (self.capabilities.relative_root) { + options.relative_root = self.watchProjectInfo.relativePath; + } + self.client.command( + ['subscribe', getWatchRoot(), SUB_NAME, options], + onSubscribe + ); + } + function onSubscribe(error, resp) { + if (handleError(self, error)) { + return; + } + handleWarning(resp); + self.emit('ready'); + } + self.client.capabilityCheck( + { + optional: ['wildmatch', 'relative_root'] + }, + onCapability + ); +}; + +/** + * Handles a change event coming from the subscription. + * + * @param {Object} resp + * @private + */ + +WatchmanWatcher.prototype.handleChangeEvent = function (resp) { + _assert().strict.equal( + resp.subscription, + SUB_NAME, + 'Invalid subscription event.' + ); + if (resp.is_fresh_instance) { + this.emit('fresh_instance'); + } + if (resp.is_fresh_instance) { + this.emit('fresh_instance'); + } + if (Array.isArray(resp.files)) { + resp.files.forEach(this.handleFileChange, this); + } +}; + +/** + * Handles a single change event record. + * + * @param {Object} changeDescriptor + * @private + */ + +WatchmanWatcher.prototype.handleFileChange = function (changeDescriptor) { + const self = this; + let absPath; + let relativePath; + if (this.capabilities.relative_root) { + relativePath = changeDescriptor.name; + absPath = path().join( + this.watchProjectInfo.root, + this.watchProjectInfo.relativePath, + relativePath + ); + } else { + absPath = path().join(this.root, changeDescriptor.name); + relativePath = changeDescriptor.name; + } + if ( + !(self.capabilities.wildmatch && !this.hasIgnore) && + !_common.default.isFileIncluded( + this.globs, + this.dot, + this.doIgnore, + relativePath + ) + ) { + return; + } + if (!changeDescriptor.exists) { + self.emitEvent(DELETE_EVENT, relativePath, self.root); + } else { + _gracefulFs().default.lstat(absPath, (error, stat) => { + // Files can be deleted between the event and the lstat call + // the most reliable thing to do here is to ignore the event. + if (error && error.code === 'ENOENT') { + return; + } + if (handleError(self, error)) { + return; + } + const eventType = changeDescriptor.new ? ADD_EVENT : CHANGE_EVENT; + + // Change event on dirs are mostly useless. + if (!(eventType === CHANGE_EVENT && stat.isDirectory())) { + self.emitEvent(eventType, relativePath, self.root, stat); + } + }); + } +}; + +/** + * Dispatches the event. + * + * @param {string} eventType + * @param {string} filepath + * @param {string} root + * @param {fs.Stat} stat + * @private + */ + +WatchmanWatcher.prototype.emitEvent = function ( + eventType, + filepath, + root, + stat +) { + this.emit(eventType, filepath, root, stat); + this.emit(ALL_EVENT, eventType, filepath, root, stat); +}; + +/** + * Closes the watcher. + * + */ + +WatchmanWatcher.prototype.close = function () { + this.client.removeAllListeners(); + this.client.end(); + return Promise.resolve(); +}; + +/** + * Handles an error and returns true if exists. + * + * @param {WatchmanWatcher} self + * @param {Error} error + * @private + */ + +function handleError(self, error) { + if (error != null) { + self.emit('error', error); + return true; + } else { + return false; + } +} + +/** + * Handles a warning in the watchman resp object. + * + * @param {object} resp + * @private + */ + +function handleWarning(resp) { + if ('warning' in resp) { + if (_RecrawlWarning.default.isRecrawlWarningDupe(resp.warning)) { + return true; + } + console.warn(resp.warning); + return true; + } else { + return false; + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/watchers/common.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/watchers/common.js new file mode 100644 index 0000000000000000000000000000000000000000..b8fa0c30bdaa10b46e6c70eb9b4f29072b6f97f5 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/watchers/common.js @@ -0,0 +1,111 @@ +// vendored from https://github.com/amasad/sane/blob/64ff3a870c42e84f744086884bf55a4f9c22d376/src/common.js + +'use strict'; + +const platform = require('os').platform(); +const path = require('path'); +const anymatch = require('anymatch'); +const micromatch = require('micromatch'); +const walker = require('walker'); + +/** + * Constants + */ + +exports.DEFAULT_DELAY = 100; +exports.CHANGE_EVENT = 'change'; +exports.DELETE_EVENT = 'delete'; +exports.ADD_EVENT = 'add'; +exports.ALL_EVENT = 'all'; + +/** + * Assigns options to the watcher. + * + * @param {NodeWatcher|PollWatcher|WatchmanWatcher} watcher + * @param {?object} opts + * @return {boolean} + * @public + */ + +exports.assignOptions = function (watcher, opts) { + opts = opts || {}; + watcher.globs = opts.glob || []; + watcher.dot = opts.dot || false; + watcher.ignored = opts.ignored || false; + if (!Array.isArray(watcher.globs)) { + watcher.globs = [watcher.globs]; + } + watcher.hasIgnore = + Boolean(opts.ignored) && !(Array.isArray(opts) && opts.length > 0); + watcher.doIgnore = opts.ignored ? anymatch(opts.ignored) : () => false; + if (opts.watchman && opts.watchmanPath) { + watcher.watchmanPath = opts.watchmanPath; + } + return opts; +}; + +/** + * Checks a file relative path against the globs array. + * + * @param {array} globs + * @param {string} relativePath + * @return {boolean} + * @public + */ + +exports.isFileIncluded = function (globs, dot, doIgnore, relativePath) { + if (doIgnore(relativePath)) { + return false; + } + return globs.length + ? micromatch.some(relativePath, globs, { + dot + }) + : dot || micromatch.some(relativePath, '**/*'); +}; + +/** + * Traverse a directory recursively calling `callback` on every directory. + * + * @param {string} dir + * @param {function} dirCallback + * @param {function} fileCallback + * @param {function} endCallback + * @param {*} ignored + * @public + */ + +exports.recReaddir = function ( + dir, + dirCallback, + fileCallback, + endCallback, + errorCallback, + ignored +) { + walker(dir) + .filterDir(currentDir => !anymatch(ignored, currentDir)) + .on('dir', normalizeProxy(dirCallback)) + .on('file', normalizeProxy(fileCallback)) + .on('error', errorCallback) + .on('end', () => { + if (platform === 'win32') { + setTimeout(endCallback, 1000); + } else { + endCallback(); + } + }); +}; + +/** + * Returns a callback that when called will normalize a path and call the + * original callback + * + * @param {function} callback + * @return {function} + * @private + */ + +function normalizeProxy(callback) { + return (filepath, stats) => callback(path.normalize(filepath), stats); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/worker.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/worker.js new file mode 100644 index 0000000000000000000000000000000000000000..7f27df08d7251b1ddc23737ad525ae1f01734729 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/build/worker.js @@ -0,0 +1,180 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.getSha1 = getSha1; +exports.worker = worker; +function _crypto() { + const data = require('crypto'); + _crypto = function () { + return data; + }; + return data; +} +function path() { + const data = _interopRequireWildcard(require('path')); + path = function () { + return data; + }; + return data; +} +function fs() { + const data = _interopRequireWildcard(require('graceful-fs')); + fs = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +var _blacklist = _interopRequireDefault(require('./blacklist')); +var _constants = _interopRequireDefault(require('./constants')); +var _dependencyExtractor = require('./lib/dependencyExtractor'); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const PACKAGE_JSON = `${path().sep}package.json`; +let hasteImpl = null; +let hasteImplModulePath = null; +function sha1hex(content) { + return (0, _crypto().createHash)('sha1').update(content).digest('hex'); +} +async function worker(data) { + if ( + data.hasteImplModulePath && + data.hasteImplModulePath !== hasteImplModulePath + ) { + if (hasteImpl) { + throw new Error('jest-haste-map: hasteImplModulePath changed'); + } + hasteImplModulePath = data.hasteImplModulePath; + hasteImpl = require(hasteImplModulePath); + } + let content; + let dependencies; + let id; + let module; + let sha1; + const {computeDependencies, computeSha1, rootDir, filePath} = data; + const getContent = () => { + if (content === undefined) { + content = fs().readFileSync(filePath, 'utf8'); + } + return content; + }; + if (filePath.endsWith(PACKAGE_JSON)) { + // Process a package.json that is returned as a PACKAGE type with its name. + try { + const fileData = JSON.parse(getContent()); + if (fileData.name) { + const relativeFilePath = path().relative(rootDir, filePath); + id = fileData.name; + module = [relativeFilePath, _constants.default.PACKAGE]; + } + } catch (err) { + throw new Error(`Cannot parse ${filePath} as JSON: ${err.message}`); + } + } else if ( + !_blacklist.default.has(filePath.substring(filePath.lastIndexOf('.'))) + ) { + // Process a random file that is returned as a MODULE. + if (hasteImpl) { + id = hasteImpl.getHasteName(filePath); + } + if (computeDependencies) { + const content = getContent(); + const extractor = data.dependencyExtractor + ? await (0, _jestUtil().requireOrImportModule)( + data.dependencyExtractor, + false + ) + : _dependencyExtractor.extractor; + dependencies = Array.from( + extractor.extract( + content, + filePath, + _dependencyExtractor.extractor.extract + ) + ); + } + if (id) { + const relativeFilePath = path().relative(rootDir, filePath); + module = [relativeFilePath, _constants.default.MODULE]; + } + } + + // If a SHA-1 is requested on update, compute it. + if (computeSha1) { + sha1 = sha1hex(content || fs().readFileSync(filePath)); + } + return { + dependencies, + id, + module, + sha1 + }; +} +async function getSha1(data) { + const sha1 = data.computeSha1 + ? sha1hex(fs().readFileSync(data.filePath)) + : null; + return { + dependencies: undefined, + id: undefined, + module: undefined, + sha1 + }; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/package.json new file mode 100644 index 0000000000000000000000000000000000000000..ee459fdff926c11c17110c05124251fdfa0fd26e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-haste-map/package.json @@ -0,0 +1,47 @@ +{ + "name": "jest-haste-map", + "version": "29.7.0", + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/jest-haste-map" + }, + "license": "MIT", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "dependencies": { + "@jest/types": "^29.6.3", + "@types/graceful-fs": "^4.1.3", + "@types/node": "*", + "anymatch": "^3.0.3", + "fb-watchman": "^2.0.0", + "graceful-fs": "^4.2.9", + "jest-regex-util": "^29.6.3", + "jest-util": "^29.7.0", + "jest-worker": "^29.7.0", + "micromatch": "^4.0.4", + "walker": "^1.0.8" + }, + "devDependencies": { + "@types/fb-watchman": "^2.0.0", + "@types/micromatch": "^4.0.1", + "slash": "^3.0.0" + }, + "optionalDependencies": { + "fsevents": "^2.3.2" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "publishConfig": { + "access": "public" + }, + "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-regex-util/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-regex-util/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-regex-util/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-regex-util/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-regex-util/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8de7081045133753a839e978a29a0c0d612fa6c0 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-regex-util/build/index.d.ts @@ -0,0 +1,20 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + */ +export declare const escapePathForRegex: (dir: string) => string; + +export declare const escapeStrForRegex: (string: string) => string; + +export declare const replacePathSepForRegex: (string: string) => string; + +export {}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-regex-util/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-regex-util/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..0bb27016d51ed693d3c951f27cd2e8d84997a661 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-regex-util/build/index.js @@ -0,0 +1,40 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.replacePathSepForRegex = + exports.escapeStrForRegex = + exports.escapePathForRegex = + void 0; +var _path = require('path'); +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + */ + +const escapePathForRegex = dir => { + if (_path.sep === '\\') { + // Replace "\" with "/" so it's not escaped by escapeStrForRegex. + // replacePathSepForRegex will convert it back. + dir = dir.replace(/\\/g, '/'); + } + return replacePathSepForRegex(escapeStrForRegex(dir)); +}; +exports.escapePathForRegex = escapePathForRegex; +const escapeStrForRegex = string => + string.replace(/[[\]{}()*+?.\\^$|]/g, '\\$&'); +exports.escapeStrForRegex = escapeStrForRegex; +const replacePathSepForRegex = string => { + if (_path.sep === '\\') { + return string.replace( + /(\/|(.)?\\(?![[\]{}()*+?.^$|\\]))/g, + (_match, _, p2) => (p2 && p2 !== '\\' ? `${p2}\\\\` : '\\\\') + ); + } + return string; +}; +exports.replacePathSepForRegex = replacePathSepForRegex; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-regex-util/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-regex-util/package.json new file mode 100644 index 0000000000000000000000000000000000000000..ed8bc70707d3fc647eaf310d5cd0060b5cfbdb9d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-regex-util/package.json @@ -0,0 +1,29 @@ +{ + "name": "jest-regex-util", + "version": "29.6.3", + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/jest-regex-util" + }, + "devDependencies": { + "@types/node": "*" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "license": "MIT", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "publishConfig": { + "access": "public" + }, + "gitHead": "fb7d95c8af6e0d65a8b65348433d8a0ea0725b5b" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f9e1131c95e794f7399c3fd25354ec19d20a8b96 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/README.md @@ -0,0 +1,272 @@ +# jest-worker + +Module for executing heavy tasks under forked processes in parallel, by providing a `Promise` based interface, minimum overhead, and bound workers. + +The module works by providing an absolute path of the module to be loaded in all forked processes. All methods are exposed on the parent process as promises, so they can be `await`'ed. Child (worker) methods can either be synchronous or asynchronous. + +The module also implements support for bound workers. Binding a worker means that, based on certain parameters, the same task will always be executed by the same worker. The way bound workers work is by using the returned string of the `computeWorkerKey` method. If the string was used before for a task, the call will be queued to the related worker that processed the task earlier; if not, it will be executed by the first available worker, then sticked to the worker that executed it; so the next time it will be processed by the same worker. If you have no preference on the worker executing the task, but you have defined a `computeWorkerKey` method because you want _some_ of the tasks to be sticked, you can return `null` from it. + +The list of exposed methods can be explicitly provided via the `exposedMethods` option. If it is not provided, it will be obtained by requiring the child module into the main process, and analyzed via reflection. Check the "minimal example" section for a valid one. + +## Install + +```sh +yarn add jest-worker +``` + +## Example + +This example covers the minimal usage: + +### File `parent.js` + +```js +import {Worker as JestWorker} from 'jest-worker'; + +async function main() { + const worker = new JestWorker(require.resolve('./worker')); + const result = await worker.hello('Alice'); // "Hello, Alice" +} + +main(); +``` + +### File `worker.js` + +```js +export function hello(param) { + return `Hello, ${param}`; +} +``` + +## Experimental worker + +Node shipped with [`worker_threads`](https://nodejs.org/api/worker_threads.html), a "threading API" that uses `SharedArrayBuffers` to communicate between the main process and its child threads. This feature can significantly improve the communication time between parent and child processes in `jest-worker`. + +To use `worker_threads` instead of default `child_process` you have to pass `enableWorkerThreads: true` when instantiating the worker. + +## API + +The `Worker` export is a constructor that is initialized by passing the worker path, plus an options object. + +### `workerPath: string | URL` (required) + +Node module name or absolute path or file URL of the file to be loaded in the child processes. You can use `require.resolve` to transform a relative path into an absolute one. + +### `options: Object` (optional) + +#### `computeWorkerKey: (method: string, ...args: Array) => string | null` (optional) + +Every time a method exposed via the API is called, `computeWorkerKey` is also called in order to bound the call to a worker. This is useful for workers that are able to cache the result or part of it. You bound calls to a worker by making `computeWorkerKey` return the same identifier for all different calls. If you do not want to bind the call to any worker, return `null`. + +The callback you provide is called with the method name, plus all the rest of the arguments of the call. Thus, you have full control to decide what to return. Check a practical example on bound workers under the "bound worker usage" section. + +By default, no process is bound to any worker. + +#### `enableWorkerThreads: boolean` (optional) + +By default, `jest-worker` will use `child_process` threads to spawn new Node.js processes. If you prefer [`worker_threads`](https://nodejs.org/api/worker_threads.html) instead, pass `enableWorkerThreads: true`. + +#### `exposedMethods: ReadonlyArray` (optional) + +List of method names that can be called on the child processes from the parent process. You cannot expose any method named like a public `Worker` method, or starting with `_`. If you use method auto-discovery, then these methods will not be exposed, even if they exist. + +#### `forkOptions: ForkOptions` (optional) + +Allow customizing all options passed to `child_process.fork`. By default, some values are set (`cwd`, `env`, `execArgv` and `serialization`), but you can override them and customize the rest. For a list of valid values, check [the Node documentation](https://nodejs.org/api/child_process.html#child_process_child_process_fork_modulepath_args_options). + +#### `idleMemoryLimit: number` (optional) + +Specifies the memory limit for workers before they are recycled and is primarily a work-around for [this issue](https://github.com/jestjs/jest/issues/11956); + +After the worker has executed a task the memory usage of it is checked. If it exceeds the value specified the worker is killed and restarted. If no limit is set this process does not occur. The limit can be specified in 2 ways: + +- `<= 1` - The value is assumed to be a percentage of system memory. So 0.5 sets the memory limit of the worker to half of the total system memory +- `\> 1` - Assumed to be a fixed byte value. Because of the previous rule if you wanted a value of 1 byte (I don't know why) you could use `1.1`. + +#### `maxRetries: number` (optional) + +Maximum amount of times that a dead child can be re-spawned, per call. Defaults to `3`, pass `Infinity` to allow endless retries. + +#### `numWorkers: number` (optional) + +Amount of workers to spawn. Defaults to the number of CPUs minus 1. + +#### `resourceLimits: ResourceLimits` (optional) + +The `resourceLimits` option which will be passed to `worker_threads` workers. + +#### `silent: Boolean` (optional) + +Set to false for `stdout` and `stderr` to be logged to console. + +By default this is true. + +#### `setupArgs: Array` (optional) + +The arguments that will be passed to the `setup` method during initialization. + +#### `taskQueue: TaskQueue` (optional) + +The task queue defines in which order tasks (method calls) are processed by the workers. `jest-worker` ships with a `FifoQueue` and `PriorityQueue`: + +- `FifoQueue` (default): Processes the method calls (tasks) in the call order. +- `PriorityQueue`: Processes the method calls by a computed priority in natural ordering (lower priorities first). Tasks with the same priority are processed in any order (FIFO not guaranteed). The constructor accepts a single argument, the function that is passed the name of the called function and the arguments and returns a numerical value for the priority: `new require('jest-worker').PriorityQueue((method, filename) => filename.length)`. + +#### `WorkerPool: new (workerPath: string, options?: WorkerPoolOptions) => WorkerPoolInterface` (optional) + +Provide a custom WorkerPool class to be used for spawning child processes. + +#### `workerSchedulingPolicy: 'round-robin' | 'in-order'` (optional) + +Specifies the policy how tasks are assigned to workers if multiple workers are _idle_: + +- `round-robin` (default): The task will be sequentially distributed onto the workers. The first task is assigned to the worker 1, the second to the worker 2, to ensure that the work is distributed across workers. +- `in-order`: The task will be assigned to the first free worker starting with worker 1 and only assign the work to worker 2 if the worker 1 is busy. + +Tasks are always assigned to the first free worker as soon as tasks start to queue up. The scheduling policy does not define the task scheduling which is always first-in, first-out. + +## JestWorker + +### Methods + +The returned `JestWorker` instance has all the exposed methods, plus some additional ones to interact with the workers itself: + +#### `getStdout(): Readable` + +Returns a `ReadableStream` where the standard output of all workers is piped. Note that the `silent` option of the child workers must be set to `true` to make it work. This is the default set by `jest-worker`, but keep it in mind when overriding options through `forkOptions`. + +#### `getStderr(): Readable` + +Returns a `ReadableStream` where the standard error of all workers is piped. Note that the `silent` option of the child workers must be set to `true` to make it work. This is the default set by `jest-worker`, but keep it in mind when overriding options through `forkOptions`. + +#### `start()` + +Starts up every worker and calls their `setup` function, if it exists. Returns a `Promise` which resolves when all workers are running and have completed their `setup`. + +This is useful if you want to start up all your workers eagerly before they are used to call any other functions. + +#### `end()` + +Finishes the workers by killing all workers. No further calls can be done to the `Worker` instance. + +Returns a `Promise` that resolves with `{ forceExited: boolean }` once all workers are dead. If `forceExited` is `true`, at least one of the workers did not exit gracefully, which likely happened because it executed a leaky task that left handles open. This should be avoided, force exiting workers is a last resort to prevent creating lots of orphans. + +**Note:** + +`await`ing the `end()` Promise immediately after the workers are no longer needed before proceeding to do other useful things in your program may not be a good idea. If workers have to be force exited, `jest-worker` may go through multiple stages of force exiting (e.g. SIGTERM, later SIGKILL) and give the worker overall around 1 second time to exit on its own. During this time, your program will wait, even though it may not be necessary that all workers are dead before continuing execution. + +Consider deliberately leaving this Promise floating (unhandled resolution). After your program has done the rest of its work and is about to exit, the Node process will wait for the Promise to resolve after all workers are dead as the last event loop task. That way you parallelized computation time of your program and waiting time and you didn't delay the outputs of your program unnecessarily. + +### Worker IDs + +Each worker has a unique id (index that starts with `'1'`), which is available inside the worker as `process.env.JEST_WORKER_ID`. + +## Setting up and tearing down the child process + +The child process can define two special methods (both of them can be asynchronous): + +- `setup()`: If defined, it's executed before the first call to any method in the child. +- `teardown()`: If defined, it's executed when the farm ends. + +# More examples + +## Standard usage + +This example covers the standard usage: + +### File `parent.js` + +```js +import {Worker as JestWorker} from 'jest-worker'; + +async function main() { + const myWorker = new JestWorker(require.resolve('./worker'), { + exposedMethods: ['foo', 'bar', 'getWorkerId'], + numWorkers: 4, + }); + + console.log(await myWorker.foo('Alice')); // "Hello from foo: Alice" + console.log(await myWorker.bar('Bob')); // "Hello from bar: Bob" + console.log(await myWorker.getWorkerId()); // "3" -> this message has sent from the 3rd worker + + const {forceExited} = await myWorker.end(); + if (forceExited) { + console.error('Workers failed to exit gracefully'); + } +} + +main(); +``` + +### File `worker.js` + +```js +export function foo(param) { + return `Hello from foo: ${param}`; +} + +export function bar(param) { + return `Hello from bar: ${param}`; +} + +export function getWorkerId() { + return process.env.JEST_WORKER_ID; +} +``` + +## Bound worker usage: + +This example covers the usage with a `computeWorkerKey` method: + +### File `parent.js` + +```js +import {Worker as JestWorker} from 'jest-worker'; + +async function main() { + const myWorker = new JestWorker(require.resolve('./worker'), { + computeWorkerKey: (method, filename) => filename, + }); + + // Transform the given file, within the first available worker. + console.log(await myWorker.transform('/tmp/foo.js')); + + // Wait a bit. + await sleep(10000); + + // Transform the same file again. Will immediately return because the + // transformed file is cached in the worker, and `computeWorkerKey` ensures + // the same worker that processed the file the first time will process it now. + console.log(await myWorker.transform('/tmp/foo.js')); + + const {forceExited} = await myWorker.end(); + if (forceExited) { + console.error('Workers failed to exit gracefully'); + } +} + +main(); +``` + +### File `worker.js` + +```js +import babel from '@babel/core'; + +const cache = Object.create(null); + +export function transform(filename) { + if (cache[filename]) { + return cache[filename]; + } + + // jest-worker can handle both immediate results and thenables. If a + // thenable is returned, it will be await'ed until it resolves. + return babel.transformFileAsync(filename).then(result => { + cache[filename] = result; + + return result; + }); +} +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/Farm.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/Farm.js new file mode 100644 index 0000000000000000000000000000000000000000..bb9accf675771738ace59536349701701db1183e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/Farm.js @@ -0,0 +1,152 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +var _FifoQueue = _interopRequireDefault(require('./FifoQueue')); +var _types = require('./types'); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class Farm { + _computeWorkerKey; + _workerSchedulingPolicy; + _cacheKeys = Object.create(null); + _locks = []; + _offset = 0; + _taskQueue; + constructor(_numOfWorkers, _callback, options = {}) { + this._numOfWorkers = _numOfWorkers; + this._callback = _callback; + this._computeWorkerKey = options.computeWorkerKey; + this._workerSchedulingPolicy = + options.workerSchedulingPolicy ?? 'round-robin'; + this._taskQueue = options.taskQueue ?? new _FifoQueue.default(); + } + doWork(method, ...args) { + const customMessageListeners = new Set(); + const addCustomMessageListener = listener => { + customMessageListeners.add(listener); + return () => { + customMessageListeners.delete(listener); + }; + }; + const onCustomMessage = message => { + customMessageListeners.forEach(listener => listener(message)); + }; + const promise = new Promise( + // Bind args to this function so it won't reference to the parent scope. + // This prevents a memory leak in v8, because otherwise the function will + // retain args for the closure. + ((args, resolve, reject) => { + const computeWorkerKey = this._computeWorkerKey; + const request = [_types.CHILD_MESSAGE_CALL, false, method, args]; + let worker = null; + let hash = null; + if (computeWorkerKey) { + hash = computeWorkerKey.call(this, method, ...args); + worker = hash == null ? null : this._cacheKeys[hash]; + } + const onStart = worker => { + if (hash != null) { + this._cacheKeys[hash] = worker; + } + }; + const onEnd = (error, result) => { + customMessageListeners.clear(); + if (error) { + reject(error); + } else { + resolve(result); + } + }; + const task = { + onCustomMessage, + onEnd, + onStart, + request + }; + if (worker) { + this._taskQueue.enqueue(task, worker.getWorkerId()); + this._process(worker.getWorkerId()); + } else { + this._push(task); + } + }).bind(null, args) + ); + promise.UNSTABLE_onCustomMessage = addCustomMessageListener; + return promise; + } + _process(workerId) { + if (this._isLocked(workerId)) { + return this; + } + const task = this._taskQueue.dequeue(workerId); + if (!task) { + return this; + } + if (task.request[1]) { + throw new Error('Queue implementation returned processed task'); + } + + // Reference the task object outside so it won't be retained by onEnd, + // and other properties of the task object, such as task.request can be + // garbage collected. + let taskOnEnd = task.onEnd; + const onEnd = (error, result) => { + if (taskOnEnd) { + taskOnEnd(error, result); + } + taskOnEnd = null; + this._unlock(workerId); + this._process(workerId); + }; + task.request[1] = true; + this._lock(workerId); + this._callback( + workerId, + task.request, + task.onStart, + onEnd, + task.onCustomMessage + ); + return this; + } + _push(task) { + this._taskQueue.enqueue(task); + const offset = this._getNextWorkerOffset(); + for (let i = 0; i < this._numOfWorkers; i++) { + this._process((offset + i) % this._numOfWorkers); + if (task.request[1]) { + break; + } + } + return this; + } + _getNextWorkerOffset() { + switch (this._workerSchedulingPolicy) { + case 'in-order': + return 0; + case 'round-robin': + return this._offset++; + } + } + _lock(workerId) { + this._locks[workerId] = true; + } + _unlock(workerId) { + this._locks[workerId] = false; + } + _isLocked(workerId) { + return this._locks[workerId]; + } +} +exports.default = Farm; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/FifoQueue.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/FifoQueue.js new file mode 100644 index 0000000000000000000000000000000000000000..1831e024b876617bd0bd00bf904b222e831016b3 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/FifoQueue.js @@ -0,0 +1,89 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +/** + * First-in, First-out task queue that manages a dedicated pool + * for each worker as well as a shared queue. The FIFO ordering is guaranteed + * across the worker specific and shared queue. + */ +class FifoQueue { + _workerQueues = []; + _sharedQueue = new InternalQueue(); + enqueue(task, workerId) { + if (workerId == null) { + this._sharedQueue.enqueue(task); + return; + } + let workerQueue = this._workerQueues[workerId]; + if (workerQueue == null) { + workerQueue = this._workerQueues[workerId] = new InternalQueue(); + } + const sharedTop = this._sharedQueue.peekLast(); + const item = { + previousSharedTask: sharedTop, + task + }; + workerQueue.enqueue(item); + } + dequeue(workerId) { + const workerTop = this._workerQueues[workerId]?.peek(); + const sharedTaskIsProcessed = + workerTop?.previousSharedTask?.request[1] ?? true; + + // Process the top task from the shared queue if + // - there's no task in the worker specific queue or + // - if the non-worker-specific task after which this worker specific task + // has been queued wasn't processed yet + if (workerTop != null && sharedTaskIsProcessed) { + return this._workerQueues[workerId]?.dequeue()?.task ?? null; + } + return this._sharedQueue.dequeue(); + } +} +exports.default = FifoQueue; +/** + * FIFO queue for a single worker / shared queue. + */ +class InternalQueue { + _head = null; + _last = null; + enqueue(value) { + const item = { + next: null, + value + }; + if (this._last == null) { + this._head = item; + } else { + this._last.next = item; + } + this._last = item; + } + dequeue() { + if (this._head == null) { + return null; + } + const item = this._head; + this._head = item.next; + if (this._head == null) { + this._last = null; + } + return item.value; + } + peek() { + return this._head?.value ?? null; + } + peekLast() { + return this._last?.value ?? null; + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/PriorityQueue.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/PriorityQueue.js new file mode 100644 index 0000000000000000000000000000000000000000..6218a8ea6186fffb90656d6a914f11bf704a1ce9 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/PriorityQueue.js @@ -0,0 +1,137 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +/** + * Priority queue that processes tasks in natural ordering (lower priority first) + * according to the priority computed by the function passed in the constructor. + * + * FIFO ordering isn't guaranteed for tasks with the same priority. + * + * Worker specific tasks with the same priority as a non-worker specific task + * are always processed first. + */ +class PriorityQueue { + _queue = []; + _sharedQueue = new MinHeap(); + constructor(_computePriority) { + this._computePriority = _computePriority; + } + enqueue(task, workerId) { + if (workerId == null) { + this._enqueue(task, this._sharedQueue); + } else { + const queue = this._getWorkerQueue(workerId); + this._enqueue(task, queue); + } + } + _enqueue(task, queue) { + const item = { + priority: this._computePriority(task.request[2], ...task.request[3]), + task + }; + queue.add(item); + } + dequeue(workerId) { + const workerQueue = this._getWorkerQueue(workerId); + const workerTop = workerQueue.peek(); + const sharedTop = this._sharedQueue.peek(); + + // use the task from the worker queue if there's no task in the shared queue + // or if the priority of the worker queue is smaller or equal to the + // priority of the top task in the shared queue. The tasks of the + // worker specific queue are preferred because no other worker can pick this + // specific task up. + if ( + sharedTop == null || + (workerTop != null && workerTop.priority <= sharedTop.priority) + ) { + return workerQueue.poll()?.task ?? null; + } + return this._sharedQueue.poll().task; + } + _getWorkerQueue(workerId) { + let queue = this._queue[workerId]; + if (queue == null) { + queue = this._queue[workerId] = new MinHeap(); + } + return queue; + } +} +exports.default = PriorityQueue; +class MinHeap { + _heap = []; + peek() { + return this._heap[0] ?? null; + } + add(item) { + const nodes = this._heap; + nodes.push(item); + if (nodes.length === 1) { + return; + } + let currentIndex = nodes.length - 1; + + // Bubble up the added node as long as the parent is bigger + while (currentIndex > 0) { + const parentIndex = Math.floor((currentIndex + 1) / 2) - 1; + const parent = nodes[parentIndex]; + if (parent.priority <= item.priority) { + break; + } + nodes[currentIndex] = parent; + nodes[parentIndex] = item; + currentIndex = parentIndex; + } + } + poll() { + const nodes = this._heap; + const result = nodes[0]; + const lastElement = nodes.pop(); + + // heap was empty or removed the last element + if (result == null || nodes.length === 0) { + return result ?? null; + } + let index = 0; + nodes[0] = lastElement ?? null; + const element = nodes[0]; + while (true) { + let swapIndex = null; + const rightChildIndex = (index + 1) * 2; + const leftChildIndex = rightChildIndex - 1; + const rightChild = nodes[rightChildIndex]; + const leftChild = nodes[leftChildIndex]; + + // if the left child is smaller, swap with the left + if (leftChild != null && leftChild.priority < element.priority) { + swapIndex = leftChildIndex; + } + + // If the right child is smaller or the right child is smaller than the left + // then swap with the right child + if ( + rightChild != null && + rightChild.priority < (swapIndex == null ? element : leftChild).priority + ) { + swapIndex = rightChildIndex; + } + if (swapIndex == null) { + break; + } + nodes[index] = nodes[swapIndex]; + nodes[swapIndex] = element; + index = swapIndex; + } + return result; + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/WorkerPool.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/WorkerPool.js new file mode 100644 index 0000000000000000000000000000000000000000..b1e439d2c53e7a33a6431a9b066d91816252d30e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/WorkerPool.js @@ -0,0 +1,34 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +var _BaseWorkerPool = _interopRequireDefault(require('./base/BaseWorkerPool')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class WorkerPool extends _BaseWorkerPool.default { + send(workerId, request, onStart, onEnd, onCustomMessage) { + this.restartWorkerIfShutDown(workerId); + this.getWorkerById(workerId).send(request, onStart, onEnd, onCustomMessage); + } + createWorker(workerOptions) { + let Worker; + if (this._options.enableWorkerThreads) { + Worker = require('./workers/NodeThreadsWorker').default; + } else { + Worker = require('./workers/ChildProcessWorker').default; + } + return new Worker(workerOptions); + } +} +var _default = WorkerPool; +exports.default = _default; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/base/BaseWorkerPool.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/base/BaseWorkerPool.js new file mode 100644 index 0000000000000000000000000000000000000000..b49d061d78d293f256c7dff0bd123d73479e69df --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/base/BaseWorkerPool.js @@ -0,0 +1,156 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _mergeStream() { + const data = _interopRequireDefault(require('merge-stream')); + _mergeStream = function () { + return data; + }; + return data; +} +var _types = require('../types'); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// How long to wait for the child process to terminate +// after CHILD_MESSAGE_END before sending force exiting. +const FORCE_EXIT_DELAY = 500; + +/* istanbul ignore next */ +// eslint-disable-next-line @typescript-eslint/no-empty-function +const emptyMethod = () => {}; +class BaseWorkerPool { + _stderr; + _stdout; + _options; + _workers; + _workerPath; + constructor(workerPath, options) { + this._options = options; + this._workerPath = workerPath; + this._workers = new Array(options.numWorkers); + const stdout = (0, _mergeStream().default)(); + const stderr = (0, _mergeStream().default)(); + const {forkOptions, maxRetries, resourceLimits, setupArgs} = options; + for (let i = 0; i < options.numWorkers; i++) { + const workerOptions = { + forkOptions, + idleMemoryLimit: this._options.idleMemoryLimit, + maxRetries, + resourceLimits, + setupArgs, + workerId: i, + workerPath + }; + const worker = this.createWorker(workerOptions); + const workerStdout = worker.getStdout(); + const workerStderr = worker.getStderr(); + if (workerStdout) { + stdout.add(workerStdout); + } + if (workerStderr) { + stderr.add(workerStderr); + } + this._workers[i] = worker; + } + this._stdout = stdout; + this._stderr = stderr; + } + getStderr() { + return this._stderr; + } + getStdout() { + return this._stdout; + } + getWorkers() { + return this._workers; + } + getWorkerById(workerId) { + return this._workers[workerId]; + } + restartWorkerIfShutDown(workerId) { + if (this._workers[workerId].state === _types.WorkerStates.SHUT_DOWN) { + const {forkOptions, maxRetries, resourceLimits, setupArgs} = + this._options; + const workerOptions = { + forkOptions, + idleMemoryLimit: this._options.idleMemoryLimit, + maxRetries, + resourceLimits, + setupArgs, + workerId, + workerPath: this._workerPath + }; + const worker = this.createWorker(workerOptions); + this._workers[workerId] = worker; + } + } + createWorker(_workerOptions) { + throw Error('Missing method createWorker in WorkerPool'); + } + async start() { + await Promise.all( + this._workers.map(async worker => { + await worker.waitForWorkerReady(); + await new Promise((resolve, reject) => { + worker.send( + [_types.CHILD_MESSAGE_CALL_SETUP], + emptyMethod, + error => { + if (error) { + reject(error); + } else { + resolve(); + } + }, + emptyMethod + ); + }); + }) + ); + } + async end() { + // We do not cache the request object here. If so, it would only be only + // processed by one of the workers, and we want them all to close. + const workerExitPromises = this._workers.map(async worker => { + worker.send( + [_types.CHILD_MESSAGE_END, false], + emptyMethod, + emptyMethod, + emptyMethod + ); + + // Schedule a force exit in case worker fails to exit gracefully so + // await worker.waitForExit() never takes longer than FORCE_EXIT_DELAY + let forceExited = false; + const forceExitTimeout = setTimeout(() => { + worker.forceExit(); + forceExited = true; + }, FORCE_EXIT_DELAY); + await worker.waitForExit(); + // Worker ideally exited gracefully, don't send force exit then + clearTimeout(forceExitTimeout); + return forceExited; + }); + const workerExits = await Promise.all(workerExitPromises); + return workerExits.reduce( + (result, forceExited) => ({ + forceExited: result.forceExited || forceExited + }), + { + forceExited: false + } + ); + } +} +exports.default = BaseWorkerPool; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8f25376839df6060786fa173cc4f6753e8f43d4d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/index.d.ts @@ -0,0 +1,355 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/// + +import type {ForkOptions} from 'child_process'; +import type {ResourceLimits} from 'worker_threads'; + +declare const CHILD_MESSAGE_CALL = 1; + +declare const CHILD_MESSAGE_CALL_SETUP = 4; + +declare const CHILD_MESSAGE_END = 2; + +declare const CHILD_MESSAGE_INITIALIZE = 0; + +declare const CHILD_MESSAGE_MEM_USAGE = 3; + +declare type ChildMessage = + | ChildMessageInitialize + | ChildMessageCall + | ChildMessageEnd + | ChildMessageMemUsage + | ChildMessageCallSetup; + +declare type ChildMessageCall = [ + type: typeof CHILD_MESSAGE_CALL, + isProcessed: boolean, + methodName: string, + args: Array, +]; + +declare type ChildMessageCallSetup = [type: typeof CHILD_MESSAGE_CALL_SETUP]; + +declare type ChildMessageEnd = [ + type: typeof CHILD_MESSAGE_END, + isProcessed: boolean, +]; + +declare type ChildMessageInitialize = [ + type: typeof CHILD_MESSAGE_INITIALIZE, + isProcessed: boolean, + fileName: string, + setupArgs: Array, + workerId: string | undefined, +]; + +declare type ChildMessageMemUsage = [type: typeof CHILD_MESSAGE_MEM_USAGE]; + +declare type ComputeTaskPriorityCallback = ( + method: string, + ...args: Array +) => number; + +declare type ExcludeReservedKeys = Exclude; + +/** + * First-in, First-out task queue that manages a dedicated pool + * for each worker as well as a shared queue. The FIFO ordering is guaranteed + * across the worker specific and shared queue. + */ +export declare class FifoQueue implements TaskQueue { + private _workerQueues; + private readonly _sharedQueue; + enqueue(task: QueueChildMessage, workerId?: number): void; + dequeue(workerId: number): QueueChildMessage | null; +} + +declare type FunctionLike = (...args: any) => unknown; + +declare type HeapItem = { + priority: number; +}; + +export declare type JestWorkerFarm> = + Worker_2 & WorkerModule; + +export declare function messageParent( + message: unknown, + parentProcess?: NodeJS.Process, +): void; + +declare type MethodLikeKeys = { + [K in keyof T]: T[K] extends FunctionLike ? K : never; +}[keyof T]; + +declare class MinHeap { + private readonly _heap; + peek(): TItem | null; + add(item: TItem): void; + poll(): TItem | null; +} + +declare type OnCustomMessage = (message: Array | unknown) => void; + +declare type OnEnd = (err: Error | null, result: unknown) => void; + +declare type OnStart = (worker: WorkerInterface) => void; + +declare type OnStateChangeHandler = ( + state: WorkerStates, + oldState: WorkerStates, +) => void; + +declare type PoolExitResult = { + forceExited: boolean; +}; + +/** + * Priority queue that processes tasks in natural ordering (lower priority first) + * according to the priority computed by the function passed in the constructor. + * + * FIFO ordering isn't guaranteed for tasks with the same priority. + * + * Worker specific tasks with the same priority as a non-worker specific task + * are always processed first. + */ +export declare class PriorityQueue implements TaskQueue { + private readonly _computePriority; + private _queue; + private readonly _sharedQueue; + constructor(_computePriority: ComputeTaskPriorityCallback); + enqueue(task: QueueChildMessage, workerId?: number): void; + _enqueue(task: QueueChildMessage, queue: MinHeap): void; + dequeue(workerId: number): QueueChildMessage | null; + _getWorkerQueue(workerId: number): MinHeap; +} + +export declare interface PromiseWithCustomMessage extends Promise { + UNSTABLE_onCustomMessage?: (listener: OnCustomMessage) => () => void; +} + +declare type Promisify = ReturnType extends Promise< + infer R +> + ? (...args: Parameters) => Promise + : (...args: Parameters) => Promise>; + +declare type QueueChildMessage = { + request: ChildMessageCall; + onStart: OnStart; + onEnd: OnEnd; + onCustomMessage: OnCustomMessage; +}; + +declare type QueueItem = { + task: QueueChildMessage; + priority: number; +}; + +declare type ReservedKeys = + | 'end' + | 'getStderr' + | 'getStdout' + | 'setup' + | 'teardown'; + +export declare interface TaskQueue { + /** + * Enqueues the task in the queue for the specified worker or adds it to the + * queue shared by all workers + * @param task the task to queue + * @param workerId the id of the worker that should process this task or undefined + * if there's no preference. + */ + enqueue(task: QueueChildMessage, workerId?: number): void; + /** + * Dequeues the next item from the queue for the specified worker + * @param workerId the id of the worker for which the next task should be retrieved + */ + dequeue(workerId: number): QueueChildMessage | null; +} + +/** + * The Jest farm (publicly called "Worker") is a class that allows you to queue + * methods across multiple child processes, in order to parallelize work. This + * is done by providing an absolute path to a module that will be loaded on each + * of the child processes, and bridged to the main process. + * + * Bridged methods are specified by using the "exposedMethods" property of the + * "options" object. This is an array of strings, where each of them corresponds + * to the exported name in the loaded module. + * + * You can also control the amount of workers by using the "numWorkers" property + * of the "options" object, and the settings passed to fork the process through + * the "forkOptions" property. The amount of workers defaults to the amount of + * CPUS minus one. + * + * Queueing calls can be done in two ways: + * - Standard method: calls will be redirected to the first available worker, + * so they will get executed as soon as they can. + * + * - Sticky method: if a "computeWorkerKey" method is provided within the + * config, the resulting string of this method will be used as a key. + * Every time this key is returned, it is guaranteed that your job will be + * processed by the same worker. This is specially useful if your workers + * are caching results. + */ +declare class Worker_2 { + private _ending; + private readonly _farm; + private readonly _options; + private readonly _workerPool; + constructor(workerPath: string | URL, options?: WorkerFarmOptions); + private _bindExposedWorkerMethods; + private _callFunctionWithArgs; + getStderr(): NodeJS.ReadableStream; + getStdout(): NodeJS.ReadableStream; + start(): Promise; + end(): Promise; +} +export {Worker_2 as Worker}; + +declare type WorkerCallback = ( + workerId: number, + request: ChildMessage, + onStart: OnStart, + onEnd: OnEnd, + onCustomMessage: OnCustomMessage, +) => void; + +declare enum WorkerEvents { + STATE_CHANGE = 'state-change', +} + +export declare type WorkerFarmOptions = { + computeWorkerKey?: (method: string, ...args: Array) => string | null; + enableWorkerThreads?: boolean; + exposedMethods?: ReadonlyArray; + forkOptions?: ForkOptions; + maxRetries?: number; + numWorkers?: number; + resourceLimits?: ResourceLimits; + setupArgs?: Array; + taskQueue?: TaskQueue; + WorkerPool?: new ( + workerPath: string, + options?: WorkerPoolOptions, + ) => WorkerPoolInterface; + workerSchedulingPolicy?: WorkerSchedulingPolicy; + idleMemoryLimit?: number; +}; + +declare interface WorkerInterface { + get state(): WorkerStates; + send( + request: ChildMessage, + onProcessStart: OnStart, + onProcessEnd: OnEnd, + onCustomMessage: OnCustomMessage, + ): void; + waitForExit(): Promise; + forceExit(): void; + getWorkerId(): number; + getStderr(): NodeJS.ReadableStream | null; + getStdout(): NodeJS.ReadableStream | null; + /** + * Some system level identifier for the worker. IE, process id, thread id, etc. + */ + getWorkerSystemId(): number; + getMemoryUsage(): Promise; + /** + * Checks to see if the child worker is actually running. + */ + isWorkerRunning(): boolean; + /** + * When the worker child is started and ready to start handling requests. + * + * @remarks + * This mostly exists to help with testing so that you don't check the status + * of things like isWorkerRunning before it actually is. + */ + waitForWorkerReady(): Promise; +} + +declare type WorkerModule = { + [K in keyof T as Extract< + ExcludeReservedKeys, + MethodLikeKeys + >]: T[K] extends FunctionLike ? Promisify : never; +}; + +declare type WorkerOptions_2 = { + forkOptions: ForkOptions; + resourceLimits: ResourceLimits; + setupArgs: Array; + maxRetries: number; + workerId: number; + workerData?: unknown; + workerPath: string; + /** + * After a job has executed the memory usage it should return to. + * + * @remarks + * Note this is different from ResourceLimits in that it checks at idle, after + * a job is complete. So you could have a resource limit of 500MB but an idle + * limit of 50MB. The latter will only trigger if after a job has completed the + * memory usage hasn't returned back down under 50MB. + */ + idleMemoryLimit?: number; + /** + * This mainly exists so the path can be changed during testing. + * https://github.com/jestjs/jest/issues/9543 + */ + childWorkerPath?: string; + /** + * This is useful for debugging individual tests allowing you to see + * the raw output of the worker. + */ + silent?: boolean; + /** + * Used to immediately bind event handlers. + */ + on?: { + [WorkerEvents.STATE_CHANGE]: + | OnStateChangeHandler + | ReadonlyArray; + }; +}; + +export declare interface WorkerPoolInterface { + getStderr(): NodeJS.ReadableStream; + getStdout(): NodeJS.ReadableStream; + getWorkers(): Array; + createWorker(options: WorkerOptions_2): WorkerInterface; + send: WorkerCallback; + start(): Promise; + end(): Promise; +} + +export declare type WorkerPoolOptions = { + setupArgs: Array; + forkOptions: ForkOptions; + resourceLimits: ResourceLimits; + maxRetries: number; + numWorkers: number; + enableWorkerThreads: boolean; + idleMemoryLimit?: number; +}; + +declare type WorkerSchedulingPolicy = 'round-robin' | 'in-order'; + +declare enum WorkerStates { + STARTING = 'starting', + OK = 'ok', + OUT_OF_MEMORY = 'oom', + RESTARTING = 'restarting', + SHUTTING_DOWN = 'shutting-down', + SHUT_DOWN = 'shut-down', +} + +export {}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..6e840cc2a2655d83001096adbb16931d8041677a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/index.js @@ -0,0 +1,192 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +Object.defineProperty(exports, 'FifoQueue', { + enumerable: true, + get: function () { + return _FifoQueue.default; + } +}); +Object.defineProperty(exports, 'PriorityQueue', { + enumerable: true, + get: function () { + return _PriorityQueue.default; + } +}); +exports.Worker = void 0; +Object.defineProperty(exports, 'messageParent', { + enumerable: true, + get: function () { + return _messageParent.default; + } +}); +function _os() { + const data = require('os'); + _os = function () { + return data; + }; + return data; +} +function _path() { + const data = require('path'); + _path = function () { + return data; + }; + return data; +} +function _url() { + const data = require('url'); + _url = function () { + return data; + }; + return data; +} +var _Farm = _interopRequireDefault(require('./Farm')); +var _WorkerPool = _interopRequireDefault(require('./WorkerPool')); +var _PriorityQueue = _interopRequireDefault(require('./PriorityQueue')); +var _FifoQueue = _interopRequireDefault(require('./FifoQueue')); +var _messageParent = _interopRequireDefault(require('./workers/messageParent')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function getExposedMethods(workerPath, options) { + let exposedMethods = options.exposedMethods; + + // If no methods list is given, try getting it by auto-requiring the module. + if (!exposedMethods) { + const module = require(workerPath); + exposedMethods = Object.keys(module).filter( + name => typeof module[name] === 'function' + ); + if (typeof module === 'function') { + exposedMethods = [...exposedMethods, 'default']; + } + } + return exposedMethods; +} +function getNumberOfCpus() { + return typeof _os().availableParallelism === 'function' + ? (0, _os().availableParallelism)() + : (0, _os().cpus)().length; +} + +/** + * The Jest farm (publicly called "Worker") is a class that allows you to queue + * methods across multiple child processes, in order to parallelize work. This + * is done by providing an absolute path to a module that will be loaded on each + * of the child processes, and bridged to the main process. + * + * Bridged methods are specified by using the "exposedMethods" property of the + * "options" object. This is an array of strings, where each of them corresponds + * to the exported name in the loaded module. + * + * You can also control the amount of workers by using the "numWorkers" property + * of the "options" object, and the settings passed to fork the process through + * the "forkOptions" property. The amount of workers defaults to the amount of + * CPUS minus one. + * + * Queueing calls can be done in two ways: + * - Standard method: calls will be redirected to the first available worker, + * so they will get executed as soon as they can. + * + * - Sticky method: if a "computeWorkerKey" method is provided within the + * config, the resulting string of this method will be used as a key. + * Every time this key is returned, it is guaranteed that your job will be + * processed by the same worker. This is specially useful if your workers + * are caching results. + */ +class Worker { + _ending; + _farm; + _options; + _workerPool; + constructor(workerPath, options) { + this._options = { + ...options + }; + this._ending = false; + if (typeof workerPath !== 'string') { + workerPath = workerPath.href; + } + if (workerPath.startsWith('file:')) { + workerPath = (0, _url().fileURLToPath)(workerPath); + } else if (!(0, _path().isAbsolute)(workerPath)) { + throw new Error(`'workerPath' must be absolute, got '${workerPath}'`); + } + const workerPoolOptions = { + enableWorkerThreads: this._options.enableWorkerThreads ?? false, + forkOptions: this._options.forkOptions ?? {}, + idleMemoryLimit: this._options.idleMemoryLimit, + maxRetries: this._options.maxRetries ?? 3, + numWorkers: + this._options.numWorkers ?? Math.max(getNumberOfCpus() - 1, 1), + resourceLimits: this._options.resourceLimits ?? {}, + setupArgs: this._options.setupArgs ?? [] + }; + if (this._options.WorkerPool) { + this._workerPool = new this._options.WorkerPool( + workerPath, + workerPoolOptions + ); + } else { + this._workerPool = new _WorkerPool.default(workerPath, workerPoolOptions); + } + this._farm = new _Farm.default( + workerPoolOptions.numWorkers, + this._workerPool.send.bind(this._workerPool), + { + computeWorkerKey: this._options.computeWorkerKey, + taskQueue: this._options.taskQueue, + workerSchedulingPolicy: this._options.workerSchedulingPolicy + } + ); + this._bindExposedWorkerMethods(workerPath, this._options); + } + _bindExposedWorkerMethods(workerPath, options) { + getExposedMethods(workerPath, options).forEach(name => { + if (name.startsWith('_')) { + return; + } + + // eslint-disable-next-line no-prototype-builtins + if (this.constructor.prototype.hasOwnProperty(name)) { + throw new TypeError(`Cannot define a method called ${name}`); + } + + // @ts-expect-error: dynamic extension of the class instance is expected. + this[name] = this._callFunctionWithArgs.bind(this, name); + }); + } + _callFunctionWithArgs(method, ...args) { + if (this._ending) { + throw new Error('Farm is ended, no more calls can be done to it'); + } + return this._farm.doWork(method, ...args); + } + getStderr() { + return this._workerPool.getStderr(); + } + getStdout() { + return this._workerPool.getStdout(); + } + async start() { + await this._workerPool.start(); + } + async end() { + if (this._ending) { + throw new Error('Farm is ended, no more calls can be done to it'); + } + this._ending = true; + return this._workerPool.end(); + } +} +exports.Worker = Worker; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/types.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/types.js new file mode 100644 index 0000000000000000000000000000000000000000..feedb0b71bc9c2654c00c828a89ce358deb7edd6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/types.js @@ -0,0 +1,72 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.WorkerStates = + exports.WorkerEvents = + exports.PARENT_MESSAGE_SETUP_ERROR = + exports.PARENT_MESSAGE_OK = + exports.PARENT_MESSAGE_MEM_USAGE = + exports.PARENT_MESSAGE_CUSTOM = + exports.PARENT_MESSAGE_CLIENT_ERROR = + exports.CHILD_MESSAGE_MEM_USAGE = + exports.CHILD_MESSAGE_INITIALIZE = + exports.CHILD_MESSAGE_END = + exports.CHILD_MESSAGE_CALL_SETUP = + exports.CHILD_MESSAGE_CALL = + void 0; +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// Because of the dynamic nature of a worker communication process, all messages +// coming from any of the other processes cannot be typed. Thus, many types +// include "unknown" as a TS type, which is (unfortunately) correct here. + +const CHILD_MESSAGE_INITIALIZE = 0; +exports.CHILD_MESSAGE_INITIALIZE = CHILD_MESSAGE_INITIALIZE; +const CHILD_MESSAGE_CALL = 1; +exports.CHILD_MESSAGE_CALL = CHILD_MESSAGE_CALL; +const CHILD_MESSAGE_END = 2; +exports.CHILD_MESSAGE_END = CHILD_MESSAGE_END; +const CHILD_MESSAGE_MEM_USAGE = 3; +exports.CHILD_MESSAGE_MEM_USAGE = CHILD_MESSAGE_MEM_USAGE; +const CHILD_MESSAGE_CALL_SETUP = 4; +exports.CHILD_MESSAGE_CALL_SETUP = CHILD_MESSAGE_CALL_SETUP; +const PARENT_MESSAGE_OK = 0; +exports.PARENT_MESSAGE_OK = PARENT_MESSAGE_OK; +const PARENT_MESSAGE_CLIENT_ERROR = 1; +exports.PARENT_MESSAGE_CLIENT_ERROR = PARENT_MESSAGE_CLIENT_ERROR; +const PARENT_MESSAGE_SETUP_ERROR = 2; +exports.PARENT_MESSAGE_SETUP_ERROR = PARENT_MESSAGE_SETUP_ERROR; +const PARENT_MESSAGE_CUSTOM = 3; +exports.PARENT_MESSAGE_CUSTOM = PARENT_MESSAGE_CUSTOM; +const PARENT_MESSAGE_MEM_USAGE = 4; + +// Option objects. + +// Messages passed from the parent to the children. + +// Messages passed from the children to the parent. + +// Queue types. +exports.PARENT_MESSAGE_MEM_USAGE = PARENT_MESSAGE_MEM_USAGE; +let WorkerStates = /*#__PURE__*/ (function (WorkerStates) { + WorkerStates['STARTING'] = 'starting'; + WorkerStates['OK'] = 'ok'; + WorkerStates['OUT_OF_MEMORY'] = 'oom'; + WorkerStates['RESTARTING'] = 'restarting'; + WorkerStates['SHUTTING_DOWN'] = 'shutting-down'; + WorkerStates['SHUT_DOWN'] = 'shut-down'; + return WorkerStates; +})({}); +exports.WorkerStates = WorkerStates; +let WorkerEvents = /*#__PURE__*/ (function (WorkerEvents) { + WorkerEvents['STATE_CHANGE'] = 'state-change'; + return WorkerEvents; +})({}); +exports.WorkerEvents = WorkerEvents; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/workers/ChildProcessWorker.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/workers/ChildProcessWorker.js new file mode 100644 index 0000000000000000000000000000000000000000..6a9d1f369ba05a7891793baf29d48b6e49946ff6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/workers/ChildProcessWorker.js @@ -0,0 +1,490 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = exports.SIGKILL_DELAY = void 0; +function _child_process() { + const data = require('child_process'); + _child_process = function () { + return data; + }; + return data; +} +function _os() { + const data = require('os'); + _os = function () { + return data; + }; + return data; +} +function _mergeStream() { + const data = _interopRequireDefault(require('merge-stream')); + _mergeStream = function () { + return data; + }; + return data; +} +function _supportsColor() { + const data = require('supports-color'); + _supportsColor = function () { + return data; + }; + return data; +} +var _types = require('../types'); +var _WorkerAbstract = _interopRequireDefault(require('./WorkerAbstract')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +const SIGNAL_BASE_EXIT_CODE = 128; +const SIGKILL_EXIT_CODE = SIGNAL_BASE_EXIT_CODE + 9; +const SIGTERM_EXIT_CODE = SIGNAL_BASE_EXIT_CODE + 15; + +// How long to wait after SIGTERM before sending SIGKILL +const SIGKILL_DELAY = 500; + +/** + * This class wraps the child process and provides a nice interface to + * communicate with. It takes care of: + * + * - Re-spawning the process if it dies. + * - Queues calls while the worker is busy. + * - Re-sends the requests if the worker blew up. + * + * The reason for queueing them here (since childProcess.send also has an + * internal queue) is because the worker could be doing asynchronous work, and + * this would lead to the child process to read its receiving buffer and start a + * second call. By queueing calls here, we don't send the next call to the + * children until we receive the result of the previous one. + * + * As soon as a request starts to be processed by a worker, its "processed" + * field is changed to "true", so that other workers which might encounter the + * same call skip it. + */ +exports.SIGKILL_DELAY = SIGKILL_DELAY; +class ChildProcessWorker extends _WorkerAbstract.default { + _child; + _options; + _request; + _retries; + _onProcessEnd; + _onCustomMessage; + _stdout; + _stderr; + _stderrBuffer = []; + _memoryUsagePromise; + _resolveMemoryUsage; + _childIdleMemoryUsage; + _childIdleMemoryUsageLimit; + _memoryUsageCheck = false; + _childWorkerPath; + constructor(options) { + super(options); + this._options = options; + this._request = null; + this._stdout = null; + this._stderr = null; + this._childIdleMemoryUsage = null; + this._childIdleMemoryUsageLimit = options.idleMemoryLimit || null; + this._childWorkerPath = + options.childWorkerPath || require.resolve('./processChild'); + this.state = _types.WorkerStates.STARTING; + this.initialize(); + } + initialize() { + if ( + this.state === _types.WorkerStates.OUT_OF_MEMORY || + this.state === _types.WorkerStates.SHUTTING_DOWN || + this.state === _types.WorkerStates.SHUT_DOWN + ) { + return; + } + if (this._child && this._child.connected) { + this._child.kill('SIGKILL'); + } + this.state = _types.WorkerStates.STARTING; + const forceColor = _supportsColor().stdout + ? { + FORCE_COLOR: '1' + } + : {}; + const silent = this._options.silent ?? true; + if (!silent) { + // NOTE: Detecting an out of memory crash is independent of idle memory usage monitoring. We want to + // monitor for a crash occurring so that it can be handled as required and so we can tell the difference + // between an OOM crash and another kind of crash. We need to do this because if a worker crashes due to + // an OOM event sometimes it isn't seen by the worker pool and it just sits there waiting for the worker + // to respond and it never will. + console.warn('Unable to detect out of memory event if silent === false'); + } + this._stderrBuffer = []; + const options = { + cwd: process.cwd(), + env: { + ...process.env, + JEST_WORKER_ID: String(this._options.workerId + 1), + // 0-indexed workerId, 1-indexed JEST_WORKER_ID + ...forceColor + }, + // Suppress --debug / --inspect flags while preserving others (like --harmony). + execArgv: process.execArgv.filter(v => !/^--(debug|inspect)/.test(v)), + // default to advanced serialization in order to match worker threads + serialization: 'advanced', + silent, + ...this._options.forkOptions + }; + this._child = (0, _child_process().fork)( + this._childWorkerPath, + [], + options + ); + if (this._child.stdout) { + if (!this._stdout) { + // We need to add a permanent stream to the merged stream to prevent it + // from ending when the subprocess stream ends + this._stdout = (0, _mergeStream().default)(this._getFakeStream()); + } + this._stdout.add(this._child.stdout); + } + if (this._child.stderr) { + if (!this._stderr) { + // We need to add a permanent stream to the merged stream to prevent it + // from ending when the subprocess stream ends + this._stderr = (0, _mergeStream().default)(this._getFakeStream()); + } + this._stderr.add(this._child.stderr); + this._child.stderr.on('data', this.stderrDataHandler.bind(this)); + } + this._child.on('message', this._onMessage.bind(this)); + this._child.on('exit', this._onExit.bind(this)); + this._child.on('disconnect', this._onDisconnect.bind(this)); + this._child.send([ + _types.CHILD_MESSAGE_INITIALIZE, + false, + this._options.workerPath, + this._options.setupArgs + ]); + this._retries++; + + // If we exceeded the amount of retries, we will emulate an error reply + // coming from the child. This avoids code duplication related with cleaning + // the queue, and scheduling the next call. + if (this._retries > this._options.maxRetries) { + const error = new Error( + `Jest worker encountered ${this._retries} child process exceptions, exceeding retry limit` + ); + this._onMessage([ + _types.PARENT_MESSAGE_CLIENT_ERROR, + error.name, + error.message, + error.stack, + { + type: 'WorkerError' + } + ]); + + // Clear the request so we don't keep executing it. + this._request = null; + } + this.state = _types.WorkerStates.OK; + if (this._resolveWorkerReady) { + this._resolveWorkerReady(); + } + } + stderrDataHandler(chunk) { + if (chunk) { + this._stderrBuffer.push(Buffer.from(chunk)); + } + this._detectOutOfMemoryCrash(); + if (this.state === _types.WorkerStates.OUT_OF_MEMORY) { + this._workerReadyPromise = undefined; + this._resolveWorkerReady = undefined; + this.killChild(); + this._shutdown(); + } + } + _detectOutOfMemoryCrash() { + try { + const bufferStr = Buffer.concat(this._stderrBuffer).toString('utf8'); + if ( + bufferStr.includes('heap out of memory') || + bufferStr.includes('allocation failure;') || + bufferStr.includes('Last few GCs') + ) { + if ( + this.state === _types.WorkerStates.OK || + this.state === _types.WorkerStates.STARTING + ) { + this.state = _types.WorkerStates.OUT_OF_MEMORY; + } + } + } catch (err) { + console.error('Error looking for out of memory crash', err); + } + } + _onDisconnect() { + this._workerReadyPromise = undefined; + this._resolveWorkerReady = undefined; + this._detectOutOfMemoryCrash(); + if (this.state === _types.WorkerStates.OUT_OF_MEMORY) { + this.killChild(); + this._shutdown(); + } + } + _onMessage(response) { + // Ignore messages not intended for us + if (!Array.isArray(response)) return; + + // TODO: Add appropriate type check + let error; + switch (response[0]) { + case _types.PARENT_MESSAGE_OK: + this._onProcessEnd(null, response[1]); + break; + case _types.PARENT_MESSAGE_CLIENT_ERROR: + error = response[4]; + if (error != null && typeof error === 'object') { + const extra = error; + // @ts-expect-error: no index + const NativeCtor = globalThis[response[1]]; + const Ctor = typeof NativeCtor === 'function' ? NativeCtor : Error; + error = new Ctor(response[2]); + error.type = response[1]; + error.stack = response[3]; + for (const key in extra) { + error[key] = extra[key]; + } + } + this._onProcessEnd(error, null); + break; + case _types.PARENT_MESSAGE_SETUP_ERROR: + error = new Error(`Error when calling setup: ${response[2]}`); + error.type = response[1]; + error.stack = response[3]; + this._onProcessEnd(error, null); + break; + case _types.PARENT_MESSAGE_CUSTOM: + this._onCustomMessage(response[1]); + break; + case _types.PARENT_MESSAGE_MEM_USAGE: + this._childIdleMemoryUsage = response[1]; + if (this._resolveMemoryUsage) { + this._resolveMemoryUsage(response[1]); + this._resolveMemoryUsage = undefined; + this._memoryUsagePromise = undefined; + } + this._performRestartIfRequired(); + break; + default: + // Ignore messages not intended for us + break; + } + } + _performRestartIfRequired() { + if (this._memoryUsageCheck) { + this._memoryUsageCheck = false; + let limit = this._childIdleMemoryUsageLimit; + + // TODO: At some point it would make sense to make use of + // stringToBytes found in jest-config, however as this + // package does not have any dependencies on an other jest + // packages that can wait until some other time. + if (limit && limit > 0 && limit <= 1) { + limit = Math.floor((0, _os().totalmem)() * limit); + } else if (limit) { + limit = Math.floor(limit); + } + if ( + limit && + this._childIdleMemoryUsage && + this._childIdleMemoryUsage > limit + ) { + this.state = _types.WorkerStates.RESTARTING; + this.killChild(); + } + } + } + _onExit(exitCode, signal) { + this._workerReadyPromise = undefined; + this._resolveWorkerReady = undefined; + this._detectOutOfMemoryCrash(); + if (exitCode !== 0 && this.state === _types.WorkerStates.OUT_OF_MEMORY) { + this._onProcessEnd( + new Error('Jest worker ran out of memory and crashed'), + null + ); + this._shutdown(); + } else if ( + (exitCode !== 0 && + exitCode !== null && + exitCode !== SIGTERM_EXIT_CODE && + exitCode !== SIGKILL_EXIT_CODE && + this.state !== _types.WorkerStates.SHUTTING_DOWN) || + this.state === _types.WorkerStates.RESTARTING + ) { + this.state = _types.WorkerStates.RESTARTING; + this.initialize(); + if (this._request) { + this._child.send(this._request); + } + } else { + // At this point, it's not clear why the child process exited. There could + // be several reasons: + // + // 1. The child process exited successfully after finishing its work. + // This is the most likely case. + // 2. The child process crashed in a manner that wasn't caught through + // any of the heuristic-based checks above. + // 3. The child process was killed by another process or daemon unrelated + // to Jest. For example, oom-killer on Linux may have picked the child + // process to kill because overall system memory is constrained. + // + // If there's a pending request to the child process in any of those + // situations, the request still needs to be handled in some manner before + // entering the shutdown phase. Otherwise the caller expecting a response + // from the worker will never receive indication that something unexpected + // happened and hang forever. + // + // In normal operation, the request is handled and cleared before the + // child process exits. If it's still present, it's not clear what + // happened and probably best to throw an error. In practice, this usually + // happens when the child process is killed externally. + // + // There's a reasonable argument that the child process should be retried + // with request re-sent in this scenario. However, if the problem was due + // to situations such as oom-killer attempting to free up system + // resources, retrying would exacerbate the problem. + const isRequestStillPending = !!this._request; + if (isRequestStillPending) { + // If a signal is present, we can be reasonably confident the process + // was killed externally. Log this fact so it's more clear to users that + // something went wrong externally, rather than a bug in Jest itself. + const error = new Error( + signal != null + ? `A jest worker process (pid=${this._child.pid}) was terminated by another process: signal=${signal}, exitCode=${exitCode}. Operating system logs may contain more information on why this occurred.` + : `A jest worker process (pid=${this._child.pid}) crashed for an unknown reason: exitCode=${exitCode}` + ); + this._onProcessEnd(error, null); + } + this._shutdown(); + } + } + send(request, onProcessStart, onProcessEnd, onCustomMessage) { + this._stderrBuffer = []; + onProcessStart(this); + this._onProcessEnd = (...args) => { + const hasRequest = !!this._request; + + // Clean the request to avoid sending past requests to workers that fail + // while waiting for a new request (timers, unhandled rejections...) + this._request = null; + if ( + this._childIdleMemoryUsageLimit && + this._child.connected && + hasRequest + ) { + this.checkMemoryUsage(); + } + return onProcessEnd(...args); + }; + this._onCustomMessage = (...arg) => onCustomMessage(...arg); + this._request = request; + this._retries = 0; + // eslint-disable-next-line @typescript-eslint/no-empty-function + this._child.send(request, () => {}); + } + waitForExit() { + return this._exitPromise; + } + killChild() { + // We store a reference so that there's no way we can accidentally + // kill a new worker that has been spawned. + const childToKill = this._child; + childToKill.kill('SIGTERM'); + return setTimeout(() => childToKill.kill('SIGKILL'), SIGKILL_DELAY); + } + forceExit() { + this.state = _types.WorkerStates.SHUTTING_DOWN; + const sigkillTimeout = this.killChild(); + this._exitPromise.then(() => clearTimeout(sigkillTimeout)); + } + getWorkerId() { + return this._options.workerId; + } + + /** + * Gets the process id of the worker. + * + * @returns Process id. + */ + getWorkerSystemId() { + return this._child.pid; + } + getStdout() { + return this._stdout; + } + getStderr() { + return this._stderr; + } + + /** + * Gets the last reported memory usage. + * + * @returns Memory usage in bytes. + */ + getMemoryUsage() { + if (!this._memoryUsagePromise) { + let rejectCallback; + const promise = new Promise((resolve, reject) => { + this._resolveMemoryUsage = resolve; + rejectCallback = reject; + }); + this._memoryUsagePromise = promise; + if (!this._child.connected && rejectCallback) { + rejectCallback(new Error('Child process is not running.')); + this._memoryUsagePromise = undefined; + this._resolveMemoryUsage = undefined; + return promise; + } + this._child.send([_types.CHILD_MESSAGE_MEM_USAGE], err => { + if (err && rejectCallback) { + this._memoryUsagePromise = undefined; + this._resolveMemoryUsage = undefined; + rejectCallback(err); + } + }); + return promise; + } + return this._memoryUsagePromise; + } + + /** + * Gets updated memory usage and restarts if required + */ + checkMemoryUsage() { + if (this._childIdleMemoryUsageLimit) { + this._memoryUsageCheck = true; + this._child.send([_types.CHILD_MESSAGE_MEM_USAGE], err => { + if (err) { + console.error('Unable to check memory usage', err); + } + }); + } else { + console.warn( + 'Memory usage of workers can only be checked if a limit is set' + ); + } + } + isWorkerRunning() { + return this._child.connected && !this._child.killed; + } +} +exports.default = ChildProcessWorker; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/workers/NodeThreadsWorker.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/workers/NodeThreadsWorker.js new file mode 100644 index 0000000000000000000000000000000000000000..e25247a6ddc65fe9a91eb36aae37657de8b6e8c6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/workers/NodeThreadsWorker.js @@ -0,0 +1,359 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _os() { + const data = require('os'); + _os = function () { + return data; + }; + return data; +} +function _worker_threads() { + const data = require('worker_threads'); + _worker_threads = function () { + return data; + }; + return data; +} +function _mergeStream() { + const data = _interopRequireDefault(require('merge-stream')); + _mergeStream = function () { + return data; + }; + return data; +} +var _types = require('../types'); +var _WorkerAbstract = _interopRequireDefault(require('./WorkerAbstract')); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class ExperimentalWorker extends _WorkerAbstract.default { + _worker; + _options; + _request; + _retries; + _onProcessEnd; + _onCustomMessage; + _stdout; + _stderr; + _memoryUsagePromise; + _resolveMemoryUsage; + _childWorkerPath; + _childIdleMemoryUsage; + _childIdleMemoryUsageLimit; + _memoryUsageCheck = false; + constructor(options) { + super(options); + this._options = options; + this._request = null; + this._stdout = null; + this._stderr = null; + this._childWorkerPath = + options.childWorkerPath || require.resolve('./threadChild'); + this._childIdleMemoryUsage = null; + this._childIdleMemoryUsageLimit = options.idleMemoryLimit || null; + this.initialize(); + } + initialize() { + if ( + this.state === _types.WorkerStates.OUT_OF_MEMORY || + this.state === _types.WorkerStates.SHUTTING_DOWN || + this.state === _types.WorkerStates.SHUT_DOWN + ) { + return; + } + if (this._worker) { + this._worker.terminate(); + } + this.state = _types.WorkerStates.STARTING; + this._worker = new (_worker_threads().Worker)(this._childWorkerPath, { + eval: false, + resourceLimits: this._options.resourceLimits, + stderr: true, + stdout: true, + workerData: this._options.workerData, + ...this._options.forkOptions + }); + if (this._worker.stdout) { + if (!this._stdout) { + // We need to add a permanent stream to the merged stream to prevent it + // from ending when the subprocess stream ends + this._stdout = (0, _mergeStream().default)(this._getFakeStream()); + } + this._stdout.add(this._worker.stdout); + } + if (this._worker.stderr) { + if (!this._stderr) { + // We need to add a permanent stream to the merged stream to prevent it + // from ending when the subprocess stream ends + this._stderr = (0, _mergeStream().default)(this._getFakeStream()); + } + this._stderr.add(this._worker.stderr); + } + + // This can be useful for debugging. + if (!(this._options.silent ?? true)) { + this._worker.stdout.setEncoding('utf8'); + // eslint-disable-next-line no-console + this._worker.stdout.on('data', console.log); + this._worker.stderr.setEncoding('utf8'); + this._worker.stderr.on('data', console.error); + } + this._worker.on('message', this._onMessage.bind(this)); + this._worker.on('exit', this._onExit.bind(this)); + this._worker.on('error', this._onError.bind(this)); + this._worker.postMessage([ + _types.CHILD_MESSAGE_INITIALIZE, + false, + this._options.workerPath, + this._options.setupArgs, + String(this._options.workerId + 1) // 0-indexed workerId, 1-indexed JEST_WORKER_ID + ]); + + this._retries++; + + // If we exceeded the amount of retries, we will emulate an error reply + // coming from the child. This avoids code duplication related with cleaning + // the queue, and scheduling the next call. + if (this._retries > this._options.maxRetries) { + const error = new Error('Call retries were exceeded'); + this._onMessage([ + _types.PARENT_MESSAGE_CLIENT_ERROR, + error.name, + error.message, + error.stack, + { + type: 'WorkerError' + } + ]); + } + this.state = _types.WorkerStates.OK; + if (this._resolveWorkerReady) { + this._resolveWorkerReady(); + } + } + _onError(error) { + if (error.message.includes('heap out of memory')) { + this.state = _types.WorkerStates.OUT_OF_MEMORY; + + // Threads don't behave like processes, they don't crash when they run out of + // memory. But for consistency we want them to behave like processes so we call + // terminate to simulate a crash happening that was not planned + this._worker.terminate(); + } + } + _onMessage(response) { + // Ignore messages not intended for us + if (!Array.isArray(response)) return; + let error; + switch (response[0]) { + case _types.PARENT_MESSAGE_OK: + this._onProcessEnd(null, response[1]); + break; + case _types.PARENT_MESSAGE_CLIENT_ERROR: + error = response[4]; + if (error != null && typeof error === 'object') { + const extra = error; + // @ts-expect-error: no index + const NativeCtor = globalThis[response[1]]; + const Ctor = typeof NativeCtor === 'function' ? NativeCtor : Error; + error = new Ctor(response[2]); + error.type = response[1]; + error.stack = response[3]; + for (const key in extra) { + // @ts-expect-error: no index + error[key] = extra[key]; + } + } + this._onProcessEnd(error, null); + break; + case _types.PARENT_MESSAGE_SETUP_ERROR: + error = new Error(`Error when calling setup: ${response[2]}`); + + // @ts-expect-error: adding custom properties to errors. + error.type = response[1]; + error.stack = response[3]; + this._onProcessEnd(error, null); + break; + case _types.PARENT_MESSAGE_CUSTOM: + this._onCustomMessage(response[1]); + break; + case _types.PARENT_MESSAGE_MEM_USAGE: + this._childIdleMemoryUsage = response[1]; + if (this._resolveMemoryUsage) { + this._resolveMemoryUsage(response[1]); + this._resolveMemoryUsage = undefined; + this._memoryUsagePromise = undefined; + } + this._performRestartIfRequired(); + break; + default: + // Ignore messages not intended for us + break; + } + } + _onExit(exitCode) { + this._workerReadyPromise = undefined; + this._resolveWorkerReady = undefined; + if (exitCode !== 0 && this.state === _types.WorkerStates.OUT_OF_MEMORY) { + this._onProcessEnd( + new Error('Jest worker ran out of memory and crashed'), + null + ); + this._shutdown(); + } else if ( + (exitCode !== 0 && + this.state !== _types.WorkerStates.SHUTTING_DOWN && + this.state !== _types.WorkerStates.SHUT_DOWN) || + this.state === _types.WorkerStates.RESTARTING + ) { + this.initialize(); + if (this._request) { + this._worker.postMessage(this._request); + } + } else { + // If the worker thread exits while a request is still pending, throw an + // error. This is unexpected and tests may not have run to completion. + const isRequestStillPending = !!this._request; + if (isRequestStillPending) { + this._onProcessEnd( + new Error( + 'A Jest worker thread exited unexpectedly before finishing tests for an unknown reason. One of the ways this can happen is if process.exit() was called in testing code.' + ), + null + ); + } + this._shutdown(); + } + } + waitForExit() { + return this._exitPromise; + } + forceExit() { + this.state = _types.WorkerStates.SHUTTING_DOWN; + this._worker.terminate(); + } + send(request, onProcessStart, onProcessEnd, onCustomMessage) { + onProcessStart(this); + this._onProcessEnd = (...args) => { + const hasRequest = !!this._request; + + // Clean the request to avoid sending past requests to workers that fail + // while waiting for a new request (timers, unhandled rejections...) + this._request = null; + if (this._childIdleMemoryUsageLimit && hasRequest) { + this.checkMemoryUsage(); + } + const res = onProcessEnd?.(...args); + + // Clean up the reference so related closures can be garbage collected. + onProcessEnd = null; + return res; + }; + this._onCustomMessage = (...arg) => onCustomMessage(...arg); + this._request = request; + this._retries = 0; + this._worker.postMessage(request); + } + getWorkerId() { + return this._options.workerId; + } + getStdout() { + return this._stdout; + } + getStderr() { + return this._stderr; + } + _performRestartIfRequired() { + if (this._memoryUsageCheck) { + this._memoryUsageCheck = false; + let limit = this._childIdleMemoryUsageLimit; + + // TODO: At some point it would make sense to make use of + // stringToBytes found in jest-config, however as this + // package does not have any dependencies on an other jest + // packages that can wait until some other time. + if (limit && limit > 0 && limit <= 1) { + limit = Math.floor((0, _os().totalmem)() * limit); + } else if (limit) { + limit = Math.floor(limit); + } + if ( + limit && + this._childIdleMemoryUsage && + this._childIdleMemoryUsage > limit + ) { + this.state = _types.WorkerStates.RESTARTING; + this._worker.terminate(); + } + } + } + + /** + * Gets the last reported memory usage. + * + * @returns Memory usage in bytes. + */ + getMemoryUsage() { + if (!this._memoryUsagePromise) { + let rejectCallback; + const promise = new Promise((resolve, reject) => { + this._resolveMemoryUsage = resolve; + rejectCallback = reject; + }); + this._memoryUsagePromise = promise; + if (!this._worker.threadId) { + rejectCallback(new Error('Child process is not running.')); + this._memoryUsagePromise = undefined; + this._resolveMemoryUsage = undefined; + return promise; + } + try { + this._worker.postMessage([_types.CHILD_MESSAGE_MEM_USAGE]); + } catch (err) { + this._memoryUsagePromise = undefined; + this._resolveMemoryUsage = undefined; + rejectCallback(err); + } + return promise; + } + return this._memoryUsagePromise; + } + + /** + * Gets updated memory usage and restarts if required + */ + checkMemoryUsage() { + if (this._childIdleMemoryUsageLimit) { + this._memoryUsageCheck = true; + this._worker.postMessage([_types.CHILD_MESSAGE_MEM_USAGE]); + } else { + console.warn( + 'Memory usage of workers can only be checked if a limit is set' + ); + } + } + + /** + * Gets the thread id of the worker. + * + * @returns Thread id. + */ + getWorkerSystemId() { + return this._worker.threadId; + } + isWorkerRunning() { + return this._worker.threadId >= 0; + } +} +exports.default = ExperimentalWorker; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/workers/WorkerAbstract.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/workers/WorkerAbstract.js new file mode 100644 index 0000000000000000000000000000000000000000..1bd32f52a215464659b169d6839329324bfc8cd3 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/workers/WorkerAbstract.js @@ -0,0 +1,135 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; +function _stream() { + const data = require('stream'); + _stream = function () { + return data; + }; + return data; +} +var _types = require('../types'); +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +class WorkerAbstract extends _stream().EventEmitter { + /** + * DO NOT WRITE TO THIS DIRECTLY. + * Use this.state getter/setters so events are emitted correctly. + */ + #state = _types.WorkerStates.STARTING; + _fakeStream = null; + _exitPromise; + _resolveExitPromise; + _workerReadyPromise; + _resolveWorkerReady; + get state() { + return this.#state; + } + set state(value) { + if (this.#state !== value) { + const oldState = this.#state; + this.#state = value; + this.emit(_types.WorkerEvents.STATE_CHANGE, value, oldState); + } + } + constructor(options) { + super(); + if (typeof options.on === 'object') { + for (const [event, handlers] of Object.entries(options.on)) { + // Can't do Array.isArray on a ReadonlyArray. + // https://github.com/microsoft/TypeScript/issues/17002 + if (typeof handlers === 'function') { + super.on(event, handlers); + } else { + for (const handler of handlers) { + super.on(event, handler); + } + } + } + } + this._exitPromise = new Promise(resolve => { + this._resolveExitPromise = resolve; + }); + this._exitPromise.then(() => { + this.state = _types.WorkerStates.SHUT_DOWN; + }); + } + + /** + * Wait for the worker child process to be ready to handle requests. + * + * @returns Promise which resolves when ready. + */ + waitForWorkerReady() { + if (!this._workerReadyPromise) { + this._workerReadyPromise = new Promise((resolve, reject) => { + let settled = false; + let to; + switch (this.state) { + case _types.WorkerStates.OUT_OF_MEMORY: + case _types.WorkerStates.SHUTTING_DOWN: + case _types.WorkerStates.SHUT_DOWN: + settled = true; + reject( + new Error( + `Worker state means it will never be ready: ${this.state}` + ) + ); + break; + case _types.WorkerStates.STARTING: + case _types.WorkerStates.RESTARTING: + this._resolveWorkerReady = () => { + settled = true; + resolve(); + if (to) { + clearTimeout(to); + } + }; + break; + case _types.WorkerStates.OK: + settled = true; + resolve(); + break; + } + if (!settled) { + to = setTimeout(() => { + if (!settled) { + reject(new Error('Timeout starting worker')); + } + }, 500); + } + }); + } + return this._workerReadyPromise; + } + + /** + * Used to shut down the current working instance once the children have been + * killed off. + */ + _shutdown() { + this.state === _types.WorkerStates.SHUT_DOWN; + + // End the permanent stream so the merged stream end too + if (this._fakeStream) { + this._fakeStream.end(); + this._fakeStream = null; + } + this._resolveExitPromise(); + } + _getFakeStream() { + if (!this._fakeStream) { + this._fakeStream = new (_stream().PassThrough)(); + } + return this._fakeStream; + } +} +exports.default = WorkerAbstract; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/workers/messageParent.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/workers/messageParent.js new file mode 100644 index 0000000000000000000000000000000000000000..62e2ccec5716b6909dbb9a41081d4f9a7dcd364f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/workers/messageParent.js @@ -0,0 +1,33 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = messageParent; +function _worker_threads() { + const data = require('worker_threads'); + _worker_threads = function () { + return data; + }; + return data; +} +var _types = require('../types'); +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function messageParent(message, parentProcess = process) { + if (!_worker_threads().isMainThread && _worker_threads().parentPort != null) { + _worker_threads().parentPort.postMessage([ + _types.PARENT_MESSAGE_CUSTOM, + message + ]); + } else if (typeof parentProcess.send === 'function') { + parentProcess.send([_types.PARENT_MESSAGE_CUSTOM, message]); + } else { + throw new Error('"messageParent" can only be used inside a worker'); + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/workers/processChild.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/workers/processChild.js new file mode 100644 index 0000000000000000000000000000000000000000..1a47f23c1b4fe56a3504d25e99514ed4218ae7a2 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/workers/processChild.js @@ -0,0 +1,159 @@ +'use strict'; + +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +var _types = require('../types'); +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +let file = null; +let setupArgs = []; +let initialized = false; + +/** + * This file is a small bootstrapper for workers. It sets up the communication + * between the worker and the parent process, interpreting parent messages and + * sending results back. + * + * The file loaded will be lazily initialized the first time any of the workers + * is called. This is done for optimal performance: if the farm is initialized, + * but no call is made to it, child Node processes will be consuming the least + * possible amount of memory. + * + * If an invalid message is detected, the child will exit (by throwing) with a + * non-zero exit code. + */ +const messageListener = request => { + switch (request[0]) { + case _types.CHILD_MESSAGE_INITIALIZE: + const init = request; + file = init[2]; + setupArgs = init[3]; + break; + case _types.CHILD_MESSAGE_CALL: + const call = request; + execMethod(call[2], call[3]); + break; + case _types.CHILD_MESSAGE_END: + end(); + break; + case _types.CHILD_MESSAGE_MEM_USAGE: + reportMemoryUsage(); + break; + case _types.CHILD_MESSAGE_CALL_SETUP: + if (initialized) { + reportSuccess(void 0); + } else { + const main = require(file); + initialized = true; + if (main.setup) { + execFunction( + main.setup, + main, + setupArgs, + reportSuccess, + reportInitializeError + ); + } else { + reportSuccess(void 0); + } + } + break; + default: + throw new TypeError( + `Unexpected request from parent process: ${request[0]}` + ); + } +}; +process.on('message', messageListener); +function reportSuccess(result) { + if (!process || !process.send) { + throw new Error('Child can only be used on a forked process'); + } + process.send([_types.PARENT_MESSAGE_OK, result]); +} +function reportClientError(error) { + return reportError(error, _types.PARENT_MESSAGE_CLIENT_ERROR); +} +function reportInitializeError(error) { + return reportError(error, _types.PARENT_MESSAGE_SETUP_ERROR); +} +function reportMemoryUsage() { + if (!process || !process.send) { + throw new Error('Child can only be used on a forked process'); + } + const msg = [_types.PARENT_MESSAGE_MEM_USAGE, process.memoryUsage().heapUsed]; + process.send(msg); +} +function reportError(error, type) { + if (!process || !process.send) { + throw new Error('Child can only be used on a forked process'); + } + if (error == null) { + error = new Error('"null" or "undefined" thrown'); + } + process.send([ + type, + error.constructor && error.constructor.name, + error.message, + error.stack, + typeof error === 'object' + ? { + ...error + } + : error + ]); +} +function end() { + const main = require(file); + if (!main.teardown) { + exitProcess(); + return; + } + execFunction(main.teardown, main, [], exitProcess, exitProcess); +} +function exitProcess() { + // Clean up open handles so the process ideally exits gracefully + process.removeListener('message', messageListener); +} +function execMethod(method, args) { + const main = require(file); + let fn; + if (method === 'default') { + fn = main.__esModule ? main.default : main; + } else { + fn = main[method]; + } + function execHelper() { + execFunction(fn, main, args, reportSuccess, reportClientError); + } + if (initialized || !main.setup) { + execHelper(); + return; + } + initialized = true; + execFunction(main.setup, main, setupArgs, execHelper, reportInitializeError); +} +function execFunction(fn, ctx, args, onResult, onError) { + let result; + try { + result = fn.apply(ctx, args); + } catch (err) { + onError(err); + return; + } + if ((0, _jestUtil().isPromise)(result)) { + result.then(onResult, onError); + } else { + onResult(result); + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/workers/threadChild.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/workers/threadChild.js new file mode 100644 index 0000000000000000000000000000000000000000..16aca004efd020a1456354299a3a606cdf0e4bc7 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/build/workers/threadChild.js @@ -0,0 +1,177 @@ +'use strict'; + +function _worker_threads() { + const data = require('worker_threads'); + _worker_threads = function () { + return data; + }; + return data; +} +function _jestUtil() { + const data = require('jest-util'); + _jestUtil = function () { + return data; + }; + return data; +} +var _types = require('../types'); +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +let file = null; +let setupArgs = []; +let initialized = false; + +/** + * This file is a small bootstrapper for workers. It sets up the communication + * between the worker and the parent process, interpreting parent messages and + * sending results back. + * + * The file loaded will be lazily initialized the first time any of the workers + * is called. This is done for optimal performance: if the farm is initialized, + * but no call is made to it, child Node processes will be consuming the least + * possible amount of memory. + * + * If an invalid message is detected, the child will exit (by throwing) with a + * non-zero exit code. + */ +const messageListener = request => { + switch (request[0]) { + case _types.CHILD_MESSAGE_INITIALIZE: + const init = request; + file = init[2]; + setupArgs = init[3]; + process.env.JEST_WORKER_ID = init[4]; + break; + case _types.CHILD_MESSAGE_CALL: + const call = request; + execMethod(call[2], call[3]); + break; + case _types.CHILD_MESSAGE_END: + end(); + break; + case _types.CHILD_MESSAGE_MEM_USAGE: + reportMemoryUsage(); + break; + case _types.CHILD_MESSAGE_CALL_SETUP: + if (initialized) { + reportSuccess(void 0); + } else { + const main = require(file); + initialized = true; + if (main.setup) { + execFunction( + main.setup, + main, + setupArgs, + reportSuccess, + reportInitializeError + ); + } else { + reportSuccess(void 0); + } + } + break; + default: + throw new TypeError( + `Unexpected request from parent process: ${request[0]}` + ); + } +}; +_worker_threads().parentPort.on('message', messageListener); +function reportMemoryUsage() { + if (_worker_threads().isMainThread) { + throw new Error('Child can only be used on a forked process'); + } + const msg = [_types.PARENT_MESSAGE_MEM_USAGE, process.memoryUsage().heapUsed]; + _worker_threads().parentPort.postMessage(msg); +} +function reportSuccess(result) { + if (_worker_threads().isMainThread) { + throw new Error('Child can only be used on a forked process'); + } + try { + _worker_threads().parentPort.postMessage([ + _types.PARENT_MESSAGE_OK, + result + ]); + } catch (err) { + // Handling it here to avoid unhandled `DataCloneError` rejection + // which is hard to distinguish on the parent side + // (such error doesn't have any message or stack trace) + reportClientError(err); + } +} +function reportClientError(error) { + return reportError(error, _types.PARENT_MESSAGE_CLIENT_ERROR); +} +function reportInitializeError(error) { + return reportError(error, _types.PARENT_MESSAGE_SETUP_ERROR); +} +function reportError(error, type) { + if (_worker_threads().isMainThread) { + throw new Error('Child can only be used on a forked process'); + } + if (error == null) { + error = new Error('"null" or "undefined" thrown'); + } + _worker_threads().parentPort.postMessage([ + type, + error.constructor && error.constructor.name, + error.message, + error.stack, + typeof error === 'object' + ? { + ...error + } + : error + ]); +} +function end() { + const main = require(file); + if (!main.teardown) { + exitProcess(); + return; + } + execFunction(main.teardown, main, [], exitProcess, exitProcess); +} +function exitProcess() { + // Clean up open handles so the worker ideally exits gracefully + _worker_threads().parentPort.removeListener('message', messageListener); +} +function execMethod(method, args) { + const main = require(file); + let fn; + if (method === 'default') { + fn = main.__esModule ? main.default : main; + } else { + fn = main[method]; + } + function execHelper() { + execFunction(fn, main, args, reportSuccess, reportClientError); + } + if (initialized || !main.setup) { + execHelper(); + return; + } + initialized = true; + execFunction(main.setup, main, setupArgs, execHelper, reportInitializeError); +} +function execFunction(fn, ctx, args, onResult, onError) { + let result; + try { + result = fn.apply(ctx, args); + } catch (err) { + onError(err); + return; + } + if ((0, _jestUtil().isPromise)(result)) { + result.then(onResult, onError); + } else { + onResult(result); + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/package.json new file mode 100644 index 0000000000000000000000000000000000000000..6975f97288e35f38ad274485dd358e4d04f4ba9f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/jest-worker/package.json @@ -0,0 +1,42 @@ +{ + "name": "jest-worker", + "version": "29.7.0", + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/jest-worker" + }, + "license": "MIT", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "dependencies": { + "@types/node": "*", + "jest-util": "^29.7.0", + "merge-stream": "^2.0.0", + "supports-color": "^8.0.0" + }, + "devDependencies": { + "@babel/core": "^7.11.6", + "@tsd/typescript": "^5.0.4", + "@types/merge-stream": "^1.1.2", + "@types/supports-color": "^8.1.0", + "get-stream": "^6.0.0", + "jest-leak-detector": "^29.7.0", + "tsd-lite": "^0.7.0", + "worker-farm": "^1.6.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "publishConfig": { + "access": "public" + }, + "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/supports-color/browser.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/supports-color/browser.js new file mode 100644 index 0000000000000000000000000000000000000000..f097aecd76a090174e5c3371234043d1ddc5d5fd --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/supports-color/browser.js @@ -0,0 +1,24 @@ +/* eslint-env browser */ +'use strict'; + +function getChromeVersion() { + const matches = /(Chrome|Chromium)\/(?\d+)\./.exec(navigator.userAgent); + + if (!matches) { + return; + } + + return Number.parseInt(matches.groups.chromeVersion, 10); +} + +const colorSupport = getChromeVersion() >= 69 ? { + level: 1, + hasBasic: true, + has256: false, + has16m: false +} : false; + +module.exports = { + stdout: colorSupport, + stderr: colorSupport +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/supports-color/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/supports-color/index.js new file mode 100644 index 0000000000000000000000000000000000000000..2dd2fcb0b057d0de56990ad41692550183830c09 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/supports-color/index.js @@ -0,0 +1,152 @@ +'use strict'; +const os = require('os'); +const tty = require('tty'); +const hasFlag = require('has-flag'); + +const {env} = process; + +let flagForceColor; +if (hasFlag('no-color') || + hasFlag('no-colors') || + hasFlag('color=false') || + hasFlag('color=never')) { + flagForceColor = 0; +} else if (hasFlag('color') || + hasFlag('colors') || + hasFlag('color=true') || + hasFlag('color=always')) { + flagForceColor = 1; +} + +function envForceColor() { + if ('FORCE_COLOR' in env) { + if (env.FORCE_COLOR === 'true') { + return 1; + } + + if (env.FORCE_COLOR === 'false') { + return 0; + } + + return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3); + } +} + +function translateLevel(level) { + if (level === 0) { + return false; + } + + return { + level, + hasBasic: true, + has256: level >= 2, + has16m: level >= 3 + }; +} + +function supportsColor(haveStream, {streamIsTTY, sniffFlags = true} = {}) { + const noFlagForceColor = envForceColor(); + if (noFlagForceColor !== undefined) { + flagForceColor = noFlagForceColor; + } + + const forceColor = sniffFlags ? flagForceColor : noFlagForceColor; + + if (forceColor === 0) { + return 0; + } + + if (sniffFlags) { + if (hasFlag('color=16m') || + hasFlag('color=full') || + hasFlag('color=truecolor')) { + return 3; + } + + if (hasFlag('color=256')) { + return 2; + } + } + + if (haveStream && !streamIsTTY && forceColor === undefined) { + return 0; + } + + const min = forceColor || 0; + + if (env.TERM === 'dumb') { + return min; + } + + if (process.platform === 'win32') { + // Windows 10 build 10586 is the first Windows release that supports 256 colors. + // Windows 10 build 14931 is the first release that supports 16m/TrueColor. + const osRelease = os.release().split('.'); + if ( + Number(osRelease[0]) >= 10 && + Number(osRelease[2]) >= 10586 + ) { + return Number(osRelease[2]) >= 14931 ? 3 : 2; + } + + return 1; + } + + if ('CI' in env) { + if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE', 'DRONE'].some(sign => sign in env) || env.CI_NAME === 'codeship') { + return 1; + } + + return min; + } + + if ('TEAMCITY_VERSION' in env) { + return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0; + } + + if (env.COLORTERM === 'truecolor') { + return 3; + } + + if ('TERM_PROGRAM' in env) { + const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10); + + switch (env.TERM_PROGRAM) { + case 'iTerm.app': + return version >= 3 ? 3 : 2; + case 'Apple_Terminal': + return 2; + // No default + } + } + + if (/-256(color)?$/i.test(env.TERM)) { + return 2; + } + + if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) { + return 1; + } + + if ('COLORTERM' in env) { + return 1; + } + + return min; +} + +function getSupportLevel(stream, options = {}) { + const level = supportsColor(stream, { + streamIsTTY: stream && stream.isTTY, + ...options + }); + + return translateLevel(level); +} + +module.exports = { + supportsColor: getSupportLevel, + stdout: getSupportLevel({isTTY: tty.isatty(1)}), + stderr: getSupportLevel({isTTY: tty.isatty(2)}) +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/supports-color/license b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/supports-color/license new file mode 100644 index 0000000000000000000000000000000000000000..fa7ceba3eb4a9657a9db7f3ffca4e4e97a9019de --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/supports-color/license @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) Sindre Sorhus (https://sindresorhus.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/supports-color/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/supports-color/package.json new file mode 100644 index 0000000000000000000000000000000000000000..a97bf2a108df2dc34563500e109b98e910169684 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/supports-color/package.json @@ -0,0 +1,58 @@ +{ + "name": "supports-color", + "version": "8.1.1", + "description": "Detect whether a terminal supports color", + "license": "MIT", + "repository": "chalk/supports-color", + "funding": "https://github.com/chalk/supports-color?sponsor=1", + "author": { + "name": "Sindre Sorhus", + "email": "sindresorhus@gmail.com", + "url": "https://sindresorhus.com" + }, + "engines": { + "node": ">=10" + }, + "scripts": { + "test": "xo && ava" + }, + "files": [ + "index.js", + "browser.js" + ], + "exports": { + "node": "./index.js", + "default": "./browser.js" + }, + "keywords": [ + "color", + "colour", + "colors", + "terminal", + "console", + "cli", + "ansi", + "styles", + "tty", + "rgb", + "256", + "shell", + "xterm", + "command-line", + "support", + "supports", + "capability", + "detect", + "truecolor", + "16m" + ], + "dependencies": { + "has-flag": "^4.0.0" + }, + "devDependencies": { + "ava": "^2.4.0", + "import-fresh": "^3.2.2", + "xo": "^0.35.0" + }, + "browser": "browser.js" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/supports-color/readme.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/supports-color/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..3eedd1caa40a0db02f9266e7efdb1c9c46837063 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/node_modules/supports-color/readme.md @@ -0,0 +1,77 @@ +# supports-color + +> Detect whether a terminal supports color + +## Install + +``` +$ npm install supports-color +``` + +## Usage + +```js +const supportsColor = require('supports-color'); + +if (supportsColor.stdout) { + console.log('Terminal stdout supports color'); +} + +if (supportsColor.stdout.has256) { + console.log('Terminal stdout supports 256 colors'); +} + +if (supportsColor.stderr.has16m) { + console.log('Terminal stderr supports 16 million colors (truecolor)'); +} +``` + +## API + +Returns an `Object` with a `stdout` and `stderr` property for testing either streams. Each property is an `Object`, or `false` if color is not supported. + +The `stdout`/`stderr` objects specifies a level of support for color through a `.level` property and a corresponding flag: + +- `.level = 1` and `.hasBasic = true`: Basic color support (16 colors) +- `.level = 2` and `.has256 = true`: 256 color support +- `.level = 3` and `.has16m = true`: Truecolor support (16 million colors) + +### `require('supports-color').supportsColor(stream, options?)` + +Additionally, `supports-color` exposes the `.supportsColor()` function that takes an arbitrary write stream (e.g. `process.stdout`) and an optional options object to (re-)evaluate color support for an arbitrary stream. + +For example, `require('supports-color').stdout` is the equivalent of `require('supports-color').supportsColor(process.stdout)`. + +The options object supports a single boolean property `sniffFlags`. By default it is `true`, which instructs `supportsColor()` to sniff `process.argv` for the multitude of `--color` flags (see _Info_ below). If `false`, then `process.argv` is not considered when determining color support. + +## Info + +It obeys the `--color` and `--no-color` CLI flags. + +For situations where using `--color` is not possible, use the environment variable `FORCE_COLOR=1` (level 1), `FORCE_COLOR=2` (level 2), or `FORCE_COLOR=3` (level 3) to forcefully enable color, or `FORCE_COLOR=0` to forcefully disable. The use of `FORCE_COLOR` overrides all other color support checks. + +Explicit 256/Truecolor mode can be enabled using the `--color=256` and `--color=16m` flags, respectively. + +## Related + +- [supports-color-cli](https://github.com/chalk/supports-color-cli) - CLI for this module +- [chalk](https://github.com/chalk/chalk) - Terminal string styling done right + +## Maintainers + +- [Sindre Sorhus](https://github.com/sindresorhus) +- [Josh Junon](https://github.com/qix-) + +--- + +
+ + Get professional support for this package with a Tidelift subscription + +
+ + Tidelift helps make open source sustainable for maintainers while giving companies
assurances about security, maintenance, and licensing for their dependencies. + +
+ +--- diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/package.json new file mode 100644 index 0000000000000000000000000000000000000000..f1c8a9fcd7c4313cff08d3dd124ba5b0d99ec219 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/test-sequencer/package.json @@ -0,0 +1,36 @@ +{ + "name": "@jest/test-sequencer", + "version": "29.7.0", + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/jest-test-sequencer" + }, + "license": "MIT", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "dependencies": { + "@jest/test-result": "^29.7.0", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^29.7.0", + "slash": "^3.0.0" + }, + "devDependencies": { + "@jest/test-utils": "^29.7.0", + "@types/graceful-fs": "^4.1.3" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "publishConfig": { + "access": "public" + }, + "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/LICENSE b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b93be90515ccd0b9daedaa589e42bf5929693f1f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Meta Platforms, Inc. and affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/README.md b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a4f56b6d70f7066b030823ded2c73e4992e910f8 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/README.md @@ -0,0 +1,30 @@ +# @jest/types + +This package contains shared types of Jest's packages. + +If you are looking for types of [Jest globals](https://jestjs.io/docs/api), you can import them from `@jest/globals` package: + +```ts +import {describe, expect, it} from '@jest/globals'; + +describe('my tests', () => { + it('works', () => { + expect(1).toBe(1); + }); +}); +``` + +If you prefer to omit imports, a similar result can be achieved installing the [@types/jest](https://npmjs.com/package/@types/jest) package. Note that this is a third party library maintained at [DefinitelyTyped](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/jest) and may not cover the latest Jest features. + +Another use-case for `@types/jest` is a typed Jest config as those types are not provided by Jest out of the box: + +```ts +// jest.config.ts +import {Config} from '@jest/types'; + +const config: Config.InitialOptions = { + // some typed config +}; + +export default config; +``` diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/build/Circus.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/build/Circus.js new file mode 100644 index 0000000000000000000000000000000000000000..ad9a93a7c160f02945911772460eb8a1bcb003db --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/build/Circus.js @@ -0,0 +1 @@ +'use strict'; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/build/Config.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/build/Config.js new file mode 100644 index 0000000000000000000000000000000000000000..ad9a93a7c160f02945911772460eb8a1bcb003db --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/build/Config.js @@ -0,0 +1 @@ +'use strict'; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/build/Global.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/build/Global.js new file mode 100644 index 0000000000000000000000000000000000000000..ad9a93a7c160f02945911772460eb8a1bcb003db --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/build/Global.js @@ -0,0 +1 @@ +'use strict'; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/build/TestResult.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/build/TestResult.js new file mode 100644 index 0000000000000000000000000000000000000000..ad9a93a7c160f02945911772460eb8a1bcb003db --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/build/TestResult.js @@ -0,0 +1 @@ +'use strict'; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/build/Transform.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/build/Transform.js new file mode 100644 index 0000000000000000000000000000000000000000..ad9a93a7c160f02945911772460eb8a1bcb003db --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/build/Transform.js @@ -0,0 +1 @@ +'use strict'; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/build/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/build/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8ddd4ce94f6e25be506f5f9292df5c855149122e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/build/index.d.ts @@ -0,0 +1,1204 @@ +/** + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/// + +import type {Arguments} from 'yargs'; +import type {CoverageMapData} from 'istanbul-lib-coverage'; +import type {ForegroundColor} from 'chalk'; +import type {ReportOptions} from 'istanbul-reports'; +import type {SnapshotFormat} from '@jest/schemas'; + +declare type Argv = Arguments< + Partial<{ + all: boolean; + automock: boolean; + bail: boolean | number; + cache: boolean; + cacheDirectory: string; + changedFilesWithAncestor: boolean; + changedSince: string; + ci: boolean; + clearCache: boolean; + clearMocks: boolean; + collectCoverage: boolean; + collectCoverageFrom: string; + color: boolean; + colors: boolean; + config: string; + coverage: boolean; + coverageDirectory: string; + coveragePathIgnorePatterns: Array; + coverageReporters: Array; + coverageThreshold: string; + debug: boolean; + env: string; + expand: boolean; + findRelatedTests: boolean; + forceExit: boolean; + globals: string; + globalSetup: string | null | undefined; + globalTeardown: string | null | undefined; + haste: string; + ignoreProjects: Array; + init: boolean; + injectGlobals: boolean; + json: boolean; + lastCommit: boolean; + logHeapUsage: boolean; + maxWorkers: number | string; + moduleDirectories: Array; + moduleFileExtensions: Array; + moduleNameMapper: string; + modulePathIgnorePatterns: Array; + modulePaths: Array; + noStackTrace: boolean; + notify: boolean; + notifyMode: string; + onlyChanged: boolean; + onlyFailures: boolean; + outputFile: string; + preset: string | null | undefined; + prettierPath: string | null | undefined; + projects: Array; + randomize: boolean; + reporters: Array; + resetMocks: boolean; + resetModules: boolean; + resolver: string | null | undefined; + restoreMocks: boolean; + rootDir: string; + roots: Array; + runInBand: boolean; + seed: number; + showSeed: boolean; + selectProjects: Array; + setupFiles: Array; + setupFilesAfterEnv: Array; + shard: string; + showConfig: boolean; + silent: boolean; + snapshotSerializers: Array; + testEnvironment: string; + testEnvironmentOptions: string; + testFailureExitCode: string | null | undefined; + testMatch: Array; + testNamePattern: string; + testPathIgnorePatterns: Array; + testPathPattern: Array; + testRegex: string | Array; + testResultsProcessor: string; + testRunner: string; + testSequencer: string; + testTimeout: number | null | undefined; + transform: string; + transformIgnorePatterns: Array; + unmockedModulePathPatterns: Array | null | undefined; + updateSnapshot: boolean; + useStderr: boolean; + verbose: boolean; + version: boolean; + watch: boolean; + watchAll: boolean; + watchman: boolean; + watchPathIgnorePatterns: Array; + workerIdleMemoryLimit: number | string; + workerThreads: boolean; + }> +>; + +declare type ArrayTable = Table | Row; + +declare type AssertionResult = { + ancestorTitles: Array; + duration?: number | null; + failureDetails: Array; + failureMessages: Array; + fullName: string; + invocations?: number; + location?: Callsite | null; + numPassingAsserts: number; + retryReasons?: Array; + status: Status; + title: string; +}; + +declare type AsyncEvent = + | { + name: 'setup'; + testNamePattern?: string; + runtimeGlobals: JestGlobals; + parentProcess: Process; + } + | { + name: 'include_test_location_in_result'; + } + | { + name: 'hook_start'; + hook: Hook; + } + | { + name: 'hook_success'; + describeBlock?: DescribeBlock; + test?: TestEntry; + hook: Hook; + } + | { + name: 'hook_failure'; + error: string | Exception; + describeBlock?: DescribeBlock; + test?: TestEntry; + hook: Hook; + } + | { + name: 'test_fn_start'; + test: TestEntry; + } + | { + name: 'test_fn_success'; + test: TestEntry; + } + | { + name: 'test_fn_failure'; + error: Exception; + test: TestEntry; + } + | { + name: 'test_retry'; + test: TestEntry; + } + | { + name: 'test_start'; + test: TestEntry; + } + | { + name: 'test_skip'; + test: TestEntry; + } + | { + name: 'test_todo'; + test: TestEntry; + } + | { + name: 'test_started'; + test: TestEntry; + } + | { + name: 'test_done'; + test: TestEntry; + } + | { + name: 'run_describe_start'; + describeBlock: DescribeBlock; + } + | { + name: 'run_describe_finish'; + describeBlock: DescribeBlock; + } + | { + name: 'run_start'; + } + | { + name: 'run_finish'; + } + | { + name: 'teardown'; + }; + +declare type AsyncFn = TestFn_2 | HookFn_2; + +declare type BlockFn = () => void; + +declare type BlockFn_2 = Global.BlockFn; + +declare type BlockMode = void | 'skip' | 'only' | 'todo'; + +declare type BlockName = string; + +declare type BlockName_2 = Global.BlockName; + +declare type BlockNameLike = BlockName | NameLike; + +declare type BlockNameLike_2 = Global.BlockNameLike; + +declare type Callsite = { + column: number; + line: number; +}; + +declare namespace Circus { + export { + DoneFn, + BlockFn_2 as BlockFn, + BlockName_2 as BlockName, + BlockNameLike_2 as BlockNameLike, + BlockMode, + TestMode, + TestName_2 as TestName, + TestNameLike_2 as TestNameLike, + TestFn_2 as TestFn, + ConcurrentTestFn_2 as ConcurrentTestFn, + HookFn_2 as HookFn, + AsyncFn, + SharedHookType, + HookType, + TestContext_2 as TestContext, + Exception, + FormattedError, + Hook, + EventHandler, + Event_2 as Event, + SyncEvent, + AsyncEvent, + MatcherResults, + TestStatus, + TestNamesPath, + TestCaseStartInfo, + TestResult_2 as TestResult, + RunResult, + TestResults, + GlobalErrorHandlers, + State, + DescribeBlock, + TestError, + TestEntry, + }; +} +export {Circus}; + +declare type Col = unknown; + +declare type ConcurrentTestFn = () => TestReturnValuePromise; + +declare type ConcurrentTestFn_2 = Global.ConcurrentTestFn; + +declare namespace Config { + export { + FakeableAPI, + GlobalFakeTimersConfig, + FakeTimersConfig, + LegacyFakeTimersConfig, + HasteConfig, + CoverageReporterName, + CoverageReporterWithOptions, + CoverageReporters, + ReporterConfig, + TransformerConfig, + ConfigGlobals, + DefaultOptions, + DisplayName, + InitialOptionsWithRootDir, + InitialProjectOptions, + InitialOptions, + SnapshotUpdateState, + CoverageThresholdValue, + GlobalConfig, + ProjectConfig, + Argv, + }; +} +export {Config}; + +declare interface ConfigGlobals { + [K: string]: unknown; +} + +declare type CoverageProvider = 'babel' | 'v8'; + +declare type CoverageReporterName = keyof ReportOptions; + +declare type CoverageReporters = Array< + CoverageReporterName | CoverageReporterWithOptions +>; + +declare type CoverageReporterWithOptions = + K extends CoverageReporterName + ? ReportOptions[K] extends never + ? never + : [K, Partial] + : never; + +declare type CoverageThreshold = { + [path: string]: CoverageThresholdValue; + global: CoverageThresholdValue; +}; + +declare type CoverageThresholdValue = { + branches?: number; + functions?: number; + lines?: number; + statements?: number; +}; + +declare type DefaultOptions = { + automock: boolean; + bail: number; + cache: boolean; + cacheDirectory: string; + changedFilesWithAncestor: boolean; + ci: boolean; + clearMocks: boolean; + collectCoverage: boolean; + coveragePathIgnorePatterns: Array; + coverageReporters: Array; + coverageProvider: CoverageProvider; + detectLeaks: boolean; + detectOpenHandles: boolean; + errorOnDeprecated: boolean; + expand: boolean; + extensionsToTreatAsEsm: Array; + fakeTimers: FakeTimers; + forceCoverageMatch: Array; + globals: ConfigGlobals; + haste: HasteConfig; + injectGlobals: boolean; + listTests: boolean; + maxConcurrency: number; + maxWorkers: number | string; + moduleDirectories: Array; + moduleFileExtensions: Array; + moduleNameMapper: Record>; + modulePathIgnorePatterns: Array; + noStackTrace: boolean; + notify: boolean; + notifyMode: NotifyMode; + openHandlesTimeout: number; + passWithNoTests: boolean; + prettierPath: string; + resetMocks: boolean; + resetModules: boolean; + restoreMocks: boolean; + roots: Array; + runTestsByPath: boolean; + runner: string; + setupFiles: Array; + setupFilesAfterEnv: Array; + skipFilter: boolean; + slowTestThreshold: number; + snapshotFormat: SnapshotFormat; + snapshotSerializers: Array; + testEnvironment: string; + testEnvironmentOptions: Record; + testFailureExitCode: string | number; + testLocationInResults: boolean; + testMatch: Array; + testPathIgnorePatterns: Array; + testRegex: Array; + testRunner: string; + testSequencer: string; + transformIgnorePatterns: Array; + useStderr: boolean; + watch: boolean; + watchPathIgnorePatterns: Array; + watchman: boolean; + workerThreads: boolean; +}; + +declare interface Describe extends DescribeBase { + only: DescribeBase; + skip: DescribeBase; +} + +declare interface DescribeBase { + (blockName: BlockNameLike, blockFn: BlockFn): void; + each: Each; +} + +declare type DescribeBlock = { + type: 'describeBlock'; + children: Array; + hooks: Array; + mode: BlockMode; + name: BlockName_2; + parent?: DescribeBlock; + /** @deprecated Please get from `children` array instead */ + tests: Array; +}; + +declare type DisplayName = { + name: string; + color: typeof ForegroundColor; +}; + +declare type DoneFn = Global.DoneFn; + +declare type DoneFn_2 = (reason?: string | Error) => void; + +declare type DoneTakingTestFn = ( + this: TestContext, + done: DoneFn_2, +) => ValidTestReturnValues; + +declare interface Each { + >(table: ReadonlyArray): ( + name: string | NameLike, + fn: (arg: T, done: DoneFn_2) => ReturnType, + timeout?: number, + ) => void; + ]>(table: ReadonlyArray): ( + name: string | NameLike, + fn: (...args: T) => ReturnType, + timeout?: number, + ) => void; + >(table: ReadonlyArray): ( + name: string | NameLike, + fn: (...args: T) => ReturnType, + timeout?: number, + ) => void; + (table: ReadonlyArray): ( + name: string | NameLike, + fn: (arg: T, done: DoneFn_2) => ReturnType, + timeout?: number, + ) => void; + (strings: TemplateStringsArray, ...expressions: Array): ( + name: string | NameLike, + fn: (arg: Record, done: DoneFn_2) => ReturnType, + timeout?: number, + ) => void; + >( + strings: TemplateStringsArray, + ...expressions: Array + ): ( + name: string | NameLike, + fn: (arg: T, done: DoneFn_2) => ReturnType, + timeout?: number, + ) => void; +} + +declare type EachTable = ArrayTable | TemplateTable; + +declare type EachTestFn = ( + ...args: ReadonlyArray +) => ReturnType; + +declare type Event_2 = SyncEvent | AsyncEvent; + +declare interface EventHandler { + (event: AsyncEvent, state: State): void | Promise; + (event: SyncEvent, state: State): void; +} + +declare type Exception = any; + +declare interface Failing { + (testName: TestNameLike, fn: T, timeout?: number): void; + each: Each; +} + +declare type FakeableAPI = + | 'Date' + | 'hrtime' + | 'nextTick' + | 'performance' + | 'queueMicrotask' + | 'requestAnimationFrame' + | 'cancelAnimationFrame' + | 'requestIdleCallback' + | 'cancelIdleCallback' + | 'setImmediate' + | 'clearImmediate' + | 'setInterval' + | 'clearInterval' + | 'setTimeout' + | 'clearTimeout'; + +declare type FakeTimers = GlobalFakeTimersConfig & + ( + | (FakeTimersConfig & { + now?: Exclude; + }) + | LegacyFakeTimersConfig + ); + +declare type FakeTimersConfig = { + /** + * If set to `true` all timers will be advanced automatically + * by 20 milliseconds every 20 milliseconds. A custom time delta + * may be provided by passing a number. + * + * @defaultValue + * The default is `false`. + */ + advanceTimers?: boolean | number; + /** + * List of names of APIs (e.g. `Date`, `nextTick()`, `setImmediate()`, + * `setTimeout()`) that should not be faked. + * + * @defaultValue + * The default is `[]`, meaning all APIs are faked. + */ + doNotFake?: Array; + /** + * Sets current system time to be used by fake timers. + * + * @defaultValue + * The default is `Date.now()`. + */ + now?: number | Date; + /** + * The maximum number of recursive timers that will be run when calling + * `jest.runAllTimers()`. + * + * @defaultValue + * The default is `100_000` timers. + */ + timerLimit?: number; + /** + * Use the old fake timers implementation instead of one backed by + * [`@sinonjs/fake-timers`](https://github.com/sinonjs/fake-timers). + * + * @defaultValue + * The default is `false`. + */ + legacyFakeTimers?: false; +}; + +declare type FormattedError = string; + +declare type GeneratorReturningTestFn = ( + this: TestContext, +) => TestReturnValueGenerator; + +declare namespace Global { + export { + ValidTestReturnValues, + TestReturnValue, + TestContext, + DoneFn_2 as DoneFn, + DoneTakingTestFn, + PromiseReturningTestFn, + GeneratorReturningTestFn, + NameLike, + TestName, + TestNameLike, + TestFn, + ConcurrentTestFn, + BlockFn, + BlockName, + BlockNameLike, + HookFn, + Col, + Row, + Table, + ArrayTable, + TemplateTable, + TemplateData, + EachTable, + TestCallback, + EachTestFn, + HookBase, + Failing, + ItBase, + It, + ItConcurrentBase, + ItConcurrentExtended, + ItConcurrent, + DescribeBase, + Describe, + TestFrameworkGlobals, + GlobalAdditions, + Global_2 as Global, + }; +} +export {Global}; + +declare interface Global_2 + extends GlobalAdditions, + Omit { + [extras: PropertyKey]: unknown; +} + +declare interface GlobalAdditions extends TestFrameworkGlobals { + __coverage__: CoverageMapData; +} + +declare type GlobalConfig = { + bail: number; + changedSince?: string; + changedFilesWithAncestor: boolean; + ci: boolean; + collectCoverage: boolean; + collectCoverageFrom: Array; + coverageDirectory: string; + coveragePathIgnorePatterns?: Array; + coverageProvider: CoverageProvider; + coverageReporters: CoverageReporters; + coverageThreshold?: CoverageThreshold; + detectLeaks: boolean; + detectOpenHandles: boolean; + expand: boolean; + filter?: string; + findRelatedTests: boolean; + forceExit: boolean; + json: boolean; + globalSetup?: string; + globalTeardown?: string; + lastCommit: boolean; + logHeapUsage: boolean; + listTests: boolean; + maxConcurrency: number; + maxWorkers: number; + noStackTrace: boolean; + nonFlagArgs: Array; + noSCM?: boolean; + notify: boolean; + notifyMode: NotifyMode; + outputFile?: string; + onlyChanged: boolean; + onlyFailures: boolean; + openHandlesTimeout: number; + passWithNoTests: boolean; + projects: Array; + randomize?: boolean; + replname?: string; + reporters?: Array; + runInBand: boolean; + runTestsByPath: boolean; + rootDir: string; + seed: number; + showSeed?: boolean; + shard?: ShardConfig; + silent?: boolean; + skipFilter: boolean; + snapshotFormat: SnapshotFormat; + errorOnDeprecated: boolean; + testFailureExitCode: number; + testNamePattern?: string; + testPathPattern: string; + testResultsProcessor?: string; + testSequencer: string; + testTimeout?: number; + updateSnapshot: SnapshotUpdateState; + useStderr: boolean; + verbose?: boolean; + watch: boolean; + watchAll: boolean; + watchman: boolean; + watchPlugins?: Array<{ + path: string; + config: Record; + }> | null; + workerIdleMemoryLimit?: number; + workerThreads?: boolean; +}; + +declare type GlobalErrorHandlers = { + uncaughtException: Array<(exception: Exception) => void>; + unhandledRejection: Array< + (exception: Exception, promise: Promise) => void + >; +}; + +declare type GlobalFakeTimersConfig = { + /** + * Whether fake timers should be enabled globally for all test files. + * + * @defaultValue + * The default is `false`. + */ + enableGlobally?: boolean; +}; + +declare type HasteConfig = { + /** Whether to hash files using SHA-1. */ + computeSha1?: boolean; + /** The platform to use as the default, e.g. 'ios'. */ + defaultPlatform?: string | null; + /** Force use of Node's `fs` APIs rather than shelling out to `find` */ + forceNodeFilesystemAPI?: boolean; + /** + * Whether to follow symlinks when crawling for files. + * This options cannot be used in projects which use watchman. + * Projects with `watchman` set to true will error if this option is set to true. + */ + enableSymlinks?: boolean; + /** string to a custom implementation of Haste. */ + hasteImplModulePath?: string; + /** All platforms to target, e.g ['ios', 'android']. */ + platforms?: Array; + /** Whether to throw on error on module collision. */ + throwOnModuleCollision?: boolean; + /** Custom HasteMap module */ + hasteMapModulePath?: string; + /** Whether to retain all files, allowing e.g. search for tests in `node_modules`. */ + retainAllFiles?: boolean; +}; + +declare type Hook = { + asyncError: Error; + fn: HookFn_2; + type: HookType; + parent: DescribeBlock; + seenDone: boolean; + timeout: number | undefined | null; +}; + +declare interface HookBase { + (fn: HookFn, timeout?: number): void; +} + +declare type HookFn = TestFn; + +declare type HookFn_2 = Global.HookFn; + +declare type HookType = SharedHookType | 'afterEach' | 'beforeEach'; + +declare type InitialOptions = Partial<{ + automock: boolean; + bail: boolean | number; + cache: boolean; + cacheDirectory: string; + ci: boolean; + clearMocks: boolean; + changedFilesWithAncestor: boolean; + changedSince: string; + collectCoverage: boolean; + collectCoverageFrom: Array; + coverageDirectory: string; + coveragePathIgnorePatterns: Array; + coverageProvider: CoverageProvider; + coverageReporters: CoverageReporters; + coverageThreshold: CoverageThreshold; + dependencyExtractor: string; + detectLeaks: boolean; + detectOpenHandles: boolean; + displayName: string | DisplayName; + expand: boolean; + extensionsToTreatAsEsm: Array; + fakeTimers: FakeTimers; + filter: string; + findRelatedTests: boolean; + forceCoverageMatch: Array; + forceExit: boolean; + json: boolean; + globals: ConfigGlobals; + globalSetup: string | null | undefined; + globalTeardown: string | null | undefined; + haste: HasteConfig; + id: string; + injectGlobals: boolean; + reporters: Array; + logHeapUsage: boolean; + lastCommit: boolean; + listTests: boolean; + maxConcurrency: number; + maxWorkers: number | string; + moduleDirectories: Array; + moduleFileExtensions: Array; + moduleNameMapper: { + [key: string]: string | Array; + }; + modulePathIgnorePatterns: Array; + modulePaths: Array; + noStackTrace: boolean; + notify: boolean; + notifyMode: string; + onlyChanged: boolean; + onlyFailures: boolean; + openHandlesTimeout: number; + outputFile: string; + passWithNoTests: boolean; + preset: string | null | undefined; + prettierPath: string | null | undefined; + projects: Array; + randomize: boolean; + replname: string | null | undefined; + resetMocks: boolean; + resetModules: boolean; + resolver: string | null | undefined; + restoreMocks: boolean; + rootDir: string; + roots: Array; + runner: string; + runTestsByPath: boolean; + runtime: string; + sandboxInjectedGlobals: Array; + setupFiles: Array; + setupFilesAfterEnv: Array; + showSeed: boolean; + silent: boolean; + skipFilter: boolean; + skipNodeResolution: boolean; + slowTestThreshold: number; + snapshotResolver: string; + snapshotSerializers: Array; + snapshotFormat: SnapshotFormat; + errorOnDeprecated: boolean; + testEnvironment: string; + testEnvironmentOptions: Record; + testFailureExitCode: string | number; + testLocationInResults: boolean; + testMatch: Array; + testNamePattern: string; + testPathIgnorePatterns: Array; + testRegex: string | Array; + testResultsProcessor: string; + testRunner: string; + testSequencer: string; + testTimeout: number; + transform: { + [regex: string]: string | TransformerConfig; + }; + transformIgnorePatterns: Array; + watchPathIgnorePatterns: Array; + unmockedModulePathPatterns: Array; + updateSnapshot: boolean; + useStderr: boolean; + verbose?: boolean; + watch: boolean; + watchAll: boolean; + watchman: boolean; + watchPlugins: Array]>; + workerIdleMemoryLimit: number | string; + workerThreads: boolean; +}>; + +declare type InitialOptionsWithRootDir = InitialOptions & + Required>; + +declare type InitialProjectOptions = Pick< + InitialOptions & { + cwd?: string; + }, + keyof ProjectConfig +>; + +declare interface It extends ItBase { + only: ItBase; + skip: ItBase; + todo: (testName: TestNameLike) => void; +} + +declare interface ItBase { + (testName: TestNameLike, fn: TestFn, timeout?: number): void; + each: Each; + failing: Failing; +} + +declare interface ItConcurrent extends It { + concurrent: ItConcurrentExtended; +} + +declare interface ItConcurrentBase { + (testName: TestNameLike, testFn: ConcurrentTestFn, timeout?: number): void; + each: Each; + failing: Failing; +} + +declare interface ItConcurrentExtended extends ItConcurrentBase { + only: ItConcurrentBase; + skip: ItConcurrentBase; +} + +declare interface JestGlobals extends Global.TestFrameworkGlobals { + expect: unknown; +} + +declare type LegacyFakeTimersConfig = { + /** + * Use the old fake timers implementation instead of one backed by + * [`@sinonjs/fake-timers`](https://github.com/sinonjs/fake-timers). + * + * @defaultValue + * The default is `false`. + */ + legacyFakeTimers?: true; +}; + +declare type MatcherResults = { + actual: unknown; + expected: unknown; + name: string; + pass: boolean; +}; + +declare type NameLike = number | Function; + +declare type NotifyMode = + | 'always' + | 'failure' + | 'success' + | 'change' + | 'success-change' + | 'failure-change'; + +declare type Process = NodeJS.Process; + +declare type ProjectConfig = { + automock: boolean; + cache: boolean; + cacheDirectory: string; + clearMocks: boolean; + collectCoverageFrom: Array; + coverageDirectory: string; + coveragePathIgnorePatterns: Array; + cwd: string; + dependencyExtractor?: string; + detectLeaks: boolean; + detectOpenHandles: boolean; + displayName?: DisplayName; + errorOnDeprecated: boolean; + extensionsToTreatAsEsm: Array; + fakeTimers: FakeTimers; + filter?: string; + forceCoverageMatch: Array; + globalSetup?: string; + globalTeardown?: string; + globals: ConfigGlobals; + haste: HasteConfig; + id: string; + injectGlobals: boolean; + moduleDirectories: Array; + moduleFileExtensions: Array; + moduleNameMapper: Array<[string, string]>; + modulePathIgnorePatterns: Array; + modulePaths?: Array; + openHandlesTimeout: number; + preset?: string; + prettierPath: string; + resetMocks: boolean; + resetModules: boolean; + resolver?: string; + restoreMocks: boolean; + rootDir: string; + roots: Array; + runner: string; + runtime?: string; + sandboxInjectedGlobals: Array; + setupFiles: Array; + setupFilesAfterEnv: Array; + skipFilter: boolean; + skipNodeResolution?: boolean; + slowTestThreshold: number; + snapshotResolver?: string; + snapshotSerializers: Array; + snapshotFormat: SnapshotFormat; + testEnvironment: string; + testEnvironmentOptions: Record; + testMatch: Array; + testLocationInResults: boolean; + testPathIgnorePatterns: Array; + testRegex: Array; + testRunner: string; + transform: Array<[string, string, Record]>; + transformIgnorePatterns: Array; + watchPathIgnorePatterns: Array; + unmockedModulePathPatterns?: Array; + workerIdleMemoryLimit?: number; +}; + +declare type PromiseReturningTestFn = (this: TestContext) => TestReturnValue; + +declare type ReporterConfig = [string, Record]; + +declare type Row = ReadonlyArray; + +declare type RunResult = { + unhandledErrors: Array; + testResults: TestResults; +}; + +declare type SerializableError = { + code?: unknown; + message: string; + stack: string | null | undefined; + type?: string; +}; + +declare type ShardConfig = { + shardIndex: number; + shardCount: number; +}; + +declare type SharedHookType = 'afterAll' | 'beforeAll'; + +declare type SnapshotUpdateState = 'all' | 'new' | 'none'; + +declare type State = { + currentDescribeBlock: DescribeBlock; + currentlyRunningTest?: TestEntry | null; + expand?: boolean; + hasFocusedTests: boolean; + hasStarted: boolean; + originalGlobalErrorHandlers?: GlobalErrorHandlers; + parentProcess: Process | null; + randomize?: boolean; + rootDescribeBlock: DescribeBlock; + seed: number; + testNamePattern?: RegExp | null; + testTimeout: number; + unhandledErrors: Array; + includeTestLocationInResult: boolean; + maxConcurrency: number; +}; + +declare type Status = + | 'passed' + | 'failed' + | 'skipped' + | 'pending' + | 'todo' + | 'disabled' + | 'focused'; + +declare type SyncEvent = + | { + asyncError: Error; + mode: BlockMode; + name: 'start_describe_definition'; + blockName: BlockName_2; + } + | { + mode: BlockMode; + name: 'finish_describe_definition'; + blockName: BlockName_2; + } + | { + asyncError: Error; + name: 'add_hook'; + hookType: HookType; + fn: HookFn_2; + timeout: number | undefined; + } + | { + asyncError: Error; + name: 'add_test'; + testName: TestName_2; + fn: TestFn_2; + mode?: TestMode; + concurrent: boolean; + timeout: number | undefined; + failing: boolean; + } + | { + name: 'error'; + error: Exception; + }; + +declare type Table = ReadonlyArray; + +declare type TemplateData = ReadonlyArray; + +declare type TemplateTable = TemplateStringsArray; + +declare type TestCallback = BlockFn | TestFn | ConcurrentTestFn; + +declare type TestCaseStartInfo = { + ancestorTitles: Array; + fullName: string; + mode: TestMode; + title: string; + startedAt?: number | null; +}; + +declare type TestContext = Record; + +declare type TestContext_2 = Global.TestContext; + +declare type TestEntry = { + type: 'test'; + asyncError: Exception; + errors: Array; + retryReasons: Array; + fn: TestFn_2; + invocations: number; + mode: TestMode; + concurrent: boolean; + name: TestName_2; + numPassingAsserts: number; + parent: DescribeBlock; + startedAt?: number | null; + duration?: number | null; + seenDone: boolean; + status?: TestStatus | null; + timeout?: number; + failing: boolean; +}; + +declare type TestError = Exception | [Exception | undefined, Exception]; + +declare type TestFn = + | PromiseReturningTestFn + | GeneratorReturningTestFn + | DoneTakingTestFn; + +declare type TestFn_2 = Global.TestFn; + +declare interface TestFrameworkGlobals { + it: ItConcurrent; + test: ItConcurrent; + fit: ItBase & { + concurrent?: ItConcurrentBase; + }; + xit: ItBase; + xtest: ItBase; + describe: Describe; + xdescribe: DescribeBase; + fdescribe: DescribeBase; + beforeAll: HookBase; + beforeEach: HookBase; + afterEach: HookBase; + afterAll: HookBase; +} + +declare type TestMode = BlockMode; + +declare type TestName = string; + +declare type TestName_2 = Global.TestName; + +declare type TestNameLike = TestName | NameLike; + +declare type TestNameLike_2 = Global.TestNameLike; + +declare type TestNamesPath = Array; + +declare namespace TestResult { + export {AssertionResult, SerializableError}; +} +export {TestResult}; + +declare type TestResult_2 = { + duration?: number | null; + errors: Array; + errorsDetailed: Array; + invocations: number; + status: TestStatus; + location?: { + column: number; + line: number; + } | null; + numPassingAsserts: number; + retryReasons: Array; + testPath: TestNamesPath; +}; + +declare type TestResults = Array; + +declare type TestReturnValue = ValidTestReturnValues | TestReturnValuePromise; + +declare type TestReturnValueGenerator = Generator; + +declare type TestReturnValuePromise = Promise; + +declare type TestStatus = 'skip' | 'done' | 'todo'; + +declare type TransformerConfig = [string, Record]; + +declare type TransformResult = { + code: string; + originalCode: string; + sourceMapPath: string | null; +}; + +declare namespace TransformTypes { + export {TransformResult}; +} +export {TransformTypes}; + +declare type ValidTestReturnValues = void | undefined; + +export {}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/build/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/build/index.js new file mode 100644 index 0000000000000000000000000000000000000000..ad9a93a7c160f02945911772460eb8a1bcb003db --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/build/index.js @@ -0,0 +1 @@ +'use strict'; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/package.json b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/package.json new file mode 100644 index 0000000000000000000000000000000000000000..76f9024355386b5c482a2367dc4cf11a1d82eed4 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/@jest/types/package.json @@ -0,0 +1,38 @@ +{ + "name": "@jest/types", + "version": "29.6.3", + "repository": { + "type": "git", + "url": "https://github.com/jestjs/jest.git", + "directory": "packages/jest-types" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "license": "MIT", + "main": "./build/index.js", + "types": "./build/index.d.ts", + "exports": { + ".": { + "types": "./build/index.d.ts", + "default": "./build/index.js" + }, + "./package.json": "./package.json" + }, + "dependencies": { + "@jest/schemas": "^29.6.3", + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^17.0.8", + "chalk": "^4.0.0" + }, + "devDependencies": { + "@tsd/typescript": "^5.0.4", + "tsd-lite": "^0.7.0" + }, + "publishConfig": { + "access": "public" + }, + "gitHead": "fb7d95c8af6e0d65a8b65348433d8a0ea0725b5b" +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action.js b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action.js new file mode 100644 index 0000000000000000000000000000000000000000..1483c79ffa53d6537fbae068987e39a50e2cfa08 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action.js @@ -0,0 +1,146 @@ +/** + * class Action + * + * Base class for all actions + * Do not call in your code, use this class only for inherits your own action + * + * Information about how to convert command line strings to Javascript objects. + * Action objects are used by an ArgumentParser to represent the information + * needed to parse a single argument from one or more strings from the command + * line. The keyword arguments to the Action constructor are also all attributes + * of Action instances. + * + * ##### Allowed keywords: + * + * - `store` + * - `storeConstant` + * - `storeTrue` + * - `storeFalse` + * - `append` + * - `appendConstant` + * - `count` + * - `help` + * - `version` + * + * Information about action options see [[Action.new]] + * + * See also [original guide](http://docs.python.org/dev/library/argparse.html#action) + * + **/ + +'use strict'; + + +// Constants +var c = require('./const'); + + +/** + * new Action(options) + * + * Base class for all actions. Used only for inherits + * + * + * ##### Options: + * + * - `optionStrings` A list of command-line option strings for the action. + * - `dest` Attribute to hold the created object(s) + * - `nargs` The number of command-line arguments that should be consumed. + * By default, one argument will be consumed and a single value will be + * produced. + * - `constant` Default value for an action with no value. + * - `defaultValue` The value to be produced if the option is not specified. + * - `type` Cast to 'string'|'int'|'float'|'complex'|function (string). If + * None, 'string'. + * - `choices` The choices available. + * - `required` True if the action must always be specified at the command + * line. + * - `help` The help describing the argument. + * - `metavar` The name to be used for the option's argument with the help + * string. If None, the 'dest' value will be used as the name. + * + * ##### nargs supported values: + * + * - `N` (an integer) consumes N arguments (and produces a list) + * - `?` consumes zero or one arguments + * - `*` consumes zero or more arguments (and produces a list) + * - `+` consumes one or more arguments (and produces a list) + * + * Note: that the difference between the default and nargs=1 is that with the + * default, a single value will be produced, while with nargs=1, a list + * containing a single value will be produced. + **/ +var Action = module.exports = function Action(options) { + options = options || {}; + this.optionStrings = options.optionStrings || []; + this.dest = options.dest; + this.nargs = typeof options.nargs !== 'undefined' ? options.nargs : null; + this.constant = typeof options.constant !== 'undefined' ? options.constant : null; + this.defaultValue = options.defaultValue; + this.type = typeof options.type !== 'undefined' ? options.type : null; + this.choices = typeof options.choices !== 'undefined' ? options.choices : null; + this.required = typeof options.required !== 'undefined' ? options.required : false; + this.help = typeof options.help !== 'undefined' ? options.help : null; + this.metavar = typeof options.metavar !== 'undefined' ? options.metavar : null; + + if (!(this.optionStrings instanceof Array)) { + throw new Error('optionStrings should be an array'); + } + if (typeof this.required !== 'undefined' && typeof this.required !== 'boolean') { + throw new Error('required should be a boolean'); + } +}; + +/** + * Action#getName -> String + * + * Tells action name + **/ +Action.prototype.getName = function () { + if (this.optionStrings.length > 0) { + return this.optionStrings.join('/'); + } else if (this.metavar !== null && this.metavar !== c.SUPPRESS) { + return this.metavar; + } else if (typeof this.dest !== 'undefined' && this.dest !== c.SUPPRESS) { + return this.dest; + } + return null; +}; + +/** + * Action#isOptional -> Boolean + * + * Return true if optional + **/ +Action.prototype.isOptional = function () { + return !this.isPositional(); +}; + +/** + * Action#isPositional -> Boolean + * + * Return true if positional + **/ +Action.prototype.isPositional = function () { + return (this.optionStrings.length === 0); +}; + +/** + * Action#call(parser, namespace, values, optionString) -> Void + * - parser (ArgumentParser): current parser + * - namespace (Namespace): namespace for output data + * - values (Array): parsed values + * - optionString (Array): input option string(not parsed) + * + * Call the action. Should be implemented in inherited classes + * + * ##### Example + * + * ActionCount.prototype.call = function (parser, namespace, values, optionString) { + * namespace.set(this.dest, (namespace[this.dest] || 0) + 1); + * }; + * + **/ +Action.prototype.call = function () { + throw new Error('.call() not defined');// Not Implemented error +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/append.js b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/append.js new file mode 100644 index 0000000000000000000000000000000000000000..b5da0de2327504e69266b713f07fd4cc3c83ecaa --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/append.js @@ -0,0 +1,53 @@ +/*:nodoc:* + * class ActionAppend + * + * This action stores a list, and appends each argument value to the list. + * This is useful to allow an option to be specified multiple times. + * This class inherided from [[Action]] + * + **/ + +'use strict'; + +var util = require('util'); + +var Action = require('../action'); + +// Constants +var c = require('../const'); + +/*:nodoc:* + * new ActionAppend(options) + * - options (object): options hash see [[Action.new]] + * + * Note: options.nargs should be optional for constants + * and more then zero for other + **/ +var ActionAppend = module.exports = function ActionAppend(options) { + options = options || {}; + if (this.nargs <= 0) { + throw new Error('nargs for append actions must be > 0; if arg ' + + 'strings are not supplying the value to append, ' + + 'the append const action may be more appropriate'); + } + if (!!this.constant && this.nargs !== c.OPTIONAL) { + throw new Error('nargs must be OPTIONAL to supply const'); + } + Action.call(this, options); +}; +util.inherits(ActionAppend, Action); + +/*:nodoc:* + * ActionAppend#call(parser, namespace, values, optionString) -> Void + * - parser (ArgumentParser): current parser + * - namespace (Namespace): namespace for output data + * - values (Array): parsed values + * - optionString (Array): input option string(not parsed) + * + * Call the action. Save result in namespace object + **/ +ActionAppend.prototype.call = function (parser, namespace, values) { + var items = (namespace[this.dest] || []).slice(); + items.push(values); + namespace.set(this.dest, items); +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/append/constant.js b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/append/constant.js new file mode 100644 index 0000000000000000000000000000000000000000..313f5d2efcb03fa8d62b5f9d79d0577bed0b6ea4 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/append/constant.js @@ -0,0 +1,47 @@ +/*:nodoc:* + * class ActionAppendConstant + * + * This stores a list, and appends the value specified by + * the const keyword argument to the list. + * (Note that the const keyword argument defaults to null.) + * The 'appendConst' action is typically useful when multiple + * arguments need to store constants to the same list. + * + * This class inherited from [[Action]] + **/ + +'use strict'; + +var util = require('util'); + +var Action = require('../../action'); + +/*:nodoc:* + * new ActionAppendConstant(options) + * - options (object): options hash see [[Action.new]] + * + **/ +var ActionAppendConstant = module.exports = function ActionAppendConstant(options) { + options = options || {}; + options.nargs = 0; + if (typeof options.constant === 'undefined') { + throw new Error('constant option is required for appendAction'); + } + Action.call(this, options); +}; +util.inherits(ActionAppendConstant, Action); + +/*:nodoc:* + * ActionAppendConstant#call(parser, namespace, values, optionString) -> Void + * - parser (ArgumentParser): current parser + * - namespace (Namespace): namespace for output data + * - values (Array): parsed values + * - optionString (Array): input option string(not parsed) + * + * Call the action. Save result in namespace object + **/ +ActionAppendConstant.prototype.call = function (parser, namespace) { + var items = [].concat(namespace[this.dest] || []); + items.push(this.constant); + namespace.set(this.dest, items); +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/count.js b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/count.js new file mode 100644 index 0000000000000000000000000000000000000000..d6a5899d07ef2405d31777a2616bed14a0485d74 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/count.js @@ -0,0 +1,40 @@ +/*:nodoc:* + * class ActionCount + * + * This counts the number of times a keyword argument occurs. + * For example, this is useful for increasing verbosity levels + * + * This class inherided from [[Action]] + * + **/ +'use strict'; + +var util = require('util'); + +var Action = require('../action'); + +/*:nodoc:* + * new ActionCount(options) + * - options (object): options hash see [[Action.new]] + * + **/ +var ActionCount = module.exports = function ActionCount(options) { + options = options || {}; + options.nargs = 0; + + Action.call(this, options); +}; +util.inherits(ActionCount, Action); + +/*:nodoc:* + * ActionCount#call(parser, namespace, values, optionString) -> Void + * - parser (ArgumentParser): current parser + * - namespace (Namespace): namespace for output data + * - values (Array): parsed values + * - optionString (Array): input option string(not parsed) + * + * Call the action. Save result in namespace object + **/ +ActionCount.prototype.call = function (parser, namespace) { + namespace.set(this.dest, (namespace[this.dest] || 0) + 1); +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/help.js b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/help.js new file mode 100644 index 0000000000000000000000000000000000000000..b40e05a6f0b3eb2382b7d7c78b67653a5be18ce5 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/help.js @@ -0,0 +1,47 @@ +/*:nodoc:* + * class ActionHelp + * + * Support action for printing help + * This class inherided from [[Action]] + **/ +'use strict'; + +var util = require('util'); + +var Action = require('../action'); + +// Constants +var c = require('../const'); + +/*:nodoc:* + * new ActionHelp(options) + * - options (object): options hash see [[Action.new]] + * + **/ +var ActionHelp = module.exports = function ActionHelp(options) { + options = options || {}; + if (options.defaultValue !== null) { + options.defaultValue = options.defaultValue; + } else { + options.defaultValue = c.SUPPRESS; + } + options.dest = (options.dest !== null ? options.dest : c.SUPPRESS); + options.nargs = 0; + Action.call(this, options); + +}; +util.inherits(ActionHelp, Action); + +/*:nodoc:* + * ActionHelp#call(parser, namespace, values, optionString) + * - parser (ArgumentParser): current parser + * - namespace (Namespace): namespace for output data + * - values (Array): parsed values + * - optionString (Array): input option string(not parsed) + * + * Print help and exit + **/ +ActionHelp.prototype.call = function (parser) { + parser.printHelp(); + parser.exit(); +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/store.js b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/store.js new file mode 100644 index 0000000000000000000000000000000000000000..283b8609217561910aca7d0eb725a37b4966d314 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/store.js @@ -0,0 +1,50 @@ +/*:nodoc:* + * class ActionStore + * + * This action just stores the argument’s value. This is the default action. + * + * This class inherited from [[Action]] + * + **/ +'use strict'; + +var util = require('util'); + +var Action = require('../action'); + +// Constants +var c = require('../const'); + + +/*:nodoc:* + * new ActionStore(options) + * - options (object): options hash see [[Action.new]] + * + **/ +var ActionStore = module.exports = function ActionStore(options) { + options = options || {}; + if (this.nargs <= 0) { + throw new Error('nargs for store actions must be > 0; if you ' + + 'have nothing to store, actions such as store ' + + 'true or store const may be more appropriate'); + + } + if (typeof this.constant !== 'undefined' && this.nargs !== c.OPTIONAL) { + throw new Error('nargs must be OPTIONAL to supply const'); + } + Action.call(this, options); +}; +util.inherits(ActionStore, Action); + +/*:nodoc:* + * ActionStore#call(parser, namespace, values, optionString) -> Void + * - parser (ArgumentParser): current parser + * - namespace (Namespace): namespace for output data + * - values (Array): parsed values + * - optionString (Array): input option string(not parsed) + * + * Call the action. Save result in namespace object + **/ +ActionStore.prototype.call = function (parser, namespace, values) { + namespace.set(this.dest, values); +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/store/constant.js b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/store/constant.js new file mode 100644 index 0000000000000000000000000000000000000000..23caa897b375d47cf8e07a6b2e80b92f867fc1c7 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/store/constant.js @@ -0,0 +1,43 @@ +/*:nodoc:* + * class ActionStoreConstant + * + * This action stores the value specified by the const keyword argument. + * (Note that the const keyword argument defaults to the rather unhelpful null.) + * The 'store_const' action is most commonly used with optional + * arguments that specify some sort of flag. + * + * This class inherited from [[Action]] + **/ +'use strict'; + +var util = require('util'); + +var Action = require('../../action'); + +/*:nodoc:* + * new ActionStoreConstant(options) + * - options (object): options hash see [[Action.new]] + * + **/ +var ActionStoreConstant = module.exports = function ActionStoreConstant(options) { + options = options || {}; + options.nargs = 0; + if (typeof options.constant === 'undefined') { + throw new Error('constant option is required for storeAction'); + } + Action.call(this, options); +}; +util.inherits(ActionStoreConstant, Action); + +/*:nodoc:* + * ActionStoreConstant#call(parser, namespace, values, optionString) -> Void + * - parser (ArgumentParser): current parser + * - namespace (Namespace): namespace for output data + * - values (Array): parsed values + * - optionString (Array): input option string(not parsed) + * + * Call the action. Save result in namespace object + **/ +ActionStoreConstant.prototype.call = function (parser, namespace) { + namespace.set(this.dest, this.constant); +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/store/false.js b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/store/false.js new file mode 100644 index 0000000000000000000000000000000000000000..9924f461dadfe687903a93825a59f819b01eb989 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/store/false.js @@ -0,0 +1,27 @@ +/*:nodoc:* + * class ActionStoreFalse + * + * This action store the values False respectively. + * This is special cases of 'storeConst' + * + * This class inherited from [[Action]] + **/ + +'use strict'; + +var util = require('util'); + +var ActionStoreConstant = require('./constant'); + +/*:nodoc:* + * new ActionStoreFalse(options) + * - options (object): hash of options see [[Action.new]] + * + **/ +var ActionStoreFalse = module.exports = function ActionStoreFalse(options) { + options = options || {}; + options.constant = false; + options.defaultValue = options.defaultValue !== null ? options.defaultValue : true; + ActionStoreConstant.call(this, options); +}; +util.inherits(ActionStoreFalse, ActionStoreConstant); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/store/true.js b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/store/true.js new file mode 100644 index 0000000000000000000000000000000000000000..9e22f7d4419eeafd4c4ce2136aa492d781de2818 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/store/true.js @@ -0,0 +1,26 @@ +/*:nodoc:* + * class ActionStoreTrue + * + * This action store the values True respectively. + * This isspecial cases of 'storeConst' + * + * This class inherited from [[Action]] + **/ +'use strict'; + +var util = require('util'); + +var ActionStoreConstant = require('./constant'); + +/*:nodoc:* + * new ActionStoreTrue(options) + * - options (object): options hash see [[Action.new]] + * + **/ +var ActionStoreTrue = module.exports = function ActionStoreTrue(options) { + options = options || {}; + options.constant = true; + options.defaultValue = options.defaultValue !== null ? options.defaultValue : false; + ActionStoreConstant.call(this, options); +}; +util.inherits(ActionStoreTrue, ActionStoreConstant); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/subparsers.js b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/subparsers.js new file mode 100644 index 0000000000000000000000000000000000000000..99dfedd0f1aa02e7a55cc9b75512e31f40f382d4 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/subparsers.js @@ -0,0 +1,149 @@ +/** internal + * class ActionSubparsers + * + * Support the creation of such sub-commands with the addSubparsers() + * + * This class inherited from [[Action]] + **/ +'use strict'; + +var util = require('util'); +var format = require('util').format; + + +var Action = require('../action'); + +// Constants +var c = require('../const'); + +// Errors +var argumentErrorHelper = require('../argument/error'); + + +/*:nodoc:* + * new ChoicesPseudoAction(name, help) + * + * Create pseudo action for correct help text + * + **/ +function ChoicesPseudoAction(name, help) { + var options = { + optionStrings: [], + dest: name, + help: help + }; + + Action.call(this, options); +} + +util.inherits(ChoicesPseudoAction, Action); + +/** + * new ActionSubparsers(options) + * - options (object): options hash see [[Action.new]] + * + **/ +function ActionSubparsers(options) { + options = options || {}; + options.dest = options.dest || c.SUPPRESS; + options.nargs = c.PARSER; + + this.debug = (options.debug === true); + + this._progPrefix = options.prog; + this._parserClass = options.parserClass; + this._nameParserMap = {}; + this._choicesActions = []; + + options.choices = this._nameParserMap; + Action.call(this, options); +} + +util.inherits(ActionSubparsers, Action); + +/*:nodoc:* + * ActionSubparsers#addParser(name, options) -> ArgumentParser + * - name (string): sub-command name + * - options (object): see [[ArgumentParser.new]] + * + * Note: + * addParser supports an additional aliases option, + * which allows multiple strings to refer to the same subparser. + * This example, like svn, aliases co as a shorthand for checkout + * + **/ +ActionSubparsers.prototype.addParser = function (name, options) { + var parser; + + var self = this; + + options = options || {}; + + options.debug = (this.debug === true); + + // set program from the existing prefix + if (!options.prog) { + options.prog = this._progPrefix + ' ' + name; + } + + var aliases = options.aliases || []; + + // create a pseudo-action to hold the choice help + if (!!options.help || typeof options.help === 'string') { + var help = options.help; + delete options.help; + + var choiceAction = new ChoicesPseudoAction(name, help); + this._choicesActions.push(choiceAction); + } + + // create the parser and add it to the map + parser = new this._parserClass(options); + this._nameParserMap[name] = parser; + + // make parser available under aliases also + aliases.forEach(function (alias) { + self._nameParserMap[alias] = parser; + }); + + return parser; +}; + +ActionSubparsers.prototype._getSubactions = function () { + return this._choicesActions; +}; + +/*:nodoc:* + * ActionSubparsers#call(parser, namespace, values, optionString) -> Void + * - parser (ArgumentParser): current parser + * - namespace (Namespace): namespace for output data + * - values (Array): parsed values + * - optionString (Array): input option string(not parsed) + * + * Call the action. Parse input aguments + **/ +ActionSubparsers.prototype.call = function (parser, namespace, values) { + var parserName = values[0]; + var argStrings = values.slice(1); + + // set the parser name if requested + if (this.dest !== c.SUPPRESS) { + namespace[this.dest] = parserName; + } + + // select the parser + if (this._nameParserMap[parserName]) { + parser = this._nameParserMap[parserName]; + } else { + throw argumentErrorHelper(format( + 'Unknown parser "%s" (choices: [%s]).', + parserName, + Object.keys(this._nameParserMap).join(', ') + )); + } + + // parse all the remaining options into the namespace + parser.parseArgs(argStrings, namespace); +}; + +module.exports = ActionSubparsers; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/version.js b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/version.js new file mode 100644 index 0000000000000000000000000000000000000000..8053328cdef44694a00f2cc31d72818d967ce4dc --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action/version.js @@ -0,0 +1,47 @@ +/*:nodoc:* + * class ActionVersion + * + * Support action for printing program version + * This class inherited from [[Action]] + **/ +'use strict'; + +var util = require('util'); + +var Action = require('../action'); + +// +// Constants +// +var c = require('../const'); + +/*:nodoc:* + * new ActionVersion(options) + * - options (object): options hash see [[Action.new]] + * + **/ +var ActionVersion = module.exports = function ActionVersion(options) { + options = options || {}; + options.defaultValue = (options.defaultValue ? options.defaultValue : c.SUPPRESS); + options.dest = (options.dest || c.SUPPRESS); + options.nargs = 0; + this.version = options.version; + Action.call(this, options); +}; +util.inherits(ActionVersion, Action); + +/*:nodoc:* + * ActionVersion#call(parser, namespace, values, optionString) -> Void + * - parser (ArgumentParser): current parser + * - namespace (Namespace): namespace for output data + * - values (Array): parsed values + * - optionString (Array): input option string(not parsed) + * + * Print version and exit + **/ +ActionVersion.prototype.call = function (parser) { + var version = this.version || parser.version; + var formatter = parser._getFormatter(); + formatter.addText(version); + parser.exit(0, formatter.formatHelp()); +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action_container.js b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action_container.js new file mode 100644 index 0000000000000000000000000000000000000000..6f1237bea23d59b8cb1bb0d8778bcd1e0c1a2c39 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/action_container.js @@ -0,0 +1,482 @@ +/** internal + * class ActionContainer + * + * Action container. Parent for [[ArgumentParser]] and [[ArgumentGroup]] + **/ + +'use strict'; + +var format = require('util').format; + +// Constants +var c = require('./const'); + +var $$ = require('./utils'); + +//Actions +var ActionHelp = require('./action/help'); +var ActionAppend = require('./action/append'); +var ActionAppendConstant = require('./action/append/constant'); +var ActionCount = require('./action/count'); +var ActionStore = require('./action/store'); +var ActionStoreConstant = require('./action/store/constant'); +var ActionStoreTrue = require('./action/store/true'); +var ActionStoreFalse = require('./action/store/false'); +var ActionVersion = require('./action/version'); +var ActionSubparsers = require('./action/subparsers'); + +// Errors +var argumentErrorHelper = require('./argument/error'); + +/** + * new ActionContainer(options) + * + * Action container. Parent for [[ArgumentParser]] and [[ArgumentGroup]] + * + * ##### Options: + * + * - `description` -- A description of what the program does + * - `prefixChars` -- Characters that prefix optional arguments + * - `argumentDefault` -- The default value for all arguments + * - `conflictHandler` -- The conflict handler to use for duplicate arguments + **/ +var ActionContainer = module.exports = function ActionContainer(options) { + options = options || {}; + + this.description = options.description; + this.argumentDefault = options.argumentDefault; + this.prefixChars = options.prefixChars || ''; + this.conflictHandler = options.conflictHandler; + + // set up registries + this._registries = {}; + + // register actions + this.register('action', null, ActionStore); + this.register('action', 'store', ActionStore); + this.register('action', 'storeConst', ActionStoreConstant); + this.register('action', 'storeTrue', ActionStoreTrue); + this.register('action', 'storeFalse', ActionStoreFalse); + this.register('action', 'append', ActionAppend); + this.register('action', 'appendConst', ActionAppendConstant); + this.register('action', 'count', ActionCount); + this.register('action', 'help', ActionHelp); + this.register('action', 'version', ActionVersion); + this.register('action', 'parsers', ActionSubparsers); + + // raise an exception if the conflict handler is invalid + this._getHandler(); + + // action storage + this._actions = []; + this._optionStringActions = {}; + + // groups + this._actionGroups = []; + this._mutuallyExclusiveGroups = []; + + // defaults storage + this._defaults = {}; + + // determines whether an "option" looks like a negative number + // -1, -1.5 -5e+4 + this._regexpNegativeNumber = new RegExp('^[-]?[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?$'); + + // whether or not there are any optionals that look like negative + // numbers -- uses a list so it can be shared and edited + this._hasNegativeNumberOptionals = []; +}; + +// Groups must be required, then ActionContainer already defined +var ArgumentGroup = require('./argument/group'); +var MutuallyExclusiveGroup = require('./argument/exclusive'); + +// +// Registration methods +// + +/** + * ActionContainer#register(registryName, value, object) -> Void + * - registryName (String) : object type action|type + * - value (string) : keyword + * - object (Object|Function) : handler + * + * Register handlers + **/ +ActionContainer.prototype.register = function (registryName, value, object) { + this._registries[registryName] = this._registries[registryName] || {}; + this._registries[registryName][value] = object; +}; + +ActionContainer.prototype._registryGet = function (registryName, value, defaultValue) { + if (arguments.length < 3) { + defaultValue = null; + } + return this._registries[registryName][value] || defaultValue; +}; + +// +// Namespace default accessor methods +// + +/** + * ActionContainer#setDefaults(options) -> Void + * - options (object):hash of options see [[Action.new]] + * + * Set defaults + **/ +ActionContainer.prototype.setDefaults = function (options) { + options = options || {}; + for (var property in options) { + if ($$.has(options, property)) { + this._defaults[property] = options[property]; + } + } + + // if these defaults match any existing arguments, replace the previous + // default on the object with the new one + this._actions.forEach(function (action) { + if ($$.has(options, action.dest)) { + action.defaultValue = options[action.dest]; + } + }); +}; + +/** + * ActionContainer#getDefault(dest) -> Mixed + * - dest (string): action destination + * + * Return action default value + **/ +ActionContainer.prototype.getDefault = function (dest) { + var result = $$.has(this._defaults, dest) ? this._defaults[dest] : null; + + this._actions.forEach(function (action) { + if (action.dest === dest && $$.has(action, 'defaultValue')) { + result = action.defaultValue; + } + }); + + return result; +}; +// +// Adding argument actions +// + +/** + * ActionContainer#addArgument(args, options) -> Object + * - args (String|Array): argument key, or array of argument keys + * - options (Object): action objects see [[Action.new]] + * + * #### Examples + * - addArgument([ '-f', '--foo' ], { action: 'store', defaultValue: 1, ... }) + * - addArgument([ 'bar' ], { action: 'store', nargs: 1, ... }) + * - addArgument('--baz', { action: 'store', nargs: 1, ... }) + **/ +ActionContainer.prototype.addArgument = function (args, options) { + args = args; + options = options || {}; + + if (typeof args === 'string') { + args = [ args ]; + } + if (!Array.isArray(args)) { + throw new TypeError('addArgument first argument should be a string or an array'); + } + if (typeof options !== 'object' || Array.isArray(options)) { + throw new TypeError('addArgument second argument should be a hash'); + } + + // if no positional args are supplied or only one is supplied and + // it doesn't look like an option string, parse a positional argument + if (!args || args.length === 1 && this.prefixChars.indexOf(args[0][0]) < 0) { + if (args && !!options.dest) { + throw new Error('dest supplied twice for positional argument'); + } + options = this._getPositional(args, options); + + // otherwise, we're adding an optional argument + } else { + options = this._getOptional(args, options); + } + + // if no default was supplied, use the parser-level default + if (typeof options.defaultValue === 'undefined') { + var dest = options.dest; + if ($$.has(this._defaults, dest)) { + options.defaultValue = this._defaults[dest]; + } else if (typeof this.argumentDefault !== 'undefined') { + options.defaultValue = this.argumentDefault; + } + } + + // create the action object, and add it to the parser + var ActionClass = this._popActionClass(options); + if (typeof ActionClass !== 'function') { + throw new Error(format('Unknown action "%s".', ActionClass)); + } + var action = new ActionClass(options); + + // throw an error if the action type is not callable + var typeFunction = this._registryGet('type', action.type, action.type); + if (typeof typeFunction !== 'function') { + throw new Error(format('"%s" is not callable', typeFunction)); + } + + return this._addAction(action); +}; + +/** + * ActionContainer#addArgumentGroup(options) -> ArgumentGroup + * - options (Object): hash of options see [[ArgumentGroup.new]] + * + * Create new arguments groups + **/ +ActionContainer.prototype.addArgumentGroup = function (options) { + var group = new ArgumentGroup(this, options); + this._actionGroups.push(group); + return group; +}; + +/** + * ActionContainer#addMutuallyExclusiveGroup(options) -> ArgumentGroup + * - options (Object): {required: false} + * + * Create new mutual exclusive groups + **/ +ActionContainer.prototype.addMutuallyExclusiveGroup = function (options) { + var group = new MutuallyExclusiveGroup(this, options); + this._mutuallyExclusiveGroups.push(group); + return group; +}; + +ActionContainer.prototype._addAction = function (action) { + var self = this; + + // resolve any conflicts + this._checkConflict(action); + + // add to actions list + this._actions.push(action); + action.container = this; + + // index the action by any option strings it has + action.optionStrings.forEach(function (optionString) { + self._optionStringActions[optionString] = action; + }); + + // set the flag if any option strings look like negative numbers + action.optionStrings.forEach(function (optionString) { + if (optionString.match(self._regexpNegativeNumber)) { + if (!self._hasNegativeNumberOptionals.some(Boolean)) { + self._hasNegativeNumberOptionals.push(true); + } + } + }); + + // return the created action + return action; +}; + +ActionContainer.prototype._removeAction = function (action) { + var actionIndex = this._actions.indexOf(action); + if (actionIndex >= 0) { + this._actions.splice(actionIndex, 1); + } +}; + +ActionContainer.prototype._addContainerActions = function (container) { + // collect groups by titles + var titleGroupMap = {}; + this._actionGroups.forEach(function (group) { + if (titleGroupMap[group.title]) { + throw new Error(format('Cannot merge actions - two groups are named "%s".', group.title)); + } + titleGroupMap[group.title] = group; + }); + + // map each action to its group + var groupMap = {}; + function actionHash(action) { + // unique (hopefully?) string suitable as dictionary key + return action.getName(); + } + container._actionGroups.forEach(function (group) { + // if a group with the title exists, use that, otherwise + // create a new group matching the container's group + if (!titleGroupMap[group.title]) { + titleGroupMap[group.title] = this.addArgumentGroup({ + title: group.title, + description: group.description + }); + } + + // map the actions to their new group + group._groupActions.forEach(function (action) { + groupMap[actionHash(action)] = titleGroupMap[group.title]; + }); + }, this); + + // add container's mutually exclusive groups + // NOTE: if add_mutually_exclusive_group ever gains title= and + // description= then this code will need to be expanded as above + var mutexGroup; + container._mutuallyExclusiveGroups.forEach(function (group) { + mutexGroup = this.addMutuallyExclusiveGroup({ + required: group.required + }); + // map the actions to their new mutex group + group._groupActions.forEach(function (action) { + groupMap[actionHash(action)] = mutexGroup; + }); + }, this); // forEach takes a 'this' argument + + // add all actions to this container or their group + container._actions.forEach(function (action) { + var key = actionHash(action); + if (groupMap[key]) { + groupMap[key]._addAction(action); + } else { + this._addAction(action); + } + }); +}; + +ActionContainer.prototype._getPositional = function (dest, options) { + if (Array.isArray(dest)) { + dest = dest[0]; + } + // make sure required is not specified + if (options.required) { + throw new Error('"required" is an invalid argument for positionals.'); + } + + // mark positional arguments as required if at least one is + // always required + if (options.nargs !== c.OPTIONAL && options.nargs !== c.ZERO_OR_MORE) { + options.required = true; + } + if (options.nargs === c.ZERO_OR_MORE && typeof options.defaultValue === 'undefined') { + options.required = true; + } + + // return the keyword arguments with no option strings + options.dest = dest; + options.optionStrings = []; + return options; +}; + +ActionContainer.prototype._getOptional = function (args, options) { + var prefixChars = this.prefixChars; + var optionStrings = []; + var optionStringsLong = []; + + // determine short and long option strings + args.forEach(function (optionString) { + // error on strings that don't start with an appropriate prefix + if (prefixChars.indexOf(optionString[0]) < 0) { + throw new Error(format('Invalid option string "%s": must start with a "%s".', + optionString, + prefixChars + )); + } + + // strings starting with two prefix characters are long options + optionStrings.push(optionString); + if (optionString.length > 1 && prefixChars.indexOf(optionString[1]) >= 0) { + optionStringsLong.push(optionString); + } + }); + + // infer dest, '--foo-bar' -> 'foo_bar' and '-x' -> 'x' + var dest = options.dest || null; + delete options.dest; + + if (!dest) { + var optionStringDest = optionStringsLong.length ? optionStringsLong[0] : optionStrings[0]; + dest = $$.trimChars(optionStringDest, this.prefixChars); + + if (dest.length === 0) { + throw new Error( + format('dest= is required for options like "%s"', optionStrings.join(', ')) + ); + } + dest = dest.replace(/-/g, '_'); + } + + // return the updated keyword arguments + options.dest = dest; + options.optionStrings = optionStrings; + + return options; +}; + +ActionContainer.prototype._popActionClass = function (options, defaultValue) { + defaultValue = defaultValue || null; + + var action = (options.action || defaultValue); + delete options.action; + + var actionClass = this._registryGet('action', action, action); + return actionClass; +}; + +ActionContainer.prototype._getHandler = function () { + var handlerString = this.conflictHandler; + var handlerFuncName = '_handleConflict' + $$.capitalize(handlerString); + var func = this[handlerFuncName]; + if (typeof func === 'undefined') { + var msg = 'invalid conflict resolution value: ' + handlerString; + throw new Error(msg); + } else { + return func; + } +}; + +ActionContainer.prototype._checkConflict = function (action) { + var optionStringActions = this._optionStringActions; + var conflictOptionals = []; + + // find all options that conflict with this option + // collect pairs, the string, and an existing action that it conflicts with + action.optionStrings.forEach(function (optionString) { + var conflOptional = optionStringActions[optionString]; + if (typeof conflOptional !== 'undefined') { + conflictOptionals.push([ optionString, conflOptional ]); + } + }); + + if (conflictOptionals.length > 0) { + var conflictHandler = this._getHandler(); + conflictHandler.call(this, action, conflictOptionals); + } +}; + +ActionContainer.prototype._handleConflictError = function (action, conflOptionals) { + var conflicts = conflOptionals.map(function (pair) { return pair[0]; }); + conflicts = conflicts.join(', '); + throw argumentErrorHelper( + action, + format('Conflicting option string(s): %s', conflicts) + ); +}; + +ActionContainer.prototype._handleConflictResolve = function (action, conflOptionals) { + // remove all conflicting options + var self = this; + conflOptionals.forEach(function (pair) { + var optionString = pair[0]; + var conflictingAction = pair[1]; + // remove the conflicting option string + var i = conflictingAction.optionStrings.indexOf(optionString); + if (i >= 0) { + conflictingAction.optionStrings.splice(i, 1); + } + delete self._optionStringActions[optionString]; + // if the option now has no option string, remove it from the + // container holding it + if (conflictingAction.optionStrings.length === 0) { + conflictingAction.container._removeAction(conflictingAction); + } + }); +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/argparse.js b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/argparse.js new file mode 100644 index 0000000000000000000000000000000000000000..f2a2c51d9a8917bc2089cf662b84a1032ecd6ddd --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/argparse.js @@ -0,0 +1,14 @@ +'use strict'; + +module.exports.ArgumentParser = require('./argument_parser.js'); +module.exports.Namespace = require('./namespace'); +module.exports.Action = require('./action'); +module.exports.HelpFormatter = require('./help/formatter.js'); +module.exports.Const = require('./const.js'); + +module.exports.ArgumentDefaultsHelpFormatter = + require('./help/added_formatters.js').ArgumentDefaultsHelpFormatter; +module.exports.RawDescriptionHelpFormatter = + require('./help/added_formatters.js').RawDescriptionHelpFormatter; +module.exports.RawTextHelpFormatter = + require('./help/added_formatters.js').RawTextHelpFormatter; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/argument/error.js b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/argument/error.js new file mode 100644 index 0000000000000000000000000000000000000000..c8a02a08b8fbafb1c4f609f1f7195a84042e619a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/argument/error.js @@ -0,0 +1,50 @@ +'use strict'; + + +var format = require('util').format; + + +var ERR_CODE = 'ARGError'; + +/*:nodoc:* + * argumentError(argument, message) -> TypeError + * - argument (Object): action with broken argument + * - message (String): error message + * + * Error format helper. An error from creating or using an argument + * (optional or positional). The string value of this exception + * is the message, augmented with information + * about the argument that caused it. + * + * #####Example + * + * var argumentErrorHelper = require('./argument/error'); + * if (conflictOptionals.length > 0) { + * throw argumentErrorHelper( + * action, + * format('Conflicting option string(s): %s', conflictOptionals.join(', ')) + * ); + * } + * + **/ +module.exports = function (argument, message) { + var argumentName = null; + var errMessage; + var err; + + if (argument.getName) { + argumentName = argument.getName(); + } else { + argumentName = '' + argument; + } + + if (!argumentName) { + errMessage = message; + } else { + errMessage = format('argument "%s": %s', argumentName, message); + } + + err = new TypeError(errMessage); + err.code = ERR_CODE; + return err; +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/argument/exclusive.js b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/argument/exclusive.js new file mode 100644 index 0000000000000000000000000000000000000000..8287e00d0464f37c2f5ab02e3750d56c3dc56ff3 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/argument/exclusive.js @@ -0,0 +1,54 @@ +/** internal + * class MutuallyExclusiveGroup + * + * Group arguments. + * By default, ArgumentParser groups command-line arguments + * into “positional arguments” and “optional arguments” + * when displaying help messages. When there is a better + * conceptual grouping of arguments than this default one, + * appropriate groups can be created using the addArgumentGroup() method + * + * This class inherited from [[ArgumentContainer]] + **/ +'use strict'; + +var util = require('util'); + +var ArgumentGroup = require('./group'); + +/** + * new MutuallyExclusiveGroup(container, options) + * - container (object): main container + * - options (object): options.required -> true/false + * + * `required` could be an argument itself, but making it a property of + * the options argument is more consistent with the JS adaptation of the Python) + **/ +var MutuallyExclusiveGroup = module.exports = function MutuallyExclusiveGroup(container, options) { + var required; + options = options || {}; + required = options.required || false; + ArgumentGroup.call(this, container); + this.required = required; + +}; +util.inherits(MutuallyExclusiveGroup, ArgumentGroup); + + +MutuallyExclusiveGroup.prototype._addAction = function (action) { + var msg; + if (action.required) { + msg = 'mutually exclusive arguments must be optional'; + throw new Error(msg); + } + action = this._container._addAction(action); + this._groupActions.push(action); + return action; +}; + + +MutuallyExclusiveGroup.prototype._removeAction = function (action) { + this._container._removeAction(action); + this._groupActions.remove(action); +}; + diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/argument/group.js b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/argument/group.js new file mode 100644 index 0000000000000000000000000000000000000000..58b271f2fec8d005065c9001c2fb65b960185fd0 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/argument/group.js @@ -0,0 +1,75 @@ +/** internal + * class ArgumentGroup + * + * Group arguments. + * By default, ArgumentParser groups command-line arguments + * into “positional arguments” and “optional arguments” + * when displaying help messages. When there is a better + * conceptual grouping of arguments than this default one, + * appropriate groups can be created using the addArgumentGroup() method + * + * This class inherited from [[ArgumentContainer]] + **/ +'use strict'; + +var util = require('util'); + +var ActionContainer = require('../action_container'); + + +/** + * new ArgumentGroup(container, options) + * - container (object): main container + * - options (object): hash of group options + * + * #### options + * - **prefixChars** group name prefix + * - **argumentDefault** default argument value + * - **title** group title + * - **description** group description + * + **/ +var ArgumentGroup = module.exports = function ArgumentGroup(container, options) { + + options = options || {}; + + // add any missing keyword arguments by checking the container + options.conflictHandler = (options.conflictHandler || container.conflictHandler); + options.prefixChars = (options.prefixChars || container.prefixChars); + options.argumentDefault = (options.argumentDefault || container.argumentDefault); + + ActionContainer.call(this, options); + + // group attributes + this.title = options.title; + this._groupActions = []; + + // share most attributes with the container + this._container = container; + this._registries = container._registries; + this._actions = container._actions; + this._optionStringActions = container._optionStringActions; + this._defaults = container._defaults; + this._hasNegativeNumberOptionals = container._hasNegativeNumberOptionals; + this._mutuallyExclusiveGroups = container._mutuallyExclusiveGroups; +}; +util.inherits(ArgumentGroup, ActionContainer); + + +ArgumentGroup.prototype._addAction = function (action) { + // Parent add action + action = ActionContainer.prototype._addAction.call(this, action); + this._groupActions.push(action); + return action; +}; + + +ArgumentGroup.prototype._removeAction = function (action) { + // Parent remove action + ActionContainer.prototype._removeAction.call(this, action); + var actionIndex = this._groupActions.indexOf(action); + if (actionIndex >= 0) { + this._groupActions.splice(actionIndex, 1); + } +}; + diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/argument_parser.js b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/argument_parser.js new file mode 100644 index 0000000000000000000000000000000000000000..bd9a59a453c946f47032be60f4b26ca0430fbe0f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/argument_parser.js @@ -0,0 +1,1161 @@ +/** + * class ArgumentParser + * + * Object for parsing command line strings into js objects. + * + * Inherited from [[ActionContainer]] + **/ +'use strict'; + +var util = require('util'); +var format = require('util').format; +var Path = require('path'); +var sprintf = require('sprintf-js').sprintf; + +// Constants +var c = require('./const'); + +var $$ = require('./utils'); + +var ActionContainer = require('./action_container'); + +// Errors +var argumentErrorHelper = require('./argument/error'); + +var HelpFormatter = require('./help/formatter'); + +var Namespace = require('./namespace'); + + +/** + * new ArgumentParser(options) + * + * Create a new ArgumentParser object. + * + * ##### Options: + * - `prog` The name of the program (default: Path.basename(process.argv[1])) + * - `usage` A usage message (default: auto-generated from arguments) + * - `description` A description of what the program does + * - `epilog` Text following the argument descriptions + * - `parents` Parsers whose arguments should be copied into this one + * - `formatterClass` HelpFormatter class for printing help messages + * - `prefixChars` Characters that prefix optional arguments + * - `fromfilePrefixChars` Characters that prefix files containing additional arguments + * - `argumentDefault` The default value for all arguments + * - `addHelp` Add a -h/-help option + * - `conflictHandler` Specifies how to handle conflicting argument names + * - `debug` Enable debug mode. Argument errors throw exception in + * debug mode and process.exit in normal. Used for development and + * testing (default: false) + * + * See also [original guide][1] + * + * [1]:http://docs.python.org/dev/library/argparse.html#argumentparser-objects + **/ +function ArgumentParser(options) { + if (!(this instanceof ArgumentParser)) { + return new ArgumentParser(options); + } + var self = this; + options = options || {}; + + options.description = (options.description || null); + options.argumentDefault = (options.argumentDefault || null); + options.prefixChars = (options.prefixChars || '-'); + options.conflictHandler = (options.conflictHandler || 'error'); + ActionContainer.call(this, options); + + options.addHelp = typeof options.addHelp === 'undefined' || !!options.addHelp; + options.parents = options.parents || []; + // default program name + options.prog = (options.prog || Path.basename(process.argv[1])); + this.prog = options.prog; + this.usage = options.usage; + this.epilog = options.epilog; + this.version = options.version; + + this.debug = (options.debug === true); + + this.formatterClass = (options.formatterClass || HelpFormatter); + this.fromfilePrefixChars = options.fromfilePrefixChars || null; + this._positionals = this.addArgumentGroup({ title: 'Positional arguments' }); + this._optionals = this.addArgumentGroup({ title: 'Optional arguments' }); + this._subparsers = null; + + // register types + function FUNCTION_IDENTITY(o) { + return o; + } + this.register('type', 'auto', FUNCTION_IDENTITY); + this.register('type', null, FUNCTION_IDENTITY); + this.register('type', 'int', function (x) { + var result = parseInt(x, 10); + if (isNaN(result)) { + throw new Error(x + ' is not a valid integer.'); + } + return result; + }); + this.register('type', 'float', function (x) { + var result = parseFloat(x); + if (isNaN(result)) { + throw new Error(x + ' is not a valid float.'); + } + return result; + }); + this.register('type', 'string', function (x) { + return '' + x; + }); + + // add help and version arguments if necessary + var defaultPrefix = (this.prefixChars.indexOf('-') > -1) ? '-' : this.prefixChars[0]; + if (options.addHelp) { + this.addArgument( + [ defaultPrefix + 'h', defaultPrefix + defaultPrefix + 'help' ], + { + action: 'help', + defaultValue: c.SUPPRESS, + help: 'Show this help message and exit.' + } + ); + } + if (typeof this.version !== 'undefined') { + this.addArgument( + [ defaultPrefix + 'v', defaultPrefix + defaultPrefix + 'version' ], + { + action: 'version', + version: this.version, + defaultValue: c.SUPPRESS, + help: "Show program's version number and exit." + } + ); + } + + // add parent arguments and defaults + options.parents.forEach(function (parent) { + self._addContainerActions(parent); + if (typeof parent._defaults !== 'undefined') { + for (var defaultKey in parent._defaults) { + if (parent._defaults.hasOwnProperty(defaultKey)) { + self._defaults[defaultKey] = parent._defaults[defaultKey]; + } + } + } + }); +} + +util.inherits(ArgumentParser, ActionContainer); + +/** + * ArgumentParser#addSubparsers(options) -> [[ActionSubparsers]] + * - options (object): hash of options see [[ActionSubparsers.new]] + * + * See also [subcommands][1] + * + * [1]:http://docs.python.org/dev/library/argparse.html#sub-commands + **/ +ArgumentParser.prototype.addSubparsers = function (options) { + if (this._subparsers) { + this.error('Cannot have multiple subparser arguments.'); + } + + options = options || {}; + options.debug = (this.debug === true); + options.optionStrings = []; + options.parserClass = (options.parserClass || ArgumentParser); + + + if (!!options.title || !!options.description) { + + this._subparsers = this.addArgumentGroup({ + title: (options.title || 'subcommands'), + description: options.description + }); + delete options.title; + delete options.description; + + } else { + this._subparsers = this._positionals; + } + + // prog defaults to the usage message of this parser, skipping + // optional arguments and with no "usage:" prefix + if (!options.prog) { + var formatter = this._getFormatter(); + var positionals = this._getPositionalActions(); + var groups = this._mutuallyExclusiveGroups; + formatter.addUsage(this.usage, positionals, groups, ''); + options.prog = formatter.formatHelp().trim(); + } + + // create the parsers action and add it to the positionals list + var ParsersClass = this._popActionClass(options, 'parsers'); + var action = new ParsersClass(options); + this._subparsers._addAction(action); + + // return the created parsers action + return action; +}; + +ArgumentParser.prototype._addAction = function (action) { + if (action.isOptional()) { + this._optionals._addAction(action); + } else { + this._positionals._addAction(action); + } + return action; +}; + +ArgumentParser.prototype._getOptionalActions = function () { + return this._actions.filter(function (action) { + return action.isOptional(); + }); +}; + +ArgumentParser.prototype._getPositionalActions = function () { + return this._actions.filter(function (action) { + return action.isPositional(); + }); +}; + + +/** + * ArgumentParser#parseArgs(args, namespace) -> Namespace|Object + * - args (array): input elements + * - namespace (Namespace|Object): result object + * + * Parsed args and throws error if some arguments are not recognized + * + * See also [original guide][1] + * + * [1]:http://docs.python.org/dev/library/argparse.html#the-parse-args-method + **/ +ArgumentParser.prototype.parseArgs = function (args, namespace) { + var argv; + var result = this.parseKnownArgs(args, namespace); + + args = result[0]; + argv = result[1]; + if (argv && argv.length > 0) { + this.error( + format('Unrecognized arguments: %s.', argv.join(' ')) + ); + } + return args; +}; + +/** + * ArgumentParser#parseKnownArgs(args, namespace) -> array + * - args (array): input options + * - namespace (Namespace|Object): result object + * + * Parse known arguments and return tuple of result object + * and unknown args + * + * See also [original guide][1] + * + * [1]:http://docs.python.org/dev/library/argparse.html#partial-parsing + **/ +ArgumentParser.prototype.parseKnownArgs = function (args, namespace) { + var self = this; + + // args default to the system args + args = args || process.argv.slice(2); + + // default Namespace built from parser defaults + namespace = namespace || new Namespace(); + + self._actions.forEach(function (action) { + if (action.dest !== c.SUPPRESS) { + if (!$$.has(namespace, action.dest)) { + if (action.defaultValue !== c.SUPPRESS) { + var defaultValue = action.defaultValue; + if (typeof action.defaultValue === 'string') { + defaultValue = self._getValue(action, defaultValue); + } + namespace[action.dest] = defaultValue; + } + } + } + }); + + Object.keys(self._defaults).forEach(function (dest) { + namespace[dest] = self._defaults[dest]; + }); + + // parse the arguments and exit if there are any errors + try { + var res = this._parseKnownArgs(args, namespace); + + namespace = res[0]; + args = res[1]; + if ($$.has(namespace, c._UNRECOGNIZED_ARGS_ATTR)) { + args = $$.arrayUnion(args, namespace[c._UNRECOGNIZED_ARGS_ATTR]); + delete namespace[c._UNRECOGNIZED_ARGS_ATTR]; + } + return [ namespace, args ]; + } catch (e) { + this.error(e); + } +}; + +ArgumentParser.prototype._parseKnownArgs = function (argStrings, namespace) { + var self = this; + + var extras = []; + + // replace arg strings that are file references + if (this.fromfilePrefixChars !== null) { + argStrings = this._readArgsFromFiles(argStrings); + } + // map all mutually exclusive arguments to the other arguments + // they can't occur with + // Python has 'conflicts = action_conflicts.setdefault(mutex_action, [])' + // though I can't conceive of a way in which an action could be a member + // of two different mutually exclusive groups. + + function actionHash(action) { + // some sort of hashable key for this action + // action itself cannot be a key in actionConflicts + // I think getName() (join of optionStrings) is unique enough + return action.getName(); + } + + var conflicts, key; + var actionConflicts = {}; + + this._mutuallyExclusiveGroups.forEach(function (mutexGroup) { + mutexGroup._groupActions.forEach(function (mutexAction, i, groupActions) { + key = actionHash(mutexAction); + if (!$$.has(actionConflicts, key)) { + actionConflicts[key] = []; + } + conflicts = actionConflicts[key]; + conflicts.push.apply(conflicts, groupActions.slice(0, i)); + conflicts.push.apply(conflicts, groupActions.slice(i + 1)); + }); + }); + + // find all option indices, and determine the arg_string_pattern + // which has an 'O' if there is an option at an index, + // an 'A' if there is an argument, or a '-' if there is a '--' + var optionStringIndices = {}; + + var argStringPatternParts = []; + + argStrings.forEach(function (argString, argStringIndex) { + if (argString === '--') { + argStringPatternParts.push('-'); + while (argStringIndex < argStrings.length) { + argStringPatternParts.push('A'); + argStringIndex++; + } + } else { + // otherwise, add the arg to the arg strings + // and note the index if it was an option + var pattern; + var optionTuple = self._parseOptional(argString); + if (!optionTuple) { + pattern = 'A'; + } else { + optionStringIndices[argStringIndex] = optionTuple; + pattern = 'O'; + } + argStringPatternParts.push(pattern); + } + }); + var argStringsPattern = argStringPatternParts.join(''); + + var seenActions = []; + var seenNonDefaultActions = []; + + + function takeAction(action, argumentStrings, optionString) { + seenActions.push(action); + var argumentValues = self._getValues(action, argumentStrings); + + // error if this argument is not allowed with other previously + // seen arguments, assuming that actions that use the default + // value don't really count as "present" + if (argumentValues !== action.defaultValue) { + seenNonDefaultActions.push(action); + if (actionConflicts[actionHash(action)]) { + actionConflicts[actionHash(action)].forEach(function (actionConflict) { + if (seenNonDefaultActions.indexOf(actionConflict) >= 0) { + throw argumentErrorHelper( + action, + format('Not allowed with argument "%s".', actionConflict.getName()) + ); + } + }); + } + } + + if (argumentValues !== c.SUPPRESS) { + action.call(self, namespace, argumentValues, optionString); + } + } + + function consumeOptional(startIndex) { + // get the optional identified at this index + var optionTuple = optionStringIndices[startIndex]; + var action = optionTuple[0]; + var optionString = optionTuple[1]; + var explicitArg = optionTuple[2]; + + // identify additional optionals in the same arg string + // (e.g. -xyz is the same as -x -y -z if no args are required) + var actionTuples = []; + + var args, argCount, start, stop; + + for (;;) { + if (!action) { + extras.push(argStrings[startIndex]); + return startIndex + 1; + } + if (explicitArg) { + argCount = self._matchArgument(action, 'A'); + + // if the action is a single-dash option and takes no + // arguments, try to parse more single-dash options out + // of the tail of the option string + var chars = self.prefixChars; + if (argCount === 0 && chars.indexOf(optionString[1]) < 0) { + actionTuples.push([ action, [], optionString ]); + optionString = optionString[0] + explicitArg[0]; + var newExplicitArg = explicitArg.slice(1) || null; + var optionalsMap = self._optionStringActions; + + if (Object.keys(optionalsMap).indexOf(optionString) >= 0) { + action = optionalsMap[optionString]; + explicitArg = newExplicitArg; + } else { + throw argumentErrorHelper(action, sprintf('ignored explicit argument %r', explicitArg)); + } + } else if (argCount === 1) { + // if the action expect exactly one argument, we've + // successfully matched the option; exit the loop + stop = startIndex + 1; + args = [ explicitArg ]; + actionTuples.push([ action, args, optionString ]); + break; + } else { + // error if a double-dash option did not use the + // explicit argument + throw argumentErrorHelper(action, sprintf('ignored explicit argument %r', explicitArg)); + } + } else { + // if there is no explicit argument, try to match the + // optional's string arguments with the following strings + // if successful, exit the loop + + start = startIndex + 1; + var selectedPatterns = argStringsPattern.substr(start); + + argCount = self._matchArgument(action, selectedPatterns); + stop = start + argCount; + + + args = argStrings.slice(start, stop); + + actionTuples.push([ action, args, optionString ]); + break; + } + + } + + // add the Optional to the list and return the index at which + // the Optional's string args stopped + if (actionTuples.length < 1) { + throw new Error('length should be > 0'); + } + for (var i = 0; i < actionTuples.length; i++) { + takeAction.apply(self, actionTuples[i]); + } + return stop; + } + + // the list of Positionals left to be parsed; this is modified + // by consume_positionals() + var positionals = self._getPositionalActions(); + + function consumePositionals(startIndex) { + // match as many Positionals as possible + var selectedPattern = argStringsPattern.substr(startIndex); + var argCounts = self._matchArgumentsPartial(positionals, selectedPattern); + + // slice off the appropriate arg strings for each Positional + // and add the Positional and its args to the list + for (var i = 0; i < positionals.length; i++) { + var action = positionals[i]; + var argCount = argCounts[i]; + if (typeof argCount === 'undefined') { + continue; + } + var args = argStrings.slice(startIndex, startIndex + argCount); + + startIndex += argCount; + takeAction(action, args); + } + + // slice off the Positionals that we just parsed and return the + // index at which the Positionals' string args stopped + positionals = positionals.slice(argCounts.length); + return startIndex; + } + + // consume Positionals and Optionals alternately, until we have + // passed the last option string + var startIndex = 0; + var position; + + var maxOptionStringIndex = -1; + + Object.keys(optionStringIndices).forEach(function (position) { + maxOptionStringIndex = Math.max(maxOptionStringIndex, parseInt(position, 10)); + }); + + var positionalsEndIndex, nextOptionStringIndex; + + while (startIndex <= maxOptionStringIndex) { + // consume any Positionals preceding the next option + nextOptionStringIndex = null; + for (position in optionStringIndices) { + if (!optionStringIndices.hasOwnProperty(position)) { continue; } + + position = parseInt(position, 10); + if (position >= startIndex) { + if (nextOptionStringIndex !== null) { + nextOptionStringIndex = Math.min(nextOptionStringIndex, position); + } else { + nextOptionStringIndex = position; + } + } + } + + if (startIndex !== nextOptionStringIndex) { + positionalsEndIndex = consumePositionals(startIndex); + // only try to parse the next optional if we didn't consume + // the option string during the positionals parsing + if (positionalsEndIndex > startIndex) { + startIndex = positionalsEndIndex; + continue; + } else { + startIndex = positionalsEndIndex; + } + } + + // if we consumed all the positionals we could and we're not + // at the index of an option string, there were extra arguments + if (!optionStringIndices[startIndex]) { + var strings = argStrings.slice(startIndex, nextOptionStringIndex); + extras = extras.concat(strings); + startIndex = nextOptionStringIndex; + } + // consume the next optional and any arguments for it + startIndex = consumeOptional(startIndex); + } + + // consume any positionals following the last Optional + var stopIndex = consumePositionals(startIndex); + + // if we didn't consume all the argument strings, there were extras + extras = extras.concat(argStrings.slice(stopIndex)); + + // if we didn't use all the Positional objects, there were too few + // arg strings supplied. + if (positionals.length > 0) { + self.error('too few arguments'); + } + + // make sure all required actions were present + self._actions.forEach(function (action) { + if (action.required) { + if (seenActions.indexOf(action) < 0) { + self.error(format('Argument "%s" is required', action.getName())); + } + } + }); + + // make sure all required groups have one option present + var actionUsed = false; + self._mutuallyExclusiveGroups.forEach(function (group) { + if (group.required) { + actionUsed = group._groupActions.some(function (action) { + return seenNonDefaultActions.indexOf(action) !== -1; + }); + + // if no actions were used, report the error + if (!actionUsed) { + var names = []; + group._groupActions.forEach(function (action) { + if (action.help !== c.SUPPRESS) { + names.push(action.getName()); + } + }); + names = names.join(' '); + var msg = 'one of the arguments ' + names + ' is required'; + self.error(msg); + } + } + }); + + // return the updated namespace and the extra arguments + return [ namespace, extras ]; +}; + +ArgumentParser.prototype._readArgsFromFiles = function (argStrings) { + // expand arguments referencing files + var self = this; + var fs = require('fs'); + var newArgStrings = []; + argStrings.forEach(function (argString) { + if (self.fromfilePrefixChars.indexOf(argString[0]) < 0) { + // for regular arguments, just add them back into the list + newArgStrings.push(argString); + } else { + // replace arguments referencing files with the file content + try { + var argstrs = []; + var filename = argString.slice(1); + var content = fs.readFileSync(filename, 'utf8'); + content = content.trim().split('\n'); + content.forEach(function (argLine) { + self.convertArgLineToArgs(argLine).forEach(function (arg) { + argstrs.push(arg); + }); + argstrs = self._readArgsFromFiles(argstrs); + }); + newArgStrings.push.apply(newArgStrings, argstrs); + } catch (error) { + return self.error(error.message); + } + } + }); + return newArgStrings; +}; + +ArgumentParser.prototype.convertArgLineToArgs = function (argLine) { + return [ argLine ]; +}; + +ArgumentParser.prototype._matchArgument = function (action, regexpArgStrings) { + + // match the pattern for this action to the arg strings + var regexpNargs = new RegExp('^' + this._getNargsPattern(action)); + var matches = regexpArgStrings.match(regexpNargs); + var message; + + // throw an exception if we weren't able to find a match + if (!matches) { + switch (action.nargs) { + /*eslint-disable no-undefined*/ + case undefined: + case null: + message = 'Expected one argument.'; + break; + case c.OPTIONAL: + message = 'Expected at most one argument.'; + break; + case c.ONE_OR_MORE: + message = 'Expected at least one argument.'; + break; + default: + message = 'Expected %s argument(s)'; + } + + throw argumentErrorHelper( + action, + format(message, action.nargs) + ); + } + // return the number of arguments matched + return matches[1].length; +}; + +ArgumentParser.prototype._matchArgumentsPartial = function (actions, regexpArgStrings) { + // progressively shorten the actions list by slicing off the + // final actions until we find a match + var self = this; + var result = []; + var actionSlice, pattern, matches; + var i, j; + + function getLength(string) { + return string.length; + } + + for (i = actions.length; i > 0; i--) { + pattern = ''; + actionSlice = actions.slice(0, i); + for (j = 0; j < actionSlice.length; j++) { + pattern += self._getNargsPattern(actionSlice[j]); + } + + pattern = new RegExp('^' + pattern); + matches = regexpArgStrings.match(pattern); + + if (matches && matches.length > 0) { + // need only groups + matches = matches.splice(1); + result = result.concat(matches.map(getLength)); + break; + } + } + + // return the list of arg string counts + return result; +}; + +ArgumentParser.prototype._parseOptional = function (argString) { + var action, optionString, argExplicit, optionTuples; + + // if it's an empty string, it was meant to be a positional + if (!argString) { + return null; + } + + // if it doesn't start with a prefix, it was meant to be positional + if (this.prefixChars.indexOf(argString[0]) < 0) { + return null; + } + + // if the option string is present in the parser, return the action + if (this._optionStringActions[argString]) { + return [ this._optionStringActions[argString], argString, null ]; + } + + // if it's just a single character, it was meant to be positional + if (argString.length === 1) { + return null; + } + + // if the option string before the "=" is present, return the action + if (argString.indexOf('=') >= 0) { + optionString = argString.split('=', 1)[0]; + argExplicit = argString.slice(optionString.length + 1); + + if (this._optionStringActions[optionString]) { + action = this._optionStringActions[optionString]; + return [ action, optionString, argExplicit ]; + } + } + + // search through all possible prefixes of the option string + // and all actions in the parser for possible interpretations + optionTuples = this._getOptionTuples(argString); + + // if multiple actions match, the option string was ambiguous + if (optionTuples.length > 1) { + var optionStrings = optionTuples.map(function (optionTuple) { + return optionTuple[1]; + }); + this.error(format( + 'Ambiguous option: "%s" could match %s.', + argString, optionStrings.join(', ') + )); + // if exactly one action matched, this segmentation is good, + // so return the parsed action + } else if (optionTuples.length === 1) { + return optionTuples[0]; + } + + // if it was not found as an option, but it looks like a negative + // number, it was meant to be positional + // unless there are negative-number-like options + if (argString.match(this._regexpNegativeNumber)) { + if (!this._hasNegativeNumberOptionals.some(Boolean)) { + return null; + } + } + // if it contains a space, it was meant to be a positional + if (argString.search(' ') >= 0) { + return null; + } + + // it was meant to be an optional but there is no such option + // in this parser (though it might be a valid option in a subparser) + return [ null, argString, null ]; +}; + +ArgumentParser.prototype._getOptionTuples = function (optionString) { + var result = []; + var chars = this.prefixChars; + var optionPrefix; + var argExplicit; + var action; + var actionOptionString; + + // option strings starting with two prefix characters are only split at + // the '=' + if (chars.indexOf(optionString[0]) >= 0 && chars.indexOf(optionString[1]) >= 0) { + if (optionString.indexOf('=') >= 0) { + var optionStringSplit = optionString.split('=', 1); + + optionPrefix = optionStringSplit[0]; + argExplicit = optionStringSplit[1]; + } else { + optionPrefix = optionString; + argExplicit = null; + } + + for (actionOptionString in this._optionStringActions) { + if (actionOptionString.substr(0, optionPrefix.length) === optionPrefix) { + action = this._optionStringActions[actionOptionString]; + result.push([ action, actionOptionString, argExplicit ]); + } + } + + // single character options can be concatenated with their arguments + // but multiple character options always have to have their argument + // separate + } else if (chars.indexOf(optionString[0]) >= 0 && chars.indexOf(optionString[1]) < 0) { + optionPrefix = optionString; + argExplicit = null; + var optionPrefixShort = optionString.substr(0, 2); + var argExplicitShort = optionString.substr(2); + + for (actionOptionString in this._optionStringActions) { + if (!$$.has(this._optionStringActions, actionOptionString)) continue; + + action = this._optionStringActions[actionOptionString]; + if (actionOptionString === optionPrefixShort) { + result.push([ action, actionOptionString, argExplicitShort ]); + } else if (actionOptionString.substr(0, optionPrefix.length) === optionPrefix) { + result.push([ action, actionOptionString, argExplicit ]); + } + } + + // shouldn't ever get here + } else { + throw new Error(format('Unexpected option string: %s.', optionString)); + } + // return the collected option tuples + return result; +}; + +ArgumentParser.prototype._getNargsPattern = function (action) { + // in all examples below, we have to allow for '--' args + // which are represented as '-' in the pattern + var regexpNargs; + + switch (action.nargs) { + // the default (null) is assumed to be a single argument + case undefined: + case null: + regexpNargs = '(-*A-*)'; + break; + // allow zero or more arguments + case c.OPTIONAL: + regexpNargs = '(-*A?-*)'; + break; + // allow zero or more arguments + case c.ZERO_OR_MORE: + regexpNargs = '(-*[A-]*)'; + break; + // allow one or more arguments + case c.ONE_OR_MORE: + regexpNargs = '(-*A[A-]*)'; + break; + // allow any number of options or arguments + case c.REMAINDER: + regexpNargs = '([-AO]*)'; + break; + // allow one argument followed by any number of options or arguments + case c.PARSER: + regexpNargs = '(-*A[-AO]*)'; + break; + // all others should be integers + default: + regexpNargs = '(-*' + $$.repeat('-*A', action.nargs) + '-*)'; + } + + // if this is an optional action, -- is not allowed + if (action.isOptional()) { + regexpNargs = regexpNargs.replace(/-\*/g, ''); + regexpNargs = regexpNargs.replace(/-/g, ''); + } + + // return the pattern + return regexpNargs; +}; + +// +// Value conversion methods +// + +ArgumentParser.prototype._getValues = function (action, argStrings) { + var self = this; + + // for everything but PARSER args, strip out '--' + if (action.nargs !== c.PARSER && action.nargs !== c.REMAINDER) { + argStrings = argStrings.filter(function (arrayElement) { + return arrayElement !== '--'; + }); + } + + var value, argString; + + // optional argument produces a default when not present + if (argStrings.length === 0 && action.nargs === c.OPTIONAL) { + + value = (action.isOptional()) ? action.constant : action.defaultValue; + + if (typeof (value) === 'string') { + value = this._getValue(action, value); + this._checkValue(action, value); + } + + // when nargs='*' on a positional, if there were no command-line + // args, use the default if it is anything other than None + } else if (argStrings.length === 0 && action.nargs === c.ZERO_OR_MORE && + action.optionStrings.length === 0) { + + value = (action.defaultValue || argStrings); + this._checkValue(action, value); + + // single argument or optional argument produces a single value + } else if (argStrings.length === 1 && + (!action.nargs || action.nargs === c.OPTIONAL)) { + + argString = argStrings[0]; + value = this._getValue(action, argString); + this._checkValue(action, value); + + // REMAINDER arguments convert all values, checking none + } else if (action.nargs === c.REMAINDER) { + value = argStrings.map(function (v) { + return self._getValue(action, v); + }); + + // PARSER arguments convert all values, but check only the first + } else if (action.nargs === c.PARSER) { + value = argStrings.map(function (v) { + return self._getValue(action, v); + }); + this._checkValue(action, value[0]); + + // all other types of nargs produce a list + } else { + value = argStrings.map(function (v) { + return self._getValue(action, v); + }); + value.forEach(function (v) { + self._checkValue(action, v); + }); + } + + // return the converted value + return value; +}; + +ArgumentParser.prototype._getValue = function (action, argString) { + var result; + + var typeFunction = this._registryGet('type', action.type, action.type); + if (typeof typeFunction !== 'function') { + var message = format('%s is not callable', typeFunction); + throw argumentErrorHelper(action, message); + } + + // convert the value to the appropriate type + try { + result = typeFunction(argString); + + // ArgumentTypeErrors indicate errors + // If action.type is not a registered string, it is a function + // Try to deduce its name for inclusion in the error message + // Failing that, include the error message it raised. + } catch (e) { + var name = null; + if (typeof action.type === 'string') { + name = action.type; + } else { + name = action.type.name || action.type.displayName || ''; + } + var msg = format('Invalid %s value: %s', name, argString); + if (name === '') { msg += '\n' + e.message; } + throw argumentErrorHelper(action, msg); + } + // return the converted value + return result; +}; + +ArgumentParser.prototype._checkValue = function (action, value) { + // converted value must be one of the choices (if specified) + var choices = action.choices; + if (choices) { + // choise for argument can by array or string + if ((typeof choices === 'string' || Array.isArray(choices)) && + choices.indexOf(value) !== -1) { + return; + } + // choise for subparsers can by only hash + if (typeof choices === 'object' && !Array.isArray(choices) && choices[value]) { + return; + } + + if (typeof choices === 'string') { + choices = choices.split('').join(', '); + } else if (Array.isArray(choices)) { + choices = choices.join(', '); + } else { + choices = Object.keys(choices).join(', '); + } + var message = format('Invalid choice: %s (choose from [%s])', value, choices); + throw argumentErrorHelper(action, message); + } +}; + +// +// Help formatting methods +// + +/** + * ArgumentParser#formatUsage -> string + * + * Return usage string + * + * See also [original guide][1] + * + * [1]:http://docs.python.org/dev/library/argparse.html#printing-help + **/ +ArgumentParser.prototype.formatUsage = function () { + var formatter = this._getFormatter(); + formatter.addUsage(this.usage, this._actions, this._mutuallyExclusiveGroups); + return formatter.formatHelp(); +}; + +/** + * ArgumentParser#formatHelp -> string + * + * Return help + * + * See also [original guide][1] + * + * [1]:http://docs.python.org/dev/library/argparse.html#printing-help + **/ +ArgumentParser.prototype.formatHelp = function () { + var formatter = this._getFormatter(); + + // usage + formatter.addUsage(this.usage, this._actions, this._mutuallyExclusiveGroups); + + // description + formatter.addText(this.description); + + // positionals, optionals and user-defined groups + this._actionGroups.forEach(function (actionGroup) { + formatter.startSection(actionGroup.title); + formatter.addText(actionGroup.description); + formatter.addArguments(actionGroup._groupActions); + formatter.endSection(); + }); + + // epilog + formatter.addText(this.epilog); + + // determine help from format above + return formatter.formatHelp(); +}; + +ArgumentParser.prototype._getFormatter = function () { + var FormatterClass = this.formatterClass; + var formatter = new FormatterClass({ prog: this.prog }); + return formatter; +}; + +// +// Print functions +// + +/** + * ArgumentParser#printUsage() -> Void + * + * Print usage + * + * See also [original guide][1] + * + * [1]:http://docs.python.org/dev/library/argparse.html#printing-help + **/ +ArgumentParser.prototype.printUsage = function () { + this._printMessage(this.formatUsage()); +}; + +/** + * ArgumentParser#printHelp() -> Void + * + * Print help + * + * See also [original guide][1] + * + * [1]:http://docs.python.org/dev/library/argparse.html#printing-help + **/ +ArgumentParser.prototype.printHelp = function () { + this._printMessage(this.formatHelp()); +}; + +ArgumentParser.prototype._printMessage = function (message, stream) { + if (!stream) { + stream = process.stdout; + } + if (message) { + stream.write('' + message); + } +}; + +// +// Exit functions +// + +/** + * ArgumentParser#exit(status=0, message) -> Void + * - status (int): exit status + * - message (string): message + * + * Print message in stderr/stdout and exit program + **/ +ArgumentParser.prototype.exit = function (status, message) { + if (message) { + if (status === 0) { + this._printMessage(message); + } else { + this._printMessage(message, process.stderr); + } + } + + process.exit(status); +}; + +/** + * ArgumentParser#error(message) -> Void + * - err (Error|string): message + * + * Error method Prints a usage message incorporating the message to stderr and + * exits. If you override this in a subclass, + * it should not return -- it should + * either exit or throw an exception. + * + **/ +ArgumentParser.prototype.error = function (err) { + var message; + if (err instanceof Error) { + if (this.debug === true) { + throw err; + } + message = err.message; + } else { + message = err; + } + var msg = format('%s: error: %s', this.prog, message) + c.EOL; + + if (this.debug === true) { + throw new Error(msg); + } + + this.printUsage(process.stderr); + + return this.exit(2, msg); +}; + +module.exports = ArgumentParser; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/const.js b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/const.js new file mode 100644 index 0000000000000000000000000000000000000000..b1fd4ced4e888b0aa67dd7cde76c6f41f582c3d6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/const.js @@ -0,0 +1,21 @@ +// +// Constants +// + +'use strict'; + +module.exports.EOL = '\n'; + +module.exports.SUPPRESS = '==SUPPRESS=='; + +module.exports.OPTIONAL = '?'; + +module.exports.ZERO_OR_MORE = '*'; + +module.exports.ONE_OR_MORE = '+'; + +module.exports.PARSER = 'A...'; + +module.exports.REMAINDER = '...'; + +module.exports._UNRECOGNIZED_ARGS_ATTR = '_unrecognized_args'; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/help/added_formatters.js b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/help/added_formatters.js new file mode 100644 index 0000000000000000000000000000000000000000..f8e42998e9bf5871f3c0e42ce8a00ae048178c90 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/help/added_formatters.js @@ -0,0 +1,87 @@ +'use strict'; + +var util = require('util'); + +// Constants +var c = require('../const'); + +var $$ = require('../utils'); +var HelpFormatter = require('./formatter.js'); + +/** + * new RawDescriptionHelpFormatter(options) + * new ArgumentParser({formatterClass: argparse.RawDescriptionHelpFormatter, ...}) + * + * Help message formatter which adds default values to argument help. + * + * Only the name of this class is considered a public API. All the methods + * provided by the class are considered an implementation detail. + **/ + +function ArgumentDefaultsHelpFormatter(options) { + HelpFormatter.call(this, options); +} + +util.inherits(ArgumentDefaultsHelpFormatter, HelpFormatter); + +ArgumentDefaultsHelpFormatter.prototype._getHelpString = function (action) { + var help = action.help; + if (action.help.indexOf('%(defaultValue)s') === -1) { + if (action.defaultValue !== c.SUPPRESS) { + var defaulting_nargs = [ c.OPTIONAL, c.ZERO_OR_MORE ]; + if (action.isOptional() || (defaulting_nargs.indexOf(action.nargs) >= 0)) { + help += ' (default: %(defaultValue)s)'; + } + } + } + return help; +}; + +module.exports.ArgumentDefaultsHelpFormatter = ArgumentDefaultsHelpFormatter; + +/** + * new RawDescriptionHelpFormatter(options) + * new ArgumentParser({formatterClass: argparse.RawDescriptionHelpFormatter, ...}) + * + * Help message formatter which retains any formatting in descriptions. + * + * Only the name of this class is considered a public API. All the methods + * provided by the class are considered an implementation detail. + **/ + +function RawDescriptionHelpFormatter(options) { + HelpFormatter.call(this, options); +} + +util.inherits(RawDescriptionHelpFormatter, HelpFormatter); + +RawDescriptionHelpFormatter.prototype._fillText = function (text, width, indent) { + var lines = text.split('\n'); + lines = lines.map(function (line) { + return $$.trimEnd(indent + line); + }); + return lines.join('\n'); +}; +module.exports.RawDescriptionHelpFormatter = RawDescriptionHelpFormatter; + +/** + * new RawTextHelpFormatter(options) + * new ArgumentParser({formatterClass: argparse.RawTextHelpFormatter, ...}) + * + * Help message formatter which retains formatting of all help text. + * + * Only the name of this class is considered a public API. All the methods + * provided by the class are considered an implementation detail. + **/ + +function RawTextHelpFormatter(options) { + RawDescriptionHelpFormatter.call(this, options); +} + +util.inherits(RawTextHelpFormatter, RawDescriptionHelpFormatter); + +RawTextHelpFormatter.prototype._splitLines = function (text) { + return text.split('\n'); +}; + +module.exports.RawTextHelpFormatter = RawTextHelpFormatter; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/help/formatter.js b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/help/formatter.js new file mode 100644 index 0000000000000000000000000000000000000000..29036c14b2e156e4287e8136a545ec0be17fc5b4 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/help/formatter.js @@ -0,0 +1,795 @@ +/** + * class HelpFormatter + * + * Formatter for generating usage messages and argument help strings. Only the + * name of this class is considered a public API. All the methods provided by + * the class are considered an implementation detail. + * + * Do not call in your code, use this class only for inherits your own forvatter + * + * ToDo add [additonal formatters][1] + * + * [1]:http://docs.python.org/dev/library/argparse.html#formatter-class + **/ +'use strict'; + +var sprintf = require('sprintf-js').sprintf; + +// Constants +var c = require('../const'); + +var $$ = require('../utils'); + + +/*:nodoc:* internal + * new Support(parent, heding) + * - parent (object): parent section + * - heading (string): header string + * + **/ +function Section(parent, heading) { + this._parent = parent; + this._heading = heading; + this._items = []; +} + +/*:nodoc:* internal + * Section#addItem(callback) -> Void + * - callback (array): tuple with function and args + * + * Add function for single element + **/ +Section.prototype.addItem = function (callback) { + this._items.push(callback); +}; + +/*:nodoc:* internal + * Section#formatHelp(formatter) -> string + * - formatter (HelpFormatter): current formatter + * + * Form help section string + * + **/ +Section.prototype.formatHelp = function (formatter) { + var itemHelp, heading; + + // format the indented section + if (this._parent) { + formatter._indent(); + } + + itemHelp = this._items.map(function (item) { + var obj, func, args; + + obj = formatter; + func = item[0]; + args = item[1]; + return func.apply(obj, args); + }); + itemHelp = formatter._joinParts(itemHelp); + + if (this._parent) { + formatter._dedent(); + } + + // return nothing if the section was empty + if (!itemHelp) { + return ''; + } + + // add the heading if the section was non-empty + heading = ''; + if (this._heading && this._heading !== c.SUPPRESS) { + var currentIndent = formatter.currentIndent; + heading = $$.repeat(' ', currentIndent) + this._heading + ':' + c.EOL; + } + + // join the section-initialize newline, the heading and the help + return formatter._joinParts([ c.EOL, heading, itemHelp, c.EOL ]); +}; + +/** + * new HelpFormatter(options) + * + * #### Options: + * - `prog`: program name + * - `indentIncriment`: indent step, default value 2 + * - `maxHelpPosition`: max help position, default value = 24 + * - `width`: line width + * + **/ +var HelpFormatter = module.exports = function HelpFormatter(options) { + options = options || {}; + + this._prog = options.prog; + + this._maxHelpPosition = options.maxHelpPosition || 24; + this._width = (options.width || ((process.env.COLUMNS || 80) - 2)); + + this._currentIndent = 0; + this._indentIncriment = options.indentIncriment || 2; + this._level = 0; + this._actionMaxLength = 0; + + this._rootSection = new Section(null); + this._currentSection = this._rootSection; + + this._whitespaceMatcher = new RegExp('\\s+', 'g'); + this._longBreakMatcher = new RegExp(c.EOL + c.EOL + c.EOL + '+', 'g'); +}; + +HelpFormatter.prototype._indent = function () { + this._currentIndent += this._indentIncriment; + this._level += 1; +}; + +HelpFormatter.prototype._dedent = function () { + this._currentIndent -= this._indentIncriment; + this._level -= 1; + if (this._currentIndent < 0) { + throw new Error('Indent decreased below 0.'); + } +}; + +HelpFormatter.prototype._addItem = function (func, args) { + this._currentSection.addItem([ func, args ]); +}; + +// +// Message building methods +// + +/** + * HelpFormatter#startSection(heading) -> Void + * - heading (string): header string + * + * Start new help section + * + * See alse [code example][1] + * + * ##### Example + * + * formatter.startSection(actionGroup.title); + * formatter.addText(actionGroup.description); + * formatter.addArguments(actionGroup._groupActions); + * formatter.endSection(); + * + **/ +HelpFormatter.prototype.startSection = function (heading) { + this._indent(); + var section = new Section(this._currentSection, heading); + var func = section.formatHelp.bind(section); + this._addItem(func, [ this ]); + this._currentSection = section; +}; + +/** + * HelpFormatter#endSection -> Void + * + * End help section + * + * ##### Example + * + * formatter.startSection(actionGroup.title); + * formatter.addText(actionGroup.description); + * formatter.addArguments(actionGroup._groupActions); + * formatter.endSection(); + **/ +HelpFormatter.prototype.endSection = function () { + this._currentSection = this._currentSection._parent; + this._dedent(); +}; + +/** + * HelpFormatter#addText(text) -> Void + * - text (string): plain text + * + * Add plain text into current section + * + * ##### Example + * + * formatter.startSection(actionGroup.title); + * formatter.addText(actionGroup.description); + * formatter.addArguments(actionGroup._groupActions); + * formatter.endSection(); + * + **/ +HelpFormatter.prototype.addText = function (text) { + if (text && text !== c.SUPPRESS) { + this._addItem(this._formatText, [ text ]); + } +}; + +/** + * HelpFormatter#addUsage(usage, actions, groups, prefix) -> Void + * - usage (string): usage text + * - actions (array): actions list + * - groups (array): groups list + * - prefix (string): usage prefix + * + * Add usage data into current section + * + * ##### Example + * + * formatter.addUsage(this.usage, this._actions, []); + * return formatter.formatHelp(); + * + **/ +HelpFormatter.prototype.addUsage = function (usage, actions, groups, prefix) { + if (usage !== c.SUPPRESS) { + this._addItem(this._formatUsage, [ usage, actions, groups, prefix ]); + } +}; + +/** + * HelpFormatter#addArgument(action) -> Void + * - action (object): action + * + * Add argument into current section + * + * Single variant of [[HelpFormatter#addArguments]] + **/ +HelpFormatter.prototype.addArgument = function (action) { + if (action.help !== c.SUPPRESS) { + var self = this; + + // find all invocations + var invocations = [ this._formatActionInvocation(action) ]; + var invocationLength = invocations[0].length; + + var actionLength; + + if (action._getSubactions) { + this._indent(); + action._getSubactions().forEach(function (subaction) { + + var invocationNew = self._formatActionInvocation(subaction); + invocations.push(invocationNew); + invocationLength = Math.max(invocationLength, invocationNew.length); + + }); + this._dedent(); + } + + // update the maximum item length + actionLength = invocationLength + this._currentIndent; + this._actionMaxLength = Math.max(this._actionMaxLength, actionLength); + + // add the item to the list + this._addItem(this._formatAction, [ action ]); + } +}; + +/** + * HelpFormatter#addArguments(actions) -> Void + * - actions (array): actions list + * + * Mass add arguments into current section + * + * ##### Example + * + * formatter.startSection(actionGroup.title); + * formatter.addText(actionGroup.description); + * formatter.addArguments(actionGroup._groupActions); + * formatter.endSection(); + * + **/ +HelpFormatter.prototype.addArguments = function (actions) { + var self = this; + actions.forEach(function (action) { + self.addArgument(action); + }); +}; + +// +// Help-formatting methods +// + +/** + * HelpFormatter#formatHelp -> string + * + * Format help + * + * ##### Example + * + * formatter.addText(this.epilog); + * return formatter.formatHelp(); + * + **/ +HelpFormatter.prototype.formatHelp = function () { + var help = this._rootSection.formatHelp(this); + if (help) { + help = help.replace(this._longBreakMatcher, c.EOL + c.EOL); + help = $$.trimChars(help, c.EOL) + c.EOL; + } + return help; +}; + +HelpFormatter.prototype._joinParts = function (partStrings) { + return partStrings.filter(function (part) { + return (part && part !== c.SUPPRESS); + }).join(''); +}; + +HelpFormatter.prototype._formatUsage = function (usage, actions, groups, prefix) { + if (!prefix && typeof prefix !== 'string') { + prefix = 'usage: '; + } + + actions = actions || []; + groups = groups || []; + + + // if usage is specified, use that + if (usage) { + usage = sprintf(usage, { prog: this._prog }); + + // if no optionals or positionals are available, usage is just prog + } else if (!usage && actions.length === 0) { + usage = this._prog; + + // if optionals and positionals are available, calculate usage + } else if (!usage) { + var prog = this._prog; + var optionals = []; + var positionals = []; + var actionUsage; + var textWidth; + + // split optionals from positionals + actions.forEach(function (action) { + if (action.isOptional()) { + optionals.push(action); + } else { + positionals.push(action); + } + }); + + // build full usage string + actionUsage = this._formatActionsUsage([].concat(optionals, positionals), groups); + usage = [ prog, actionUsage ].join(' '); + + // wrap the usage parts if it's too long + textWidth = this._width - this._currentIndent; + if ((prefix.length + usage.length) > textWidth) { + + // break usage into wrappable parts + var regexpPart = new RegExp('\\(.*?\\)+|\\[.*?\\]+|\\S+', 'g'); + var optionalUsage = this._formatActionsUsage(optionals, groups); + var positionalUsage = this._formatActionsUsage(positionals, groups); + + + var optionalParts = optionalUsage.match(regexpPart); + var positionalParts = positionalUsage.match(regexpPart) || []; + + if (optionalParts.join(' ') !== optionalUsage) { + throw new Error('assert "optionalParts.join(\' \') === optionalUsage"'); + } + if (positionalParts.join(' ') !== positionalUsage) { + throw new Error('assert "positionalParts.join(\' \') === positionalUsage"'); + } + + // helper for wrapping lines + /*eslint-disable func-style*/ // node 0.10 compat + var _getLines = function (parts, indent, prefix) { + var lines = []; + var line = []; + + var lineLength = prefix ? prefix.length - 1 : indent.length - 1; + + parts.forEach(function (part) { + if (lineLength + 1 + part.length > textWidth) { + lines.push(indent + line.join(' ')); + line = []; + lineLength = indent.length - 1; + } + line.push(part); + lineLength += part.length + 1; + }); + + if (line) { + lines.push(indent + line.join(' ')); + } + if (prefix) { + lines[0] = lines[0].substr(indent.length); + } + return lines; + }; + + var lines, indent, parts; + // if prog is short, follow it with optionals or positionals + if (prefix.length + prog.length <= 0.75 * textWidth) { + indent = $$.repeat(' ', (prefix.length + prog.length + 1)); + if (optionalParts) { + lines = [].concat( + _getLines([ prog ].concat(optionalParts), indent, prefix), + _getLines(positionalParts, indent) + ); + } else if (positionalParts) { + lines = _getLines([ prog ].concat(positionalParts), indent, prefix); + } else { + lines = [ prog ]; + } + + // if prog is long, put it on its own line + } else { + indent = $$.repeat(' ', prefix.length); + parts = optionalParts.concat(positionalParts); + lines = _getLines(parts, indent); + if (lines.length > 1) { + lines = [].concat( + _getLines(optionalParts, indent), + _getLines(positionalParts, indent) + ); + } + lines = [ prog ].concat(lines); + } + // join lines into usage + usage = lines.join(c.EOL); + } + } + + // prefix with 'usage:' + return prefix + usage + c.EOL + c.EOL; +}; + +HelpFormatter.prototype._formatActionsUsage = function (actions, groups) { + // find group indices and identify actions in groups + var groupActions = []; + var inserts = []; + var self = this; + + groups.forEach(function (group) { + var end; + var i; + + var start = actions.indexOf(group._groupActions[0]); + if (start >= 0) { + end = start + group._groupActions.length; + + //if (actions.slice(start, end) === group._groupActions) { + if ($$.arrayEqual(actions.slice(start, end), group._groupActions)) { + group._groupActions.forEach(function (action) { + groupActions.push(action); + }); + + if (!group.required) { + if (inserts[start]) { + inserts[start] += ' ['; + } else { + inserts[start] = '['; + } + inserts[end] = ']'; + } else { + if (inserts[start]) { + inserts[start] += ' ('; + } else { + inserts[start] = '('; + } + inserts[end] = ')'; + } + for (i = start + 1; i < end; i += 1) { + inserts[i] = '|'; + } + } + } + }); + + // collect all actions format strings + var parts = []; + + actions.forEach(function (action, actionIndex) { + var part; + var optionString; + var argsDefault; + var argsString; + + // suppressed arguments are marked with None + // remove | separators for suppressed arguments + if (action.help === c.SUPPRESS) { + parts.push(null); + if (inserts[actionIndex] === '|') { + inserts.splice(actionIndex, actionIndex); + } else if (inserts[actionIndex + 1] === '|') { + inserts.splice(actionIndex + 1, actionIndex + 1); + } + + // produce all arg strings + } else if (!action.isOptional()) { + part = self._formatArgs(action, action.dest); + + // if it's in a group, strip the outer [] + if (groupActions.indexOf(action) >= 0) { + if (part[0] === '[' && part[part.length - 1] === ']') { + part = part.slice(1, -1); + } + } + // add the action string to the list + parts.push(part); + + // produce the first way to invoke the option in brackets + } else { + optionString = action.optionStrings[0]; + + // if the Optional doesn't take a value, format is: -s or --long + if (action.nargs === 0) { + part = '' + optionString; + + // if the Optional takes a value, format is: -s ARGS or --long ARGS + } else { + argsDefault = action.dest.toUpperCase(); + argsString = self._formatArgs(action, argsDefault); + part = optionString + ' ' + argsString; + } + // make it look optional if it's not required or in a group + if (!action.required && groupActions.indexOf(action) < 0) { + part = '[' + part + ']'; + } + // add the action string to the list + parts.push(part); + } + }); + + // insert things at the necessary indices + for (var i = inserts.length - 1; i >= 0; --i) { + if (inserts[i] !== null) { + parts.splice(i, 0, inserts[i]); + } + } + + // join all the action items with spaces + var text = parts.filter(function (part) { + return !!part; + }).join(' '); + + // clean up separators for mutually exclusive groups + text = text.replace(/([\[(]) /g, '$1'); // remove spaces + text = text.replace(/ ([\])])/g, '$1'); + text = text.replace(/\[ *\]/g, ''); // remove empty groups + text = text.replace(/\( *\)/g, ''); + text = text.replace(/\(([^|]*)\)/g, '$1'); // remove () from single action groups + + text = text.trim(); + + // return the text + return text; +}; + +HelpFormatter.prototype._formatText = function (text) { + text = sprintf(text, { prog: this._prog }); + var textWidth = this._width - this._currentIndent; + var indentIncriment = $$.repeat(' ', this._currentIndent); + return this._fillText(text, textWidth, indentIncriment) + c.EOL + c.EOL; +}; + +HelpFormatter.prototype._formatAction = function (action) { + var self = this; + + var helpText; + var helpLines; + var parts; + var indentFirst; + + // determine the required width and the entry label + var helpPosition = Math.min(this._actionMaxLength + 2, this._maxHelpPosition); + var helpWidth = this._width - helpPosition; + var actionWidth = helpPosition - this._currentIndent - 2; + var actionHeader = this._formatActionInvocation(action); + + // no help; start on same line and add a final newline + if (!action.help) { + actionHeader = $$.repeat(' ', this._currentIndent) + actionHeader + c.EOL; + + // short action name; start on the same line and pad two spaces + } else if (actionHeader.length <= actionWidth) { + actionHeader = $$.repeat(' ', this._currentIndent) + + actionHeader + + ' ' + + $$.repeat(' ', actionWidth - actionHeader.length); + indentFirst = 0; + + // long action name; start on the next line + } else { + actionHeader = $$.repeat(' ', this._currentIndent) + actionHeader + c.EOL; + indentFirst = helpPosition; + } + + // collect the pieces of the action help + parts = [ actionHeader ]; + + // if there was help for the action, add lines of help text + if (action.help) { + helpText = this._expandHelp(action); + helpLines = this._splitLines(helpText, helpWidth); + parts.push($$.repeat(' ', indentFirst) + helpLines[0] + c.EOL); + helpLines.slice(1).forEach(function (line) { + parts.push($$.repeat(' ', helpPosition) + line + c.EOL); + }); + + // or add a newline if the description doesn't end with one + } else if (actionHeader.charAt(actionHeader.length - 1) !== c.EOL) { + parts.push(c.EOL); + } + // if there are any sub-actions, add their help as well + if (action._getSubactions) { + this._indent(); + action._getSubactions().forEach(function (subaction) { + parts.push(self._formatAction(subaction)); + }); + this._dedent(); + } + // return a single string + return this._joinParts(parts); +}; + +HelpFormatter.prototype._formatActionInvocation = function (action) { + if (!action.isOptional()) { + var format_func = this._metavarFormatter(action, action.dest); + var metavars = format_func(1); + return metavars[0]; + } + + var parts = []; + var argsDefault; + var argsString; + + // if the Optional doesn't take a value, format is: -s, --long + if (action.nargs === 0) { + parts = parts.concat(action.optionStrings); + + // if the Optional takes a value, format is: -s ARGS, --long ARGS + } else { + argsDefault = action.dest.toUpperCase(); + argsString = this._formatArgs(action, argsDefault); + action.optionStrings.forEach(function (optionString) { + parts.push(optionString + ' ' + argsString); + }); + } + return parts.join(', '); +}; + +HelpFormatter.prototype._metavarFormatter = function (action, metavarDefault) { + var result; + + if (action.metavar || action.metavar === '') { + result = action.metavar; + } else if (action.choices) { + var choices = action.choices; + + if (typeof choices === 'string') { + choices = choices.split('').join(', '); + } else if (Array.isArray(choices)) { + choices = choices.join(','); + } else { + choices = Object.keys(choices).join(','); + } + result = '{' + choices + '}'; + } else { + result = metavarDefault; + } + + return function (size) { + if (Array.isArray(result)) { + return result; + } + + var metavars = []; + for (var i = 0; i < size; i += 1) { + metavars.push(result); + } + return metavars; + }; +}; + +HelpFormatter.prototype._formatArgs = function (action, metavarDefault) { + var result; + var metavars; + + var buildMetavar = this._metavarFormatter(action, metavarDefault); + + switch (action.nargs) { + /*eslint-disable no-undefined*/ + case undefined: + case null: + metavars = buildMetavar(1); + result = '' + metavars[0]; + break; + case c.OPTIONAL: + metavars = buildMetavar(1); + result = '[' + metavars[0] + ']'; + break; + case c.ZERO_OR_MORE: + metavars = buildMetavar(2); + result = '[' + metavars[0] + ' [' + metavars[1] + ' ...]]'; + break; + case c.ONE_OR_MORE: + metavars = buildMetavar(2); + result = '' + metavars[0] + ' [' + metavars[1] + ' ...]'; + break; + case c.REMAINDER: + result = '...'; + break; + case c.PARSER: + metavars = buildMetavar(1); + result = metavars[0] + ' ...'; + break; + default: + metavars = buildMetavar(action.nargs); + result = metavars.join(' '); + } + return result; +}; + +HelpFormatter.prototype._expandHelp = function (action) { + var params = { prog: this._prog }; + + Object.keys(action).forEach(function (actionProperty) { + var actionValue = action[actionProperty]; + + if (actionValue !== c.SUPPRESS) { + params[actionProperty] = actionValue; + } + }); + + if (params.choices) { + if (typeof params.choices === 'string') { + params.choices = params.choices.split('').join(', '); + } else if (Array.isArray(params.choices)) { + params.choices = params.choices.join(', '); + } else { + params.choices = Object.keys(params.choices).join(', '); + } + } + + return sprintf(this._getHelpString(action), params); +}; + +HelpFormatter.prototype._splitLines = function (text, width) { + var lines = []; + var delimiters = [ ' ', '.', ',', '!', '?' ]; + var re = new RegExp('[' + delimiters.join('') + '][^' + delimiters.join('') + ']*$'); + + text = text.replace(/[\n\|\t]/g, ' '); + + text = text.trim(); + text = text.replace(this._whitespaceMatcher, ' '); + + // Wraps the single paragraph in text (a string) so every line + // is at most width characters long. + text.split(c.EOL).forEach(function (line) { + if (width >= line.length) { + lines.push(line); + return; + } + + var wrapStart = 0; + var wrapEnd = width; + var delimiterIndex = 0; + while (wrapEnd <= line.length) { + if (wrapEnd !== line.length && delimiters.indexOf(line[wrapEnd] < -1)) { + delimiterIndex = (re.exec(line.substring(wrapStart, wrapEnd)) || {}).index; + wrapEnd = wrapStart + delimiterIndex + 1; + } + lines.push(line.substring(wrapStart, wrapEnd)); + wrapStart = wrapEnd; + wrapEnd += width; + } + if (wrapStart < line.length) { + lines.push(line.substring(wrapStart, wrapEnd)); + } + }); + + return lines; +}; + +HelpFormatter.prototype._fillText = function (text, width, indent) { + var lines = this._splitLines(text, width); + lines = lines.map(function (line) { + return indent + line; + }); + return lines.join(c.EOL); +}; + +HelpFormatter.prototype._getHelpString = function (action) { + return action.help; +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/namespace.js b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/namespace.js new file mode 100644 index 0000000000000000000000000000000000000000..a860de9ecc48ddc61ef65fab4794406005f67a48 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/namespace.js @@ -0,0 +1,76 @@ +/** + * class Namespace + * + * Simple object for storing attributes. Implements equality by attribute names + * and values, and provides a simple string representation. + * + * See also [original guide][1] + * + * [1]:http://docs.python.org/dev/library/argparse.html#the-namespace-object + **/ +'use strict'; + +var $$ = require('./utils'); + +/** + * new Namespace(options) + * - options(object): predefined propertis for result object + * + **/ +var Namespace = module.exports = function Namespace(options) { + $$.extend(this, options); +}; + +/** + * Namespace#isset(key) -> Boolean + * - key (string|number): property name + * + * Tells whenever `namespace` contains given `key` or not. + **/ +Namespace.prototype.isset = function (key) { + return $$.has(this, key); +}; + +/** + * Namespace#set(key, value) -> self + * -key (string|number|object): propery name + * -value (mixed): new property value + * + * Set the property named key with value. + * If key object then set all key properties to namespace object + **/ +Namespace.prototype.set = function (key, value) { + if (typeof (key) === 'object') { + $$.extend(this, key); + } else { + this[key] = value; + } + return this; +}; + +/** + * Namespace#get(key, defaultValue) -> mixed + * - key (string|number): property name + * - defaultValue (mixed): default value + * + * Return the property key or defaulValue if not set + **/ +Namespace.prototype.get = function (key, defaultValue) { + return !this[key] ? defaultValue : this[key]; +}; + +/** + * Namespace#unset(key, defaultValue) -> mixed + * - key (string|number): property name + * - defaultValue (mixed): default value + * + * Return data[key](and delete it) or defaultValue + **/ +Namespace.prototype.unset = function (key, defaultValue) { + var value = this[key]; + if (value !== null) { + delete this[key]; + return value; + } + return defaultValue; +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/utils.js b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/utils.js new file mode 100644 index 0000000000000000000000000000000000000000..4a9cf3edb615ce9a5f572836c66711e0814cec9c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/argparse/lib/utils.js @@ -0,0 +1,57 @@ +'use strict'; + +exports.repeat = function (str, num) { + var result = ''; + for (var i = 0; i < num; i++) { result += str; } + return result; +}; + +exports.arrayEqual = function (a, b) { + if (a.length !== b.length) { return false; } + for (var i = 0; i < a.length; i++) { + if (a[i] !== b[i]) { return false; } + } + return true; +}; + +exports.trimChars = function (str, chars) { + var start = 0; + var end = str.length - 1; + while (chars.indexOf(str.charAt(start)) >= 0) { start++; } + while (chars.indexOf(str.charAt(end)) >= 0) { end--; } + return str.slice(start, end + 1); +}; + +exports.capitalize = function (str) { + return str.charAt(0).toUpperCase() + str.slice(1); +}; + +exports.arrayUnion = function () { + var result = []; + for (var i = 0, values = {}; i < arguments.length; i++) { + var arr = arguments[i]; + for (var j = 0; j < arr.length; j++) { + if (!values[arr[j]]) { + values[arr[j]] = true; + result.push(arr[j]); + } + } + } + return result; +}; + +function has(obj, key) { + return Object.prototype.hasOwnProperty.call(obj, key); +} + +exports.has = has; + +exports.extend = function (dest, src) { + for (var i in src) { + if (has(src, i)) { dest[i] = src[i]; } + } +}; + +exports.trimEnd = function (str) { + return str.replace(/\s+$/g, ''); +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/balanced-match/.github/FUNDING.yml b/novas/novacore-zephyr/claude-code-router/node_modules/balanced-match/.github/FUNDING.yml new file mode 100644 index 0000000000000000000000000000000000000000..cea8b16e9edc40b78b839e97f7d4b174ada0b41f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/balanced-match/.github/FUNDING.yml @@ -0,0 +1,2 @@ +tidelift: "npm/balanced-match" +patreon: juliangruber diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..45e2dfd6cf683a0061beb343f0cc8dad42930436 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/index.d.ts @@ -0,0 +1,8 @@ +import { LogMethod, Logger, createLogger, lastSequenceNumber, resetSequence } from './logger'; +import { LogContext, LogContexts } from './logger/context'; +import { LogLevelName, LogLevels, logLevelNameFor, parseLogLevel } from './logger/level'; +import { LogMessage, LogMessageFormatter, LogMessageTranslator, registerLogFormatter, resetLogFormatters } from './logger/message'; +import { rootLogger, setup } from './logger/root'; +import { DEFAULT_LOG_TARGET, LogTarget, parseLogTargets } from './logger/target'; +import * as testing from './testing'; +export { rootLogger as default, rootLogger as logger, setup, createLogger, DEFAULT_LOG_TARGET, lastSequenceNumber, LogContext, LogContexts, Logger, LogLevelName, logLevelNameFor, LogLevels, LogMessage, LogMessageFormatter, LogMessageTranslator, LogMethod, LogTarget, parseLogLevel, parseLogTargets, registerLogFormatter, resetLogFormatters, resetSequence, testing, }; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/index.js new file mode 100644 index 0000000000000000000000000000000000000000..4257d8035db705383f961799c752bebadc2ca71b --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/index.js @@ -0,0 +1,31 @@ +"use strict"; +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var logger_1 = require("./logger"); +exports.createLogger = logger_1.createLogger; +exports.lastSequenceNumber = logger_1.lastSequenceNumber; +exports.resetSequence = logger_1.resetSequence; +var context_1 = require("./logger/context"); +exports.LogContexts = context_1.LogContexts; +var level_1 = require("./logger/level"); +exports.LogLevels = level_1.LogLevels; +exports.logLevelNameFor = level_1.logLevelNameFor; +exports.parseLogLevel = level_1.parseLogLevel; +var message_1 = require("./logger/message"); +exports.registerLogFormatter = message_1.registerLogFormatter; +exports.resetLogFormatters = message_1.resetLogFormatters; +var root_1 = require("./logger/root"); +exports.default = root_1.rootLogger; +exports.logger = root_1.rootLogger; +exports.setup = root_1.setup; +var target_1 = require("./logger/target"); +exports.DEFAULT_LOG_TARGET = target_1.DEFAULT_LOG_TARGET; +exports.parseLogTargets = target_1.parseLogTargets; +var testing = __importStar(require("./testing")); +exports.testing = testing; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/context.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/context.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8e43e933f2988d2ecf32ef11d61f133092c30d90 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/context.d.ts @@ -0,0 +1,16 @@ +declare enum LogContexts { + application = "application", + hostname = "hostname", + logLevel = "logLevel", + namespace = "namespace", + package = "package" +} +interface LogContext { + [key: string]: any; + [LogContexts.application]?: string; + [LogContexts.hostname]?: string; + [LogContexts.logLevel]?: number; + [LogContexts.namespace]?: string; + [LogContexts.package]?: string; +} +export { LogContext, LogContexts }; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/context.js b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/context.js new file mode 100644 index 0000000000000000000000000000000000000000..6cf9b77bb607fd1b4a2267f4090e12532c4e4d99 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/context.js @@ -0,0 +1,11 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var LogContexts; +(function (LogContexts) { + LogContexts["application"] = "application"; + LogContexts["hostname"] = "hostname"; + LogContexts["logLevel"] = "logLevel"; + LogContexts["namespace"] = "namespace"; + LogContexts["package"] = "package"; +})(LogContexts || (LogContexts = {})); +exports.LogContexts = LogContexts; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f051c974241f850d1df41ca9f2b7365295d50382 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/index.d.ts @@ -0,0 +1,37 @@ +import { LogContext } from './context'; +import { LogMessageTranslator } from './message'; +import { LogTarget } from './target'; +interface LogMethod { + (message: string, ...args: any[]): void; + (context: LogContext, message: string, ...args: any[]): void; + isEmptyFunction?: boolean; +} +interface LogChildMethod { + (context: LogContext): Logger; + (translate: LogMessageTranslator): Logger; +} +interface LogWrapMethod { + any>(func: F): F; + any>(message: string, func: F): F; + any>(context: LogContext, message: string, func: F): F; + any>(level: number, message: string, func: F): F; +} +interface Logger extends LogMethod { + trace: LogMethod; + debug: LogMethod; + info: LogMethod; + warn: LogMethod; + error: LogMethod; + fatal: LogMethod; + child: LogChildMethod; + wrap: LogWrapMethod; +} +declare const resetSequence: (next?: number) => void; +declare const lastSequenceNumber: () => number; +interface CreateLoggerOptions { + context?: LogContext; + translate?: LogMessageTranslator; + targets?: string | LogTarget[]; +} +declare const createLogger: ({ context: baseContext, targets: logTargets, translate: logTranslator, }?: CreateLoggerOptions) => Logger; +export { createLogger, lastSequenceNumber, Logger, LogMethod, resetSequence, CreateLoggerOptions }; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/index.js new file mode 100644 index 0000000000000000000000000000000000000000..6dd01505c021d9cfb6609875722830a29f3d9a8f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/index.js @@ -0,0 +1,164 @@ +"use strict"; +var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var __spread = (this && this.__spread) || function () { + for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i])); + return ar; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var util_1 = require("util"); +var context_1 = require("./context"); +var level_1 = require("./level"); +var target_1 = require("./target"); +var lastSeqNumber = 0; +var resetSequence = function (next) { + if (next === void 0) { next = 1; } + lastSeqNumber = next - 1; +}; +exports.resetSequence = resetSequence; +var lastSequenceNumber = function () { return lastSeqNumber; }; +exports.lastSequenceNumber = lastSequenceNumber; +var createEmptyFunction = function () { + return Object.defineProperty(function emptyFunction() { }, 'isEmptyFunction', { value: true }); +}; +var createEmptyLogger = function () { + var log = createEmptyFunction(); + log.child = function () { return createEmptyLogger(); }; + log.wrap = function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + return args.pop(); + }; + level_1.LogLevelNames.forEach(function (name) { + log[name] = log; + }); + return log; +}; +var createLogger = function (_a) { + var _b = _a === void 0 ? {} : _a, _c = _b.context, baseContext = _c === void 0 ? {} : _c, _d = _b.targets, logTargets = _d === void 0 ? target_1.DEFAULT_LOG_TARGET : _d, logTranslator = _b.translate; + var targets = typeof logTargets === 'string' ? target_1.parseLogTargets(logTargets) : logTargets; + if (targets.length === 0) { + return createEmptyLogger(); + } + var log = function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + var time = Date.now(); + var sequence = ++lastSeqNumber; + var context; + if (typeof args[0] === 'string') { + context = __assign({}, baseContext); + } + else { + context = __assign({}, baseContext, args.shift()); + } + var msg = args.shift(); + var logLevel = context[context_1.LogContexts.logLevel]; + var destTargets = logLevel == null ? targets : targets.filter(function (t) { return logLevel >= t.minLevel; }); + if (destTargets.length === 0) { + return; + } + var message = util_1.format.apply(void 0, __spread([msg], args)); + var logMessage = { + context: context, + time: time, + sequence: sequence, + message: message, + }; + if (logTranslator) { + logMessage = logTranslator(logMessage); + } + destTargets.forEach(function (t) { return t.stream.write(t.format(logMessage) + "\n"); }); + }; + log.child = function (ctxOrTranslator) { + var isTranslator = typeof ctxOrTranslator === 'function'; + var childContext = isTranslator ? __assign({}, baseContext) : __assign({}, baseContext, ctxOrTranslator); + var translate; + if (isTranslator) { + if (logTranslator) { + translate = function (msg) { return ctxOrTranslator(logTranslator(msg)); }; + } + else { + translate = ctxOrTranslator; + } + } + else { + translate = logTranslator; + } + return createLogger({ context: childContext, targets: targets, translate: translate }); + }; + log.wrap = function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + var _a; + var _b = __read(Array(3 - args.length).concat(args), 3), ctx = _b[0], msg = _b[1], func = _b[2]; + var context = typeof ctx === 'number' ? __assign({}, baseContext, (_a = {}, _a[context_1.LogContexts.logLevel] = ctx, _a)) : __assign({}, baseContext, ctx); + var logLevel = context[context_1.LogContexts.logLevel]; + if (typeof logLevel === 'number' && targets.every(function (t) { return t.minLevel > logLevel; })) { + return func; + } + var message = msg == null ? "calling " + (func.name || '[anonymous]') + "()" : msg; + return function wrapped() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + log(__assign({ call: { args: args } }, context), message); + return func.apply(this, args); + }; + }; + level_1.LogLevelNames.forEach(function (name) { + var _a; + var level = level_1.LogLevels[name]; + var extraContext = (_a = {}, _a[context_1.LogContexts.logLevel] = level, _a); + log[name] = function (ctxOrMsg) { + var args = []; + for (var _i = 1; _i < arguments.length; _i++) { + args[_i - 1] = arguments[_i]; + } + if (targets.length === 0 || targets.every(function (t) { return t.minLevel > level; })) { + log[name] = createEmptyFunction(); + return; + } + if (typeof ctxOrMsg === 'string') { + log.apply(void 0, __spread([extraContext, ctxOrMsg], args)); + } + else { + log.apply(void 0, __spread([__assign({}, ctxOrMsg, extraContext)], args)); + } + }; + }); + return log; +}; +exports.createLogger = createLogger; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/level.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/level.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3bb73e2d790f531efc20407598dbb5525f5dcbe2 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/level.d.ts @@ -0,0 +1,25 @@ +declare const LogLevels: { + trace: number; + debug: number; + info: number; + warn: number; + error: number; + fatal: number; + readonly lower: number; + readonly higher: number; +}; +declare type LogLevelName = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal'; +declare const LogLevelNames: LogLevelName[]; +declare const LogLevelValues: number[]; +interface LogLevelsScaleEntry { + range: { + from: number; + next: number; + }; + name: string; + test(level: number): boolean; +} +declare const LogLevelsScale: ReadonlyArray; +declare const logLevelNameFor: (level?: number | undefined) => string; +declare const parseLogLevel: (level: string | number) => number | undefined; +export { logLevelNameFor, LogLevels, LogLevelNames, LogLevelValues, LogLevelsScale, parseLogLevel, LogLevelName }; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/level.js b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/level.js new file mode 100644 index 0000000000000000000000000000000000000000..9378891878dd03ce4b3473ef9808d1b12a476958 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/level.js @@ -0,0 +1,62 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var cache_getters_1 = require("../utils/cache-getters"); +var LogLevels = cache_getters_1.cacheGetters({ + trace: 10, + debug: 20, + info: 30, + warn: 40, + error: 50, + fatal: 60, + get lower() { + return LogLevels.trace; + }, + get higher() { + return LogLevels.fatal; + }, +}, 'lower', 'higher'); +exports.LogLevels = LogLevels; +var LogLevelNames = ['trace', 'debug', 'info', 'warn', 'error', 'fatal']; +exports.LogLevelNames = LogLevelNames; +var LogLevelValues = LogLevelNames.map(function (name) { return LogLevels[name]; }); +exports.LogLevelValues = LogLevelValues; +var LogLevelsScale = LogLevelNames.map(function (name, index, _a) { + var length = _a.length; + var first = index === 0; + var last = index === length - 1; + var from = first ? -Infinity : LogLevelValues[index]; + var next = last ? +Infinity : LogLevelValues[index + 1]; + var test; + if (first) { + test = function (level) { return level < next; }; + } + else if (last) { + test = function (level) { return level >= from; }; + } + else { + test = function (level) { return level < next && level >= from; }; + } + return { range: { from: from, next: next }, name: name, test: test }; +}); +exports.LogLevelsScale = LogLevelsScale; +var logLevelNameFor = function (level) { + if (level == null || isNaN(level)) { + return LogLevelNames[0]; + } + return LogLevelsScale.find(function (_a) { + var test = _a.test; + return test(level); + }).name; +}; +exports.logLevelNameFor = logLevelNameFor; +var parseLogLevel = function (level) { + if (typeof level === 'string') { + level = level.toLowerCase(); + if (level in LogLevels) { + return LogLevels[level]; + } + return /^\s*[0-9]+\s*$/.test(level) ? parseInt(level.trim(), 10) : undefined; + } + return typeof level === 'number' && !isNaN(level) ? +level : undefined; +}; +exports.parseLogLevel = parseLogLevel; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/message.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/message.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6a31fb19a10e5fb402035175460a8ac5196147da --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/message.d.ts @@ -0,0 +1,18 @@ +import { LogContext } from './context'; +interface LogMessage { + context: LogContext; + message: string; + sequence: number; + time: number; +} +declare type LogMessageFormatter = (msg: LogMessage) => string; +declare type LogMessageTranslator = (msg: LogMessage) => LogMessage; +interface LogFormattersMap { + json: LogMessageFormatter; + simple: LogMessageFormatter; + [key: string]: LogMessageFormatter; +} +declare let LogFormatters: LogFormattersMap; +declare const resetLogFormatters: () => void; +declare const registerLogFormatter: (name: string, format: LogMessageFormatter) => void; +export { LogMessage, LogMessageTranslator, LogMessageFormatter, LogFormatters, resetLogFormatters, registerLogFormatter, }; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/message.js b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/message.js new file mode 100644 index 0000000000000000000000000000000000000000..4664e27e657123676baf6b38ab952f22e9824265 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/message.js @@ -0,0 +1,37 @@ +"use strict"; +var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var fast_json_stable_stringify_1 = __importDefault(require("fast-json-stable-stringify")); +var context_1 = require("./context"); +var level_1 = require("./level"); +var LogFormatters = defaultLogFormatters(); +exports.LogFormatters = LogFormatters; +var resetLogFormatters = function () { + exports.LogFormatters = LogFormatters = defaultLogFormatters(); +}; +exports.resetLogFormatters = resetLogFormatters; +var registerLogFormatter = function (name, format) { + LogFormatters[name] = format; +}; +exports.registerLogFormatter = registerLogFormatter; +function defaultLogFormatters() { + return { + json: function (msg) { return fast_json_stable_stringify_1.default(__assign({}, msg, { time: new Date(msg.time) }), { cycles: true }); }, + simple: function (msg) { + return (msg.context[context_1.LogContexts.package] || msg.context[context_1.LogContexts.application] || 'main') + "[" + (msg.context[context_1.LogContexts.namespace] || 'root') + "] (" + level_1.logLevelNameFor(msg.context[context_1.LogContexts.logLevel]).toUpperCase() + ") " + msg.message; + }, + }; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/root.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/root.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..546afc3a684acbbbb568b7d52e975ad5630e9738 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/root.d.ts @@ -0,0 +1,4 @@ +import { Logger } from '.'; +declare const setup: (factory?: () => Logger) => void; +declare const rootLogger: Logger; +export { rootLogger, setup }; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/root.js b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/root.js new file mode 100644 index 0000000000000000000000000000000000000000..a049616797dc98865462278716fd97255817d7a8 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/root.js @@ -0,0 +1,79 @@ +"use strict"; +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var __spread = (this && this.__spread) || function () { + for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i])); + return ar; +}; +var __values = (this && this.__values) || function (o) { + var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; + if (m) return m.call(o); + return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var e_1, _a; +var cache_getters_1 = require("../utils/cache-getters"); +var _1 = require("."); +var level_1 = require("./level"); +var cache; +var setup = function (factory) { + if (factory === void 0) { factory = function () { return _1.createLogger({ targets: process.env.LOG_TARGETS || process.env.LOG_TARGET }); }; } + cache = cache_getters_1.cacheGetters({ + get root() { + return factory(); + }, + }, 'root'); +}; +exports.setup = setup; +var rootLogger = (function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + return cache.root.apply(cache, __spread(args)); +}); +exports.rootLogger = rootLogger; +var props = __spread(level_1.LogLevelNames, ['child', 'wrap']); +var _loop_1 = function (prop) { + Object.defineProperty(rootLogger, prop, { + enumerable: true, + configurable: true, + get: function () { + return cache.root[prop]; + }, + }); +}; +try { + for (var props_1 = __values(props), props_1_1 = props_1.next(); !props_1_1.done; props_1_1 = props_1.next()) { + var prop = props_1_1.value; + _loop_1(prop); + } +} +catch (e_1_1) { e_1 = { error: e_1_1 }; } +finally { + try { + if (props_1_1 && !props_1_1.done && (_a = props_1.return)) _a.call(props_1); + } + finally { if (e_1) throw e_1.error; } +} +cache_getters_1.cacheGetters.apply(void 0, __spread([rootLogger], props)); +setup(); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/target.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/target.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1374d9509f69f7807d79bc053d3881e19e71e851 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/target.d.ts @@ -0,0 +1,11 @@ +/// +import { Writable } from 'stream'; +import { LogMessageFormatter } from './message'; +interface LogTarget { + stream: Writable; + minLevel: number; + format: LogMessageFormatter; +} +declare const parseLogTargets: (targetString?: string | undefined) => LogTarget[]; +declare const DEFAULT_LOG_TARGET: string; +export { LogTarget, DEFAULT_LOG_TARGET, parseLogTargets }; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/target.js b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/target.js new file mode 100644 index 0000000000000000000000000000000000000000..1b20841e626dd4fe6f9c4a1b1f80af6cc21dc3e5 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/logger/target.js @@ -0,0 +1,90 @@ +"use strict"; +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var __spread = (this && this.__spread) || function () { + for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i])); + return ar; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var fs_1 = require("fs"); +var path_1 = require("path"); +var cache_getters_1 = require("../utils/cache-getters"); +var level_1 = require("./level"); +var message_1 = require("./message"); +var logTargetWithLevelRegex = new RegExp("^\\s*(.+):([0-9]+|" + level_1.LogLevelNames.join('|') + ")\\s*$", 'i'); +var parseLogTargets = function (targetString) { + var items = (targetString || '').split(/([^\\]),/g).reduce(function (list, item, index) { + if (index % 2 === 1) { + list[list.length - 1] += item; + } + else { + list.push(item); + } + return list; + }, []); + return items.reduce(function (targets, str) { + var format; + str = str.replace(/^(.+)%([a-z_][a-z0-9_]*)$/, function (_, before, key) { + format = message_1.LogFormatters[key]; + return before; + }); + var pieces = str.match(logTargetWithLevelRegex); + var file; + var level; + if (pieces) { + file = pieces[1].trim(); + level = pieces[2].trim(); + } + else { + file = str.trim(); + } + var append = file.endsWith('+'); + if (append) { + file = file.slice(0, -1).trim(); + } + file = file.replace(/\\,/g, ','); + if (!file) { + return targets; + } + var isStandardFd = /^(stdout|stderr)$/i.test(file); + if (format == null) { + format = isStandardFd ? message_1.LogFormatters.simple : message_1.LogFormatters.json; + } + var target = cache_getters_1.cacheGetters({ + format: format, + get minLevel() { + return level_1.parseLogLevel(level) || -Infinity; + }, + get stream() { + if (isStandardFd) { + return process[file.toLowerCase()]; + } + else { + return fs_1.createWriteStream(path_1.resolve(process.cwd(), file), { + flags: append ? 'a' : 'w', + autoClose: true, + encoding: 'utf8', + }); + } + }, + }, 'minLevel', 'stream'); + return __spread(targets, [target]); + }, []); +}; +exports.parseLogTargets = parseLogTargets; +var DEFAULT_LOG_TARGET = "stderr:" + level_1.LogLevels.warn; +exports.DEFAULT_LOG_TARGET = DEFAULT_LOG_TARGET; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/testing/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/testing/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..94cce016dbc8e1836c339930be2d94a7e571590e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/testing/index.d.ts @@ -0,0 +1,8 @@ +import { CreateLoggerOptions, Logger } from '../logger'; +import { ExtendedArray, LogTargetMock, extendArray } from './target-mock'; +declare const setupForTesting: (target?: LogTargetMock) => void; +interface LoggerMock extends Logger { + readonly target: LogTargetMock; +} +declare const createLoggerMock: (options?: CreateLoggerOptions | undefined, target?: LogTargetMock) => LoggerMock; +export { LogTargetMock, ExtendedArray, extendArray, setupForTesting as setup, createLoggerMock, LoggerMock }; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/testing/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/testing/index.js new file mode 100644 index 0000000000000000000000000000000000000000..928d7cb2bf01a36d06c1cec8046a1f699e929c36 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/testing/index.js @@ -0,0 +1,29 @@ +"use strict"; +var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var logger_1 = require("../logger"); +var root_1 = require("../logger/root"); +var target_mock_1 = require("./target-mock"); +exports.LogTargetMock = target_mock_1.LogTargetMock; +exports.extendArray = target_mock_1.extendArray; +var setupForTesting = function (target) { + if (target === void 0) { target = new target_mock_1.LogTargetMock(); } + root_1.setup(function () { return createLoggerMock(undefined, target); }); +}; +exports.setup = setupForTesting; +var createLoggerMock = function (options, target) { + if (target === void 0) { target = new target_mock_1.LogTargetMock(); } + var opt = __assign({}, options, { targets: [target] }); + return Object.assign(logger_1.createLogger(opt), { target: target }); +}; +exports.createLoggerMock = createLoggerMock; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/testing/target-mock.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/testing/target-mock.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a3248dd536e6735ad0fc27aeef23fb7755de9628 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/testing/target-mock.d.ts @@ -0,0 +1,28 @@ +import { LogMessage } from '../logger/message'; +import { LogTarget } from '../logger/target'; +interface ExtendedArray extends Array { + readonly last: T | undefined; +} +interface LogLevelMap { + trace: T; + debug: T; + info: T; + warn: T; + error: T; + fatal: T; +} +declare const extendArray: (array: T[]) => ExtendedArray; +declare class LogTargetMock implements LogTarget { + minLevel: number; + readonly messages: ExtendedArray & LogLevelMap>; + readonly lines: ExtendedArray & LogLevelMap>; + readonly stream: LogTarget['stream']; + constructor(minLevel?: number); + format(msg: LogMessage): string; + clear(): void; + filteredMessages(level: number, untilLevel?: number): ExtendedArray; + filteredMessages(level: null): ExtendedArray; + filteredLines(level: number, untilLevel?: number): ExtendedArray; + filteredLines(level: null): ExtendedArray; +} +export { LogTargetMock, extendArray, ExtendedArray }; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/testing/target-mock.js b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/testing/target-mock.js new file mode 100644 index 0000000000000000000000000000000000000000..b41757cfadc4b70e552a7370b3fa15827f6e3493 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/testing/target-mock.js @@ -0,0 +1,89 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var context_1 = require("../logger/context"); +var level_1 = require("../logger/level"); +var extendArray = function (array) { + return Object.defineProperty(array, 'last', { + configurable: true, + get: function () { + return this[this.length - 1]; + }, + }); +}; +exports.extendArray = extendArray; +var LogTargetMock = (function () { + function LogTargetMock(minLevel) { + if (minLevel === void 0) { minLevel = -Infinity; } + var _this = this; + this.minLevel = minLevel; + this.messages = Object.defineProperties(extendArray([]), { + trace: { get: function () { return _this.filteredMessages(level_1.LogLevels.trace); } }, + debug: { get: function () { return _this.filteredMessages(level_1.LogLevels.debug); } }, + info: { get: function () { return _this.filteredMessages(level_1.LogLevels.info); } }, + warn: { get: function () { return _this.filteredMessages(level_1.LogLevels.warn); } }, + error: { get: function () { return _this.filteredMessages(level_1.LogLevels.error); } }, + fatal: { get: function () { return _this.filteredMessages(level_1.LogLevels.fatal); } }, + }); + this.lines = Object.defineProperties(extendArray([]), { + trace: { get: function () { return _this.filteredLines(level_1.LogLevels.trace); } }, + debug: { get: function () { return _this.filteredLines(level_1.LogLevels.debug); } }, + info: { get: function () { return _this.filteredLines(level_1.LogLevels.info); } }, + warn: { get: function () { return _this.filteredLines(level_1.LogLevels.warn); } }, + error: { get: function () { return _this.filteredLines(level_1.LogLevels.error); } }, + fatal: { get: function () { return _this.filteredLines(level_1.LogLevels.fatal); } }, + }); + this.stream = { + write: function (msg) { return !!_this.lines.push(msg); }, + }; + } + LogTargetMock.prototype.format = function (msg) { + this.messages.push(msg); + var lvl = msg.context[context_1.LogContexts.logLevel]; + if (lvl != null) { + return "[level:" + lvl + "] " + msg.message; + } + return msg.message; + }; + LogTargetMock.prototype.clear = function () { + this.messages.splice(0, this.messages.length); + this.lines.splice(0, this.lines.length); + }; + LogTargetMock.prototype.filteredMessages = function (level, untilLevel) { + var filter; + if (level == null) { + filter = function (m) { return m.context[context_1.LogContexts.logLevel] == null; }; + } + else if (untilLevel != null) { + filter = function (m) { + var lvl = m.context[context_1.LogContexts.logLevel]; + return lvl != null && lvl >= level && lvl <= untilLevel; + }; + } + else { + filter = function (m) { return m.context[context_1.LogContexts.logLevel] === level; }; + } + return extendArray(this.messages.filter(filter)); + }; + LogTargetMock.prototype.filteredLines = function (level, untilLevel) { + var extractLevel = function (line) { + var level = (line.match(/^\[level:([0-9]+)\] /) || [])[1]; + return level == null ? undefined : parseInt(level, 10); + }; + var filter; + if (level == null) { + filter = function (line) { return extractLevel(line) === undefined; }; + } + else if (untilLevel != null) { + filter = function (line) { + var lvl = extractLevel(line); + return lvl != null && lvl >= level && lvl <= untilLevel; + }; + } + else { + filter = function (line) { return extractLevel(line) === level; }; + } + return extendArray(this.lines.filter(filter)); + }; + return LogTargetMock; +}()); +exports.LogTargetMock = LogTargetMock; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/utils/cache-getters.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/utils/cache-getters.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e09c5adce8d2ab433ee570a5edd873989a77d73d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/utils/cache-getters.d.ts @@ -0,0 +1,2 @@ +declare const cacheGetters: (target: T, ...props: (keyof T)[]) => T; +export { cacheGetters }; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/utils/cache-getters.js b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/utils/cache-getters.js new file mode 100644 index 0000000000000000000000000000000000000000..665489bd223c59ad929ffd6a7cf1860bbb0ffd78 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/bs-logger/dist/utils/cache-getters.js @@ -0,0 +1,40 @@ +"use strict"; +var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +var __rest = (this && this.__rest) || function (s, e) { + var t = {}; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) + t[p] = s[p]; + if (s != null && typeof Object.getOwnPropertySymbols === "function") + for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0) + t[p[i]] = s[p[i]]; + return t; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var cacheGetters = function (target) { + var props = []; + for (var _i = 1; _i < arguments.length; _i++) { + props[_i - 1] = arguments[_i]; + } + props.forEach(function (prop) { + var desc = Object.getOwnPropertyDescriptor(target, prop); + var set = desc.set, previousGet = desc.get, partial = __rest(desc, ["set", "get"]); + desc.get = function get() { + var value = previousGet.call(this); + Object.defineProperty(this, prop, __assign({}, partial, { value: value })); + return value; + }; + Object.defineProperty(target, prop, desc); + }); + return target; +}; +exports.cacheGetters = cacheGetters; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/concat-map/example/map.js b/novas/novacore-zephyr/claude-code-router/node_modules/concat-map/example/map.js new file mode 100644 index 0000000000000000000000000000000000000000..33656217b61d8f06a55db4631ec95eea828495d2 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/concat-map/example/map.js @@ -0,0 +1,6 @@ +var concatMap = require('../'); +var xs = [ 1, 2, 3, 4, 5, 6 ]; +var ys = concatMap(xs, function (x) { + return x % 2 ? [ x - 0.1, x, x + 0.1 ] : []; +}); +console.dir(ys); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/concat-map/test/map.js b/novas/novacore-zephyr/claude-code-router/node_modules/concat-map/test/map.js new file mode 100644 index 0000000000000000000000000000000000000000..fdbd7022f6da17600dad4d477734115bf28287e0 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/concat-map/test/map.js @@ -0,0 +1,39 @@ +var concatMap = require('../'); +var test = require('tape'); + +test('empty or not', function (t) { + var xs = [ 1, 2, 3, 4, 5, 6 ]; + var ixes = []; + var ys = concatMap(xs, function (x, ix) { + ixes.push(ix); + return x % 2 ? [ x - 0.1, x, x + 0.1 ] : []; + }); + t.same(ys, [ 0.9, 1, 1.1, 2.9, 3, 3.1, 4.9, 5, 5.1 ]); + t.same(ixes, [ 0, 1, 2, 3, 4, 5 ]); + t.end(); +}); + +test('always something', function (t) { + var xs = [ 'a', 'b', 'c', 'd' ]; + var ys = concatMap(xs, function (x) { + return x === 'b' ? [ 'B', 'B', 'B' ] : [ x ]; + }); + t.same(ys, [ 'a', 'B', 'B', 'B', 'c', 'd' ]); + t.end(); +}); + +test('scalars', function (t) { + var xs = [ 'a', 'b', 'c', 'd' ]; + var ys = concatMap(xs, function (x) { + return x === 'b' ? [ 'B', 'B', 'B' ] : x; + }); + t.same(ys, [ 'a', 'B', 'B', 'B', 'c', 'd' ]); + t.end(); +}); + +test('undefs', function (t) { + var xs = [ 'a', 'b', 'c', 'd' ]; + var ys = concatMap(xs, function () {}); + t.same(ys, [ undefined, undefined, undefined, undefined ]); + t.end(); +}); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/escalade/dist/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/escalade/dist/index.js new file mode 100644 index 0000000000000000000000000000000000000000..ad236c492050394ade5d7d3d1749e5bcfcc8542b --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/escalade/dist/index.js @@ -0,0 +1,22 @@ +const { dirname, resolve } = require('path'); +const { readdir, stat } = require('fs'); +const { promisify } = require('util'); + +const toStats = promisify(stat); +const toRead = promisify(readdir); + +module.exports = async function (start, callback) { + let dir = resolve('.', start); + let tmp, stats = await toStats(dir); + + if (!stats.isDirectory()) { + dir = dirname(dir); + } + + while (true) { + tmp = await callback(dir, await toRead(dir)); + if (tmp) return resolve(dir, tmp); + dir = dirname(tmp = dir); + if (tmp === dir) break; + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/escalade/dist/index.mjs b/novas/novacore-zephyr/claude-code-router/node_modules/escalade/dist/index.mjs new file mode 100644 index 0000000000000000000000000000000000000000..bf95be03425c909cd4aaef11fdb7ac6fe31e2dd3 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/escalade/dist/index.mjs @@ -0,0 +1,22 @@ +import { dirname, resolve } from 'path'; +import { readdir, stat } from 'fs'; +import { promisify } from 'util'; + +const toStats = promisify(stat); +const toRead = promisify(readdir); + +export default async function (start, callback) { + let dir = resolve('.', start); + let tmp, stats = await toStats(dir); + + if (!stats.isDirectory()) { + dir = dirname(dir); + } + + while (true) { + tmp = await callback(dir, await toRead(dir)); + if (tmp) return resolve(dir, tmp); + dir = dirname(tmp = dir); + if (tmp === dir) break; + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/escalade/sync/index.d.mts b/novas/novacore-zephyr/claude-code-router/node_modules/escalade/sync/index.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..c023d37b286d1f16630ed054d492c027184dffc0 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/escalade/sync/index.d.mts @@ -0,0 +1,9 @@ +export type Callback = ( + directory: string, + files: string[], +) => string | false | void; + +export default function ( + directory: string, + callback: Callback, +): string | void; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/escalade/sync/index.d.ts b/novas/novacore-zephyr/claude-code-router/node_modules/escalade/sync/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9d5b5890c38169867e93a5dd6d3e9ed829370243 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/escalade/sync/index.d.ts @@ -0,0 +1,13 @@ +declare namespace escalade { + export type Callback = ( + directory: string, + files: string[], + ) => string | false | void; +} + +declare function escalade( + directory: string, + callback: escalade.Callback, +): string | void; + +export = escalade; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/escalade/sync/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/escalade/sync/index.js new file mode 100644 index 0000000000000000000000000000000000000000..902cc46cd9a80b10aa787e067ff1936ada95505d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/escalade/sync/index.js @@ -0,0 +1,18 @@ +const { dirname, resolve } = require('path'); +const { readdirSync, statSync } = require('fs'); + +module.exports = function (start, callback) { + let dir = resolve('.', start); + let tmp, stats = statSync(dir); + + if (!stats.isDirectory()) { + dir = dirname(dir); + } + + while (true) { + tmp = callback(dir, readdirSync(dir)); + if (tmp) return resolve(dir, tmp); + dir = dirname(tmp = dir); + if (tmp === dir) break; + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/escalade/sync/index.mjs b/novas/novacore-zephyr/claude-code-router/node_modules/escalade/sync/index.mjs new file mode 100644 index 0000000000000000000000000000000000000000..3cdc5bd1fee04733ea106fd6cdde40ec094880cb --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/escalade/sync/index.mjs @@ -0,0 +1,18 @@ +import { dirname, resolve } from 'path'; +import { readdirSync, statSync } from 'fs'; + +export default function (start, callback) { + let dir = resolve('.', start); + let tmp, stats = statSync(dir); + + if (!stats.isDirectory()) { + dir = dirname(dir); + } + + while (true) { + tmp = callback(dir, readdirSync(dir)); + if (tmp) return resolve(dir, tmp); + dir = dirname(tmp = dir); + if (tmp === dir) break; + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/esprima/bin/esparse.js b/novas/novacore-zephyr/claude-code-router/node_modules/esprima/bin/esparse.js new file mode 100644 index 0000000000000000000000000000000000000000..45d05fbb732673ddbd05d73e9a737d94d26742f2 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/esprima/bin/esparse.js @@ -0,0 +1,139 @@ +#!/usr/bin/env node +/* + Copyright JS Foundation and other contributors, https://js.foundation/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/*jslint sloppy:true node:true rhino:true */ + +var fs, esprima, fname, forceFile, content, options, syntax; + +if (typeof require === 'function') { + fs = require('fs'); + try { + esprima = require('esprima'); + } catch (e) { + esprima = require('../'); + } +} else if (typeof load === 'function') { + try { + load('esprima.js'); + } catch (e) { + load('../esprima.js'); + } +} + +// Shims to Node.js objects when running under Rhino. +if (typeof console === 'undefined' && typeof process === 'undefined') { + console = { log: print }; + fs = { readFileSync: readFile }; + process = { argv: arguments, exit: quit }; + process.argv.unshift('esparse.js'); + process.argv.unshift('rhino'); +} + +function showUsage() { + console.log('Usage:'); + console.log(' esparse [options] [file.js]'); + console.log(); + console.log('Available options:'); + console.log(); + console.log(' --comment Gather all line and block comments in an array'); + console.log(' --loc Include line-column location info for each syntax node'); + console.log(' --range Include index-based range for each syntax node'); + console.log(' --raw Display the raw value of literals'); + console.log(' --tokens List all tokens in an array'); + console.log(' --tolerant Tolerate errors on a best-effort basis (experimental)'); + console.log(' -v, --version Shows program version'); + console.log(); + process.exit(1); +} + +options = {}; + +process.argv.splice(2).forEach(function (entry) { + + if (forceFile || entry === '-' || entry.slice(0, 1) !== '-') { + if (typeof fname === 'string') { + console.log('Error: more than one input file.'); + process.exit(1); + } else { + fname = entry; + } + } else if (entry === '-h' || entry === '--help') { + showUsage(); + } else if (entry === '-v' || entry === '--version') { + console.log('ECMAScript Parser (using Esprima version', esprima.version, ')'); + console.log(); + process.exit(0); + } else if (entry === '--comment') { + options.comment = true; + } else if (entry === '--loc') { + options.loc = true; + } else if (entry === '--range') { + options.range = true; + } else if (entry === '--raw') { + options.raw = true; + } else if (entry === '--tokens') { + options.tokens = true; + } else if (entry === '--tolerant') { + options.tolerant = true; + } else if (entry === '--') { + forceFile = true; + } else { + console.log('Error: unknown option ' + entry + '.'); + process.exit(1); + } +}); + +// Special handling for regular expression literal since we need to +// convert it to a string literal, otherwise it will be decoded +// as object "{}" and the regular expression would be lost. +function adjustRegexLiteral(key, value) { + if (key === 'value' && value instanceof RegExp) { + value = value.toString(); + } + return value; +} + +function run(content) { + syntax = esprima.parse(content, options); + console.log(JSON.stringify(syntax, adjustRegexLiteral, 4)); +} + +try { + if (fname && (fname !== '-' || forceFile)) { + run(fs.readFileSync(fname, 'utf-8')); + } else { + var content = ''; + process.stdin.resume(); + process.stdin.on('data', function(chunk) { + content += chunk; + }); + process.stdin.on('end', function() { + run(content); + }); + } +} catch (e) { + console.log('Error: ' + e.message); + process.exit(1); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/esprima/bin/esvalidate.js b/novas/novacore-zephyr/claude-code-router/node_modules/esprima/bin/esvalidate.js new file mode 100644 index 0000000000000000000000000000000000000000..d49a7e40a8c3d409aec5256a317c60dc98e8eefc --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/esprima/bin/esvalidate.js @@ -0,0 +1,236 @@ +#!/usr/bin/env node +/* + Copyright JS Foundation and other contributors, https://js.foundation/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/*jslint sloppy:true plusplus:true node:true rhino:true */ +/*global phantom:true */ + +var fs, system, esprima, options, fnames, forceFile, count; + +if (typeof esprima === 'undefined') { + // PhantomJS can only require() relative files + if (typeof phantom === 'object') { + fs = require('fs'); + system = require('system'); + esprima = require('./esprima'); + } else if (typeof require === 'function') { + fs = require('fs'); + try { + esprima = require('esprima'); + } catch (e) { + esprima = require('../'); + } + } else if (typeof load === 'function') { + try { + load('esprima.js'); + } catch (e) { + load('../esprima.js'); + } + } +} + +// Shims to Node.js objects when running under PhantomJS 1.7+. +if (typeof phantom === 'object') { + fs.readFileSync = fs.read; + process = { + argv: [].slice.call(system.args), + exit: phantom.exit, + on: function (evt, callback) { + callback(); + } + }; + process.argv.unshift('phantomjs'); +} + +// Shims to Node.js objects when running under Rhino. +if (typeof console === 'undefined' && typeof process === 'undefined') { + console = { log: print }; + fs = { readFileSync: readFile }; + process = { + argv: arguments, + exit: quit, + on: function (evt, callback) { + callback(); + } + }; + process.argv.unshift('esvalidate.js'); + process.argv.unshift('rhino'); +} + +function showUsage() { + console.log('Usage:'); + console.log(' esvalidate [options] [file.js...]'); + console.log(); + console.log('Available options:'); + console.log(); + console.log(' --format=type Set the report format, plain (default) or junit'); + console.log(' -v, --version Print program version'); + console.log(); + process.exit(1); +} + +options = { + format: 'plain' +}; + +fnames = []; + +process.argv.splice(2).forEach(function (entry) { + + if (forceFile || entry === '-' || entry.slice(0, 1) !== '-') { + fnames.push(entry); + } else if (entry === '-h' || entry === '--help') { + showUsage(); + } else if (entry === '-v' || entry === '--version') { + console.log('ECMAScript Validator (using Esprima version', esprima.version, ')'); + console.log(); + process.exit(0); + } else if (entry.slice(0, 9) === '--format=') { + options.format = entry.slice(9); + if (options.format !== 'plain' && options.format !== 'junit') { + console.log('Error: unknown report format ' + options.format + '.'); + process.exit(1); + } + } else if (entry === '--') { + forceFile = true; + } else { + console.log('Error: unknown option ' + entry + '.'); + process.exit(1); + } +}); + +if (fnames.length === 0) { + fnames.push(''); +} + +if (options.format === 'junit') { + console.log(''); + console.log(''); +} + +count = 0; + +function run(fname, content) { + var timestamp, syntax, name; + try { + if (typeof content !== 'string') { + throw content; + } + + if (content[0] === '#' && content[1] === '!') { + content = '//' + content.substr(2, content.length); + } + + timestamp = Date.now(); + syntax = esprima.parse(content, { tolerant: true }); + + if (options.format === 'junit') { + + name = fname; + if (name.lastIndexOf('/') >= 0) { + name = name.slice(name.lastIndexOf('/') + 1); + } + + console.log(''); + + syntax.errors.forEach(function (error) { + var msg = error.message; + msg = msg.replace(/^Line\ [0-9]*\:\ /, ''); + console.log(' '); + console.log(' ' + + error.message + '(' + name + ':' + error.lineNumber + ')' + + ''); + console.log(' '); + }); + + console.log(''); + + } else if (options.format === 'plain') { + + syntax.errors.forEach(function (error) { + var msg = error.message; + msg = msg.replace(/^Line\ [0-9]*\:\ /, ''); + msg = fname + ':' + error.lineNumber + ': ' + msg; + console.log(msg); + ++count; + }); + + } + } catch (e) { + ++count; + if (options.format === 'junit') { + console.log(''); + console.log(' '); + console.log(' ' + + e.message + '(' + fname + ((e.lineNumber) ? ':' + e.lineNumber : '') + + ')'); + console.log(' '); + console.log(''); + } else { + console.log(fname + ':' + e.lineNumber + ': ' + e.message.replace(/^Line\ [0-9]*\:\ /, '')); + } + } +} + +fnames.forEach(function (fname) { + var content = ''; + try { + if (fname && (fname !== '-' || forceFile)) { + content = fs.readFileSync(fname, 'utf-8'); + } else { + fname = ''; + process.stdin.resume(); + process.stdin.on('data', function(chunk) { + content += chunk; + }); + process.stdin.on('end', function() { + run(fname, content); + }); + return; + } + } catch (e) { + content = e; + } + run(fname, content); +}); + +process.on('exit', function () { + if (options.format === 'junit') { + console.log(''); + } + + if (count > 0) { + process.exit(1); + } + + if (count === 0 && typeof phantom === 'object') { + process.exit(0); + } +}); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/esprima/dist/esprima.js b/novas/novacore-zephyr/claude-code-router/node_modules/esprima/dist/esprima.js new file mode 100644 index 0000000000000000000000000000000000000000..2af3eee125b0cfbb6be38411321064bbe7fd6bdd --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/esprima/dist/esprima.js @@ -0,0 +1,6709 @@ +(function webpackUniversalModuleDefinition(root, factory) { +/* istanbul ignore next */ + if(typeof exports === 'object' && typeof module === 'object') + module.exports = factory(); + else if(typeof define === 'function' && define.amd) + define([], factory); +/* istanbul ignore next */ + else if(typeof exports === 'object') + exports["esprima"] = factory(); + else + root["esprima"] = factory(); +})(this, function() { +return /******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; + +/******/ // The require function +/******/ function __webpack_require__(moduleId) { + +/******/ // Check if module is in cache +/* istanbul ignore if */ +/******/ if(installedModules[moduleId]) +/******/ return installedModules[moduleId].exports; + +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ exports: {}, +/******/ id: moduleId, +/******/ loaded: false +/******/ }; + +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); + +/******/ // Flag the module as loaded +/******/ module.loaded = true; + +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } + + +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; + +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; + +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; + +/******/ // Load entry module and return exports +/******/ return __webpack_require__(0); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + /* + Copyright JS Foundation and other contributors, https://js.foundation/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + Object.defineProperty(exports, "__esModule", { value: true }); + var comment_handler_1 = __webpack_require__(1); + var jsx_parser_1 = __webpack_require__(3); + var parser_1 = __webpack_require__(8); + var tokenizer_1 = __webpack_require__(15); + function parse(code, options, delegate) { + var commentHandler = null; + var proxyDelegate = function (node, metadata) { + if (delegate) { + delegate(node, metadata); + } + if (commentHandler) { + commentHandler.visit(node, metadata); + } + }; + var parserDelegate = (typeof delegate === 'function') ? proxyDelegate : null; + var collectComment = false; + if (options) { + collectComment = (typeof options.comment === 'boolean' && options.comment); + var attachComment = (typeof options.attachComment === 'boolean' && options.attachComment); + if (collectComment || attachComment) { + commentHandler = new comment_handler_1.CommentHandler(); + commentHandler.attach = attachComment; + options.comment = true; + parserDelegate = proxyDelegate; + } + } + var isModule = false; + if (options && typeof options.sourceType === 'string') { + isModule = (options.sourceType === 'module'); + } + var parser; + if (options && typeof options.jsx === 'boolean' && options.jsx) { + parser = new jsx_parser_1.JSXParser(code, options, parserDelegate); + } + else { + parser = new parser_1.Parser(code, options, parserDelegate); + } + var program = isModule ? parser.parseModule() : parser.parseScript(); + var ast = program; + if (collectComment && commentHandler) { + ast.comments = commentHandler.comments; + } + if (parser.config.tokens) { + ast.tokens = parser.tokens; + } + if (parser.config.tolerant) { + ast.errors = parser.errorHandler.errors; + } + return ast; + } + exports.parse = parse; + function parseModule(code, options, delegate) { + var parsingOptions = options || {}; + parsingOptions.sourceType = 'module'; + return parse(code, parsingOptions, delegate); + } + exports.parseModule = parseModule; + function parseScript(code, options, delegate) { + var parsingOptions = options || {}; + parsingOptions.sourceType = 'script'; + return parse(code, parsingOptions, delegate); + } + exports.parseScript = parseScript; + function tokenize(code, options, delegate) { + var tokenizer = new tokenizer_1.Tokenizer(code, options); + var tokens; + tokens = []; + try { + while (true) { + var token = tokenizer.getNextToken(); + if (!token) { + break; + } + if (delegate) { + token = delegate(token); + } + tokens.push(token); + } + } + catch (e) { + tokenizer.errorHandler.tolerate(e); + } + if (tokenizer.errorHandler.tolerant) { + tokens.errors = tokenizer.errors(); + } + return tokens; + } + exports.tokenize = tokenize; + var syntax_1 = __webpack_require__(2); + exports.Syntax = syntax_1.Syntax; + // Sync with *.json manifests. + exports.version = '4.0.1'; + + +/***/ }, +/* 1 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var syntax_1 = __webpack_require__(2); + var CommentHandler = (function () { + function CommentHandler() { + this.attach = false; + this.comments = []; + this.stack = []; + this.leading = []; + this.trailing = []; + } + CommentHandler.prototype.insertInnerComments = function (node, metadata) { + // innnerComments for properties empty block + // `function a() {/** comments **\/}` + if (node.type === syntax_1.Syntax.BlockStatement && node.body.length === 0) { + var innerComments = []; + for (var i = this.leading.length - 1; i >= 0; --i) { + var entry = this.leading[i]; + if (metadata.end.offset >= entry.start) { + innerComments.unshift(entry.comment); + this.leading.splice(i, 1); + this.trailing.splice(i, 1); + } + } + if (innerComments.length) { + node.innerComments = innerComments; + } + } + }; + CommentHandler.prototype.findTrailingComments = function (metadata) { + var trailingComments = []; + if (this.trailing.length > 0) { + for (var i = this.trailing.length - 1; i >= 0; --i) { + var entry_1 = this.trailing[i]; + if (entry_1.start >= metadata.end.offset) { + trailingComments.unshift(entry_1.comment); + } + } + this.trailing.length = 0; + return trailingComments; + } + var entry = this.stack[this.stack.length - 1]; + if (entry && entry.node.trailingComments) { + var firstComment = entry.node.trailingComments[0]; + if (firstComment && firstComment.range[0] >= metadata.end.offset) { + trailingComments = entry.node.trailingComments; + delete entry.node.trailingComments; + } + } + return trailingComments; + }; + CommentHandler.prototype.findLeadingComments = function (metadata) { + var leadingComments = []; + var target; + while (this.stack.length > 0) { + var entry = this.stack[this.stack.length - 1]; + if (entry && entry.start >= metadata.start.offset) { + target = entry.node; + this.stack.pop(); + } + else { + break; + } + } + if (target) { + var count = target.leadingComments ? target.leadingComments.length : 0; + for (var i = count - 1; i >= 0; --i) { + var comment = target.leadingComments[i]; + if (comment.range[1] <= metadata.start.offset) { + leadingComments.unshift(comment); + target.leadingComments.splice(i, 1); + } + } + if (target.leadingComments && target.leadingComments.length === 0) { + delete target.leadingComments; + } + return leadingComments; + } + for (var i = this.leading.length - 1; i >= 0; --i) { + var entry = this.leading[i]; + if (entry.start <= metadata.start.offset) { + leadingComments.unshift(entry.comment); + this.leading.splice(i, 1); + } + } + return leadingComments; + }; + CommentHandler.prototype.visitNode = function (node, metadata) { + if (node.type === syntax_1.Syntax.Program && node.body.length > 0) { + return; + } + this.insertInnerComments(node, metadata); + var trailingComments = this.findTrailingComments(metadata); + var leadingComments = this.findLeadingComments(metadata); + if (leadingComments.length > 0) { + node.leadingComments = leadingComments; + } + if (trailingComments.length > 0) { + node.trailingComments = trailingComments; + } + this.stack.push({ + node: node, + start: metadata.start.offset + }); + }; + CommentHandler.prototype.visitComment = function (node, metadata) { + var type = (node.type[0] === 'L') ? 'Line' : 'Block'; + var comment = { + type: type, + value: node.value + }; + if (node.range) { + comment.range = node.range; + } + if (node.loc) { + comment.loc = node.loc; + } + this.comments.push(comment); + if (this.attach) { + var entry = { + comment: { + type: type, + value: node.value, + range: [metadata.start.offset, metadata.end.offset] + }, + start: metadata.start.offset + }; + if (node.loc) { + entry.comment.loc = node.loc; + } + node.type = type; + this.leading.push(entry); + this.trailing.push(entry); + } + }; + CommentHandler.prototype.visit = function (node, metadata) { + if (node.type === 'LineComment') { + this.visitComment(node, metadata); + } + else if (node.type === 'BlockComment') { + this.visitComment(node, metadata); + } + else if (this.attach) { + this.visitNode(node, metadata); + } + }; + return CommentHandler; + }()); + exports.CommentHandler = CommentHandler; + + +/***/ }, +/* 2 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.Syntax = { + AssignmentExpression: 'AssignmentExpression', + AssignmentPattern: 'AssignmentPattern', + ArrayExpression: 'ArrayExpression', + ArrayPattern: 'ArrayPattern', + ArrowFunctionExpression: 'ArrowFunctionExpression', + AwaitExpression: 'AwaitExpression', + BlockStatement: 'BlockStatement', + BinaryExpression: 'BinaryExpression', + BreakStatement: 'BreakStatement', + CallExpression: 'CallExpression', + CatchClause: 'CatchClause', + ClassBody: 'ClassBody', + ClassDeclaration: 'ClassDeclaration', + ClassExpression: 'ClassExpression', + ConditionalExpression: 'ConditionalExpression', + ContinueStatement: 'ContinueStatement', + DoWhileStatement: 'DoWhileStatement', + DebuggerStatement: 'DebuggerStatement', + EmptyStatement: 'EmptyStatement', + ExportAllDeclaration: 'ExportAllDeclaration', + ExportDefaultDeclaration: 'ExportDefaultDeclaration', + ExportNamedDeclaration: 'ExportNamedDeclaration', + ExportSpecifier: 'ExportSpecifier', + ExpressionStatement: 'ExpressionStatement', + ForStatement: 'ForStatement', + ForOfStatement: 'ForOfStatement', + ForInStatement: 'ForInStatement', + FunctionDeclaration: 'FunctionDeclaration', + FunctionExpression: 'FunctionExpression', + Identifier: 'Identifier', + IfStatement: 'IfStatement', + ImportDeclaration: 'ImportDeclaration', + ImportDefaultSpecifier: 'ImportDefaultSpecifier', + ImportNamespaceSpecifier: 'ImportNamespaceSpecifier', + ImportSpecifier: 'ImportSpecifier', + Literal: 'Literal', + LabeledStatement: 'LabeledStatement', + LogicalExpression: 'LogicalExpression', + MemberExpression: 'MemberExpression', + MetaProperty: 'MetaProperty', + MethodDefinition: 'MethodDefinition', + NewExpression: 'NewExpression', + ObjectExpression: 'ObjectExpression', + ObjectPattern: 'ObjectPattern', + Program: 'Program', + Property: 'Property', + RestElement: 'RestElement', + ReturnStatement: 'ReturnStatement', + SequenceExpression: 'SequenceExpression', + SpreadElement: 'SpreadElement', + Super: 'Super', + SwitchCase: 'SwitchCase', + SwitchStatement: 'SwitchStatement', + TaggedTemplateExpression: 'TaggedTemplateExpression', + TemplateElement: 'TemplateElement', + TemplateLiteral: 'TemplateLiteral', + ThisExpression: 'ThisExpression', + ThrowStatement: 'ThrowStatement', + TryStatement: 'TryStatement', + UnaryExpression: 'UnaryExpression', + UpdateExpression: 'UpdateExpression', + VariableDeclaration: 'VariableDeclaration', + VariableDeclarator: 'VariableDeclarator', + WhileStatement: 'WhileStatement', + WithStatement: 'WithStatement', + YieldExpression: 'YieldExpression' + }; + + +/***/ }, +/* 3 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; +/* istanbul ignore next */ + var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + })(); + Object.defineProperty(exports, "__esModule", { value: true }); + var character_1 = __webpack_require__(4); + var JSXNode = __webpack_require__(5); + var jsx_syntax_1 = __webpack_require__(6); + var Node = __webpack_require__(7); + var parser_1 = __webpack_require__(8); + var token_1 = __webpack_require__(13); + var xhtml_entities_1 = __webpack_require__(14); + token_1.TokenName[100 /* Identifier */] = 'JSXIdentifier'; + token_1.TokenName[101 /* Text */] = 'JSXText'; + // Fully qualified element name, e.g. returns "svg:path" + function getQualifiedElementName(elementName) { + var qualifiedName; + switch (elementName.type) { + case jsx_syntax_1.JSXSyntax.JSXIdentifier: + var id = elementName; + qualifiedName = id.name; + break; + case jsx_syntax_1.JSXSyntax.JSXNamespacedName: + var ns = elementName; + qualifiedName = getQualifiedElementName(ns.namespace) + ':' + + getQualifiedElementName(ns.name); + break; + case jsx_syntax_1.JSXSyntax.JSXMemberExpression: + var expr = elementName; + qualifiedName = getQualifiedElementName(expr.object) + '.' + + getQualifiedElementName(expr.property); + break; + /* istanbul ignore next */ + default: + break; + } + return qualifiedName; + } + var JSXParser = (function (_super) { + __extends(JSXParser, _super); + function JSXParser(code, options, delegate) { + return _super.call(this, code, options, delegate) || this; + } + JSXParser.prototype.parsePrimaryExpression = function () { + return this.match('<') ? this.parseJSXRoot() : _super.prototype.parsePrimaryExpression.call(this); + }; + JSXParser.prototype.startJSX = function () { + // Unwind the scanner before the lookahead token. + this.scanner.index = this.startMarker.index; + this.scanner.lineNumber = this.startMarker.line; + this.scanner.lineStart = this.startMarker.index - this.startMarker.column; + }; + JSXParser.prototype.finishJSX = function () { + // Prime the next lookahead. + this.nextToken(); + }; + JSXParser.prototype.reenterJSX = function () { + this.startJSX(); + this.expectJSX('}'); + // Pop the closing '}' added from the lookahead. + if (this.config.tokens) { + this.tokens.pop(); + } + }; + JSXParser.prototype.createJSXNode = function () { + this.collectComments(); + return { + index: this.scanner.index, + line: this.scanner.lineNumber, + column: this.scanner.index - this.scanner.lineStart + }; + }; + JSXParser.prototype.createJSXChildNode = function () { + return { + index: this.scanner.index, + line: this.scanner.lineNumber, + column: this.scanner.index - this.scanner.lineStart + }; + }; + JSXParser.prototype.scanXHTMLEntity = function (quote) { + var result = '&'; + var valid = true; + var terminated = false; + var numeric = false; + var hex = false; + while (!this.scanner.eof() && valid && !terminated) { + var ch = this.scanner.source[this.scanner.index]; + if (ch === quote) { + break; + } + terminated = (ch === ';'); + result += ch; + ++this.scanner.index; + if (!terminated) { + switch (result.length) { + case 2: + // e.g. '{' + numeric = (ch === '#'); + break; + case 3: + if (numeric) { + // e.g. 'A' + hex = (ch === 'x'); + valid = hex || character_1.Character.isDecimalDigit(ch.charCodeAt(0)); + numeric = numeric && !hex; + } + break; + default: + valid = valid && !(numeric && !character_1.Character.isDecimalDigit(ch.charCodeAt(0))); + valid = valid && !(hex && !character_1.Character.isHexDigit(ch.charCodeAt(0))); + break; + } + } + } + if (valid && terminated && result.length > 2) { + // e.g. 'A' becomes just '#x41' + var str = result.substr(1, result.length - 2); + if (numeric && str.length > 1) { + result = String.fromCharCode(parseInt(str.substr(1), 10)); + } + else if (hex && str.length > 2) { + result = String.fromCharCode(parseInt('0' + str.substr(1), 16)); + } + else if (!numeric && !hex && xhtml_entities_1.XHTMLEntities[str]) { + result = xhtml_entities_1.XHTMLEntities[str]; + } + } + return result; + }; + // Scan the next JSX token. This replaces Scanner#lex when in JSX mode. + JSXParser.prototype.lexJSX = function () { + var cp = this.scanner.source.charCodeAt(this.scanner.index); + // < > / : = { } + if (cp === 60 || cp === 62 || cp === 47 || cp === 58 || cp === 61 || cp === 123 || cp === 125) { + var value = this.scanner.source[this.scanner.index++]; + return { + type: 7 /* Punctuator */, + value: value, + lineNumber: this.scanner.lineNumber, + lineStart: this.scanner.lineStart, + start: this.scanner.index - 1, + end: this.scanner.index + }; + } + // " ' + if (cp === 34 || cp === 39) { + var start = this.scanner.index; + var quote = this.scanner.source[this.scanner.index++]; + var str = ''; + while (!this.scanner.eof()) { + var ch = this.scanner.source[this.scanner.index++]; + if (ch === quote) { + break; + } + else if (ch === '&') { + str += this.scanXHTMLEntity(quote); + } + else { + str += ch; + } + } + return { + type: 8 /* StringLiteral */, + value: str, + lineNumber: this.scanner.lineNumber, + lineStart: this.scanner.lineStart, + start: start, + end: this.scanner.index + }; + } + // ... or . + if (cp === 46) { + var n1 = this.scanner.source.charCodeAt(this.scanner.index + 1); + var n2 = this.scanner.source.charCodeAt(this.scanner.index + 2); + var value = (n1 === 46 && n2 === 46) ? '...' : '.'; + var start = this.scanner.index; + this.scanner.index += value.length; + return { + type: 7 /* Punctuator */, + value: value, + lineNumber: this.scanner.lineNumber, + lineStart: this.scanner.lineStart, + start: start, + end: this.scanner.index + }; + } + // ` + if (cp === 96) { + // Only placeholder, since it will be rescanned as a real assignment expression. + return { + type: 10 /* Template */, + value: '', + lineNumber: this.scanner.lineNumber, + lineStart: this.scanner.lineStart, + start: this.scanner.index, + end: this.scanner.index + }; + } + // Identifer can not contain backslash (char code 92). + if (character_1.Character.isIdentifierStart(cp) && (cp !== 92)) { + var start = this.scanner.index; + ++this.scanner.index; + while (!this.scanner.eof()) { + var ch = this.scanner.source.charCodeAt(this.scanner.index); + if (character_1.Character.isIdentifierPart(ch) && (ch !== 92)) { + ++this.scanner.index; + } + else if (ch === 45) { + // Hyphen (char code 45) can be part of an identifier. + ++this.scanner.index; + } + else { + break; + } + } + var id = this.scanner.source.slice(start, this.scanner.index); + return { + type: 100 /* Identifier */, + value: id, + lineNumber: this.scanner.lineNumber, + lineStart: this.scanner.lineStart, + start: start, + end: this.scanner.index + }; + } + return this.scanner.lex(); + }; + JSXParser.prototype.nextJSXToken = function () { + this.collectComments(); + this.startMarker.index = this.scanner.index; + this.startMarker.line = this.scanner.lineNumber; + this.startMarker.column = this.scanner.index - this.scanner.lineStart; + var token = this.lexJSX(); + this.lastMarker.index = this.scanner.index; + this.lastMarker.line = this.scanner.lineNumber; + this.lastMarker.column = this.scanner.index - this.scanner.lineStart; + if (this.config.tokens) { + this.tokens.push(this.convertToken(token)); + } + return token; + }; + JSXParser.prototype.nextJSXText = function () { + this.startMarker.index = this.scanner.index; + this.startMarker.line = this.scanner.lineNumber; + this.startMarker.column = this.scanner.index - this.scanner.lineStart; + var start = this.scanner.index; + var text = ''; + while (!this.scanner.eof()) { + var ch = this.scanner.source[this.scanner.index]; + if (ch === '{' || ch === '<') { + break; + } + ++this.scanner.index; + text += ch; + if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) { + ++this.scanner.lineNumber; + if (ch === '\r' && this.scanner.source[this.scanner.index] === '\n') { + ++this.scanner.index; + } + this.scanner.lineStart = this.scanner.index; + } + } + this.lastMarker.index = this.scanner.index; + this.lastMarker.line = this.scanner.lineNumber; + this.lastMarker.column = this.scanner.index - this.scanner.lineStart; + var token = { + type: 101 /* Text */, + value: text, + lineNumber: this.scanner.lineNumber, + lineStart: this.scanner.lineStart, + start: start, + end: this.scanner.index + }; + if ((text.length > 0) && this.config.tokens) { + this.tokens.push(this.convertToken(token)); + } + return token; + }; + JSXParser.prototype.peekJSXToken = function () { + var state = this.scanner.saveState(); + this.scanner.scanComments(); + var next = this.lexJSX(); + this.scanner.restoreState(state); + return next; + }; + // Expect the next JSX token to match the specified punctuator. + // If not, an exception will be thrown. + JSXParser.prototype.expectJSX = function (value) { + var token = this.nextJSXToken(); + if (token.type !== 7 /* Punctuator */ || token.value !== value) { + this.throwUnexpectedToken(token); + } + }; + // Return true if the next JSX token matches the specified punctuator. + JSXParser.prototype.matchJSX = function (value) { + var next = this.peekJSXToken(); + return next.type === 7 /* Punctuator */ && next.value === value; + }; + JSXParser.prototype.parseJSXIdentifier = function () { + var node = this.createJSXNode(); + var token = this.nextJSXToken(); + if (token.type !== 100 /* Identifier */) { + this.throwUnexpectedToken(token); + } + return this.finalize(node, new JSXNode.JSXIdentifier(token.value)); + }; + JSXParser.prototype.parseJSXElementName = function () { + var node = this.createJSXNode(); + var elementName = this.parseJSXIdentifier(); + if (this.matchJSX(':')) { + var namespace = elementName; + this.expectJSX(':'); + var name_1 = this.parseJSXIdentifier(); + elementName = this.finalize(node, new JSXNode.JSXNamespacedName(namespace, name_1)); + } + else if (this.matchJSX('.')) { + while (this.matchJSX('.')) { + var object = elementName; + this.expectJSX('.'); + var property = this.parseJSXIdentifier(); + elementName = this.finalize(node, new JSXNode.JSXMemberExpression(object, property)); + } + } + return elementName; + }; + JSXParser.prototype.parseJSXAttributeName = function () { + var node = this.createJSXNode(); + var attributeName; + var identifier = this.parseJSXIdentifier(); + if (this.matchJSX(':')) { + var namespace = identifier; + this.expectJSX(':'); + var name_2 = this.parseJSXIdentifier(); + attributeName = this.finalize(node, new JSXNode.JSXNamespacedName(namespace, name_2)); + } + else { + attributeName = identifier; + } + return attributeName; + }; + JSXParser.prototype.parseJSXStringLiteralAttribute = function () { + var node = this.createJSXNode(); + var token = this.nextJSXToken(); + if (token.type !== 8 /* StringLiteral */) { + this.throwUnexpectedToken(token); + } + var raw = this.getTokenRaw(token); + return this.finalize(node, new Node.Literal(token.value, raw)); + }; + JSXParser.prototype.parseJSXExpressionAttribute = function () { + var node = this.createJSXNode(); + this.expectJSX('{'); + this.finishJSX(); + if (this.match('}')) { + this.tolerateError('JSX attributes must only be assigned a non-empty expression'); + } + var expression = this.parseAssignmentExpression(); + this.reenterJSX(); + return this.finalize(node, new JSXNode.JSXExpressionContainer(expression)); + }; + JSXParser.prototype.parseJSXAttributeValue = function () { + return this.matchJSX('{') ? this.parseJSXExpressionAttribute() : + this.matchJSX('<') ? this.parseJSXElement() : this.parseJSXStringLiteralAttribute(); + }; + JSXParser.prototype.parseJSXNameValueAttribute = function () { + var node = this.createJSXNode(); + var name = this.parseJSXAttributeName(); + var value = null; + if (this.matchJSX('=')) { + this.expectJSX('='); + value = this.parseJSXAttributeValue(); + } + return this.finalize(node, new JSXNode.JSXAttribute(name, value)); + }; + JSXParser.prototype.parseJSXSpreadAttribute = function () { + var node = this.createJSXNode(); + this.expectJSX('{'); + this.expectJSX('...'); + this.finishJSX(); + var argument = this.parseAssignmentExpression(); + this.reenterJSX(); + return this.finalize(node, new JSXNode.JSXSpreadAttribute(argument)); + }; + JSXParser.prototype.parseJSXAttributes = function () { + var attributes = []; + while (!this.matchJSX('/') && !this.matchJSX('>')) { + var attribute = this.matchJSX('{') ? this.parseJSXSpreadAttribute() : + this.parseJSXNameValueAttribute(); + attributes.push(attribute); + } + return attributes; + }; + JSXParser.prototype.parseJSXOpeningElement = function () { + var node = this.createJSXNode(); + this.expectJSX('<'); + var name = this.parseJSXElementName(); + var attributes = this.parseJSXAttributes(); + var selfClosing = this.matchJSX('/'); + if (selfClosing) { + this.expectJSX('/'); + } + this.expectJSX('>'); + return this.finalize(node, new JSXNode.JSXOpeningElement(name, selfClosing, attributes)); + }; + JSXParser.prototype.parseJSXBoundaryElement = function () { + var node = this.createJSXNode(); + this.expectJSX('<'); + if (this.matchJSX('/')) { + this.expectJSX('/'); + var name_3 = this.parseJSXElementName(); + this.expectJSX('>'); + return this.finalize(node, new JSXNode.JSXClosingElement(name_3)); + } + var name = this.parseJSXElementName(); + var attributes = this.parseJSXAttributes(); + var selfClosing = this.matchJSX('/'); + if (selfClosing) { + this.expectJSX('/'); + } + this.expectJSX('>'); + return this.finalize(node, new JSXNode.JSXOpeningElement(name, selfClosing, attributes)); + }; + JSXParser.prototype.parseJSXEmptyExpression = function () { + var node = this.createJSXChildNode(); + this.collectComments(); + this.lastMarker.index = this.scanner.index; + this.lastMarker.line = this.scanner.lineNumber; + this.lastMarker.column = this.scanner.index - this.scanner.lineStart; + return this.finalize(node, new JSXNode.JSXEmptyExpression()); + }; + JSXParser.prototype.parseJSXExpressionContainer = function () { + var node = this.createJSXNode(); + this.expectJSX('{'); + var expression; + if (this.matchJSX('}')) { + expression = this.parseJSXEmptyExpression(); + this.expectJSX('}'); + } + else { + this.finishJSX(); + expression = this.parseAssignmentExpression(); + this.reenterJSX(); + } + return this.finalize(node, new JSXNode.JSXExpressionContainer(expression)); + }; + JSXParser.prototype.parseJSXChildren = function () { + var children = []; + while (!this.scanner.eof()) { + var node = this.createJSXChildNode(); + var token = this.nextJSXText(); + if (token.start < token.end) { + var raw = this.getTokenRaw(token); + var child = this.finalize(node, new JSXNode.JSXText(token.value, raw)); + children.push(child); + } + if (this.scanner.source[this.scanner.index] === '{') { + var container = this.parseJSXExpressionContainer(); + children.push(container); + } + else { + break; + } + } + return children; + }; + JSXParser.prototype.parseComplexJSXElement = function (el) { + var stack = []; + while (!this.scanner.eof()) { + el.children = el.children.concat(this.parseJSXChildren()); + var node = this.createJSXChildNode(); + var element = this.parseJSXBoundaryElement(); + if (element.type === jsx_syntax_1.JSXSyntax.JSXOpeningElement) { + var opening = element; + if (opening.selfClosing) { + var child = this.finalize(node, new JSXNode.JSXElement(opening, [], null)); + el.children.push(child); + } + else { + stack.push(el); + el = { node: node, opening: opening, closing: null, children: [] }; + } + } + if (element.type === jsx_syntax_1.JSXSyntax.JSXClosingElement) { + el.closing = element; + var open_1 = getQualifiedElementName(el.opening.name); + var close_1 = getQualifiedElementName(el.closing.name); + if (open_1 !== close_1) { + this.tolerateError('Expected corresponding JSX closing tag for %0', open_1); + } + if (stack.length > 0) { + var child = this.finalize(el.node, new JSXNode.JSXElement(el.opening, el.children, el.closing)); + el = stack[stack.length - 1]; + el.children.push(child); + stack.pop(); + } + else { + break; + } + } + } + return el; + }; + JSXParser.prototype.parseJSXElement = function () { + var node = this.createJSXNode(); + var opening = this.parseJSXOpeningElement(); + var children = []; + var closing = null; + if (!opening.selfClosing) { + var el = this.parseComplexJSXElement({ node: node, opening: opening, closing: closing, children: children }); + children = el.children; + closing = el.closing; + } + return this.finalize(node, new JSXNode.JSXElement(opening, children, closing)); + }; + JSXParser.prototype.parseJSXRoot = function () { + // Pop the opening '<' added from the lookahead. + if (this.config.tokens) { + this.tokens.pop(); + } + this.startJSX(); + var element = this.parseJSXElement(); + this.finishJSX(); + return element; + }; + JSXParser.prototype.isStartOfExpression = function () { + return _super.prototype.isStartOfExpression.call(this) || this.match('<'); + }; + return JSXParser; + }(parser_1.Parser)); + exports.JSXParser = JSXParser; + + +/***/ }, +/* 4 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + // See also tools/generate-unicode-regex.js. + var Regex = { + // Unicode v8.0.0 NonAsciiIdentifierStart: + NonAsciiIdentifierStart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]/, + // Unicode v8.0.0 NonAsciiIdentifierPart: + NonAsciiIdentifierPart: /[\xAA\xB5\xB7\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B4\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1369-\u1371\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/ + }; + exports.Character = { + /* tslint:disable:no-bitwise */ + fromCodePoint: function (cp) { + return (cp < 0x10000) ? String.fromCharCode(cp) : + String.fromCharCode(0xD800 + ((cp - 0x10000) >> 10)) + + String.fromCharCode(0xDC00 + ((cp - 0x10000) & 1023)); + }, + // https://tc39.github.io/ecma262/#sec-white-space + isWhiteSpace: function (cp) { + return (cp === 0x20) || (cp === 0x09) || (cp === 0x0B) || (cp === 0x0C) || (cp === 0xA0) || + (cp >= 0x1680 && [0x1680, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x202F, 0x205F, 0x3000, 0xFEFF].indexOf(cp) >= 0); + }, + // https://tc39.github.io/ecma262/#sec-line-terminators + isLineTerminator: function (cp) { + return (cp === 0x0A) || (cp === 0x0D) || (cp === 0x2028) || (cp === 0x2029); + }, + // https://tc39.github.io/ecma262/#sec-names-and-keywords + isIdentifierStart: function (cp) { + return (cp === 0x24) || (cp === 0x5F) || + (cp >= 0x41 && cp <= 0x5A) || + (cp >= 0x61 && cp <= 0x7A) || + (cp === 0x5C) || + ((cp >= 0x80) && Regex.NonAsciiIdentifierStart.test(exports.Character.fromCodePoint(cp))); + }, + isIdentifierPart: function (cp) { + return (cp === 0x24) || (cp === 0x5F) || + (cp >= 0x41 && cp <= 0x5A) || + (cp >= 0x61 && cp <= 0x7A) || + (cp >= 0x30 && cp <= 0x39) || + (cp === 0x5C) || + ((cp >= 0x80) && Regex.NonAsciiIdentifierPart.test(exports.Character.fromCodePoint(cp))); + }, + // https://tc39.github.io/ecma262/#sec-literals-numeric-literals + isDecimalDigit: function (cp) { + return (cp >= 0x30 && cp <= 0x39); // 0..9 + }, + isHexDigit: function (cp) { + return (cp >= 0x30 && cp <= 0x39) || + (cp >= 0x41 && cp <= 0x46) || + (cp >= 0x61 && cp <= 0x66); // a..f + }, + isOctalDigit: function (cp) { + return (cp >= 0x30 && cp <= 0x37); // 0..7 + } + }; + + +/***/ }, +/* 5 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var jsx_syntax_1 = __webpack_require__(6); + /* tslint:disable:max-classes-per-file */ + var JSXClosingElement = (function () { + function JSXClosingElement(name) { + this.type = jsx_syntax_1.JSXSyntax.JSXClosingElement; + this.name = name; + } + return JSXClosingElement; + }()); + exports.JSXClosingElement = JSXClosingElement; + var JSXElement = (function () { + function JSXElement(openingElement, children, closingElement) { + this.type = jsx_syntax_1.JSXSyntax.JSXElement; + this.openingElement = openingElement; + this.children = children; + this.closingElement = closingElement; + } + return JSXElement; + }()); + exports.JSXElement = JSXElement; + var JSXEmptyExpression = (function () { + function JSXEmptyExpression() { + this.type = jsx_syntax_1.JSXSyntax.JSXEmptyExpression; + } + return JSXEmptyExpression; + }()); + exports.JSXEmptyExpression = JSXEmptyExpression; + var JSXExpressionContainer = (function () { + function JSXExpressionContainer(expression) { + this.type = jsx_syntax_1.JSXSyntax.JSXExpressionContainer; + this.expression = expression; + } + return JSXExpressionContainer; + }()); + exports.JSXExpressionContainer = JSXExpressionContainer; + var JSXIdentifier = (function () { + function JSXIdentifier(name) { + this.type = jsx_syntax_1.JSXSyntax.JSXIdentifier; + this.name = name; + } + return JSXIdentifier; + }()); + exports.JSXIdentifier = JSXIdentifier; + var JSXMemberExpression = (function () { + function JSXMemberExpression(object, property) { + this.type = jsx_syntax_1.JSXSyntax.JSXMemberExpression; + this.object = object; + this.property = property; + } + return JSXMemberExpression; + }()); + exports.JSXMemberExpression = JSXMemberExpression; + var JSXAttribute = (function () { + function JSXAttribute(name, value) { + this.type = jsx_syntax_1.JSXSyntax.JSXAttribute; + this.name = name; + this.value = value; + } + return JSXAttribute; + }()); + exports.JSXAttribute = JSXAttribute; + var JSXNamespacedName = (function () { + function JSXNamespacedName(namespace, name) { + this.type = jsx_syntax_1.JSXSyntax.JSXNamespacedName; + this.namespace = namespace; + this.name = name; + } + return JSXNamespacedName; + }()); + exports.JSXNamespacedName = JSXNamespacedName; + var JSXOpeningElement = (function () { + function JSXOpeningElement(name, selfClosing, attributes) { + this.type = jsx_syntax_1.JSXSyntax.JSXOpeningElement; + this.name = name; + this.selfClosing = selfClosing; + this.attributes = attributes; + } + return JSXOpeningElement; + }()); + exports.JSXOpeningElement = JSXOpeningElement; + var JSXSpreadAttribute = (function () { + function JSXSpreadAttribute(argument) { + this.type = jsx_syntax_1.JSXSyntax.JSXSpreadAttribute; + this.argument = argument; + } + return JSXSpreadAttribute; + }()); + exports.JSXSpreadAttribute = JSXSpreadAttribute; + var JSXText = (function () { + function JSXText(value, raw) { + this.type = jsx_syntax_1.JSXSyntax.JSXText; + this.value = value; + this.raw = raw; + } + return JSXText; + }()); + exports.JSXText = JSXText; + + +/***/ }, +/* 6 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.JSXSyntax = { + JSXAttribute: 'JSXAttribute', + JSXClosingElement: 'JSXClosingElement', + JSXElement: 'JSXElement', + JSXEmptyExpression: 'JSXEmptyExpression', + JSXExpressionContainer: 'JSXExpressionContainer', + JSXIdentifier: 'JSXIdentifier', + JSXMemberExpression: 'JSXMemberExpression', + JSXNamespacedName: 'JSXNamespacedName', + JSXOpeningElement: 'JSXOpeningElement', + JSXSpreadAttribute: 'JSXSpreadAttribute', + JSXText: 'JSXText' + }; + + +/***/ }, +/* 7 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var syntax_1 = __webpack_require__(2); + /* tslint:disable:max-classes-per-file */ + var ArrayExpression = (function () { + function ArrayExpression(elements) { + this.type = syntax_1.Syntax.ArrayExpression; + this.elements = elements; + } + return ArrayExpression; + }()); + exports.ArrayExpression = ArrayExpression; + var ArrayPattern = (function () { + function ArrayPattern(elements) { + this.type = syntax_1.Syntax.ArrayPattern; + this.elements = elements; + } + return ArrayPattern; + }()); + exports.ArrayPattern = ArrayPattern; + var ArrowFunctionExpression = (function () { + function ArrowFunctionExpression(params, body, expression) { + this.type = syntax_1.Syntax.ArrowFunctionExpression; + this.id = null; + this.params = params; + this.body = body; + this.generator = false; + this.expression = expression; + this.async = false; + } + return ArrowFunctionExpression; + }()); + exports.ArrowFunctionExpression = ArrowFunctionExpression; + var AssignmentExpression = (function () { + function AssignmentExpression(operator, left, right) { + this.type = syntax_1.Syntax.AssignmentExpression; + this.operator = operator; + this.left = left; + this.right = right; + } + return AssignmentExpression; + }()); + exports.AssignmentExpression = AssignmentExpression; + var AssignmentPattern = (function () { + function AssignmentPattern(left, right) { + this.type = syntax_1.Syntax.AssignmentPattern; + this.left = left; + this.right = right; + } + return AssignmentPattern; + }()); + exports.AssignmentPattern = AssignmentPattern; + var AsyncArrowFunctionExpression = (function () { + function AsyncArrowFunctionExpression(params, body, expression) { + this.type = syntax_1.Syntax.ArrowFunctionExpression; + this.id = null; + this.params = params; + this.body = body; + this.generator = false; + this.expression = expression; + this.async = true; + } + return AsyncArrowFunctionExpression; + }()); + exports.AsyncArrowFunctionExpression = AsyncArrowFunctionExpression; + var AsyncFunctionDeclaration = (function () { + function AsyncFunctionDeclaration(id, params, body) { + this.type = syntax_1.Syntax.FunctionDeclaration; + this.id = id; + this.params = params; + this.body = body; + this.generator = false; + this.expression = false; + this.async = true; + } + return AsyncFunctionDeclaration; + }()); + exports.AsyncFunctionDeclaration = AsyncFunctionDeclaration; + var AsyncFunctionExpression = (function () { + function AsyncFunctionExpression(id, params, body) { + this.type = syntax_1.Syntax.FunctionExpression; + this.id = id; + this.params = params; + this.body = body; + this.generator = false; + this.expression = false; + this.async = true; + } + return AsyncFunctionExpression; + }()); + exports.AsyncFunctionExpression = AsyncFunctionExpression; + var AwaitExpression = (function () { + function AwaitExpression(argument) { + this.type = syntax_1.Syntax.AwaitExpression; + this.argument = argument; + } + return AwaitExpression; + }()); + exports.AwaitExpression = AwaitExpression; + var BinaryExpression = (function () { + function BinaryExpression(operator, left, right) { + var logical = (operator === '||' || operator === '&&'); + this.type = logical ? syntax_1.Syntax.LogicalExpression : syntax_1.Syntax.BinaryExpression; + this.operator = operator; + this.left = left; + this.right = right; + } + return BinaryExpression; + }()); + exports.BinaryExpression = BinaryExpression; + var BlockStatement = (function () { + function BlockStatement(body) { + this.type = syntax_1.Syntax.BlockStatement; + this.body = body; + } + return BlockStatement; + }()); + exports.BlockStatement = BlockStatement; + var BreakStatement = (function () { + function BreakStatement(label) { + this.type = syntax_1.Syntax.BreakStatement; + this.label = label; + } + return BreakStatement; + }()); + exports.BreakStatement = BreakStatement; + var CallExpression = (function () { + function CallExpression(callee, args) { + this.type = syntax_1.Syntax.CallExpression; + this.callee = callee; + this.arguments = args; + } + return CallExpression; + }()); + exports.CallExpression = CallExpression; + var CatchClause = (function () { + function CatchClause(param, body) { + this.type = syntax_1.Syntax.CatchClause; + this.param = param; + this.body = body; + } + return CatchClause; + }()); + exports.CatchClause = CatchClause; + var ClassBody = (function () { + function ClassBody(body) { + this.type = syntax_1.Syntax.ClassBody; + this.body = body; + } + return ClassBody; + }()); + exports.ClassBody = ClassBody; + var ClassDeclaration = (function () { + function ClassDeclaration(id, superClass, body) { + this.type = syntax_1.Syntax.ClassDeclaration; + this.id = id; + this.superClass = superClass; + this.body = body; + } + return ClassDeclaration; + }()); + exports.ClassDeclaration = ClassDeclaration; + var ClassExpression = (function () { + function ClassExpression(id, superClass, body) { + this.type = syntax_1.Syntax.ClassExpression; + this.id = id; + this.superClass = superClass; + this.body = body; + } + return ClassExpression; + }()); + exports.ClassExpression = ClassExpression; + var ComputedMemberExpression = (function () { + function ComputedMemberExpression(object, property) { + this.type = syntax_1.Syntax.MemberExpression; + this.computed = true; + this.object = object; + this.property = property; + } + return ComputedMemberExpression; + }()); + exports.ComputedMemberExpression = ComputedMemberExpression; + var ConditionalExpression = (function () { + function ConditionalExpression(test, consequent, alternate) { + this.type = syntax_1.Syntax.ConditionalExpression; + this.test = test; + this.consequent = consequent; + this.alternate = alternate; + } + return ConditionalExpression; + }()); + exports.ConditionalExpression = ConditionalExpression; + var ContinueStatement = (function () { + function ContinueStatement(label) { + this.type = syntax_1.Syntax.ContinueStatement; + this.label = label; + } + return ContinueStatement; + }()); + exports.ContinueStatement = ContinueStatement; + var DebuggerStatement = (function () { + function DebuggerStatement() { + this.type = syntax_1.Syntax.DebuggerStatement; + } + return DebuggerStatement; + }()); + exports.DebuggerStatement = DebuggerStatement; + var Directive = (function () { + function Directive(expression, directive) { + this.type = syntax_1.Syntax.ExpressionStatement; + this.expression = expression; + this.directive = directive; + } + return Directive; + }()); + exports.Directive = Directive; + var DoWhileStatement = (function () { + function DoWhileStatement(body, test) { + this.type = syntax_1.Syntax.DoWhileStatement; + this.body = body; + this.test = test; + } + return DoWhileStatement; + }()); + exports.DoWhileStatement = DoWhileStatement; + var EmptyStatement = (function () { + function EmptyStatement() { + this.type = syntax_1.Syntax.EmptyStatement; + } + return EmptyStatement; + }()); + exports.EmptyStatement = EmptyStatement; + var ExportAllDeclaration = (function () { + function ExportAllDeclaration(source) { + this.type = syntax_1.Syntax.ExportAllDeclaration; + this.source = source; + } + return ExportAllDeclaration; + }()); + exports.ExportAllDeclaration = ExportAllDeclaration; + var ExportDefaultDeclaration = (function () { + function ExportDefaultDeclaration(declaration) { + this.type = syntax_1.Syntax.ExportDefaultDeclaration; + this.declaration = declaration; + } + return ExportDefaultDeclaration; + }()); + exports.ExportDefaultDeclaration = ExportDefaultDeclaration; + var ExportNamedDeclaration = (function () { + function ExportNamedDeclaration(declaration, specifiers, source) { + this.type = syntax_1.Syntax.ExportNamedDeclaration; + this.declaration = declaration; + this.specifiers = specifiers; + this.source = source; + } + return ExportNamedDeclaration; + }()); + exports.ExportNamedDeclaration = ExportNamedDeclaration; + var ExportSpecifier = (function () { + function ExportSpecifier(local, exported) { + this.type = syntax_1.Syntax.ExportSpecifier; + this.exported = exported; + this.local = local; + } + return ExportSpecifier; + }()); + exports.ExportSpecifier = ExportSpecifier; + var ExpressionStatement = (function () { + function ExpressionStatement(expression) { + this.type = syntax_1.Syntax.ExpressionStatement; + this.expression = expression; + } + return ExpressionStatement; + }()); + exports.ExpressionStatement = ExpressionStatement; + var ForInStatement = (function () { + function ForInStatement(left, right, body) { + this.type = syntax_1.Syntax.ForInStatement; + this.left = left; + this.right = right; + this.body = body; + this.each = false; + } + return ForInStatement; + }()); + exports.ForInStatement = ForInStatement; + var ForOfStatement = (function () { + function ForOfStatement(left, right, body) { + this.type = syntax_1.Syntax.ForOfStatement; + this.left = left; + this.right = right; + this.body = body; + } + return ForOfStatement; + }()); + exports.ForOfStatement = ForOfStatement; + var ForStatement = (function () { + function ForStatement(init, test, update, body) { + this.type = syntax_1.Syntax.ForStatement; + this.init = init; + this.test = test; + this.update = update; + this.body = body; + } + return ForStatement; + }()); + exports.ForStatement = ForStatement; + var FunctionDeclaration = (function () { + function FunctionDeclaration(id, params, body, generator) { + this.type = syntax_1.Syntax.FunctionDeclaration; + this.id = id; + this.params = params; + this.body = body; + this.generator = generator; + this.expression = false; + this.async = false; + } + return FunctionDeclaration; + }()); + exports.FunctionDeclaration = FunctionDeclaration; + var FunctionExpression = (function () { + function FunctionExpression(id, params, body, generator) { + this.type = syntax_1.Syntax.FunctionExpression; + this.id = id; + this.params = params; + this.body = body; + this.generator = generator; + this.expression = false; + this.async = false; + } + return FunctionExpression; + }()); + exports.FunctionExpression = FunctionExpression; + var Identifier = (function () { + function Identifier(name) { + this.type = syntax_1.Syntax.Identifier; + this.name = name; + } + return Identifier; + }()); + exports.Identifier = Identifier; + var IfStatement = (function () { + function IfStatement(test, consequent, alternate) { + this.type = syntax_1.Syntax.IfStatement; + this.test = test; + this.consequent = consequent; + this.alternate = alternate; + } + return IfStatement; + }()); + exports.IfStatement = IfStatement; + var ImportDeclaration = (function () { + function ImportDeclaration(specifiers, source) { + this.type = syntax_1.Syntax.ImportDeclaration; + this.specifiers = specifiers; + this.source = source; + } + return ImportDeclaration; + }()); + exports.ImportDeclaration = ImportDeclaration; + var ImportDefaultSpecifier = (function () { + function ImportDefaultSpecifier(local) { + this.type = syntax_1.Syntax.ImportDefaultSpecifier; + this.local = local; + } + return ImportDefaultSpecifier; + }()); + exports.ImportDefaultSpecifier = ImportDefaultSpecifier; + var ImportNamespaceSpecifier = (function () { + function ImportNamespaceSpecifier(local) { + this.type = syntax_1.Syntax.ImportNamespaceSpecifier; + this.local = local; + } + return ImportNamespaceSpecifier; + }()); + exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier; + var ImportSpecifier = (function () { + function ImportSpecifier(local, imported) { + this.type = syntax_1.Syntax.ImportSpecifier; + this.local = local; + this.imported = imported; + } + return ImportSpecifier; + }()); + exports.ImportSpecifier = ImportSpecifier; + var LabeledStatement = (function () { + function LabeledStatement(label, body) { + this.type = syntax_1.Syntax.LabeledStatement; + this.label = label; + this.body = body; + } + return LabeledStatement; + }()); + exports.LabeledStatement = LabeledStatement; + var Literal = (function () { + function Literal(value, raw) { + this.type = syntax_1.Syntax.Literal; + this.value = value; + this.raw = raw; + } + return Literal; + }()); + exports.Literal = Literal; + var MetaProperty = (function () { + function MetaProperty(meta, property) { + this.type = syntax_1.Syntax.MetaProperty; + this.meta = meta; + this.property = property; + } + return MetaProperty; + }()); + exports.MetaProperty = MetaProperty; + var MethodDefinition = (function () { + function MethodDefinition(key, computed, value, kind, isStatic) { + this.type = syntax_1.Syntax.MethodDefinition; + this.key = key; + this.computed = computed; + this.value = value; + this.kind = kind; + this.static = isStatic; + } + return MethodDefinition; + }()); + exports.MethodDefinition = MethodDefinition; + var Module = (function () { + function Module(body) { + this.type = syntax_1.Syntax.Program; + this.body = body; + this.sourceType = 'module'; + } + return Module; + }()); + exports.Module = Module; + var NewExpression = (function () { + function NewExpression(callee, args) { + this.type = syntax_1.Syntax.NewExpression; + this.callee = callee; + this.arguments = args; + } + return NewExpression; + }()); + exports.NewExpression = NewExpression; + var ObjectExpression = (function () { + function ObjectExpression(properties) { + this.type = syntax_1.Syntax.ObjectExpression; + this.properties = properties; + } + return ObjectExpression; + }()); + exports.ObjectExpression = ObjectExpression; + var ObjectPattern = (function () { + function ObjectPattern(properties) { + this.type = syntax_1.Syntax.ObjectPattern; + this.properties = properties; + } + return ObjectPattern; + }()); + exports.ObjectPattern = ObjectPattern; + var Property = (function () { + function Property(kind, key, computed, value, method, shorthand) { + this.type = syntax_1.Syntax.Property; + this.key = key; + this.computed = computed; + this.value = value; + this.kind = kind; + this.method = method; + this.shorthand = shorthand; + } + return Property; + }()); + exports.Property = Property; + var RegexLiteral = (function () { + function RegexLiteral(value, raw, pattern, flags) { + this.type = syntax_1.Syntax.Literal; + this.value = value; + this.raw = raw; + this.regex = { pattern: pattern, flags: flags }; + } + return RegexLiteral; + }()); + exports.RegexLiteral = RegexLiteral; + var RestElement = (function () { + function RestElement(argument) { + this.type = syntax_1.Syntax.RestElement; + this.argument = argument; + } + return RestElement; + }()); + exports.RestElement = RestElement; + var ReturnStatement = (function () { + function ReturnStatement(argument) { + this.type = syntax_1.Syntax.ReturnStatement; + this.argument = argument; + } + return ReturnStatement; + }()); + exports.ReturnStatement = ReturnStatement; + var Script = (function () { + function Script(body) { + this.type = syntax_1.Syntax.Program; + this.body = body; + this.sourceType = 'script'; + } + return Script; + }()); + exports.Script = Script; + var SequenceExpression = (function () { + function SequenceExpression(expressions) { + this.type = syntax_1.Syntax.SequenceExpression; + this.expressions = expressions; + } + return SequenceExpression; + }()); + exports.SequenceExpression = SequenceExpression; + var SpreadElement = (function () { + function SpreadElement(argument) { + this.type = syntax_1.Syntax.SpreadElement; + this.argument = argument; + } + return SpreadElement; + }()); + exports.SpreadElement = SpreadElement; + var StaticMemberExpression = (function () { + function StaticMemberExpression(object, property) { + this.type = syntax_1.Syntax.MemberExpression; + this.computed = false; + this.object = object; + this.property = property; + } + return StaticMemberExpression; + }()); + exports.StaticMemberExpression = StaticMemberExpression; + var Super = (function () { + function Super() { + this.type = syntax_1.Syntax.Super; + } + return Super; + }()); + exports.Super = Super; + var SwitchCase = (function () { + function SwitchCase(test, consequent) { + this.type = syntax_1.Syntax.SwitchCase; + this.test = test; + this.consequent = consequent; + } + return SwitchCase; + }()); + exports.SwitchCase = SwitchCase; + var SwitchStatement = (function () { + function SwitchStatement(discriminant, cases) { + this.type = syntax_1.Syntax.SwitchStatement; + this.discriminant = discriminant; + this.cases = cases; + } + return SwitchStatement; + }()); + exports.SwitchStatement = SwitchStatement; + var TaggedTemplateExpression = (function () { + function TaggedTemplateExpression(tag, quasi) { + this.type = syntax_1.Syntax.TaggedTemplateExpression; + this.tag = tag; + this.quasi = quasi; + } + return TaggedTemplateExpression; + }()); + exports.TaggedTemplateExpression = TaggedTemplateExpression; + var TemplateElement = (function () { + function TemplateElement(value, tail) { + this.type = syntax_1.Syntax.TemplateElement; + this.value = value; + this.tail = tail; + } + return TemplateElement; + }()); + exports.TemplateElement = TemplateElement; + var TemplateLiteral = (function () { + function TemplateLiteral(quasis, expressions) { + this.type = syntax_1.Syntax.TemplateLiteral; + this.quasis = quasis; + this.expressions = expressions; + } + return TemplateLiteral; + }()); + exports.TemplateLiteral = TemplateLiteral; + var ThisExpression = (function () { + function ThisExpression() { + this.type = syntax_1.Syntax.ThisExpression; + } + return ThisExpression; + }()); + exports.ThisExpression = ThisExpression; + var ThrowStatement = (function () { + function ThrowStatement(argument) { + this.type = syntax_1.Syntax.ThrowStatement; + this.argument = argument; + } + return ThrowStatement; + }()); + exports.ThrowStatement = ThrowStatement; + var TryStatement = (function () { + function TryStatement(block, handler, finalizer) { + this.type = syntax_1.Syntax.TryStatement; + this.block = block; + this.handler = handler; + this.finalizer = finalizer; + } + return TryStatement; + }()); + exports.TryStatement = TryStatement; + var UnaryExpression = (function () { + function UnaryExpression(operator, argument) { + this.type = syntax_1.Syntax.UnaryExpression; + this.operator = operator; + this.argument = argument; + this.prefix = true; + } + return UnaryExpression; + }()); + exports.UnaryExpression = UnaryExpression; + var UpdateExpression = (function () { + function UpdateExpression(operator, argument, prefix) { + this.type = syntax_1.Syntax.UpdateExpression; + this.operator = operator; + this.argument = argument; + this.prefix = prefix; + } + return UpdateExpression; + }()); + exports.UpdateExpression = UpdateExpression; + var VariableDeclaration = (function () { + function VariableDeclaration(declarations, kind) { + this.type = syntax_1.Syntax.VariableDeclaration; + this.declarations = declarations; + this.kind = kind; + } + return VariableDeclaration; + }()); + exports.VariableDeclaration = VariableDeclaration; + var VariableDeclarator = (function () { + function VariableDeclarator(id, init) { + this.type = syntax_1.Syntax.VariableDeclarator; + this.id = id; + this.init = init; + } + return VariableDeclarator; + }()); + exports.VariableDeclarator = VariableDeclarator; + var WhileStatement = (function () { + function WhileStatement(test, body) { + this.type = syntax_1.Syntax.WhileStatement; + this.test = test; + this.body = body; + } + return WhileStatement; + }()); + exports.WhileStatement = WhileStatement; + var WithStatement = (function () { + function WithStatement(object, body) { + this.type = syntax_1.Syntax.WithStatement; + this.object = object; + this.body = body; + } + return WithStatement; + }()); + exports.WithStatement = WithStatement; + var YieldExpression = (function () { + function YieldExpression(argument, delegate) { + this.type = syntax_1.Syntax.YieldExpression; + this.argument = argument; + this.delegate = delegate; + } + return YieldExpression; + }()); + exports.YieldExpression = YieldExpression; + + +/***/ }, +/* 8 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var assert_1 = __webpack_require__(9); + var error_handler_1 = __webpack_require__(10); + var messages_1 = __webpack_require__(11); + var Node = __webpack_require__(7); + var scanner_1 = __webpack_require__(12); + var syntax_1 = __webpack_require__(2); + var token_1 = __webpack_require__(13); + var ArrowParameterPlaceHolder = 'ArrowParameterPlaceHolder'; + var Parser = (function () { + function Parser(code, options, delegate) { + if (options === void 0) { options = {}; } + this.config = { + range: (typeof options.range === 'boolean') && options.range, + loc: (typeof options.loc === 'boolean') && options.loc, + source: null, + tokens: (typeof options.tokens === 'boolean') && options.tokens, + comment: (typeof options.comment === 'boolean') && options.comment, + tolerant: (typeof options.tolerant === 'boolean') && options.tolerant + }; + if (this.config.loc && options.source && options.source !== null) { + this.config.source = String(options.source); + } + this.delegate = delegate; + this.errorHandler = new error_handler_1.ErrorHandler(); + this.errorHandler.tolerant = this.config.tolerant; + this.scanner = new scanner_1.Scanner(code, this.errorHandler); + this.scanner.trackComment = this.config.comment; + this.operatorPrecedence = { + ')': 0, + ';': 0, + ',': 0, + '=': 0, + ']': 0, + '||': 1, + '&&': 2, + '|': 3, + '^': 4, + '&': 5, + '==': 6, + '!=': 6, + '===': 6, + '!==': 6, + '<': 7, + '>': 7, + '<=': 7, + '>=': 7, + '<<': 8, + '>>': 8, + '>>>': 8, + '+': 9, + '-': 9, + '*': 11, + '/': 11, + '%': 11 + }; + this.lookahead = { + type: 2 /* EOF */, + value: '', + lineNumber: this.scanner.lineNumber, + lineStart: 0, + start: 0, + end: 0 + }; + this.hasLineTerminator = false; + this.context = { + isModule: false, + await: false, + allowIn: true, + allowStrictDirective: true, + allowYield: true, + firstCoverInitializedNameError: null, + isAssignmentTarget: false, + isBindingElement: false, + inFunctionBody: false, + inIteration: false, + inSwitch: false, + labelSet: {}, + strict: false + }; + this.tokens = []; + this.startMarker = { + index: 0, + line: this.scanner.lineNumber, + column: 0 + }; + this.lastMarker = { + index: 0, + line: this.scanner.lineNumber, + column: 0 + }; + this.nextToken(); + this.lastMarker = { + index: this.scanner.index, + line: this.scanner.lineNumber, + column: this.scanner.index - this.scanner.lineStart + }; + } + Parser.prototype.throwError = function (messageFormat) { + var values = []; + for (var _i = 1; _i < arguments.length; _i++) { + values[_i - 1] = arguments[_i]; + } + var args = Array.prototype.slice.call(arguments, 1); + var msg = messageFormat.replace(/%(\d)/g, function (whole, idx) { + assert_1.assert(idx < args.length, 'Message reference must be in range'); + return args[idx]; + }); + var index = this.lastMarker.index; + var line = this.lastMarker.line; + var column = this.lastMarker.column + 1; + throw this.errorHandler.createError(index, line, column, msg); + }; + Parser.prototype.tolerateError = function (messageFormat) { + var values = []; + for (var _i = 1; _i < arguments.length; _i++) { + values[_i - 1] = arguments[_i]; + } + var args = Array.prototype.slice.call(arguments, 1); + var msg = messageFormat.replace(/%(\d)/g, function (whole, idx) { + assert_1.assert(idx < args.length, 'Message reference must be in range'); + return args[idx]; + }); + var index = this.lastMarker.index; + var line = this.scanner.lineNumber; + var column = this.lastMarker.column + 1; + this.errorHandler.tolerateError(index, line, column, msg); + }; + // Throw an exception because of the token. + Parser.prototype.unexpectedTokenError = function (token, message) { + var msg = message || messages_1.Messages.UnexpectedToken; + var value; + if (token) { + if (!message) { + msg = (token.type === 2 /* EOF */) ? messages_1.Messages.UnexpectedEOS : + (token.type === 3 /* Identifier */) ? messages_1.Messages.UnexpectedIdentifier : + (token.type === 6 /* NumericLiteral */) ? messages_1.Messages.UnexpectedNumber : + (token.type === 8 /* StringLiteral */) ? messages_1.Messages.UnexpectedString : + (token.type === 10 /* Template */) ? messages_1.Messages.UnexpectedTemplate : + messages_1.Messages.UnexpectedToken; + if (token.type === 4 /* Keyword */) { + if (this.scanner.isFutureReservedWord(token.value)) { + msg = messages_1.Messages.UnexpectedReserved; + } + else if (this.context.strict && this.scanner.isStrictModeReservedWord(token.value)) { + msg = messages_1.Messages.StrictReservedWord; + } + } + } + value = token.value; + } + else { + value = 'ILLEGAL'; + } + msg = msg.replace('%0', value); + if (token && typeof token.lineNumber === 'number') { + var index = token.start; + var line = token.lineNumber; + var lastMarkerLineStart = this.lastMarker.index - this.lastMarker.column; + var column = token.start - lastMarkerLineStart + 1; + return this.errorHandler.createError(index, line, column, msg); + } + else { + var index = this.lastMarker.index; + var line = this.lastMarker.line; + var column = this.lastMarker.column + 1; + return this.errorHandler.createError(index, line, column, msg); + } + }; + Parser.prototype.throwUnexpectedToken = function (token, message) { + throw this.unexpectedTokenError(token, message); + }; + Parser.prototype.tolerateUnexpectedToken = function (token, message) { + this.errorHandler.tolerate(this.unexpectedTokenError(token, message)); + }; + Parser.prototype.collectComments = function () { + if (!this.config.comment) { + this.scanner.scanComments(); + } + else { + var comments = this.scanner.scanComments(); + if (comments.length > 0 && this.delegate) { + for (var i = 0; i < comments.length; ++i) { + var e = comments[i]; + var node = void 0; + node = { + type: e.multiLine ? 'BlockComment' : 'LineComment', + value: this.scanner.source.slice(e.slice[0], e.slice[1]) + }; + if (this.config.range) { + node.range = e.range; + } + if (this.config.loc) { + node.loc = e.loc; + } + var metadata = { + start: { + line: e.loc.start.line, + column: e.loc.start.column, + offset: e.range[0] + }, + end: { + line: e.loc.end.line, + column: e.loc.end.column, + offset: e.range[1] + } + }; + this.delegate(node, metadata); + } + } + } + }; + // From internal representation to an external structure + Parser.prototype.getTokenRaw = function (token) { + return this.scanner.source.slice(token.start, token.end); + }; + Parser.prototype.convertToken = function (token) { + var t = { + type: token_1.TokenName[token.type], + value: this.getTokenRaw(token) + }; + if (this.config.range) { + t.range = [token.start, token.end]; + } + if (this.config.loc) { + t.loc = { + start: { + line: this.startMarker.line, + column: this.startMarker.column + }, + end: { + line: this.scanner.lineNumber, + column: this.scanner.index - this.scanner.lineStart + } + }; + } + if (token.type === 9 /* RegularExpression */) { + var pattern = token.pattern; + var flags = token.flags; + t.regex = { pattern: pattern, flags: flags }; + } + return t; + }; + Parser.prototype.nextToken = function () { + var token = this.lookahead; + this.lastMarker.index = this.scanner.index; + this.lastMarker.line = this.scanner.lineNumber; + this.lastMarker.column = this.scanner.index - this.scanner.lineStart; + this.collectComments(); + if (this.scanner.index !== this.startMarker.index) { + this.startMarker.index = this.scanner.index; + this.startMarker.line = this.scanner.lineNumber; + this.startMarker.column = this.scanner.index - this.scanner.lineStart; + } + var next = this.scanner.lex(); + this.hasLineTerminator = (token.lineNumber !== next.lineNumber); + if (next && this.context.strict && next.type === 3 /* Identifier */) { + if (this.scanner.isStrictModeReservedWord(next.value)) { + next.type = 4 /* Keyword */; + } + } + this.lookahead = next; + if (this.config.tokens && next.type !== 2 /* EOF */) { + this.tokens.push(this.convertToken(next)); + } + return token; + }; + Parser.prototype.nextRegexToken = function () { + this.collectComments(); + var token = this.scanner.scanRegExp(); + if (this.config.tokens) { + // Pop the previous token, '/' or '/=' + // This is added from the lookahead token. + this.tokens.pop(); + this.tokens.push(this.convertToken(token)); + } + // Prime the next lookahead. + this.lookahead = token; + this.nextToken(); + return token; + }; + Parser.prototype.createNode = function () { + return { + index: this.startMarker.index, + line: this.startMarker.line, + column: this.startMarker.column + }; + }; + Parser.prototype.startNode = function (token, lastLineStart) { + if (lastLineStart === void 0) { lastLineStart = 0; } + var column = token.start - token.lineStart; + var line = token.lineNumber; + if (column < 0) { + column += lastLineStart; + line--; + } + return { + index: token.start, + line: line, + column: column + }; + }; + Parser.prototype.finalize = function (marker, node) { + if (this.config.range) { + node.range = [marker.index, this.lastMarker.index]; + } + if (this.config.loc) { + node.loc = { + start: { + line: marker.line, + column: marker.column, + }, + end: { + line: this.lastMarker.line, + column: this.lastMarker.column + } + }; + if (this.config.source) { + node.loc.source = this.config.source; + } + } + if (this.delegate) { + var metadata = { + start: { + line: marker.line, + column: marker.column, + offset: marker.index + }, + end: { + line: this.lastMarker.line, + column: this.lastMarker.column, + offset: this.lastMarker.index + } + }; + this.delegate(node, metadata); + } + return node; + }; + // Expect the next token to match the specified punctuator. + // If not, an exception will be thrown. + Parser.prototype.expect = function (value) { + var token = this.nextToken(); + if (token.type !== 7 /* Punctuator */ || token.value !== value) { + this.throwUnexpectedToken(token); + } + }; + // Quietly expect a comma when in tolerant mode, otherwise delegates to expect(). + Parser.prototype.expectCommaSeparator = function () { + if (this.config.tolerant) { + var token = this.lookahead; + if (token.type === 7 /* Punctuator */ && token.value === ',') { + this.nextToken(); + } + else if (token.type === 7 /* Punctuator */ && token.value === ';') { + this.nextToken(); + this.tolerateUnexpectedToken(token); + } + else { + this.tolerateUnexpectedToken(token, messages_1.Messages.UnexpectedToken); + } + } + else { + this.expect(','); + } + }; + // Expect the next token to match the specified keyword. + // If not, an exception will be thrown. + Parser.prototype.expectKeyword = function (keyword) { + var token = this.nextToken(); + if (token.type !== 4 /* Keyword */ || token.value !== keyword) { + this.throwUnexpectedToken(token); + } + }; + // Return true if the next token matches the specified punctuator. + Parser.prototype.match = function (value) { + return this.lookahead.type === 7 /* Punctuator */ && this.lookahead.value === value; + }; + // Return true if the next token matches the specified keyword + Parser.prototype.matchKeyword = function (keyword) { + return this.lookahead.type === 4 /* Keyword */ && this.lookahead.value === keyword; + }; + // Return true if the next token matches the specified contextual keyword + // (where an identifier is sometimes a keyword depending on the context) + Parser.prototype.matchContextualKeyword = function (keyword) { + return this.lookahead.type === 3 /* Identifier */ && this.lookahead.value === keyword; + }; + // Return true if the next token is an assignment operator + Parser.prototype.matchAssign = function () { + if (this.lookahead.type !== 7 /* Punctuator */) { + return false; + } + var op = this.lookahead.value; + return op === '=' || + op === '*=' || + op === '**=' || + op === '/=' || + op === '%=' || + op === '+=' || + op === '-=' || + op === '<<=' || + op === '>>=' || + op === '>>>=' || + op === '&=' || + op === '^=' || + op === '|='; + }; + // Cover grammar support. + // + // When an assignment expression position starts with an left parenthesis, the determination of the type + // of the syntax is to be deferred arbitrarily long until the end of the parentheses pair (plus a lookahead) + // or the first comma. This situation also defers the determination of all the expressions nested in the pair. + // + // There are three productions that can be parsed in a parentheses pair that needs to be determined + // after the outermost pair is closed. They are: + // + // 1. AssignmentExpression + // 2. BindingElements + // 3. AssignmentTargets + // + // In order to avoid exponential backtracking, we use two flags to denote if the production can be + // binding element or assignment target. + // + // The three productions have the relationship: + // + // BindingElements ⊆ AssignmentTargets ⊆ AssignmentExpression + // + // with a single exception that CoverInitializedName when used directly in an Expression, generates + // an early error. Therefore, we need the third state, firstCoverInitializedNameError, to track the + // first usage of CoverInitializedName and report it when we reached the end of the parentheses pair. + // + // isolateCoverGrammar function runs the given parser function with a new cover grammar context, and it does not + // effect the current flags. This means the production the parser parses is only used as an expression. Therefore + // the CoverInitializedName check is conducted. + // + // inheritCoverGrammar function runs the given parse function with a new cover grammar context, and it propagates + // the flags outside of the parser. This means the production the parser parses is used as a part of a potential + // pattern. The CoverInitializedName check is deferred. + Parser.prototype.isolateCoverGrammar = function (parseFunction) { + var previousIsBindingElement = this.context.isBindingElement; + var previousIsAssignmentTarget = this.context.isAssignmentTarget; + var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError; + this.context.isBindingElement = true; + this.context.isAssignmentTarget = true; + this.context.firstCoverInitializedNameError = null; + var result = parseFunction.call(this); + if (this.context.firstCoverInitializedNameError !== null) { + this.throwUnexpectedToken(this.context.firstCoverInitializedNameError); + } + this.context.isBindingElement = previousIsBindingElement; + this.context.isAssignmentTarget = previousIsAssignmentTarget; + this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError; + return result; + }; + Parser.prototype.inheritCoverGrammar = function (parseFunction) { + var previousIsBindingElement = this.context.isBindingElement; + var previousIsAssignmentTarget = this.context.isAssignmentTarget; + var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError; + this.context.isBindingElement = true; + this.context.isAssignmentTarget = true; + this.context.firstCoverInitializedNameError = null; + var result = parseFunction.call(this); + this.context.isBindingElement = this.context.isBindingElement && previousIsBindingElement; + this.context.isAssignmentTarget = this.context.isAssignmentTarget && previousIsAssignmentTarget; + this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError || this.context.firstCoverInitializedNameError; + return result; + }; + Parser.prototype.consumeSemicolon = function () { + if (this.match(';')) { + this.nextToken(); + } + else if (!this.hasLineTerminator) { + if (this.lookahead.type !== 2 /* EOF */ && !this.match('}')) { + this.throwUnexpectedToken(this.lookahead); + } + this.lastMarker.index = this.startMarker.index; + this.lastMarker.line = this.startMarker.line; + this.lastMarker.column = this.startMarker.column; + } + }; + // https://tc39.github.io/ecma262/#sec-primary-expression + Parser.prototype.parsePrimaryExpression = function () { + var node = this.createNode(); + var expr; + var token, raw; + switch (this.lookahead.type) { + case 3 /* Identifier */: + if ((this.context.isModule || this.context.await) && this.lookahead.value === 'await') { + this.tolerateUnexpectedToken(this.lookahead); + } + expr = this.matchAsyncFunction() ? this.parseFunctionExpression() : this.finalize(node, new Node.Identifier(this.nextToken().value)); + break; + case 6 /* NumericLiteral */: + case 8 /* StringLiteral */: + if (this.context.strict && this.lookahead.octal) { + this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.StrictOctalLiteral); + } + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + token = this.nextToken(); + raw = this.getTokenRaw(token); + expr = this.finalize(node, new Node.Literal(token.value, raw)); + break; + case 1 /* BooleanLiteral */: + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + token = this.nextToken(); + raw = this.getTokenRaw(token); + expr = this.finalize(node, new Node.Literal(token.value === 'true', raw)); + break; + case 5 /* NullLiteral */: + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + token = this.nextToken(); + raw = this.getTokenRaw(token); + expr = this.finalize(node, new Node.Literal(null, raw)); + break; + case 10 /* Template */: + expr = this.parseTemplateLiteral(); + break; + case 7 /* Punctuator */: + switch (this.lookahead.value) { + case '(': + this.context.isBindingElement = false; + expr = this.inheritCoverGrammar(this.parseGroupExpression); + break; + case '[': + expr = this.inheritCoverGrammar(this.parseArrayInitializer); + break; + case '{': + expr = this.inheritCoverGrammar(this.parseObjectInitializer); + break; + case '/': + case '/=': + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + this.scanner.index = this.startMarker.index; + token = this.nextRegexToken(); + raw = this.getTokenRaw(token); + expr = this.finalize(node, new Node.RegexLiteral(token.regex, raw, token.pattern, token.flags)); + break; + default: + expr = this.throwUnexpectedToken(this.nextToken()); + } + break; + case 4 /* Keyword */: + if (!this.context.strict && this.context.allowYield && this.matchKeyword('yield')) { + expr = this.parseIdentifierName(); + } + else if (!this.context.strict && this.matchKeyword('let')) { + expr = this.finalize(node, new Node.Identifier(this.nextToken().value)); + } + else { + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + if (this.matchKeyword('function')) { + expr = this.parseFunctionExpression(); + } + else if (this.matchKeyword('this')) { + this.nextToken(); + expr = this.finalize(node, new Node.ThisExpression()); + } + else if (this.matchKeyword('class')) { + expr = this.parseClassExpression(); + } + else { + expr = this.throwUnexpectedToken(this.nextToken()); + } + } + break; + default: + expr = this.throwUnexpectedToken(this.nextToken()); + } + return expr; + }; + // https://tc39.github.io/ecma262/#sec-array-initializer + Parser.prototype.parseSpreadElement = function () { + var node = this.createNode(); + this.expect('...'); + var arg = this.inheritCoverGrammar(this.parseAssignmentExpression); + return this.finalize(node, new Node.SpreadElement(arg)); + }; + Parser.prototype.parseArrayInitializer = function () { + var node = this.createNode(); + var elements = []; + this.expect('['); + while (!this.match(']')) { + if (this.match(',')) { + this.nextToken(); + elements.push(null); + } + else if (this.match('...')) { + var element = this.parseSpreadElement(); + if (!this.match(']')) { + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + this.expect(','); + } + elements.push(element); + } + else { + elements.push(this.inheritCoverGrammar(this.parseAssignmentExpression)); + if (!this.match(']')) { + this.expect(','); + } + } + } + this.expect(']'); + return this.finalize(node, new Node.ArrayExpression(elements)); + }; + // https://tc39.github.io/ecma262/#sec-object-initializer + Parser.prototype.parsePropertyMethod = function (params) { + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + var previousStrict = this.context.strict; + var previousAllowStrictDirective = this.context.allowStrictDirective; + this.context.allowStrictDirective = params.simple; + var body = this.isolateCoverGrammar(this.parseFunctionSourceElements); + if (this.context.strict && params.firstRestricted) { + this.tolerateUnexpectedToken(params.firstRestricted, params.message); + } + if (this.context.strict && params.stricted) { + this.tolerateUnexpectedToken(params.stricted, params.message); + } + this.context.strict = previousStrict; + this.context.allowStrictDirective = previousAllowStrictDirective; + return body; + }; + Parser.prototype.parsePropertyMethodFunction = function () { + var isGenerator = false; + var node = this.createNode(); + var previousAllowYield = this.context.allowYield; + this.context.allowYield = true; + var params = this.parseFormalParameters(); + var method = this.parsePropertyMethod(params); + this.context.allowYield = previousAllowYield; + return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator)); + }; + Parser.prototype.parsePropertyMethodAsyncFunction = function () { + var node = this.createNode(); + var previousAllowYield = this.context.allowYield; + var previousAwait = this.context.await; + this.context.allowYield = false; + this.context.await = true; + var params = this.parseFormalParameters(); + var method = this.parsePropertyMethod(params); + this.context.allowYield = previousAllowYield; + this.context.await = previousAwait; + return this.finalize(node, new Node.AsyncFunctionExpression(null, params.params, method)); + }; + Parser.prototype.parseObjectPropertyKey = function () { + var node = this.createNode(); + var token = this.nextToken(); + var key; + switch (token.type) { + case 8 /* StringLiteral */: + case 6 /* NumericLiteral */: + if (this.context.strict && token.octal) { + this.tolerateUnexpectedToken(token, messages_1.Messages.StrictOctalLiteral); + } + var raw = this.getTokenRaw(token); + key = this.finalize(node, new Node.Literal(token.value, raw)); + break; + case 3 /* Identifier */: + case 1 /* BooleanLiteral */: + case 5 /* NullLiteral */: + case 4 /* Keyword */: + key = this.finalize(node, new Node.Identifier(token.value)); + break; + case 7 /* Punctuator */: + if (token.value === '[') { + key = this.isolateCoverGrammar(this.parseAssignmentExpression); + this.expect(']'); + } + else { + key = this.throwUnexpectedToken(token); + } + break; + default: + key = this.throwUnexpectedToken(token); + } + return key; + }; + Parser.prototype.isPropertyKey = function (key, value) { + return (key.type === syntax_1.Syntax.Identifier && key.name === value) || + (key.type === syntax_1.Syntax.Literal && key.value === value); + }; + Parser.prototype.parseObjectProperty = function (hasProto) { + var node = this.createNode(); + var token = this.lookahead; + var kind; + var key = null; + var value = null; + var computed = false; + var method = false; + var shorthand = false; + var isAsync = false; + if (token.type === 3 /* Identifier */) { + var id = token.value; + this.nextToken(); + computed = this.match('['); + isAsync = !this.hasLineTerminator && (id === 'async') && + !this.match(':') && !this.match('(') && !this.match('*') && !this.match(','); + key = isAsync ? this.parseObjectPropertyKey() : this.finalize(node, new Node.Identifier(id)); + } + else if (this.match('*')) { + this.nextToken(); + } + else { + computed = this.match('['); + key = this.parseObjectPropertyKey(); + } + var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead); + if (token.type === 3 /* Identifier */ && !isAsync && token.value === 'get' && lookaheadPropertyKey) { + kind = 'get'; + computed = this.match('['); + key = this.parseObjectPropertyKey(); + this.context.allowYield = false; + value = this.parseGetterMethod(); + } + else if (token.type === 3 /* Identifier */ && !isAsync && token.value === 'set' && lookaheadPropertyKey) { + kind = 'set'; + computed = this.match('['); + key = this.parseObjectPropertyKey(); + value = this.parseSetterMethod(); + } + else if (token.type === 7 /* Punctuator */ && token.value === '*' && lookaheadPropertyKey) { + kind = 'init'; + computed = this.match('['); + key = this.parseObjectPropertyKey(); + value = this.parseGeneratorMethod(); + method = true; + } + else { + if (!key) { + this.throwUnexpectedToken(this.lookahead); + } + kind = 'init'; + if (this.match(':') && !isAsync) { + if (!computed && this.isPropertyKey(key, '__proto__')) { + if (hasProto.value) { + this.tolerateError(messages_1.Messages.DuplicateProtoProperty); + } + hasProto.value = true; + } + this.nextToken(); + value = this.inheritCoverGrammar(this.parseAssignmentExpression); + } + else if (this.match('(')) { + value = isAsync ? this.parsePropertyMethodAsyncFunction() : this.parsePropertyMethodFunction(); + method = true; + } + else if (token.type === 3 /* Identifier */) { + var id = this.finalize(node, new Node.Identifier(token.value)); + if (this.match('=')) { + this.context.firstCoverInitializedNameError = this.lookahead; + this.nextToken(); + shorthand = true; + var init = this.isolateCoverGrammar(this.parseAssignmentExpression); + value = this.finalize(node, new Node.AssignmentPattern(id, init)); + } + else { + shorthand = true; + value = id; + } + } + else { + this.throwUnexpectedToken(this.nextToken()); + } + } + return this.finalize(node, new Node.Property(kind, key, computed, value, method, shorthand)); + }; + Parser.prototype.parseObjectInitializer = function () { + var node = this.createNode(); + this.expect('{'); + var properties = []; + var hasProto = { value: false }; + while (!this.match('}')) { + properties.push(this.parseObjectProperty(hasProto)); + if (!this.match('}')) { + this.expectCommaSeparator(); + } + } + this.expect('}'); + return this.finalize(node, new Node.ObjectExpression(properties)); + }; + // https://tc39.github.io/ecma262/#sec-template-literals + Parser.prototype.parseTemplateHead = function () { + assert_1.assert(this.lookahead.head, 'Template literal must start with a template head'); + var node = this.createNode(); + var token = this.nextToken(); + var raw = token.value; + var cooked = token.cooked; + return this.finalize(node, new Node.TemplateElement({ raw: raw, cooked: cooked }, token.tail)); + }; + Parser.prototype.parseTemplateElement = function () { + if (this.lookahead.type !== 10 /* Template */) { + this.throwUnexpectedToken(); + } + var node = this.createNode(); + var token = this.nextToken(); + var raw = token.value; + var cooked = token.cooked; + return this.finalize(node, new Node.TemplateElement({ raw: raw, cooked: cooked }, token.tail)); + }; + Parser.prototype.parseTemplateLiteral = function () { + var node = this.createNode(); + var expressions = []; + var quasis = []; + var quasi = this.parseTemplateHead(); + quasis.push(quasi); + while (!quasi.tail) { + expressions.push(this.parseExpression()); + quasi = this.parseTemplateElement(); + quasis.push(quasi); + } + return this.finalize(node, new Node.TemplateLiteral(quasis, expressions)); + }; + // https://tc39.github.io/ecma262/#sec-grouping-operator + Parser.prototype.reinterpretExpressionAsPattern = function (expr) { + switch (expr.type) { + case syntax_1.Syntax.Identifier: + case syntax_1.Syntax.MemberExpression: + case syntax_1.Syntax.RestElement: + case syntax_1.Syntax.AssignmentPattern: + break; + case syntax_1.Syntax.SpreadElement: + expr.type = syntax_1.Syntax.RestElement; + this.reinterpretExpressionAsPattern(expr.argument); + break; + case syntax_1.Syntax.ArrayExpression: + expr.type = syntax_1.Syntax.ArrayPattern; + for (var i = 0; i < expr.elements.length; i++) { + if (expr.elements[i] !== null) { + this.reinterpretExpressionAsPattern(expr.elements[i]); + } + } + break; + case syntax_1.Syntax.ObjectExpression: + expr.type = syntax_1.Syntax.ObjectPattern; + for (var i = 0; i < expr.properties.length; i++) { + this.reinterpretExpressionAsPattern(expr.properties[i].value); + } + break; + case syntax_1.Syntax.AssignmentExpression: + expr.type = syntax_1.Syntax.AssignmentPattern; + delete expr.operator; + this.reinterpretExpressionAsPattern(expr.left); + break; + default: + // Allow other node type for tolerant parsing. + break; + } + }; + Parser.prototype.parseGroupExpression = function () { + var expr; + this.expect('('); + if (this.match(')')) { + this.nextToken(); + if (!this.match('=>')) { + this.expect('=>'); + } + expr = { + type: ArrowParameterPlaceHolder, + params: [], + async: false + }; + } + else { + var startToken = this.lookahead; + var params = []; + if (this.match('...')) { + expr = this.parseRestElement(params); + this.expect(')'); + if (!this.match('=>')) { + this.expect('=>'); + } + expr = { + type: ArrowParameterPlaceHolder, + params: [expr], + async: false + }; + } + else { + var arrow = false; + this.context.isBindingElement = true; + expr = this.inheritCoverGrammar(this.parseAssignmentExpression); + if (this.match(',')) { + var expressions = []; + this.context.isAssignmentTarget = false; + expressions.push(expr); + while (this.lookahead.type !== 2 /* EOF */) { + if (!this.match(',')) { + break; + } + this.nextToken(); + if (this.match(')')) { + this.nextToken(); + for (var i = 0; i < expressions.length; i++) { + this.reinterpretExpressionAsPattern(expressions[i]); + } + arrow = true; + expr = { + type: ArrowParameterPlaceHolder, + params: expressions, + async: false + }; + } + else if (this.match('...')) { + if (!this.context.isBindingElement) { + this.throwUnexpectedToken(this.lookahead); + } + expressions.push(this.parseRestElement(params)); + this.expect(')'); + if (!this.match('=>')) { + this.expect('=>'); + } + this.context.isBindingElement = false; + for (var i = 0; i < expressions.length; i++) { + this.reinterpretExpressionAsPattern(expressions[i]); + } + arrow = true; + expr = { + type: ArrowParameterPlaceHolder, + params: expressions, + async: false + }; + } + else { + expressions.push(this.inheritCoverGrammar(this.parseAssignmentExpression)); + } + if (arrow) { + break; + } + } + if (!arrow) { + expr = this.finalize(this.startNode(startToken), new Node.SequenceExpression(expressions)); + } + } + if (!arrow) { + this.expect(')'); + if (this.match('=>')) { + if (expr.type === syntax_1.Syntax.Identifier && expr.name === 'yield') { + arrow = true; + expr = { + type: ArrowParameterPlaceHolder, + params: [expr], + async: false + }; + } + if (!arrow) { + if (!this.context.isBindingElement) { + this.throwUnexpectedToken(this.lookahead); + } + if (expr.type === syntax_1.Syntax.SequenceExpression) { + for (var i = 0; i < expr.expressions.length; i++) { + this.reinterpretExpressionAsPattern(expr.expressions[i]); + } + } + else { + this.reinterpretExpressionAsPattern(expr); + } + var parameters = (expr.type === syntax_1.Syntax.SequenceExpression ? expr.expressions : [expr]); + expr = { + type: ArrowParameterPlaceHolder, + params: parameters, + async: false + }; + } + } + this.context.isBindingElement = false; + } + } + } + return expr; + }; + // https://tc39.github.io/ecma262/#sec-left-hand-side-expressions + Parser.prototype.parseArguments = function () { + this.expect('('); + var args = []; + if (!this.match(')')) { + while (true) { + var expr = this.match('...') ? this.parseSpreadElement() : + this.isolateCoverGrammar(this.parseAssignmentExpression); + args.push(expr); + if (this.match(')')) { + break; + } + this.expectCommaSeparator(); + if (this.match(')')) { + break; + } + } + } + this.expect(')'); + return args; + }; + Parser.prototype.isIdentifierName = function (token) { + return token.type === 3 /* Identifier */ || + token.type === 4 /* Keyword */ || + token.type === 1 /* BooleanLiteral */ || + token.type === 5 /* NullLiteral */; + }; + Parser.prototype.parseIdentifierName = function () { + var node = this.createNode(); + var token = this.nextToken(); + if (!this.isIdentifierName(token)) { + this.throwUnexpectedToken(token); + } + return this.finalize(node, new Node.Identifier(token.value)); + }; + Parser.prototype.parseNewExpression = function () { + var node = this.createNode(); + var id = this.parseIdentifierName(); + assert_1.assert(id.name === 'new', 'New expression must start with `new`'); + var expr; + if (this.match('.')) { + this.nextToken(); + if (this.lookahead.type === 3 /* Identifier */ && this.context.inFunctionBody && this.lookahead.value === 'target') { + var property = this.parseIdentifierName(); + expr = new Node.MetaProperty(id, property); + } + else { + this.throwUnexpectedToken(this.lookahead); + } + } + else { + var callee = this.isolateCoverGrammar(this.parseLeftHandSideExpression); + var args = this.match('(') ? this.parseArguments() : []; + expr = new Node.NewExpression(callee, args); + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + } + return this.finalize(node, expr); + }; + Parser.prototype.parseAsyncArgument = function () { + var arg = this.parseAssignmentExpression(); + this.context.firstCoverInitializedNameError = null; + return arg; + }; + Parser.prototype.parseAsyncArguments = function () { + this.expect('('); + var args = []; + if (!this.match(')')) { + while (true) { + var expr = this.match('...') ? this.parseSpreadElement() : + this.isolateCoverGrammar(this.parseAsyncArgument); + args.push(expr); + if (this.match(')')) { + break; + } + this.expectCommaSeparator(); + if (this.match(')')) { + break; + } + } + } + this.expect(')'); + return args; + }; + Parser.prototype.parseLeftHandSideExpressionAllowCall = function () { + var startToken = this.lookahead; + var maybeAsync = this.matchContextualKeyword('async'); + var previousAllowIn = this.context.allowIn; + this.context.allowIn = true; + var expr; + if (this.matchKeyword('super') && this.context.inFunctionBody) { + expr = this.createNode(); + this.nextToken(); + expr = this.finalize(expr, new Node.Super()); + if (!this.match('(') && !this.match('.') && !this.match('[')) { + this.throwUnexpectedToken(this.lookahead); + } + } + else { + expr = this.inheritCoverGrammar(this.matchKeyword('new') ? this.parseNewExpression : this.parsePrimaryExpression); + } + while (true) { + if (this.match('.')) { + this.context.isBindingElement = false; + this.context.isAssignmentTarget = true; + this.expect('.'); + var property = this.parseIdentifierName(); + expr = this.finalize(this.startNode(startToken), new Node.StaticMemberExpression(expr, property)); + } + else if (this.match('(')) { + var asyncArrow = maybeAsync && (startToken.lineNumber === this.lookahead.lineNumber); + this.context.isBindingElement = false; + this.context.isAssignmentTarget = false; + var args = asyncArrow ? this.parseAsyncArguments() : this.parseArguments(); + expr = this.finalize(this.startNode(startToken), new Node.CallExpression(expr, args)); + if (asyncArrow && this.match('=>')) { + for (var i = 0; i < args.length; ++i) { + this.reinterpretExpressionAsPattern(args[i]); + } + expr = { + type: ArrowParameterPlaceHolder, + params: args, + async: true + }; + } + } + else if (this.match('[')) { + this.context.isBindingElement = false; + this.context.isAssignmentTarget = true; + this.expect('['); + var property = this.isolateCoverGrammar(this.parseExpression); + this.expect(']'); + expr = this.finalize(this.startNode(startToken), new Node.ComputedMemberExpression(expr, property)); + } + else if (this.lookahead.type === 10 /* Template */ && this.lookahead.head) { + var quasi = this.parseTemplateLiteral(); + expr = this.finalize(this.startNode(startToken), new Node.TaggedTemplateExpression(expr, quasi)); + } + else { + break; + } + } + this.context.allowIn = previousAllowIn; + return expr; + }; + Parser.prototype.parseSuper = function () { + var node = this.createNode(); + this.expectKeyword('super'); + if (!this.match('[') && !this.match('.')) { + this.throwUnexpectedToken(this.lookahead); + } + return this.finalize(node, new Node.Super()); + }; + Parser.prototype.parseLeftHandSideExpression = function () { + assert_1.assert(this.context.allowIn, 'callee of new expression always allow in keyword.'); + var node = this.startNode(this.lookahead); + var expr = (this.matchKeyword('super') && this.context.inFunctionBody) ? this.parseSuper() : + this.inheritCoverGrammar(this.matchKeyword('new') ? this.parseNewExpression : this.parsePrimaryExpression); + while (true) { + if (this.match('[')) { + this.context.isBindingElement = false; + this.context.isAssignmentTarget = true; + this.expect('['); + var property = this.isolateCoverGrammar(this.parseExpression); + this.expect(']'); + expr = this.finalize(node, new Node.ComputedMemberExpression(expr, property)); + } + else if (this.match('.')) { + this.context.isBindingElement = false; + this.context.isAssignmentTarget = true; + this.expect('.'); + var property = this.parseIdentifierName(); + expr = this.finalize(node, new Node.StaticMemberExpression(expr, property)); + } + else if (this.lookahead.type === 10 /* Template */ && this.lookahead.head) { + var quasi = this.parseTemplateLiteral(); + expr = this.finalize(node, new Node.TaggedTemplateExpression(expr, quasi)); + } + else { + break; + } + } + return expr; + }; + // https://tc39.github.io/ecma262/#sec-update-expressions + Parser.prototype.parseUpdateExpression = function () { + var expr; + var startToken = this.lookahead; + if (this.match('++') || this.match('--')) { + var node = this.startNode(startToken); + var token = this.nextToken(); + expr = this.inheritCoverGrammar(this.parseUnaryExpression); + if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) { + this.tolerateError(messages_1.Messages.StrictLHSPrefix); + } + if (!this.context.isAssignmentTarget) { + this.tolerateError(messages_1.Messages.InvalidLHSInAssignment); + } + var prefix = true; + expr = this.finalize(node, new Node.UpdateExpression(token.value, expr, prefix)); + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + } + else { + expr = this.inheritCoverGrammar(this.parseLeftHandSideExpressionAllowCall); + if (!this.hasLineTerminator && this.lookahead.type === 7 /* Punctuator */) { + if (this.match('++') || this.match('--')) { + if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) { + this.tolerateError(messages_1.Messages.StrictLHSPostfix); + } + if (!this.context.isAssignmentTarget) { + this.tolerateError(messages_1.Messages.InvalidLHSInAssignment); + } + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + var operator = this.nextToken().value; + var prefix = false; + expr = this.finalize(this.startNode(startToken), new Node.UpdateExpression(operator, expr, prefix)); + } + } + } + return expr; + }; + // https://tc39.github.io/ecma262/#sec-unary-operators + Parser.prototype.parseAwaitExpression = function () { + var node = this.createNode(); + this.nextToken(); + var argument = this.parseUnaryExpression(); + return this.finalize(node, new Node.AwaitExpression(argument)); + }; + Parser.prototype.parseUnaryExpression = function () { + var expr; + if (this.match('+') || this.match('-') || this.match('~') || this.match('!') || + this.matchKeyword('delete') || this.matchKeyword('void') || this.matchKeyword('typeof')) { + var node = this.startNode(this.lookahead); + var token = this.nextToken(); + expr = this.inheritCoverGrammar(this.parseUnaryExpression); + expr = this.finalize(node, new Node.UnaryExpression(token.value, expr)); + if (this.context.strict && expr.operator === 'delete' && expr.argument.type === syntax_1.Syntax.Identifier) { + this.tolerateError(messages_1.Messages.StrictDelete); + } + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + } + else if (this.context.await && this.matchContextualKeyword('await')) { + expr = this.parseAwaitExpression(); + } + else { + expr = this.parseUpdateExpression(); + } + return expr; + }; + Parser.prototype.parseExponentiationExpression = function () { + var startToken = this.lookahead; + var expr = this.inheritCoverGrammar(this.parseUnaryExpression); + if (expr.type !== syntax_1.Syntax.UnaryExpression && this.match('**')) { + this.nextToken(); + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + var left = expr; + var right = this.isolateCoverGrammar(this.parseExponentiationExpression); + expr = this.finalize(this.startNode(startToken), new Node.BinaryExpression('**', left, right)); + } + return expr; + }; + // https://tc39.github.io/ecma262/#sec-exp-operator + // https://tc39.github.io/ecma262/#sec-multiplicative-operators + // https://tc39.github.io/ecma262/#sec-additive-operators + // https://tc39.github.io/ecma262/#sec-bitwise-shift-operators + // https://tc39.github.io/ecma262/#sec-relational-operators + // https://tc39.github.io/ecma262/#sec-equality-operators + // https://tc39.github.io/ecma262/#sec-binary-bitwise-operators + // https://tc39.github.io/ecma262/#sec-binary-logical-operators + Parser.prototype.binaryPrecedence = function (token) { + var op = token.value; + var precedence; + if (token.type === 7 /* Punctuator */) { + precedence = this.operatorPrecedence[op] || 0; + } + else if (token.type === 4 /* Keyword */) { + precedence = (op === 'instanceof' || (this.context.allowIn && op === 'in')) ? 7 : 0; + } + else { + precedence = 0; + } + return precedence; + }; + Parser.prototype.parseBinaryExpression = function () { + var startToken = this.lookahead; + var expr = this.inheritCoverGrammar(this.parseExponentiationExpression); + var token = this.lookahead; + var prec = this.binaryPrecedence(token); + if (prec > 0) { + this.nextToken(); + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + var markers = [startToken, this.lookahead]; + var left = expr; + var right = this.isolateCoverGrammar(this.parseExponentiationExpression); + var stack = [left, token.value, right]; + var precedences = [prec]; + while (true) { + prec = this.binaryPrecedence(this.lookahead); + if (prec <= 0) { + break; + } + // Reduce: make a binary expression from the three topmost entries. + while ((stack.length > 2) && (prec <= precedences[precedences.length - 1])) { + right = stack.pop(); + var operator = stack.pop(); + precedences.pop(); + left = stack.pop(); + markers.pop(); + var node = this.startNode(markers[markers.length - 1]); + stack.push(this.finalize(node, new Node.BinaryExpression(operator, left, right))); + } + // Shift. + stack.push(this.nextToken().value); + precedences.push(prec); + markers.push(this.lookahead); + stack.push(this.isolateCoverGrammar(this.parseExponentiationExpression)); + } + // Final reduce to clean-up the stack. + var i = stack.length - 1; + expr = stack[i]; + var lastMarker = markers.pop(); + while (i > 1) { + var marker = markers.pop(); + var lastLineStart = lastMarker && lastMarker.lineStart; + var node = this.startNode(marker, lastLineStart); + var operator = stack[i - 1]; + expr = this.finalize(node, new Node.BinaryExpression(operator, stack[i - 2], expr)); + i -= 2; + lastMarker = marker; + } + } + return expr; + }; + // https://tc39.github.io/ecma262/#sec-conditional-operator + Parser.prototype.parseConditionalExpression = function () { + var startToken = this.lookahead; + var expr = this.inheritCoverGrammar(this.parseBinaryExpression); + if (this.match('?')) { + this.nextToken(); + var previousAllowIn = this.context.allowIn; + this.context.allowIn = true; + var consequent = this.isolateCoverGrammar(this.parseAssignmentExpression); + this.context.allowIn = previousAllowIn; + this.expect(':'); + var alternate = this.isolateCoverGrammar(this.parseAssignmentExpression); + expr = this.finalize(this.startNode(startToken), new Node.ConditionalExpression(expr, consequent, alternate)); + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + } + return expr; + }; + // https://tc39.github.io/ecma262/#sec-assignment-operators + Parser.prototype.checkPatternParam = function (options, param) { + switch (param.type) { + case syntax_1.Syntax.Identifier: + this.validateParam(options, param, param.name); + break; + case syntax_1.Syntax.RestElement: + this.checkPatternParam(options, param.argument); + break; + case syntax_1.Syntax.AssignmentPattern: + this.checkPatternParam(options, param.left); + break; + case syntax_1.Syntax.ArrayPattern: + for (var i = 0; i < param.elements.length; i++) { + if (param.elements[i] !== null) { + this.checkPatternParam(options, param.elements[i]); + } + } + break; + case syntax_1.Syntax.ObjectPattern: + for (var i = 0; i < param.properties.length; i++) { + this.checkPatternParam(options, param.properties[i].value); + } + break; + default: + break; + } + options.simple = options.simple && (param instanceof Node.Identifier); + }; + Parser.prototype.reinterpretAsCoverFormalsList = function (expr) { + var params = [expr]; + var options; + var asyncArrow = false; + switch (expr.type) { + case syntax_1.Syntax.Identifier: + break; + case ArrowParameterPlaceHolder: + params = expr.params; + asyncArrow = expr.async; + break; + default: + return null; + } + options = { + simple: true, + paramSet: {} + }; + for (var i = 0; i < params.length; ++i) { + var param = params[i]; + if (param.type === syntax_1.Syntax.AssignmentPattern) { + if (param.right.type === syntax_1.Syntax.YieldExpression) { + if (param.right.argument) { + this.throwUnexpectedToken(this.lookahead); + } + param.right.type = syntax_1.Syntax.Identifier; + param.right.name = 'yield'; + delete param.right.argument; + delete param.right.delegate; + } + } + else if (asyncArrow && param.type === syntax_1.Syntax.Identifier && param.name === 'await') { + this.throwUnexpectedToken(this.lookahead); + } + this.checkPatternParam(options, param); + params[i] = param; + } + if (this.context.strict || !this.context.allowYield) { + for (var i = 0; i < params.length; ++i) { + var param = params[i]; + if (param.type === syntax_1.Syntax.YieldExpression) { + this.throwUnexpectedToken(this.lookahead); + } + } + } + if (options.message === messages_1.Messages.StrictParamDupe) { + var token = this.context.strict ? options.stricted : options.firstRestricted; + this.throwUnexpectedToken(token, options.message); + } + return { + simple: options.simple, + params: params, + stricted: options.stricted, + firstRestricted: options.firstRestricted, + message: options.message + }; + }; + Parser.prototype.parseAssignmentExpression = function () { + var expr; + if (!this.context.allowYield && this.matchKeyword('yield')) { + expr = this.parseYieldExpression(); + } + else { + var startToken = this.lookahead; + var token = startToken; + expr = this.parseConditionalExpression(); + if (token.type === 3 /* Identifier */ && (token.lineNumber === this.lookahead.lineNumber) && token.value === 'async') { + if (this.lookahead.type === 3 /* Identifier */ || this.matchKeyword('yield')) { + var arg = this.parsePrimaryExpression(); + this.reinterpretExpressionAsPattern(arg); + expr = { + type: ArrowParameterPlaceHolder, + params: [arg], + async: true + }; + } + } + if (expr.type === ArrowParameterPlaceHolder || this.match('=>')) { + // https://tc39.github.io/ecma262/#sec-arrow-function-definitions + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + var isAsync = expr.async; + var list = this.reinterpretAsCoverFormalsList(expr); + if (list) { + if (this.hasLineTerminator) { + this.tolerateUnexpectedToken(this.lookahead); + } + this.context.firstCoverInitializedNameError = null; + var previousStrict = this.context.strict; + var previousAllowStrictDirective = this.context.allowStrictDirective; + this.context.allowStrictDirective = list.simple; + var previousAllowYield = this.context.allowYield; + var previousAwait = this.context.await; + this.context.allowYield = true; + this.context.await = isAsync; + var node = this.startNode(startToken); + this.expect('=>'); + var body = void 0; + if (this.match('{')) { + var previousAllowIn = this.context.allowIn; + this.context.allowIn = true; + body = this.parseFunctionSourceElements(); + this.context.allowIn = previousAllowIn; + } + else { + body = this.isolateCoverGrammar(this.parseAssignmentExpression); + } + var expression = body.type !== syntax_1.Syntax.BlockStatement; + if (this.context.strict && list.firstRestricted) { + this.throwUnexpectedToken(list.firstRestricted, list.message); + } + if (this.context.strict && list.stricted) { + this.tolerateUnexpectedToken(list.stricted, list.message); + } + expr = isAsync ? this.finalize(node, new Node.AsyncArrowFunctionExpression(list.params, body, expression)) : + this.finalize(node, new Node.ArrowFunctionExpression(list.params, body, expression)); + this.context.strict = previousStrict; + this.context.allowStrictDirective = previousAllowStrictDirective; + this.context.allowYield = previousAllowYield; + this.context.await = previousAwait; + } + } + else { + if (this.matchAssign()) { + if (!this.context.isAssignmentTarget) { + this.tolerateError(messages_1.Messages.InvalidLHSInAssignment); + } + if (this.context.strict && expr.type === syntax_1.Syntax.Identifier) { + var id = expr; + if (this.scanner.isRestrictedWord(id.name)) { + this.tolerateUnexpectedToken(token, messages_1.Messages.StrictLHSAssignment); + } + if (this.scanner.isStrictModeReservedWord(id.name)) { + this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord); + } + } + if (!this.match('=')) { + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + } + else { + this.reinterpretExpressionAsPattern(expr); + } + token = this.nextToken(); + var operator = token.value; + var right = this.isolateCoverGrammar(this.parseAssignmentExpression); + expr = this.finalize(this.startNode(startToken), new Node.AssignmentExpression(operator, expr, right)); + this.context.firstCoverInitializedNameError = null; + } + } + } + return expr; + }; + // https://tc39.github.io/ecma262/#sec-comma-operator + Parser.prototype.parseExpression = function () { + var startToken = this.lookahead; + var expr = this.isolateCoverGrammar(this.parseAssignmentExpression); + if (this.match(',')) { + var expressions = []; + expressions.push(expr); + while (this.lookahead.type !== 2 /* EOF */) { + if (!this.match(',')) { + break; + } + this.nextToken(); + expressions.push(this.isolateCoverGrammar(this.parseAssignmentExpression)); + } + expr = this.finalize(this.startNode(startToken), new Node.SequenceExpression(expressions)); + } + return expr; + }; + // https://tc39.github.io/ecma262/#sec-block + Parser.prototype.parseStatementListItem = function () { + var statement; + this.context.isAssignmentTarget = true; + this.context.isBindingElement = true; + if (this.lookahead.type === 4 /* Keyword */) { + switch (this.lookahead.value) { + case 'export': + if (!this.context.isModule) { + this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalExportDeclaration); + } + statement = this.parseExportDeclaration(); + break; + case 'import': + if (!this.context.isModule) { + this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalImportDeclaration); + } + statement = this.parseImportDeclaration(); + break; + case 'const': + statement = this.parseLexicalDeclaration({ inFor: false }); + break; + case 'function': + statement = this.parseFunctionDeclaration(); + break; + case 'class': + statement = this.parseClassDeclaration(); + break; + case 'let': + statement = this.isLexicalDeclaration() ? this.parseLexicalDeclaration({ inFor: false }) : this.parseStatement(); + break; + default: + statement = this.parseStatement(); + break; + } + } + else { + statement = this.parseStatement(); + } + return statement; + }; + Parser.prototype.parseBlock = function () { + var node = this.createNode(); + this.expect('{'); + var block = []; + while (true) { + if (this.match('}')) { + break; + } + block.push(this.parseStatementListItem()); + } + this.expect('}'); + return this.finalize(node, new Node.BlockStatement(block)); + }; + // https://tc39.github.io/ecma262/#sec-let-and-const-declarations + Parser.prototype.parseLexicalBinding = function (kind, options) { + var node = this.createNode(); + var params = []; + var id = this.parsePattern(params, kind); + if (this.context.strict && id.type === syntax_1.Syntax.Identifier) { + if (this.scanner.isRestrictedWord(id.name)) { + this.tolerateError(messages_1.Messages.StrictVarName); + } + } + var init = null; + if (kind === 'const') { + if (!this.matchKeyword('in') && !this.matchContextualKeyword('of')) { + if (this.match('=')) { + this.nextToken(); + init = this.isolateCoverGrammar(this.parseAssignmentExpression); + } + else { + this.throwError(messages_1.Messages.DeclarationMissingInitializer, 'const'); + } + } + } + else if ((!options.inFor && id.type !== syntax_1.Syntax.Identifier) || this.match('=')) { + this.expect('='); + init = this.isolateCoverGrammar(this.parseAssignmentExpression); + } + return this.finalize(node, new Node.VariableDeclarator(id, init)); + }; + Parser.prototype.parseBindingList = function (kind, options) { + var list = [this.parseLexicalBinding(kind, options)]; + while (this.match(',')) { + this.nextToken(); + list.push(this.parseLexicalBinding(kind, options)); + } + return list; + }; + Parser.prototype.isLexicalDeclaration = function () { + var state = this.scanner.saveState(); + this.scanner.scanComments(); + var next = this.scanner.lex(); + this.scanner.restoreState(state); + return (next.type === 3 /* Identifier */) || + (next.type === 7 /* Punctuator */ && next.value === '[') || + (next.type === 7 /* Punctuator */ && next.value === '{') || + (next.type === 4 /* Keyword */ && next.value === 'let') || + (next.type === 4 /* Keyword */ && next.value === 'yield'); + }; + Parser.prototype.parseLexicalDeclaration = function (options) { + var node = this.createNode(); + var kind = this.nextToken().value; + assert_1.assert(kind === 'let' || kind === 'const', 'Lexical declaration must be either let or const'); + var declarations = this.parseBindingList(kind, options); + this.consumeSemicolon(); + return this.finalize(node, new Node.VariableDeclaration(declarations, kind)); + }; + // https://tc39.github.io/ecma262/#sec-destructuring-binding-patterns + Parser.prototype.parseBindingRestElement = function (params, kind) { + var node = this.createNode(); + this.expect('...'); + var arg = this.parsePattern(params, kind); + return this.finalize(node, new Node.RestElement(arg)); + }; + Parser.prototype.parseArrayPattern = function (params, kind) { + var node = this.createNode(); + this.expect('['); + var elements = []; + while (!this.match(']')) { + if (this.match(',')) { + this.nextToken(); + elements.push(null); + } + else { + if (this.match('...')) { + elements.push(this.parseBindingRestElement(params, kind)); + break; + } + else { + elements.push(this.parsePatternWithDefault(params, kind)); + } + if (!this.match(']')) { + this.expect(','); + } + } + } + this.expect(']'); + return this.finalize(node, new Node.ArrayPattern(elements)); + }; + Parser.prototype.parsePropertyPattern = function (params, kind) { + var node = this.createNode(); + var computed = false; + var shorthand = false; + var method = false; + var key; + var value; + if (this.lookahead.type === 3 /* Identifier */) { + var keyToken = this.lookahead; + key = this.parseVariableIdentifier(); + var init = this.finalize(node, new Node.Identifier(keyToken.value)); + if (this.match('=')) { + params.push(keyToken); + shorthand = true; + this.nextToken(); + var expr = this.parseAssignmentExpression(); + value = this.finalize(this.startNode(keyToken), new Node.AssignmentPattern(init, expr)); + } + else if (!this.match(':')) { + params.push(keyToken); + shorthand = true; + value = init; + } + else { + this.expect(':'); + value = this.parsePatternWithDefault(params, kind); + } + } + else { + computed = this.match('['); + key = this.parseObjectPropertyKey(); + this.expect(':'); + value = this.parsePatternWithDefault(params, kind); + } + return this.finalize(node, new Node.Property('init', key, computed, value, method, shorthand)); + }; + Parser.prototype.parseObjectPattern = function (params, kind) { + var node = this.createNode(); + var properties = []; + this.expect('{'); + while (!this.match('}')) { + properties.push(this.parsePropertyPattern(params, kind)); + if (!this.match('}')) { + this.expect(','); + } + } + this.expect('}'); + return this.finalize(node, new Node.ObjectPattern(properties)); + }; + Parser.prototype.parsePattern = function (params, kind) { + var pattern; + if (this.match('[')) { + pattern = this.parseArrayPattern(params, kind); + } + else if (this.match('{')) { + pattern = this.parseObjectPattern(params, kind); + } + else { + if (this.matchKeyword('let') && (kind === 'const' || kind === 'let')) { + this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.LetInLexicalBinding); + } + params.push(this.lookahead); + pattern = this.parseVariableIdentifier(kind); + } + return pattern; + }; + Parser.prototype.parsePatternWithDefault = function (params, kind) { + var startToken = this.lookahead; + var pattern = this.parsePattern(params, kind); + if (this.match('=')) { + this.nextToken(); + var previousAllowYield = this.context.allowYield; + this.context.allowYield = true; + var right = this.isolateCoverGrammar(this.parseAssignmentExpression); + this.context.allowYield = previousAllowYield; + pattern = this.finalize(this.startNode(startToken), new Node.AssignmentPattern(pattern, right)); + } + return pattern; + }; + // https://tc39.github.io/ecma262/#sec-variable-statement + Parser.prototype.parseVariableIdentifier = function (kind) { + var node = this.createNode(); + var token = this.nextToken(); + if (token.type === 4 /* Keyword */ && token.value === 'yield') { + if (this.context.strict) { + this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord); + } + else if (!this.context.allowYield) { + this.throwUnexpectedToken(token); + } + } + else if (token.type !== 3 /* Identifier */) { + if (this.context.strict && token.type === 4 /* Keyword */ && this.scanner.isStrictModeReservedWord(token.value)) { + this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord); + } + else { + if (this.context.strict || token.value !== 'let' || kind !== 'var') { + this.throwUnexpectedToken(token); + } + } + } + else if ((this.context.isModule || this.context.await) && token.type === 3 /* Identifier */ && token.value === 'await') { + this.tolerateUnexpectedToken(token); + } + return this.finalize(node, new Node.Identifier(token.value)); + }; + Parser.prototype.parseVariableDeclaration = function (options) { + var node = this.createNode(); + var params = []; + var id = this.parsePattern(params, 'var'); + if (this.context.strict && id.type === syntax_1.Syntax.Identifier) { + if (this.scanner.isRestrictedWord(id.name)) { + this.tolerateError(messages_1.Messages.StrictVarName); + } + } + var init = null; + if (this.match('=')) { + this.nextToken(); + init = this.isolateCoverGrammar(this.parseAssignmentExpression); + } + else if (id.type !== syntax_1.Syntax.Identifier && !options.inFor) { + this.expect('='); + } + return this.finalize(node, new Node.VariableDeclarator(id, init)); + }; + Parser.prototype.parseVariableDeclarationList = function (options) { + var opt = { inFor: options.inFor }; + var list = []; + list.push(this.parseVariableDeclaration(opt)); + while (this.match(',')) { + this.nextToken(); + list.push(this.parseVariableDeclaration(opt)); + } + return list; + }; + Parser.prototype.parseVariableStatement = function () { + var node = this.createNode(); + this.expectKeyword('var'); + var declarations = this.parseVariableDeclarationList({ inFor: false }); + this.consumeSemicolon(); + return this.finalize(node, new Node.VariableDeclaration(declarations, 'var')); + }; + // https://tc39.github.io/ecma262/#sec-empty-statement + Parser.prototype.parseEmptyStatement = function () { + var node = this.createNode(); + this.expect(';'); + return this.finalize(node, new Node.EmptyStatement()); + }; + // https://tc39.github.io/ecma262/#sec-expression-statement + Parser.prototype.parseExpressionStatement = function () { + var node = this.createNode(); + var expr = this.parseExpression(); + this.consumeSemicolon(); + return this.finalize(node, new Node.ExpressionStatement(expr)); + }; + // https://tc39.github.io/ecma262/#sec-if-statement + Parser.prototype.parseIfClause = function () { + if (this.context.strict && this.matchKeyword('function')) { + this.tolerateError(messages_1.Messages.StrictFunction); + } + return this.parseStatement(); + }; + Parser.prototype.parseIfStatement = function () { + var node = this.createNode(); + var consequent; + var alternate = null; + this.expectKeyword('if'); + this.expect('('); + var test = this.parseExpression(); + if (!this.match(')') && this.config.tolerant) { + this.tolerateUnexpectedToken(this.nextToken()); + consequent = this.finalize(this.createNode(), new Node.EmptyStatement()); + } + else { + this.expect(')'); + consequent = this.parseIfClause(); + if (this.matchKeyword('else')) { + this.nextToken(); + alternate = this.parseIfClause(); + } + } + return this.finalize(node, new Node.IfStatement(test, consequent, alternate)); + }; + // https://tc39.github.io/ecma262/#sec-do-while-statement + Parser.prototype.parseDoWhileStatement = function () { + var node = this.createNode(); + this.expectKeyword('do'); + var previousInIteration = this.context.inIteration; + this.context.inIteration = true; + var body = this.parseStatement(); + this.context.inIteration = previousInIteration; + this.expectKeyword('while'); + this.expect('('); + var test = this.parseExpression(); + if (!this.match(')') && this.config.tolerant) { + this.tolerateUnexpectedToken(this.nextToken()); + } + else { + this.expect(')'); + if (this.match(';')) { + this.nextToken(); + } + } + return this.finalize(node, new Node.DoWhileStatement(body, test)); + }; + // https://tc39.github.io/ecma262/#sec-while-statement + Parser.prototype.parseWhileStatement = function () { + var node = this.createNode(); + var body; + this.expectKeyword('while'); + this.expect('('); + var test = this.parseExpression(); + if (!this.match(')') && this.config.tolerant) { + this.tolerateUnexpectedToken(this.nextToken()); + body = this.finalize(this.createNode(), new Node.EmptyStatement()); + } + else { + this.expect(')'); + var previousInIteration = this.context.inIteration; + this.context.inIteration = true; + body = this.parseStatement(); + this.context.inIteration = previousInIteration; + } + return this.finalize(node, new Node.WhileStatement(test, body)); + }; + // https://tc39.github.io/ecma262/#sec-for-statement + // https://tc39.github.io/ecma262/#sec-for-in-and-for-of-statements + Parser.prototype.parseForStatement = function () { + var init = null; + var test = null; + var update = null; + var forIn = true; + var left, right; + var node = this.createNode(); + this.expectKeyword('for'); + this.expect('('); + if (this.match(';')) { + this.nextToken(); + } + else { + if (this.matchKeyword('var')) { + init = this.createNode(); + this.nextToken(); + var previousAllowIn = this.context.allowIn; + this.context.allowIn = false; + var declarations = this.parseVariableDeclarationList({ inFor: true }); + this.context.allowIn = previousAllowIn; + if (declarations.length === 1 && this.matchKeyword('in')) { + var decl = declarations[0]; + if (decl.init && (decl.id.type === syntax_1.Syntax.ArrayPattern || decl.id.type === syntax_1.Syntax.ObjectPattern || this.context.strict)) { + this.tolerateError(messages_1.Messages.ForInOfLoopInitializer, 'for-in'); + } + init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var')); + this.nextToken(); + left = init; + right = this.parseExpression(); + init = null; + } + else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword('of')) { + init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var')); + this.nextToken(); + left = init; + right = this.parseAssignmentExpression(); + init = null; + forIn = false; + } + else { + init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var')); + this.expect(';'); + } + } + else if (this.matchKeyword('const') || this.matchKeyword('let')) { + init = this.createNode(); + var kind = this.nextToken().value; + if (!this.context.strict && this.lookahead.value === 'in') { + init = this.finalize(init, new Node.Identifier(kind)); + this.nextToken(); + left = init; + right = this.parseExpression(); + init = null; + } + else { + var previousAllowIn = this.context.allowIn; + this.context.allowIn = false; + var declarations = this.parseBindingList(kind, { inFor: true }); + this.context.allowIn = previousAllowIn; + if (declarations.length === 1 && declarations[0].init === null && this.matchKeyword('in')) { + init = this.finalize(init, new Node.VariableDeclaration(declarations, kind)); + this.nextToken(); + left = init; + right = this.parseExpression(); + init = null; + } + else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword('of')) { + init = this.finalize(init, new Node.VariableDeclaration(declarations, kind)); + this.nextToken(); + left = init; + right = this.parseAssignmentExpression(); + init = null; + forIn = false; + } + else { + this.consumeSemicolon(); + init = this.finalize(init, new Node.VariableDeclaration(declarations, kind)); + } + } + } + else { + var initStartToken = this.lookahead; + var previousAllowIn = this.context.allowIn; + this.context.allowIn = false; + init = this.inheritCoverGrammar(this.parseAssignmentExpression); + this.context.allowIn = previousAllowIn; + if (this.matchKeyword('in')) { + if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) { + this.tolerateError(messages_1.Messages.InvalidLHSInForIn); + } + this.nextToken(); + this.reinterpretExpressionAsPattern(init); + left = init; + right = this.parseExpression(); + init = null; + } + else if (this.matchContextualKeyword('of')) { + if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) { + this.tolerateError(messages_1.Messages.InvalidLHSInForLoop); + } + this.nextToken(); + this.reinterpretExpressionAsPattern(init); + left = init; + right = this.parseAssignmentExpression(); + init = null; + forIn = false; + } + else { + if (this.match(',')) { + var initSeq = [init]; + while (this.match(',')) { + this.nextToken(); + initSeq.push(this.isolateCoverGrammar(this.parseAssignmentExpression)); + } + init = this.finalize(this.startNode(initStartToken), new Node.SequenceExpression(initSeq)); + } + this.expect(';'); + } + } + } + if (typeof left === 'undefined') { + if (!this.match(';')) { + test = this.parseExpression(); + } + this.expect(';'); + if (!this.match(')')) { + update = this.parseExpression(); + } + } + var body; + if (!this.match(')') && this.config.tolerant) { + this.tolerateUnexpectedToken(this.nextToken()); + body = this.finalize(this.createNode(), new Node.EmptyStatement()); + } + else { + this.expect(')'); + var previousInIteration = this.context.inIteration; + this.context.inIteration = true; + body = this.isolateCoverGrammar(this.parseStatement); + this.context.inIteration = previousInIteration; + } + return (typeof left === 'undefined') ? + this.finalize(node, new Node.ForStatement(init, test, update, body)) : + forIn ? this.finalize(node, new Node.ForInStatement(left, right, body)) : + this.finalize(node, new Node.ForOfStatement(left, right, body)); + }; + // https://tc39.github.io/ecma262/#sec-continue-statement + Parser.prototype.parseContinueStatement = function () { + var node = this.createNode(); + this.expectKeyword('continue'); + var label = null; + if (this.lookahead.type === 3 /* Identifier */ && !this.hasLineTerminator) { + var id = this.parseVariableIdentifier(); + label = id; + var key = '$' + id.name; + if (!Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) { + this.throwError(messages_1.Messages.UnknownLabel, id.name); + } + } + this.consumeSemicolon(); + if (label === null && !this.context.inIteration) { + this.throwError(messages_1.Messages.IllegalContinue); + } + return this.finalize(node, new Node.ContinueStatement(label)); + }; + // https://tc39.github.io/ecma262/#sec-break-statement + Parser.prototype.parseBreakStatement = function () { + var node = this.createNode(); + this.expectKeyword('break'); + var label = null; + if (this.lookahead.type === 3 /* Identifier */ && !this.hasLineTerminator) { + var id = this.parseVariableIdentifier(); + var key = '$' + id.name; + if (!Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) { + this.throwError(messages_1.Messages.UnknownLabel, id.name); + } + label = id; + } + this.consumeSemicolon(); + if (label === null && !this.context.inIteration && !this.context.inSwitch) { + this.throwError(messages_1.Messages.IllegalBreak); + } + return this.finalize(node, new Node.BreakStatement(label)); + }; + // https://tc39.github.io/ecma262/#sec-return-statement + Parser.prototype.parseReturnStatement = function () { + if (!this.context.inFunctionBody) { + this.tolerateError(messages_1.Messages.IllegalReturn); + } + var node = this.createNode(); + this.expectKeyword('return'); + var hasArgument = (!this.match(';') && !this.match('}') && + !this.hasLineTerminator && this.lookahead.type !== 2 /* EOF */) || + this.lookahead.type === 8 /* StringLiteral */ || + this.lookahead.type === 10 /* Template */; + var argument = hasArgument ? this.parseExpression() : null; + this.consumeSemicolon(); + return this.finalize(node, new Node.ReturnStatement(argument)); + }; + // https://tc39.github.io/ecma262/#sec-with-statement + Parser.prototype.parseWithStatement = function () { + if (this.context.strict) { + this.tolerateError(messages_1.Messages.StrictModeWith); + } + var node = this.createNode(); + var body; + this.expectKeyword('with'); + this.expect('('); + var object = this.parseExpression(); + if (!this.match(')') && this.config.tolerant) { + this.tolerateUnexpectedToken(this.nextToken()); + body = this.finalize(this.createNode(), new Node.EmptyStatement()); + } + else { + this.expect(')'); + body = this.parseStatement(); + } + return this.finalize(node, new Node.WithStatement(object, body)); + }; + // https://tc39.github.io/ecma262/#sec-switch-statement + Parser.prototype.parseSwitchCase = function () { + var node = this.createNode(); + var test; + if (this.matchKeyword('default')) { + this.nextToken(); + test = null; + } + else { + this.expectKeyword('case'); + test = this.parseExpression(); + } + this.expect(':'); + var consequent = []; + while (true) { + if (this.match('}') || this.matchKeyword('default') || this.matchKeyword('case')) { + break; + } + consequent.push(this.parseStatementListItem()); + } + return this.finalize(node, new Node.SwitchCase(test, consequent)); + }; + Parser.prototype.parseSwitchStatement = function () { + var node = this.createNode(); + this.expectKeyword('switch'); + this.expect('('); + var discriminant = this.parseExpression(); + this.expect(')'); + var previousInSwitch = this.context.inSwitch; + this.context.inSwitch = true; + var cases = []; + var defaultFound = false; + this.expect('{'); + while (true) { + if (this.match('}')) { + break; + } + var clause = this.parseSwitchCase(); + if (clause.test === null) { + if (defaultFound) { + this.throwError(messages_1.Messages.MultipleDefaultsInSwitch); + } + defaultFound = true; + } + cases.push(clause); + } + this.expect('}'); + this.context.inSwitch = previousInSwitch; + return this.finalize(node, new Node.SwitchStatement(discriminant, cases)); + }; + // https://tc39.github.io/ecma262/#sec-labelled-statements + Parser.prototype.parseLabelledStatement = function () { + var node = this.createNode(); + var expr = this.parseExpression(); + var statement; + if ((expr.type === syntax_1.Syntax.Identifier) && this.match(':')) { + this.nextToken(); + var id = expr; + var key = '$' + id.name; + if (Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) { + this.throwError(messages_1.Messages.Redeclaration, 'Label', id.name); + } + this.context.labelSet[key] = true; + var body = void 0; + if (this.matchKeyword('class')) { + this.tolerateUnexpectedToken(this.lookahead); + body = this.parseClassDeclaration(); + } + else if (this.matchKeyword('function')) { + var token = this.lookahead; + var declaration = this.parseFunctionDeclaration(); + if (this.context.strict) { + this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunction); + } + else if (declaration.generator) { + this.tolerateUnexpectedToken(token, messages_1.Messages.GeneratorInLegacyContext); + } + body = declaration; + } + else { + body = this.parseStatement(); + } + delete this.context.labelSet[key]; + statement = new Node.LabeledStatement(id, body); + } + else { + this.consumeSemicolon(); + statement = new Node.ExpressionStatement(expr); + } + return this.finalize(node, statement); + }; + // https://tc39.github.io/ecma262/#sec-throw-statement + Parser.prototype.parseThrowStatement = function () { + var node = this.createNode(); + this.expectKeyword('throw'); + if (this.hasLineTerminator) { + this.throwError(messages_1.Messages.NewlineAfterThrow); + } + var argument = this.parseExpression(); + this.consumeSemicolon(); + return this.finalize(node, new Node.ThrowStatement(argument)); + }; + // https://tc39.github.io/ecma262/#sec-try-statement + Parser.prototype.parseCatchClause = function () { + var node = this.createNode(); + this.expectKeyword('catch'); + this.expect('('); + if (this.match(')')) { + this.throwUnexpectedToken(this.lookahead); + } + var params = []; + var param = this.parsePattern(params); + var paramMap = {}; + for (var i = 0; i < params.length; i++) { + var key = '$' + params[i].value; + if (Object.prototype.hasOwnProperty.call(paramMap, key)) { + this.tolerateError(messages_1.Messages.DuplicateBinding, params[i].value); + } + paramMap[key] = true; + } + if (this.context.strict && param.type === syntax_1.Syntax.Identifier) { + if (this.scanner.isRestrictedWord(param.name)) { + this.tolerateError(messages_1.Messages.StrictCatchVariable); + } + } + this.expect(')'); + var body = this.parseBlock(); + return this.finalize(node, new Node.CatchClause(param, body)); + }; + Parser.prototype.parseFinallyClause = function () { + this.expectKeyword('finally'); + return this.parseBlock(); + }; + Parser.prototype.parseTryStatement = function () { + var node = this.createNode(); + this.expectKeyword('try'); + var block = this.parseBlock(); + var handler = this.matchKeyword('catch') ? this.parseCatchClause() : null; + var finalizer = this.matchKeyword('finally') ? this.parseFinallyClause() : null; + if (!handler && !finalizer) { + this.throwError(messages_1.Messages.NoCatchOrFinally); + } + return this.finalize(node, new Node.TryStatement(block, handler, finalizer)); + }; + // https://tc39.github.io/ecma262/#sec-debugger-statement + Parser.prototype.parseDebuggerStatement = function () { + var node = this.createNode(); + this.expectKeyword('debugger'); + this.consumeSemicolon(); + return this.finalize(node, new Node.DebuggerStatement()); + }; + // https://tc39.github.io/ecma262/#sec-ecmascript-language-statements-and-declarations + Parser.prototype.parseStatement = function () { + var statement; + switch (this.lookahead.type) { + case 1 /* BooleanLiteral */: + case 5 /* NullLiteral */: + case 6 /* NumericLiteral */: + case 8 /* StringLiteral */: + case 10 /* Template */: + case 9 /* RegularExpression */: + statement = this.parseExpressionStatement(); + break; + case 7 /* Punctuator */: + var value = this.lookahead.value; + if (value === '{') { + statement = this.parseBlock(); + } + else if (value === '(') { + statement = this.parseExpressionStatement(); + } + else if (value === ';') { + statement = this.parseEmptyStatement(); + } + else { + statement = this.parseExpressionStatement(); + } + break; + case 3 /* Identifier */: + statement = this.matchAsyncFunction() ? this.parseFunctionDeclaration() : this.parseLabelledStatement(); + break; + case 4 /* Keyword */: + switch (this.lookahead.value) { + case 'break': + statement = this.parseBreakStatement(); + break; + case 'continue': + statement = this.parseContinueStatement(); + break; + case 'debugger': + statement = this.parseDebuggerStatement(); + break; + case 'do': + statement = this.parseDoWhileStatement(); + break; + case 'for': + statement = this.parseForStatement(); + break; + case 'function': + statement = this.parseFunctionDeclaration(); + break; + case 'if': + statement = this.parseIfStatement(); + break; + case 'return': + statement = this.parseReturnStatement(); + break; + case 'switch': + statement = this.parseSwitchStatement(); + break; + case 'throw': + statement = this.parseThrowStatement(); + break; + case 'try': + statement = this.parseTryStatement(); + break; + case 'var': + statement = this.parseVariableStatement(); + break; + case 'while': + statement = this.parseWhileStatement(); + break; + case 'with': + statement = this.parseWithStatement(); + break; + default: + statement = this.parseExpressionStatement(); + break; + } + break; + default: + statement = this.throwUnexpectedToken(this.lookahead); + } + return statement; + }; + // https://tc39.github.io/ecma262/#sec-function-definitions + Parser.prototype.parseFunctionSourceElements = function () { + var node = this.createNode(); + this.expect('{'); + var body = this.parseDirectivePrologues(); + var previousLabelSet = this.context.labelSet; + var previousInIteration = this.context.inIteration; + var previousInSwitch = this.context.inSwitch; + var previousInFunctionBody = this.context.inFunctionBody; + this.context.labelSet = {}; + this.context.inIteration = false; + this.context.inSwitch = false; + this.context.inFunctionBody = true; + while (this.lookahead.type !== 2 /* EOF */) { + if (this.match('}')) { + break; + } + body.push(this.parseStatementListItem()); + } + this.expect('}'); + this.context.labelSet = previousLabelSet; + this.context.inIteration = previousInIteration; + this.context.inSwitch = previousInSwitch; + this.context.inFunctionBody = previousInFunctionBody; + return this.finalize(node, new Node.BlockStatement(body)); + }; + Parser.prototype.validateParam = function (options, param, name) { + var key = '$' + name; + if (this.context.strict) { + if (this.scanner.isRestrictedWord(name)) { + options.stricted = param; + options.message = messages_1.Messages.StrictParamName; + } + if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) { + options.stricted = param; + options.message = messages_1.Messages.StrictParamDupe; + } + } + else if (!options.firstRestricted) { + if (this.scanner.isRestrictedWord(name)) { + options.firstRestricted = param; + options.message = messages_1.Messages.StrictParamName; + } + else if (this.scanner.isStrictModeReservedWord(name)) { + options.firstRestricted = param; + options.message = messages_1.Messages.StrictReservedWord; + } + else if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) { + options.stricted = param; + options.message = messages_1.Messages.StrictParamDupe; + } + } + /* istanbul ignore next */ + if (typeof Object.defineProperty === 'function') { + Object.defineProperty(options.paramSet, key, { value: true, enumerable: true, writable: true, configurable: true }); + } + else { + options.paramSet[key] = true; + } + }; + Parser.prototype.parseRestElement = function (params) { + var node = this.createNode(); + this.expect('...'); + var arg = this.parsePattern(params); + if (this.match('=')) { + this.throwError(messages_1.Messages.DefaultRestParameter); + } + if (!this.match(')')) { + this.throwError(messages_1.Messages.ParameterAfterRestParameter); + } + return this.finalize(node, new Node.RestElement(arg)); + }; + Parser.prototype.parseFormalParameter = function (options) { + var params = []; + var param = this.match('...') ? this.parseRestElement(params) : this.parsePatternWithDefault(params); + for (var i = 0; i < params.length; i++) { + this.validateParam(options, params[i], params[i].value); + } + options.simple = options.simple && (param instanceof Node.Identifier); + options.params.push(param); + }; + Parser.prototype.parseFormalParameters = function (firstRestricted) { + var options; + options = { + simple: true, + params: [], + firstRestricted: firstRestricted + }; + this.expect('('); + if (!this.match(')')) { + options.paramSet = {}; + while (this.lookahead.type !== 2 /* EOF */) { + this.parseFormalParameter(options); + if (this.match(')')) { + break; + } + this.expect(','); + if (this.match(')')) { + break; + } + } + } + this.expect(')'); + return { + simple: options.simple, + params: options.params, + stricted: options.stricted, + firstRestricted: options.firstRestricted, + message: options.message + }; + }; + Parser.prototype.matchAsyncFunction = function () { + var match = this.matchContextualKeyword('async'); + if (match) { + var state = this.scanner.saveState(); + this.scanner.scanComments(); + var next = this.scanner.lex(); + this.scanner.restoreState(state); + match = (state.lineNumber === next.lineNumber) && (next.type === 4 /* Keyword */) && (next.value === 'function'); + } + return match; + }; + Parser.prototype.parseFunctionDeclaration = function (identifierIsOptional) { + var node = this.createNode(); + var isAsync = this.matchContextualKeyword('async'); + if (isAsync) { + this.nextToken(); + } + this.expectKeyword('function'); + var isGenerator = isAsync ? false : this.match('*'); + if (isGenerator) { + this.nextToken(); + } + var message; + var id = null; + var firstRestricted = null; + if (!identifierIsOptional || !this.match('(')) { + var token = this.lookahead; + id = this.parseVariableIdentifier(); + if (this.context.strict) { + if (this.scanner.isRestrictedWord(token.value)) { + this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName); + } + } + else { + if (this.scanner.isRestrictedWord(token.value)) { + firstRestricted = token; + message = messages_1.Messages.StrictFunctionName; + } + else if (this.scanner.isStrictModeReservedWord(token.value)) { + firstRestricted = token; + message = messages_1.Messages.StrictReservedWord; + } + } + } + var previousAllowAwait = this.context.await; + var previousAllowYield = this.context.allowYield; + this.context.await = isAsync; + this.context.allowYield = !isGenerator; + var formalParameters = this.parseFormalParameters(firstRestricted); + var params = formalParameters.params; + var stricted = formalParameters.stricted; + firstRestricted = formalParameters.firstRestricted; + if (formalParameters.message) { + message = formalParameters.message; + } + var previousStrict = this.context.strict; + var previousAllowStrictDirective = this.context.allowStrictDirective; + this.context.allowStrictDirective = formalParameters.simple; + var body = this.parseFunctionSourceElements(); + if (this.context.strict && firstRestricted) { + this.throwUnexpectedToken(firstRestricted, message); + } + if (this.context.strict && stricted) { + this.tolerateUnexpectedToken(stricted, message); + } + this.context.strict = previousStrict; + this.context.allowStrictDirective = previousAllowStrictDirective; + this.context.await = previousAllowAwait; + this.context.allowYield = previousAllowYield; + return isAsync ? this.finalize(node, new Node.AsyncFunctionDeclaration(id, params, body)) : + this.finalize(node, new Node.FunctionDeclaration(id, params, body, isGenerator)); + }; + Parser.prototype.parseFunctionExpression = function () { + var node = this.createNode(); + var isAsync = this.matchContextualKeyword('async'); + if (isAsync) { + this.nextToken(); + } + this.expectKeyword('function'); + var isGenerator = isAsync ? false : this.match('*'); + if (isGenerator) { + this.nextToken(); + } + var message; + var id = null; + var firstRestricted; + var previousAllowAwait = this.context.await; + var previousAllowYield = this.context.allowYield; + this.context.await = isAsync; + this.context.allowYield = !isGenerator; + if (!this.match('(')) { + var token = this.lookahead; + id = (!this.context.strict && !isGenerator && this.matchKeyword('yield')) ? this.parseIdentifierName() : this.parseVariableIdentifier(); + if (this.context.strict) { + if (this.scanner.isRestrictedWord(token.value)) { + this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName); + } + } + else { + if (this.scanner.isRestrictedWord(token.value)) { + firstRestricted = token; + message = messages_1.Messages.StrictFunctionName; + } + else if (this.scanner.isStrictModeReservedWord(token.value)) { + firstRestricted = token; + message = messages_1.Messages.StrictReservedWord; + } + } + } + var formalParameters = this.parseFormalParameters(firstRestricted); + var params = formalParameters.params; + var stricted = formalParameters.stricted; + firstRestricted = formalParameters.firstRestricted; + if (formalParameters.message) { + message = formalParameters.message; + } + var previousStrict = this.context.strict; + var previousAllowStrictDirective = this.context.allowStrictDirective; + this.context.allowStrictDirective = formalParameters.simple; + var body = this.parseFunctionSourceElements(); + if (this.context.strict && firstRestricted) { + this.throwUnexpectedToken(firstRestricted, message); + } + if (this.context.strict && stricted) { + this.tolerateUnexpectedToken(stricted, message); + } + this.context.strict = previousStrict; + this.context.allowStrictDirective = previousAllowStrictDirective; + this.context.await = previousAllowAwait; + this.context.allowYield = previousAllowYield; + return isAsync ? this.finalize(node, new Node.AsyncFunctionExpression(id, params, body)) : + this.finalize(node, new Node.FunctionExpression(id, params, body, isGenerator)); + }; + // https://tc39.github.io/ecma262/#sec-directive-prologues-and-the-use-strict-directive + Parser.prototype.parseDirective = function () { + var token = this.lookahead; + var node = this.createNode(); + var expr = this.parseExpression(); + var directive = (expr.type === syntax_1.Syntax.Literal) ? this.getTokenRaw(token).slice(1, -1) : null; + this.consumeSemicolon(); + return this.finalize(node, directive ? new Node.Directive(expr, directive) : new Node.ExpressionStatement(expr)); + }; + Parser.prototype.parseDirectivePrologues = function () { + var firstRestricted = null; + var body = []; + while (true) { + var token = this.lookahead; + if (token.type !== 8 /* StringLiteral */) { + break; + } + var statement = this.parseDirective(); + body.push(statement); + var directive = statement.directive; + if (typeof directive !== 'string') { + break; + } + if (directive === 'use strict') { + this.context.strict = true; + if (firstRestricted) { + this.tolerateUnexpectedToken(firstRestricted, messages_1.Messages.StrictOctalLiteral); + } + if (!this.context.allowStrictDirective) { + this.tolerateUnexpectedToken(token, messages_1.Messages.IllegalLanguageModeDirective); + } + } + else { + if (!firstRestricted && token.octal) { + firstRestricted = token; + } + } + } + return body; + }; + // https://tc39.github.io/ecma262/#sec-method-definitions + Parser.prototype.qualifiedPropertyName = function (token) { + switch (token.type) { + case 3 /* Identifier */: + case 8 /* StringLiteral */: + case 1 /* BooleanLiteral */: + case 5 /* NullLiteral */: + case 6 /* NumericLiteral */: + case 4 /* Keyword */: + return true; + case 7 /* Punctuator */: + return token.value === '['; + default: + break; + } + return false; + }; + Parser.prototype.parseGetterMethod = function () { + var node = this.createNode(); + var isGenerator = false; + var previousAllowYield = this.context.allowYield; + this.context.allowYield = !isGenerator; + var formalParameters = this.parseFormalParameters(); + if (formalParameters.params.length > 0) { + this.tolerateError(messages_1.Messages.BadGetterArity); + } + var method = this.parsePropertyMethod(formalParameters); + this.context.allowYield = previousAllowYield; + return this.finalize(node, new Node.FunctionExpression(null, formalParameters.params, method, isGenerator)); + }; + Parser.prototype.parseSetterMethod = function () { + var node = this.createNode(); + var isGenerator = false; + var previousAllowYield = this.context.allowYield; + this.context.allowYield = !isGenerator; + var formalParameters = this.parseFormalParameters(); + if (formalParameters.params.length !== 1) { + this.tolerateError(messages_1.Messages.BadSetterArity); + } + else if (formalParameters.params[0] instanceof Node.RestElement) { + this.tolerateError(messages_1.Messages.BadSetterRestParameter); + } + var method = this.parsePropertyMethod(formalParameters); + this.context.allowYield = previousAllowYield; + return this.finalize(node, new Node.FunctionExpression(null, formalParameters.params, method, isGenerator)); + }; + Parser.prototype.parseGeneratorMethod = function () { + var node = this.createNode(); + var isGenerator = true; + var previousAllowYield = this.context.allowYield; + this.context.allowYield = true; + var params = this.parseFormalParameters(); + this.context.allowYield = false; + var method = this.parsePropertyMethod(params); + this.context.allowYield = previousAllowYield; + return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator)); + }; + // https://tc39.github.io/ecma262/#sec-generator-function-definitions + Parser.prototype.isStartOfExpression = function () { + var start = true; + var value = this.lookahead.value; + switch (this.lookahead.type) { + case 7 /* Punctuator */: + start = (value === '[') || (value === '(') || (value === '{') || + (value === '+') || (value === '-') || + (value === '!') || (value === '~') || + (value === '++') || (value === '--') || + (value === '/') || (value === '/='); // regular expression literal + break; + case 4 /* Keyword */: + start = (value === 'class') || (value === 'delete') || + (value === 'function') || (value === 'let') || (value === 'new') || + (value === 'super') || (value === 'this') || (value === 'typeof') || + (value === 'void') || (value === 'yield'); + break; + default: + break; + } + return start; + }; + Parser.prototype.parseYieldExpression = function () { + var node = this.createNode(); + this.expectKeyword('yield'); + var argument = null; + var delegate = false; + if (!this.hasLineTerminator) { + var previousAllowYield = this.context.allowYield; + this.context.allowYield = false; + delegate = this.match('*'); + if (delegate) { + this.nextToken(); + argument = this.parseAssignmentExpression(); + } + else if (this.isStartOfExpression()) { + argument = this.parseAssignmentExpression(); + } + this.context.allowYield = previousAllowYield; + } + return this.finalize(node, new Node.YieldExpression(argument, delegate)); + }; + // https://tc39.github.io/ecma262/#sec-class-definitions + Parser.prototype.parseClassElement = function (hasConstructor) { + var token = this.lookahead; + var node = this.createNode(); + var kind = ''; + var key = null; + var value = null; + var computed = false; + var method = false; + var isStatic = false; + var isAsync = false; + if (this.match('*')) { + this.nextToken(); + } + else { + computed = this.match('['); + key = this.parseObjectPropertyKey(); + var id = key; + if (id.name === 'static' && (this.qualifiedPropertyName(this.lookahead) || this.match('*'))) { + token = this.lookahead; + isStatic = true; + computed = this.match('['); + if (this.match('*')) { + this.nextToken(); + } + else { + key = this.parseObjectPropertyKey(); + } + } + if ((token.type === 3 /* Identifier */) && !this.hasLineTerminator && (token.value === 'async')) { + var punctuator = this.lookahead.value; + if (punctuator !== ':' && punctuator !== '(' && punctuator !== '*') { + isAsync = true; + token = this.lookahead; + key = this.parseObjectPropertyKey(); + if (token.type === 3 /* Identifier */ && token.value === 'constructor') { + this.tolerateUnexpectedToken(token, messages_1.Messages.ConstructorIsAsync); + } + } + } + } + var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead); + if (token.type === 3 /* Identifier */) { + if (token.value === 'get' && lookaheadPropertyKey) { + kind = 'get'; + computed = this.match('['); + key = this.parseObjectPropertyKey(); + this.context.allowYield = false; + value = this.parseGetterMethod(); + } + else if (token.value === 'set' && lookaheadPropertyKey) { + kind = 'set'; + computed = this.match('['); + key = this.parseObjectPropertyKey(); + value = this.parseSetterMethod(); + } + } + else if (token.type === 7 /* Punctuator */ && token.value === '*' && lookaheadPropertyKey) { + kind = 'init'; + computed = this.match('['); + key = this.parseObjectPropertyKey(); + value = this.parseGeneratorMethod(); + method = true; + } + if (!kind && key && this.match('(')) { + kind = 'init'; + value = isAsync ? this.parsePropertyMethodAsyncFunction() : this.parsePropertyMethodFunction(); + method = true; + } + if (!kind) { + this.throwUnexpectedToken(this.lookahead); + } + if (kind === 'init') { + kind = 'method'; + } + if (!computed) { + if (isStatic && this.isPropertyKey(key, 'prototype')) { + this.throwUnexpectedToken(token, messages_1.Messages.StaticPrototype); + } + if (!isStatic && this.isPropertyKey(key, 'constructor')) { + if (kind !== 'method' || !method || (value && value.generator)) { + this.throwUnexpectedToken(token, messages_1.Messages.ConstructorSpecialMethod); + } + if (hasConstructor.value) { + this.throwUnexpectedToken(token, messages_1.Messages.DuplicateConstructor); + } + else { + hasConstructor.value = true; + } + kind = 'constructor'; + } + } + return this.finalize(node, new Node.MethodDefinition(key, computed, value, kind, isStatic)); + }; + Parser.prototype.parseClassElementList = function () { + var body = []; + var hasConstructor = { value: false }; + this.expect('{'); + while (!this.match('}')) { + if (this.match(';')) { + this.nextToken(); + } + else { + body.push(this.parseClassElement(hasConstructor)); + } + } + this.expect('}'); + return body; + }; + Parser.prototype.parseClassBody = function () { + var node = this.createNode(); + var elementList = this.parseClassElementList(); + return this.finalize(node, new Node.ClassBody(elementList)); + }; + Parser.prototype.parseClassDeclaration = function (identifierIsOptional) { + var node = this.createNode(); + var previousStrict = this.context.strict; + this.context.strict = true; + this.expectKeyword('class'); + var id = (identifierIsOptional && (this.lookahead.type !== 3 /* Identifier */)) ? null : this.parseVariableIdentifier(); + var superClass = null; + if (this.matchKeyword('extends')) { + this.nextToken(); + superClass = this.isolateCoverGrammar(this.parseLeftHandSideExpressionAllowCall); + } + var classBody = this.parseClassBody(); + this.context.strict = previousStrict; + return this.finalize(node, new Node.ClassDeclaration(id, superClass, classBody)); + }; + Parser.prototype.parseClassExpression = function () { + var node = this.createNode(); + var previousStrict = this.context.strict; + this.context.strict = true; + this.expectKeyword('class'); + var id = (this.lookahead.type === 3 /* Identifier */) ? this.parseVariableIdentifier() : null; + var superClass = null; + if (this.matchKeyword('extends')) { + this.nextToken(); + superClass = this.isolateCoverGrammar(this.parseLeftHandSideExpressionAllowCall); + } + var classBody = this.parseClassBody(); + this.context.strict = previousStrict; + return this.finalize(node, new Node.ClassExpression(id, superClass, classBody)); + }; + // https://tc39.github.io/ecma262/#sec-scripts + // https://tc39.github.io/ecma262/#sec-modules + Parser.prototype.parseModule = function () { + this.context.strict = true; + this.context.isModule = true; + this.scanner.isModule = true; + var node = this.createNode(); + var body = this.parseDirectivePrologues(); + while (this.lookahead.type !== 2 /* EOF */) { + body.push(this.parseStatementListItem()); + } + return this.finalize(node, new Node.Module(body)); + }; + Parser.prototype.parseScript = function () { + var node = this.createNode(); + var body = this.parseDirectivePrologues(); + while (this.lookahead.type !== 2 /* EOF */) { + body.push(this.parseStatementListItem()); + } + return this.finalize(node, new Node.Script(body)); + }; + // https://tc39.github.io/ecma262/#sec-imports + Parser.prototype.parseModuleSpecifier = function () { + var node = this.createNode(); + if (this.lookahead.type !== 8 /* StringLiteral */) { + this.throwError(messages_1.Messages.InvalidModuleSpecifier); + } + var token = this.nextToken(); + var raw = this.getTokenRaw(token); + return this.finalize(node, new Node.Literal(token.value, raw)); + }; + // import {} ...; + Parser.prototype.parseImportSpecifier = function () { + var node = this.createNode(); + var imported; + var local; + if (this.lookahead.type === 3 /* Identifier */) { + imported = this.parseVariableIdentifier(); + local = imported; + if (this.matchContextualKeyword('as')) { + this.nextToken(); + local = this.parseVariableIdentifier(); + } + } + else { + imported = this.parseIdentifierName(); + local = imported; + if (this.matchContextualKeyword('as')) { + this.nextToken(); + local = this.parseVariableIdentifier(); + } + else { + this.throwUnexpectedToken(this.nextToken()); + } + } + return this.finalize(node, new Node.ImportSpecifier(local, imported)); + }; + // {foo, bar as bas} + Parser.prototype.parseNamedImports = function () { + this.expect('{'); + var specifiers = []; + while (!this.match('}')) { + specifiers.push(this.parseImportSpecifier()); + if (!this.match('}')) { + this.expect(','); + } + } + this.expect('}'); + return specifiers; + }; + // import ...; + Parser.prototype.parseImportDefaultSpecifier = function () { + var node = this.createNode(); + var local = this.parseIdentifierName(); + return this.finalize(node, new Node.ImportDefaultSpecifier(local)); + }; + // import <* as foo> ...; + Parser.prototype.parseImportNamespaceSpecifier = function () { + var node = this.createNode(); + this.expect('*'); + if (!this.matchContextualKeyword('as')) { + this.throwError(messages_1.Messages.NoAsAfterImportNamespace); + } + this.nextToken(); + var local = this.parseIdentifierName(); + return this.finalize(node, new Node.ImportNamespaceSpecifier(local)); + }; + Parser.prototype.parseImportDeclaration = function () { + if (this.context.inFunctionBody) { + this.throwError(messages_1.Messages.IllegalImportDeclaration); + } + var node = this.createNode(); + this.expectKeyword('import'); + var src; + var specifiers = []; + if (this.lookahead.type === 8 /* StringLiteral */) { + // import 'foo'; + src = this.parseModuleSpecifier(); + } + else { + if (this.match('{')) { + // import {bar} + specifiers = specifiers.concat(this.parseNamedImports()); + } + else if (this.match('*')) { + // import * as foo + specifiers.push(this.parseImportNamespaceSpecifier()); + } + else if (this.isIdentifierName(this.lookahead) && !this.matchKeyword('default')) { + // import foo + specifiers.push(this.parseImportDefaultSpecifier()); + if (this.match(',')) { + this.nextToken(); + if (this.match('*')) { + // import foo, * as foo + specifiers.push(this.parseImportNamespaceSpecifier()); + } + else if (this.match('{')) { + // import foo, {bar} + specifiers = specifiers.concat(this.parseNamedImports()); + } + else { + this.throwUnexpectedToken(this.lookahead); + } + } + } + else { + this.throwUnexpectedToken(this.nextToken()); + } + if (!this.matchContextualKeyword('from')) { + var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause; + this.throwError(message, this.lookahead.value); + } + this.nextToken(); + src = this.parseModuleSpecifier(); + } + this.consumeSemicolon(); + return this.finalize(node, new Node.ImportDeclaration(specifiers, src)); + }; + // https://tc39.github.io/ecma262/#sec-exports + Parser.prototype.parseExportSpecifier = function () { + var node = this.createNode(); + var local = this.parseIdentifierName(); + var exported = local; + if (this.matchContextualKeyword('as')) { + this.nextToken(); + exported = this.parseIdentifierName(); + } + return this.finalize(node, new Node.ExportSpecifier(local, exported)); + }; + Parser.prototype.parseExportDeclaration = function () { + if (this.context.inFunctionBody) { + this.throwError(messages_1.Messages.IllegalExportDeclaration); + } + var node = this.createNode(); + this.expectKeyword('export'); + var exportDeclaration; + if (this.matchKeyword('default')) { + // export default ... + this.nextToken(); + if (this.matchKeyword('function')) { + // export default function foo () {} + // export default function () {} + var declaration = this.parseFunctionDeclaration(true); + exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration)); + } + else if (this.matchKeyword('class')) { + // export default class foo {} + var declaration = this.parseClassDeclaration(true); + exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration)); + } + else if (this.matchContextualKeyword('async')) { + // export default async function f () {} + // export default async function () {} + // export default async x => x + var declaration = this.matchAsyncFunction() ? this.parseFunctionDeclaration(true) : this.parseAssignmentExpression(); + exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration)); + } + else { + if (this.matchContextualKeyword('from')) { + this.throwError(messages_1.Messages.UnexpectedToken, this.lookahead.value); + } + // export default {}; + // export default []; + // export default (1 + 2); + var declaration = this.match('{') ? this.parseObjectInitializer() : + this.match('[') ? this.parseArrayInitializer() : this.parseAssignmentExpression(); + this.consumeSemicolon(); + exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration)); + } + } + else if (this.match('*')) { + // export * from 'foo'; + this.nextToken(); + if (!this.matchContextualKeyword('from')) { + var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause; + this.throwError(message, this.lookahead.value); + } + this.nextToken(); + var src = this.parseModuleSpecifier(); + this.consumeSemicolon(); + exportDeclaration = this.finalize(node, new Node.ExportAllDeclaration(src)); + } + else if (this.lookahead.type === 4 /* Keyword */) { + // export var f = 1; + var declaration = void 0; + switch (this.lookahead.value) { + case 'let': + case 'const': + declaration = this.parseLexicalDeclaration({ inFor: false }); + break; + case 'var': + case 'class': + case 'function': + declaration = this.parseStatementListItem(); + break; + default: + this.throwUnexpectedToken(this.lookahead); + } + exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(declaration, [], null)); + } + else if (this.matchAsyncFunction()) { + var declaration = this.parseFunctionDeclaration(); + exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(declaration, [], null)); + } + else { + var specifiers = []; + var source = null; + var isExportFromIdentifier = false; + this.expect('{'); + while (!this.match('}')) { + isExportFromIdentifier = isExportFromIdentifier || this.matchKeyword('default'); + specifiers.push(this.parseExportSpecifier()); + if (!this.match('}')) { + this.expect(','); + } + } + this.expect('}'); + if (this.matchContextualKeyword('from')) { + // export {default} from 'foo'; + // export {foo} from 'foo'; + this.nextToken(); + source = this.parseModuleSpecifier(); + this.consumeSemicolon(); + } + else if (isExportFromIdentifier) { + // export {default}; // missing fromClause + var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause; + this.throwError(message, this.lookahead.value); + } + else { + // export {foo}; + this.consumeSemicolon(); + } + exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(null, specifiers, source)); + } + return exportDeclaration; + }; + return Parser; + }()); + exports.Parser = Parser; + + +/***/ }, +/* 9 */ +/***/ function(module, exports) { + + "use strict"; + // Ensure the condition is true, otherwise throw an error. + // This is only to have a better contract semantic, i.e. another safety net + // to catch a logic error. The condition shall be fulfilled in normal case. + // Do NOT use this to enforce a certain condition on any user input. + Object.defineProperty(exports, "__esModule", { value: true }); + function assert(condition, message) { + /* istanbul ignore if */ + if (!condition) { + throw new Error('ASSERT: ' + message); + } + } + exports.assert = assert; + + +/***/ }, +/* 10 */ +/***/ function(module, exports) { + + "use strict"; + /* tslint:disable:max-classes-per-file */ + Object.defineProperty(exports, "__esModule", { value: true }); + var ErrorHandler = (function () { + function ErrorHandler() { + this.errors = []; + this.tolerant = false; + } + ErrorHandler.prototype.recordError = function (error) { + this.errors.push(error); + }; + ErrorHandler.prototype.tolerate = function (error) { + if (this.tolerant) { + this.recordError(error); + } + else { + throw error; + } + }; + ErrorHandler.prototype.constructError = function (msg, column) { + var error = new Error(msg); + try { + throw error; + } + catch (base) { + /* istanbul ignore else */ + if (Object.create && Object.defineProperty) { + error = Object.create(base); + Object.defineProperty(error, 'column', { value: column }); + } + } + /* istanbul ignore next */ + return error; + }; + ErrorHandler.prototype.createError = function (index, line, col, description) { + var msg = 'Line ' + line + ': ' + description; + var error = this.constructError(msg, col); + error.index = index; + error.lineNumber = line; + error.description = description; + return error; + }; + ErrorHandler.prototype.throwError = function (index, line, col, description) { + throw this.createError(index, line, col, description); + }; + ErrorHandler.prototype.tolerateError = function (index, line, col, description) { + var error = this.createError(index, line, col, description); + if (this.tolerant) { + this.recordError(error); + } + else { + throw error; + } + }; + return ErrorHandler; + }()); + exports.ErrorHandler = ErrorHandler; + + +/***/ }, +/* 11 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + // Error messages should be identical to V8. + exports.Messages = { + BadGetterArity: 'Getter must not have any formal parameters', + BadSetterArity: 'Setter must have exactly one formal parameter', + BadSetterRestParameter: 'Setter function argument must not be a rest parameter', + ConstructorIsAsync: 'Class constructor may not be an async method', + ConstructorSpecialMethod: 'Class constructor may not be an accessor', + DeclarationMissingInitializer: 'Missing initializer in %0 declaration', + DefaultRestParameter: 'Unexpected token =', + DuplicateBinding: 'Duplicate binding %0', + DuplicateConstructor: 'A class may only have one constructor', + DuplicateProtoProperty: 'Duplicate __proto__ fields are not allowed in object literals', + ForInOfLoopInitializer: '%0 loop variable declaration may not have an initializer', + GeneratorInLegacyContext: 'Generator declarations are not allowed in legacy contexts', + IllegalBreak: 'Illegal break statement', + IllegalContinue: 'Illegal continue statement', + IllegalExportDeclaration: 'Unexpected token', + IllegalImportDeclaration: 'Unexpected token', + IllegalLanguageModeDirective: 'Illegal \'use strict\' directive in function with non-simple parameter list', + IllegalReturn: 'Illegal return statement', + InvalidEscapedReservedWord: 'Keyword must not contain escaped characters', + InvalidHexEscapeSequence: 'Invalid hexadecimal escape sequence', + InvalidLHSInAssignment: 'Invalid left-hand side in assignment', + InvalidLHSInForIn: 'Invalid left-hand side in for-in', + InvalidLHSInForLoop: 'Invalid left-hand side in for-loop', + InvalidModuleSpecifier: 'Unexpected token', + InvalidRegExp: 'Invalid regular expression', + LetInLexicalBinding: 'let is disallowed as a lexically bound name', + MissingFromClause: 'Unexpected token', + MultipleDefaultsInSwitch: 'More than one default clause in switch statement', + NewlineAfterThrow: 'Illegal newline after throw', + NoAsAfterImportNamespace: 'Unexpected token', + NoCatchOrFinally: 'Missing catch or finally after try', + ParameterAfterRestParameter: 'Rest parameter must be last formal parameter', + Redeclaration: '%0 \'%1\' has already been declared', + StaticPrototype: 'Classes may not have static property named prototype', + StrictCatchVariable: 'Catch variable may not be eval or arguments in strict mode', + StrictDelete: 'Delete of an unqualified identifier in strict mode.', + StrictFunction: 'In strict mode code, functions can only be declared at top level or inside a block', + StrictFunctionName: 'Function name may not be eval or arguments in strict mode', + StrictLHSAssignment: 'Assignment to eval or arguments is not allowed in strict mode', + StrictLHSPostfix: 'Postfix increment/decrement may not have eval or arguments operand in strict mode', + StrictLHSPrefix: 'Prefix increment/decrement may not have eval or arguments operand in strict mode', + StrictModeWith: 'Strict mode code may not include a with statement', + StrictOctalLiteral: 'Octal literals are not allowed in strict mode.', + StrictParamDupe: 'Strict mode function may not have duplicate parameter names', + StrictParamName: 'Parameter name eval or arguments is not allowed in strict mode', + StrictReservedWord: 'Use of future reserved word in strict mode', + StrictVarName: 'Variable name may not be eval or arguments in strict mode', + TemplateOctalLiteral: 'Octal literals are not allowed in template strings.', + UnexpectedEOS: 'Unexpected end of input', + UnexpectedIdentifier: 'Unexpected identifier', + UnexpectedNumber: 'Unexpected number', + UnexpectedReserved: 'Unexpected reserved word', + UnexpectedString: 'Unexpected string', + UnexpectedTemplate: 'Unexpected quasi %0', + UnexpectedToken: 'Unexpected token %0', + UnexpectedTokenIllegal: 'Unexpected token ILLEGAL', + UnknownLabel: 'Undefined label \'%0\'', + UnterminatedRegExp: 'Invalid regular expression: missing /' + }; + + +/***/ }, +/* 12 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var assert_1 = __webpack_require__(9); + var character_1 = __webpack_require__(4); + var messages_1 = __webpack_require__(11); + function hexValue(ch) { + return '0123456789abcdef'.indexOf(ch.toLowerCase()); + } + function octalValue(ch) { + return '01234567'.indexOf(ch); + } + var Scanner = (function () { + function Scanner(code, handler) { + this.source = code; + this.errorHandler = handler; + this.trackComment = false; + this.isModule = false; + this.length = code.length; + this.index = 0; + this.lineNumber = (code.length > 0) ? 1 : 0; + this.lineStart = 0; + this.curlyStack = []; + } + Scanner.prototype.saveState = function () { + return { + index: this.index, + lineNumber: this.lineNumber, + lineStart: this.lineStart + }; + }; + Scanner.prototype.restoreState = function (state) { + this.index = state.index; + this.lineNumber = state.lineNumber; + this.lineStart = state.lineStart; + }; + Scanner.prototype.eof = function () { + return this.index >= this.length; + }; + Scanner.prototype.throwUnexpectedToken = function (message) { + if (message === void 0) { message = messages_1.Messages.UnexpectedTokenIllegal; } + return this.errorHandler.throwError(this.index, this.lineNumber, this.index - this.lineStart + 1, message); + }; + Scanner.prototype.tolerateUnexpectedToken = function (message) { + if (message === void 0) { message = messages_1.Messages.UnexpectedTokenIllegal; } + this.errorHandler.tolerateError(this.index, this.lineNumber, this.index - this.lineStart + 1, message); + }; + // https://tc39.github.io/ecma262/#sec-comments + Scanner.prototype.skipSingleLineComment = function (offset) { + var comments = []; + var start, loc; + if (this.trackComment) { + comments = []; + start = this.index - offset; + loc = { + start: { + line: this.lineNumber, + column: this.index - this.lineStart - offset + }, + end: {} + }; + } + while (!this.eof()) { + var ch = this.source.charCodeAt(this.index); + ++this.index; + if (character_1.Character.isLineTerminator(ch)) { + if (this.trackComment) { + loc.end = { + line: this.lineNumber, + column: this.index - this.lineStart - 1 + }; + var entry = { + multiLine: false, + slice: [start + offset, this.index - 1], + range: [start, this.index - 1], + loc: loc + }; + comments.push(entry); + } + if (ch === 13 && this.source.charCodeAt(this.index) === 10) { + ++this.index; + } + ++this.lineNumber; + this.lineStart = this.index; + return comments; + } + } + if (this.trackComment) { + loc.end = { + line: this.lineNumber, + column: this.index - this.lineStart + }; + var entry = { + multiLine: false, + slice: [start + offset, this.index], + range: [start, this.index], + loc: loc + }; + comments.push(entry); + } + return comments; + }; + Scanner.prototype.skipMultiLineComment = function () { + var comments = []; + var start, loc; + if (this.trackComment) { + comments = []; + start = this.index - 2; + loc = { + start: { + line: this.lineNumber, + column: this.index - this.lineStart - 2 + }, + end: {} + }; + } + while (!this.eof()) { + var ch = this.source.charCodeAt(this.index); + if (character_1.Character.isLineTerminator(ch)) { + if (ch === 0x0D && this.source.charCodeAt(this.index + 1) === 0x0A) { + ++this.index; + } + ++this.lineNumber; + ++this.index; + this.lineStart = this.index; + } + else if (ch === 0x2A) { + // Block comment ends with '*/'. + if (this.source.charCodeAt(this.index + 1) === 0x2F) { + this.index += 2; + if (this.trackComment) { + loc.end = { + line: this.lineNumber, + column: this.index - this.lineStart + }; + var entry = { + multiLine: true, + slice: [start + 2, this.index - 2], + range: [start, this.index], + loc: loc + }; + comments.push(entry); + } + return comments; + } + ++this.index; + } + else { + ++this.index; + } + } + // Ran off the end of the file - the whole thing is a comment + if (this.trackComment) { + loc.end = { + line: this.lineNumber, + column: this.index - this.lineStart + }; + var entry = { + multiLine: true, + slice: [start + 2, this.index], + range: [start, this.index], + loc: loc + }; + comments.push(entry); + } + this.tolerateUnexpectedToken(); + return comments; + }; + Scanner.prototype.scanComments = function () { + var comments; + if (this.trackComment) { + comments = []; + } + var start = (this.index === 0); + while (!this.eof()) { + var ch = this.source.charCodeAt(this.index); + if (character_1.Character.isWhiteSpace(ch)) { + ++this.index; + } + else if (character_1.Character.isLineTerminator(ch)) { + ++this.index; + if (ch === 0x0D && this.source.charCodeAt(this.index) === 0x0A) { + ++this.index; + } + ++this.lineNumber; + this.lineStart = this.index; + start = true; + } + else if (ch === 0x2F) { + ch = this.source.charCodeAt(this.index + 1); + if (ch === 0x2F) { + this.index += 2; + var comment = this.skipSingleLineComment(2); + if (this.trackComment) { + comments = comments.concat(comment); + } + start = true; + } + else if (ch === 0x2A) { + this.index += 2; + var comment = this.skipMultiLineComment(); + if (this.trackComment) { + comments = comments.concat(comment); + } + } + else { + break; + } + } + else if (start && ch === 0x2D) { + // U+003E is '>' + if ((this.source.charCodeAt(this.index + 1) === 0x2D) && (this.source.charCodeAt(this.index + 2) === 0x3E)) { + // '-->' is a single-line comment + this.index += 3; + var comment = this.skipSingleLineComment(3); + if (this.trackComment) { + comments = comments.concat(comment); + } + } + else { + break; + } + } + else if (ch === 0x3C && !this.isModule) { + if (this.source.slice(this.index + 1, this.index + 4) === '!--') { + this.index += 4; // ` SymbolDef for all variables/functions defined in this scope", + }, + clone: function(deep) { + var node = this._clone(deep); + if (this.enclosed) node.enclosed = this.enclosed.slice(); + if (this.functions) node.functions = this.functions.clone(); + if (this.variables) node.variables = this.variables.clone(); + return node; + }, + pinned: function() { + return this.resolve().pinned(); + }, + resolve: function() { + return this.parent_scope.resolve(); + }, + _validate: function() { + if (this.TYPE == "BlockScope") throw new Error("should not instantiate AST_BlockScope"); + if (this.parent_scope == null) return; + if (!(this.parent_scope instanceof AST_BlockScope)) throw new Error("parent_scope must be AST_BlockScope"); + if (!(this.resolve() instanceof AST_Scope)) throw new Error("must be contained within AST_Scope"); + }, +}, AST_Statement); + +function walk_body(node, visitor) { + node.body.forEach(function(node) { + node.walk(visitor); + }); +} + +var AST_Block = DEFNODE("Block", "body", { + $documentation: "A body of statements (usually braced)", + $propdoc: { + body: "[AST_Statement*] an array of statements" + }, + _equals: function(node) { + return all_equals(this.body, node.body); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + walk_body(node, visitor); + }); + }, + _validate: function() { + if (this.TYPE == "Block") throw new Error("should not instantiate AST_Block"); + this.body.forEach(function(node) { + if (!is_statement(node)) throw new Error("body must contain AST_Statement"); + }); + }, +}, AST_BlockScope); + +var AST_BlockStatement = DEFNODE("BlockStatement", null, { + $documentation: "A block statement", +}, AST_Block); + +var AST_StatementWithBody = DEFNODE("StatementWithBody", "body", { + $documentation: "Base class for all statements that contain one nested body: `For`, `ForIn`, `Do`, `While`, `With`", + $propdoc: { + body: "[AST_Statement] the body; this should always be present, even if it's an AST_EmptyStatement" + }, + _validate: function() { + if (this.TYPE == "StatementWithBody") throw new Error("should not instantiate AST_StatementWithBody"); + if (!is_statement(this.body)) throw new Error("body must be AST_Statement"); + }, +}, AST_BlockScope); + +var AST_LabeledStatement = DEFNODE("LabeledStatement", "label", { + $documentation: "Statement with a label", + $propdoc: { + label: "[AST_Label] a label definition" + }, + _equals: function(node) { + return this.label.equals(node.label) + && this.body.equals(node.body); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.label.walk(visitor); + node.body.walk(visitor); + }); + }, + clone: function(deep) { + var node = this._clone(deep); + if (deep) { + var label = node.label; + var def = this.label; + node.walk(new TreeWalker(function(node) { + if (node instanceof AST_LoopControl) { + if (!node.label || node.label.thedef !== def) return; + node.label.thedef = label; + label.references.push(node); + return true; + } + if (node instanceof AST_Scope) return true; + })); + } + return node; + }, + _validate: function() { + if (!(this.label instanceof AST_Label)) throw new Error("label must be AST_Label"); + }, +}, AST_StatementWithBody); + +var AST_IterationStatement = DEFNODE("IterationStatement", null, { + $documentation: "Internal class. All loops inherit from it.", + _validate: function() { + if (this.TYPE == "IterationStatement") throw new Error("should not instantiate AST_IterationStatement"); + }, +}, AST_StatementWithBody); + +var AST_DWLoop = DEFNODE("DWLoop", "condition", { + $documentation: "Base class for do/while statements", + $propdoc: { + condition: "[AST_Node] the loop condition. Should not be instanceof AST_Statement" + }, + _equals: function(node) { + return this.body.equals(node.body) + && this.condition.equals(node.condition); + }, + _validate: function() { + if (this.TYPE == "DWLoop") throw new Error("should not instantiate AST_DWLoop"); + must_be_expression(this, "condition"); + }, +}, AST_IterationStatement); + +var AST_Do = DEFNODE("Do", null, { + $documentation: "A `do` statement", + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.body.walk(visitor); + node.condition.walk(visitor); + }); + }, +}, AST_DWLoop); + +var AST_While = DEFNODE("While", null, { + $documentation: "A `while` statement", + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.condition.walk(visitor); + node.body.walk(visitor); + }); + }, +}, AST_DWLoop); + +var AST_For = DEFNODE("For", "init condition step", { + $documentation: "A `for` statement", + $propdoc: { + init: "[AST_Node?] the `for` initialization code, or null if empty", + condition: "[AST_Node?] the `for` termination clause, or null if empty", + step: "[AST_Node?] the `for` update clause, or null if empty" + }, + _equals: function(node) { + return prop_equals(this.init, node.init) + && prop_equals(this.condition, node.condition) + && prop_equals(this.step, node.step) + && this.body.equals(node.body); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + if (node.init) node.init.walk(visitor); + if (node.condition) node.condition.walk(visitor); + if (node.step) node.step.walk(visitor); + node.body.walk(visitor); + }); + }, + _validate: function() { + if (this.init != null) { + if (!(this.init instanceof AST_Node)) throw new Error("init must be AST_Node"); + if (is_statement(this.init) && !(this.init instanceof AST_Definitions)) { + throw new Error("init cannot be AST_Statement"); + } + } + if (this.condition != null) must_be_expression(this, "condition"); + if (this.step != null) must_be_expression(this, "step"); + }, +}, AST_IterationStatement); + +var AST_ForEnumeration = DEFNODE("ForEnumeration", "init object", { + $documentation: "Base class for enumeration loops, i.e. `for ... in`, `for ... of` & `for await ... of`", + $propdoc: { + init: "[AST_Node] the assignment target during iteration", + object: "[AST_Node] the object to iterate over" + }, + _equals: function(node) { + return this.init.equals(node.init) + && this.object.equals(node.object) + && this.body.equals(node.body); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.init.walk(visitor); + node.object.walk(visitor); + node.body.walk(visitor); + }); + }, + _validate: function() { + if (this.TYPE == "ForEnumeration") throw new Error("should not instantiate AST_ForEnumeration"); + if (this.init instanceof AST_Definitions) { + if (this.init.definitions.length != 1) throw new Error("init must have single declaration"); + } else { + validate_destructured(this.init, function(node) { + if (!(node instanceof AST_PropAccess || node instanceof AST_SymbolRef)) { + throw new Error("init must be assignable: " + node.TYPE); + } + }); + } + must_be_expression(this, "object"); + }, +}, AST_IterationStatement); + +var AST_ForIn = DEFNODE("ForIn", null, { + $documentation: "A `for ... in` statement", +}, AST_ForEnumeration); + +var AST_ForOf = DEFNODE("ForOf", null, { + $documentation: "A `for ... of` statement", +}, AST_ForEnumeration); + +var AST_ForAwaitOf = DEFNODE("ForAwaitOf", null, { + $documentation: "A `for await ... of` statement", +}, AST_ForOf); + +var AST_With = DEFNODE("With", "expression", { + $documentation: "A `with` statement", + $propdoc: { + expression: "[AST_Node] the `with` expression" + }, + _equals: function(node) { + return this.expression.equals(node.expression) + && this.body.equals(node.body); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.expression.walk(visitor); + node.body.walk(visitor); + }); + }, + _validate: function() { + must_be_expression(this, "expression"); + }, +}, AST_StatementWithBody); + +/* -----[ scope and functions ]----- */ + +var AST_Scope = DEFNODE("Scope", "fn_defs may_call_this uses_eval uses_with", { + $documentation: "Base class for all statements introducing a lambda scope", + $propdoc: { + uses_eval: "[boolean/S] tells whether this scope contains a direct call to the global `eval`", + uses_with: "[boolean/S] tells whether this scope uses the `with` statement", + }, + pinned: function() { + return this.uses_eval || this.uses_with; + }, + resolve: return_this, + _validate: function() { + if (this.TYPE == "Scope") throw new Error("should not instantiate AST_Scope"); + }, +}, AST_Block); + +var AST_Toplevel = DEFNODE("Toplevel", "globals", { + $documentation: "The toplevel scope", + $propdoc: { + globals: "[Dictionary/S] a map of name ---> SymbolDef for all undeclared names", + }, + wrap: function(name) { + var body = this.body; + return parse([ + "(function(exports){'$ORIG';})(typeof ", + name, + "=='undefined'?(", + name, + "={}):", + name, + ");" + ].join(""), { + filename: "wrap=" + JSON.stringify(name) + }).transform(new TreeTransformer(function(node) { + if (node instanceof AST_Directive && node.value == "$ORIG") { + return List.splice(body); + } + })); + }, + enclose: function(args_values) { + if (typeof args_values != "string") args_values = ""; + var index = args_values.indexOf(":"); + if (index < 0) index = args_values.length; + var body = this.body; + return parse([ + "(function(", + args_values.slice(0, index), + '){"$ORIG"})(', + args_values.slice(index + 1), + ")" + ].join(""), { + filename: "enclose=" + JSON.stringify(args_values) + }).transform(new TreeTransformer(function(node) { + if (node instanceof AST_Directive && node.value == "$ORIG") { + return List.splice(body); + } + })); + } +}, AST_Scope); + +var AST_ClassInitBlock = DEFNODE("ClassInitBlock", null, { + $documentation: "Value for `class` static initialization blocks", +}, AST_Scope); + +var AST_Lambda = DEFNODE("Lambda", "argnames length_read rest safe_ids uses_arguments", { + $documentation: "Base class for functions", + $propdoc: { + argnames: "[(AST_DefaultValue|AST_Destructured|AST_SymbolFunarg)*] array of function arguments and/or destructured literals", + length_read: "[boolean/S] whether length property of this function is accessed", + rest: "[(AST_Destructured|AST_SymbolFunarg)?] rest parameter, or null if absent", + uses_arguments: "[boolean|number/S] whether this function accesses the arguments array", + }, + each_argname: function(visit) { + var tw = new TreeWalker(function(node) { + if (node instanceof AST_DefaultValue) { + node.name.walk(tw); + return true; + } + if (node instanceof AST_DestructuredKeyVal) { + node.value.walk(tw); + return true; + } + if (node instanceof AST_SymbolFunarg) visit(node); + }); + this.argnames.forEach(function(argname) { + argname.walk(tw); + }); + if (this.rest) this.rest.walk(tw); + }, + _equals: function(node) { + return prop_equals(this.rest, node.rest) + && prop_equals(this.name, node.name) + && prop_equals(this.value, node.value) + && all_equals(this.argnames, node.argnames) + && all_equals(this.body, node.body); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + if (node.name) node.name.walk(visitor); + node.argnames.forEach(function(argname) { + argname.walk(visitor); + }); + if (node.rest) node.rest.walk(visitor); + walk_body(node, visitor); + }); + }, + _validate: function() { + if (this.TYPE == "Lambda") throw new Error("should not instantiate AST_Lambda"); + this.argnames.forEach(function(node) { + validate_destructured(node, function(node) { + if (!(node instanceof AST_SymbolFunarg)) throw new Error("argnames must be AST_SymbolFunarg[]"); + }, true); + }); + if (this.rest != null) validate_destructured(this.rest, function(node) { + if (!(node instanceof AST_SymbolFunarg)) throw new Error("rest must be AST_SymbolFunarg"); + }); + }, +}, AST_Scope); + +var AST_Accessor = DEFNODE("Accessor", null, { + $documentation: "A getter/setter function", + _validate: function() { + if (this.name != null) throw new Error("name must be null"); + }, +}, AST_Lambda); + +var AST_LambdaExpression = DEFNODE("LambdaExpression", "inlined", { + $documentation: "Base class for function expressions", + $propdoc: { + inlined: "[boolean/S] whether this function has been inlined", + }, + _validate: function() { + if (this.TYPE == "LambdaExpression") throw new Error("should not instantiate AST_LambdaExpression"); + }, +}, AST_Lambda); + +function is_arrow(node) { + return node instanceof AST_Arrow || node instanceof AST_AsyncArrow; +} + +function is_async(node) { + return node instanceof AST_AsyncArrow + || node instanceof AST_AsyncDefun + || node instanceof AST_AsyncFunction + || node instanceof AST_AsyncGeneratorDefun + || node instanceof AST_AsyncGeneratorFunction; +} + +function is_generator(node) { + return node instanceof AST_AsyncGeneratorDefun + || node instanceof AST_AsyncGeneratorFunction + || node instanceof AST_GeneratorDefun + || node instanceof AST_GeneratorFunction; +} + +function walk_lambda(node, tw) { + if (is_arrow(node) && node.value) { + node.value.walk(tw); + } else { + walk_body(node, tw); + } +} + +var AST_Arrow = DEFNODE("Arrow", "value", { + $documentation: "An arrow function expression", + $propdoc: { + value: "[AST_Node?] simple return expression, or null if using function body.", + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.argnames.forEach(function(argname) { + argname.walk(visitor); + }); + if (node.rest) node.rest.walk(visitor); + if (node.value) { + node.value.walk(visitor); + } else { + walk_body(node, visitor); + } + }); + }, + _validate: function() { + if (this.name != null) throw new Error("name must be null"); + if (this.uses_arguments) throw new Error("uses_arguments must be false"); + if (this.value != null) { + must_be_expression(this, "value"); + if (this.body.length) throw new Error("body must be empty if value exists"); + } + }, +}, AST_LambdaExpression); + +var AST_AsyncArrow = DEFNODE("AsyncArrow", "value", { + $documentation: "An asynchronous arrow function expression", + $propdoc: { + value: "[AST_Node?] simple return expression, or null if using function body.", + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.argnames.forEach(function(argname) { + argname.walk(visitor); + }); + if (node.rest) node.rest.walk(visitor); + if (node.value) { + node.value.walk(visitor); + } else { + walk_body(node, visitor); + } + }); + }, + _validate: function() { + if (this.name != null) throw new Error("name must be null"); + if (this.uses_arguments) throw new Error("uses_arguments must be false"); + if (this.value != null) { + must_be_expression(this, "value"); + if (this.body.length) throw new Error("body must be empty if value exists"); + } + }, +}, AST_LambdaExpression); + +var AST_AsyncFunction = DEFNODE("AsyncFunction", "name", { + $documentation: "An asynchronous function expression", + $propdoc: { + name: "[AST_SymbolLambda?] the name of this function, or null if not specified", + }, + _validate: function() { + if (this.name != null) { + if (!(this.name instanceof AST_SymbolLambda)) throw new Error("name must be AST_SymbolLambda"); + } + }, +}, AST_LambdaExpression); + +var AST_AsyncGeneratorFunction = DEFNODE("AsyncGeneratorFunction", "name", { + $documentation: "An asynchronous generator function expression", + $propdoc: { + name: "[AST_SymbolLambda?] the name of this function, or null if not specified", + }, + _validate: function() { + if (this.name != null) { + if (!(this.name instanceof AST_SymbolLambda)) throw new Error("name must be AST_SymbolLambda"); + } + }, +}, AST_LambdaExpression); + +var AST_Function = DEFNODE("Function", "name", { + $documentation: "A function expression", + $propdoc: { + name: "[AST_SymbolLambda?] the name of this function, or null if not specified", + }, + _validate: function() { + if (this.name != null) { + if (!(this.name instanceof AST_SymbolLambda)) throw new Error("name must be AST_SymbolLambda"); + } + }, +}, AST_LambdaExpression); + +var AST_GeneratorFunction = DEFNODE("GeneratorFunction", "name", { + $documentation: "A generator function expression", + $propdoc: { + name: "[AST_SymbolLambda?] the name of this function, or null if not specified", + }, + _validate: function() { + if (this.name != null) { + if (!(this.name instanceof AST_SymbolLambda)) throw new Error("name must be AST_SymbolLambda"); + } + }, +}, AST_LambdaExpression); + +var AST_LambdaDefinition = DEFNODE("LambdaDefinition", "inlined name", { + $documentation: "Base class for function definitions", + $propdoc: { + inlined: "[boolean/S] whether this function has been inlined", + name: "[AST_SymbolDefun] the name of this function", + }, + _validate: function() { + if (this.TYPE == "LambdaDefinition") throw new Error("should not instantiate AST_LambdaDefinition"); + if (!(this.name instanceof AST_SymbolDefun)) throw new Error("name must be AST_SymbolDefun"); + }, +}, AST_Lambda); + +var AST_AsyncDefun = DEFNODE("AsyncDefun", null, { + $documentation: "An asynchronous function definition", +}, AST_LambdaDefinition); + +var AST_AsyncGeneratorDefun = DEFNODE("AsyncGeneratorDefun", null, { + $documentation: "An asynchronous generator function definition", +}, AST_LambdaDefinition); + +var AST_Defun = DEFNODE("Defun", null, { + $documentation: "A function definition", +}, AST_LambdaDefinition); + +var AST_GeneratorDefun = DEFNODE("GeneratorDefun", null, { + $documentation: "A generator function definition", +}, AST_LambdaDefinition); + +/* -----[ classes ]----- */ + +var AST_Class = DEFNODE("Class", "extends name properties", { + $documentation: "Base class for class literals", + $propdoc: { + extends: "[AST_Node?] the super class, or null if not specified", + properties: "[AST_ClassProperty*] array of class properties", + }, + _equals: function(node) { + return prop_equals(this.name, node.name) + && prop_equals(this.extends, node.extends) + && all_equals(this.properties, node.properties); + }, + resolve: function(def_class) { + return def_class ? this : this.parent_scope.resolve(); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + if (node.name) node.name.walk(visitor); + if (node.extends) node.extends.walk(visitor); + node.properties.forEach(function(prop) { + prop.walk(visitor); + }); + }); + }, + _validate: function() { + if (this.TYPE == "Class") throw new Error("should not instantiate AST_Class"); + if (this.extends != null) must_be_expression(this, "extends"); + this.properties.forEach(function(node) { + if (!(node instanceof AST_ClassProperty)) throw new Error("properties must contain AST_ClassProperty"); + }); + }, +}, AST_BlockScope); + +var AST_DefClass = DEFNODE("DefClass", null, { + $documentation: "A class definition", + $propdoc: { + name: "[AST_SymbolDefClass] the name of this class", + }, + _validate: function() { + if (!(this.name instanceof AST_SymbolDefClass)) throw new Error("name must be AST_SymbolDefClass"); + }, +}, AST_Class); + +var AST_ClassExpression = DEFNODE("ClassExpression", null, { + $documentation: "A class expression", + $propdoc: { + name: "[AST_SymbolClass?] the name of this class, or null if not specified", + }, + _validate: function() { + if (this.name != null) { + if (!(this.name instanceof AST_SymbolClass)) throw new Error("name must be AST_SymbolClass"); + } + }, +}, AST_Class); + +var AST_ClassProperty = DEFNODE("ClassProperty", "key private static value", { + $documentation: "Base class for `class` properties", + $propdoc: { + key: "[string|AST_Node?] property name (AST_Node for computed property, null for initialization block)", + private: "[boolean] whether this is a private property", + static: "[boolean] whether this is a static property", + value: "[AST_Node?] property value (AST_Accessor for getters/setters, AST_LambdaExpression for methods, null if not specified for fields)", + }, + _equals: function(node) { + return !this.private == !node.private + && !this.static == !node.static + && prop_equals(this.key, node.key) + && prop_equals(this.value, node.value); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + if (node.key instanceof AST_Node) node.key.walk(visitor); + if (node.value) node.value.walk(visitor); + }); + }, + _validate: function() { + if (this.TYPE == "ClassProperty") throw new Error("should not instantiate AST_ClassProperty"); + if (this instanceof AST_ClassInit) { + if (this.key != null) throw new Error("key must be null"); + } else if (typeof this.key != "string") { + if (!(this.key instanceof AST_Node)) throw new Error("key must be string or AST_Node"); + if (this.private) throw new Error("computed key cannot be private"); + must_be_expression(this, "key"); + } else if (this.private) { + if (!/^#/.test(this.key)) throw new Error("private key must prefix with #"); + } + if (this.value != null) { + if (!(this.value instanceof AST_Node)) throw new Error("value must be AST_Node"); + } + }, +}); + +var AST_ClassField = DEFNODE("ClassField", null, { + $documentation: "A `class` field", + _validate: function() { + if (this.value != null) must_be_expression(this, "value"); + }, +}, AST_ClassProperty); + +var AST_ClassGetter = DEFNODE("ClassGetter", null, { + $documentation: "A `class` getter", + _validate: function() { + if (!(this.value instanceof AST_Accessor)) throw new Error("value must be AST_Accessor"); + }, +}, AST_ClassProperty); + +var AST_ClassSetter = DEFNODE("ClassSetter", null, { + $documentation: "A `class` setter", + _validate: function() { + if (!(this.value instanceof AST_Accessor)) throw new Error("value must be AST_Accessor"); + }, +}, AST_ClassProperty); + +var AST_ClassMethod = DEFNODE("ClassMethod", null, { + $documentation: "A `class` method", + _validate: function() { + if (!(this.value instanceof AST_LambdaExpression)) throw new Error("value must be AST_LambdaExpression"); + if (is_arrow(this.value)) throw new Error("value cannot be AST_Arrow or AST_AsyncArrow"); + if (this.value.name != null) throw new Error("name of class method's lambda must be null"); + }, +}, AST_ClassProperty); + +var AST_ClassInit = DEFNODE("ClassInit", null, { + $documentation: "A `class` static initialization block", + _validate: function() { + if (!this.static) throw new Error("static must be true"); + if (!(this.value instanceof AST_ClassInitBlock)) throw new Error("value must be AST_ClassInitBlock"); + }, + initialize: function() { + this.static = true; + }, +}, AST_ClassProperty); + +/* -----[ JUMPS ]----- */ + +var AST_Jump = DEFNODE("Jump", null, { + $documentation: "Base class for “jumps” (for now that's `return`, `throw`, `break` and `continue`)", + _validate: function() { + if (this.TYPE == "Jump") throw new Error("should not instantiate AST_Jump"); + }, +}, AST_Statement); + +var AST_Exit = DEFNODE("Exit", "value", { + $documentation: "Base class for “exits” (`return` and `throw`)", + $propdoc: { + value: "[AST_Node?] the value returned or thrown by this statement; could be null for AST_Return" + }, + _equals: function(node) { + return prop_equals(this.value, node.value); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + if (node.value) node.value.walk(visitor); + }); + }, + _validate: function() { + if (this.TYPE == "Exit") throw new Error("should not instantiate AST_Exit"); + }, +}, AST_Jump); + +var AST_Return = DEFNODE("Return", null, { + $documentation: "A `return` statement", + _validate: function() { + if (this.value != null) must_be_expression(this, "value"); + }, +}, AST_Exit); + +var AST_Throw = DEFNODE("Throw", null, { + $documentation: "A `throw` statement", + _validate: function() { + must_be_expression(this, "value"); + }, +}, AST_Exit); + +var AST_LoopControl = DEFNODE("LoopControl", "label", { + $documentation: "Base class for loop control statements (`break` and `continue`)", + $propdoc: { + label: "[AST_LabelRef?] the label, or null if none", + }, + _equals: function(node) { + return prop_equals(this.label, node.label); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + if (node.label) node.label.walk(visitor); + }); + }, + _validate: function() { + if (this.TYPE == "LoopControl") throw new Error("should not instantiate AST_LoopControl"); + if (this.label != null) { + if (!(this.label instanceof AST_LabelRef)) throw new Error("label must be AST_LabelRef"); + } + }, +}, AST_Jump); + +var AST_Break = DEFNODE("Break", null, { + $documentation: "A `break` statement" +}, AST_LoopControl); + +var AST_Continue = DEFNODE("Continue", null, { + $documentation: "A `continue` statement" +}, AST_LoopControl); + +/* -----[ IF ]----- */ + +var AST_If = DEFNODE("If", "condition alternative", { + $documentation: "A `if` statement", + $propdoc: { + condition: "[AST_Node] the `if` condition", + alternative: "[AST_Statement?] the `else` part, or null if not present" + }, + _equals: function(node) { + return this.body.equals(node.body) + && this.condition.equals(node.condition) + && prop_equals(this.alternative, node.alternative); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.condition.walk(visitor); + node.body.walk(visitor); + if (node.alternative) node.alternative.walk(visitor); + }); + }, + _validate: function() { + must_be_expression(this, "condition"); + if (this.alternative != null) { + if (!is_statement(this.alternative)) throw new Error("alternative must be AST_Statement"); + } + }, +}, AST_StatementWithBody); + +/* -----[ SWITCH ]----- */ + +var AST_Switch = DEFNODE("Switch", "expression", { + $documentation: "A `switch` statement", + $propdoc: { + expression: "[AST_Node] the `switch` “discriminant”" + }, + _equals: function(node) { + return this.expression.equals(node.expression) + && all_equals(this.body, node.body); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.expression.walk(visitor); + walk_body(node, visitor); + }); + }, + _validate: function() { + must_be_expression(this, "expression"); + this.body.forEach(function(node) { + if (!(node instanceof AST_SwitchBranch)) throw new Error("body must be AST_SwitchBranch[]"); + }); + }, +}, AST_Block); + +var AST_SwitchBranch = DEFNODE("SwitchBranch", null, { + $documentation: "Base class for `switch` branches", + _validate: function() { + if (this.TYPE == "SwitchBranch") throw new Error("should not instantiate AST_SwitchBranch"); + }, +}, AST_Block); + +var AST_Default = DEFNODE("Default", null, { + $documentation: "A `default` switch branch", +}, AST_SwitchBranch); + +var AST_Case = DEFNODE("Case", "expression", { + $documentation: "A `case` switch branch", + $propdoc: { + expression: "[AST_Node] the `case` expression" + }, + _equals: function(node) { + return this.expression.equals(node.expression) + && all_equals(this.body, node.body); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.expression.walk(visitor); + walk_body(node, visitor); + }); + }, + _validate: function() { + must_be_expression(this, "expression"); + }, +}, AST_SwitchBranch); + +/* -----[ EXCEPTIONS ]----- */ + +var AST_Try = DEFNODE("Try", "bcatch bfinally", { + $documentation: "A `try` statement", + $propdoc: { + bcatch: "[AST_Catch?] the catch block, or null if not present", + bfinally: "[AST_Finally?] the finally block, or null if not present" + }, + _equals: function(node) { + return all_equals(this.body, node.body) + && prop_equals(this.bcatch, node.bcatch) + && prop_equals(this.bfinally, node.bfinally); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + walk_body(node, visitor); + if (node.bcatch) node.bcatch.walk(visitor); + if (node.bfinally) node.bfinally.walk(visitor); + }); + }, + _validate: function() { + if (this.bcatch != null) { + if (!(this.bcatch instanceof AST_Catch)) throw new Error("bcatch must be AST_Catch"); + } + if (this.bfinally != null) { + if (!(this.bfinally instanceof AST_Finally)) throw new Error("bfinally must be AST_Finally"); + } + }, +}, AST_Block); + +var AST_Catch = DEFNODE("Catch", "argname", { + $documentation: "A `catch` node; only makes sense as part of a `try` statement", + $propdoc: { + argname: "[(AST_Destructured|AST_SymbolCatch)?] symbol for the exception, or null if not present", + }, + _equals: function(node) { + return prop_equals(this.argname, node.argname) + && all_equals(this.body, node.body); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + if (node.argname) node.argname.walk(visitor); + walk_body(node, visitor); + }); + }, + _validate: function() { + if (this.argname != null) validate_destructured(this.argname, function(node) { + if (!(node instanceof AST_SymbolCatch)) throw new Error("argname must be AST_SymbolCatch"); + }); + }, +}, AST_Block); + +var AST_Finally = DEFNODE("Finally", null, { + $documentation: "A `finally` node; only makes sense as part of a `try` statement" +}, AST_Block); + +/* -----[ VAR ]----- */ + +var AST_Definitions = DEFNODE("Definitions", "definitions", { + $documentation: "Base class for `var` nodes (variable declarations/initializations)", + $propdoc: { + definitions: "[AST_VarDef*] array of variable definitions" + }, + _equals: function(node) { + return all_equals(this.definitions, node.definitions); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.definitions.forEach(function(defn) { + defn.walk(visitor); + }); + }); + }, + _validate: function() { + if (this.TYPE == "Definitions") throw new Error("should not instantiate AST_Definitions"); + if (this.definitions.length < 1) throw new Error("must have at least one definition"); + }, +}, AST_Statement); + +var AST_Const = DEFNODE("Const", null, { + $documentation: "A `const` statement", + _validate: function() { + this.definitions.forEach(function(node) { + if (!(node instanceof AST_VarDef)) throw new Error("definitions must be AST_VarDef[]"); + validate_destructured(node.name, function(node) { + if (!(node instanceof AST_SymbolConst)) throw new Error("name must be AST_SymbolConst"); + }); + }); + }, +}, AST_Definitions); + +var AST_Let = DEFNODE("Let", null, { + $documentation: "A `let` statement", + _validate: function() { + this.definitions.forEach(function(node) { + if (!(node instanceof AST_VarDef)) throw new Error("definitions must be AST_VarDef[]"); + validate_destructured(node.name, function(node) { + if (!(node instanceof AST_SymbolLet)) throw new Error("name must be AST_SymbolLet"); + }); + }); + }, +}, AST_Definitions); + +var AST_Var = DEFNODE("Var", null, { + $documentation: "A `var` statement", + _validate: function() { + this.definitions.forEach(function(node) { + if (!(node instanceof AST_VarDef)) throw new Error("definitions must be AST_VarDef[]"); + validate_destructured(node.name, function(node) { + if (!(node instanceof AST_SymbolVar)) throw new Error("name must be AST_SymbolVar"); + }); + }); + }, +}, AST_Definitions); + +var AST_VarDef = DEFNODE("VarDef", "name value", { + $documentation: "A variable declaration; only appears in a AST_Definitions node", + $propdoc: { + name: "[AST_Destructured|AST_SymbolVar] name of the variable", + value: "[AST_Node?] initializer, or null of there's no initializer", + }, + _equals: function(node) { + return this.name.equals(node.name) + && prop_equals(this.value, node.value); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.name.walk(visitor); + if (node.value) node.value.walk(visitor); + }); + }, + _validate: function() { + if (this.value != null) must_be_expression(this, "value"); + }, +}); + +/* -----[ OTHER ]----- */ + +var AST_ExportDeclaration = DEFNODE("ExportDeclaration", "body", { + $documentation: "An `export` statement", + $propdoc: { + body: "[AST_DefClass|AST_Definitions|AST_LambdaDefinition] the statement to export", + }, + _equals: function(node) { + return this.body.equals(node.body); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.body.walk(visitor); + }); + }, + _validate: function() { + if (!(this.body instanceof AST_DefClass + || this.body instanceof AST_Definitions + || this.body instanceof AST_LambdaDefinition)) { + throw new Error("body must be AST_DefClass, AST_Definitions or AST_LambdaDefinition"); + } + }, +}, AST_Statement); + +var AST_ExportDefault = DEFNODE("ExportDefault", "body", { + $documentation: "An `export default` statement", + $propdoc: { + body: "[AST_Node] the default export", + }, + _equals: function(node) { + return this.body.equals(node.body); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.body.walk(visitor); + }); + }, + _validate: function() { + if (!(this.body instanceof AST_DefClass || this.body instanceof AST_LambdaDefinition)) { + must_be_expression(this, "body"); + } + }, +}, AST_Statement); + +var AST_ExportForeign = DEFNODE("ExportForeign", "aliases keys path", { + $documentation: "An `export ... from '...'` statement", + $propdoc: { + aliases: "[AST_String*] array of aliases to export", + keys: "[AST_String*] array of keys to import", + path: "[AST_String] the path to import module", + }, + _equals: function(node) { + return this.path.equals(node.path) + && all_equals(this.aliases, node.aliases) + && all_equals(this.keys, node.keys); + }, + _validate: function() { + if (this.aliases.length != this.keys.length) { + throw new Error("aliases:key length mismatch: " + this.aliases.length + " != " + this.keys.length); + } + this.aliases.forEach(function(name) { + if (!(name instanceof AST_String)) throw new Error("aliases must contain AST_String"); + }); + this.keys.forEach(function(name) { + if (!(name instanceof AST_String)) throw new Error("keys must contain AST_String"); + }); + if (!(this.path instanceof AST_String)) throw new Error("path must be AST_String"); + }, +}, AST_Statement); + +var AST_ExportReferences = DEFNODE("ExportReferences", "properties", { + $documentation: "An `export { ... }` statement", + $propdoc: { + properties: "[AST_SymbolExport*] array of aliases to export", + }, + _equals: function(node) { + return all_equals(this.properties, node.properties); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.properties.forEach(function(prop) { + prop.walk(visitor); + }); + }); + }, + _validate: function() { + this.properties.forEach(function(prop) { + if (!(prop instanceof AST_SymbolExport)) throw new Error("properties must contain AST_SymbolExport"); + }); + }, +}, AST_Statement); + +var AST_Import = DEFNODE("Import", "all default path properties", { + $documentation: "An `import` statement", + $propdoc: { + all: "[AST_SymbolImport?] the imported namespace, or null if not specified", + default: "[AST_SymbolImport?] the alias for default `export`, or null if not specified", + path: "[AST_String] the path to import module", + properties: "[(AST_SymbolImport*)?] array of aliases, or null if not specified", + }, + _equals: function(node) { + return this.path.equals(node.path) + && prop_equals(this.all, node.all) + && prop_equals(this.default, node.default) + && !this.properties == !node.properties + && (!this.properties || all_equals(this.properties, node.properties)); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + if (node.all) node.all.walk(visitor); + if (node.default) node.default.walk(visitor); + if (node.properties) node.properties.forEach(function(prop) { + prop.walk(visitor); + }); + }); + }, + _validate: function() { + if (this.all != null) { + if (!(this.all instanceof AST_SymbolImport)) throw new Error("all must be AST_SymbolImport"); + if (this.properties != null) throw new Error("cannot import both * and {} in the same statement"); + } + if (this.default != null) { + if (!(this.default instanceof AST_SymbolImport)) throw new Error("default must be AST_SymbolImport"); + if (this.default.key.value !== "") throw new Error("invalid default key: " + this.default.key.value); + } + if (!(this.path instanceof AST_String)) throw new Error("path must be AST_String"); + if (this.properties != null) this.properties.forEach(function(node) { + if (!(node instanceof AST_SymbolImport)) throw new Error("properties must contain AST_SymbolImport"); + }); + }, +}, AST_Statement); + +var AST_DefaultValue = DEFNODE("DefaultValue", "name value", { + $documentation: "A default value declaration", + $propdoc: { + name: "[AST_Destructured|AST_SymbolDeclaration] name of the variable", + value: "[AST_Node] value to assign if variable is `undefined`", + }, + _equals: function(node) { + return this.name.equals(node.name) + && this.value.equals(node.value); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.name.walk(visitor); + node.value.walk(visitor); + }); + }, + _validate: function() { + must_be_expression(this, "value"); + }, +}); + +function must_be_expressions(node, prop, allow_spread, allow_hole) { + node[prop].forEach(function(node) { + validate_expression(node, prop, true, allow_spread, allow_hole); + }); +} + +var AST_Call = DEFNODE("Call", "args expression optional pure terminal", { + $documentation: "A function call expression", + $propdoc: { + args: "[AST_Node*] array of arguments", + expression: "[AST_Node] expression to invoke as function", + optional: "[boolean] whether the expression is optional chaining", + pure: "[boolean/S] marker for side-effect-free call expression", + terminal: "[boolean] whether the chain has ended", + }, + _equals: function(node) { + return !this.optional == !node.optional + && this.expression.equals(node.expression) + && all_equals(this.args, node.args); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.expression.walk(visitor); + node.args.forEach(function(arg) { + arg.walk(visitor); + }); + }); + }, + _validate: function() { + must_be_expression(this, "expression"); + must_be_expressions(this, "args", true); + }, +}); + +var AST_New = DEFNODE("New", null, { + $documentation: "An object instantiation. Derives from a function call since it has exactly the same properties", + _validate: function() { + if (this.optional) throw new Error("optional must be false"); + if (this.terminal) throw new Error("terminal must be false"); + }, +}, AST_Call); + +var AST_Sequence = DEFNODE("Sequence", "expressions", { + $documentation: "A sequence expression (comma-separated expressions)", + $propdoc: { + expressions: "[AST_Node*] array of expressions (at least two)", + }, + _equals: function(node) { + return all_equals(this.expressions, node.expressions); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.expressions.forEach(function(expr) { + expr.walk(visitor); + }); + }); + }, + _validate: function() { + if (this.expressions.length < 2) throw new Error("expressions must contain multiple elements"); + must_be_expressions(this, "expressions"); + }, +}); + +function root_expr(prop) { + while (prop instanceof AST_PropAccess) prop = prop.expression; + return prop; +} + +var AST_PropAccess = DEFNODE("PropAccess", "expression optional property terminal", { + $documentation: "Base class for property access expressions, i.e. `a.foo` or `a[\"foo\"]`", + $propdoc: { + expression: "[AST_Node] the “container” expression", + optional: "[boolean] whether the expression is optional chaining", + property: "[AST_Node|string] the property to access. For AST_Dot this is always a plain string, while for AST_Sub it's an arbitrary AST_Node", + terminal: "[boolean] whether the chain has ended", + }, + _equals: function(node) { + return !this.optional == !node.optional + && prop_equals(this.property, node.property) + && this.expression.equals(node.expression); + }, + get_property: function() { + var p = this.property; + if (p instanceof AST_Constant) return p.value; + if (p instanceof AST_UnaryPrefix && p.operator == "void" && p.expression instanceof AST_Constant) return; + return p; + }, + _validate: function() { + if (this.TYPE == "PropAccess") throw new Error("should not instantiate AST_PropAccess"); + must_be_expression(this, "expression"); + }, +}); + +var AST_Dot = DEFNODE("Dot", "quoted", { + $documentation: "A dotted property access expression", + $propdoc: { + quoted: "[boolean] whether property is transformed from a quoted string", + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.expression.walk(visitor); + }); + }, + _validate: function() { + if (typeof this.property != "string") throw new Error("property must be string"); + }, +}, AST_PropAccess); + +var AST_Sub = DEFNODE("Sub", null, { + $documentation: "Index-style property access, i.e. `a[\"foo\"]`", + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.expression.walk(visitor); + node.property.walk(visitor); + }); + }, + _validate: function() { + must_be_expression(this, "property"); + }, +}, AST_PropAccess); + +var AST_Spread = DEFNODE("Spread", "expression", { + $documentation: "Spread expression in array/object literals or function calls", + $propdoc: { + expression: "[AST_Node] expression to be expanded", + }, + _equals: function(node) { + return this.expression.equals(node.expression); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.expression.walk(visitor); + }); + }, + _validate: function() { + must_be_expression(this, "expression"); + }, +}); + +var AST_Unary = DEFNODE("Unary", "operator expression", { + $documentation: "Base class for unary expressions", + $propdoc: { + operator: "[string] the operator", + expression: "[AST_Node] expression that this unary operator applies to", + }, + _equals: function(node) { + return this.operator == node.operator + && this.expression.equals(node.expression); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.expression.walk(visitor); + }); + }, + _validate: function() { + if (this.TYPE == "Unary") throw new Error("should not instantiate AST_Unary"); + if (typeof this.operator != "string") throw new Error("operator must be string"); + must_be_expression(this, "expression"); + }, +}); + +var AST_UnaryPrefix = DEFNODE("UnaryPrefix", null, { + $documentation: "Unary prefix expression, i.e. `typeof i` or `++i`" +}, AST_Unary); + +var AST_UnaryPostfix = DEFNODE("UnaryPostfix", null, { + $documentation: "Unary postfix expression, i.e. `i++`" +}, AST_Unary); + +var AST_Binary = DEFNODE("Binary", "operator left right", { + $documentation: "Binary expression, i.e. `a + b`", + $propdoc: { + left: "[AST_Node] left-hand side expression", + operator: "[string] the operator", + right: "[AST_Node] right-hand side expression" + }, + _equals: function(node) { + return this.operator == node.operator + && this.left.equals(node.left) + && this.right.equals(node.right); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.left.walk(visitor); + node.right.walk(visitor); + }); + }, + _validate: function() { + if (!(this instanceof AST_Assign)) must_be_expression(this, "left"); + if (typeof this.operator != "string") throw new Error("operator must be string"); + must_be_expression(this, "right"); + }, +}); + +var AST_Conditional = DEFNODE("Conditional", "condition consequent alternative", { + $documentation: "Conditional expression using the ternary operator, i.e. `a ? b : c`", + $propdoc: { + condition: "[AST_Node]", + consequent: "[AST_Node]", + alternative: "[AST_Node]" + }, + _equals: function(node) { + return this.condition.equals(node.condition) + && this.consequent.equals(node.consequent) + && this.alternative.equals(node.alternative); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.condition.walk(visitor); + node.consequent.walk(visitor); + node.alternative.walk(visitor); + }); + }, + _validate: function() { + must_be_expression(this, "condition"); + must_be_expression(this, "consequent"); + must_be_expression(this, "alternative"); + }, +}); + +var AST_Assign = DEFNODE("Assign", null, { + $documentation: "An assignment expression — `a = b + 5`", + _validate: function() { + if (this.operator.indexOf("=") < 0) throw new Error('operator must contain "="'); + if (this.left instanceof AST_Destructured) { + if (this.operator != "=") throw new Error("invalid destructuring operator: " + this.operator); + validate_destructured(this.left, function(node) { + if (!(node instanceof AST_PropAccess || node instanceof AST_SymbolRef)) { + throw new Error("left must be assignable: " + node.TYPE); + } + }); + } else if (!(this.left instanceof AST_Infinity + || this.left instanceof AST_NaN + || this.left instanceof AST_PropAccess && !this.left.optional + || this.left instanceof AST_SymbolRef + || this.left instanceof AST_Undefined)) { + throw new Error("left must be assignable"); + } + }, +}, AST_Binary); + +var AST_Await = DEFNODE("Await", "expression", { + $documentation: "An await expression", + $propdoc: { + expression: "[AST_Node] expression with Promise to resolve on", + }, + _equals: function(node) { + return this.expression.equals(node.expression); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.expression.walk(visitor); + }); + }, + _validate: function() { + must_be_expression(this, "expression"); + }, +}); + +var AST_Yield = DEFNODE("Yield", "expression nested", { + $documentation: "A yield expression", + $propdoc: { + expression: "[AST_Node?] return value for iterator, or null if undefined", + nested: "[boolean] whether to iterate over expression as generator", + }, + _equals: function(node) { + return !this.nested == !node.nested + && prop_equals(this.expression, node.expression); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + if (node.expression) node.expression.walk(visitor); + }); + }, + _validate: function() { + if (this.expression != null) { + must_be_expression(this, "expression"); + } else if (this.nested) { + throw new Error("yield* must contain expression"); + } + }, +}); + +/* -----[ LITERALS ]----- */ + +var AST_Array = DEFNODE("Array", "elements", { + $documentation: "An array literal", + $propdoc: { + elements: "[AST_Node*] array of elements" + }, + _equals: function(node) { + return all_equals(this.elements, node.elements); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.elements.forEach(function(element) { + element.walk(visitor); + }); + }); + }, + _validate: function() { + must_be_expressions(this, "elements", true, true); + }, +}); + +var AST_Destructured = DEFNODE("Destructured", "rest", { + $documentation: "Base class for destructured literal", + $propdoc: { + rest: "[(AST_Destructured|AST_SymbolDeclaration|AST_SymbolRef)?] rest parameter, or null if absent", + }, + _validate: function() { + if (this.TYPE == "Destructured") throw new Error("should not instantiate AST_Destructured"); + }, +}); + +function validate_destructured(node, check, allow_default) { + if (node instanceof AST_DefaultValue && allow_default) return validate_destructured(node.name, check); + if (node instanceof AST_Destructured) { + if (node.rest != null) validate_destructured(node.rest, check); + if (node instanceof AST_DestructuredArray) return node.elements.forEach(function(node) { + if (!(node instanceof AST_Hole)) validate_destructured(node, check, true); + }); + if (node instanceof AST_DestructuredObject) return node.properties.forEach(function(prop) { + validate_destructured(prop.value, check, true); + }); + } + check(node); +} + +var AST_DestructuredArray = DEFNODE("DestructuredArray", "elements", { + $documentation: "A destructured array literal", + $propdoc: { + elements: "[(AST_DefaultValue|AST_Destructured|AST_SymbolDeclaration|AST_SymbolRef)*] array of elements", + }, + _equals: function(node) { + return prop_equals(this.rest, node.rest) + && all_equals(this.elements, node.elements); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.elements.forEach(function(element) { + element.walk(visitor); + }); + if (node.rest) node.rest.walk(visitor); + }); + }, +}, AST_Destructured); + +var AST_DestructuredKeyVal = DEFNODE("DestructuredKeyVal", "key value", { + $documentation: "A key: value destructured property", + $propdoc: { + key: "[string|AST_Node] property name. For computed property this is an AST_Node.", + value: "[AST_DefaultValue|AST_Destructured|AST_SymbolDeclaration|AST_SymbolRef] property value", + }, + _equals: function(node) { + return prop_equals(this.key, node.key) + && this.value.equals(node.value); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + if (node.key instanceof AST_Node) node.key.walk(visitor); + node.value.walk(visitor); + }); + }, + _validate: function() { + if (typeof this.key != "string") { + if (!(this.key instanceof AST_Node)) throw new Error("key must be string or AST_Node"); + must_be_expression(this, "key"); + } + if (!(this.value instanceof AST_Node)) throw new Error("value must be AST_Node"); + }, +}); + +var AST_DestructuredObject = DEFNODE("DestructuredObject", "properties", { + $documentation: "A destructured object literal", + $propdoc: { + properties: "[AST_DestructuredKeyVal*] array of properties", + }, + _equals: function(node) { + return prop_equals(this.rest, node.rest) + && all_equals(this.properties, node.properties); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.properties.forEach(function(prop) { + prop.walk(visitor); + }); + if (node.rest) node.rest.walk(visitor); + }); + }, + _validate: function() { + this.properties.forEach(function(node) { + if (!(node instanceof AST_DestructuredKeyVal)) throw new Error("properties must be AST_DestructuredKeyVal[]"); + }); + }, +}, AST_Destructured); + +var AST_Object = DEFNODE("Object", "properties", { + $documentation: "An object literal", + $propdoc: { + properties: "[(AST_ObjectProperty|AST_Spread)*] array of properties" + }, + _equals: function(node) { + return all_equals(this.properties, node.properties); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + node.properties.forEach(function(prop) { + prop.walk(visitor); + }); + }); + }, + _validate: function() { + this.properties.forEach(function(node) { + if (!(node instanceof AST_ObjectProperty || node instanceof AST_Spread)) { + throw new Error("properties must contain AST_ObjectProperty and/or AST_Spread only"); + } + }); + }, +}); + +var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", { + $documentation: "Base class for literal object properties", + $propdoc: { + key: "[string|AST_Node] property name. For computed property this is an AST_Node.", + value: "[AST_Node] property value. For getters and setters this is an AST_Accessor.", + }, + _equals: function(node) { + return prop_equals(this.key, node.key) + && this.value.equals(node.value); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + if (node.key instanceof AST_Node) node.key.walk(visitor); + node.value.walk(visitor); + }); + }, + _validate: function() { + if (this.TYPE == "ObjectProperty") throw new Error("should not instantiate AST_ObjectProperty"); + if (typeof this.key != "string") { + if (!(this.key instanceof AST_Node)) throw new Error("key must be string or AST_Node"); + must_be_expression(this, "key"); + } + if (!(this.value instanceof AST_Node)) throw new Error("value must be AST_Node"); + }, +}); + +var AST_ObjectKeyVal = DEFNODE("ObjectKeyVal", null, { + $documentation: "A key: value object property", + _validate: function() { + must_be_expression(this, "value"); + }, +}, AST_ObjectProperty); + +var AST_ObjectMethod = DEFNODE("ObjectMethod", null, { + $documentation: "A key(){} object property", + _validate: function() { + if (!(this.value instanceof AST_LambdaExpression)) throw new Error("value must be AST_LambdaExpression"); + if (is_arrow(this.value)) throw new Error("value cannot be AST_Arrow or AST_AsyncArrow"); + if (this.value.name != null) throw new Error("name of object method's lambda must be null"); + }, +}, AST_ObjectKeyVal); + +var AST_ObjectSetter = DEFNODE("ObjectSetter", null, { + $documentation: "An object setter property", + _validate: function() { + if (!(this.value instanceof AST_Accessor)) throw new Error("value must be AST_Accessor"); + }, +}, AST_ObjectProperty); + +var AST_ObjectGetter = DEFNODE("ObjectGetter", null, { + $documentation: "An object getter property", + _validate: function() { + if (!(this.value instanceof AST_Accessor)) throw new Error("value must be AST_Accessor"); + }, +}, AST_ObjectProperty); + +var AST_Symbol = DEFNODE("Symbol", "scope name thedef", { + $documentation: "Base class for all symbols", + $propdoc: { + name: "[string] name of this symbol", + scope: "[AST_Scope/S] the current scope (not necessarily the definition scope)", + thedef: "[SymbolDef/S] the definition of this symbol" + }, + _equals: function(node) { + return this.thedef ? this.thedef === node.thedef : this.name == node.name; + }, + _validate: function() { + if (this.TYPE == "Symbol") throw new Error("should not instantiate AST_Symbol"); + if (typeof this.name != "string") throw new Error("name must be string"); + }, +}); + +var AST_SymbolDeclaration = DEFNODE("SymbolDeclaration", "init", { + $documentation: "A declaration symbol (symbol in var, function name or argument, symbol in catch)", +}, AST_Symbol); + +var AST_SymbolConst = DEFNODE("SymbolConst", null, { + $documentation: "Symbol defining a constant", +}, AST_SymbolDeclaration); + +var AST_SymbolImport = DEFNODE("SymbolImport", "key", { + $documentation: "Symbol defined by an `import` statement", + $propdoc: { + key: "[AST_String] the original `export` name", + }, + _equals: function(node) { + return this.name == node.name + && this.key.equals(node.key); + }, + _validate: function() { + if (!(this.key instanceof AST_String)) throw new Error("key must be AST_String"); + }, +}, AST_SymbolConst); + +var AST_SymbolLet = DEFNODE("SymbolLet", null, { + $documentation: "Symbol defining a lexical-scoped variable", +}, AST_SymbolDeclaration); + +var AST_SymbolVar = DEFNODE("SymbolVar", null, { + $documentation: "Symbol defining a variable", +}, AST_SymbolDeclaration); + +var AST_SymbolFunarg = DEFNODE("SymbolFunarg", "unused", { + $documentation: "Symbol naming a function argument", +}, AST_SymbolVar); + +var AST_SymbolDefun = DEFNODE("SymbolDefun", null, { + $documentation: "Symbol defining a function", +}, AST_SymbolDeclaration); + +var AST_SymbolLambda = DEFNODE("SymbolLambda", null, { + $documentation: "Symbol naming a function expression", +}, AST_SymbolDeclaration); + +var AST_SymbolDefClass = DEFNODE("SymbolDefClass", null, { + $documentation: "Symbol defining a class", +}, AST_SymbolConst); + +var AST_SymbolClass = DEFNODE("SymbolClass", null, { + $documentation: "Symbol naming a class expression", +}, AST_SymbolConst); + +var AST_SymbolCatch = DEFNODE("SymbolCatch", null, { + $documentation: "Symbol naming the exception in catch", +}, AST_SymbolDeclaration); + +var AST_Label = DEFNODE("Label", "references", { + $documentation: "Symbol naming a label (declaration)", + $propdoc: { + references: "[AST_LoopControl*] a list of nodes referring to this label" + }, + initialize: function() { + this.references = []; + this.thedef = this; + }, +}, AST_Symbol); + +var AST_SymbolRef = DEFNODE("SymbolRef", "fixed in_arg redef", { + $documentation: "Reference to some symbol (not definition/declaration)", +}, AST_Symbol); + +var AST_SymbolExport = DEFNODE("SymbolExport", "alias", { + $documentation: "Reference in an `export` statement", + $propdoc: { + alias: "[AST_String] the `export` alias", + }, + _equals: function(node) { + return this.name == node.name + && this.alias.equals(node.alias); + }, + _validate: function() { + if (!(this.alias instanceof AST_String)) throw new Error("alias must be AST_String"); + }, +}, AST_SymbolRef); + +var AST_LabelRef = DEFNODE("LabelRef", null, { + $documentation: "Reference to a label symbol", +}, AST_Symbol); + +var AST_ObjectIdentity = DEFNODE("ObjectIdentity", null, { + $documentation: "Base class for `super` & `this`", + _equals: return_true, + _validate: function() { + if (this.TYPE == "ObjectIdentity") throw new Error("should not instantiate AST_ObjectIdentity"); + }, +}, AST_Symbol); + +var AST_Super = DEFNODE("Super", null, { + $documentation: "The `super` symbol", + _validate: function() { + if (this.name !== "super") throw new Error('name must be "super"'); + }, +}, AST_ObjectIdentity); + +var AST_This = DEFNODE("This", null, { + $documentation: "The `this` symbol", + _validate: function() { + if (this.TYPE == "This" && this.name !== "this") throw new Error('name must be "this"'); + }, +}, AST_ObjectIdentity); + +var AST_NewTarget = DEFNODE("NewTarget", null, { + $documentation: "The `new.target` symbol", + initialize: function() { + this.name = "new.target"; + }, + _validate: function() { + if (this.name !== "new.target") throw new Error('name must be "new.target": ' + this.name); + }, +}, AST_This); + +var AST_Template = DEFNODE("Template", "expressions strings tag", { + $documentation: "A template literal, i.e. tag`str1${expr1}...strN${exprN}strN+1`", + $propdoc: { + expressions: "[AST_Node*] the placeholder expressions", + strings: "[string*] the raw text segments", + tag: "[AST_Node?] tag function, or null if absent", + }, + _equals: function(node) { + return prop_equals(this.tag, node.tag) + && list_equals(this.strings, node.strings) + && all_equals(this.expressions, node.expressions); + }, + walk: function(visitor) { + var node = this; + visitor.visit(node, function() { + if (node.tag) node.tag.walk(visitor); + node.expressions.forEach(function(expr) { + expr.walk(visitor); + }); + }); + }, + _validate: function() { + if (this.expressions.length + 1 != this.strings.length) { + throw new Error("malformed template with " + this.expressions.length + " placeholder(s) but " + this.strings.length + " text segment(s)"); + } + must_be_expressions(this, "expressions"); + this.strings.forEach(function(string) { + if (typeof string != "string") throw new Error("strings must contain string"); + }); + if (this.tag != null) must_be_expression(this, "tag"); + }, +}); + +var AST_Constant = DEFNODE("Constant", null, { + $documentation: "Base class for all constants", + _equals: function(node) { + return this.value === node.value; + }, + _validate: function() { + if (this.TYPE == "Constant") throw new Error("should not instantiate AST_Constant"); + }, +}); + +var AST_String = DEFNODE("String", "quote value", { + $documentation: "A string literal", + $propdoc: { + quote: "[string?] the original quote character", + value: "[string] the contents of this string", + }, + _validate: function() { + if (this.quote != null) { + if (typeof this.quote != "string") throw new Error("quote must be string"); + if (!/^["']$/.test(this.quote)) throw new Error("invalid quote: " + this.quote); + } + if (typeof this.value != "string") throw new Error("value must be string"); + }, +}, AST_Constant); + +var AST_Number = DEFNODE("Number", "value", { + $documentation: "A number literal", + $propdoc: { + value: "[number] the numeric value", + }, + _validate: function() { + if (typeof this.value != "number") throw new Error("value must be number"); + if (!isFinite(this.value)) throw new Error("value must be finite"); + if (this.value < 0) throw new Error("value cannot be negative"); + }, +}, AST_Constant); + +var AST_BigInt = DEFNODE("BigInt", "value", { + $documentation: "A BigInt literal", + $propdoc: { + value: "[string] the numeric representation", + }, + _validate: function() { + if (typeof this.value != "string") throw new Error("value must be string"); + if (this.value[0] == "-") throw new Error("value cannot be negative"); + }, +}, AST_Constant); + +var AST_RegExp = DEFNODE("RegExp", "value", { + $documentation: "A regexp literal", + $propdoc: { + value: "[RegExp] the actual regexp" + }, + _equals: function(node) { + return "" + this.value == "" + node.value; + }, + _validate: function() { + if (!(this.value instanceof RegExp)) throw new Error("value must be RegExp"); + }, +}, AST_Constant); + +var AST_Atom = DEFNODE("Atom", null, { + $documentation: "Base class for atoms", + _equals: return_true, + _validate: function() { + if (this.TYPE == "Atom") throw new Error("should not instantiate AST_Atom"); + }, +}, AST_Constant); + +var AST_Null = DEFNODE("Null", null, { + $documentation: "The `null` atom", + value: null, +}, AST_Atom); + +var AST_NaN = DEFNODE("NaN", null, { + $documentation: "The impossible value", + value: 0/0, +}, AST_Atom); + +var AST_Undefined = DEFNODE("Undefined", null, { + $documentation: "The `undefined` value", + value: function(){}(), +}, AST_Atom); + +var AST_Hole = DEFNODE("Hole", null, { + $documentation: "A hole in an array", + value: function(){}(), +}, AST_Atom); + +var AST_Infinity = DEFNODE("Infinity", null, { + $documentation: "The `Infinity` value", + value: 1/0, +}, AST_Atom); + +var AST_Boolean = DEFNODE("Boolean", null, { + $documentation: "Base class for booleans", + _validate: function() { + if (this.TYPE == "Boolean") throw new Error("should not instantiate AST_Boolean"); + }, +}, AST_Atom); + +var AST_False = DEFNODE("False", null, { + $documentation: "The `false` atom", + value: false, +}, AST_Boolean); + +var AST_True = DEFNODE("True", null, { + $documentation: "The `true` atom", + value: true, +}, AST_Boolean); + +/* -----[ TreeWalker ]----- */ + +function TreeWalker(callback) { + this.callback = callback; + this.directives = Object.create(null); + this.stack = []; +} +TreeWalker.prototype = { + visit: function(node, descend) { + this.push(node); + var done = this.callback(node, descend || noop); + if (!done && descend) descend(); + this.pop(); + }, + parent: function(n) { + return this.stack[this.stack.length - 2 - (n || 0)]; + }, + push: function(node) { + var value; + if (node instanceof AST_Class) { + this.directives = Object.create(this.directives); + value = "use strict"; + } else if (node instanceof AST_Directive) { + value = node.value; + } else if (node instanceof AST_Lambda) { + this.directives = Object.create(this.directives); + } + if (value && !this.directives[value]) this.directives[value] = node; + this.stack.push(node); + }, + pop: function() { + var node = this.stack.pop(); + if (node instanceof AST_Class || node instanceof AST_Lambda) { + this.directives = Object.getPrototypeOf(this.directives); + } + }, + self: function() { + return this.stack[this.stack.length - 1]; + }, + find_parent: function(type) { + var stack = this.stack; + for (var i = stack.length - 1; --i >= 0;) { + var x = stack[i]; + if (x instanceof type) return x; + } + }, + has_directive: function(type) { + var dir = this.directives[type]; + if (dir) return dir; + var node = this.stack[this.stack.length - 1]; + if (node instanceof AST_Scope) { + for (var i = 0; i < node.body.length; ++i) { + var st = node.body[i]; + if (!(st instanceof AST_Directive)) break; + if (st.value == type) return st; + } + } + }, + loopcontrol_target: function(node) { + var stack = this.stack; + if (node.label) for (var i = stack.length; --i >= 0;) { + var x = stack[i]; + if (x instanceof AST_LabeledStatement && x.label.name == node.label.name) + return x.body; + } else for (var i = stack.length; --i >= 0;) { + var x = stack[i]; + if (x instanceof AST_IterationStatement + || node instanceof AST_Break && x instanceof AST_Switch) + return x; + } + }, + in_boolean_context: function() { + for (var drop = true, level = 0, parent, self = this.self(); parent = this.parent(level++); self = parent) { + if (parent instanceof AST_Binary) switch (parent.operator) { + case "&&": + case "||": + if (parent.left === self) drop = false; + continue; + default: + return false; + } + if (parent instanceof AST_Conditional) { + if (parent.condition === self) return true; + continue; + } + if (parent instanceof AST_DWLoop) return parent.condition === self; + if (parent instanceof AST_For) return parent.condition === self; + if (parent instanceof AST_If) return parent.condition === self; + if (parent instanceof AST_Return) { + if (parent.in_bool) return true; + while (parent = this.parent(level++)) { + if (parent instanceof AST_Lambda) { + if (parent.name) return false; + parent = this.parent(level++); + if (parent.TYPE != "Call") return false; + break; + } + } + } + if (parent instanceof AST_Sequence) { + if (parent.tail_node() === self) continue; + return drop ? "d" : true; + } + if (parent instanceof AST_SimpleStatement) return drop ? "d" : true; + if (parent instanceof AST_UnaryPrefix) return parent.operator == "!"; + return false; + } + } +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/compress.js b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/compress.js new file mode 100644 index 0000000000000000000000000000000000000000..f0d470fa706b6c3217584e714af358be7fd4f146 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/compress.js @@ -0,0 +1,14650 @@ +/*********************************************************************** + + A JavaScript tokenizer / parser / beautifier / compressor. + https://github.com/mishoo/UglifyJS + + -------------------------------- (C) --------------------------------- + + Author: Mihai Bazon + + http://mihai.bazon.net/blog + + Distributed under the BSD license: + + Copyright 2012 (c) Mihai Bazon + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + * Redistributions of source code must retain the above + copyright notice, this list of conditions and the following + disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials + provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY + EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, + OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF + THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + SUCH DAMAGE. + + ***********************************************************************/ + +"use strict"; + +function Compressor(options, false_by_default) { + if (!(this instanceof Compressor)) + return new Compressor(options, false_by_default); + TreeTransformer.call(this, this.before, this.after); + this.options = defaults(options, { + annotations : !false_by_default, + arguments : !false_by_default, + arrows : !false_by_default, + assignments : !false_by_default, + awaits : !false_by_default, + booleans : !false_by_default, + collapse_vars : !false_by_default, + comparisons : !false_by_default, + conditionals : !false_by_default, + dead_code : !false_by_default, + default_values : !false_by_default, + directives : !false_by_default, + drop_console : false, + drop_debugger : !false_by_default, + evaluate : !false_by_default, + expression : false, + functions : !false_by_default, + global_defs : false, + hoist_exports : !false_by_default, + hoist_funs : false, + hoist_props : !false_by_default, + hoist_vars : false, + ie : false, + if_return : !false_by_default, + imports : !false_by_default, + inline : !false_by_default, + join_vars : !false_by_default, + keep_fargs : false_by_default, + keep_fnames : false, + keep_infinity : false, + loops : !false_by_default, + merge_vars : !false_by_default, + module : false, + negate_iife : !false_by_default, + objects : !false_by_default, + optional_chains : !false_by_default, + passes : 1, + properties : !false_by_default, + pure_funcs : null, + pure_getters : !false_by_default && "strict", + reduce_funcs : !false_by_default, + reduce_vars : !false_by_default, + rests : !false_by_default, + sequences : !false_by_default, + side_effects : !false_by_default, + spreads : !false_by_default, + strings : !false_by_default, + switches : !false_by_default, + templates : !false_by_default, + top_retain : null, + toplevel : !!(options && !options["expression"] && options["top_retain"]), + typeofs : !false_by_default, + unsafe : false, + unsafe_comps : false, + unsafe_Function : false, + unsafe_math : false, + unsafe_proto : false, + unsafe_regexp : false, + unsafe_undefined: false, + unused : !false_by_default, + varify : !false_by_default, + webkit : false, + yields : !false_by_default, + }, true); + var evaluate = this.options["evaluate"]; + this.eval_threshold = /eager/.test(evaluate) ? 1 / 0 : +evaluate; + var global_defs = this.options["global_defs"]; + if (typeof global_defs == "object") for (var key in global_defs) { + if (/^@/.test(key) && HOP(global_defs, key)) { + global_defs[key.slice(1)] = parse(global_defs[key], { expression: true }); + } + } + if (this.options["inline"] === true) this.options["inline"] = 4; + this.drop_fargs = this.options["keep_fargs"] ? return_false : function(lambda, parent) { + if (lambda.length_read) return false; + var name = lambda.name; + if (!name) return parent && parent.TYPE == "Call" && parent.expression === lambda; + if (name.fixed_value() !== lambda) return false; + var def = name.definition(); + if (def.direct_access) return false; + var escaped = def.escaped; + return escaped && escaped.depth != 1; + }; + if (this.options["module"]) this.directives["use strict"] = true; + var pure_funcs = this.options["pure_funcs"]; + if (typeof pure_funcs == "function") { + this.pure_funcs = pure_funcs; + } else if (typeof pure_funcs == "string") { + this.pure_funcs = function(node) { + var expr; + if (node instanceof AST_Call) { + expr = node.expression; + } else if (node instanceof AST_Template) { + expr = node.tag; + } + return !(expr && pure_funcs === expr.print_to_string()); + }; + } else if (Array.isArray(pure_funcs)) { + this.pure_funcs = function(node) { + var expr; + if (node instanceof AST_Call) { + expr = node.expression; + } else if (node instanceof AST_Template) { + expr = node.tag; + } + return !(expr && member(expr.print_to_string(), pure_funcs)); + }; + } else { + this.pure_funcs = return_true; + } + var sequences = this.options["sequences"]; + this.sequences_limit = sequences == 1 ? 800 : sequences | 0; + var top_retain = this.options["top_retain"]; + if (top_retain instanceof RegExp) { + this.top_retain = function(def) { + return top_retain.test(def.name); + }; + } else if (typeof top_retain == "function") { + this.top_retain = top_retain; + } else if (top_retain) { + if (typeof top_retain == "string") { + top_retain = top_retain.split(/,/); + } + this.top_retain = function(def) { + return member(def.name, top_retain); + }; + } + var toplevel = this.options["toplevel"]; + this.toplevel = typeof toplevel == "string" ? { + funcs: /funcs/.test(toplevel), + vars: /vars/.test(toplevel) + } : { + funcs: toplevel, + vars: toplevel + }; +} + +Compressor.prototype = new TreeTransformer(function(node, descend) { + if (node._squeezed) return node; + var is_scope = node instanceof AST_Scope; + if (is_scope) { + if (this.option("arrows") && is_arrow(node) && node.value) { + node.body = [ node.first_statement() ]; + node.value = null; + } + node.hoist_properties(this); + node.hoist_declarations(this); + node.process_returns(this); + } + // Before https://github.com/mishoo/UglifyJS/pull/1602 AST_Node.optimize() + // would call AST_Node.transform() if a different instance of AST_Node is + // produced after OPT(). + // This corrupts TreeWalker.stack, which cause AST look-ups to malfunction. + // Migrate and defer all children's AST_Node.transform() to below, which + // will now happen after this parent AST_Node has been properly substituted + // thus gives a consistent AST snapshot. + descend(node, this); + // Existing code relies on how AST_Node.optimize() worked, and omitting the + // following replacement call would result in degraded efficiency of both + // output and performance. + descend(node, this); + var opt = node.optimize(this); + if (is_scope) { + if (opt === node && !this.has_directive("use asm") && !opt.pinned()) { + opt.drop_unused(this); + if (opt.merge_variables(this)) opt.drop_unused(this); + descend(opt, this); + } + if (this.option("arrows") && is_arrow(opt) && opt.body.length == 1) { + var stat = opt.body[0]; + if (stat instanceof AST_Return) { + opt.body.length = 0; + opt.value = stat.value; + } + } + } + if (opt === node) opt._squeezed = true; + return opt; +}); +Compressor.prototype.option = function(key) { + return this.options[key]; +}; +Compressor.prototype.exposed = function(def) { + if (def.exported) return true; + if (def.undeclared) return true; + if (!(def.global || def.scope.resolve() instanceof AST_Toplevel)) return false; + var toplevel = this.toplevel; + return !all(def.orig, function(sym) { + return toplevel[sym instanceof AST_SymbolDefun ? "funcs" : "vars"]; + }); +}; +Compressor.prototype.compress = function(node) { + node = node.resolve_defines(this); + node.hoist_exports(this); + if (this.option("expression")) node.process_expression(true); + var merge_vars = this.options.merge_vars; + var passes = +this.options.passes || 1; + var min_count = 1 / 0; + var stopping = false; + var mangle = { ie: this.option("ie") }; + for (var pass = 0; pass < passes; pass++) { + node.figure_out_scope(mangle); + if (pass > 0 || this.option("reduce_vars")) + node.reset_opt_flags(this); + this.options.merge_vars = merge_vars && (stopping || pass == passes - 1); + node = node.transform(this); + if (passes > 1) { + var count = 0; + node.walk(new TreeWalker(function() { + count++; + })); + AST_Node.info("pass {pass}: last_count: {min_count}, count: {count}", { + pass: pass, + min_count: min_count, + count: count, + }); + if (count < min_count) { + min_count = count; + stopping = false; + } else if (stopping) { + break; + } else { + stopping = true; + } + } + } + if (this.option("expression")) node.process_expression(false); + return node; +}; + +(function(OPT) { + OPT(AST_Node, function(self) { + return self; + }); + + AST_Toplevel.DEFMETHOD("hoist_exports", function(compressor) { + if (!compressor.option("hoist_exports")) return; + var body = this.body, props = []; + for (var i = 0; i < body.length; i++) { + var stat = body[i]; + if (stat instanceof AST_ExportDeclaration) { + body[i] = stat = stat.body; + if (stat instanceof AST_Definitions) { + stat.definitions.forEach(function(defn) { + defn.name.match_symbol(export_symbol, true); + }); + } else { + export_symbol(stat.name); + } + } else if (stat instanceof AST_ExportReferences) { + body.splice(i--, 1); + [].push.apply(props, stat.properties); + } + } + if (props.length) body.push(make_node(AST_ExportReferences, this, { properties: props })); + + function export_symbol(sym) { + if (!(sym instanceof AST_SymbolDeclaration)) return; + var node = make_node(AST_SymbolExport, sym); + node.alias = make_node(AST_String, node, { value: node.name }); + props.push(node); + } + }); + + AST_Scope.DEFMETHOD("process_expression", function(insert, transform) { + var self = this; + var tt = new TreeTransformer(function(node) { + if (insert) { + if (node instanceof AST_Directive) node = make_node(AST_SimpleStatement, node, { + body: make_node(AST_String, node), + }); + if (node instanceof AST_SimpleStatement) { + return transform ? transform(node) : make_node(AST_Return, node, { value: node.body }); + } + } else if (node instanceof AST_Return) { + if (transform) return transform(node); + var value = node.value; + if (value instanceof AST_String) return make_node(AST_Directive, value); + return make_node(AST_SimpleStatement, node, { + body: value || make_node(AST_UnaryPrefix, node, { + operator: "void", + expression: make_node(AST_Number, node, { value: 0 }), + }), + }); + } + if (node instanceof AST_Block) { + if (node instanceof AST_Lambda) { + if (node !== self) return node; + } else if (insert === "awaits" && node instanceof AST_Try) { + if (node.bfinally) return node; + } + for (var index = node.body.length; --index >= 0;) { + var stat = node.body[index]; + if (!is_declaration(stat, true)) { + node.body[index] = stat.transform(tt); + break; + } + } + } else if (node instanceof AST_If) { + node.body = node.body.transform(tt); + if (node.alternative) node.alternative = node.alternative.transform(tt); + } else if (node instanceof AST_With) { + node.body = node.body.transform(tt); + } + return node; + }); + self.transform(tt); + }); + AST_Toplevel.DEFMETHOD("unwrap_expression", function() { + var self = this; + switch (self.body.length) { + case 0: + return make_node(AST_UnaryPrefix, self, { + operator: "void", + expression: make_node(AST_Number, self, { value: 0 }), + }); + case 1: + var stat = self.body[0]; + if (stat instanceof AST_Directive) return make_node(AST_String, stat); + if (stat instanceof AST_SimpleStatement) return stat.body; + default: + return make_node(AST_Call, self, { + expression: make_node(AST_Function, self, { + argnames: [], + body: self.body, + }).init_vars(self, self), + args: [], + }); + } + }); + AST_Node.DEFMETHOD("wrap_expression", function() { + var self = this; + if (!is_statement(self)) self = make_node(AST_SimpleStatement, self, { body: self }); + if (!(self instanceof AST_Toplevel)) self = make_node(AST_Toplevel, self, { body: [ self ] }); + return self; + }); + + function read_property(obj, node) { + var key = node.get_property(); + if (key instanceof AST_Node) return; + var value; + if (obj instanceof AST_Array) { + var elements = obj.elements; + if (key == "length") return make_node_from_constant(elements.length, obj); + if (typeof key == "number" && key in elements) value = elements[key]; + } else if (obj instanceof AST_Lambda) { + if (key == "length") { + obj.length_read = true; + return make_node_from_constant(obj.argnames.length, obj); + } + } else if (obj instanceof AST_Object) { + key = "" + key; + var props = obj.properties; + for (var i = props.length; --i >= 0;) { + var prop = props[i]; + if (!can_hoist_property(prop)) return; + if (!value && props[i].key === key) value = props[i].value; + } + } + return value instanceof AST_SymbolRef && value.fixed_value() || value; + } + + function is_read_only_fn(value, name) { + if (value instanceof AST_Boolean) return native_fns.Boolean[name]; + if (value instanceof AST_Number) return native_fns.Number[name]; + if (value instanceof AST_String) return native_fns.String[name]; + if (name == "valueOf") return false; + if (value instanceof AST_Array) return native_fns.Array[name]; + if (value instanceof AST_Lambda) return native_fns.Function[name]; + if (value instanceof AST_Object) return native_fns.Object[name]; + if (value instanceof AST_RegExp) return native_fns.RegExp[name] && !value.value.global; + } + + function is_modified(compressor, tw, node, value, level, immutable, recursive) { + var parent = tw.parent(level); + if (compressor.option("unsafe") && parent instanceof AST_Dot && is_read_only_fn(value, parent.property)) { + return; + } + var lhs = is_lhs(node, parent); + if (lhs) return lhs; + if (level == 0 && value && value.is_constant()) return; + if (parent instanceof AST_Array) return is_modified(compressor, tw, parent, parent, level + 1); + if (parent instanceof AST_Assign) switch (parent.operator) { + case "=": + return is_modified(compressor, tw, parent, value, level + 1, immutable, recursive); + case "&&=": + case "||=": + case "??=": + return is_modified(compressor, tw, parent, parent, level + 1); + default: + return; + } + if (parent instanceof AST_Binary) { + if (!lazy_op[parent.operator]) return; + return is_modified(compressor, tw, parent, parent, level + 1); + } + if (parent instanceof AST_Call) { + return !immutable + && parent.expression === node + && !parent.is_expr_pure(compressor) + && (!(value instanceof AST_LambdaExpression) || !(parent instanceof AST_New) && value.contains_this()); + } + if (parent instanceof AST_Conditional) { + if (parent.condition === node) return; + return is_modified(compressor, tw, parent, parent, level + 1); + } + if (parent instanceof AST_ForEnumeration) return parent.init === node; + if (parent instanceof AST_ObjectKeyVal) { + if (parent.value !== node) return; + var obj = tw.parent(level + 1); + return is_modified(compressor, tw, obj, obj, level + 2); + } + if (parent instanceof AST_PropAccess) { + if (parent.expression !== node) return; + var prop = read_property(value, parent); + return (!immutable || recursive) && is_modified(compressor, tw, parent, prop, level + 1); + } + if (parent instanceof AST_Sequence) { + if (parent.tail_node() !== node) return; + return is_modified(compressor, tw, parent, value, level + 1, immutable, recursive); + } + } + + function is_lambda(node) { + return node instanceof AST_Class || node instanceof AST_Lambda; + } + + function safe_for_extends(node) { + return node instanceof AST_Class || node instanceof AST_Defun || node instanceof AST_Function; + } + + function is_arguments(def) { + return def.name == "arguments" && def.scope.uses_arguments; + } + + function cross_scope(def, sym) { + do { + if (def === sym) return false; + if (sym instanceof AST_Scope) return true; + } while (sym = sym.parent_scope); + } + + function can_drop_symbol(ref, compressor, keep_lambda) { + var def = ref.redef || ref.definition(); + if (ref.in_arg && is_funarg(def)) return false; + return all(def.orig, function(sym) { + if (sym instanceof AST_SymbolConst || sym instanceof AST_SymbolLet) { + if (sym instanceof AST_SymbolImport) return true; + return compressor && safe_from_tdz(compressor, sym); + } + return !(keep_lambda && sym instanceof AST_SymbolLambda); + }); + } + + function has_escaped(d, scope, node, parent) { + if (parent instanceof AST_Assign) return parent.operator == "=" && parent.right === node; + if (parent instanceof AST_Call) return parent.expression !== node || parent instanceof AST_New; + if (parent instanceof AST_ClassField) return parent.value === node && !parent.static; + if (parent instanceof AST_Exit) return parent.value === node && scope.resolve() !== d.scope.resolve(); + if (parent instanceof AST_VarDef) return parent.value === node; + } + + function make_ref(ref, fixed) { + var node = make_node(AST_SymbolRef, ref); + node.fixed = fixed || make_node(AST_Undefined, ref); + return node; + } + + function replace_ref(resolve, fixed) { + return function(node) { + var ref = resolve(node); + var node = make_ref(ref, fixed); + var def = ref.definition(); + def.references.push(node); + def.replaced++; + return node; + }; + } + + var RE_POSITIVE_INTEGER = /^(0|[1-9][0-9]*)$/; + (function(def) { + def(AST_Node, noop); + + function reset_def(tw, compressor, def) { + def.assignments = 0; + def.bool_return = 0; + def.cross_loop = false; + def.direct_access = false; + def.drop_return = 0; + def.escaped = []; + def.first_decl = null; + def.fixed = !def.const_redefs + && !def.scope.pinned() + && !compressor.exposed(def) + && !(def.init instanceof AST_LambdaExpression && def.init !== def.scope) + && def.init; + def.reassigned = 0; + def.recursive_refs = 0; + def.references = []; + def.single_use = undefined; + } + + function reset_block_variables(tw, compressor, scope) { + scope.variables.each(function(def) { + reset_def(tw, compressor, def); + }); + } + + function reset_variables(tw, compressor, scope) { + scope.fn_defs = []; + scope.variables.each(function(def) { + reset_def(tw, compressor, def); + var init = def.init; + if (init instanceof AST_LambdaDefinition) { + scope.fn_defs.push(init); + init.safe_ids = null; + } + if (def.fixed === null) { + def.safe_ids = tw.safe_ids; + mark(tw, def); + } else if (def.fixed) { + tw.loop_ids[def.id] = tw.in_loop; + mark(tw, def); + } + }); + scope.may_call_this = function() { + scope.may_call_this = scope.contains_this() ? return_true : return_false; + }; + if (scope.uses_arguments) scope.each_argname(function(node) { + node.definition().last_ref = false; + }); + if (compressor.option("ie")) scope.variables.each(function(def) { + var d = def.orig[0].definition(); + if (d !== def) d.fixed = false; + }); + } + + function safe_to_visit(tw, fn) { + var marker = fn.safe_ids; + return marker === undefined || marker === tw.safe_ids; + } + + function walk_fn_def(tw, fn) { + var was_scanning = tw.fn_scanning; + tw.fn_scanning = fn; + fn.walk(tw); + tw.fn_scanning = was_scanning; + } + + function revisit_fn_def(tw, fn) { + fn.enclosed.forEach(function(d) { + if (fn.variables.get(d.name) === d) return; + if (safe_to_read(tw, d)) return; + d.single_use = false; + var fixed = d.fixed; + if (typeof fixed == "function") fixed = fixed(); + if (fixed instanceof AST_Lambda) { + var safe_ids = fixed.safe_ids; + switch (safe_ids) { + case null: + case false: + return; + default: + if (safe_ids && safe_ids.seq !== tw.safe_ids.seq) return; + } + } + d.fixed = false; + }); + } + + function mark_fn_def(tw, def, fn) { + var marker = fn.safe_ids; + if (marker === undefined) return; + if (marker === false) return; + if (fn.parent_scope.resolve().may_call_this === return_true) { + if (member(fn, tw.fn_visited)) revisit_fn_def(tw, fn); + } else if (marker) { + var visited = member(fn, tw.fn_visited); + if (marker === tw.safe_ids) { + if (!visited) walk_fn_def(tw, fn); + } else if (visited) { + revisit_fn_def(tw, fn); + } else { + fn.safe_ids = false; + } + } else if (tw.fn_scanning && tw.fn_scanning !== def.scope.resolve()) { + fn.safe_ids = false; + } else { + fn.safe_ids = tw.safe_ids; + walk_fn_def(tw, fn); + } + } + + function pop_scope(tw, scope) { + pop(tw); + var fn_defs = scope.fn_defs; + fn_defs.forEach(function(fn) { + fn.safe_ids = tw.safe_ids; + walk_fn_def(tw, fn); + }); + fn_defs.forEach(function(fn) { + fn.safe_ids = undefined; + }); + scope.fn_defs = undefined; + scope.may_call_this = undefined; + } + + function push(tw, sequential, conditional) { + var defined_ids = Object.create(tw.defined_ids); + if (!sequential || conditional) defined_ids.seq = Object.create(null); + tw.defined_ids = defined_ids; + var safe_ids = Object.create(tw.safe_ids); + if (!sequential) safe_ids.seq = {}; + if (conditional) safe_ids.cond = true; + tw.safe_ids = safe_ids; + } + + function pop(tw) { + tw.defined_ids = Object.getPrototypeOf(tw.defined_ids); + tw.safe_ids = Object.getPrototypeOf(tw.safe_ids); + } + + function access(tw, def) { + var seq = tw.defined_ids.seq; + tw.defined_ids[def.id] = seq; + seq[def.id] = true; + } + + function assign(tw, def) { + var seq = tw.defined_ids.seq; + tw.assigned_ids[def.id] = seq; + seq[def.id] = false; + } + + function safe_to_access(tw, def) { + var seq = tw.defined_ids.seq; + var defined = tw.defined_ids[def.id]; + if (defined !== seq) return false; + if (!defined[def.id]) return false; + var assigned = tw.assigned_ids[def.id]; + return !assigned || assigned === seq; + } + + function mark(tw, def) { + tw.safe_ids[def.id] = {}; + } + + function push_ref(def, ref) { + def.references.push(ref); + if (def.last_ref !== false) def.last_ref = ref; + } + + function safe_to_read(tw, def) { + if (def.single_use == "m") return false; + var safe = tw.safe_ids[def.id]; + if (safe) { + var in_order = HOP(tw.safe_ids, def.id); + if (!in_order) { + var seq = tw.safe_ids.seq; + if (!safe.read) { + safe.read = seq; + } else if (safe.read !== seq) { + safe.read = true; + } + } + if (def.fixed == null) { + if (is_arguments(def)) return false; + if (def.global && def.name == "arguments") return false; + tw.loop_ids[def.id] = null; + def.fixed = make_node(AST_Undefined, def.orig[0]); + if (in_order) def.safe_ids = undefined; + return true; + } + return !safe.assign || safe.assign === tw.safe_ids; + } + return def.fixed instanceof AST_LambdaDefinition; + } + + function safe_to_assign(tw, def, declare) { + if (!declare) { + if (is_funarg(def) && def.scope.uses_arguments && !tw.has_directive("use strict")) return false; + if (!all(def.orig, function(sym) { + return !(sym instanceof AST_SymbolConst); + })) return false; + } + if (def.fixed === undefined) return declare || all(def.orig, function(sym) { + return !(sym instanceof AST_SymbolLet); + }); + if (def.fixed === false || def.fixed === 0) return false; + var safe = tw.safe_ids[def.id]; + if (def.safe_ids) { + def.safe_ids[def.id] = false; + def.safe_ids = undefined; + return def.fixed === null || HOP(tw.safe_ids, def.id) && !safe.read; + } + if (!HOP(tw.safe_ids, def.id)) { + if (!safe) return false; + if (safe.read || tw.in_loop) { + var scope = tw.find_parent(AST_BlockScope); + if (scope instanceof AST_Class) return false; + if (def.scope.resolve() !== scope.resolve()) return false; + } + safe.assign = safe.assign && safe.assign !== tw.safe_ids ? true : tw.safe_ids; + } + if (def.fixed != null && safe.read) { + if (safe.read !== tw.safe_ids.seq) return false; + if (tw.loop_ids[def.id] !== tw.in_loop) return false; + } + return safe_to_read(tw, def) && all(def.orig, function(sym) { + return !(sym instanceof AST_SymbolLambda); + }); + } + + function ref_once(compressor, def) { + return compressor.option("unused") + && !def.scope.pinned() + && def.single_use !== false + && def.references.length - def.recursive_refs == 1 + && !(is_funarg(def) && def.scope.uses_arguments); + } + + function is_immutable(value) { + if (!value) return false; + if (value instanceof AST_Assign) { + var op = value.operator; + return op == "=" ? is_immutable(value.right) : !lazy_op[op.slice(0, -1)]; + } + if (value instanceof AST_Sequence) return is_immutable(value.tail_node()); + return value.is_constant() || is_lambda(value) || value instanceof AST_ObjectIdentity; + } + + function value_in_use(node, parent) { + if (parent instanceof AST_Array) return true; + if (parent instanceof AST_Binary) return lazy_op[parent.operator]; + if (parent instanceof AST_Conditional) return parent.condition !== node; + if (parent instanceof AST_Sequence) return parent.tail_node() === node; + if (parent instanceof AST_Spread) return true; + } + + function mark_escaped(tw, d, scope, node, value, level, depth) { + var parent = tw.parent(level); + if (value && value.is_constant()) return; + if (has_escaped(d, scope, node, parent)) { + d.escaped.push(parent); + if (depth > 1 && !(value && value.is_constant_expression(scope))) depth = 1; + if (!d.escaped.depth || d.escaped.depth > depth) d.escaped.depth = depth; + if (d.scope.resolve() !== scope.resolve()) d.escaped.cross_scope = true; + if (d.fixed) d.fixed.escaped = d.escaped; + return; + } else if (value_in_use(node, parent)) { + mark_escaped(tw, d, scope, parent, parent, level + 1, depth); + } else if (parent instanceof AST_ObjectKeyVal && parent.value === node) { + var obj = tw.parent(level + 1); + mark_escaped(tw, d, scope, obj, obj, level + 2, depth); + } else if (parent instanceof AST_PropAccess && parent.expression === node) { + value = read_property(value, parent); + mark_escaped(tw, d, scope, parent, value, level + 1, depth + 1); + if (value) return; + } + if (level > 0) return; + if (parent instanceof AST_Call && parent.expression === node) return; + if (parent instanceof AST_Sequence && parent.tail_node() !== node) return; + if (parent instanceof AST_SimpleStatement) return; + if (parent instanceof AST_Unary && !unary_side_effects[parent.operator]) return; + d.direct_access = true; + if (d.fixed) d.fixed.direct_access = true; + } + + function mark_assignment_to_arguments(node) { + if (!(node instanceof AST_Sub)) return; + var expr = node.expression; + if (!(expr instanceof AST_SymbolRef)) return; + var def = expr.definition(); + if (!is_arguments(def)) return; + var key = node.property; + if (key.is_constant()) key = key.value; + if (!(key instanceof AST_Node) && !RE_POSITIVE_INTEGER.test(key)) return; + def.reassigned++; + (key instanceof AST_Node ? def.scope.argnames : [ def.scope.argnames[key] ]).forEach(function(argname) { + if (argname instanceof AST_SymbolFunarg) argname.definition().fixed = false; + }); + } + + function make_fixed(save, fn) { + var prev_save, prev_value; + return function() { + var current = save(); + if (prev_save !== current) { + prev_save = current; + prev_value = fn(current); + } + return prev_value; + }; + } + + function make_fixed_default(compressor, node, save) { + var prev_save, prev_seq; + return function() { + if (prev_seq === node) return node; + var current = save(); + var ev = fuzzy_eval(compressor, current, true); + if (ev instanceof AST_Node) { + prev_seq = node; + } else if (prev_save !== current) { + prev_save = current; + prev_seq = ev === undefined ? make_sequence(node, [ current, node.value ]) : current; + } + return prev_seq; + }; + } + + function scan_declaration(tw, compressor, lhs, fixed, visit) { + var scanner = new TreeWalker(function(node) { + if (node instanceof AST_DefaultValue) { + reset_flags(node); + push(tw, true, true); + node.value.walk(tw); + pop(tw); + var save = fixed; + if (save) fixed = make_fixed_default(compressor, node, save); + node.name.walk(scanner); + fixed = save; + return true; + } + if (node instanceof AST_DestructuredArray) { + reset_flags(node); + var save = fixed; + node.elements.forEach(function(node, index) { + if (node instanceof AST_Hole) return reset_flags(node); + if (save) fixed = make_fixed(save, function(value) { + return make_node(AST_Sub, node, { + expression: value, + property: make_node(AST_Number, node, { value: index }), + }); + }); + node.walk(scanner); + }); + if (node.rest) { + var fixed_node; + if (save) fixed = compressor.option("rests") && make_fixed(save, function(value) { + if (!(value instanceof AST_Array)) return node; + for (var i = 0, len = node.elements.length; i < len; i++) { + if (value.elements[i] instanceof AST_Spread) return node; + } + if (!fixed_node) fixed_node = make_node(AST_Array, node, {}); + fixed_node.elements = value.elements.slice(len); + return fixed_node; + }); + node.rest.walk(scanner); + } + fixed = save; + return true; + } + if (node instanceof AST_DestructuredObject) { + reset_flags(node); + var save = fixed; + node.properties.forEach(function(node) { + reset_flags(node); + if (node.key instanceof AST_Node) { + push(tw); + node.key.walk(tw); + pop(tw); + } + if (save) fixed = make_fixed(save, function(value) { + var key = node.key; + var type = AST_Sub; + if (typeof key == "string") { + if (is_identifier_string(key)) { + type = AST_Dot; + } else { + key = make_node_from_constant(key, node); + } + } + return make_node(type, node, { + expression: value, + property: key, + }); + }); + node.value.walk(scanner); + }); + if (node.rest) { + fixed = false; + node.rest.walk(scanner); + } + fixed = save; + return true; + } + visit(node, fixed, function() { + var save_len = tw.stack.length; + for (var i = 0, len = scanner.stack.length - 1; i < len; i++) { + tw.stack.push(scanner.stack[i]); + } + node.walk(tw); + tw.stack.length = save_len; + }); + return true; + }); + lhs.walk(scanner); + } + + function reduce_iife(tw, descend, compressor) { + var fn = this; + fn.inlined = false; + var iife = tw.parent(); + var sequential = !is_async(fn) && !is_generator(fn); + var hit = !sequential; + var aborts = false; + fn.walk(new TreeWalker(function(node) { + if (hit) return aborts = true; + if (node instanceof AST_Return) return hit = true; + if (node instanceof AST_Scope && node !== fn) return true; + })); + if (aborts) push(tw, sequential); + reset_variables(tw, compressor, fn); + // Virtually turn IIFE parameters into variable definitions: + // (function(a,b) {...})(c,d) ---> (function() {var a=c,b=d; ...})() + // So existing transformation rules can work on them. + var safe = !fn.uses_arguments || tw.has_directive("use strict"); + fn.argnames.forEach(function(argname, i) { + var value = iife.args[i]; + scan_declaration(tw, compressor, argname, function() { + var j = fn.argnames.indexOf(argname); + var arg = j < 0 ? value : iife.args[j]; + if (arg instanceof AST_Sequence && arg.expressions.length < 2) arg = arg.expressions[0]; + return arg || make_node(AST_Undefined, iife); + }, visit); + }); + var rest = fn.rest, fixed_node; + if (rest) scan_declaration(tw, compressor, rest, compressor.option("rests") && function() { + if (fn.rest !== rest) return rest; + if (!fixed_node) fixed_node = make_node(AST_Array, fn, {}); + fixed_node.elements = iife.args.slice(fn.argnames.length); + return fixed_node; + }, visit); + walk_lambda(fn, tw); + var defined_ids = tw.defined_ids; + var safe_ids = tw.safe_ids; + pop_scope(tw, fn); + if (!aborts) { + tw.defined_ids = defined_ids; + tw.safe_ids = safe_ids; + } + return true; + + function visit(node, fixed) { + var d = node.definition(); + if (!d.first_decl && d.references.length == 0) d.first_decl = node; + if (fixed && safe && d.fixed === undefined) { + mark(tw, d); + tw.loop_ids[d.id] = tw.in_loop; + d.fixed = fixed; + d.fixed.assigns = [ node ]; + } else { + d.fixed = false; + } + } + } + + def(AST_Assign, function(tw, descend, compressor) { + var node = this; + var left = node.left; + var right = node.right; + var ld = left instanceof AST_SymbolRef && left.definition(); + var scan = ld || left instanceof AST_Destructured; + switch (node.operator) { + case "=": + if (left.equals(right) && !left.has_side_effects(compressor)) { + right.walk(tw); + walk_prop(left); + return true; + } + if (ld && right instanceof AST_LambdaExpression) { + walk_assign(); + right.parent_scope.resolve().fn_defs.push(right); + right.safe_ids = null; + if (!ld.fixed || !node.write_only || tw.safe_ids.cond) mark_fn_def(tw, ld, right); + return true; + } + if (scan) { + right.walk(tw); + walk_assign(); + return true; + } + mark_assignment_to_arguments(left); + return; + case "&&=": + case "||=": + case "??=": + var lazy = true; + default: + if (!scan) { + mark_assignment_to_arguments(left); + return walk_lazy(); + } + assign(tw, ld); + ld.assignments++; + var fixed = ld.fixed; + if (is_modified(compressor, tw, node, node, 0)) { + ld.fixed = false; + return walk_lazy(); + } + var safe = safe_to_read(tw, ld); + if (lazy) push(tw, true, true); + right.walk(tw); + if (lazy) pop(tw); + if (safe && !left.in_arg && safe_to_assign(tw, ld)) { + push_ref(ld, left); + mark(tw, ld); + if (ld.single_use) ld.single_use = false; + left.fixed = ld.fixed = function() { + return make_node(AST_Binary, node, { + operator: node.operator.slice(0, -1), + left: make_ref(left, fixed), + right: node.right, + }); + }; + left.fixed.assigns = !fixed || !fixed.assigns ? [ ld.orig[0] ] : fixed.assigns.slice(); + left.fixed.assigns.push(node); + left.fixed.to_binary = replace_ref(function(node) { + return node.left; + }, fixed); + } else { + left.walk(tw); + ld.fixed = false; + } + return true; + } + + function walk_prop(lhs) { + reset_flags(lhs); + if (lhs instanceof AST_Dot) { + walk_prop(lhs.expression); + } else if (lhs instanceof AST_Sub) { + walk_prop(lhs.expression); + lhs.property.walk(tw); + } else if (lhs instanceof AST_SymbolRef) { + var d = lhs.definition(); + push_ref(d, lhs); + if (d.fixed) { + lhs.fixed = d.fixed; + if (lhs.fixed.assigns) { + lhs.fixed.assigns.push(node); + } else { + lhs.fixed.assigns = [ node ]; + } + } + } else { + lhs.walk(tw); + } + } + + function walk_assign() { + var recursive = ld && recursive_ref(tw, ld); + var modified = is_modified(compressor, tw, node, right, 0, is_immutable(right), recursive); + scan_declaration(tw, compressor, left, function() { + return node.right; + }, function(sym, fixed, walk) { + if (!(sym instanceof AST_SymbolRef)) { + mark_assignment_to_arguments(sym); + walk(); + return; + } + var d = sym.definition(); + assign(tw, d); + d.assignments++; + if (!fixed || sym.in_arg || !safe_to_assign(tw, d)) { + walk(); + d.fixed = false; + } else { + push_ref(d, sym); + mark(tw, d); + if (left instanceof AST_Destructured + || d.orig.length == 1 && d.orig[0] instanceof AST_SymbolDefun) { + d.single_use = false; + } + tw.loop_ids[d.id] = tw.in_loop; + d.fixed = modified ? 0 : fixed; + sym.fixed = fixed; + sym.fixed.assigns = [ node ]; + mark_escaped(tw, d, sym.scope, node, right, 0, 1); + } + }); + } + + function walk_lazy() { + if (!lazy) return; + left.walk(tw); + push(tw, true, true); + right.walk(tw); + pop(tw); + return true; + } + }); + def(AST_Binary, function(tw) { + if (!lazy_op[this.operator]) return; + this.left.walk(tw); + push(tw, true, true); + this.right.walk(tw); + pop(tw); + return true; + }); + def(AST_BlockScope, function(tw, descend, compressor) { + reset_block_variables(tw, compressor, this); + }); + def(AST_Call, function(tw) { + var node = this; + var exp = node.expression; + if (exp instanceof AST_LambdaExpression) { + var iife = is_iife_single(node); + node.args.forEach(function(arg) { + arg.walk(tw); + if (arg instanceof AST_Spread) iife = false; + }); + if (iife) exp.reduce_vars = reduce_iife; + exp.walk(tw); + if (iife) delete exp.reduce_vars; + return true; + } + if (node.TYPE == "Call") switch (tw.in_boolean_context()) { + case "d": + var drop = true; + case true: + mark_refs(exp, drop); + } + exp.walk(tw); + var optional = node.optional; + if (optional) push(tw, true, true); + node.args.forEach(function(arg) { + arg.walk(tw); + }); + if (optional) pop(tw); + var fixed = exp instanceof AST_SymbolRef && exp.fixed_value(); + if (fixed instanceof AST_Lambda) { + mark_fn_def(tw, exp.definition(), fixed); + } else { + tw.defined_ids.seq = {}; + tw.find_parent(AST_Scope).may_call_this(); + } + return true; + + function mark_refs(node, drop) { + if (node instanceof AST_Assign) { + if (node.operator != "=") return; + mark_refs(node.left, drop); + mark_refs(node.right, drop); + } else if (node instanceof AST_Binary) { + if (!lazy_op[node.operator]) return; + mark_refs(node.left, drop); + mark_refs(node.right, drop); + } else if (node instanceof AST_Conditional) { + mark_refs(node.consequent, drop); + mark_refs(node.alternative, drop); + } else if (node instanceof AST_SymbolRef) { + var def = node.definition(); + def.bool_return++; + if (drop) def.drop_return++; + } + } + }); + def(AST_Class, function(tw, descend, compressor) { + var node = this; + reset_block_variables(tw, compressor, node); + if (node.extends) node.extends.walk(tw); + var props = node.properties.filter(function(prop) { + reset_flags(prop); + if (prop.key instanceof AST_Node) { + tw.push(prop); + prop.key.walk(tw); + tw.pop(); + } + return prop.value; + }); + if (node.name) { + var d = node.name.definition(); + var parent = tw.parent(); + if (parent instanceof AST_ExportDeclaration || parent instanceof AST_ExportDefault) d.single_use = false; + if (safe_to_assign(tw, d, true)) { + mark(tw, d); + tw.loop_ids[d.id] = tw.in_loop; + d.fixed = function() { + return node; + }; + d.fixed.assigns = [ node ]; + if (!is_safe_lexical(d)) d.single_use = false; + } else { + d.fixed = false; + } + } + props.forEach(function(prop) { + tw.push(prop); + if (!prop.static || is_static_field_or_init(prop) && prop.value.contains_this()) { + push(tw); + prop.value.walk(tw); + pop(tw); + } else { + prop.value.walk(tw); + } + tw.pop(); + }); + return true; + }); + def(AST_ClassInitBlock, function(tw, descend, compressor) { + var node = this; + push(tw, true); + reset_variables(tw, compressor, node); + descend(); + pop_scope(tw, node); + return true; + }); + def(AST_Conditional, function(tw) { + this.condition.walk(tw); + push(tw, true, true); + this.consequent.walk(tw); + pop(tw); + push(tw, true, true); + this.alternative.walk(tw); + pop(tw); + return true; + }); + def(AST_DefaultValue, function(tw) { + push(tw, true, true); + this.value.walk(tw); + pop(tw); + this.name.walk(tw); + return true; + }); + def(AST_Do, function(tw) { + var save_loop = tw.in_loop; + tw.in_loop = this; + push(tw); + this.body.walk(tw); + if (has_loop_control(this, tw.parent())) { + pop(tw); + push(tw); + } + this.condition.walk(tw); + pop(tw); + tw.in_loop = save_loop; + return true; + }); + def(AST_Dot, function(tw, descend) { + descend(); + var node = this; + var expr = node.expression; + if (!node.optional) { + while (expr instanceof AST_Assign && expr.operator == "=") { + var lhs = expr.left; + if (lhs instanceof AST_SymbolRef) access(tw, lhs.definition()); + expr = expr.right; + } + if (expr instanceof AST_SymbolRef) access(tw, expr.definition()); + } + return true; + }); + def(AST_For, function(tw, descend, compressor) { + var node = this; + reset_block_variables(tw, compressor, node); + if (node.init) node.init.walk(tw); + var save_loop = tw.in_loop; + tw.in_loop = node; + push(tw); + if (node.condition) node.condition.walk(tw); + node.body.walk(tw); + if (node.step) { + if (has_loop_control(node, tw.parent())) { + pop(tw); + push(tw); + } + node.step.walk(tw); + } + pop(tw); + tw.in_loop = save_loop; + return true; + }); + def(AST_ForEnumeration, function(tw, descend, compressor) { + var node = this; + reset_block_variables(tw, compressor, node); + node.object.walk(tw); + var save_loop = tw.in_loop; + tw.in_loop = node; + push(tw); + var init = node.init; + if (init instanceof AST_Definitions) { + init.definitions[0].name.mark_symbol(function(node) { + if (node instanceof AST_SymbolDeclaration) { + var def = node.definition(); + def.assignments++; + def.fixed = false; + } + }, tw); + } else if (init instanceof AST_Destructured || init instanceof AST_SymbolRef) { + init.mark_symbol(function(node) { + if (node instanceof AST_SymbolRef) { + var def = node.definition(); + push_ref(def, node); + def.assignments++; + if (!node.is_immutable()) def.fixed = false; + } + }, tw); + } else { + init.walk(tw); + } + node.body.walk(tw); + pop(tw); + tw.in_loop = save_loop; + return true; + }); + def(AST_If, function(tw) { + this.condition.walk(tw); + push(tw, true, true); + this.body.walk(tw); + pop(tw); + if (this.alternative) { + push(tw, true, true); + this.alternative.walk(tw); + pop(tw); + } + return true; + }); + def(AST_LabeledStatement, function(tw) { + push(tw, true); + this.body.walk(tw); + pop(tw); + return true; + }); + def(AST_Lambda, function(tw, descend, compressor) { + var fn = this; + if (!safe_to_visit(tw, fn)) return true; + if (!push_uniq(tw.fn_visited, fn)) return true; + fn.inlined = false; + push(tw); + reset_variables(tw, compressor, fn); + descend(); + pop_scope(tw, fn); + if (fn.name) mark_escaped(tw, fn.name.definition(), fn, fn.name, fn, 0, 1); + return true; + }); + def(AST_LambdaDefinition, function(tw, descend, compressor) { + var fn = this; + var def = fn.name.definition(); + if (!safe_to_trim(fn)) def.fixed = false; + var parent = tw.parent(); + if (parent instanceof AST_ExportDeclaration || parent instanceof AST_ExportDefault) def.single_use = false; + if (!safe_to_visit(tw, fn)) return true; + if (!push_uniq(tw.fn_visited, fn)) return true; + fn.inlined = false; + push(tw); + reset_variables(tw, compressor, fn); + descend(); + pop_scope(tw, fn); + return true; + }); + def(AST_Sub, function(tw, descend) { + var node = this; + var expr = node.expression; + if (node.optional) { + expr.walk(tw); + push(tw, true, true); + node.property.walk(tw); + pop(tw); + } else { + descend(); + while (expr instanceof AST_Assign && expr.operator == "=") { + var lhs = expr.left; + if (lhs instanceof AST_SymbolRef) access(tw, lhs.definition()); + expr = expr.right; + } + if (expr instanceof AST_SymbolRef) access(tw, expr.definition()); + } + return true; + }); + def(AST_Switch, function(tw, descend, compressor) { + var node = this; + reset_block_variables(tw, compressor, node); + node.expression.walk(tw); + var first = true; + node.body.forEach(function(branch) { + if (branch instanceof AST_Default) return; + branch.expression.walk(tw); + if (first) { + first = false; + push(tw, true, true); + } + }); + if (!first) pop(tw); + walk_body(node, tw); + return true; + }); + def(AST_SwitchBranch, function(tw) { + push(tw, true, true); + walk_body(this, tw); + pop(tw); + return true; + }); + def(AST_SymbolCatch, function() { + var d = this.definition(); + if (!d.first_decl && d.references.length == 0) d.first_decl = this; + d.fixed = false; + }); + def(AST_SymbolDeclaration, function() { + var d = this.definition(); + if (!d.first_decl && d.references.length == 0) d.first_decl = this; + }); + def(AST_SymbolDefun, function() { + var d = this.definition(); + if (!d.first_decl && d.references.length == 0) d.first_decl = this; + if (d.orig.length > 1 && d.scope.resolve() !== this.scope) d.fixed = false; + }); + def(AST_SymbolImport, function() { + var d = this.definition(); + d.first_decl = this; + d.fixed = false; + }); + def(AST_SymbolRef, function(tw, descend, compressor) { + var ref = this; + var d = ref.definition(); + var fixed = d.fixed || d.last_ref && d.last_ref.fixed; + push_ref(d, ref); + if (safe_to_access(tw, d)) ref.defined = true; + if (d.references.length == 1 && !d.fixed && d.orig[0] instanceof AST_SymbolDefun) { + tw.loop_ids[d.id] = tw.in_loop; + } + var recursive = recursive_ref(tw, d); + if (recursive) recursive.enclosed.forEach(function(def) { + if (d === def) return; + if (def.scope.resolve() === recursive) return; + var assigns = def.fixed && def.fixed.assigns; + if (!assigns) return; + if (assigns[assigns.length - 1] instanceof AST_VarDef) return; + var safe = tw.safe_ids[def.id]; + if (!safe) return; + safe.assign = true; + }); + if (d.single_use == "m" && d.fixed) { + d.fixed = 0; + d.single_use = false; + } + switch (d.fixed) { + case 0: + if (!safe_to_read(tw, d)) d.fixed = false; + case false: + var redef = d.redefined(); + if (redef && cross_scope(d.scope, ref.scope)) redef.single_use = false; + break; + case undefined: + d.fixed = false; + break; + default: + if (!safe_to_read(tw, d)) { + d.fixed = false; + break; + } + if (ref.in_arg && d.orig[0] instanceof AST_SymbolLambda) ref.fixed = d.scope; + var value = ref.fixed_value(); + if (recursive) { + d.recursive_refs++; + } else if (value && ref_once(compressor, d)) { + d.in_loop = tw.loop_ids[d.id] !== tw.in_loop; + d.single_use = is_lambda(value) + && !value.pinned() + && (!d.in_loop || tw.parent() instanceof AST_Call) + || !d.in_loop + && d.scope === ref.scope.resolve() + && value.is_constant_expression(); + } else { + d.single_use = false; + } + if (is_modified(compressor, tw, ref, value, 0, is_immutable(value), recursive)) { + if (d.single_use) { + d.single_use = "m"; + } else { + d.fixed = 0; + } + } + if (d.fixed && tw.loop_ids[d.id] !== tw.in_loop) d.cross_loop = true; + mark_escaped(tw, d, ref.scope, ref, value, 0, 1); + break; + } + if (!ref.fixed) ref.fixed = d.fixed === 0 ? fixed : d.fixed; + if (!value && fixed) value = fixed instanceof AST_Node ? fixed : fixed(); + if (!(value instanceof AST_Lambda)) return; + if (d.fixed) { + var parent = tw.parent(); + if (parent instanceof AST_Call && parent.expression === ref) return; + } + mark_fn_def(tw, d, value); + }); + def(AST_Template, function(tw) { + var node = this; + var tag = node.tag; + if (!tag) return; + if (tag instanceof AST_LambdaExpression) { + node.expressions.forEach(function(exp) { + exp.walk(tw); + }); + tag.walk(tw); + return true; + } + tag.walk(tw); + node.expressions.forEach(function(exp) { + exp.walk(tw); + }); + var fixed = tag instanceof AST_SymbolRef && tag.fixed_value(); + if (fixed instanceof AST_Lambda) { + mark_fn_def(tw, tag.definition(), fixed); + } else { + tw.find_parent(AST_Scope).may_call_this(); + } + return true; + }); + def(AST_Toplevel, function(tw, descend, compressor) { + var node = this; + node.globals.each(function(def) { + reset_def(tw, compressor, def); + }); + push(tw, true); + reset_variables(tw, compressor, node); + descend(); + pop_scope(tw, node); + return true; + }); + def(AST_Try, function(tw, descend, compressor) { + var node = this; + reset_block_variables(tw, compressor, node); + push(tw, true); + walk_body(node, tw); + pop(tw); + if (node.bcatch) { + push(tw, true, true); + node.bcatch.walk(tw); + pop(tw); + } + if (node.bfinally) node.bfinally.walk(tw); + return true; + }); + def(AST_Unary, function(tw) { + var node = this; + if (!UNARY_POSTFIX[node.operator]) return; + var exp = node.expression; + if (!(exp instanceof AST_SymbolRef)) { + mark_assignment_to_arguments(exp); + return; + } + var d = exp.definition(); + d.assignments++; + var fixed = d.fixed; + if (safe_to_read(tw, d) && !exp.in_arg && safe_to_assign(tw, d)) { + push_ref(d, exp); + mark(tw, d); + if (d.single_use) d.single_use = false; + d.fixed = function() { + return make_node(AST_Binary, node, { + operator: node.operator.slice(0, -1), + left: make_node(AST_UnaryPrefix, node, { + operator: "+", + expression: make_ref(exp, fixed), + }), + right: make_node(AST_Number, node, { value: 1 }), + }); + }; + d.fixed.assigns = fixed && fixed.assigns ? fixed.assigns.slice() : []; + d.fixed.assigns.push(node); + if (node instanceof AST_UnaryPrefix) { + exp.fixed = d.fixed; + } else { + exp.fixed = function() { + return make_node(AST_UnaryPrefix, node, { + operator: "+", + expression: make_ref(exp, fixed), + }); + }; + exp.fixed.assigns = fixed && fixed.assigns; + exp.fixed.to_prefix = replace_ref(function(node) { + return node.expression; + }, d.fixed); + } + } else { + exp.walk(tw); + d.fixed = false; + } + return true; + }); + def(AST_VarDef, function(tw, descend, compressor) { + var node = this; + var value = node.value; + if (value instanceof AST_LambdaExpression && node.name instanceof AST_SymbolDeclaration) { + walk_defn(); + value.parent_scope.resolve().fn_defs.push(value); + value.safe_ids = null; + var ld = node.name.definition(); + if (!ld.fixed) mark_fn_def(tw, ld, value); + } else if (value) { + value.walk(tw); + walk_defn(); + } else if (tw.parent() instanceof AST_Let) { + walk_defn(); + } else { + node.name.walk(tw); + } + return true; + + function walk_defn() { + scan_declaration(tw, compressor, node.name, function() { + return node.value || make_node(AST_Undefined, node); + }, function(name, fixed) { + var d = name.definition(); + assign(tw, d); + if (!d.first_decl && d.references.length == 0) d.first_decl = name; + if (fixed && safe_to_assign(tw, d, true)) { + mark(tw, d); + tw.loop_ids[d.id] = tw.in_loop; + d.fixed = fixed; + d.fixed.assigns = [ node ]; + if (name instanceof AST_SymbolConst && d.redefined() + || !(can_drop_symbol(name) || is_safe_lexical(d))) { + d.single_use = false; + } + } else { + d.fixed = false; + } + }); + } + }); + def(AST_While, function(tw, descend) { + var save_loop = tw.in_loop; + tw.in_loop = this; + push(tw); + descend(); + pop(tw); + tw.in_loop = save_loop; + return true; + }); + })(function(node, func) { + node.DEFMETHOD("reduce_vars", func); + }); + + function reset_flags(node) { + node._squeezed = false; + node._optimized = false; + node.single_use = false; + if (node instanceof AST_BlockScope) node._var_names = undefined; + if (node instanceof AST_SymbolRef) node.fixed = undefined; + } + + AST_Toplevel.DEFMETHOD("reset_opt_flags", function(compressor) { + var tw = new TreeWalker(compressor.option("reduce_vars") ? function(node, descend) { + reset_flags(node); + return node.reduce_vars(tw, descend, compressor); + } : reset_flags); + // Side-effect tracking on sequential property access + tw.assigned_ids = Object.create(null); + tw.defined_ids = Object.create(null); + tw.defined_ids.seq = {}; + // Flow control for visiting lambda definitions + tw.fn_scanning = null; + tw.fn_visited = []; + // Record the loop body in which `AST_SymbolDeclaration` is first encountered + tw.in_loop = null; + tw.loop_ids = Object.create(null); + // Stack of look-up tables to keep track of whether a `SymbolDef` has been + // properly assigned before use: + // - `push()` & `pop()` when visiting conditional branches + // - backup & restore via `save_ids` when visiting out-of-order sections + tw.safe_ids = Object.create(null); + tw.safe_ids.seq = {}; + this.walk(tw); + }); + + AST_Symbol.DEFMETHOD("fixed_value", function(ref_only) { + var def = this.definition(); + var fixed = def.fixed; + if (fixed) { + if (this.fixed) fixed = this.fixed; + return (fixed instanceof AST_Node ? fixed : fixed()).tail_node(); + } + fixed = fixed === 0 && this.fixed; + if (!fixed) return fixed; + var value = (fixed instanceof AST_Node ? fixed : fixed()).tail_node(); + if (ref_only && def.escaped.depth != 1 && is_object(value, true)) return value; + if (value.is_constant()) return value; + }); + + AST_SymbolRef.DEFMETHOD("is_immutable", function() { + var def = this.redef || this.definition(); + if (!(def.orig[0] instanceof AST_SymbolLambda)) return false; + if (def.orig.length == 1) return true; + if (!this.in_arg) return false; + return !(def.orig[1] instanceof AST_SymbolFunarg); + }); + + AST_Node.DEFMETHOD("convert_symbol", noop); + function convert_destructured(type, process) { + return this.transform(new TreeTransformer(function(node, descend) { + if (node instanceof AST_DefaultValue) { + node = node.clone(); + node.name = node.name.transform(this); + return node; + } + if (node instanceof AST_Destructured) { + node = node.clone(); + descend(node, this); + return node; + } + if (node instanceof AST_DestructuredKeyVal) { + node = node.clone(); + node.value = node.value.transform(this); + return node; + } + return node.convert_symbol(type, process); + })); + } + AST_DefaultValue.DEFMETHOD("convert_symbol", convert_destructured); + AST_Destructured.DEFMETHOD("convert_symbol", convert_destructured); + function convert_symbol(type, process) { + var node = make_node(type, this); + return process(node, this) || node; + } + AST_SymbolDeclaration.DEFMETHOD("convert_symbol", convert_symbol); + AST_SymbolRef.DEFMETHOD("convert_symbol", convert_symbol); + + function process_to_assign(ref) { + var def = ref.definition(); + def.assignments++; + def.references.push(ref); + } + + function mark_destructured(process, tw) { + var marker = new TreeWalker(function(node) { + if (node instanceof AST_DefaultValue) { + node.value.walk(tw); + node.name.walk(marker); + return true; + } + if (node instanceof AST_DestructuredKeyVal) { + if (node.key instanceof AST_Node) node.key.walk(tw); + node.value.walk(marker); + return true; + } + return process(node); + }); + this.walk(marker); + } + AST_DefaultValue.DEFMETHOD("mark_symbol", mark_destructured); + AST_Destructured.DEFMETHOD("mark_symbol", mark_destructured); + function mark_symbol(process) { + return process(this); + } + AST_SymbolDeclaration.DEFMETHOD("mark_symbol", mark_symbol); + AST_SymbolRef.DEFMETHOD("mark_symbol", mark_symbol); + + AST_Node.DEFMETHOD("match_symbol", function(predicate) { + return predicate(this); + }); + function match_destructured(predicate, ignore_side_effects) { + var found = false; + var tw = new TreeWalker(function(node) { + if (found) return true; + if (node instanceof AST_DefaultValue) { + if (!ignore_side_effects) return found = true; + node.name.walk(tw); + return true; + } + if (node instanceof AST_DestructuredKeyVal) { + if (!ignore_side_effects && node.key instanceof AST_Node) return found = true; + node.value.walk(tw); + return true; + } + if (predicate(node)) return found = true; + }); + this.walk(tw); + return found; + } + AST_DefaultValue.DEFMETHOD("match_symbol", match_destructured); + AST_Destructured.DEFMETHOD("match_symbol", match_destructured); + + function in_async_generator(scope) { + return scope instanceof AST_AsyncGeneratorDefun || scope instanceof AST_AsyncGeneratorFunction; + } + + function find_scope(compressor) { + var level = 0, node = compressor.self(); + do { + if (node.variables) return node; + } while (node = compressor.parent(level++)); + } + + function find_try(compressor, level, node, scope, may_throw, sync) { + for (var parent; parent = compressor.parent(level++); node = parent) { + if (parent === scope) return false; + if (sync && parent instanceof AST_Lambda) { + if (parent.name || is_async(parent) || is_generator(parent)) return true; + } else if (parent instanceof AST_Try) { + if (parent.bfinally && parent.bfinally !== node) return true; + if (may_throw && parent.bcatch && parent.bcatch !== node) return true; + } + } + return false; + } + + var identifier_atom = makePredicate("Infinity NaN undefined"); + function is_lhs_read_only(lhs, compressor) { + if (lhs instanceof AST_Assign) { + if (lhs.operator != "=") return true; + if (lhs.right.tail_node().is_constant()) return true; + return is_lhs_read_only(lhs.left, compressor); + } + if (lhs instanceof AST_Atom) return true; + if (lhs instanceof AST_ObjectIdentity) return true; + if (lhs instanceof AST_PropAccess) { + if (lhs.property === "__proto__") return true; + lhs = lhs.expression; + if (lhs instanceof AST_SymbolRef) { + if (lhs.is_immutable()) return false; + lhs = lhs.fixed_value(); + } + if (!lhs) return true; + if (lhs.tail_node().is_constant()) return true; + return is_lhs_read_only(lhs, compressor); + } + if (lhs instanceof AST_SymbolRef) { + if (lhs.is_immutable()) return true; + var def = lhs.definition(); + return compressor.exposed(def) && identifier_atom[def.name]; + } + return false; + } + + function make_node(ctor, orig, props) { + if (props) { + props.start = orig.start; + props.end = orig.end; + } else { + props = orig; + } + return new ctor(props); + } + + function make_sequence(orig, expressions) { + if (expressions.length == 1) return expressions[0]; + return make_node(AST_Sequence, orig, { expressions: expressions.reduce(merge_sequence, []) }); + } + + function make_node_from_constant(val, orig) { + switch (typeof val) { + case "string": + return make_node(AST_String, orig, { value: val }); + case "number": + if (isNaN(val)) return make_node(AST_NaN, orig); + if (isFinite(val)) { + return 1 / val < 0 ? make_node(AST_UnaryPrefix, orig, { + operator: "-", + expression: make_node(AST_Number, orig, { value: -val }), + }) : make_node(AST_Number, orig, { value: val }); + } + return val < 0 ? make_node(AST_UnaryPrefix, orig, { + operator: "-", + expression: make_node(AST_Infinity, orig), + }) : make_node(AST_Infinity, orig); + case "boolean": + return make_node(val ? AST_True : AST_False, orig); + case "undefined": + return make_node(AST_Undefined, orig); + default: + if (val === null) { + return make_node(AST_Null, orig); + } + if (val instanceof RegExp) { + return make_node(AST_RegExp, orig, { value: val }); + } + throw new Error(string_template("Can't handle constant of type: {type}", { type: typeof val })); + } + } + + function needs_unbinding(val) { + return val instanceof AST_PropAccess + || is_undeclared_ref(val) && val.name == "eval"; + } + + // we shouldn't compress (1,func)(something) to + // func(something) because that changes the meaning of + // the func (becomes lexical instead of global). + function maintain_this_binding(parent, orig, val) { + var wrap = false; + if (parent.TYPE == "Call") { + wrap = parent.expression === orig && needs_unbinding(val); + } else if (parent instanceof AST_Template) { + wrap = parent.tag === orig && needs_unbinding(val); + } else if (parent instanceof AST_UnaryPrefix) { + wrap = parent.operator == "delete" + || parent.operator == "typeof" && is_undeclared_ref(val); + } + return wrap ? make_sequence(orig, [ make_node(AST_Number, orig, { value: 0 }), val ]) : val; + } + + function merge_expression(base, target) { + var fixed_by_id = new Dictionary(); + base.walk(new TreeWalker(function(node) { + if (!(node instanceof AST_SymbolRef)) return; + var def = node.definition(); + var fixed = node.fixed; + if (!fixed || !fixed_by_id.has(def.id)) { + fixed_by_id.set(def.id, fixed); + } else if (fixed_by_id.get(def.id) !== fixed) { + fixed_by_id.set(def.id, false); + } + })); + if (fixed_by_id.size() > 0) target.walk(new TreeWalker(function(node) { + if (!(node instanceof AST_SymbolRef)) return; + var def = node.definition(); + var fixed = node.fixed; + if (!fixed || !fixed_by_id.has(def.id)) return; + if (fixed_by_id.get(def.id) !== fixed) node.fixed = false; + })); + return target; + } + + function merge_sequence(array, node) { + if (node instanceof AST_Sequence) { + [].push.apply(array, node.expressions); + } else { + array.push(node); + } + return array; + } + + function is_lexical_definition(stat) { + return stat instanceof AST_Const || stat instanceof AST_DefClass || stat instanceof AST_Let; + } + + function safe_to_trim(stat) { + if (stat instanceof AST_LambdaDefinition) { + var def = stat.name.definition(); + var scope = stat.name.scope; + if (def.orig.length > 1 && def.scope.resolve() !== scope) return false; + return def.scope === scope || all(def.references, function(ref) { + var s = ref.scope; + do { + if (s === scope) return true; + } while (s = s.parent_scope); + }); + } + return !is_lexical_definition(stat); + } + + function as_statement_array(thing) { + if (thing === null) return []; + if (thing instanceof AST_BlockStatement) return all(thing.body, safe_to_trim) ? thing.body : [ thing ]; + if (thing instanceof AST_EmptyStatement) return []; + if (is_statement(thing)) return [ thing ]; + throw new Error("Can't convert thing to statement array"); + } + + function is_empty(thing) { + if (thing === null) return true; + if (thing instanceof AST_EmptyStatement) return true; + if (thing instanceof AST_BlockStatement) return thing.body.length == 0; + return false; + } + + function has_declarations_only(block) { + return all(block.body, function(stat) { + return is_empty(stat) + || stat instanceof AST_Defun + || stat instanceof AST_Var && declarations_only(stat); + }); + } + + function loop_body(x) { + if (x instanceof AST_IterationStatement) { + return x.body instanceof AST_BlockStatement ? x.body : x; + } + return x; + } + + function is_iife_call(node) { + if (node.TYPE != "Call") return false; + do { + node = node.expression; + } while (node instanceof AST_PropAccess); + return node instanceof AST_LambdaExpression ? !is_arrow(node) : is_iife_call(node); + } + + function is_iife_single(call) { + var exp = call.expression; + if (exp.name) return false; + if (!(call instanceof AST_New)) return true; + var found = false; + exp.walk(new TreeWalker(function(node) { + if (found) return true; + if (node instanceof AST_NewTarget) return found = true; + if (node instanceof AST_Scope && node !== exp) return true; + })); + return !found; + } + + function is_undeclared_ref(node) { + return node instanceof AST_SymbolRef && node.definition().undeclared; + } + + var global_names = makePredicate("Array Boolean clearInterval clearTimeout console Date decodeURI decodeURIComponent encodeURI encodeURIComponent Error escape eval EvalError Function isFinite isNaN JSON Map Math Number parseFloat parseInt RangeError ReferenceError RegExp Object Set setInterval setTimeout String SyntaxError TypeError unescape URIError WeakMap WeakSet"); + AST_SymbolRef.DEFMETHOD("is_declared", function(compressor) { + return this.defined + || !this.definition().undeclared + || compressor.option("unsafe") && global_names[this.name]; + }); + + function is_static_field_or_init(prop) { + return prop.static && prop.value && (prop instanceof AST_ClassField || prop instanceof AST_ClassInit); + } + + function declarations_only(node) { + return all(node.definitions, function(var_def) { + return !var_def.value; + }); + } + + function is_declaration(stat, lexical) { + if (stat instanceof AST_DefClass) return lexical && !stat.extends && all(stat.properties, function(prop) { + if (prop.key instanceof AST_Node) return false; + return !is_static_field_or_init(prop); + }); + if (stat instanceof AST_Definitions) return (lexical || stat instanceof AST_Var) && declarations_only(stat); + if (stat instanceof AST_ExportDeclaration) return is_declaration(stat.body, lexical); + if (stat instanceof AST_ExportDefault) return is_declaration(stat.body, lexical); + return stat instanceof AST_LambdaDefinition; + } + + function is_last_statement(body, stat) { + var index = body.lastIndexOf(stat); + if (index < 0) return false; + while (++index < body.length) { + if (!is_declaration(body[index], true)) return false; + } + return true; + } + + // Certain combination of unused name + side effect leads to invalid AST: + // https://github.com/mishoo/UglifyJS/issues/44 + // https://github.com/mishoo/UglifyJS/issues/1838 + // https://github.com/mishoo/UglifyJS/issues/3371 + // We fix it at this stage by moving the `var` outside the `for`. + function patch_for_init(node, in_list) { + var block; + if (node.init instanceof AST_BlockStatement) { + block = node.init; + node.init = block.body.pop(); + block.body.push(node); + } + if (node.init instanceof AST_Defun) { + if (!block) block = make_node(AST_BlockStatement, node, { body: [ node ] }); + block.body.splice(-1, 0, node.init); + node.init = null; + } else if (node.init instanceof AST_SimpleStatement) { + node.init = node.init.body; + } else if (is_empty(node.init)) { + node.init = null; + } + if (!block) return; + return in_list ? List.splice(block.body) : block; + } + + function tighten_body(statements, compressor) { + var in_lambda = last_of(compressor, function(node) { + return node instanceof AST_Lambda; + }); + var block_scope, iife_in_try, in_iife_single, in_loop, in_try, scope; + find_loop_scope_try(); + var changed, last_changed, max_iter = 10; + do { + last_changed = changed; + changed = 0; + if (eliminate_spurious_blocks(statements)) changed = 1; + if (!changed && last_changed == 1) break; + if (compressor.option("dead_code")) { + if (eliminate_dead_code(statements, compressor)) changed = 2; + if (!changed && last_changed == 2) break; + } + if (compressor.option("if_return")) { + if (handle_if_return(statements, compressor)) changed = 3; + if (!changed && last_changed == 3) break; + } + if (compressor.option("awaits") && compressor.option("side_effects")) { + if (trim_awaits(statements, compressor)) changed = 4; + if (!changed && last_changed == 4) break; + } + if (compressor.option("inline") >= 4) { + if (inline_iife(statements, compressor)) changed = 5; + if (!changed && last_changed == 5) break; + } + if (compressor.sequences_limit > 0) { + if (sequencesize(statements, compressor)) changed = 6; + if (!changed && last_changed == 6) break; + if (sequencesize_2(statements, compressor)) changed = 7; + if (!changed && last_changed == 7) break; + } + if (compressor.option("join_vars")) { + if (join_consecutive_vars(statements)) changed = 8; + if (!changed && last_changed == 8) break; + } + if (compressor.option("collapse_vars")) { + if (collapse(statements, compressor)) changed = 9; + } + } while (changed && max_iter-- > 0); + return statements; + + function last_of(compressor, predicate) { + var block = compressor.self(), level = 0, stat; + do { + if (block instanceof AST_Catch) { + block = compressor.parent(level++); + } else if (block instanceof AST_LabeledStatement) { + block = block.body; + } else if (block instanceof AST_SwitchBranch) { + var branches = compressor.parent(level); + if (branches.body[branches.body.length - 1] === block || has_break(block.body)) { + level++; + block = branches; + } + } + do { + stat = block; + if (predicate(stat)) return stat; + block = compressor.parent(level++); + } while (block instanceof AST_If); + } while (stat + && (block instanceof AST_BlockStatement + || block instanceof AST_Catch + || block instanceof AST_Scope + || block instanceof AST_SwitchBranch + || block instanceof AST_Try) + && is_last_statement(block.body, stat)); + + function has_break(stats) { + for (var i = stats.length; --i >= 0;) { + if (stats[i] instanceof AST_Break) return true; + } + return false; + } + } + + function find_loop_scope_try() { + var node = compressor.self(), level = 0; + do { + if (!block_scope && node.variables) block_scope = node; + if (node instanceof AST_Catch) { + if (compressor.parent(level).bfinally) { + if (!in_try) in_try = {}; + in_try.bfinally = true; + } + level++; + } else if (node instanceof AST_Finally) { + level++; + } else if (node instanceof AST_IterationStatement) { + in_loop = true; + } else if (node instanceof AST_Scope) { + scope = node; + break; + } else if (node instanceof AST_Try) { + if (!in_try) in_try = {}; + if (node.bcatch) in_try.bcatch = true; + if (node.bfinally) in_try.bfinally = true; + } + } while (node = compressor.parent(level++)); + } + + // Search from right to left for assignment-like expressions: + // - `var a = x;` + // - `a = x;` + // - `++a` + // For each candidate, scan from left to right for first usage, then try + // to fold assignment into the site for compression. + // Will not attempt to collapse assignments into or past code blocks + // which are not sequentially executed, e.g. loops and conditionals. + function collapse(statements, compressor) { + if (scope.pinned()) return; + var args; + var assignments = new Dictionary(); + var candidates = []; + var changed = false; + var declare_only = new Dictionary(); + var force_single; + var stat_index = statements.length; + var scanner = new TreeTransformer(function(node, descend) { + if (abort) return node; + // Skip nodes before `candidate` as quickly as possible + if (!hit) { + if (node !== hit_stack[hit_index]) return node; + hit_index++; + if (hit_index < hit_stack.length) return handle_custom_scan_order(node, scanner); + hit = true; + stop_after = (value_def ? find_stop_value : find_stop)(node, 0); + if (stop_after === node) abort = true; + return node; + } + var parent = scanner.parent(); + // Stop only if candidate is found within conditional branches + if (!stop_if_hit && in_conditional(node, parent)) { + stop_if_hit = parent; + } + // Cascade compound assignments + if (compound && scan_lhs && can_replace && !stop_if_hit + && node instanceof AST_Assign && node.operator != "=" && node.left.equals(lhs)) { + replaced++; + changed = true; + AST_Node.info("Cascading {this} [{start}]", node); + can_replace = false; + lvalues = get_lvalues(lhs); + node.right.transform(scanner); + clear_write_only(candidate); + var folded; + if (abort) { + folded = candidate; + } else { + abort = true; + folded = make_node(AST_Binary, candidate, { + operator: compound, + left: lhs.fixed && lhs.definition().fixed ? lhs.fixed.to_binary(candidate) : lhs, + right: rvalue, + }); + } + return make_node(AST_Assign, node, { + operator: "=", + left: node.left, + right: make_node(AST_Binary, node, { + operator: node.operator.slice(0, -1), + left: folded, + right: node.right, + }), + }); + } + // Stop immediately if these node types are encountered + if (should_stop(node, parent)) { + abort = true; + return node; + } + // Skip transient nodes caused by single-use variable replacement + if (node.single_use) return node; + // Replace variable with assignment when found + var hit_rhs; + if (!(node instanceof AST_SymbolDeclaration) + && (scan_lhs && lhs.equals(node) + || scan_rhs && (hit_rhs = scan_rhs(node, this)))) { + if (!can_replace || stop_if_hit && (hit_rhs || !lhs_local || !replace_all)) { + if (!hit_rhs && !value_def) abort = true; + return node; + } + if (is_lhs(node, parent)) { + if (value_def && !hit_rhs) assign_used = true; + return node; + } + if (!hit_rhs && verify_ref && node.fixed !== lhs.fixed) { + abort = true; + return node; + } + if (value_def) { + if (stop_if_hit && assign_pos == 0) assign_pos = remaining - replaced; + if (!hit_rhs) replaced++; + return node; + } + replaced++; + changed = abort = true; + AST_Node.info("Collapsing {this} [{start}]", node); + if (candidate.TYPE == "Binary") { + update_symbols(candidate, node); + return make_node(AST_Assign, candidate, { + operator: "=", + left: candidate.right.left, + right: candidate.operator == "&&" ? make_node(AST_Conditional, candidate, { + condition: candidate.left, + consequent: candidate.right.right, + alternative: node, + }) : make_node(AST_Conditional, candidate, { + condition: candidate.left, + consequent: node, + alternative: candidate.right.right, + }), + }); + } + if (candidate instanceof AST_UnaryPostfix) return make_node(AST_UnaryPrefix, candidate, { + operator: candidate.operator, + expression: lhs.fixed && lhs.definition().fixed ? lhs.fixed.to_prefix(candidate) : lhs, + }); + if (candidate instanceof AST_UnaryPrefix) { + clear_write_only(candidate); + return candidate; + } + update_symbols(rvalue, node); + if (candidate instanceof AST_VarDef) { + var def = candidate.name.definition(); + if (def.references.length - def.replaced == 1 && !compressor.exposed(def)) { + def.replaced++; + return maintain_this_binding(parent, node, rvalue); + } + return make_node(AST_Assign, candidate, { + operator: "=", + left: node, + right: rvalue, + }); + } + clear_write_only(rvalue); + var assign = candidate.clone(); + assign.right = rvalue; + return assign; + } + // Stop signals related to AST_SymbolRef + if (should_stop_ref(node, parent)) { + abort = true; + return node; + } + // These node types have child nodes that execute sequentially, + // but are otherwise not safe to scan into or beyond them. + if (is_last_node(node, parent) || may_throw(node)) { + stop_after = node; + if (node instanceof AST_Scope) abort = true; + } + // Scan but don't replace inside getter/setter + if (node instanceof AST_Accessor) { + var replace = can_replace; + can_replace = false; + descend(node, scanner); + can_replace = replace; + return signal_abort(node); + } + // Scan but don't replace inside destructuring expression + if (node instanceof AST_Destructured) { + var replace = can_replace; + can_replace = false; + descend(node, scanner); + can_replace = replace; + return signal_abort(node); + } + // Scan but don't replace inside default value + if (node instanceof AST_DefaultValue) { + node.name = node.name.transform(scanner); + var replace = can_replace; + can_replace = false; + node.value = node.value.transform(scanner); + can_replace = replace; + return signal_abort(node); + } + // Scan but don't replace inside block scope with colliding variable + if (node instanceof AST_BlockScope + && !(node instanceof AST_Scope) + && !(node.variables && node.variables.all(function(def) { + return !enclosed.has(def.name) && !lvalues.has(def.name); + }))) { + var replace = can_replace; + can_replace = false; + if (!handle_custom_scan_order(node, scanner)) descend(node, scanner); + can_replace = replace; + return signal_abort(node); + } + if (handle_custom_scan_order(node, scanner)) return signal_abort(node); + }, signal_abort); + var multi_replacer = new TreeTransformer(function(node) { + if (abort) return node; + // Skip nodes before `candidate` as quickly as possible + if (!hit) { + if (node !== hit_stack[hit_index]) return node; + hit_index++; + switch (hit_stack.length - hit_index) { + case 0: + hit = true; + if (assign_used) return node; + if (node !== candidate) return node; + if (node instanceof AST_VarDef) return node; + def.replaced++; + var parent = multi_replacer.parent(); + if (parent instanceof AST_Sequence && parent.tail_node() !== node) { + value_def.replaced++; + if (rvalue === rhs_value) return List.skip; + return make_sequence(rhs_value, rhs_value.expressions.slice(0, -1)); + } + return rvalue; + case 1: + if (!assign_used && node.body === candidate) { + hit = true; + def.replaced++; + value_def.replaced++; + return null; + } + default: + return handle_custom_scan_order(node, multi_replacer); + } + } + // Replace variable when found + if (node instanceof AST_SymbolRef && node.definition() === def) { + if (is_lhs(node, multi_replacer.parent())) return node; + if (!--replaced) abort = true; + AST_Node.info("Replacing {this} [{start}]", node); + var ref = rvalue.clone(); + ref.scope = node.scope; + ref.reference(); + if (replaced == assign_pos) { + abort = true; + return make_node(AST_Assign, candidate, { + operator: "=", + left: node, + right: ref, + }); + } + def.replaced++; + return ref; + } + // Skip (non-executed) functions and (leading) default case in switch statements + if (node instanceof AST_Default || node instanceof AST_Scope) return node; + }, function(node) { + return patch_sequence(node, multi_replacer); + }); + while (--stat_index >= 0) { + // Treat parameters as collapsible in IIFE, i.e. + // function(a, b){ ... }(x()); + // would be translated into equivalent assignments: + // var a = x(), b = undefined; + if (stat_index == 0 && compressor.option("unused")) extract_args(); + // Find collapsible assignments + var hit_stack = []; + extract_candidates(statements[stat_index]); + while (candidates.length > 0) { + hit_stack = candidates.pop(); + var hit_index = 0; + var candidate = hit_stack[hit_stack.length - 1]; + var assign_pos = -1; + var assign_used = false; + var verify_ref = false; + var remaining; + var value_def = null; + var stop_after = null; + var stop_if_hit = null; + var lhs = get_lhs(candidate); + var side_effects = lhs && lhs.has_side_effects(compressor); + var scan_lhs = lhs && (!side_effects || lhs instanceof AST_SymbolRef) + && !is_lhs_read_only(lhs, compressor); + var scan_rhs = foldable(candidate); + if (!scan_lhs && !scan_rhs) continue; + var compound = candidate instanceof AST_Assign && candidate.operator.slice(0, -1); + var funarg = candidate.name instanceof AST_SymbolFunarg; + var may_throw = return_false; + if (candidate.may_throw(compressor)) { + if (funarg && is_async(scope)) continue; + may_throw = in_try ? function(node) { + return node.has_side_effects(compressor); + } : side_effects_external; + } + var read_toplevel = false; + var modify_toplevel = false; + var defun_scopes = get_defun_scopes(lhs); + // Locate symbols which may execute code outside of scanning range + var enclosed = new Dictionary(); + var well_defined = true; + var lvalues = get_lvalues(candidate); + var lhs_local = is_lhs_local(lhs); + var rhs_value = get_rvalue(candidate); + var rvalue = rhs_value; + if (!side_effects) { + if (!compound && rvalue instanceof AST_Sequence) rvalue = rvalue.tail_node(); + side_effects = value_has_side_effects(); + } + var check_destructured = in_try || !lhs_local ? function(node) { + return node instanceof AST_Destructured; + } : return_false; + var replace_all = replace_all_symbols(candidate); + var hit = funarg; + var abort = false; + var replaced = 0; + var can_replace = !args || !hit; + if (!can_replace) { + for (var j = candidate.arg_index + 1; !abort && j < args.length; j++) { + if (args[j]) args[j].transform(scanner); + } + can_replace = true; + } + for (var i = stat_index; !abort && i < statements.length; i++) { + statements[i].transform(scanner); + } + if (value_def) { + if (!replaced || remaining > replaced + assign_used) { + candidates.push(hit_stack); + force_single = true; + continue; + } + if (replaced == assign_pos) assign_used = true; + var def = lhs.definition(); + abort = false; + hit_index = 0; + hit = funarg; + for (var i = stat_index; !abort && i < statements.length; i++) { + if (!statements[i].transform(multi_replacer)) statements.splice(i--, 1); + } + replaced = candidate instanceof AST_VarDef + && candidate === hit_stack[hit_stack.length - 1] + && def.references.length == def.replaced + && !compressor.exposed(def); + value_def.last_ref = false; + value_def.single_use = false; + changed = true; + } + if (replaced) remove_candidate(candidate); + } + } + return changed; + + function signal_abort(node) { + if (abort) return node; + if (stop_after === node) abort = true; + if (stop_if_hit === node) stop_if_hit = null; + return node; + } + + function handle_custom_scan_order(node, tt) { + if (!(node instanceof AST_BlockScope)) return; + // Skip (non-executed) functions + if (node instanceof AST_Scope) return node; + // Scan computed keys, static fields & initializers in class + if (node instanceof AST_Class) { + var replace = can_replace; + can_replace = false; + if (node.name) node.name.transform(tt); + if (!abort && node.extends) node.extends.transform(tt); + var fields = [], stats = []; + for (var i = 0; !abort && i < node.properties.length; i++) { + var prop = node.properties[i]; + if (prop.key instanceof AST_Node) prop.key = prop.key.transform(tt); + if (!prop.static) continue; + if (prop instanceof AST_ClassField) { + if (prop.value) fields.push(prop); + } else if (prop instanceof AST_ClassInit) { + [].push.apply(stats, prop.value.body); + } + } + for (var i = 0; !abort && i < stats.length; i++) { + stats[i].transform(tt); + } + for (var i = 0; !abort && i < fields.length; i++) { + fields[i].value.transform(tt); + } + can_replace = replace; + return node; + } + // Scan object only in a for-in/of statement + if (node instanceof AST_ForEnumeration) { + node.object = node.object.transform(tt); + abort = true; + return node; + } + // Scan first case expression only in a switch statement + if (node instanceof AST_Switch) { + node.expression = node.expression.transform(tt); + for (var i = 0; !abort && i < node.body.length; i++) { + var branch = node.body[i]; + if (branch instanceof AST_Case) { + if (!hit) { + if (branch !== hit_stack[hit_index]) continue; + hit_index++; + } + branch.expression = branch.expression.transform(tt); + if (!replace_all || verify_ref) break; + scan_rhs = false; + } + } + abort = true; + return node; + } + } + + function is_direct_assignment(node, parent) { + if (parent instanceof AST_Assign) return parent.operator == "=" && parent.left === node; + if (parent instanceof AST_DefaultValue) return parent.name === node; + if (parent instanceof AST_DestructuredArray) return true; + if (parent instanceof AST_DestructuredKeyVal) return parent.value === node; + } + + function should_stop(node, parent) { + if (node === rvalue) return true; + if (parent instanceof AST_For) { + if (node !== parent.init) return true; + } + if (node instanceof AST_Assign) return node.operator != "=" && lhs.equals(node.left); + if (node instanceof AST_BlockStatement) { + return defun_scopes && !all(defun_scopes, function(scope) { + return node !== scope; + }); + } + if (node instanceof AST_Call) { + if (!(lhs instanceof AST_PropAccess)) return false; + if (!lhs.equals(node.expression)) return false; + return !(rvalue instanceof AST_LambdaExpression && !rvalue.contains_this()); + } + if (node instanceof AST_Class) return !compressor.has_directive("use strict"); + if (node instanceof AST_Debugger) return true; + if (node instanceof AST_Defun) return funarg && lhs.name === node.name.name; + if (node instanceof AST_DestructuredKeyVal) return node.key instanceof AST_Node; + if (node instanceof AST_DWLoop) return true; + if (node instanceof AST_LoopControl) return true; + if (node instanceof AST_Try) return true; + if (node instanceof AST_With) return true; + return false; + } + + function should_stop_ref(node, parent) { + if (!(node instanceof AST_SymbolRef)) return false; + if (node.is_declared(compressor)) { + if (node.fixed_value()) return false; + if (can_drop_symbol(node)) { + return !(parent instanceof AST_PropAccess && parent.expression === node) + && is_arguments(node.definition()); + } + } else if (is_direct_assignment(node, parent)) { + return false; + } + if (!replace_all) return true; + scan_rhs = false; + return false; + } + + function in_conditional(node, parent) { + if (parent instanceof AST_Assign) return parent.left !== node && lazy_op[parent.operator.slice(0, -1)]; + if (parent instanceof AST_Binary) return parent.left !== node && lazy_op[parent.operator]; + if (parent instanceof AST_Call) return parent.optional && parent.expression !== node; + if (parent instanceof AST_Case) return parent.expression !== node; + if (parent instanceof AST_Conditional) return parent.condition !== node; + if (parent instanceof AST_If) return parent.condition !== node; + if (parent instanceof AST_Sub) return parent.optional && parent.expression !== node; + } + + function is_last_node(node, parent) { + if (node instanceof AST_Await) return true; + if (node.TYPE == "Binary") return !can_drop_op(node, compressor); + if (node instanceof AST_Call) { + var def, fn = node.expression; + if (fn instanceof AST_SymbolRef) { + def = fn.definition(); + fn = fn.fixed_value(); + } + if (!(fn instanceof AST_Lambda)) return !node.is_expr_pure(compressor); + if (def && recursive_ref(compressor, def, fn)) return true; + if (fn.collapse_scanning) return false; + fn.collapse_scanning = true; + var replace = can_replace; + can_replace = false; + var after = stop_after; + var if_hit = stop_if_hit; + for (var i = 0; !abort && i < fn.argnames.length; i++) { + if (arg_may_throw(reject, fn.argnames[i], node.args[i])) abort = true; + } + if (!abort) { + if (fn.rest && arg_may_throw(reject, fn.rest, make_node(AST_Array, node, { + elements: node.args.slice(i), + }))) { + abort = true; + } else if (is_arrow(fn) && fn.value) { + fn.value.transform(scanner); + } else for (var i = 0; !abort && i < fn.body.length; i++) { + var stat = fn.body[i]; + if (stat instanceof AST_Return) { + if (stat.value) stat.value.transform(scanner); + break; + } + stat.transform(scanner); + } + } + stop_if_hit = if_hit; + stop_after = after; + can_replace = replace; + fn.collapse_scanning = false; + if (!abort) return false; + abort = false; + return true; + } + if (node instanceof AST_Class) { + if (!in_try) return false; + var base = node.extends; + if (!base) return false; + if (base instanceof AST_SymbolRef) base = base.fixed_value(); + return !safe_for_extends(base); + } + if (node instanceof AST_Exit) { + if (in_try) { + if (in_try.bfinally) return true; + if (in_try.bcatch && node instanceof AST_Throw) return true; + } + return side_effects || lhs instanceof AST_PropAccess || may_modify(lhs); + } + if (node instanceof AST_Function) { + return compressor.option("ie") && node.name && lvalues.has(node.name.name); + } + if (node instanceof AST_ObjectIdentity) return symbol_in_lvalues(node); + if (node instanceof AST_PropAccess) { + var exp = node.expression; + if (compressor.option("unsafe")) { + if (is_undeclared_ref(exp) && global_names[exp.name]) return false; + if (is_static_fn(exp)) return false; + } + if (exp instanceof AST_SymbolRef && is_arguments(exp.definition())) return true; + if (side_effects) return true; + if (!well_defined) return true; + if (value_def) return false; + if (!in_try && lhs_local) return false; + if (node.optional) return false; + return exp.may_throw_on_access(compressor); + } + if (node instanceof AST_Spread) return true; + if (node instanceof AST_SymbolRef) { + var assign_direct = symbol_in_lvalues(node); + if (is_undeclared_ref(node) && node.is_declared(compressor)) return false; + if (assign_direct) return !is_direct_assignment(node, parent); + if (side_effects && may_modify(node)) return true; + var def = node.definition(); + return (in_try || def.scope.resolve() !== scope) && !can_drop_symbol(node); + } + if (node instanceof AST_Template) return !node.is_expr_pure(compressor); + if (node instanceof AST_VarDef) { + if (check_destructured(node.name)) return true; + return (node.value || parent instanceof AST_Let) && node.name.match_symbol(function(node) { + return node instanceof AST_SymbolDeclaration + && (lvalues.has(node.name) || side_effects && may_modify(node)); + }, true); + } + if (node instanceof AST_Yield) return true; + var sym = is_lhs(node.left, node); + if (!sym) return false; + if (sym instanceof AST_PropAccess) return true; + if (check_destructured(sym)) return true; + return sym.match_symbol(function(node) { + if (node instanceof AST_PropAccess) return true; + if (node instanceof AST_SymbolRef) { + return lvalues.has(node.name) || read_toplevel && compressor.exposed(node.definition()); + } + }, true); + + function reject(node) { + node.transform(scanner); + return abort; + } + } + + function arg_may_throw(reject, node, value) { + if (node instanceof AST_DefaultValue) { + return reject(node.value) + || arg_may_throw(reject, node.name, node.value) + || !is_undefined(value) && arg_may_throw(reject, node.name, value); + } + if (!value) return !(node instanceof AST_Symbol); + if (node instanceof AST_Destructured) { + if (node.rest && arg_may_throw(reject, node.rest)) return true; + if (node instanceof AST_DestructuredArray) { + if (value instanceof AST_Array) return !all(node.elements, function(element, index) { + return !arg_may_throw(reject, element, value[index]); + }); + if (!value.is_string(compressor)) return true; + return !all(node.elements, function(element) { + return !arg_may_throw(reject, element); + }); + } + if (node instanceof AST_DestructuredObject) { + if (value.may_throw_on_access(compressor)) return true; + return !all(node.properties, function(prop) { + if (prop.key instanceof AST_Node && reject(prop.key)) return false; + return !arg_may_throw(reject, prop.value); + }); + } + } + } + + function extract_args() { + if (in_iife_single === false) return; + var iife = compressor.parent(), fn = compressor.self(); + if (in_iife_single === undefined) { + if (!(fn instanceof AST_LambdaExpression) + || is_generator(fn) + || fn.uses_arguments + || fn.pinned() + || !(iife instanceof AST_Call) + || iife.expression !== fn + || !all(iife.args, function(arg) { + return !(arg instanceof AST_Spread); + })) { + in_iife_single = false; + return; + } + if (!is_iife_single(iife)) return; + in_iife_single = true; + } + var fn_strict = fn.in_strict_mode(compressor) + && !fn.parent_scope.resolve(true).in_strict_mode(compressor); + var has_await; + if (is_async(fn)) { + has_await = function(node) { + return node instanceof AST_Symbol && node.name == "await"; + }; + iife_in_try = true; + } else { + has_await = function(node) { + return node instanceof AST_Await && !tw.find_parent(AST_Scope); + }; + if (iife_in_try === undefined) iife_in_try = find_try(compressor, 1, iife, null, true, true); + } + var arg_scope = null; + var tw = new TreeWalker(function(node, descend) { + if (!arg) return true; + if (has_await(node) || node instanceof AST_Yield) { + arg = null; + return true; + } + if (node instanceof AST_ObjectIdentity) { + if (fn_strict || !arg_scope) arg = null; + return true; + } + if (node instanceof AST_SymbolRef) { + var def; + if (node.in_arg && !is_safe_lexical(node.definition()) + || (def = fn.variables.get(node.name)) && def !== node.definition()) { + arg = null; + } + return true; + } + if (node instanceof AST_Scope && !is_arrow(node)) { + var save_scope = arg_scope; + arg_scope = node; + descend(); + arg_scope = save_scope; + return true; + } + }); + args = iife.args.slice(); + var len = args.length; + var names = new Dictionary(); + for (var i = fn.argnames.length; --i >= 0;) { + var sym = fn.argnames[i]; + var arg = args[i]; + var value = null; + if (sym instanceof AST_DefaultValue) { + value = sym.value; + sym = sym.name; + args[len + i] = value; + } + if (sym instanceof AST_Destructured) { + if (iife_in_try && arg_may_throw(function(node) { + return node.has_side_effects(compressor); + }, sym, arg)) { + candidates.length = 0; + break; + } + args[len + i] = fn.argnames[i]; + continue; + } + if (names.has(sym.name)) continue; + names.set(sym.name, true); + if (value) arg = is_undefined(arg) ? value : null; + if (!arg && !value) { + arg = make_node(AST_Undefined, sym).transform(compressor); + } else if (arg instanceof AST_Lambda && arg.pinned()) { + arg = null; + } else if (arg) { + arg.walk(tw); + } + if (!arg) continue; + var candidate = make_node(AST_VarDef, sym, { + name: sym, + value: arg, + }); + candidate.name_index = i; + candidate.arg_index = value ? len + i : i; + candidates.unshift([ candidate ]); + } + if (fn.rest) args.push(fn.rest); + } + + function extract_candidates(expr, unused) { + hit_stack.push(expr); + if (expr instanceof AST_Array) { + expr.elements.forEach(function(node) { + extract_candidates(node, unused); + }); + } else if (expr instanceof AST_Assign) { + var lhs = expr.left; + if (!(lhs instanceof AST_Destructured)) candidates.push(hit_stack.slice()); + extract_candidates(lhs); + extract_candidates(expr.right); + if (lhs instanceof AST_SymbolRef && expr.operator == "=") { + assignments.set(lhs.name, (assignments.get(lhs.name) || 0) + 1); + } + } else if (expr instanceof AST_Await) { + extract_candidates(expr.expression, unused); + } else if (expr instanceof AST_Binary) { + var lazy = lazy_op[expr.operator]; + if (unused + && lazy + && expr.operator != "??" + && expr.right instanceof AST_Assign + && expr.right.operator == "=" + && !(expr.right.left instanceof AST_Destructured)) { + candidates.push(hit_stack.slice()); + } + extract_candidates(expr.left, !lazy && unused); + extract_candidates(expr.right, unused); + } else if (expr instanceof AST_Call) { + extract_candidates(expr.expression); + expr.args.forEach(extract_candidates); + } else if (expr instanceof AST_Case) { + extract_candidates(expr.expression); + } else if (expr instanceof AST_Conditional) { + extract_candidates(expr.condition); + extract_candidates(expr.consequent, unused); + extract_candidates(expr.alternative, unused); + } else if (expr instanceof AST_Definitions) { + expr.definitions.forEach(extract_candidates); + } else if (expr instanceof AST_Dot) { + extract_candidates(expr.expression); + } else if (expr instanceof AST_DWLoop) { + extract_candidates(expr.condition); + if (!(expr.body instanceof AST_Block)) { + extract_candidates(expr.body); + } + } else if (expr instanceof AST_Exit) { + if (expr.value) extract_candidates(expr.value); + } else if (expr instanceof AST_For) { + if (expr.init) extract_candidates(expr.init, true); + if (expr.condition) extract_candidates(expr.condition); + if (expr.step) extract_candidates(expr.step, true); + if (!(expr.body instanceof AST_Block)) { + extract_candidates(expr.body); + } + } else if (expr instanceof AST_ForEnumeration) { + extract_candidates(expr.object); + if (!(expr.body instanceof AST_Block)) { + extract_candidates(expr.body); + } + } else if (expr instanceof AST_If) { + extract_candidates(expr.condition); + if (!(expr.body instanceof AST_Block)) { + extract_candidates(expr.body); + } + if (expr.alternative && !(expr.alternative instanceof AST_Block)) { + extract_candidates(expr.alternative); + } + } else if (expr instanceof AST_Object) { + expr.properties.forEach(function(prop) { + hit_stack.push(prop); + if (prop.key instanceof AST_Node) extract_candidates(prop.key); + if (prop instanceof AST_ObjectKeyVal) extract_candidates(prop.value, unused); + hit_stack.pop(); + }); + } else if (expr instanceof AST_Sequence) { + var end = expr.expressions.length - (unused ? 0 : 1); + expr.expressions.forEach(function(node, index) { + extract_candidates(node, index < end); + }); + } else if (expr instanceof AST_SimpleStatement) { + extract_candidates(expr.body, true); + } else if (expr instanceof AST_Spread) { + extract_candidates(expr.expression); + } else if (expr instanceof AST_Sub) { + extract_candidates(expr.expression); + extract_candidates(expr.property); + } else if (expr instanceof AST_Switch) { + extract_candidates(expr.expression); + expr.body.forEach(extract_candidates); + } else if (expr instanceof AST_Unary) { + if (UNARY_POSTFIX[expr.operator]) { + candidates.push(hit_stack.slice()); + } else { + extract_candidates(expr.expression); + } + } else if (expr instanceof AST_VarDef) { + if (expr.name instanceof AST_SymbolVar) { + if (expr.value) { + var def = expr.name.definition(); + if (def.references.length > def.replaced) { + candidates.push(hit_stack.slice()); + } + } else { + declare_only.set(expr.name.name, (declare_only.get(expr.name.name) || 0) + 1); + } + } + if (expr.value) extract_candidates(expr.value); + } else if (expr instanceof AST_Yield) { + if (expr.expression) extract_candidates(expr.expression); + } + hit_stack.pop(); + } + + function find_stop(node, level) { + var parent = scanner.parent(level); + if (parent instanceof AST_Array) return node; + if (parent instanceof AST_Assign) return node; + if (parent instanceof AST_Await) return node; + if (parent instanceof AST_Binary) return node; + if (parent instanceof AST_Call) return node; + if (parent instanceof AST_Case) return node; + if (parent instanceof AST_Conditional) return node; + if (parent instanceof AST_Definitions) return find_stop_unused(parent, level + 1); + if (parent instanceof AST_Exit) return node; + if (parent instanceof AST_If) return node; + if (parent instanceof AST_IterationStatement) return node; + if (parent instanceof AST_ObjectProperty) return node; + if (parent instanceof AST_PropAccess) return node; + if (parent instanceof AST_Sequence) { + return (parent.tail_node() === node ? find_stop : find_stop_unused)(parent, level + 1); + } + if (parent instanceof AST_SimpleStatement) return find_stop_unused(parent, level + 1); + if (parent instanceof AST_Spread) return node; + if (parent instanceof AST_Switch) return node; + if (parent instanceof AST_Unary) return node; + if (parent instanceof AST_VarDef) return node; + if (parent instanceof AST_Yield) return node; + return null; + } + + function find_stop_logical(parent, op, level) { + var node; + do { + node = parent; + parent = scanner.parent(++level); + } while (parent instanceof AST_Assign && parent.operator.slice(0, -1) == op + || parent instanceof AST_Binary && parent.operator == op); + return node; + } + + function find_stop_expr(expr, cont, node, parent, level) { + var replace = can_replace; + can_replace = false; + var after = stop_after; + var if_hit = stop_if_hit; + var stack = scanner.stack; + scanner.stack = [ parent ]; + expr.transform(scanner); + scanner.stack = stack; + stop_if_hit = if_hit; + stop_after = after; + can_replace = replace; + if (abort) { + abort = false; + return node; + } + return cont(parent, level + 1); + } + + function find_stop_value(node, level) { + var parent = scanner.parent(level); + if (parent instanceof AST_Array) return find_stop_value(parent, level + 1); + if (parent instanceof AST_Assign) { + if (may_throw(parent)) return node; + if (parent.left.match_symbol(function(ref) { + return ref instanceof AST_SymbolRef && (lhs.name == ref.name || value_def.name == ref.name); + })) return node; + var op; + if (parent.left === node || !lazy_op[op = parent.operator.slice(0, -1)]) { + return find_stop_value(parent, level + 1); + } + return find_stop_logical(parent, op, level); + } + if (parent instanceof AST_Await) return find_stop_value(parent, level + 1); + if (parent instanceof AST_Binary) { + var op; + if (parent.left === node || !lazy_op[op = parent.operator]) { + return find_stop_value(parent, level + 1); + } + return find_stop_logical(parent, op, level); + } + if (parent instanceof AST_Call) return parent; + if (parent instanceof AST_Case) { + if (parent.expression !== node) return node; + return find_stop_value(parent, level + 1); + } + if (parent instanceof AST_Conditional) { + if (parent.condition !== node) return node; + return find_stop_value(parent, level + 1); + } + if (parent instanceof AST_Definitions) return find_stop_unused(parent, level + 1); + if (parent instanceof AST_Do) return node; + if (parent instanceof AST_Exit) return find_stop_unused(parent, level + 1); + if (parent instanceof AST_For) { + if (parent.init !== node && parent.condition !== node) return node; + return find_stop_value(parent, level + 1); + } + if (parent instanceof AST_ForEnumeration) { + if (parent.init !== node) return node; + return find_stop_value(parent, level + 1); + } + if (parent instanceof AST_If) { + if (parent.condition !== node) return node; + return find_stop_value(parent, level + 1); + } + if (parent instanceof AST_ObjectProperty) { + var obj = scanner.parent(level + 1); + return all(obj.properties, function(prop) { + return prop instanceof AST_ObjectKeyVal; + }) ? find_stop_value(obj, level + 2) : obj; + } + if (parent instanceof AST_PropAccess) { + var exp = parent.expression; + return exp === node ? find_stop_value(parent, level + 1) : node; + } + if (parent instanceof AST_Sequence) { + return (parent.tail_node() === node ? find_stop_value : find_stop_unused)(parent, level + 1); + } + if (parent instanceof AST_SimpleStatement) return find_stop_unused(parent, level + 1); + if (parent instanceof AST_Spread) return find_stop_value(parent, level + 1); + if (parent instanceof AST_Switch) { + if (parent.expression !== node) return node; + return find_stop_value(parent, level + 1); + } + if (parent instanceof AST_Unary) { + if (parent.operator == "delete") return node; + return find_stop_value(parent, level + 1); + } + if (parent instanceof AST_VarDef) return parent.name.match_symbol(function(sym) { + return sym instanceof AST_SymbolDeclaration && (lhs.name == sym.name || value_def.name == sym.name); + }) ? node : find_stop_value(parent, level + 1); + if (parent instanceof AST_While) { + if (parent.condition !== node) return node; + return find_stop_value(parent, level + 1); + } + if (parent instanceof AST_Yield) return find_stop_value(parent, level + 1); + return null; + } + + function find_stop_unused(node, level) { + var parent = scanner.parent(level); + if (is_last_node(node, parent)) return node; + if (in_conditional(node, parent)) return node; + if (parent instanceof AST_Array) return find_stop_unused(parent, level + 1); + if (parent instanceof AST_Assign) return check_assignment(parent.left); + if (parent instanceof AST_Await) return node; + if (parent instanceof AST_Binary) return find_stop_unused(parent, level + 1); + if (parent instanceof AST_Call) return find_stop_unused(parent, level + 1); + if (parent instanceof AST_Case) return find_stop_unused(parent, level + 1); + if (parent instanceof AST_Conditional) return find_stop_unused(parent, level + 1); + if (parent instanceof AST_Definitions) return find_stop_unused(parent, level + 1); + if (parent instanceof AST_Exit) return find_stop_unused(parent, level + 1); + if (parent instanceof AST_If) return find_stop_unused(parent, level + 1); + if (parent instanceof AST_IterationStatement) return node; + if (parent instanceof AST_ObjectProperty) { + var obj = scanner.parent(level + 1); + return all(obj.properties, function(prop) { + return prop instanceof AST_ObjectKeyVal; + }) ? find_stop_unused(obj, level + 2) : obj; + } + if (parent instanceof AST_PropAccess) { + var exp = parent.expression; + if (exp === node) return find_stop_unused(parent, level + 1); + return find_stop_expr(exp, find_stop_unused, node, parent, level); + } + if (parent instanceof AST_Sequence) return find_stop_unused(parent, level + 1); + if (parent instanceof AST_SimpleStatement) return find_stop_unused(parent, level + 1); + if (parent instanceof AST_Spread) return node; + if (parent instanceof AST_Switch) return find_stop_unused(parent, level + 1); + if (parent instanceof AST_Unary) return find_stop_unused(parent, level + 1); + if (parent instanceof AST_VarDef) return check_assignment(parent.name); + if (parent instanceof AST_Yield) return node; + return null; + + function check_assignment(lhs) { + if (may_throw(parent)) return node; + if (lhs !== node && lhs instanceof AST_Destructured) { + return find_stop_expr(lhs, find_stop_unused, node, parent, level); + } + return find_stop_unused(parent, level + 1); + } + } + + function mangleable_var(rhs) { + if (force_single) { + force_single = false; + return; + } + if (remaining < 1) return; + rhs = rhs.tail_node(); + var value = rhs instanceof AST_Assign && rhs.operator == "=" ? rhs.left : rhs; + if (!(value instanceof AST_SymbolRef)) return; + var def = value.definition(); + if (def.undeclared) return; + if (is_arguments(def)) return; + if (value !== rhs) { + if (is_lhs_read_only(value, compressor)) return; + var referenced = def.references.length - def.replaced; + if (referenced < 2) return; + var expr = candidate.clone(); + expr[expr instanceof AST_Assign ? "right" : "value"] = value; + if (candidate.name_index >= 0) { + expr.name_index = candidate.name_index; + expr.arg_index = candidate.arg_index; + } + candidate = expr; + } + return value_def = def; + } + + function remaining_refs(def) { + return def.references.length - def.replaced - (assignments.get(def.name) || 0); + } + + function get_lhs(expr) { + if (expr instanceof AST_Assign) { + var lhs = expr.left; + if (!(lhs instanceof AST_SymbolRef)) return lhs; + var def = lhs.definition(); + if (scope.uses_arguments && is_funarg(def)) return lhs; + if (compressor.exposed(def)) return lhs; + remaining = remaining_refs(def); + if (def.fixed && lhs.fixed) { + var matches = def.references.filter(function(ref) { + return ref.fixed === lhs.fixed; + }).length - 1; + if (matches < remaining) { + remaining = matches; + assign_pos = 0; + verify_ref = true; + } + } + if (expr.operator == "=") mangleable_var(expr.right); + return lhs; + } + if (expr instanceof AST_Binary) return expr.right.left; + if (expr instanceof AST_Unary) return expr.expression; + if (expr instanceof AST_VarDef) { + var lhs = expr.name; + var def = lhs.definition(); + if (def.const_redefs) return; + if (!member(lhs, def.orig)) return; + if (scope.uses_arguments && is_funarg(def)) return; + var declared = def.orig.length - def.eliminated - (declare_only.get(def.name) || 0); + remaining = remaining_refs(def); + if (def.fixed) remaining = Math.min(remaining, def.references.filter(function(ref) { + if (!ref.fixed) return true; + if (!ref.fixed.assigns) return true; + var assign = ref.fixed.assigns[0]; + return assign === lhs || get_rvalue(assign) === expr.value; + }).length); + if (declared > 1 && !(lhs instanceof AST_SymbolFunarg)) { + mangleable_var(expr.value); + return make_node(AST_SymbolRef, lhs); + } + if (mangleable_var(expr.value) || remaining == 1 && !compressor.exposed(def)) { + return make_node(AST_SymbolRef, lhs); + } + return; + } + } + + function get_rvalue(expr) { + if (expr instanceof AST_Assign) return expr.right; + if (expr instanceof AST_Binary) { + var node = expr.clone(); + node.right = expr.right.right; + return node; + } + if (expr instanceof AST_VarDef) return expr.value; + } + + function invariant(expr) { + if (expr instanceof AST_Array) return false; + if (expr instanceof AST_Binary && lazy_op[expr.operator]) { + return invariant(expr.left) && invariant(expr.right); + } + if (expr instanceof AST_Call) return false; + if (expr instanceof AST_Conditional) { + return invariant(expr.consequent) && invariant(expr.alternative); + } + if (expr instanceof AST_Object) return false; + return !expr.has_side_effects(compressor); + } + + function foldable(expr) { + if (expr instanceof AST_Assign && expr.right.single_use) return; + var lhs_ids = Object.create(null); + var marker = new TreeWalker(function(node) { + if (!(node instanceof AST_SymbolRef)) return; + for (var level = 0, parent, child = node; parent = marker.parent(level++); child = parent) { + if (is_direct_assignment(child, parent)) { + if (parent instanceof AST_DestructuredKeyVal) parent = marker.parent(level++); + continue; + } + lhs_ids[node.definition().id] = true; + return; + } + lhs_ids[node.definition().id] = "a"; + }); + while (expr instanceof AST_Assign && expr.operator == "=") { + expr.left.walk(marker); + expr = expr.right; + } + if (expr instanceof AST_ObjectIdentity) return rhs_exact_match; + if (expr instanceof AST_SymbolRef) { + if (lhs_ids[expr.definition().id] === "a") return; + var value = expr.evaluate(compressor); + if (value === expr) return rhs_exact_match; + return rhs_fuzzy_match(value, rhs_exact_match); + } + if (expr.is_truthy()) return rhs_fuzzy_match(true, return_false); + if (expr.is_constant()) { + var ev = expr.evaluate(compressor); + if (!(ev instanceof AST_Node)) return rhs_fuzzy_match(ev, rhs_exact_match); + } + if (!(lhs instanceof AST_SymbolRef)) return false; + if (!invariant(expr)) return false; + var circular; + expr.walk(new TreeWalker(function(node) { + if (circular) return true; + if (node instanceof AST_SymbolRef && lhs_ids[node.definition().id]) circular = true; + })); + return !circular && rhs_exact_match; + + function rhs_exact_match(node) { + return expr.equals(node); + } + } + + function rhs_fuzzy_match(value, fallback) { + return function(node, tw) { + if (tw.in_boolean_context()) { + if (value && node.is_truthy() && !node.has_side_effects(compressor)) { + return true; + } + if (node.is_constant()) { + var ev = node.evaluate(compressor); + if (!(ev instanceof AST_Node)) return !ev == !value; + } + } + return fallback(node); + }; + } + + function clear_write_only(assign) { + while (assign.write_only) { + assign.write_only = false; + if (!(assign instanceof AST_Assign)) break; + assign = assign.right; + } + } + + function update_symbols(value, node) { + var clear_defined = node instanceof AST_SymbolRef && !node.defined; + var scope = node.scope || find_scope(scanner) || block_scope; + value.walk(new TreeWalker(function(node) { + if (node instanceof AST_BlockScope) return true; + if (node instanceof AST_Symbol) { + if (clear_defined && node instanceof AST_SymbolRef) node.defined = false; + node.scope = scope; + } + })); + } + + function may_be_global(node) { + if (node instanceof AST_SymbolRef) { + node = node.fixed_value(); + if (!node) return true; + } + if (node instanceof AST_Assign) return node.operator == "=" && may_be_global(node.right); + return node instanceof AST_PropAccess || node instanceof AST_ObjectIdentity; + } + + function get_lvalues(expr) { + var lvalues = new Dictionary(); + if (expr instanceof AST_VarDef) { + if (!expr.name.definition().fixed) well_defined = false; + lvalues.add(expr.name.name, lhs); + } + var find_arguments = scope.uses_arguments && !compressor.has_directive("use strict"); + var scan_toplevel = scope instanceof AST_Toplevel; + var tw = new TreeWalker(function(node) { + if (node.inlined_node) node.inlined_node.walk(tw); + var value; + if (node instanceof AST_SymbolRef) { + value = node.fixed_value(); + if (!value) { + value = node; + var def = node.definition(); + var escaped = node.fixed && node.fixed.escaped || def.escaped; + if (!def.undeclared + && (def.assignments || !escaped || escaped.cross_scope) + && (has_escaped(def, node.scope, node, tw.parent()) || !same_scope(def))) { + well_defined = false; + } + } + } else if (node instanceof AST_ObjectIdentity) { + value = node; + } + if (value) { + lvalues.add(node.name, is_modified(compressor, tw, node, value, 0)); + } else if (node instanceof AST_Lambda) { + for (var level = 0, parent, child = node; parent = tw.parent(level++); child = parent) { + if (parent instanceof AST_Assign) { + if (parent.left === child) break; + if (parent.operator == "=") continue; + if (lazy_op[parent.operator.slice(0, -1)]) continue; + break; + } + if (parent instanceof AST_Binary) { + if (lazy_op[parent.operator]) continue; + break; + } + if (parent instanceof AST_Call) return; + if (parent instanceof AST_Scope) return; + if (parent instanceof AST_Sequence) { + if (parent.tail_node() === child) continue; + break; + } + if (parent instanceof AST_Template) { + if (parent.tag) return; + break; + } + } + node.enclosed.forEach(function(def) { + if (def.scope !== node) enclosed.set(def.name, true); + }); + return true; + } else if (find_arguments && node instanceof AST_Sub) { + scope.each_argname(function(argname) { + if (!compressor.option("reduce_vars") || argname.definition().assignments) { + if (!argname.definition().fixed) well_defined = false; + lvalues.add(argname.name, true); + } + }); + find_arguments = false; + } + if (!scan_toplevel) return; + if (node.TYPE == "Call") { + if (modify_toplevel) return; + var exp = node.expression; + if (exp instanceof AST_PropAccess) return; + if (exp instanceof AST_LambdaExpression && !exp.contains_this()) return; + modify_toplevel = true; + } else if (node instanceof AST_PropAccess && may_be_global(node.expression)) { + if (node === lhs && !(expr instanceof AST_Unary)) { + modify_toplevel = true; + } else { + read_toplevel = true; + } + } + }); + expr.walk(tw); + return lvalues; + } + + function remove_candidate(expr) { + var value = rvalue === rhs_value ? null : make_sequence(rhs_value, rhs_value.expressions.slice(0, -1)); + var index = expr.name_index; + if (index >= 0) { + var args, argname = scope.argnames[index]; + if (argname instanceof AST_DefaultValue) { + scope.argnames[index] = argname = argname.clone(); + argname.value = value || make_node(AST_Number, argname, { value: 0 }); + } else if ((args = compressor.parent().args)[index]) { + scope.argnames[index] = argname.clone(); + args[index] = value || make_node(AST_Number, args[index], { value: 0 }); + } + return; + } + var end = hit_stack.length - 1; + var last = hit_stack[end]; + if (last instanceof AST_VarDef || hit_stack[end - 1].body === last) end--; + var tt = new TreeTransformer(function(node, descend, in_list) { + if (hit) return node; + if (node !== hit_stack[hit_index]) return node; + hit_index++; + if (hit_index <= end) return handle_custom_scan_order(node, tt); + hit = true; + if (node instanceof AST_Definitions) { + declare_only.set(last.name.name, (declare_only.get(last.name.name) || 0) + 1); + if (value_def) value_def.replaced++; + var defns = node.definitions; + var index = defns.indexOf(last); + var defn = last.clone(); + defn.value = null; + if (!value) { + node.definitions[index] = defn; + return node; + } + var body = [ make_node(AST_SimpleStatement, value, { body: value }) ]; + if (index > 0) { + var head = node.clone(); + head.definitions = defns.slice(0, index); + body.unshift(head); + node = node.clone(); + node.definitions = defns.slice(index); + } + body.push(node); + node.definitions[0] = defn; + return in_list ? List.splice(body) : make_node(AST_BlockStatement, node, { body: body }); + } + if (!value) return in_list ? List.skip : null; + return is_statement(node) ? make_node(AST_SimpleStatement, value, { body: value }) : value; + }, function(node, in_list) { + if (node instanceof AST_For) return patch_for_init(node, in_list); + return patch_sequence(node, tt); + }); + abort = false; + hit = false; + hit_index = 0; + if (!(statements[stat_index] = statements[stat_index].transform(tt))) statements.splice(stat_index, 1); + } + + function patch_sequence(node, tt) { + if (node instanceof AST_Sequence) switch (node.expressions.length) { + case 0: return null; + case 1: return maintain_this_binding(tt.parent(), node, node.expressions[0]); + } + } + + function get_defun_scopes(lhs) { + if (!(lhs instanceof AST_SymbolDeclaration + || lhs instanceof AST_SymbolRef + || lhs instanceof AST_Destructured)) return; + var scopes = []; + lhs.mark_symbol(function(node) { + if (node instanceof AST_Symbol) { + var def = node.definition(); + var scope = def.scope.resolve(); + def.orig.forEach(function(sym) { + if (sym instanceof AST_SymbolDefun) { + if (sym.scope !== scope) push_uniq(scopes, sym.scope); + } + }); + } + }); + if (scopes.length == 0) return; + return scopes; + } + + function is_lhs_local(lhs) { + var sym = root_expr(lhs); + if (!(sym instanceof AST_SymbolRef)) return false; + if (sym.definition().scope.resolve() !== scope) return false; + if (!in_loop) return true; + if (compound) return false; + if (candidate instanceof AST_Unary) return false; + var lvalue = lvalues.get(sym.name); + return !lvalue || lvalue[0] === lhs; + } + + function value_has_side_effects() { + if (candidate instanceof AST_Unary) return false; + return rvalue.has_side_effects(compressor); + } + + function replace_all_symbols(expr) { + if (expr instanceof AST_Unary) return false; + if (side_effects) return false; + if (value_def) return true; + if (!(lhs instanceof AST_SymbolRef)) return false; + var referenced; + if (expr instanceof AST_VarDef) { + referenced = 1; + } else if (expr.operator == "=") { + referenced = 2; + } else { + return false; + } + var def = lhs.definition(); + if (def.references.length - def.replaced == referenced) return true; + if (!def.fixed) return false; + if (!lhs.fixed) return false; + var assigns = lhs.fixed.assigns; + var matched = 0; + if (!all(def.references, function(ref, index) { + var fixed = ref.fixed; + if (!fixed) return false; + if (fixed.to_binary || fixed.to_prefix) return false; + if (fixed === lhs.fixed) { + matched++; + return true; + } + return assigns && fixed.assigns && assigns[0] !== fixed.assigns[0]; + })) return false; + if (matched != referenced) return false; + verify_ref = true; + return true; + } + + function symbol_in_lvalues(sym) { + var lvalue = lvalues.get(sym.name); + if (!lvalue || all(lvalue, function(lhs) { + return !lhs; + })) return; + if (lvalue[0] !== lhs) return true; + scan_rhs = false; + } + + function may_modify(sym) { + var def = sym.definition(); + if (def.orig.length == 1 && def.orig[0] instanceof AST_SymbolDefun) return false; + if (def.scope.resolve() !== scope) return true; + if (modify_toplevel && compressor.exposed(def)) return true; + return !all(def.references, function(ref) { + return ref.scope.resolve(true) === scope; + }); + } + + function side_effects_external(node, lhs) { + if (node instanceof AST_Assign) return side_effects_external(node.left, true); + if (node instanceof AST_Unary) return side_effects_external(node.expression, true); + if (node instanceof AST_VarDef) return node.value && side_effects_external(node.value); + if (lhs) { + if (node instanceof AST_Dot) return side_effects_external(node.expression, true); + if (node instanceof AST_Sub) return side_effects_external(node.expression, true); + if (node instanceof AST_SymbolRef) return node.definition().scope.resolve() !== scope; + } + return false; + } + } + + function eliminate_spurious_blocks(statements) { + var changed = false, seen_dirs = []; + for (var i = 0; i < statements.length;) { + var stat = statements[i]; + if (stat instanceof AST_BlockStatement) { + if (all(stat.body, safe_to_trim)) { + changed = true; + eliminate_spurious_blocks(stat.body); + [].splice.apply(statements, [i, 1].concat(stat.body)); + i += stat.body.length; + continue; + } + } + if (stat instanceof AST_Directive) { + if (member(stat.value, seen_dirs)) { + changed = true; + statements.splice(i, 1); + continue; + } + seen_dirs.push(stat.value); + } + if (stat instanceof AST_EmptyStatement) { + changed = true; + statements.splice(i, 1); + continue; + } + i++; + } + return changed; + } + + function handle_if_return(statements, compressor) { + var changed = false; + var parent = compressor.parent(); + var self = compressor.self(); + var declare_only, jump, merge_jump; + var in_iife = in_lambda && parent && parent.TYPE == "Call" && parent.expression === self; + var chain_if_returns = in_lambda && compressor.option("conditionals") && compressor.option("sequences"); + var drop_return_void = !(in_try && in_try.bfinally && in_async_generator(scope)); + var multiple_if_returns = has_multiple_if_returns(statements); + for (var i = statements.length; --i >= 0;) { + var stat = statements[i]; + var j = next_index(i); + var next = statements[j]; + + if (in_lambda && declare_only && !next && stat instanceof AST_Return + && drop_return_void && !(self instanceof AST_SwitchBranch)) { + var body = stat.value; + if (!body) { + changed = true; + statements.splice(i, 1); + continue; + } + var tail = body.tail_node(); + if (is_undefined(tail)) { + changed = true; + if (body instanceof AST_UnaryPrefix) { + body = body.expression; + } else if (tail instanceof AST_UnaryPrefix) { + body = body.clone(); + body.expressions[body.expressions.length - 1] = tail.expression; + } + statements[i] = make_node(AST_SimpleStatement, stat, { body: body }); + continue; + } + } + + if (stat instanceof AST_If) { + var ab = aborts(stat.body); + // if (foo()) { bar(); return; } else baz(); moo(); ---> if (foo()) bar(); else { baz(); moo(); } + if (can_merge_flow(ab)) { + if (ab.label) remove(ab.label.thedef.references, ab); + changed = true; + stat = stat.clone(); + stat.body = make_node(AST_BlockStatement, stat, { + body: as_statement_array_with_return(stat.body, ab), + }); + stat.alternative = make_node(AST_BlockStatement, stat, { + body: as_statement_array(stat.alternative).concat(extract_functions(merge_jump, jump)), + }); + adjust_refs(ab.value, merge_jump); + statements[i] = stat; + statements[i] = stat.transform(compressor); + continue; + } + // if (foo()) { bar(); return x; } return y; ---> if (!foo()) return y; bar(); return x; + if (ab && !stat.alternative && next instanceof AST_Jump) { + var cond = stat.condition; + var preference = i + 1 == j && stat.body instanceof AST_BlockStatement; + cond = best_of_expression(cond, cond.negate(compressor), preference); + if (cond !== stat.condition) { + changed = true; + stat = stat.clone(); + stat.condition = cond; + var body = stat.body; + stat.body = make_node(AST_BlockStatement, next, { + body: extract_functions(true, null, j + 1), + }); + statements.splice(i, 1, stat, body); + // proceed further only if `TreeWalker.stack` is in a consistent state + // https://github.com/mishoo/UglifyJS/issues/5595 + // https://github.com/mishoo/UglifyJS/issues/5597 + if (!in_lambda || self instanceof AST_Block && self.body === statements) { + statements[i] = stat.transform(compressor); + } + continue; + } + } + var alt = aborts(stat.alternative); + // if (foo()) bar(); else { baz(); return; } moo(); ---> if (foo()) { bar(); moo(); } else baz(); + if (can_merge_flow(alt)) { + if (alt.label) remove(alt.label.thedef.references, alt); + changed = true; + stat = stat.clone(); + stat.body = make_node(AST_BlockStatement, stat.body, { + body: as_statement_array(stat.body).concat(extract_functions(merge_jump, jump)), + }); + stat.alternative = make_node(AST_BlockStatement, stat.alternative, { + body: as_statement_array_with_return(stat.alternative, alt), + }); + adjust_refs(alt.value, merge_jump); + statements[i] = stat; + statements[i] = stat.transform(compressor); + continue; + } + if (compressor.option("typeofs")) { + if (ab && !alt) { + var stats = make_node(AST_BlockStatement, self, { body: statements.slice(i + 1) }); + mark_locally_defined(stat.condition, null, stats); + } + if (!ab && alt) { + var stats = make_node(AST_BlockStatement, self, { body: statements.slice(i + 1) }); + mark_locally_defined(stat.condition, stats); + } + } + } + + if (stat instanceof AST_If && stat.body instanceof AST_Return) { + var value = stat.body.value; + var in_bool = stat.body.in_bool || next instanceof AST_Return && next.in_bool; + // if (foo()) return x; return y; ---> return foo() ? x : y; + if (!stat.alternative && next instanceof AST_Return + && (drop_return_void || !value == !next.value)) { + changed = true; + stat = stat.clone(); + stat.alternative = make_node(AST_BlockStatement, next, { + body: extract_functions(true, null, j + 1), + }); + statements[i] = stat; + statements[i] = stat.transform(compressor); + continue; + } + // if (foo()) return x; [ return ; ] ---> return foo() ? x : undefined; + // if (foo()) return bar() ? x : void 0; ---> return foo() && bar() ? x : void 0; + // if (foo()) return bar() ? void 0 : x; ---> return !foo() || bar() ? void 0 : x; + if (in_lambda && declare_only && !next && !stat.alternative && (in_bool + || value && multiple_if_returns + || value instanceof AST_Conditional && (is_undefined(value.consequent, compressor) + || is_undefined(value.alternative, compressor)))) { + changed = true; + stat = stat.clone(); + stat.alternative = make_node(AST_Return, stat, { value: null }); + statements[i] = stat; + statements[i] = stat.transform(compressor); + continue; + } + // if (a) return b; if (c) return d; e; ---> return a ? b : c ? d : void e; + // + // if sequences is not enabled, this can lead to an endless loop (issue #866). + // however, with sequences on this helps producing slightly better output for + // the example code. + var prev, prev_stat; + if (chain_if_returns && !stat.alternative + && (!(prev_stat = statements[prev = prev_index(i)]) && in_iife + || prev_stat instanceof AST_If && prev_stat.body instanceof AST_Return) + && (!next ? !declare_only + : next instanceof AST_SimpleStatement && next_index(j) == statements.length)) { + changed = true; + var exprs = []; + stat = stat.clone(); + exprs.push(stat.condition); + stat.condition = make_sequence(stat, exprs); + stat.alternative = make_node(AST_BlockStatement, self, { + body: extract_functions().concat(make_node(AST_Return, self, { value: null })), + }); + statements[i] = stat.transform(compressor); + i = prev + 1; + continue; + } + } + + if (stat instanceof AST_Break || stat instanceof AST_Exit) { + jump = stat; + continue; + } + + if (declare_only && jump && jump === next) eliminate_returns(stat); + } + return changed; + + function has_multiple_if_returns(statements) { + var n = 0; + for (var i = statements.length; --i >= 0;) { + var stat = statements[i]; + if (stat instanceof AST_If && stat.body instanceof AST_Return) { + if (++n > 1) return true; + } + } + return false; + } + + function match_target(target) { + return last_of(compressor, function(node) { + return node === target; + }); + } + + function match_return(ab, exact) { + if (!jump) return false; + if (jump.TYPE != ab.TYPE) return false; + var value = ab.value; + if (!value) return false; + var equals = jump.equals(ab); + if (!equals && value instanceof AST_Sequence) { + value = value.tail_node(); + if (jump.value && jump.value.equals(value)) equals = 2; + } + if (!equals && !exact && jump.value instanceof AST_Sequence) { + if (jump.value.tail_node().equals(value)) equals = 3; + } + return equals; + } + + function can_drop_abort(ab) { + if (ab instanceof AST_Exit) { + if (merge_jump = match_return(ab)) return true; + if (!in_lambda) return false; + if (!(ab instanceof AST_Return)) return false; + var value = ab.value; + if (value) { + if (!drop_return_void) return false; + if (!is_undefined(value.tail_node())) return false; + } + if (!(self instanceof AST_SwitchBranch)) return true; + if (!jump) return false; + if (jump instanceof AST_Exit && jump.value) return false; + merge_jump = 4; + return true; + } + if (!(ab instanceof AST_LoopControl)) return false; + if (self instanceof AST_SwitchBranch) { + if (jump instanceof AST_Exit) { + if (!in_lambda) return false; + if (jump.value) return false; + merge_jump = true; + } else if (jump) { + if (compressor.loopcontrol_target(jump) !== parent) return false; + merge_jump = true; + } else if (jump === false) { + return false; + } + } + var lct = compressor.loopcontrol_target(ab); + if (ab instanceof AST_Continue) return match_target(loop_body(lct)); + if (lct instanceof AST_IterationStatement) return false; + return match_target(lct); + } + + function can_merge_flow(ab) { + merge_jump = false; + if (!can_drop_abort(ab)) return false; + for (var j = statements.length; --j > i;) { + var stat = statements[j]; + if (stat instanceof AST_DefClass) { + if (stat.name.definition().preinit) return false; + } else if (stat instanceof AST_Const || stat instanceof AST_Let) { + if (!all(stat.definitions, function(defn) { + return !defn.name.match_symbol(function(node) { + return node instanceof AST_SymbolDeclaration && node.definition().preinit; + }); + })) return false; + } + } + return true; + } + + function extract_functions(mode, stop, end) { + var defuns = []; + var lexical = false; + var start = i + 1; + if (!mode) { + end = statements.length; + jump = null; + } else if (stop) { + end = statements.lastIndexOf(stop); + } else { + stop = statements[end]; + if (stop !== jump) jump = false; + } + var tail = statements.splice(start, end - start).filter(function(stat) { + if (stat instanceof AST_LambdaDefinition) { + defuns.push(stat); + return false; + } + if (is_lexical_definition(stat)) lexical = true; + return true; + }); + if (mode === 3) { + tail.push(make_node(AST_SimpleStatement, stop.value, { + body: make_sequence(stop.value, stop.value.expressions.slice(0, -1)), + })); + stop.value = stop.value.tail_node(); + } + [].push.apply(lexical ? tail : statements, defuns); + return tail; + } + + function trim_return(value, mode) { + if (value) switch (mode) { + case 4: + return value; + case 3: + if (!(value instanceof AST_Sequence)) break; + case 2: + return make_sequence(value, value.expressions.slice(0, -1)); + } + } + + function as_statement_array_with_return(node, ab) { + var body = as_statement_array(node); + var block = body, last; + while ((last = block[block.length - 1]) !== ab) { + block = last.body; + } + block.pop(); + var value = ab.value; + if (merge_jump) value = trim_return(value, merge_jump); + if (value) block.push(make_node(AST_SimpleStatement, value, { body: value })); + return body; + } + + function adjust_refs(value, mode) { + if (!mode) return; + if (!value) return; + switch (mode) { + case 4: + return; + case 3: + case 2: + value = value.tail_node(); + } + merge_expression(value, jump.value); + } + + function next_index(i) { + declare_only = true; + for (var j = i; ++j < statements.length;) { + var stat = statements[j]; + if (is_declaration(stat)) continue; + if (stat instanceof AST_Var) { + declare_only = false; + continue; + } + break; + } + return j; + } + + function prev_index(i) { + for (var j = i; --j >= 0;) { + var stat = statements[j]; + if (stat instanceof AST_Var) continue; + if (is_declaration(stat)) continue; + break; + } + return j; + } + + function eliminate_returns(stat, keep_throws, in_block) { + if (stat instanceof AST_Exit) { + var mode = !(keep_throws && stat instanceof AST_Throw) && match_return(stat, true); + if (mode) { + changed = true; + var value = trim_return(stat.value, mode); + if (value) return make_node(AST_SimpleStatement, value, { body: value }); + return in_block ? null : make_node(AST_EmptyStatement, stat); + } + } else if (stat instanceof AST_If) { + stat.body = eliminate_returns(stat.body, keep_throws); + if (stat.alternative) stat.alternative = eliminate_returns(stat.alternative, keep_throws); + } else if (stat instanceof AST_LabeledStatement) { + stat.body = eliminate_returns(stat.body, keep_throws); + } else if (stat instanceof AST_Try) { + if (!stat.bfinally || !jump.value || jump.value.is_constant()) { + if (stat.bcatch) eliminate_returns(stat.bcatch, keep_throws); + var trimmed = eliminate_returns(stat.body.pop(), true, true); + if (trimmed) stat.body.push(trimmed); + } + } else if (stat instanceof AST_Block && !(stat instanceof AST_Scope || stat instanceof AST_Switch)) { + var trimmed = eliminate_returns(stat.body.pop(), keep_throws, true); + if (trimmed) stat.body.push(trimmed); + } + return stat; + } + } + + function eliminate_dead_code(statements, compressor) { + var has_quit; + var self = compressor.self(); + if (self instanceof AST_Catch) { + self = compressor.parent(); + } else if (self instanceof AST_LabeledStatement) { + self = self.body; + } + for (var i = 0, n = 0, len = statements.length; i < len; i++) { + var stat = statements[i]; + if (stat instanceof AST_LoopControl) { + var lct = compressor.loopcontrol_target(stat); + if (loop_body(lct) !== self + || stat instanceof AST_Break && lct instanceof AST_IterationStatement) { + statements[n++] = stat; + } else if (stat.label) { + remove(stat.label.thedef.references, stat); + } + } else { + statements[n++] = stat; + } + if (aborts(stat)) { + has_quit = statements.slice(i + 1); + break; + } + } + statements.length = n; + if (has_quit) has_quit.forEach(function(stat) { + extract_declarations_from_unreachable_code(compressor, stat, statements); + }); + return statements.length != len; + } + + function trim_awaits(statements, compressor) { + if (!in_lambda || in_try && in_try.bfinally) return; + var changed = false; + for (var index = statements.length; --index >= 0;) { + var stat = statements[index]; + if (!(stat instanceof AST_SimpleStatement)) break; + var node = stat.body.tail_node(); + if (!(node instanceof AST_Await)) break; + var exp = node.expression; + if (!needs_enqueuing(compressor, exp)) break; + changed = true; + exp = exp.drop_side_effect_free(compressor, true); + if (stat.body instanceof AST_Sequence) { + var expressions = stat.body.expressions.slice(); + expressions.pop(); + if (exp) expressions.push(exp); + stat.body = make_sequence(stat.body, expressions); + break; + } + if (exp) { + stat.body = exp; + break; + } + } + statements.length = index + 1; + return changed; + } + + function inline_iife(statements, compressor) { + var changed = false; + var index = statements.length - 1; + if (in_lambda && index >= 0) { + var no_return = in_try && in_try.bfinally && in_async_generator(scope); + var inlined = statements[index].try_inline(compressor, block_scope, no_return); + if (inlined) { + statements[index--] = inlined; + changed = true; + } + } + var loop = in_loop && in_try ? "try" : in_loop; + for (; index >= 0; index--) { + var inlined = statements[index].try_inline(compressor, block_scope, true, loop); + if (!inlined) continue; + statements[index] = inlined; + changed = true; + } + return changed; + } + + function sequencesize(statements, compressor) { + if (statements.length < 2) return; + var seq = [], n = 0; + function push_seq() { + if (!seq.length) return; + var body = make_sequence(seq[0], seq); + statements[n++] = make_node(AST_SimpleStatement, body, { body: body }); + seq = []; + } + for (var i = 0, len = statements.length; i < len; i++) { + var stat = statements[i]; + if (stat instanceof AST_SimpleStatement) { + if (seq.length >= compressor.sequences_limit) push_seq(); + merge_sequence(seq, stat.body); + } else if (is_declaration(stat)) { + statements[n++] = stat; + } else { + push_seq(); + statements[n++] = stat; + } + } + push_seq(); + statements.length = n; + return n != len; + } + + function to_simple_statement(block, decls) { + if (!(block instanceof AST_BlockStatement)) return block; + var stat = null; + for (var i = 0; i < block.body.length; i++) { + var line = block.body[i]; + if (line instanceof AST_Var && declarations_only(line)) { + decls.push(line); + } else if (stat || is_lexical_definition(line)) { + return false; + } else { + stat = line; + } + } + return stat; + } + + function sequencesize_2(statements, compressor) { + var changed = false, n = 0, prev; + for (var i = 0; i < statements.length; i++) { + var stat = statements[i]; + if (prev) { + if (stat instanceof AST_Exit) { + if (stat.value || !in_async_generator(scope)) { + stat.value = cons_seq(stat.value || make_node(AST_Undefined, stat)).optimize(compressor); + } + } else if (stat instanceof AST_For) { + if (!(stat.init instanceof AST_Definitions)) { + var abort = false; + prev.body.walk(new TreeWalker(function(node) { + if (abort || node instanceof AST_Scope) return true; + if (node instanceof AST_Binary && node.operator == "in") { + abort = true; + return true; + } + })); + if (!abort) { + if (stat.init) stat.init = cons_seq(stat.init); + else { + stat.init = prev.body; + n--; + changed = true; + } + } + } + } else if (stat instanceof AST_ForIn) { + if (!is_lexical_definition(stat.init)) stat.object = cons_seq(stat.object); + } else if (stat instanceof AST_If) { + stat.condition = cons_seq(stat.condition); + } else if (stat instanceof AST_Switch) { + stat.expression = cons_seq(stat.expression); + } else if (stat instanceof AST_With) { + stat.expression = cons_seq(stat.expression); + } + } + if (compressor.option("conditionals") && stat instanceof AST_If) { + var decls = []; + var body = to_simple_statement(stat.body, decls); + var alt = to_simple_statement(stat.alternative, decls); + if (body !== false && alt !== false && decls.length > 0) { + var len = decls.length; + decls.push(make_node(AST_If, stat, { + condition: stat.condition, + body: body || make_node(AST_EmptyStatement, stat.body), + alternative: alt, + })); + decls.unshift(n, 1); + [].splice.apply(statements, decls); + i += len; + n += len + 1; + prev = null; + changed = true; + continue; + } + } + statements[n++] = stat; + prev = stat instanceof AST_SimpleStatement ? stat : null; + } + statements.length = n; + return changed; + + function cons_seq(right) { + n--; + changed = true; + var left = prev.body; + return make_sequence(left, [ left, right ]); + } + } + + function extract_exprs(body) { + if (body instanceof AST_Assign) return [ body ]; + if (body instanceof AST_Sequence) return body.expressions.slice(); + } + + function join_assigns(defn, body, keep) { + var exprs = extract_exprs(body); + if (!exprs) return; + keep = keep || 0; + var trimmed = false; + for (var i = exprs.length - keep; --i >= 0;) { + var expr = exprs[i]; + if (!can_trim(expr)) continue; + var tail; + if (expr.left instanceof AST_SymbolRef) { + tail = exprs.slice(i + 1); + } else if (expr.left instanceof AST_PropAccess && can_trim(expr.left.expression)) { + tail = exprs.slice(i + 1); + var flattened = expr.clone(); + expr = expr.left.expression; + flattened.left = flattened.left.clone(); + flattened.left.expression = expr.left.clone(); + tail.unshift(flattened); + } else { + continue; + } + if (tail.length == 0) continue; + if (!trim_assigns(expr.left, expr.right, tail)) continue; + trimmed = true; + exprs = exprs.slice(0, i).concat(expr, tail); + } + if (defn instanceof AST_Definitions) { + for (var i = defn.definitions.length; --i >= 0;) { + var def = defn.definitions[i]; + if (!def.value) continue; + if (trim_assigns(def.name, def.value, exprs)) trimmed = true; + if (merge_conditional_assignments(def, exprs, keep)) trimmed = true; + break; + } + if (defn instanceof AST_Var && join_var_assign(defn.definitions, exprs, keep)) trimmed = true; + } + return trimmed && exprs; + + function can_trim(node) { + return node instanceof AST_Assign && node.operator == "="; + } + } + + function merge_assigns(prev, defn) { + if (!(prev instanceof AST_SimpleStatement)) return; + if (declarations_only(defn)) return; + var exprs = extract_exprs(prev.body); + if (!exprs) return; + var definitions = []; + if (!join_var_assign(definitions, exprs.reverse(), 0)) return; + defn.definitions = definitions.reverse().concat(defn.definitions); + return exprs.reverse(); + } + + function merge_conditional_assignments(var_def, exprs, keep) { + if (!compressor.option("conditionals")) return; + if (var_def.name instanceof AST_Destructured) return; + var trimmed = false; + var def = var_def.name.definition(); + while (exprs.length > keep) { + var cond = to_conditional_assignment(compressor, def, var_def.value, exprs[0]); + if (!cond) break; + var_def.value = cond; + exprs.shift(); + trimmed = true; + } + return trimmed; + } + + function join_var_assign(definitions, exprs, keep) { + var trimmed = false; + while (exprs.length > keep) { + var expr = exprs[0]; + if (!(expr instanceof AST_Assign)) break; + if (expr.operator != "=") break; + var lhs = expr.left; + if (!(lhs instanceof AST_SymbolRef)) break; + if (is_undeclared_ref(lhs)) break; + if (lhs.scope.resolve() !== scope) break; + var def = lhs.definition(); + if (def.scope !== scope) break; + if (def.orig.length > def.eliminated + 1) break; + if (def.orig[0].TYPE != "SymbolVar") break; + var name = make_node(AST_SymbolVar, lhs); + definitions.push(make_node(AST_VarDef, expr, { + name: name, + value: expr.right, + })); + def.orig.push(name); + def.replaced++; + exprs.shift(); + trimmed = true; + } + return trimmed; + } + + function trim_assigns(name, value, exprs) { + var names = new Dictionary(); + names.set(name.name, true); + while (value instanceof AST_Assign && value.operator == "=") { + if (value.left instanceof AST_SymbolRef) names.set(value.left.name, true); + value = value.right; + } + if (value instanceof AST_Array) { + var trimmed = false; + do { + if (!try_join_array(exprs[0])) break; + exprs.shift(); + trimmed = true; + } while (exprs.length); + return trimmed; + } else if (value instanceof AST_Object) { + var trimmed = false; + do { + if (!try_join_object(exprs[0])) break; + exprs.shift(); + trimmed = true; + } while (exprs.length); + return trimmed; + } + + function try_join_array(node) { + if (!(node instanceof AST_Assign)) return; + if (node.operator != "=") return; + if (!(node.left instanceof AST_PropAccess)) return; + var sym = node.left.expression; + if (!(sym instanceof AST_SymbolRef)) return; + if (!names.has(sym.name)) return; + if (!node.right.is_constant_expression(scope)) return; + var prop = node.left.property; + if (prop instanceof AST_Node) { + if (try_join_array(prop)) prop = node.left.property = prop.right.clone(); + prop = prop.evaluate(compressor); + } + if (prop instanceof AST_Node) return; + if (!RE_POSITIVE_INTEGER.test("" + prop)) return; + prop = +prop; + var elements = value.elements; + var len = elements.length; + if (prop > len + 4) return; + for (var i = Math.min(len, prop + 1); --i >= 0;) { + if (elements[i] instanceof AST_Spread) return; + } + if (prop < len) { + var element = elements[prop].drop_side_effect_free(compressor); + elements[prop] = element ? make_sequence(node, [ element, node.right ]) : node.right; + } else { + while (prop > len) elements[len++] = make_node(AST_Hole, value); + elements[prop] = node.right; + } + return true; + } + + function try_join_object(node) { + if (!(node instanceof AST_Assign)) return; + if (node.operator != "=") return; + if (!(node.left instanceof AST_PropAccess)) return; + var sym = node.left.expression; + if (!(sym instanceof AST_SymbolRef)) return; + if (!names.has(sym.name)) return; + if (!node.right.is_constant_expression(scope)) return; + var prop = node.left.property; + if (prop instanceof AST_Node) { + if (try_join_object(prop)) prop = node.left.property = prop.right.clone(); + prop = prop.evaluate(compressor); + } + if (prop instanceof AST_Node) return; + prop = "" + prop; + var diff = prop == "__proto__" || compressor.has_directive("use strict") ? function(node) { + var key = node.key; + return typeof key == "string" && key != prop && key != "__proto__"; + } : function(node) { + var key = node.key; + if (node instanceof AST_ObjectGetter || node instanceof AST_ObjectSetter) { + return typeof key == "string" && key != prop; + } + return key !== "__proto__"; + }; + if (!all(value.properties, diff)) return; + value.properties.push(make_node(AST_ObjectKeyVal, node, { + key: prop, + value: node.right, + })); + return true; + } + } + + function join_consecutive_vars(statements) { + var changed = false, defs, prev_defs; + for (var i = 0, j = -1; i < statements.length; i++) { + var stat = statements[i]; + var prev = statements[j]; + if (stat instanceof AST_Definitions) { + if (prev && prev.TYPE == stat.TYPE) { + prev.definitions = prev.definitions.concat(stat.definitions); + changed = true; + } else if (stat && prev instanceof AST_Let && stat.can_letify(compressor)) { + prev.definitions = prev.definitions.concat(to_let(stat, block_scope).definitions); + changed = true; + } else if (prev && stat instanceof AST_Let && prev.can_letify(compressor)) { + defs = prev_defs; + statements[j] = prev = to_let(prev, block_scope); + prev.definitions = prev.definitions.concat(stat.definitions); + changed = true; + } else if (defs && defs.TYPE == stat.TYPE && declarations_only(stat)) { + defs.definitions = defs.definitions.concat(stat.definitions); + changed = true; + } else if (stat instanceof AST_Var) { + var exprs = merge_assigns(prev, stat); + if (exprs) { + if (exprs.length) { + prev.body = make_sequence(prev, exprs); + j++; + } + changed = true; + } else { + j++; + } + prev_defs = defs; + statements[j] = defs = stat; + } else { + statements[++j] = stat; + } + continue; + } else if (stat instanceof AST_Exit) { + stat.value = join_assigns_expr(stat.value); + } else if (stat instanceof AST_For) { + var exprs = join_assigns(prev, stat.init); + if (exprs) { + changed = true; + stat.init = exprs.length ? make_sequence(stat.init, exprs) : null; + } else if (prev instanceof AST_Var && (!stat.init || stat.init.TYPE == prev.TYPE)) { + if (stat.init) { + prev.definitions = prev.definitions.concat(stat.init.definitions); + } + stat = stat.clone(); + prev_defs = defs; + defs = stat.init = prev; + statements[j] = merge_defns(stat); + changed = true; + continue; + } else if (defs && stat.init && defs.TYPE == stat.init.TYPE && declarations_only(stat.init)) { + defs.definitions = defs.definitions.concat(stat.init.definitions); + stat.init = null; + changed = true; + } else if (stat.init instanceof AST_Var) { + prev_defs = defs; + defs = stat.init; + exprs = merge_assigns(prev, stat.init); + if (exprs) { + changed = true; + if (exprs.length == 0) { + statements[j] = merge_defns(stat); + continue; + } + prev.body = make_sequence(prev, exprs); + } + } + } else if (stat instanceof AST_ForEnumeration) { + if (defs && defs.TYPE == stat.init.TYPE) { + var defns = defs.definitions.slice(); + stat.init = stat.init.definitions[0].name.convert_symbol(AST_SymbolRef, function(ref, name) { + defns.push(make_node(AST_VarDef, name, { + name: name, + value: null, + })); + name.definition().references.push(ref); + }); + defs.definitions = defns; + changed = true; + } + stat.object = join_assigns_expr(stat.object); + } else if (stat instanceof AST_If) { + stat.condition = join_assigns_expr(stat.condition); + } else if (stat instanceof AST_SimpleStatement) { + var exprs = join_assigns(prev, stat.body), next; + if (exprs) { + changed = true; + if (!exprs.length) continue; + stat.body = make_sequence(stat.body, exprs); + } else if (prev instanceof AST_Definitions + && (next = statements[i + 1]) + && prev.TYPE == next.TYPE + && (next = next.definitions[0]).value) { + changed = true; + next.value = make_sequence(stat, [ stat.body, next.value ]); + continue; + } + } else if (stat instanceof AST_Switch) { + stat.expression = join_assigns_expr(stat.expression); + } else if (stat instanceof AST_With) { + stat.expression = join_assigns_expr(stat.expression); + } + statements[++j] = defs ? merge_defns(stat) : stat; + } + statements.length = j + 1; + return changed; + + function join_assigns_expr(value) { + var exprs = join_assigns(prev, value, 1); + if (!exprs) return value; + changed = true; + var tail = value.tail_node(); + if (exprs[exprs.length - 1] !== tail) exprs.push(tail.left); + return make_sequence(value, exprs); + } + + function merge_defns(stat) { + return stat.transform(new TreeTransformer(function(node, descend, in_list) { + if (node instanceof AST_Definitions) { + if (defs === node) return node; + if (defs.TYPE != node.TYPE) return node; + var parent = this.parent(); + if (parent instanceof AST_ForEnumeration && parent.init === node) return node; + if (!declarations_only(node)) return node; + defs.definitions = defs.definitions.concat(node.definitions); + changed = true; + if (parent instanceof AST_For && parent.init === node) return null; + return in_list ? List.skip : make_node(AST_EmptyStatement, node); + } + if (node instanceof AST_ExportDeclaration) return node; + if (node instanceof AST_Scope) return node; + if (!is_statement(node)) return node; + })); + } + } + } + + function extract_declarations_from_unreachable_code(compressor, stat, target) { + var block; + var dropped = false; + stat.walk(new TreeWalker(function(node, descend) { + if (node instanceof AST_DefClass) { + node.extends = null; + node.properties = []; + push(node); + return true; + } + if (node instanceof AST_Definitions) { + var defns = []; + if (node.remove_initializers(compressor, defns)) { + AST_Node.warn("Dropping initialization in unreachable code [{start}]", node); + } + if (defns.length > 0) { + node.definitions = defns; + push(node); + } + return true; + } + if (node instanceof AST_LambdaDefinition) { + push(node); + return true; + } + if (node instanceof AST_Scope) return true; + if (node instanceof AST_BlockScope) { + var save = block; + block = []; + descend(); + if (block.required) { + target.push(make_node(AST_BlockStatement, stat, { body: block })); + } else if (block.length) { + [].push.apply(target, block); + } + block = save; + return true; + } + if (!(node instanceof AST_LoopControl)) dropped = true; + })); + if (dropped) AST_Node.warn("Dropping unreachable code [{start}]", stat); + + function push(node) { + if (block) { + block.push(node); + if (!safe_to_trim(node)) block.required = true; + } else { + target.push(node); + } + } + } + + function is_undefined(node, compressor) { + return node == null + || node.is_undefined + || node instanceof AST_Undefined + || node instanceof AST_UnaryPrefix + && node.operator == "void" + && !(compressor && node.expression.has_side_effects(compressor)); + } + + // in_strict_mode() + // return true if scope executes in Strict Mode + (function(def) { + def(AST_Class, return_true); + def(AST_Scope, function(compressor) { + var body = this.body; + for (var i = 0; i < body.length; i++) { + var stat = body[i]; + if (!(stat instanceof AST_Directive)) break; + if (stat.value == "use strict") return true; + } + var parent = this.parent_scope; + if (!parent) return compressor.option("module"); + return parent.resolve(true).in_strict_mode(compressor); + }); + })(function(node, func) { + node.DEFMETHOD("in_strict_mode", func); + }); + + // is_truthy() + // return true if `!!node === true` + (function(def) { + def(AST_Node, return_false); + def(AST_Array, return_true); + def(AST_Assign, function() { + return this.operator == "=" && this.right.is_truthy(); + }); + def(AST_Lambda, return_true); + def(AST_Object, return_true); + def(AST_RegExp, return_true); + def(AST_Sequence, function() { + return this.tail_node().is_truthy(); + }); + def(AST_SymbolRef, function() { + var fixed = this.fixed_value(); + if (!fixed) return false; + this.is_truthy = return_false; + var result = fixed.is_truthy(); + delete this.is_truthy; + return result; + }); + })(function(node, func) { + node.DEFMETHOD("is_truthy", func); + }); + + // is_negative_zero() + // return true if the node may represent -0 + (function(def) { + def(AST_Node, return_true); + def(AST_Array, return_false); + function binary(op, left, right) { + switch (op) { + case "-": + return left.is_negative_zero() + && (!(right instanceof AST_Constant) || right.value == 0); + case "&&": + case "||": + return left.is_negative_zero() || right.is_negative_zero(); + case "*": + case "/": + case "%": + case "**": + return true; + default: + return false; + } + } + def(AST_Assign, function() { + var op = this.operator; + if (op == "=") return this.right.is_negative_zero(); + return binary(op.slice(0, -1), this.left, this.right); + }); + def(AST_Binary, function() { + return binary(this.operator, this.left, this.right); + }); + def(AST_Constant, function() { + return this.value == 0 && 1 / this.value < 0; + }); + def(AST_Lambda, return_false); + def(AST_Object, return_false); + def(AST_RegExp, return_false); + def(AST_Sequence, function() { + return this.tail_node().is_negative_zero(); + }); + def(AST_SymbolRef, function() { + var fixed = this.fixed_value(); + if (!fixed) return true; + this.is_negative_zero = return_true; + var result = fixed.is_negative_zero(); + delete this.is_negative_zero; + return result; + }); + def(AST_UnaryPrefix, function() { + return this.operator == "+" && this.expression.is_negative_zero() + || this.operator == "-"; + }); + })(function(node, func) { + node.DEFMETHOD("is_negative_zero", func); + }); + + // may_throw_on_access() + // returns true if this node may be null, undefined or contain `AST_Accessor` + (function(def) { + AST_Node.DEFMETHOD("may_throw_on_access", function(compressor, force) { + return !compressor.option("pure_getters") || this._dot_throw(compressor, force); + }); + function is_strict(compressor, force) { + return force || /strict/.test(compressor.option("pure_getters")); + } + def(AST_Node, is_strict); + def(AST_Array, return_false); + def(AST_Assign, function(compressor) { + var op = this.operator; + var sym = this.left; + var rhs = this.right; + if (op != "=") { + return lazy_op[op.slice(0, -1)] && (sym._dot_throw(compressor) || rhs._dot_throw(compressor)); + } + if (!rhs._dot_throw(compressor)) return false; + if (!(sym instanceof AST_SymbolRef)) return true; + if (rhs instanceof AST_Binary && rhs.operator == "||" && sym.name == rhs.left.name) { + return rhs.right._dot_throw(compressor); + } + return true; + }); + def(AST_Binary, function(compressor) { + return lazy_op[this.operator] && (this.left._dot_throw(compressor) || this.right._dot_throw(compressor)); + }); + def(AST_Class, function(compressor, force) { + return is_strict(compressor, force) && !all(this.properties, function(prop) { + if (prop.private) return true; + if (!prop.static) return true; + return !(prop instanceof AST_ClassGetter || prop instanceof AST_ClassSetter); + }); + }); + def(AST_Conditional, function(compressor) { + return this.consequent._dot_throw(compressor) || this.alternative._dot_throw(compressor); + }); + def(AST_Constant, return_false); + def(AST_Dot, function(compressor, force) { + if (!is_strict(compressor, force)) return false; + var exp = this.expression; + if (exp instanceof AST_SymbolRef) exp = exp.fixed_value(); + return !(this.property == "prototype" && is_lambda(exp)); + }); + def(AST_Lambda, return_false); + def(AST_Null, return_true); + def(AST_Object, function(compressor, force) { + return is_strict(compressor, force) && !all(this.properties, function(prop) { + if (prop instanceof AST_ObjectGetter || prop instanceof AST_ObjectSetter) return false; + return !(prop.key === "__proto__" && prop.value._dot_throw(compressor, force)); + }); + }); + def(AST_ObjectIdentity, function(compressor, force) { + return is_strict(compressor, force) && !this.scope.resolve().new; + }); + def(AST_Sequence, function(compressor) { + return this.tail_node()._dot_throw(compressor); + }); + def(AST_SymbolRef, function(compressor, force) { + if (this.defined) return false; + if (this.is_undefined) return true; + if (!is_strict(compressor, force)) return false; + if (is_undeclared_ref(this) && this.is_declared(compressor)) return false; + if (this.is_immutable()) return false; + var def = this.definition(); + if (is_arguments(def) && !def.scope.rest && all(def.scope.argnames, function(argname) { + return argname instanceof AST_SymbolFunarg; + })) return def.scope.uses_arguments > 2; + var fixed = this.fixed_value(true); + if (!fixed) return true; + this._dot_throw = return_true; + if (fixed._dot_throw(compressor)) { + delete this._dot_throw; + return true; + } + this._dot_throw = return_false; + return false; + }); + def(AST_UnaryPrefix, function() { + return this.operator == "void"; + }); + def(AST_UnaryPostfix, return_false); + def(AST_Undefined, return_true); + })(function(node, func) { + node.DEFMETHOD("_dot_throw", func); + }); + + (function(def) { + def(AST_Node, return_false); + def(AST_Array, return_true); + function is_binary_defined(compressor, op, node) { + switch (op) { + case "&&": + return node.left.is_defined(compressor) && node.right.is_defined(compressor); + case "||": + return node.left.is_truthy() || node.right.is_defined(compressor); + case "??": + return node.left.is_defined(compressor) || node.right.is_defined(compressor); + default: + return true; + } + } + def(AST_Assign, function(compressor) { + var op = this.operator; + if (op == "=") return this.right.is_defined(compressor); + return is_binary_defined(compressor, op.slice(0, -1), this); + }); + def(AST_Binary, function(compressor) { + return is_binary_defined(compressor, this.operator, this); + }); + def(AST_Conditional, function(compressor) { + return this.consequent.is_defined(compressor) && this.alternative.is_defined(compressor); + }); + def(AST_Constant, return_true); + def(AST_Hole, return_false); + def(AST_Lambda, return_true); + def(AST_Object, return_true); + def(AST_Sequence, function(compressor) { + return this.tail_node().is_defined(compressor); + }); + def(AST_SymbolRef, function(compressor) { + if (this.is_undefined) return false; + if (is_undeclared_ref(this) && this.is_declared(compressor)) return true; + if (this.is_immutable()) return true; + var fixed = this.fixed_value(); + if (!fixed) return false; + this.is_defined = return_false; + var result = fixed.is_defined(compressor); + delete this.is_defined; + return result; + }); + def(AST_UnaryPrefix, function() { + return this.operator != "void"; + }); + def(AST_UnaryPostfix, return_true); + def(AST_Undefined, return_false); + })(function(node, func) { + node.DEFMETHOD("is_defined", func); + }); + + /* -----[ boolean/negation helpers ]----- */ + + // methods to determine whether an expression has a boolean result type + (function(def) { + def(AST_Node, return_false); + def(AST_Assign, function(compressor) { + return this.operator == "=" && this.right.is_boolean(compressor); + }); + var binary = makePredicate("in instanceof == != === !== < <= >= >"); + def(AST_Binary, function(compressor) { + return binary[this.operator] || lazy_op[this.operator] + && this.left.is_boolean(compressor) + && this.right.is_boolean(compressor); + }); + def(AST_Boolean, return_true); + var fn = makePredicate("every hasOwnProperty isPrototypeOf propertyIsEnumerable some"); + def(AST_Call, function(compressor) { + if (!compressor.option("unsafe")) return false; + var exp = this.expression; + return exp instanceof AST_Dot && (fn[exp.property] + || exp.property == "test" && exp.expression instanceof AST_RegExp); + }); + def(AST_Conditional, function(compressor) { + return this.consequent.is_boolean(compressor) && this.alternative.is_boolean(compressor); + }); + def(AST_New, return_false); + def(AST_Sequence, function(compressor) { + return this.tail_node().is_boolean(compressor); + }); + def(AST_SymbolRef, function(compressor) { + var fixed = this.fixed_value(); + if (!fixed) return false; + this.is_boolean = return_false; + var result = fixed.is_boolean(compressor); + delete this.is_boolean; + return result; + }); + var unary = makePredicate("! delete"); + def(AST_UnaryPrefix, function() { + return unary[this.operator]; + }); + })(function(node, func) { + node.DEFMETHOD("is_boolean", func); + }); + + // methods to determine if an expression has a numeric result type + (function(def) { + def(AST_Node, return_false); + var binary = makePredicate("- * / % ** & | ^ << >> >>>"); + def(AST_Assign, function(compressor) { + return binary[this.operator.slice(0, -1)] + || this.operator == "=" && this.right.is_number(compressor); + }); + def(AST_Binary, function(compressor) { + if (binary[this.operator]) return true; + if (this.operator != "+") return false; + return (this.left.is_boolean(compressor) || this.left.is_number(compressor)) + && (this.right.is_boolean(compressor) || this.right.is_number(compressor)); + }); + var fn = makePredicate([ + "charCodeAt", + "getDate", + "getDay", + "getFullYear", + "getHours", + "getMilliseconds", + "getMinutes", + "getMonth", + "getSeconds", + "getTime", + "getTimezoneOffset", + "getUTCDate", + "getUTCDay", + "getUTCFullYear", + "getUTCHours", + "getUTCMilliseconds", + "getUTCMinutes", + "getUTCMonth", + "getUTCSeconds", + "getYear", + "indexOf", + "lastIndexOf", + "localeCompare", + "push", + "search", + "setDate", + "setFullYear", + "setHours", + "setMilliseconds", + "setMinutes", + "setMonth", + "setSeconds", + "setTime", + "setUTCDate", + "setUTCFullYear", + "setUTCHours", + "setUTCMilliseconds", + "setUTCMinutes", + "setUTCMonth", + "setUTCSeconds", + "setYear", + ]); + def(AST_Call, function(compressor) { + if (!compressor.option("unsafe")) return false; + var exp = this.expression; + return exp instanceof AST_Dot && (fn[exp.property] + || is_undeclared_ref(exp.expression) && exp.expression.name == "Math"); + }); + def(AST_Conditional, function(compressor) { + return this.consequent.is_number(compressor) && this.alternative.is_number(compressor); + }); + def(AST_New, return_false); + def(AST_Number, return_true); + def(AST_Sequence, function(compressor) { + return this.tail_node().is_number(compressor); + }); + def(AST_SymbolRef, function(compressor, keep_unary) { + var fixed = this.fixed_value(); + if (!fixed) return false; + if (keep_unary + && fixed instanceof AST_UnaryPrefix + && fixed.operator == "+" + && fixed.expression.equals(this)) { + return false; + } + this.is_number = return_false; + var result = fixed.is_number(compressor); + delete this.is_number; + return result; + }); + var unary = makePredicate("+ - ~ ++ --"); + def(AST_Unary, function() { + return unary[this.operator]; + }); + })(function(node, func) { + node.DEFMETHOD("is_number", func); + }); + + // methods to determine if an expression has a string result type + (function(def) { + def(AST_Node, return_false); + def(AST_Assign, function(compressor) { + switch (this.operator) { + case "+=": + if (this.left.is_string(compressor)) return true; + case "=": + return this.right.is_string(compressor); + } + }); + def(AST_Binary, function(compressor) { + return this.operator == "+" && + (this.left.is_string(compressor) || this.right.is_string(compressor)); + }); + var fn = makePredicate([ + "charAt", + "substr", + "substring", + "toExponential", + "toFixed", + "toLowerCase", + "toPrecision", + "toString", + "toUpperCase", + "trim", + ]); + def(AST_Call, function(compressor) { + if (!compressor.option("unsafe")) return false; + var exp = this.expression; + return exp instanceof AST_Dot && fn[exp.property]; + }); + def(AST_Conditional, function(compressor) { + return this.consequent.is_string(compressor) && this.alternative.is_string(compressor); + }); + def(AST_Sequence, function(compressor) { + return this.tail_node().is_string(compressor); + }); + def(AST_String, return_true); + def(AST_SymbolRef, function(compressor) { + var fixed = this.fixed_value(); + if (!fixed) return false; + this.is_string = return_false; + var result = fixed.is_string(compressor); + delete this.is_string; + return result; + }); + def(AST_Template, function(compressor) { + return !this.tag || is_raw_tag(compressor, this.tag); + }); + def(AST_UnaryPrefix, function() { + return this.operator == "typeof"; + }); + })(function(node, func) { + node.DEFMETHOD("is_string", func); + }); + + var lazy_op = makePredicate("&& || ??"); + + (function(def) { + function to_node(value, orig) { + if (value instanceof AST_Node) return value.clone(true); + if (Array.isArray(value)) return make_node(AST_Array, orig, { + elements: value.map(function(value) { + return to_node(value, orig); + }) + }); + if (value && typeof value == "object") { + var props = []; + for (var key in value) if (HOP(value, key)) { + props.push(make_node(AST_ObjectKeyVal, orig, { + key: key, + value: to_node(value[key], orig), + })); + } + return make_node(AST_Object, orig, { properties: props }); + } + return make_node_from_constant(value, orig); + } + + function warn(node) { + AST_Node.warn("global_defs {this} redefined [{start}]", node); + } + + AST_Toplevel.DEFMETHOD("resolve_defines", function(compressor) { + if (!compressor.option("global_defs")) return this; + this.figure_out_scope({ ie: compressor.option("ie") }); + return this.transform(new TreeTransformer(function(node) { + var def = node._find_defs(compressor, ""); + if (!def) return; + var level = 0, child = node, parent; + while (parent = this.parent(level++)) { + if (!(parent instanceof AST_PropAccess)) break; + if (parent.expression !== child) break; + child = parent; + } + if (is_lhs(child, parent)) { + warn(node); + return; + } + return def; + })); + }); + def(AST_Node, noop); + def(AST_Dot, function(compressor, suffix) { + return this.expression._find_defs(compressor, "." + this.property + suffix); + }); + def(AST_SymbolDeclaration, function(compressor) { + if (!this.definition().global) return; + if (HOP(compressor.option("global_defs"), this.name)) warn(this); + }); + def(AST_SymbolRef, function(compressor, suffix) { + if (!this.definition().global) return; + var defines = compressor.option("global_defs"); + var name = this.name + suffix; + if (HOP(defines, name)) return to_node(defines[name], this); + }); + })(function(node, func) { + node.DEFMETHOD("_find_defs", func); + }); + + function best_of_expression(ast1, ast2, threshold) { + var delta = ast2.print_to_string().length - ast1.print_to_string().length; + return delta < (threshold || 0) ? ast2 : ast1; + } + + function best_of_statement(ast1, ast2, threshold) { + return best_of_expression(make_node(AST_SimpleStatement, ast1, { + body: ast1, + }), make_node(AST_SimpleStatement, ast2, { + body: ast2, + }), threshold).body; + } + + function best_of(compressor, ast1, ast2, threshold) { + return (first_in_statement(compressor) ? best_of_statement : best_of_expression)(ast1, ast2, threshold); + } + + function convert_to_predicate(obj) { + var map = Object.create(null); + Object.keys(obj).forEach(function(key) { + map[key] = makePredicate(obj[key]); + }); + return map; + } + + function skip_directives(body) { + for (var i = 0; i < body.length; i++) { + var stat = body[i]; + if (!(stat instanceof AST_Directive)) return stat; + } + } + + function arrow_first_statement() { + if (this.value) return make_node(AST_Return, this.value, { value: this.value }); + return skip_directives(this.body); + } + AST_Arrow.DEFMETHOD("first_statement", arrow_first_statement); + AST_AsyncArrow.DEFMETHOD("first_statement", arrow_first_statement); + AST_Lambda.DEFMETHOD("first_statement", function() { + return skip_directives(this.body); + }); + + AST_Lambda.DEFMETHOD("length", function() { + var argnames = this.argnames; + for (var i = 0; i < argnames.length; i++) { + if (argnames[i] instanceof AST_DefaultValue) break; + } + return i; + }); + + function try_evaluate(compressor, node) { + var ev = node.evaluate(compressor); + if (ev === node) return node; + ev = make_node_from_constant(ev, node).optimize(compressor); + return best_of(compressor, node, ev, compressor.eval_threshold); + } + + var object_fns = [ + "constructor", + "toString", + "valueOf", + ]; + var native_fns = convert_to_predicate({ + Array: [ + "indexOf", + "join", + "lastIndexOf", + "slice", + ].concat(object_fns), + Boolean: object_fns, + Function: object_fns, + Number: [ + "toExponential", + "toFixed", + "toPrecision", + ].concat(object_fns), + Object: object_fns, + RegExp: [ + "exec", + "test", + ].concat(object_fns), + String: [ + "charAt", + "charCodeAt", + "concat", + "indexOf", + "italics", + "lastIndexOf", + "match", + "replace", + "search", + "slice", + "split", + "substr", + "substring", + "toLowerCase", + "toUpperCase", + "trim", + ].concat(object_fns), + }); + var static_fns = convert_to_predicate({ + Array: [ + "isArray", + ], + Math: [ + "abs", + "acos", + "asin", + "atan", + "ceil", + "cos", + "exp", + "floor", + "log", + "round", + "sin", + "sqrt", + "tan", + "atan2", + "pow", + "max", + "min", + ], + Number: [ + "isFinite", + "isNaN", + ], + Object: [ + "create", + "getOwnPropertyDescriptor", + "getOwnPropertyNames", + "getPrototypeOf", + "isExtensible", + "isFrozen", + "isSealed", + "keys", + ], + String: [ + "fromCharCode", + "raw", + ], + }); + + function is_static_fn(node) { + if (!(node instanceof AST_Dot)) return false; + var expr = node.expression; + if (!is_undeclared_ref(expr)) return false; + var static_fn = static_fns[expr.name]; + return static_fn && (static_fn[node.property] || expr.name == "Math" && node.property == "random"); + } + + // Accommodate when compress option evaluate=false + // as well as the common constant expressions !0 and -1 + (function(def) { + def(AST_Node, return_false); + def(AST_Constant, return_true); + def(AST_RegExp, return_false); + var unaryPrefix = makePredicate("! ~ - + void"); + def(AST_UnaryPrefix, function() { + return unaryPrefix[this.operator] && this.expression instanceof AST_Constant; + }); + })(function(node, func) { + node.DEFMETHOD("is_constant", func); + }); + + // methods to evaluate a constant expression + (function(def) { + // If the node has been successfully reduced to a constant, + // then its value is returned; otherwise the element itself + // is returned. + // + // They can be distinguished as constant value is never a + // descendant of AST_Node. + // + // When `ignore_side_effects` is `true`, inspect the constant value + // produced without worrying about any side effects caused by said + // expression. + AST_Node.DEFMETHOD("evaluate", function(compressor, ignore_side_effects) { + if (!compressor.option("evaluate")) return this; + var cached = []; + var val = this._eval(compressor, ignore_side_effects, cached, 1); + cached.forEach(function(node) { + delete node._eval; + }); + if (ignore_side_effects) return val; + if (!val || val instanceof RegExp) return val; + if (typeof val == "function" || typeof val == "object") return this; + return val; + }); + var scan_modified = new TreeWalker(function(node) { + if (node instanceof AST_Assign) modified(node.left); + if (node instanceof AST_ForEnumeration) modified(node.init); + if (node instanceof AST_Unary && UNARY_POSTFIX[node.operator]) modified(node.expression); + }); + function modified(node) { + if (node instanceof AST_DestructuredArray) { + node.elements.forEach(modified); + } else if (node instanceof AST_DestructuredObject) { + node.properties.forEach(function(prop) { + modified(prop.value); + }); + } else if (node instanceof AST_PropAccess) { + modified(node.expression); + } else if (node instanceof AST_SymbolRef) { + node.definition().references.forEach(function(ref) { + delete ref._eval; + }); + } + } + def(AST_Statement, function() { + throw new Error(string_template("Cannot evaluate a statement [{start}]", this)); + }); + def(AST_Accessor, return_this); + def(AST_BigInt, return_this); + def(AST_Class, return_this); + def(AST_Node, return_this); + def(AST_Constant, function() { + return this.value; + }); + def(AST_Assign, function(compressor, ignore_side_effects, cached, depth) { + var lhs = this.left; + if (!ignore_side_effects) { + if (!(lhs instanceof AST_SymbolRef)) return this; + if (!HOP(lhs, "_eval")) { + if (!lhs.fixed) return this; + var def = lhs.definition(); + if (!def.fixed) return this; + if (def.undeclared) return this; + if (def.last_ref !== lhs) return this; + if (def.single_use == "m") return this; + if (this.right.has_side_effects(compressor)) return this; + } + } + var op = this.operator; + var node; + if (!HOP(lhs, "_eval") && lhs instanceof AST_SymbolRef && lhs.fixed && lhs.definition().fixed) { + node = lhs; + } else if (op == "=") { + node = this.right; + } else { + node = make_node(AST_Binary, this, { + operator: op.slice(0, -1), + left: lhs, + right: this.right, + }); + } + lhs.walk(scan_modified); + var value = node._eval(compressor, ignore_side_effects, cached, depth); + if (typeof value == "object") return this; + modified(lhs); + return value; + }); + def(AST_Sequence, function(compressor, ignore_side_effects, cached, depth) { + if (!ignore_side_effects) return this; + var exprs = this.expressions; + for (var i = 0, last = exprs.length - 1; i < last; i++) { + exprs[i].walk(scan_modified); + } + var tail = exprs[last]; + var value = tail._eval(compressor, ignore_side_effects, cached, depth); + return value === tail ? this : value; + }); + def(AST_Lambda, function(compressor) { + if (compressor.option("unsafe")) { + var fn = function() {}; + fn.node = this; + fn.toString = function() { + return "function(){}"; + }; + return fn; + } + return this; + }); + def(AST_Array, function(compressor, ignore_side_effects, cached, depth) { + if (compressor.option("unsafe")) { + var elements = []; + for (var i = 0; i < this.elements.length; i++) { + var element = this.elements[i]; + if (element instanceof AST_Hole) return this; + var value = element._eval(compressor, ignore_side_effects, cached, depth); + if (element === value) return this; + elements.push(value); + } + return elements; + } + return this; + }); + def(AST_Object, function(compressor, ignore_side_effects, cached, depth) { + if (compressor.option("unsafe")) { + var val = {}; + for (var i = 0; i < this.properties.length; i++) { + var prop = this.properties[i]; + if (!(prop instanceof AST_ObjectKeyVal)) return this; + var key = prop.key; + if (key instanceof AST_Node) { + key = key._eval(compressor, ignore_side_effects, cached, depth); + if (key === prop.key) return this; + } + switch (key) { + case "__proto__": + case "toString": + case "valueOf": + return this; + } + val[key] = prop.value._eval(compressor, ignore_side_effects, cached, depth); + if (val[key] === prop.value) return this; + } + return val; + } + return this; + }); + var non_converting_unary = makePredicate("! typeof void"); + def(AST_UnaryPrefix, function(compressor, ignore_side_effects, cached, depth) { + var e = this.expression; + var op = this.operator; + // Function would be evaluated to an array and so typeof would + // incorrectly return "object". Hence making is a special case. + if (compressor.option("typeofs") + && op == "typeof" + && (e instanceof AST_Lambda + || e instanceof AST_SymbolRef + && e.fixed_value() instanceof AST_Lambda)) { + return typeof function(){}; + } + var def = e instanceof AST_SymbolRef && e.definition(); + if (!non_converting_unary[op] && !(def && def.fixed)) depth++; + e.walk(scan_modified); + var v = e._eval(compressor, ignore_side_effects, cached, depth); + if (v === e) { + if (ignore_side_effects && op == "void") return; + return this; + } + switch (op) { + case "!": return !v; + case "typeof": + // typeof returns "object" or "function" on different platforms + // so cannot evaluate reliably + if (v instanceof RegExp) return this; + return typeof v; + case "void": return; + case "~": return ~v; + case "-": return -v; + case "+": return +v; + case "++": + case "--": + if (!def) return this; + if (!ignore_side_effects) { + if (def.undeclared) return this; + if (def.last_ref !== e) return this; + } + if (HOP(e, "_eval")) v = +(op[0] + 1) + +v; + modified(e); + return v; + } + return this; + }); + def(AST_UnaryPostfix, function(compressor, ignore_side_effects, cached, depth) { + var e = this.expression; + if (!(e instanceof AST_SymbolRef)) { + if (!ignore_side_effects) return this; + } else if (!HOP(e, "_eval")) { + if (!e.fixed) return this; + if (!ignore_side_effects) { + var def = e.definition(); + if (!def.fixed) return this; + if (def.undeclared) return this; + if (def.last_ref !== e) return this; + } + } + if (!(e instanceof AST_SymbolRef && e.definition().fixed)) depth++; + e.walk(scan_modified); + var v = e._eval(compressor, ignore_side_effects, cached, depth); + if (v === e) return this; + modified(e); + return +v; + }); + var non_converting_binary = makePredicate("&& || === !=="); + def(AST_Binary, function(compressor, ignore_side_effects, cached, depth) { + if (!non_converting_binary[this.operator]) depth++; + var left = this.left._eval(compressor, ignore_side_effects, cached, depth); + if (left === this.left) return this; + if (this.operator == (left ? "||" : "&&")) return left; + var rhs_ignore_side_effects = ignore_side_effects && !(left && typeof left == "object"); + var right = this.right._eval(compressor, rhs_ignore_side_effects, cached, depth); + if (right === this.right) return this; + var result; + switch (this.operator) { + case "&&" : result = left && right; break; + case "||" : result = left || right; break; + case "??" : + result = left == null ? right : left; + break; + case "|" : result = left | right; break; + case "&" : result = left & right; break; + case "^" : result = left ^ right; break; + case "+" : result = left + right; break; + case "-" : result = left - right; break; + case "*" : result = left * right; break; + case "/" : result = left / right; break; + case "%" : result = left % right; break; + case "<<" : result = left << right; break; + case ">>" : result = left >> right; break; + case ">>>": result = left >>> right; break; + case "==" : result = left == right; break; + case "===": result = left === right; break; + case "!=" : result = left != right; break; + case "!==": result = left !== right; break; + case "<" : result = left < right; break; + case "<=" : result = left <= right; break; + case ">" : result = left > right; break; + case ">=" : result = left >= right; break; + case "**": + result = Math.pow(left, right); + break; + case "in": + if (right && typeof right == "object" && HOP(right, left)) { + result = true; + break; + } + default: + return this; + } + if (isNaN(result)) return compressor.find_parent(AST_With) ? this : result; + if (compressor.option("unsafe_math") + && !ignore_side_effects + && result + && typeof result == "number" + && (this.operator == "+" || this.operator == "-")) { + var digits = Math.max(0, decimals(left), decimals(right)); + // 53-bit significand ---> 15.95 decimal places + if (digits < 16) return +result.toFixed(digits); + } + return result; + + function decimals(operand) { + var match = /(\.[0-9]*)?(e[^e]+)?$/.exec(+operand); + return (match[1] || ".").length - 1 - (match[2] || "").slice(1); + } + }); + def(AST_Conditional, function(compressor, ignore_side_effects, cached, depth) { + var condition = this.condition._eval(compressor, ignore_side_effects, cached, depth); + if (condition === this.condition) return this; + var node = condition ? this.consequent : this.alternative; + var value = node._eval(compressor, ignore_side_effects, cached, depth); + return value === node ? this : value; + }); + function verify_escaped(ref, depth) { + var escaped = ref.definition().escaped; + switch (escaped.length) { + case 0: + return true; + case 1: + var found = false; + escaped[0].walk(new TreeWalker(function(node) { + if (found) return true; + if (node === ref) return found = true; + if (node instanceof AST_Scope) return true; + })); + return found; + default: + return depth <= escaped.depth; + } + } + def(AST_SymbolRef, function(compressor, ignore_side_effects, cached, depth) { + this._eval = return_this; + try { + var fixed = this.fixed_value(); + if (!fixed) return this; + var value; + if (HOP(fixed, "_eval")) { + value = fixed._eval(); + } else { + value = fixed._eval(compressor, ignore_side_effects, cached, depth); + if (value === fixed) return this; + fixed._eval = function() { + return value; + }; + cached.push(fixed); + } + return value && typeof value == "object" && !verify_escaped(this, depth) ? this : value; + } finally { + delete this._eval; + } + }); + var global_objs = { + Array: Array, + Math: Math, + Number: Number, + Object: Object, + String: String, + }; + var static_values = convert_to_predicate({ + Math: [ + "E", + "LN10", + "LN2", + "LOG2E", + "LOG10E", + "PI", + "SQRT1_2", + "SQRT2", + ], + Number: [ + "MAX_VALUE", + "MIN_VALUE", + "NaN", + "NEGATIVE_INFINITY", + "POSITIVE_INFINITY", + ], + }); + var regexp_props = makePredicate("global ignoreCase multiline source"); + def(AST_PropAccess, function(compressor, ignore_side_effects, cached, depth) { + if (compressor.option("unsafe")) { + var val; + var exp = this.expression; + if (!is_undeclared_ref(exp)) { + val = exp._eval(compressor, ignore_side_effects, cached, depth + 1); + if (val == null || val === exp) return this; + } + var key = this.property; + if (key instanceof AST_Node) { + key = key._eval(compressor, ignore_side_effects, cached, depth); + if (key === this.property) return this; + } + if (val === undefined) { + var static_value = static_values[exp.name]; + if (!static_value || !static_value[key]) return this; + val = global_objs[exp.name]; + } else if (val instanceof RegExp) { + if (!regexp_props[key]) return this; + } else if (typeof val == "object") { + if (!HOP(val, key)) return this; + } else if (typeof val == "function") switch (key) { + case "name": + return val.node.name ? val.node.name.name : ""; + case "length": + return val.node.length(); + default: + return this; + } + return val[key]; + } + return this; + }); + function eval_all(nodes, compressor, ignore_side_effects, cached, depth) { + var values = []; + for (var i = 0; i < nodes.length; i++) { + var node = nodes[i]; + var value = node._eval(compressor, ignore_side_effects, cached, depth); + if (node === value) return; + values.push(value); + } + return values; + } + def(AST_Call, function(compressor, ignore_side_effects, cached, depth) { + var exp = this.expression; + var fn = exp instanceof AST_SymbolRef ? exp.fixed_value() : exp; + if (fn instanceof AST_Arrow || fn instanceof AST_Defun || fn instanceof AST_Function) { + if (fn.evaluating) return this; + if (fn.name && fn.name.definition().recursive_refs > 0) return this; + if (this.is_expr_pure(compressor)) return this; + var args = eval_all(this.args, compressor, ignore_side_effects, cached, depth); + if (!all(fn.argnames, function(sym, index) { + if (sym instanceof AST_DefaultValue) { + if (!args) return false; + if (args[index] === undefined) { + var value = sym.value._eval(compressor, ignore_side_effects, cached, depth); + if (value === sym.value) return false; + args[index] = value; + } + sym = sym.name; + } + return !(sym instanceof AST_Destructured); + })) return this; + if (fn.rest instanceof AST_Destructured) return this; + if (!args && !ignore_side_effects) return this; + var stat = fn.first_statement(); + if (!(stat instanceof AST_Return)) { + if (ignore_side_effects) { + fn.walk(scan_modified); + var found = false; + fn.evaluating = true; + walk_body(fn, new TreeWalker(function(node) { + if (found) return true; + if (node instanceof AST_Return) { + if (node.value && node.value._eval(compressor, true, cached, depth) !== undefined) { + found = true; + } + return true; + } + if (node instanceof AST_Scope && node !== fn) return true; + })); + fn.evaluating = false; + if (!found) return; + } + return this; + } + var val = stat.value; + if (!val) return; + var cached_args = []; + if (!args || all(fn.argnames, function(sym, i) { + return assign(sym, args[i]); + }) && !(fn.rest && !assign(fn.rest, args.slice(fn.argnames.length))) || ignore_side_effects) { + if (ignore_side_effects) fn.argnames.forEach(function(sym) { + if (sym instanceof AST_DefaultValue) sym.value.walk(scan_modified); + }); + fn.evaluating = true; + val = val._eval(compressor, ignore_side_effects, cached, depth); + fn.evaluating = false; + } + cached_args.forEach(function(node) { + delete node._eval; + }); + return val === stat.value ? this : val; + } else if (compressor.option("unsafe") && exp instanceof AST_PropAccess) { + var key = exp.property; + if (key instanceof AST_Node) { + key = key._eval(compressor, ignore_side_effects, cached, depth); + if (key === exp.property) return this; + } + var val; + var e = exp.expression; + if (is_undeclared_ref(e)) { + var static_fn = static_fns[e.name]; + if (!static_fn || !static_fn[key]) return this; + val = global_objs[e.name]; + } else { + val = e._eval(compressor, ignore_side_effects, cached, depth + 1); + if (val == null || val === e) return this; + var native_fn = native_fns[val.constructor.name]; + if (!native_fn || !native_fn[key]) return this; + if (val instanceof RegExp && val.global && !(e instanceof AST_RegExp)) return this; + } + var args = eval_all(this.args, compressor, ignore_side_effects, cached, depth); + if (!args) return this; + if (key == "replace" && typeof args[1] == "function") return this; + try { + return val[key].apply(val, args); + } catch (ex) { + AST_Node.warn("Error evaluating {this} [{start}]", this); + } finally { + if (val instanceof RegExp) val.lastIndex = 0; + } + } + return this; + + function assign(sym, arg) { + if (sym instanceof AST_DefaultValue) sym = sym.name; + var def = sym.definition(); + if (def.orig[def.orig.length - 1] !== sym) return false; + var value = arg; + def.references.forEach(function(node) { + node._eval = function() { + return value; + }; + cached_args.push(node); + }); + return true; + } + }); + def(AST_New, return_this); + def(AST_Template, function(compressor, ignore_side_effects, cached, depth) { + if (!compressor.option("templates")) return this; + if (this.tag) { + if (!is_raw_tag(compressor, this.tag)) return this; + decode = function(str) { + return str; + }; + } + var exprs = eval_all(this.expressions, compressor, ignore_side_effects, cached, depth); + if (!exprs) return this; + var malformed = false; + var ret = decode(this.strings[0]); + for (var i = 0; i < exprs.length; i++) { + ret += exprs[i] + decode(this.strings[i + 1]); + } + if (!malformed) return ret; + this._eval = return_this; + return this; + + function decode(str) { + str = decode_template(str); + if (typeof str != "string") malformed = true; + return str; + } + }); + })(function(node, func) { + node.DEFMETHOD("_eval", func); + }); + + // method to negate an expression + (function(def) { + function basic_negation(exp) { + return make_node(AST_UnaryPrefix, exp, { + operator: "!", + expression: exp, + }); + } + function best(orig, alt, first_in_statement) { + var negated = basic_negation(orig); + if (first_in_statement) return best_of_expression(negated, make_node(AST_SimpleStatement, alt, { + body: alt, + })) === negated ? negated : alt; + return best_of_expression(negated, alt); + } + def(AST_Node, function() { + return basic_negation(this); + }); + def(AST_Statement, function() { + throw new Error("Cannot negate a statement"); + }); + def(AST_Binary, function(compressor, first_in_statement) { + var self = this.clone(), op = this.operator; + if (compressor.option("unsafe_comps")) { + switch (op) { + case "<=" : self.operator = ">" ; return self; + case "<" : self.operator = ">=" ; return self; + case ">=" : self.operator = "<" ; return self; + case ">" : self.operator = "<=" ; return self; + } + } + switch (op) { + case "==" : self.operator = "!="; return self; + case "!=" : self.operator = "=="; return self; + case "===": self.operator = "!=="; return self; + case "!==": self.operator = "==="; return self; + case "&&": + self.operator = "||"; + self.left = self.left.negate(compressor, first_in_statement); + self.right = self.right.negate(compressor); + return best(this, self, first_in_statement); + case "||": + self.operator = "&&"; + self.left = self.left.negate(compressor, first_in_statement); + self.right = self.right.negate(compressor); + return best(this, self, first_in_statement); + } + return basic_negation(this); + }); + def(AST_ClassExpression, function() { + return basic_negation(this); + }); + def(AST_Conditional, function(compressor, first_in_statement) { + var self = this.clone(); + self.consequent = self.consequent.negate(compressor); + self.alternative = self.alternative.negate(compressor); + return best(this, self, first_in_statement); + }); + def(AST_LambdaExpression, function() { + return basic_negation(this); + }); + def(AST_Sequence, function(compressor) { + var expressions = this.expressions.slice(); + expressions.push(expressions.pop().negate(compressor)); + return make_sequence(this, expressions); + }); + def(AST_UnaryPrefix, function() { + if (this.operator == "!") + return this.expression; + return basic_negation(this); + }); + })(function(node, func) { + node.DEFMETHOD("negate", function(compressor, first_in_statement) { + return func.call(this, compressor, first_in_statement); + }); + }); + + var global_pure_fns = makePredicate("Boolean decodeURI decodeURIComponent Date encodeURI encodeURIComponent Error escape EvalError isFinite isNaN Number Object parseFloat parseInt RangeError ReferenceError String SyntaxError TypeError unescape URIError"); + var global_pure_constructors = makePredicate("Map Set WeakMap WeakSet"); + AST_Call.DEFMETHOD("is_expr_pure", function(compressor) { + if (compressor.option("unsafe")) { + var expr = this.expression; + if (is_undeclared_ref(expr)) { + if (global_pure_fns[expr.name]) return true; + if (this instanceof AST_New && global_pure_constructors[expr.name]) return true; + } + if (is_static_fn(expr)) return true; + } + return compressor.option("annotations") && this.pure || !compressor.pure_funcs(this); + }); + AST_Template.DEFMETHOD("is_expr_pure", function(compressor) { + var tag = this.tag; + if (!tag) return true; + if (compressor.option("unsafe")) { + if (is_undeclared_ref(tag) && global_pure_fns[tag.name]) return true; + if (tag instanceof AST_Dot && is_undeclared_ref(tag.expression)) { + var static_fn = static_fns[tag.expression.name]; + return static_fn && (static_fn[tag.property] + || tag.expression.name == "Math" && tag.property == "random"); + } + } + return !compressor.pure_funcs(this); + }); + AST_Node.DEFMETHOD("is_call_pure", return_false); + AST_Call.DEFMETHOD("is_call_pure", function(compressor) { + if (!compressor.option("unsafe")) return false; + var dot = this.expression; + if (!(dot instanceof AST_Dot)) return false; + var exp = dot.expression; + var map; + var prop = dot.property; + if (exp instanceof AST_Array) { + map = native_fns.Array; + } else if (exp.is_boolean(compressor)) { + map = native_fns.Boolean; + } else if (exp.is_number(compressor)) { + map = native_fns.Number; + } else if (exp instanceof AST_RegExp) { + map = native_fns.RegExp; + } else if (exp.is_string(compressor)) { + map = native_fns.String; + if (prop == "replace") { + var arg = this.args[1]; + if (arg && !arg.is_string(compressor)) return false; + } + } else if (!dot.may_throw_on_access(compressor)) { + map = native_fns.Object; + } + return map && map[prop]; + }); + + // determine if object spread syntax may cause runtime exception + (function(def) { + def(AST_Node, return_false); + def(AST_Array, return_true); + def(AST_Assign, function() { + switch (this.operator) { + case "=": + return this.right.safe_to_spread(); + case "&&=": + case "||=": + case "??=": + return this.left.safe_to_spread() && this.right.safe_to_spread(); + } + return true; + }); + def(AST_Binary, function() { + return !lazy_op[this.operator] || this.left.safe_to_spread() && this.right.safe_to_spread(); + }); + def(AST_Constant, return_true); + def(AST_Lambda, return_true); + def(AST_Object, function() { + return all(this.properties, function(prop) { + return !(prop instanceof AST_ObjectGetter || prop instanceof AST_Spread); + }); + }); + def(AST_Sequence, function() { + return this.tail_node().safe_to_spread(); + }); + def(AST_SymbolRef, function() { + var fixed = this.fixed_value(); + return fixed && fixed.safe_to_spread(); + }); + def(AST_Unary, return_true); + })(function(node, func) { + node.DEFMETHOD("safe_to_spread", func); + }); + + // determine if expression has side effects + (function(def) { + function any(list, compressor, spread) { + return !all(list, spread ? function(node) { + return node instanceof AST_Spread ? !spread(node, compressor) : !node.has_side_effects(compressor); + } : function(node) { + return !node.has_side_effects(compressor); + }); + } + function array_spread(node, compressor) { + var exp = node.expression; + return !exp.is_string(compressor) || exp.has_side_effects(compressor); + } + def(AST_Node, return_true); + def(AST_Array, function(compressor) { + return any(this.elements, compressor, array_spread); + }); + def(AST_Assign, function(compressor) { + var lhs = this.left; + if (!(lhs instanceof AST_PropAccess)) return true; + var node = lhs.expression; + return !(node instanceof AST_ObjectIdentity) + || !node.scope.resolve().new + || lhs instanceof AST_Sub && lhs.property.has_side_effects(compressor) + || this.right.has_side_effects(compressor); + }); + def(AST_Binary, function(compressor) { + return this.left.has_side_effects(compressor) + || this.right.has_side_effects(compressor) + || !can_drop_op(this, compressor); + }); + def(AST_Block, function(compressor) { + return any(this.body, compressor); + }); + def(AST_Call, function(compressor) { + if (!this.is_expr_pure(compressor) + && (!this.is_call_pure(compressor) || this.expression.has_side_effects(compressor))) { + return true; + } + return any(this.args, compressor, array_spread); + }); + def(AST_Case, function(compressor) { + return this.expression.has_side_effects(compressor) + || any(this.body, compressor); + }); + def(AST_Class, function(compressor) { + var base = this.extends; + if (base) { + if (base instanceof AST_SymbolRef) base = base.fixed_value(); + if (!safe_for_extends(base)) return true; + } + return any(this.properties, compressor); + }); + def(AST_ClassProperty, function(compressor) { + return this.key instanceof AST_Node && this.key.has_side_effects(compressor) + || this.static && this.value && this.value.has_side_effects(compressor); + }); + def(AST_Conditional, function(compressor) { + return this.condition.has_side_effects(compressor) + || this.consequent.has_side_effects(compressor) + || this.alternative.has_side_effects(compressor); + }); + def(AST_Constant, return_false); + def(AST_Definitions, function(compressor) { + return any(this.definitions, compressor); + }); + def(AST_DestructuredArray, function(compressor) { + return any(this.elements, compressor); + }); + def(AST_DestructuredKeyVal, function(compressor) { + return this.key instanceof AST_Node && this.key.has_side_effects(compressor) + || this.value.has_side_effects(compressor); + }); + def(AST_DestructuredObject, function(compressor) { + return any(this.properties, compressor); + }); + def(AST_Dot, function(compressor) { + return this.expression.may_throw_on_access(compressor) + || this.expression.has_side_effects(compressor); + }); + def(AST_EmptyStatement, return_false); + def(AST_If, function(compressor) { + return this.condition.has_side_effects(compressor) + || this.body && this.body.has_side_effects(compressor) + || this.alternative && this.alternative.has_side_effects(compressor); + }); + def(AST_LabeledStatement, function(compressor) { + return this.body.has_side_effects(compressor); + }); + def(AST_Lambda, return_false); + def(AST_Object, function(compressor) { + return any(this.properties, compressor, function(node, compressor) { + var exp = node.expression; + return !exp.safe_to_spread() || exp.has_side_effects(compressor); + }); + }); + def(AST_ObjectIdentity, return_false); + def(AST_ObjectProperty, function(compressor) { + return this.key instanceof AST_Node && this.key.has_side_effects(compressor) + || this.value.has_side_effects(compressor); + }); + def(AST_Sequence, function(compressor) { + return any(this.expressions, compressor); + }); + def(AST_SimpleStatement, function(compressor) { + return this.body.has_side_effects(compressor); + }); + def(AST_Sub, function(compressor) { + return this.expression.may_throw_on_access(compressor) + || this.expression.has_side_effects(compressor) + || this.property.has_side_effects(compressor); + }); + def(AST_Switch, function(compressor) { + return this.expression.has_side_effects(compressor) + || any(this.body, compressor); + }); + def(AST_SymbolDeclaration, return_false); + def(AST_SymbolRef, function(compressor) { + return !this.is_declared(compressor) || !can_drop_symbol(this, compressor); + }); + def(AST_Template, function(compressor) { + return !this.is_expr_pure(compressor) || any(this.expressions, compressor); + }); + def(AST_Try, function(compressor) { + return any(this.body, compressor) + || this.bcatch && this.bcatch.has_side_effects(compressor) + || this.bfinally && this.bfinally.has_side_effects(compressor); + }); + def(AST_Unary, function(compressor) { + return unary_side_effects[this.operator] + || this.expression.has_side_effects(compressor); + }); + def(AST_VarDef, function() { + return this.value; + }); + })(function(node, func) { + node.DEFMETHOD("has_side_effects", func); + }); + + // determine if expression may throw + (function(def) { + def(AST_Node, return_true); + + def(AST_Constant, return_false); + def(AST_EmptyStatement, return_false); + def(AST_Lambda, return_false); + def(AST_ObjectIdentity, return_false); + def(AST_SymbolDeclaration, return_false); + + function any(list, compressor) { + for (var i = list.length; --i >= 0;) + if (list[i].may_throw(compressor)) + return true; + return false; + } + + function call_may_throw(exp, compressor) { + if (exp.may_throw(compressor)) return true; + if (exp instanceof AST_SymbolRef) exp = exp.fixed_value(); + if (!(exp instanceof AST_Lambda)) return true; + if (any(exp.argnames, compressor)) return true; + if (any(exp.body, compressor)) return true; + return is_arrow(exp) && exp.value && exp.value.may_throw(compressor); + } + + def(AST_Array, function(compressor) { + return any(this.elements, compressor); + }); + def(AST_Assign, function(compressor) { + if (this.right.may_throw(compressor)) return true; + if (!compressor.has_directive("use strict") + && this.operator == "=" + && this.left instanceof AST_SymbolRef) { + return false; + } + return this.left.may_throw(compressor); + }); + def(AST_Await, function(compressor) { + return this.expression.may_throw(compressor); + }); + def(AST_Binary, function(compressor) { + return this.left.may_throw(compressor) + || this.right.may_throw(compressor) + || !can_drop_op(this, compressor); + }); + def(AST_Block, function(compressor) { + return any(this.body, compressor); + }); + def(AST_Call, function(compressor) { + if (any(this.args, compressor)) return true; + if (this.is_expr_pure(compressor)) return false; + this.may_throw = return_true; + var ret = call_may_throw(this.expression, compressor); + delete this.may_throw; + return ret; + }); + def(AST_Case, function(compressor) { + return this.expression.may_throw(compressor) + || any(this.body, compressor); + }); + def(AST_Conditional, function(compressor) { + return this.condition.may_throw(compressor) + || this.consequent.may_throw(compressor) + || this.alternative.may_throw(compressor); + }); + def(AST_DefaultValue, function(compressor) { + return this.name.may_throw(compressor) + || this.value && this.value.may_throw(compressor); + }); + def(AST_Definitions, function(compressor) { + return any(this.definitions, compressor); + }); + def(AST_Dot, function(compressor) { + return !this.optional && this.expression.may_throw_on_access(compressor) + || this.expression.may_throw(compressor); + }); + def(AST_ForEnumeration, function(compressor) { + if (this.init.may_throw(compressor)) return true; + var obj = this.object; + if (obj.may_throw(compressor)) return true; + obj = obj.tail_node(); + if (!(obj instanceof AST_Array || obj.is_string(compressor))) return true; + return this.body.may_throw(compressor); + }); + def(AST_If, function(compressor) { + return this.condition.may_throw(compressor) + || this.body && this.body.may_throw(compressor) + || this.alternative && this.alternative.may_throw(compressor); + }); + def(AST_LabeledStatement, function(compressor) { + return this.body.may_throw(compressor); + }); + def(AST_Object, function(compressor) { + return any(this.properties, compressor); + }); + def(AST_ObjectProperty, function(compressor) { + return this.value.may_throw(compressor) + || this.key instanceof AST_Node && this.key.may_throw(compressor); + }); + def(AST_Return, function(compressor) { + return this.value && this.value.may_throw(compressor); + }); + def(AST_Sequence, function(compressor) { + return any(this.expressions, compressor); + }); + def(AST_SimpleStatement, function(compressor) { + return this.body.may_throw(compressor); + }); + def(AST_Sub, function(compressor) { + return !this.optional && this.expression.may_throw_on_access(compressor) + || this.expression.may_throw(compressor) + || this.property.may_throw(compressor); + }); + def(AST_Switch, function(compressor) { + return this.expression.may_throw(compressor) + || any(this.body, compressor); + }); + def(AST_SymbolRef, function(compressor) { + return !this.is_declared(compressor) || !can_drop_symbol(this, compressor); + }); + def(AST_Template, function(compressor) { + if (any(this.expressions, compressor)) return true; + if (this.is_expr_pure(compressor)) return false; + if (!this.tag) return false; + this.may_throw = return_true; + var ret = call_may_throw(this.tag, compressor); + delete this.may_throw; + return ret; + }); + def(AST_Try, function(compressor) { + return (this.bcatch ? this.bcatch.may_throw(compressor) : any(this.body, compressor)) + || this.bfinally && this.bfinally.may_throw(compressor); + }); + def(AST_Unary, function(compressor) { + return this.expression.may_throw(compressor) + && !(this.operator == "typeof" && this.expression instanceof AST_SymbolRef); + }); + def(AST_VarDef, function(compressor) { + return this.name.may_throw(compressor) + || this.value && this.value.may_throw(compressor); + }); + })(function(node, func) { + node.DEFMETHOD("may_throw", func); + }); + + // determine if expression is constant + (function(def) { + function all_constant(list, scope) { + for (var i = list.length; --i >= 0;) + if (!list[i].is_constant_expression(scope)) + return false; + return true; + } + + function walk_scoped(self, scope) { + var result = true; + var scopes = []; + self.walk(new TreeWalker(function(node, descend) { + if (!result) return true; + if (node instanceof AST_BlockScope) { + if (node === self) return; + scopes.push(node); + descend(); + scopes.pop(); + return true; + } + if (node instanceof AST_SymbolRef) { + if (self.inlined || node.redef || node.in_arg) { + result = false; + return true; + } + if (self.variables && self.variables.has(node.name)) return true; + var def = node.definition(); + if (member(def.scope, scopes)) return true; + if (scope && !def.redefined()) { + var scope_def = scope.find_variable(node.name); + if (scope_def ? scope_def === def : def.undeclared) { + result = "f"; + return true; + } + } + result = false; + return true; + } + if (node instanceof AST_ObjectIdentity) { + if (is_arrow(self) && all(scopes, function(s) { + return !(s instanceof AST_Scope) || is_arrow(s); + })) result = false; + return true; + } + })); + return result; + } + + def(AST_Node, return_false); + def(AST_Array, function(scope) { + return all_constant(this.elements, scope); + }); + def(AST_Binary, function(scope) { + return this.left.is_constant_expression(scope) + && this.right.is_constant_expression(scope) + && can_drop_op(this); + }); + def(AST_Class, function(scope) { + var base = this.extends; + if (base && !safe_for_extends(base)) return false; + return all_constant(this.properties, scope); + }); + def(AST_ClassProperty, function(scope) { + if (typeof this.key != "string") return false; + var value = this.value; + if (!value) return true; + return this.static ? value.is_constant_expression(scope) : walk_scoped(value, scope); + }); + def(AST_Constant, return_true); + def(AST_Lambda, function(scope) { + return walk_scoped(this, scope); + }); + def(AST_Object, function(scope) { + return all_constant(this.properties, scope); + }); + def(AST_ObjectIdentity, function(scope) { + return this.scope.resolve() === scope; + }); + def(AST_ObjectProperty, function(scope) { + return typeof this.key == "string" && this.value.is_constant_expression(scope); + }); + def(AST_Unary, function(scope) { + return this.expression.is_constant_expression(scope); + }); + })(function(node, func) { + node.DEFMETHOD("is_constant_expression", func); + }); + + // tell me if a statement aborts + function aborts(thing) { + return thing && thing.aborts(); + } + (function(def) { + def(AST_Statement, return_null); + def(AST_Jump, return_this); + function block_aborts() { + var n = this.body.length; + return n > 0 && aborts(this.body[n - 1]); + } + def(AST_BlockStatement, block_aborts); + def(AST_SwitchBranch, block_aborts); + def(AST_If, function() { + return this.alternative && aborts(this.body) && aborts(this.alternative) && this; + }); + })(function(node, func) { + node.DEFMETHOD("aborts", func); + }); + + /* -----[ optimizers ]----- */ + + var directives = makePredicate(["use asm", "use strict"]); + OPT(AST_Directive, function(self, compressor) { + if (compressor.option("directives") + && (!directives[self.value] || compressor.has_directive(self.value) !== self)) { + return make_node(AST_EmptyStatement, self); + } + return self; + }); + + OPT(AST_Debugger, function(self, compressor) { + if (compressor.option("drop_debugger")) + return make_node(AST_EmptyStatement, self); + return self; + }); + + OPT(AST_LabeledStatement, function(self, compressor) { + if (self.body instanceof AST_If || self.body instanceof AST_Break) { + var body = tighten_body([ self.body ], compressor); + switch (body.length) { + case 0: + self.body = make_node(AST_EmptyStatement, self); + break; + case 1: + self.body = body[0]; + break; + default: + self.body = make_node(AST_BlockStatement, self, { body: body }); + break; + } + } + return compressor.option("unused") && self.label.references.length == 0 ? self.body : self; + }); + + OPT(AST_LoopControl, function(self, compressor) { + if (!compressor.option("dead_code")) return self; + var label = self.label; + if (label) { + var lct = compressor.loopcontrol_target(self); + self.label = null; + if (compressor.loopcontrol_target(self) === lct) { + remove(label.thedef.references, self); + } else { + self.label = label; + } + } + return self; + }); + + OPT(AST_Block, function(self, compressor) { + self.body = tighten_body(self.body, compressor); + return self; + }); + + function trim_block(node, parent, in_list) { + switch (node.body.length) { + case 0: + return in_list ? List.skip : make_node(AST_EmptyStatement, node); + case 1: + var stat = node.body[0]; + if (!safe_to_trim(stat)) return node; + if (parent instanceof AST_IterationStatement && stat instanceof AST_LambdaDefinition) return node; + return stat; + } + return node; + } + + OPT(AST_BlockStatement, function(self, compressor) { + self.body = tighten_body(self.body, compressor); + return trim_block(self, compressor.parent()); + }); + + function drop_rest_farg(fn, compressor) { + if (!compressor.option("rests")) return; + if (fn.uses_arguments) return; + if (!(fn.rest instanceof AST_DestructuredArray)) return; + if (!compressor.drop_fargs(fn, compressor.parent())) return; + fn.argnames = fn.argnames.concat(fn.rest.elements); + fn.rest = fn.rest.rest; + } + + OPT(AST_Lambda, function(self, compressor) { + drop_rest_farg(self, compressor); + self.body = tighten_body(self.body, compressor); + return self; + }); + + OPT(AST_Function, function(self, compressor) { + drop_rest_farg(self, compressor); + self.body = tighten_body(self.body, compressor); + var parent = compressor.parent(); + if (compressor.option("inline")) for (var i = 0; i < self.body.length; i++) { + var stat = self.body[i]; + if (stat instanceof AST_Directive) continue; + if (stat instanceof AST_Return) { + if (i != self.body.length - 1) break; + var call = stat.value; + if (!call || call.TYPE != "Call") break; + if (call.is_expr_pure(compressor)) break; + var exp = call.expression, fn; + if (!(exp instanceof AST_SymbolRef)) { + fn = exp; + } else if (self.name && self.name.definition() === exp.definition()) { + break; + } else { + fn = exp.fixed_value(); + } + if (!(fn instanceof AST_Defun || fn instanceof AST_Function)) break; + if (fn.rest) break; + if (fn.uses_arguments) break; + if (fn === exp) { + if (fn.parent_scope !== self) break; + if (!all(fn.enclosed, function(def) { + return def.scope !== self; + })) break; + } + if ((fn !== exp || fn.name) + && (parent instanceof AST_ClassMethod || parent instanceof AST_ObjectMethod) + && parent.value === compressor.self()) break; + if (fn.contains_this()) break; + var len = fn.argnames.length; + if (len > 0 && compressor.option("inline") < 2) break; + if (len > self.argnames.length) break; + if (!all(self.argnames, function(argname) { + return argname instanceof AST_SymbolFunarg; + })) break; + if (!all(call.args, function(arg) { + return !(arg instanceof AST_Spread); + })) break; + for (var j = 0; j < len; j++) { + var arg = call.args[j]; + if (!(arg instanceof AST_SymbolRef)) break; + if (arg.definition() !== self.argnames[j].definition()) break; + } + if (j < len) break; + for (; j < call.args.length; j++) { + if (call.args[j].has_side_effects(compressor)) break; + } + if (j < call.args.length) break; + if (len < self.argnames.length && !compressor.drop_fargs(self, parent)) { + if (!compressor.drop_fargs(fn, call)) break; + do { + fn.argnames.push(fn.make_var(AST_SymbolFunarg, fn, "argument_" + len)); + } while (++len < self.argnames.length); + } + return exp; + } + break; + } + return self; + }); + + var NO_MERGE = makePredicate("arguments await yield"); + AST_Scope.DEFMETHOD("merge_variables", function(compressor) { + if (!compressor.option("merge_vars")) return; + var in_arg = [], in_try, root, segment = {}, self = this; + var first = [], last = [], index = 0; + var declarations = new Dictionary(); + var references = Object.create(null); + var prev = Object.create(null); + var tw = new TreeWalker(function(node, descend) { + if (node instanceof AST_Assign) { + var lhs = node.left; + var rhs = node.right; + if (lhs instanceof AST_Destructured) { + rhs.walk(tw); + walk_destructured(AST_SymbolRef, mark, lhs); + return true; + } + if (lazy_op[node.operator.slice(0, -1)]) { + lhs.walk(tw); + push(); + rhs.walk(tw); + if (lhs instanceof AST_SymbolRef) mark(lhs); + pop(); + return true; + } + if (lhs instanceof AST_SymbolRef) { + if (node.operator != "=") mark(lhs, true); + rhs.walk(tw); + mark(lhs); + return true; + } + return; + } + if (node instanceof AST_Binary) { + if (!lazy_op[node.operator]) return; + walk_cond(node); + return true; + } + if (node instanceof AST_Break) { + var target = tw.loopcontrol_target(node); + if (!(target instanceof AST_IterationStatement)) insert(target); + return true; + } + if (node instanceof AST_Call) { + var exp = node.expression; + if (exp instanceof AST_LambdaExpression) { + node.args.forEach(function(arg) { + arg.walk(tw); + }); + exp.walk(tw); + } else { + descend(); + mark_expression(exp); + } + return true; + } + if (node instanceof AST_Class) { + if (node.name) node.name.walk(tw); + if (node.extends) node.extends.walk(tw); + node.properties.filter(function(prop) { + if (prop.key instanceof AST_Node) prop.key.walk(tw); + return prop.value; + }).forEach(function(prop) { + if (prop.static) { + prop.value.walk(tw); + } else { + push(); + segment.block = node; + prop.value.walk(tw); + pop(); + } + }); + return true; + } + if (node instanceof AST_Conditional) { + walk_cond(node.condition, node.consequent, node.alternative); + return true; + } + if (node instanceof AST_Continue) { + var target = tw.loopcontrol_target(node); + if (target instanceof AST_Do) insert(target); + return true; + } + if (node instanceof AST_Do) { + push(); + segment.block = node; + segment.loop = true; + var save = segment; + node.body.walk(tw); + if (segment.inserted === node) segment = save; + node.condition.walk(tw); + pop(); + return true; + } + if (node instanceof AST_For) { + if (node.init) node.init.walk(tw); + push(); + segment.block = node; + segment.loop = true; + if (node.condition) node.condition.walk(tw); + node.body.walk(tw); + if (node.step) node.step.walk(tw); + pop(); + return true; + } + if (node instanceof AST_ForEnumeration) { + node.object.walk(tw); + push(); + segment.block = node; + segment.loop = true; + node.init.walk(tw); + node.body.walk(tw); + pop(); + return true; + } + if (node instanceof AST_If) { + walk_cond(node.condition, node.body, node.alternative); + return true; + } + if (node instanceof AST_LabeledStatement) { + push(); + segment.block = node; + var save = segment; + node.body.walk(tw); + if (segment.inserted === node) segment = save; + pop(); + return true; + } + if (node instanceof AST_Scope) { + push(); + segment.block = node; + if (node === self) root = segment; + if (node instanceof AST_Lambda) { + if (node.name) references[node.name.definition().id] = false; + var marker = node.uses_arguments && !tw.has_directive("use strict") ? function(node) { + references[node.definition().id] = false; + } : function(node) { + mark(node); + }; + in_arg.push(node); + node.argnames.forEach(function(argname) { + walk_destructured(AST_SymbolFunarg, marker, argname); + }); + if (node.rest) walk_destructured(AST_SymbolFunarg, marker, node.rest); + in_arg.pop(); + } + walk_lambda(node, tw); + pop(); + return true; + } + if (node instanceof AST_Sub) { + var exp = node.expression; + if (node.optional) { + exp.walk(tw); + push(); + node.property.walk(tw); + pop(); + } else { + descend(); + } + mark_expression(exp); + return true; + } + if (node instanceof AST_Switch) { + node.expression.walk(tw); + var save = segment; + node.body.forEach(function(branch) { + if (branch instanceof AST_Default) return; + branch.expression.walk(tw); + if (save === segment) push(); + }); + segment = save; + node.body.forEach(function(branch) { + push(); + segment.block = node; + var save = segment; + walk_body(branch, tw); + if (segment.inserted === node) segment = save; + pop(); + }); + return true; + } + if (node instanceof AST_SymbolDeclaration) { + references[node.definition().id] = false; + return true; + } + if (node instanceof AST_SymbolRef) { + mark(node, true); + return true; + } + if (node instanceof AST_Try) { + var save_try = in_try; + in_try = node; + walk_body(node, tw); + if (node.bcatch) { + if (node.bcatch.argname) node.bcatch.argname.mark_symbol(function(node) { + if (node instanceof AST_SymbolCatch) { + var def = node.definition(); + references[def.id] = false; + if (def = def.redefined()) references[def.id] = false; + } + }, tw); + if (node.bfinally || (in_try = save_try)) { + walk_body(node.bcatch, tw); + } else { + push(); + walk_body(node.bcatch, tw); + pop(); + } + } + in_try = save_try; + if (node.bfinally) node.bfinally.walk(tw); + return true; + } + if (node instanceof AST_Unary) { + if (!UNARY_POSTFIX[node.operator]) return; + var sym = node.expression; + if (!(sym instanceof AST_SymbolRef)) return; + mark(sym, true); + return true; + } + if (node instanceof AST_VarDef) { + var assigned = node.value; + if (assigned) { + assigned.walk(tw); + } else { + assigned = segment.block instanceof AST_ForEnumeration && segment.block.init === tw.parent(); + } + walk_destructured(AST_SymbolDeclaration, assigned ? function(node) { + if (node instanceof AST_SymbolVar) { + mark(node); + } else { + node.walk(tw); + } + } : function(node) { + if (node instanceof AST_SymbolVar) { + var id = node.definition().id; + var refs = references[id]; + if (refs) { + refs.push(node); + } else if (!(id in references)) { + declarations.add(id, node); + } + } else { + node.walk(tw); + } + }, node.name); + return true; + } + if (node instanceof AST_While) { + push(); + segment.block = node; + segment.loop = true; + descend(); + pop(); + return true; + } + + function mark_expression(exp) { + if (!compressor.option("ie")) return; + var sym = root_expr(exp); + if (sym instanceof AST_SymbolRef) sym.walk(tw); + } + + function walk_cond(condition, consequent, alternative) { + var save = segment; + var segments = scan_branches(1, condition, consequent, alternative); + if (consequent) { + segment = segments.consequent.segment; + for (var i = segments.consequent.level; --i >= 0;) pop(); + if (segment !== save) return; + } + if (alternative) { + segment = segments.alternative.segment; + for (var i = segments.alternative.level; --i >= 0;) pop(); + if (segment !== save) return; + } + segment = save; + } + + function scan_branches(level, condition, consequent, alternative) { + var segments = { + consequent: { + segment: segment, + level: level, + }, + alternative: { + segment: segment, + level: level, + }, + } + if (condition instanceof AST_Binary) switch (condition.operator) { + case "&&": + segments.consequent = scan_branches(level + 1, condition.left, condition.right).consequent; + break; + case "||": + segments.alternative = scan_branches(level + 1, condition.left, null, condition.right).alternative; + break; + case "??": + segments.alternative = scan_branches(level + 1, condition.left, condition.right, condition.right).alternative; + break; + default: + condition.walk(tw); + break; + } else if (condition instanceof AST_Conditional) { + scan_branches(level + 1, condition.condition, condition.consequent, condition.alternative); + } else { + condition.walk(tw); + } + if (consequent) { + segment = segments.consequent.segment; + push(); + consequent.walk(tw); + segments.consequent.segment = segment; + } + if (alternative) { + segment = segments.alternative.segment; + push(); + alternative.walk(tw); + segments.alternative.segment = segment; + } + return segments; + } + }); + tw.directives = Object.create(compressor.directives); + self.walk(tw); + var changed = false; + var merged = Object.create(null); + while (first.length && last.length) { + var tail = last.shift(); + if (!tail) continue; + var def = tail.definition; + var tail_refs = references[def.id]; + if (!tail_refs) continue; + tail_refs = { end: tail_refs.end }; + while (def.id in merged) def = merged[def.id]; + tail_refs.start = references[def.id].start; + var skipped = []; + do { + var head = first.shift(); + if (tail.index > head.index) continue; + var prev_def = head.definition; + if (!(prev_def.id in prev)) continue; + var head_refs = references[prev_def.id]; + if (!head_refs) continue; + if (head_refs.start.block !== tail_refs.start.block + || !mergeable(head_refs, tail_refs) + || (head_refs.start.loop || !same_scope(def)) && !mergeable(tail_refs, head_refs) + || compressor.option("webkit") && is_funarg(def) !== is_funarg(prev_def) + || prev_def.const_redefs + || !all(head_refs.scopes, function(scope) { + return scope.find_variable(def.name) === def; + })) { + skipped.push(head); + continue; + } + head_refs.forEach(function(sym) { + sym.thedef = def; + sym.name = def.name; + if (sym instanceof AST_SymbolRef) { + def.references.push(sym); + prev_def.replaced++; + } else { + def.orig.push(sym); + prev_def.eliminated++; + } + }); + if (!prev_def.fixed) def.fixed = false; + merged[prev_def.id] = def; + changed = true; + break; + } while (first.length); + if (skipped.length) first = skipped.concat(first); + } + return changed; + + function push() { + segment = Object.create(segment); + } + + function pop() { + segment = Object.getPrototypeOf(segment); + } + + function walk_destructured(symbol_type, mark, lhs) { + var marker = new TreeWalker(function(node) { + if (node instanceof AST_Destructured) return; + if (node instanceof AST_DefaultValue) { + push(); + node.value.walk(tw); + pop(); + node.name.walk(marker); + } else if (node instanceof AST_DestructuredKeyVal) { + if (!(node.key instanceof AST_Node)) { + node.value.walk(marker); + } else if (node.value instanceof AST_PropAccess) { + push(); + segment.block = node; + node.key.walk(tw); + node.value.walk(marker); + pop(); + } else { + node.key.walk(tw); + node.value.walk(marker); + } + } else if (node instanceof symbol_type) { + mark(node); + } else { + node.walk(tw); + } + return true; + }); + lhs.walk(marker); + } + + function mark(sym, read) { + var def = sym.definition(), ldef; + if (read && !all(in_arg, function(fn) { + ldef = fn.variables.get(sym.name); + if (!ldef) return true; + if (!is_funarg(ldef)) return true; + return ldef !== def + && !def.undeclared + && fn.parent_scope.find_variable(sym.name) !== def; + })) return references[def.id] = references[ldef.id] = false; + var seg = segment; + if (in_try) { + push(); + seg = segment; + pop(); + } + if (def.id in references) { + var refs = references[def.id]; + if (!refs) return; + if (refs.start.block !== seg.block) return references[def.id] = false; + push_ref(sym); + refs.end = seg; + if (def.id in prev) { + last[prev[def.id]] = null; + } else if (!read) { + return; + } + } else if ((ldef = self.variables.get(def.name)) !== def) { + if (ldef && root === seg) references[ldef.id] = false; + return references[def.id] = false; + } else if (compressor.exposed(def) || NO_MERGE[sym.name]) { + return references[def.id] = false; + } else { + var refs = declarations.get(def.id) || []; + refs.scopes = []; + push_ref(sym); + references[def.id] = refs; + if (!read) { + refs.start = seg; + return first.push({ + index: index++, + definition: def, + }); + } + if (seg.block !== self) return references[def.id] = false; + refs.start = root; + } + prev[def.id] = last.length; + last.push({ + index: index++, + definition: def, + }); + + function push_ref(sym) { + refs.push(sym); + push_uniq(refs.scopes, sym.scope); + var scope = find_scope(tw); + if (scope !== sym.scope) push_uniq(refs.scopes, scope); + } + } + + function insert(target) { + var stack = []; + while (true) { + if (HOP(segment, "block")) { + var block = segment.block; + if (block instanceof AST_LabeledStatement) block = block.body; + if (block === target) break; + } + stack.push(segment); + pop(); + } + segment.inserted = segment.block; + push(); + while (stack.length) { + var seg = stack.pop(); + push(); + if (HOP(seg, "block")) segment.block = seg.block; + if (HOP(seg, "loop")) segment.loop = seg.loop; + } + } + + function must_visit(base, segment) { + return base === segment || base.isPrototypeOf(segment); + } + + function mergeable(head, tail) { + return must_visit(head.start, head.end) || must_visit(head.start, tail.start); + } + }); + + function fill_holes(orig, elements) { + for (var i = elements.length; --i >= 0;) { + if (!elements[i]) elements[i] = make_node(AST_Hole, orig); + } + } + + function to_class_expr(defcl, drop_name) { + var cl = make_node(AST_ClassExpression, defcl); + if (cl.name) cl.name = drop_name ? null : make_node(AST_SymbolClass, cl.name); + return cl; + } + + function to_func_expr(defun, drop_name) { + var ctor; + switch (defun.CTOR) { + case AST_AsyncDefun: + ctor = AST_AsyncFunction; + break; + case AST_AsyncGeneratorDefun: + ctor = AST_AsyncGeneratorFunction; + break; + case AST_Defun: + ctor = AST_Function; + break; + case AST_GeneratorDefun: + ctor = AST_GeneratorFunction; + break; + } + var fn = make_node(ctor, defun); + fn.name = drop_name ? null : make_node(AST_SymbolLambda, defun.name); + return fn; + } + + AST_Scope.DEFMETHOD("drop_unused", function(compressor) { + if (!compressor.option("unused")) return; + var self = this; + var drop_funcs = !(self instanceof AST_Toplevel) || compressor.toplevel.funcs; + var drop_vars = !(self instanceof AST_Toplevel) || compressor.toplevel.vars; + var assign_as_unused = /keep_assign/.test(compressor.option("unused")) ? return_false : function(node, props) { + var sym, nested = false; + if (node instanceof AST_Assign) { + if (node.write_only || node.operator == "=") sym = extract_reference(node.left, props); + } else if (node instanceof AST_Unary) { + if (node.write_only) sym = extract_reference(node.expression, props); + } + if (!(sym instanceof AST_SymbolRef)) return; + var def = sym.definition(); + if (export_defaults[def.id]) return; + if (compressor.exposed(def)) return; + if (!can_drop_symbol(sym, compressor, nested)) return; + return sym; + + function extract_reference(node, props) { + if (node instanceof AST_PropAccess) { + var expr = node.expression; + if (!expr.may_throw_on_access(compressor, true)) { + nested = true; + if (props && node instanceof AST_Sub) props.unshift(node.property); + return extract_reference(expr, props); + } + } else if (node instanceof AST_Assign && node.operator == "=") { + node.write_only = "p"; + var ref = extract_reference(node.right); + if (!props) return ref; + props.assign = node; + return ref instanceof AST_SymbolRef ? ref : node.left; + } + return node; + } + }; + var assign_in_use = Object.create(null); + var export_defaults = Object.create(null); + var find_variable = function(name) { + find_variable = compose(self, 0, noop); + return find_variable(name); + + function compose(child, level, find) { + var parent = compressor.parent(level); + if (!parent) return find; + var in_arg = parent instanceof AST_Lambda && member(child, parent.argnames); + return compose(parent, level + 1, in_arg ? function(name) { + var def = find(name); + if (def) return def; + def = parent.variables.get(name); + if (def) { + var sym = def.orig[0]; + if (sym instanceof AST_SymbolFunarg || sym instanceof AST_SymbolLambda) return def; + } + } : parent.variables ? function(name) { + return find(name) || parent.variables.get(name); + } : find); + } + }; + var for_ins = Object.create(null); + var in_use = []; + var in_use_ids = Object.create(null); // avoid expensive linear scans of in_use + var lambda_ids = Object.create(null); + var value_read = Object.create(null); + var value_modified = Object.create(null); + var var_defs = Object.create(null); + if (self instanceof AST_Toplevel && compressor.top_retain) { + self.variables.each(function(def) { + if (compressor.top_retain(def) && !(def.id in in_use_ids)) { + AST_Node.info("Retaining variable {name}", def); + in_use_ids[def.id] = true; + in_use.push(def); + } + }); + } + var assignments = new Dictionary(); + var initializations = new Dictionary(); + // pass 1: find out which symbols are directly used in + // this scope (not in nested scopes). + var scope = this; + var tw = new TreeWalker(function(node, descend) { + if (node instanceof AST_Lambda && node.uses_arguments && !tw.has_directive("use strict")) { + node.each_argname(function(argname) { + var def = argname.definition(); + if (!(def.id in in_use_ids)) { + in_use_ids[def.id] = true; + in_use.push(def); + } + }); + } + if (node === self) return; + if (scope === self) { + if (node instanceof AST_DefClass) { + var def = node.name.definition(); + var drop = drop_funcs && !def.exported; + if (!drop && !(def.id in in_use_ids)) { + in_use_ids[def.id] = true; + in_use.push(def); + } + var used = tw.parent() instanceof AST_ExportDefault; + if (used) { + export_defaults[def.id] = true; + } else if (drop && !(def.id in lambda_ids)) { + lambda_ids[def.id] = 1; + } + if (node.extends) node.extends.walk(tw); + var values = []; + node.properties.forEach(function(prop) { + if (prop.key instanceof AST_Node) prop.key.walk(tw); + var value = prop.value; + if (!value) return; + if (is_static_field_or_init(prop)) { + if (!used && value.contains_this()) used = true; + walk_class_prop(value); + } else { + values.push(value); + } + }); + values.forEach(drop && used ? walk_class_prop : function(value) { + initializations.add(def.id, value); + }); + return true; + } + if (node instanceof AST_LambdaDefinition) { + var def = node.name.definition(); + var drop = drop_funcs && !def.exported; + if (!drop && !(def.id in in_use_ids)) { + in_use_ids[def.id] = true; + in_use.push(def); + } + initializations.add(def.id, node); + if (tw.parent() instanceof AST_ExportDefault) { + export_defaults[def.id] = true; + return scan_ref_scoped(node, descend, true); + } + if (drop && !(def.id in lambda_ids)) lambda_ids[def.id] = 1; + return true; + } + if (node instanceof AST_Definitions) { + node.definitions.forEach(function(defn) { + var value = defn.value; + var side_effects = value + && (defn.name instanceof AST_Destructured || value.has_side_effects(compressor)); + var shared = side_effects && value.tail_node().operator == "="; + defn.name.mark_symbol(function(name) { + if (!(name instanceof AST_SymbolDeclaration)) return; + var def = name.definition(); + var_defs[def.id] = (var_defs[def.id] || 0) + 1; + if (node instanceof AST_Var && def.orig[0] instanceof AST_SymbolCatch) { + var redef = def.redefined(); + if (redef) var_defs[redef.id] = (var_defs[redef.id] || 0) + 1; + } + if (!(def.id in in_use_ids) && (!drop_vars || def.exported + || (node instanceof AST_Const ? def.redefined() : def.const_redefs) + || !(node instanceof AST_Var || is_safe_lexical(def)))) { + in_use_ids[def.id] = true; + in_use.push(def); + } + if (value) { + if (!side_effects) { + initializations.add(def.id, value); + } else if (shared) { + verify_safe_usage(def, name, value_modified[def.id]); + } + assignments.add(def.id, defn); + } + unmark_lambda(def); + return true; + }, tw); + if (side_effects) value.walk(tw); + }); + return true; + } + if (node instanceof AST_SymbolFunarg) { + var def = node.definition(); + var_defs[def.id] = (var_defs[def.id] || 0) + 1; + assignments.add(def.id, node); + var fixed = node.fixed_value(true); + if (fixed && fixed.tail_node().operator == "=") { + verify_safe_usage(def, node, value_modified[def.id]); + } + return true; + } + if (node instanceof AST_SymbolImport) { + var def = node.definition(); + if (!(def.id in in_use_ids) && (!drop_vars || !is_safe_lexical(def))) { + in_use_ids[def.id] = true; + in_use.push(def); + } + return true; + } + } + return scan_ref_scoped(node, descend, true); + + function walk_class_prop(value) { + var save_scope = scope; + scope = node; + value.walk(tw); + scope = save_scope; + } + }); + tw.directives = Object.create(compressor.directives); + self.walk(tw); + var drop_fn_name = compressor.option("keep_fnames") ? return_false : compressor.option("ie") ? function(def) { + return !compressor.exposed(def) && def.references.length == def.replaced; + } : function(def) { + if (!(def.id in in_use_ids)) return true; + if (def.orig.length - def.eliminated < 2) return false; + // function argument will always overshadow its name + if (def.orig[1] instanceof AST_SymbolFunarg) return true; + // retain if referenced within destructured object of argument + return all(def.references, function(ref) { + return !ref.in_arg; + }); + }; + if (compressor.option("ie")) initializations.each(function(init, id) { + if (id in in_use_ids) return; + init.forEach(function(init) { + init.walk(new TreeWalker(function(node) { + if (node instanceof AST_Function && node.name && !drop_fn_name(node.name.definition())) { + node.walk(tw); + return true; + } + if (node instanceof AST_Scope) return true; + })); + }); + }); + // pass 2: for every used symbol we need to walk its + // initialization code to figure out if it uses other + // symbols (that may not be in_use). + tw = new TreeWalker(scan_ref_scoped); + for (var i = 0; i < in_use.length; i++) { + var init = initializations.get(in_use[i].id); + if (init) init.forEach(function(init) { + init.walk(tw); + }); + } + Object.keys(assign_in_use).forEach(function(id) { + var assigns = assign_in_use[id]; + if (!assigns) { + delete assign_in_use[id]; + return; + } + assigns = assigns.reduce(function(in_use, assigns) { + assigns.forEach(function(assign) { + push_uniq(in_use, assign); + }); + return in_use; + }, []); + var in_use = (assignments.get(id) || []).filter(function(node) { + return find_if(node instanceof AST_Unary ? function(assign) { + return assign === node; + } : function(assign) { + if (assign === node) return true; + if (assign instanceof AST_Unary) return false; + return get_rvalue(assign) === get_rvalue(node); + }, assigns); + }); + if (assigns.length == in_use.length) { + assign_in_use[id] = in_use; + } else { + delete assign_in_use[id]; + } + }); + // pass 3: we should drop declarations not in_use + var calls_to_drop_args = []; + var fns_with_marked_args = []; + var trimmer = new TreeTransformer(function(node) { + if (node instanceof AST_DefaultValue) return trim_default(trimmer, node); + if (node instanceof AST_Destructured && node.rest) node.rest = node.rest.transform(trimmer); + if (node instanceof AST_DestructuredArray) { + var trim = !node.rest; + for (var i = node.elements.length; --i >= 0;) { + var element = node.elements[i].transform(trimmer); + if (element) { + node.elements[i] = element; + trim = false; + } else if (trim) { + node.elements.pop(); + } else { + node.elements[i] = make_node(AST_Hole, node.elements[i]); + } + } + return node; + } + if (node instanceof AST_DestructuredObject) { + var properties = []; + node.properties.forEach(function(prop) { + var retain = false; + if (prop.key instanceof AST_Node) { + prop.key = prop.key.transform(tt); + retain = prop.key.has_side_effects(compressor); + } + if ((retain || node.rest) && is_decl(prop.value)) { + prop.value = prop.value.transform(tt); + properties.push(prop); + } else { + var value = prop.value.transform(trimmer); + if (!value && node.rest) { + if (prop.value instanceof AST_DestructuredArray) { + value = make_node(AST_DestructuredArray, prop.value, { elements: [] }); + } else { + value = make_node(AST_DestructuredObject, prop.value, { properties: [] }); + } + } + if (value) { + prop.value = value; + properties.push(prop); + } + } + }); + node.properties = properties; + return node; + } + if (node instanceof AST_SymbolDeclaration) return trim_decl(node); + }); + var tt = new TreeTransformer(function(node, descend, in_list) { + var parent = tt.parent(); + if (drop_vars) { + var props = [], sym = assign_as_unused(node, props); + if (sym) { + var value; + if (can_drop_lhs(sym, node)) { + if (node instanceof AST_Assign) { + value = get_rhs(node); + if (node.write_only === true) value = value.drop_side_effect_free(compressor); + } + if (!value) value = make_node(AST_Number, node, { value: 0 }); + } + if (value) { + if (props.assign) { + var assign = props.assign.drop_side_effect_free(compressor); + if (assign) { + assign.write_only = true; + props.unshift(assign); + } + } + if (!(parent instanceof AST_Sequence) + || parent.tail_node() === node + || value.has_side_effects(compressor)) { + props.push(value); + } + switch (props.length) { + case 0: + return List.skip; + case 1: + return maintain_this_binding(parent, node, props[0].transform(tt)); + default: + return make_sequence(node, props.map(function(prop) { + return prop.transform(tt); + })); + } + } + } else if (node instanceof AST_UnaryPostfix + && node.expression instanceof AST_SymbolRef + && indexOf_assign(node.expression.definition(), node) < 0) { + return make_node(AST_UnaryPrefix, node, { + operator: "+", + expression: node.expression, + }); + } + } + if (node instanceof AST_Binary && node.operator == "instanceof") { + var sym = node.right; + if (!(sym instanceof AST_SymbolRef)) return; + if (sym.definition().id in in_use_ids) return; + var lhs = node.left.drop_side_effect_free(compressor); + var value = make_node(AST_False, node).optimize(compressor); + return lhs ? make_sequence(node, [ lhs, value ]) : value; + } + if (node instanceof AST_Call) { + calls_to_drop_args.push(node); + node.args = node.args.map(function(arg) { + return arg.transform(tt); + }); + node.expression = node.expression.transform(tt); + return node; + } + if (scope !== self) return; + if (drop_funcs && node !== self && node instanceof AST_DefClass) { + var def = node.name.definition(); + if (!(def.id in in_use_ids)) { + log(node.name, "Dropping unused class {name}"); + def.eliminated++; + descend(node, tt); + var trimmed = to_class_expr(node, true); + if (parent instanceof AST_ExportDefault) return trimmed; + trimmed = trimmed.drop_side_effect_free(compressor, true); + if (trimmed) return make_node(AST_SimpleStatement, node, { body: trimmed }); + return in_list ? List.skip : make_node(AST_EmptyStatement, node); + } + } + if (node instanceof AST_ClassExpression && node.name && drop_fn_name(node.name.definition())) { + node.name = null; + } + if (node instanceof AST_Lambda) { + if (drop_funcs && node !== self && node instanceof AST_LambdaDefinition) { + var def = node.name.definition(); + if (!(def.id in in_use_ids)) { + log(node.name, "Dropping unused function {name}"); + def.eliminated++; + if (parent instanceof AST_ExportDefault) { + descend_scope(); + return to_func_expr(node, true); + } + return in_list ? List.skip : make_node(AST_EmptyStatement, node); + } + } + descend_scope(); + if (node instanceof AST_LambdaExpression && node.name && drop_fn_name(node.name.definition())) { + node.name = null; + } + if (!(node instanceof AST_Accessor)) { + var args, spread, trim = compressor.drop_fargs(node, parent); + if (trim && parent instanceof AST_Call && parent.expression === node) { + args = parent.args; + for (spread = 0; spread < args.length; spread++) { + if (args[spread] instanceof AST_Spread) break; + } + } + var argnames = node.argnames; + var rest = node.rest; + var after = false, before = false; + if (rest) { + before = true; + if (!args || spread < argnames.length || rest instanceof AST_SymbolFunarg) { + rest = rest.transform(trimmer); + } else { + var trimmed = trim_destructured(rest, make_node(AST_Array, parent, { + elements: args.slice(argnames.length), + }), trim_decl, !node.uses_arguments, rest); + rest = trimmed.name; + args.length = argnames.length; + if (trimmed.value.elements.length) [].push.apply(args, trimmed.value.elements); + } + if (rest instanceof AST_Destructured && !rest.rest) { + if (rest instanceof AST_DestructuredArray) { + if (rest.elements.length == 0) rest = null; + } else if (rest.properties.length == 0) { + rest = null; + } + } + node.rest = rest; + if (rest) { + trim = false; + after = true; + } + } + var default_length = trim ? -1 : node.length(); + var trim_value = args && !node.uses_arguments && parent !== compressor.parent(); + for (var i = argnames.length; --i >= 0;) { + var sym = argnames[i]; + if (sym instanceof AST_SymbolFunarg) { + var def = sym.definition(); + if (def.id in in_use_ids) { + trim = false; + if (indexOf_assign(def, sym) < 0) sym.unused = null; + } else if (trim) { + log(sym, "Dropping unused function argument {name}"); + argnames.pop(); + def.eliminated++; + sym.unused = true; + } else { + sym.unused = true; + } + } else { + before = true; + var funarg; + if (!args || spread < i) { + funarg = sym.transform(trimmer); + } else { + var trimmed = trim_destructured(sym, args[i], trim_decl, trim_value, sym); + funarg = trimmed.name; + if (trimmed.value) args[i] = trimmed.value; + } + if (funarg) { + trim = false; + argnames[i] = funarg; + if (!after) after = !(funarg instanceof AST_SymbolFunarg); + } else if (trim) { + log_default(sym, "Dropping unused default argument {name}"); + argnames.pop(); + } else if (i > default_length) { + log_default(sym, "Dropping unused default argument assignment {name}"); + if (sym.name instanceof AST_SymbolFunarg) { + sym.name.unused = true; + } else { + after = true; + } + argnames[i] = sym.name; + } else { + log_default(sym, "Dropping unused default argument value {name}"); + argnames[i] = sym = sym.clone(); + sym.value = make_node(AST_Number, sym, { value: 0 }); + after = true; + } + } + } + if (before && !after && node.uses_arguments && !tt.has_directive("use strict")) { + node.rest = make_node(AST_DestructuredArray, node, { elements: [] }); + } + fns_with_marked_args.push(node); + } + return node; + } + if (node instanceof AST_Catch && node.argname instanceof AST_Destructured) { + node.argname.transform(trimmer); + } + if (node instanceof AST_Definitions && !(parent instanceof AST_ForEnumeration && parent.init === node)) { + // place uninitialized names at the start + var body = [], head = [], tail = []; + // for unused names whose initialization has + // side effects, we can cascade the init. code + // into the next one, or next statement. + var side_effects = []; + var duplicated = 0; + var is_var = node instanceof AST_Var; + node.definitions.forEach(function(def) { + if (def.value) def.value = def.value.transform(tt); + var value = def.value; + if (def.name instanceof AST_Destructured) { + var trimmed = trim_destructured(def.name, value, function(node) { + if (!drop_vars) return node; + if (node.definition().id in in_use_ids) return node; + if (is_catch(node)) return node; + if (is_var && !can_drop_symbol(node)) return node; + return null; + }, true); + if (trimmed.name) { + def = make_node(AST_VarDef, def, { + name: trimmed.name, + value: value = trimmed.value, + }); + flush(); + } else if (trimmed.value) { + side_effects.push(trimmed.value); + } + return; + } + var sym = def.name.definition(); + var drop_sym = is_var ? can_drop_symbol(def.name) : is_safe_lexical(sym); + if (!drop_sym || !drop_vars || sym.id in in_use_ids) { + var index; + if (value && ((index = indexOf_assign(sym, def)) < 0 || self_assign(value.tail_node()))) { + def = def.clone(); + value = value.drop_side_effect_free(compressor); + if (value) AST_Node.warn("Side effects in definition of variable {name} [{start}]", def.name); + if (node instanceof AST_Const) { + def.value = value || make_node(AST_Number, def, { value: 0 }); + } else { + def.value = null; + if (value) side_effects.push(value); + } + value = null; + if (index >= 0) assign_in_use[sym.id][index] = def; + } + var old_def, fn; + if (!value && !(node instanceof AST_Let)) { + if (parent instanceof AST_ExportDeclaration) { + flush(); + } else if (drop_sym && var_defs[sym.id] > 1) { + AST_Node.info("Dropping declaration of variable {name} [{start}]", def.name); + var_defs[sym.id]--; + sym.eliminated++; + } else { + head.push(def); + } + } else if (compressor.option("functions") + && !compressor.option("ie") + && drop_sym + && value + && var_defs[sym.id] == 1 + && sym.assignments == 0 + && (fn = value.tail_node()) instanceof AST_LambdaExpression + && !is_arguments(sym) + && !is_arrow(fn) + && assigned_once(fn, sym.references) + && can_declare_defun(fn) + && (old_def = rename_def(fn, def.name.name)) !== false) { + AST_Node.warn("Declaring {name} as function [{start}]", def.name); + var ctor; + switch (fn.CTOR) { + case AST_AsyncFunction: + ctor = AST_AsyncDefun; + break; + case AST_AsyncGeneratorFunction: + ctor = AST_AsyncGeneratorDefun; + break; + case AST_Function: + ctor = AST_Defun; + break; + case AST_GeneratorFunction: + ctor = AST_GeneratorDefun; + break; + } + var defun = make_node(ctor, fn); + defun.name = make_node(AST_SymbolDefun, def.name); + var name_def = def.name.scope.resolve().def_function(defun.name); + if (old_def) old_def.forEach(function(node) { + node.name = name_def.name; + node.thedef = name_def; + node.reference(); + }); + body.push(defun); + if (value !== fn) [].push.apply(side_effects, value.expressions.slice(0, -1)); + sym.eliminated++; + } else { + if (drop_sym + && var_defs[sym.id] > 1 + && !(parent instanceof AST_ExportDeclaration) + && sym.orig.indexOf(def.name) > sym.eliminated) { + var_defs[sym.id]--; + duplicated++; + } + flush(); + } + } else if (is_catch(def.name)) { + value = value && value.drop_side_effect_free(compressor); + if (value) side_effects.push(value); + if (var_defs[sym.id] > 1) { + AST_Node.warn("Dropping duplicated declaration of variable {name} [{start}]", def.name); + var_defs[sym.id]--; + sym.eliminated++; + } else { + def.value = null; + head.push(def); + } + } else { + value = value && value.drop_side_effect_free(compressor); + if (value) { + AST_Node.warn("Side effects in initialization of unused variable {name} [{start}]", def.name); + side_effects.push(value); + } else { + log(def.name, "Dropping unused variable {name}"); + } + sym.eliminated++; + } + + function self_assign(ref) { + return ref instanceof AST_SymbolRef && ref.definition() === sym; + } + + function assigned_once(fn, refs) { + if (refs.length == 0) return fn === def.name.fixed_value(); + return all(refs, function(ref) { + return fn === ref.fixed_value(); + }); + } + + function can_declare_defun(fn) { + if (!is_var || compressor.has_directive("use strict") || !(fn instanceof AST_Function)) { + return parent instanceof AST_Scope; + } + return parent instanceof AST_Block + || parent instanceof AST_For && parent.init === node + || parent instanceof AST_If; + } + + function rename_def(fn, name) { + if (!fn.name) return null; + var def = fn.name.definition(); + if (def.orig.length > 1) return null; + if (def.assignments > 0) return false; + if (def.name == name) return def; + if (compressor.option("keep_fnames")) return false; + var forbidden; + switch (name) { + case "await": + forbidden = is_async; + break; + case "yield": + forbidden = is_generator; + break; + } + return all(def.references, function(ref) { + var scope = ref.scope; + if (scope.find_variable(name) !== sym) return false; + if (forbidden) do { + scope = scope.resolve(); + if (forbidden(scope)) return false; + } while (scope !== fn && (scope = scope.parent_scope)); + return true; + }) && def; + } + + function is_catch(node) { + var sym = node.definition(); + return sym.orig[0] instanceof AST_SymbolCatch && sym.scope.resolve() === node.scope.resolve(); + } + + function flush() { + if (side_effects.length > 0) { + if (tail.length == 0) { + body.push(make_node(AST_SimpleStatement, node, { + body: make_sequence(node, side_effects), + })); + } else if (value) { + side_effects.push(value); + def.value = make_sequence(value, side_effects); + } else { + def.value = make_node(AST_UnaryPrefix, def, { + operator: "void", + expression: make_sequence(def, side_effects), + }); + } + side_effects = []; + } + tail.push(def); + } + }); + switch (head.length) { + case 0: + if (tail.length == 0) break; + if (tail.length == duplicated) { + [].unshift.apply(side_effects, tail.map(function(def) { + AST_Node.info("Dropping duplicated definition of variable {name} [{start}]", def.name); + var sym = def.name.definition(); + var ref = make_node(AST_SymbolRef, def.name); + sym.references.push(ref); + var assign = make_node(AST_Assign, def, { + operator: "=", + left: ref, + right: def.value, + }); + var index = indexOf_assign(sym, def); + if (index >= 0) assign_in_use[sym.id][index] = assign; + sym.assignments++; + sym.eliminated++; + return assign; + })); + break; + } + case 1: + if (tail.length == 0) { + var id = head[0].name.definition().id; + if (id in for_ins) { + node.definitions = head; + for_ins[id].init = node; + break; + } + } + default: + var seq; + if (tail.length > 0 && (seq = tail[0].value) instanceof AST_Sequence) { + tail[0].value = seq.tail_node(); + body.push(make_node(AST_SimpleStatement, node, { + body: make_sequence(seq, seq.expressions.slice(0, -1)), + })); + } + node.definitions = head.concat(tail); + body.push(node); + } + if (side_effects.length > 0) { + body.push(make_node(AST_SimpleStatement, node, { body: make_sequence(node, side_effects) })); + } + return insert_statements(body, node, in_list); + } + if (node instanceof AST_Assign) { + descend(node, tt); + if (!(node.left instanceof AST_Destructured)) return node; + var trimmed = trim_destructured(node.left, node.right, function(node) { + return node; + }, node.write_only === true); + if (trimmed.name) return make_node(AST_Assign, node, { + operator: node.operator, + left: trimmed.name, + right: trimmed.value, + }); + if (trimmed.value) return trimmed.value; + if (parent instanceof AST_Sequence && parent.tail_node() !== node) return List.skip; + return make_node(AST_Number, node, { value: 0 }); + } + if (node instanceof AST_LabeledStatement && node.body instanceof AST_For) { + // Certain combination of unused name + side effect leads to invalid AST: + // https://github.com/mishoo/UglifyJS/issues/1830 + // We fix it at this stage by moving the label inwards, back to the `for`. + descend(node, tt); + if (node.body instanceof AST_BlockStatement) { + var block = node.body; + node.body = block.body.pop(); + block.body.push(node); + return in_list ? List.splice(block.body) : block; + } + return node; + } + if (node instanceof AST_Scope) { + descend_scope(); + return node; + } + if (node instanceof AST_SymbolImport) { + if (!compressor.option("imports") || node.definition().id in in_use_ids) return node; + return in_list ? List.skip : null; + } + + function descend_scope() { + var save_scope = scope; + scope = node; + descend(node, tt); + scope = save_scope; + } + }, function(node, in_list) { + if (node instanceof AST_BlockStatement) return trim_block(node, tt.parent(), in_list); + if (node instanceof AST_ExportDeclaration) { + var block = node.body; + if (!(block instanceof AST_BlockStatement)) return; + node.body = block.body.pop(); + block.body.push(node); + return in_list ? List.splice(block.body) : block; + } + if (node instanceof AST_For) return patch_for_init(node, in_list); + if (node instanceof AST_ForIn) { + if (!drop_vars || !compressor.option("loops")) return; + if (!is_empty(node.body)) return; + var sym = get_init_symbol(node); + if (!sym) return; + var def = sym.definition(); + if (def.id in in_use_ids) return; + log(sym, "Dropping unused loop variable {name}"); + if (for_ins[def.id] === node) delete for_ins[def.id]; + var body = []; + var value = node.object.drop_side_effect_free(compressor); + if (value) { + AST_Node.warn("Side effects in object of for-in loop [{start}]", value); + body.push(make_node(AST_SimpleStatement, node, { body: value })); + } + if (node.init instanceof AST_Definitions && def.orig[0] instanceof AST_SymbolCatch) { + body.push(node.init); + } + return insert_statements(body, node, in_list); + } + if (node instanceof AST_Import) { + if (node.properties && node.properties.length == 0) node.properties = null; + return node; + } + if (node instanceof AST_Sequence) { + if (node.expressions.length > 1) return; + return maintain_this_binding(tt.parent(), node, node.expressions[0]); + } + }); + tt.push(compressor.parent()); + tt.directives = Object.create(compressor.directives); + self.transform(tt); + if (self instanceof AST_Lambda + && self.body.length == 1 + && self.body[0] instanceof AST_Directive + && self.body[0].value == "use strict") { + self.body.length = 0; + } + calls_to_drop_args.forEach(function(call) { + drop_unused_call_args(call, compressor, fns_with_marked_args); + }); + + function log(sym, text) { + AST_Node[sym.definition().references.length > 0 ? "info" : "warn"](text + " [{start}]", sym); + } + + function log_default(node, text) { + if (node.name instanceof AST_SymbolFunarg) { + log(node.name, text); + } else { + AST_Node.info(text + " [{start}]", node); + } + } + + function get_rvalue(expr) { + return expr[expr instanceof AST_Assign ? "right" : "value"]; + } + + function insert_statements(body, orig, in_list) { + switch (body.length) { + case 0: + return in_list ? List.skip : make_node(AST_EmptyStatement, orig); + case 1: + return body[0]; + default: + return in_list ? List.splice(body) : make_node(AST_BlockStatement, orig, { body: body }); + } + } + + function track_assigns(def, node) { + if (def.scope.resolve() !== self) return false; + if (!def.fixed || !node.fixed) assign_in_use[def.id] = false; + return assign_in_use[def.id] !== false; + } + + function add_assigns(def, node) { + if (!assign_in_use[def.id]) assign_in_use[def.id] = []; + if (node.fixed.assigns) push_uniq(assign_in_use[def.id], node.fixed.assigns); + } + + function indexOf_assign(def, node) { + var nodes = assign_in_use[def.id]; + return nodes && nodes.indexOf(node); + } + + function unmark_lambda(def) { + if (lambda_ids[def.id] > 1 && !(def.id in in_use_ids)) { + in_use_ids[def.id] = true; + in_use.push(def); + } + lambda_ids[def.id] = 0; + } + + function verify_safe_usage(def, read, modified) { + if (def.id in in_use_ids) return; + if (read && modified) { + in_use_ids[def.id] = read; + in_use.push(def); + } else { + value_read[def.id] = read; + value_modified[def.id] = modified; + } + } + + function can_drop_lhs(sym, node) { + var def = sym.definition(); + var in_use = in_use_ids[def.id]; + if (!in_use) return true; + if (node[node instanceof AST_Assign ? "left" : "expression"] !== sym) return false; + return in_use === sym && def.references.length - def.replaced == 1 || indexOf_assign(def, node) < 0; + } + + function get_rhs(assign) { + var rhs = assign.right; + if (!assign.write_only) return rhs; + if (!(rhs instanceof AST_Binary && lazy_op[rhs.operator])) return rhs; + if (!(rhs.left instanceof AST_SymbolRef)) return rhs; + if (!(assign.left instanceof AST_SymbolRef)) return rhs; + var def = assign.left.definition(); + if (rhs.left.definition() !== def) return rhs; + if (rhs.right.has_side_effects(compressor)) return rhs; + if (track_assigns(def, rhs.left)) add_assigns(def, rhs.left); + return rhs.right; + } + + function get_init_symbol(for_in) { + var init = for_in.init; + if (init instanceof AST_Definitions) { + init = init.definitions[0].name; + return init instanceof AST_SymbolDeclaration && init; + } + while (init instanceof AST_PropAccess) init = init.expression.tail_node(); + if (init instanceof AST_SymbolRef) return init; + } + + function scan_ref_scoped(node, descend, init) { + if (node instanceof AST_Assign && node.left instanceof AST_SymbolRef) { + var def = node.left.definition(); + if (def.scope.resolve() === self) assignments.add(def.id, node); + } + if (node instanceof AST_SymbolRef && node.in_arg) var_defs[node.definition().id] = 0; + if (node instanceof AST_Unary && node.expression instanceof AST_SymbolRef) { + var def = node.expression.definition(); + if (def.scope.resolve() === self) assignments.add(def.id, node); + } + var props = [], sym = assign_as_unused(node, props); + if (sym) { + var node_def = sym.definition(); + if (node_def.scope.resolve() !== self && self.variables.get(sym.name) !== node_def) return; + if (is_arguments(node_def) && !all(self.argnames, function(argname) { + return !argname.match_symbol(function(node) { + if (node instanceof AST_SymbolFunarg) { + var def = node.definition(); + return def.references.length > def.replaced; + } + }, true); + })) return; + if (node.write_only === "p" && node.right.may_throw_on_access(compressor, true)) return; + var assign = props.assign; + if (assign) { + initializations.add(node_def.id, assign.left); + assign.write_only = true; + assign.walk(tw); + } + props.forEach(function(prop) { + prop.walk(tw); + }); + if (node instanceof AST_Assign) { + var fixed = sym.fixed_value(); + var right = get_rhs(node); + var safe = fixed && fixed.is_constant(); + var shared = false; + if (init + && node.write_only === true + && (safe || node.left === sym || right.equals(sym)) + && !right.has_side_effects(compressor)) { + initializations.add(node_def.id, right); + } else { + right.walk(tw); + shared = right.tail_node().operator == "="; + } + if (node.left === sym) { + if (!node.write_only || shared) { + verify_safe_usage(node_def, sym, value_modified[node_def.id]); + } + } else if (!safe) { + verify_safe_usage(node_def, value_read[node_def.id], true); + } + } + if (track_assigns(node_def, sym) && is_lhs(sym, node) !== sym) add_assigns(node_def, sym); + unmark_lambda(node_def); + return true; + } + if (node instanceof AST_Binary) { + if (node.operator != "instanceof") return; + var sym = node.right; + if (!(sym instanceof AST_SymbolRef)) return; + var id = sym.definition().id; + if (!lambda_ids[id]) return; + node.left.walk(tw); + lambda_ids[id]++; + return true; + } + if (node instanceof AST_ForIn) { + if (node.init instanceof AST_SymbolRef && scope === self) { + var id = node.init.definition().id; + if (!(id in for_ins)) for_ins[id] = node; + } + if (!drop_vars || !compressor.option("loops")) return; + if (!is_empty(node.body)) return; + if (node.init.has_side_effects(compressor)) return; + var sym = get_init_symbol(node); + if (!sym) return; + var def = sym.definition(); + if (def.scope.resolve() !== self) { + var d = find_variable(sym.name); + if (d === def || d && d.redefined() === def) return; + } + node.object.walk(tw); + return true; + } + if (node instanceof AST_SymbolRef) { + var node_def = node.definition(); + if (!(node_def.id in in_use_ids)) { + in_use_ids[node_def.id] = true; + in_use.push(node_def); + } + if (cross_scope(node_def.scope, node.scope)) { + var redef = node_def.redefined(); + if (redef && !(redef.id in in_use_ids)) { + in_use_ids[redef.id] = true; + in_use.push(redef); + } + } + if (track_assigns(node_def, node)) add_assigns(node_def, node); + return true; + } + if (node instanceof AST_Scope) { + var save_scope = scope; + scope = node; + descend(); + scope = save_scope; + return true; + } + } + + function is_decl(node) { + return (node instanceof AST_DefaultValue ? node.name : node) instanceof AST_SymbolDeclaration; + } + + function trim_decl(node) { + if (node.definition().id in in_use_ids) return node; + if (node instanceof AST_SymbolFunarg) node.unused = true; + return null; + } + + function trim_default(trimmer, node) { + node.value = node.value.transform(tt); + var name = node.name.transform(trimmer); + if (!name) { + if (node.name instanceof AST_Destructured) return null; + var value = node.value.drop_side_effect_free(compressor); + if (!value) return null; + log(node.name, "Side effects in default value of unused variable {name}"); + node = node.clone(); + node.name.unused = null; + node.value = value; + } + return node; + } + + function trim_destructured(node, value, process, drop, root) { + var unwind = true; + var trimmer = new TreeTransformer(function(node) { + if (node instanceof AST_DefaultValue) { + if (!(compressor.option("default_values") && value && value.is_defined(compressor))) { + var save_drop = drop; + drop = false; + var trimmed = trim_default(trimmer, node); + drop = save_drop; + if (!trimmed && drop && value) value = value.drop_side_effect_free(compressor); + return trimmed; + } else if (node === root) { + root = node = node.name; + } else { + node = node.name; + } + } + if (node instanceof AST_DestructuredArray) { + var save_drop = drop; + var save_unwind = unwind; + var save_value = value; + if (value instanceof AST_SymbolRef) { + drop = false; + value = value.fixed_value(); + } + var last_side_effects, native, values; + if (value instanceof AST_Array) { + native = true; + values = value.elements; + if (save_unwind) for (last_side_effects = values.length; --last_side_effects >= 0;) { + if (values[last_side_effects].has_side_effects(compressor)) break; + } + } else { + native = value && value.is_string(compressor); + values = false; + last_side_effects = node.elements.length; + } + var elements = [], newValues = drop && [], pos = 0; + node.elements.forEach(function(element, index) { + if (save_unwind) unwind = index >= last_side_effects; + value = values && values[index]; + if (value instanceof AST_Hole) { + value = null; + } else if (value instanceof AST_Spread) { + if (drop) { + newValues.length = pos; + fill_holes(save_value, newValues); + [].push.apply(newValues, values.slice(index)); + save_value.elements = newValues; + } + value = values = false; + } + element = element.transform(trimmer); + if (element) elements[pos] = element; + if (drop && value) newValues[pos] = value; + if (element || value || !drop || !values) pos++; + }); + value = values && make_node(AST_Array, save_value, { + elements: values.slice(node.elements.length), + }); + if (node.rest) { + var was_drop = drop; + drop = false; + node.rest = node.rest.transform(compressor.option("rests") ? trimmer : tt); + drop = was_drop; + if (node.rest) elements.length = pos; + } + if (drop) { + if (value && !node.rest) value = value.drop_side_effect_free(compressor); + if (value instanceof AST_Array) { + value = value.elements; + } else if (value instanceof AST_Sequence) { + value = value.expressions; + } else if (value) { + value = [ value ]; + } + if (value && value.length) { + newValues.length = pos; + [].push.apply(newValues, value); + } + } + value = save_value; + unwind = save_unwind; + drop = save_drop; + if (values && newValues) { + fill_holes(value, newValues); + value = value.clone(); + value.elements = newValues; + } + if (!native) { + elements.length = node.elements.length; + } else if (!node.rest) SHORTHAND: switch (elements.length) { + case 0: + if (node === root) break; + if (drop) value = value.drop_side_effect_free(compressor); + return null; + default: + if (!drop) break; + if (!unwind) break; + if (node === root) break; + var pos = elements.length, sym; + while (--pos >= 0) { + var element = elements[pos]; + if (element) { + sym = element; + break; + } + } + if (pos < 0) break; + for (var i = pos; --i >= 0;) { + if (elements[i]) break SHORTHAND; + } + if (sym.has_side_effects(compressor)) break; + if (value.has_side_effects(compressor) && sym.match_symbol(function(node) { + return node instanceof AST_PropAccess; + })) break; + value = make_node(AST_Sub, node, { + expression: value, + property: make_node(AST_Number, node, { value: pos }), + }); + return sym; + } + fill_holes(node, elements); + node.elements = elements; + return node; + } + if (node instanceof AST_DestructuredObject) { + var save_drop = drop; + var save_unwind = unwind; + var save_value = value; + if (value instanceof AST_SymbolRef) { + drop = false; + value = value.fixed_value(); + } + var last_side_effects, prop_keys, prop_map, values; + if (value instanceof AST_Object) { + last_side_effects = -1; + prop_keys = []; + prop_map = new Dictionary(); + values = value.properties.map(function(prop, index) { + if (save_unwind && prop.has_side_effects(compressor)) last_side_effects = index; + prop = prop.clone(); + if (prop instanceof AST_Spread) { + prop_map = false; + } else { + var key = prop.key; + if (key instanceof AST_Node) key = key.evaluate(compressor, true); + if (key instanceof AST_Node) { + prop_map = false; + } else if (prop_map && !(prop instanceof AST_ObjectSetter)) { + prop_map.set(key, prop); + } + prop_keys[index] = key; + } + return prop; + }); + } else { + last_side_effects = node.properties.length; + } + if (node.rest) { + value = false; + node.rest = node.rest.transform(compressor.option("rests") ? trimmer : tt); + } + var can_drop = new Dictionary(); + var drop_keys = drop && new Dictionary(); + var properties = []; + node.properties.map(function(prop) { + var key = prop.key; + if (key instanceof AST_Node) { + prop.key = key = key.transform(tt); + key = key.evaluate(compressor, true); + } + if (key instanceof AST_Node) { + drop_keys = false; + } else { + can_drop.set(key, !can_drop.has(key)); + } + return key; + }).forEach(function(key, index) { + var prop = node.properties[index], trimmed; + if (save_unwind) unwind = index >= last_side_effects; + if (key instanceof AST_Node) { + drop = false; + value = false; + trimmed = prop.value.transform(trimmer) || retain_lhs(prop.value); + } else { + drop = drop_keys && can_drop.get(key); + var mapped = prop_map && prop_map.get(key); + if (mapped) { + value = mapped.value; + if (value instanceof AST_Accessor) value = false; + } else { + value = false; + } + trimmed = prop.value.transform(trimmer); + if (!trimmed) { + if (node.rest || retain_key(prop)) trimmed = retain_lhs(prop.value); + if (drop_keys && !drop_keys.has(key)) { + if (mapped) { + drop_keys.set(key, mapped); + if (value === null) { + prop_map.set(key, retain_key(mapped) && make_node(AST_ObjectKeyVal, mapped, { + key: mapped.key, + value: make_node(AST_Number, mapped, { value: 0 }), + })); + } + } else { + drop_keys.set(key, true); + } + } + } else if (drop_keys) { + drop_keys.set(key, false); + } + if (value) mapped.value = value; + } + if (trimmed) { + prop.value = trimmed; + properties.push(prop); + } + }); + value = save_value; + unwind = save_unwind; + drop = save_drop; + if (drop_keys && prop_keys) { + value = value.clone(); + value.properties = List(values, function(prop, index) { + if (prop instanceof AST_Spread) return prop; + var key = prop_keys[index]; + if (key instanceof AST_Node) return prop; + if (key === "__proto__") return prop; + if (drop_keys.has(key)) { + var mapped = drop_keys.get(key); + if (!mapped) return prop; + if (mapped === prop) return prop_map.get(key) || List.skip; + } else if (node.rest) { + return prop; + } + var trimmed = prop.value.drop_side_effect_free(compressor); + if (trimmed) { + prop.value = trimmed; + return prop; + } + return retain_key(prop) ? make_node(AST_ObjectKeyVal, prop, { + key: prop.key, + value: make_node(AST_Number, prop, { value: 0 }), + }) : List.skip; + }); + } + if (value && !node.rest) switch (properties.length) { + case 0: + if (node === root) break; + if (value.may_throw_on_access(compressor, true)) break; + if (drop) value = value.drop_side_effect_free(compressor); + return null; + case 1: + if (!drop) break; + if (!unwind) break; + if (node === root) break; + var prop = properties[0]; + if (prop.key instanceof AST_Node) break; + if (prop.value.has_side_effects(compressor)) break; + if (value.has_side_effects(compressor) && prop.value.match_symbol(function(node) { + return node instanceof AST_PropAccess; + })) break; + value = is_identifier_string(prop.key) ? make_node(AST_Dot, node, { + expression: value, + property: prop.key, + }) : make_node(AST_Sub, node, { + expression: value, + property: make_node_from_constant(prop.key, prop), + }); + return prop.value; + } + node.properties = properties; + return node; + } + if (node instanceof AST_Hole) { + node = null; + } else { + node = process(node); + } + if (!node && drop && value) value = value.drop_side_effect_free(compressor); + return node; + }); + return { + name: node.transform(trimmer), + value: value, + }; + + function retain_key(prop) { + return prop.key instanceof AST_Node && prop.key.has_side_effects(compressor); + } + + function clear_write_only(node) { + if (node instanceof AST_Assign) { + node.write_only = false; + clear_write_only(node.right); + } else if (node instanceof AST_Binary) { + if (!lazy_op[node.operator]) return; + clear_write_only(node.left); + clear_write_only(node.right); + } else if (node instanceof AST_Conditional) { + clear_write_only(node.consequent); + clear_write_only(node.alternative); + } else if (node instanceof AST_Sequence) { + clear_write_only(node.tail_node()); + } else if (node instanceof AST_Unary) { + node.write_only = false; + } + } + + function retain_lhs(node) { + if (node instanceof AST_DefaultValue) return retain_lhs(node.name); + if (node instanceof AST_Destructured) { + if (value === null) { + value = make_node(AST_Number, node, { value: 0 }); + } else if (value) { + if (value.may_throw_on_access(compressor, true)) { + value = make_node(AST_Array, node, { + elements: value instanceof AST_Sequence ? value.expressions : [ value ], + }); + } else { + clear_write_only(value); + } + } + return make_node(AST_DestructuredObject, node, { properties: [] }); + } + node.unused = null; + return node; + } + } + }); + + AST_Scope.DEFMETHOD("hoist_declarations", function(compressor) { + if (compressor.has_directive("use asm")) return; + var hoist_funs = compressor.option("hoist_funs"); + var hoist_vars = compressor.option("hoist_vars"); + var self = this; + if (hoist_vars) { + // let's count var_decl first, we seem to waste a lot of + // space if we hoist `var` when there's only one. + var var_decl = 0; + self.walk(new TreeWalker(function(node) { + if (var_decl > 1) return true; + if (node instanceof AST_ExportDeclaration) return true; + if (node instanceof AST_Scope && node !== self) return true; + if (node instanceof AST_Var) { + var_decl++; + return true; + } + })); + if (var_decl <= 1) hoist_vars = false; + } + if (!hoist_funs && !hoist_vars) return; + var consts = new Dictionary(); + var dirs = []; + var hoisted = []; + var vars = new Dictionary(); + var tt = new TreeTransformer(function(node, descend, in_list) { + if (node === self) return; + if (node instanceof AST_Directive) { + dirs.push(node); + return in_list ? List.skip : make_node(AST_EmptyStatement, node); + } + if (node instanceof AST_LambdaDefinition) { + if (!hoist_funs) return node; + var p = tt.parent(); + if (p instanceof AST_ExportDeclaration) return node; + if (p instanceof AST_ExportDefault) return node; + if (p !== self && compressor.has_directive("use strict")) return node; + hoisted.push(node); + return in_list ? List.skip : make_node(AST_EmptyStatement, node); + } + if (node instanceof AST_Var) { + if (!hoist_vars) return node; + var p = tt.parent(); + if (p instanceof AST_ExportDeclaration) return node; + if (!all(node.definitions, function(defn) { + var sym = defn.name; + return sym instanceof AST_SymbolVar + && !consts.has(sym.name) + && self.find_variable(sym.name) === sym.definition(); + })) return node; + node.definitions.forEach(function(defn) { + var name = defn.name.name; + if (!vars.has(name)) vars.set(name, defn); + }); + var seq = node.to_assignments(); + if (p instanceof AST_ForEnumeration && p.init === node) { + if (seq) return seq; + var sym = node.definitions[0].name; + return make_node(AST_SymbolRef, sym); + } + if (p instanceof AST_For && p.init === node) return seq; + if (!seq) return in_list ? List.skip : make_node(AST_EmptyStatement, node); + return make_node(AST_SimpleStatement, node, { body: seq }); + } + if (node instanceof AST_Scope) return node; + if (node instanceof AST_SymbolConst) { + consts.set(node.name, true); + return node; + } + }); + self.transform(tt); + if (vars.size() > 0) { + // collect only vars which don't show up in self's arguments list + var defns = []; + if (self instanceof AST_Lambda) self.each_argname(function(argname) { + if (all(argname.definition().references, function(ref) { + return !ref.in_arg; + })) vars.del(argname.name); + }); + vars.each(function(defn) { + var name = defn.name; + defn = defn.clone(); + defn.name = name.clone(); + defn.value = null; + defns.push(defn); + var orig = name.definition().orig; + orig.splice(orig.indexOf(name), 0, defn.name); + }); + if (defns.length > 0) hoisted.push(make_node(AST_Var, self, { definitions: defns })); + } + self.body = dirs.concat(hoisted, self.body); + }); + + function scan_local_returns(fn, transform) { + fn.walk(new TreeWalker(function(node) { + if (node instanceof AST_Return) { + transform(node); + return true; + } + if (node instanceof AST_Scope && node !== fn) return true; + })); + } + + function map_self_returns(fn) { + var map = Object.create(null); + scan_local_returns(fn, function(node) { + var value = node.value; + if (value) value = value.tail_node(); + if (value instanceof AST_SymbolRef) { + var id = value.definition().id; + map[id] = (map[id] || 0) + 1; + } + }); + return map; + } + + function can_trim_returns(def, self_returns, compressor) { + if (compressor.exposed(def)) return false; + switch (def.references.length - def.replaced - (self_returns[def.id] || 0)) { + case def.drop_return: + return "d"; + case def.bool_return: + return true; + } + } + + function process_boolean_returns(fn, compressor) { + scan_local_returns(fn, function(node) { + node.in_bool = true; + var value = node.value; + if (value) { + var ev = fuzzy_eval(compressor, value); + if (!ev) { + value = value.drop_side_effect_free(compressor); + node.value = value ? make_sequence(node.value, [ + value, + make_node(AST_Number, node.value, { value: 0 }), + ]) : null; + } else if (!(ev instanceof AST_Node)) { + value = value.drop_side_effect_free(compressor); + node.value = value ? make_sequence(node.value, [ + value, + make_node(AST_Number, node.value, { value: 1 }), + ]) : make_node(AST_Number, node.value, { value: 1 }); + } + } + }); + } + + AST_Scope.DEFMETHOD("process_returns", noop); + AST_Defun.DEFMETHOD("process_returns", function(compressor) { + if (!compressor.option("booleans")) return; + if (compressor.parent() instanceof AST_ExportDefault) return; + switch (can_trim_returns(this.name.definition(), map_self_returns(this), compressor)) { + case "d": + drop_returns(compressor, this, true); + break; + case true: + process_boolean_returns(this, compressor); + break; + } + }); + AST_Function.DEFMETHOD("process_returns", function(compressor) { + if (!compressor.option("booleans")) return; + var drop = true; + var self_returns = map_self_returns(this); + if (this.name && !can_trim(this.name.definition())) return; + var parent = compressor.parent(); + if (parent instanceof AST_Assign) { + if (parent.operator != "=") return; + var sym = parent.left; + if (!(sym instanceof AST_SymbolRef)) return; + if (!can_trim(sym.definition())) return; + } else if (parent instanceof AST_Call && parent.expression !== this) { + var exp = parent.expression; + if (exp instanceof AST_SymbolRef) exp = exp.fixed_value(); + if (!(exp instanceof AST_Lambda)) return; + if (exp.uses_arguments || exp.pinned()) return; + var args = parent.args, sym; + for (var i = 0; i < args.length; i++) { + var arg = args[i]; + if (arg === this) { + sym = exp.argnames[i]; + if (!sym && exp.rest) return; + break; + } + if (arg instanceof AST_Spread) return; + } + if (sym instanceof AST_DefaultValue) sym = sym.name; + if (sym instanceof AST_SymbolFunarg && !can_trim(sym.definition())) return; + } else if (parent.TYPE == "Call") { + compressor.pop(); + var in_bool = compressor.in_boolean_context(); + compressor.push(this); + switch (in_bool) { + case true: + drop = false; + case "d": + break; + default: + return; + } + } else return; + if (drop) { + drop_returns(compressor, this, true); + } else { + process_boolean_returns(this, compressor); + } + + function can_trim(def) { + switch (can_trim_returns(def, self_returns, compressor)) { + case true: + drop = false; + case "d": + return true; + } + } + }); + + AST_BlockScope.DEFMETHOD("var_names", function() { + var var_names = this._var_names; + if (!var_names) { + this._var_names = var_names = new Dictionary(); + this.enclosed.forEach(function(def) { + var_names.set(def.name, true); + }); + this.variables.each(function(def, name) { + var_names.set(name, true); + }); + } + return var_names; + }); + + AST_Scope.DEFMETHOD("make_var", function(type, orig, prefix) { + var scopes = [ this ]; + if (orig instanceof AST_SymbolDeclaration) orig.definition().references.forEach(function(ref) { + var s = ref.scope; + do { + if (!push_uniq(scopes, s)) return; + s = s.parent_scope; + } while (s && s !== this); + }); + prefix = prefix.replace(/^[^a-z_$]|[^a-z0-9_$]/gi, "_"); + var name = prefix; + for (var i = 0; !all(scopes, function(scope) { + return !scope.var_names().has(name); + }); i++) name = prefix + "$" + i; + var sym = make_node(type, orig, { + name: name, + scope: this, + }); + var def = this.def_variable(sym); + scopes.forEach(function(scope) { + scope.enclosed.push(def); + scope.var_names().set(name, true); + }); + return sym; + }); + + AST_Scope.DEFMETHOD("hoist_properties", function(compressor) { + if (!compressor.option("hoist_props") || compressor.has_directive("use asm")) return; + var self = this; + if (is_arrow(self) && self.value) return; + var top_retain = self instanceof AST_Toplevel && compressor.top_retain || return_false; + var defs_by_id = Object.create(null); + var tt = new TreeTransformer(function(node, descend) { + if (node instanceof AST_Assign) { + if (node.operator != "=") return; + if (!node.write_only) return; + if (!can_hoist(node.left, node.right, 1)) return; + descend(node, tt); + var defs = new Dictionary(); + var assignments = []; + var decls = []; + node.right.properties.forEach(function(prop) { + var decl = make_sym(AST_SymbolVar, node.left, prop.key); + decls.push(make_node(AST_VarDef, node, { + name: decl, + value: null, + })); + var sym = make_node(AST_SymbolRef, node, { + name: decl.name, + scope: self, + thedef: decl.definition(), + }); + sym.reference(); + assignments.push(make_node(AST_Assign, node, { + operator: "=", + left: sym, + right: prop.value, + })); + }); + defs.value = node.right; + defs_by_id[node.left.definition().id] = defs; + self.body.splice(self.body.indexOf(tt.stack[1]) + 1, 0, make_node(AST_Var, node, { + definitions: decls, + })); + return make_sequence(node, assignments); + } + if (node instanceof AST_Scope) { + if (node === self) return; + var parent = tt.parent(); + if (parent.TYPE == "Call" && parent.expression === node) return; + return node; + } + if (node instanceof AST_VarDef) { + if (!can_hoist(node.name, node.value, 0)) return; + descend(node, tt); + var defs = new Dictionary(); + var var_defs = []; + var decl = node.clone(); + decl.value = node.name instanceof AST_SymbolConst ? make_node(AST_Number, node, { value: 0 }) : null; + var_defs.push(decl); + node.value.properties.forEach(function(prop) { + var_defs.push(make_node(AST_VarDef, node, { + name: make_sym(node.name.CTOR, node.name, prop.key), + value: prop.value, + })); + }); + defs.value = node.value; + defs_by_id[node.name.definition().id] = defs; + return List.splice(var_defs); + } + + function make_sym(type, sym, key) { + var new_var = self.make_var(type, sym, sym.name + "_" + key); + defs.set(key, new_var.definition()); + return new_var; + } + }); + self.transform(tt); + self.transform(new TreeTransformer(function(node, descend) { + if (node instanceof AST_PropAccess) { + if (!(node.expression instanceof AST_SymbolRef)) return; + var defs = defs_by_id[node.expression.definition().id]; + if (!defs) return; + if (node.expression.fixed_value() !== defs.value) return; + var def = defs.get(node.get_property()); + var sym = make_node(AST_SymbolRef, node, { + name: def.name, + scope: node.expression.scope, + thedef: def, + }); + sym.reference(); + return sym; + } + if (node instanceof AST_SymbolRef) { + var defs = defs_by_id[node.definition().id]; + if (!defs) return; + if (node.fixed_value() !== defs.value) return; + return make_node(AST_Object, node, { properties: [] }); + } + })); + + function can_hoist(sym, right, count) { + if (!(sym instanceof AST_Symbol)) return; + var def = sym.definition(); + if (def.assignments != count) return; + if (def.references.length - def.replaced == count) return; + if (def.single_use) return; + if (self.find_variable(sym.name) !== def) return; + if (top_retain(def)) return; + if (sym.fixed_value() !== right) return; + var fixed = sym.fixed || def.fixed; + if (fixed.direct_access) return; + if (fixed.escaped && fixed.escaped.depth == 1) return; + return right instanceof AST_Object + && right.properties.length > 0 + && can_drop_symbol(sym, compressor) + && all(right.properties, function(prop) { + return can_hoist_property(prop) && prop.key !== "__proto__"; + }); + } + }); + + function fn_name_unused(fn, compressor) { + if (!fn.name || !compressor.option("ie")) return true; + var def = fn.name.definition(); + if (compressor.exposed(def)) return false; + return all(def.references, function(sym) { + return !(sym instanceof AST_SymbolRef); + }); + } + + function drop_returns(compressor, exp, ignore_name) { + if (!(exp instanceof AST_Lambda)) return; + var arrow = is_arrow(exp); + var async = is_async(exp); + var changed = false; + var drop_body = false; + if (arrow && compressor.option("arrows")) { + if (!exp.value) { + drop_body = true; + } else if (!async || needs_enqueuing(compressor, exp.value)) { + var dropped = exp.value.drop_side_effect_free(compressor); + if (dropped !== exp.value) { + changed = true; + exp.value = dropped; + } + } + } else if (!is_generator(exp)) { + if (!ignore_name && exp.name) { + var def = exp.name.definition(); + drop_body = def.references.length == def.replaced; + } else { + drop_body = true; + } + } + if (drop_body) { + exp.process_expression(false, function(node) { + var value = node.value; + if (value) { + if (async && !needs_enqueuing(compressor, value)) return node; + value = value.drop_side_effect_free(compressor, true); + } + changed = true; + if (!value) return make_node(AST_EmptyStatement, node); + return make_node(AST_SimpleStatement, node, { body: value }); + }); + scan_local_returns(exp, function(node) { + var value = node.value; + if (value) { + if (async && !needs_enqueuing(compressor, value)) return; + var dropped = value.drop_side_effect_free(compressor); + if (dropped !== value) { + changed = true; + if (dropped && async && !needs_enqueuing(compressor, dropped)) { + dropped = dropped.negate(compressor); + } + node.value = dropped; + } + } + }); + } + if (async && compressor.option("awaits")) { + if (drop_body) exp.process_expression("awaits", function(node) { + var body = node.body; + if (body instanceof AST_Await) { + if (needs_enqueuing(compressor, body.expression)) { + changed = true; + body = body.expression.drop_side_effect_free(compressor, true); + if (!body) return make_node(AST_EmptyStatement, node); + node.body = body; + } + } else if (body instanceof AST_Sequence) { + var exprs = body.expressions; + for (var i = exprs.length; --i >= 0;) { + var tail = exprs[i]; + if (!(tail instanceof AST_Await)) break; + var value = tail.expression; + if (!needs_enqueuing(compressor, value)) break; + changed = true; + if (exprs[i] = value.drop_side_effect_free(compressor)) break; + } + switch (i) { + case -1: + return make_node(AST_EmptyStatement, node); + case 0: + node.body = exprs[0]; + break; + default: + exprs.length = i + 1; + break; + } + } + return node; + }); + var abort = !drop_body && exp.name || arrow && exp.value && !needs_enqueuing(compressor, exp.value); + var tw = new TreeWalker(function(node) { + if (abort) return true; + if (tw.parent() === exp && node.may_throw(compressor)) return abort = true; + if (node instanceof AST_Await) return abort = true; + if (node instanceof AST_ForAwaitOf) return abort = true; + if (node instanceof AST_Return) { + if (node.value && !needs_enqueuing(compressor, node.value)) return abort = true; + return; + } + if (node instanceof AST_Scope && node !== exp) return true; + }); + exp.walk(tw); + if (!abort) { + var ctor; + switch (exp.CTOR) { + case AST_AsyncArrow: + ctor = AST_Arrow; + break; + case AST_AsyncFunction: + ctor = AST_Function; + break; + case AST_AsyncGeneratorFunction: + ctor = AST_GeneratorFunction; + break; + } + return make_node(ctor, exp); + } + } + return changed && exp.clone(); + } + + // drop_side_effect_free() + // remove side-effect-free parts which only affects return value + (function(def) { + // Drop side-effect-free elements from an array of expressions. + // Returns an array of expressions with side-effects or null + // if all elements were dropped. Note: original array may be + // returned if nothing changed. + function trim(nodes, compressor, first_in_statement, spread) { + var len = nodes.length; + var ret = [], changed = false; + for (var i = 0; i < len; i++) { + var node = nodes[i]; + var trimmed; + if (spread && node instanceof AST_Spread) { + trimmed = spread(node, compressor, first_in_statement); + } else { + trimmed = node.drop_side_effect_free(compressor, first_in_statement); + } + if (trimmed !== node) changed = true; + if (trimmed) { + ret.push(trimmed); + first_in_statement = false; + } + } + return ret.length ? changed ? ret : nodes : null; + } + function array_spread(node, compressor, first_in_statement) { + var exp = node.expression; + if (!exp.is_string(compressor)) return node; + return exp.drop_side_effect_free(compressor, first_in_statement); + } + function convert_spread(node) { + return node instanceof AST_Spread ? make_node(AST_Array, node, { elements: [ node ] }) : node; + } + def(AST_Node, return_this); + def(AST_Accessor, return_null); + def(AST_Array, function(compressor, first_in_statement) { + var values = trim(this.elements, compressor, first_in_statement, array_spread); + if (!values) return null; + if (values === this.elements && all(values, function(node) { + return node instanceof AST_Spread; + })) return this; + return make_sequence(this, values.map(convert_spread)); + }); + def(AST_Assign, function(compressor) { + var left = this.left; + if (left instanceof AST_PropAccess) { + var expr = left.expression; + if (expr.may_throw_on_access(compressor, true)) return this; + if (compressor.has_directive("use strict") && expr.is_constant()) return this; + } + if (left.has_side_effects(compressor)) return this; + if (lazy_op[this.operator.slice(0, -1)]) return this; + this.write_only = true; + if (!root_expr(left).is_constant_expression(compressor.find_parent(AST_Scope))) return this; + return this.right.drop_side_effect_free(compressor); + }); + def(AST_Await, function(compressor) { + if (!compressor.option("awaits")) return this; + var exp = this.expression; + if (!needs_enqueuing(compressor, exp)) return this; + if (exp instanceof AST_UnaryPrefix && exp.operator == "!") exp = exp.expression; + var dropped = exp.drop_side_effect_free(compressor); + if (dropped === exp) return this; + if (!dropped) { + dropped = make_node(AST_Number, exp, { value: 0 }); + } else if (!needs_enqueuing(compressor, dropped)) { + dropped = dropped.negate(compressor); + } + var node = this.clone(); + node.expression = dropped; + return node; + }); + def(AST_Binary, function(compressor, first_in_statement) { + var left = this.left; + var right = this.right; + var op = this.operator; + if (!can_drop_op(this, compressor)) { + var lhs = left.drop_side_effect_free(compressor, first_in_statement); + if (lhs === left) return this; + var node = this.clone(); + if (lhs) { + node.left = lhs; + } else if (op == "instanceof" && !left.is_constant()) { + node.left = make_node(AST_Array, left, { elements: [] }); + } else { + node.left = make_node(AST_Number, left, { value: 0 }); + } + return node; + } + var rhs = right.drop_side_effect_free(compressor, first_in_statement); + if (!rhs) return left.drop_side_effect_free(compressor, first_in_statement); + if (lazy_op[op] && rhs.has_side_effects(compressor)) { + var node = this; + if (rhs !== right) { + node = node.clone(); + node.right = rhs.drop_side_effect_free(compressor); + } + if (op == "??") return node; + var negated = node.clone(); + negated.operator = op == "&&" ? "||" : "&&"; + negated.left = left.negate(compressor, first_in_statement); + var negated_rhs = negated.right.tail_node(); + if (negated_rhs instanceof AST_Binary && negated.operator == negated_rhs.operator) swap_chain(negated); + var best = first_in_statement ? best_of_statement : best_of_expression; + return op == "&&" ? best(node, negated) : best(negated, node); + } + var lhs = left.drop_side_effect_free(compressor, first_in_statement); + if (!lhs) return rhs; + rhs = rhs.drop_side_effect_free(compressor); + if (!rhs) return lhs; + return make_sequence(this, [ lhs, rhs ]); + }); + function assign_this_only(fn, compressor) { + fn.new = true; + var result = all(fn.body, function(stat) { + return !stat.has_side_effects(compressor); + }) && all(fn.argnames, function(argname) { + return !argname.match_symbol(return_false); + }) && !(fn.rest && fn.rest.match_symbol(return_false)); + fn.new = false; + return result; + } + def(AST_Call, function(compressor, first_in_statement) { + var self = this; + if (self.is_expr_pure(compressor)) { + if (self.pure) AST_Node.warn("Dropping __PURE__ call [{start}]", self); + var args = trim(self.args, compressor, first_in_statement, array_spread); + return args && make_sequence(self, args.map(convert_spread)); + } + var exp = self.expression; + if (self.is_call_pure(compressor)) { + var exprs = self.args.slice(); + exprs.unshift(exp.expression); + exprs = trim(exprs, compressor, first_in_statement, array_spread); + return exprs && make_sequence(self, exprs.map(convert_spread)); + } + if (compressor.option("yields") && is_generator(exp) && fn_name_unused(exp, compressor)) { + var call = self.clone(); + call.expression = make_node(AST_Function, exp); + call.expression.body = []; + return call; + } + var dropped = drop_returns(compressor, exp); + if (dropped) { + // always shallow clone to ensure stripping of negated IIFEs + self = self.clone(); + self.expression = dropped; + // avoid extraneous traversal + if (exp._squeezed) self.expression._squeezed = true; + } + if (self instanceof AST_New) { + var fn = exp; + if (fn instanceof AST_SymbolRef) fn = fn.fixed_value(); + if (fn instanceof AST_Lambda) { + if (assign_this_only(fn, compressor)) { + var exprs = self.args.slice(); + exprs.unshift(exp); + exprs = trim(exprs, compressor, first_in_statement, array_spread); + return exprs && make_sequence(self, exprs.map(convert_spread)); + } + if (!fn.contains_this()) { + self = make_node(AST_Call, self); + self.expression = self.expression.clone(); + self.args = self.args.slice(); + } + } + } + self.call_only = true; + return self; + }); + def(AST_ClassExpression, function(compressor, first_in_statement) { + var self = this; + var exprs = [], values = [], init = 0; + var props = self.properties; + for (var i = 0; i < props.length; i++) { + var prop = props[i]; + if (prop.key instanceof AST_Node) exprs.push(prop.key); + if (!is_static_field_or_init(prop)) continue; + var value = prop.value; + if (!value.has_side_effects(compressor)) continue; + if (value.contains_this()) return self; + if (prop instanceof AST_ClassInit) { + init++; + values.push(prop); + } else { + values.push(value); + } + } + var base = self.extends; + if (base) { + if (base instanceof AST_SymbolRef) base = base.fixed_value(); + base = !safe_for_extends(base); + if (!base) exprs.unshift(self.extends); + } + exprs = trim(exprs, compressor, first_in_statement); + if (exprs) first_in_statement = false; + values = trim(values, compressor, first_in_statement); + if (!exprs) { + if (!base && !values && !self.name) return null; + exprs = []; + } + if (base || self.name || !compressor.has_directive("use strict")) { + var node = to_class_expr(self); + if (!base) node.extends = null; + node.properties = []; + if (values) { + if (values.length == init) { + if (exprs.length) values.unshift(make_node(AST_ClassField, self, { + key: make_sequence(self, exprs), + value: null, + })); + node.properties = values; + } else node.properties.push(make_node(AST_ClassField, self, { + static: true, + key: exprs.length ? make_sequence(self, exprs) : "c", + value: make_value(), + })); + } else if (exprs.length) node.properties.push(make_node(AST_ClassMethod, self, { + key: make_sequence(self, exprs), + value: make_node(AST_Function, self, { + argnames: [], + body: [], + }).init_vars(node), + })); + return node; + } + if (values) exprs.push(make_node(AST_Call, self, { + expression: make_node(AST_Arrow, self, { + argnames: [], + body: [], + value: make_value(), + }).init_vars(self.parent_scope, self), + args: [], + })); + return make_sequence(self, exprs); + + function make_value() { + return make_sequence(self, values.map(function(node) { + if (!(node instanceof AST_ClassInit)) return node; + var fn = make_node(AST_Arrow, node.value); + fn.argnames = []; + return make_node(AST_Call, node, { + expression: fn, + args: [], + }); + })); + } + }); + def(AST_Conditional, function(compressor) { + var consequent = this.consequent.drop_side_effect_free(compressor); + var alternative = this.alternative.drop_side_effect_free(compressor); + if (consequent === this.consequent && alternative === this.alternative) return this; + var exprs; + if (compressor.option("ie")) { + exprs = []; + if (consequent instanceof AST_Function) { + exprs.push(consequent); + consequent = null; + } + if (alternative instanceof AST_Function) { + exprs.push(alternative); + alternative = null; + } + } + var node; + if (!consequent) { + node = alternative ? make_node(AST_Binary, this, { + operator: "||", + left: this.condition, + right: alternative, + }) : this.condition.drop_side_effect_free(compressor); + } else if (!alternative) { + node = make_node(AST_Binary, this, { + operator: "&&", + left: this.condition, + right: consequent, + }); + } else { + node = this.clone(); + node.consequent = consequent; + node.alternative = alternative; + } + if (!exprs) return node; + if (node) exprs.push(node); + return exprs.length == 0 ? null : make_sequence(this, exprs); + }); + def(AST_Constant, return_null); + def(AST_Dot, function(compressor, first_in_statement) { + var expr = this.expression; + if (expr.may_throw_on_access(compressor)) return this; + return expr.drop_side_effect_free(compressor, first_in_statement); + }); + def(AST_Function, function(compressor) { + return fn_name_unused(this, compressor) ? null : this; + }); + def(AST_LambdaExpression, return_null); + def(AST_Object, function(compressor, first_in_statement) { + var exprs = []; + this.properties.forEach(function(prop) { + if (prop instanceof AST_Spread) { + exprs.push(prop); + } else { + if (prop.key instanceof AST_Node) exprs.push(prop.key); + exprs.push(prop.value); + } + }); + var values = trim(exprs, compressor, first_in_statement, function(node, compressor, first_in_statement) { + var exp = node.expression; + return exp.safe_to_spread() ? exp.drop_side_effect_free(compressor, first_in_statement) : node; + }); + if (!values) return null; + if (values === exprs && !all(values, function(node) { + return !(node instanceof AST_Spread); + })) return this; + return make_sequence(this, values.map(function(node) { + return node instanceof AST_Spread ? make_node(AST_Object, node, { properties: [ node ] }) : node; + })); + }); + def(AST_ObjectIdentity, return_null); + def(AST_Sequence, function(compressor, first_in_statement) { + var expressions = trim(this.expressions, compressor, first_in_statement); + if (!expressions) return null; + var end = expressions.length - 1; + var last = expressions[end]; + if (compressor.option("awaits") && end > 0 && last instanceof AST_Await && last.expression.is_constant()) { + expressions = expressions.slice(0, -1); + end--; + var expr = expressions[end]; + last.expression = needs_enqueuing(compressor, expr) ? expr : expr.negate(compressor); + expressions[end] = last; + } + var assign, cond, lhs; + if (compressor.option("conditionals") + && end > 0 + && (assign = expressions[end - 1]) instanceof AST_Assign + && assign.operator == "=" + && (lhs = assign.left) instanceof AST_SymbolRef + && (cond = to_conditional_assignment(compressor, lhs.definition(), assign.right, last))) { + assign = assign.clone(); + assign.right = cond; + expressions = expressions.slice(0, -2); + expressions.push(assign.drop_side_effect_free(compressor, first_in_statement)); + } + return expressions === this.expressions ? this : make_sequence(this, expressions); + }); + def(AST_Sub, function(compressor, first_in_statement) { + var self = this; + var expr = self.expression; + if (expr.may_throw_on_access(compressor)) return self; + var prop = self.property; + if (self.optional) { + prop = prop.drop_side_effect_free(compressor); + if (!prop) return expr.drop_side_effect_free(compressor, first_in_statement); + self = self.clone(); + self.property = prop; + return self; + } + expr = expr.drop_side_effect_free(compressor, first_in_statement); + if (!expr) return prop.drop_side_effect_free(compressor, first_in_statement); + prop = prop.drop_side_effect_free(compressor); + if (!prop) return expr; + return make_sequence(self, [ expr, prop ]); + }); + def(AST_SymbolRef, function(compressor) { + return this.is_declared(compressor) && can_drop_symbol(this, compressor) ? null : this; + }); + def(AST_Template, function(compressor, first_in_statement) { + var self = this; + if (self.is_expr_pure(compressor)) { + var expressions = self.expressions; + if (expressions.length == 0) return null; + return make_sequence(self, expressions).drop_side_effect_free(compressor, first_in_statement); + } + var tag = self.tag; + var dropped = drop_returns(compressor, tag); + if (dropped) { + // always shallow clone to signal internal changes + self = self.clone(); + self.tag = dropped; + // avoid extraneous traversal + if (tag._squeezed) self.tag._squeezed = true; + } + return self; + }); + def(AST_Unary, function(compressor, first_in_statement) { + var exp = this.expression; + if (unary_side_effects[this.operator]) { + this.write_only = !exp.has_side_effects(compressor); + return this; + } + if (this.operator == "typeof" && exp instanceof AST_SymbolRef && can_drop_symbol(exp, compressor)) { + return null; + } + var node = exp.drop_side_effect_free(compressor, first_in_statement); + if (first_in_statement && node && is_iife_call(node)) { + if (node === exp && this.operator == "!") return this; + return node.negate(compressor, first_in_statement); + } + return node; + }); + })(function(node, func) { + node.DEFMETHOD("drop_side_effect_free", func); + }); + + OPT(AST_SimpleStatement, function(self, compressor) { + if (compressor.option("side_effects")) { + var body = self.body; + var node = body.drop_side_effect_free(compressor, true); + if (!node) { + AST_Node.warn("Dropping side-effect-free statement [{start}]", self); + return make_node(AST_EmptyStatement, self); + } + if (node !== body) { + return make_node(AST_SimpleStatement, self, { body: node }); + } + } + return self; + }); + + OPT(AST_While, function(self, compressor) { + return compressor.option("loops") ? make_node(AST_For, self).optimize(compressor) : self; + }); + + function has_loop_control(loop, parent, type) { + if (!type) type = AST_LoopControl; + var found = false; + var tw = new TreeWalker(function(node) { + if (found || node instanceof AST_Scope) return true; + if (node instanceof type && tw.loopcontrol_target(node) === loop) { + return found = true; + } + }); + if (parent instanceof AST_LabeledStatement) tw.push(parent); + tw.push(loop); + loop.body.walk(tw); + return found; + } + + OPT(AST_Do, function(self, compressor) { + if (!compressor.option("loops")) return self; + var cond = fuzzy_eval(compressor, self.condition); + if (!(cond instanceof AST_Node)) { + if (cond && !has_loop_control(self, compressor.parent(), AST_Continue)) return make_node(AST_For, self, { + body: make_node(AST_BlockStatement, self.body, { + body: [ + self.body, + make_node(AST_SimpleStatement, self.condition, { body: self.condition }), + ], + }), + }).optimize(compressor); + if (!has_loop_control(self, compressor.parent())) return make_node(AST_BlockStatement, self.body, { + body: [ + self.body, + make_node(AST_SimpleStatement, self.condition, { body: self.condition }), + ], + }).optimize(compressor); + } + if (self.body instanceof AST_BlockStatement && !has_loop_control(self, compressor.parent(), AST_Continue)) { + var body = self.body.body; + for (var i = body.length; --i >= 0;) { + var stat = body[i]; + if (stat instanceof AST_If + && !stat.alternative + && stat.body instanceof AST_Break + && compressor.loopcontrol_target(stat.body) === self) { + if (has_block_scope_refs(stat.condition)) break; + self.condition = make_node(AST_Binary, self, { + operator: "&&", + left: stat.condition.negate(compressor), + right: self.condition, + }); + body.splice(i, 1); + } else if (stat instanceof AST_SimpleStatement) { + if (has_block_scope_refs(stat.body)) break; + self.condition = make_sequence(self, [ + stat.body, + self.condition, + ]); + body.splice(i, 1); + } else if (!is_declaration(stat, true)) { + break; + } + } + self.body = trim_block(self.body, compressor.parent()); + } + if (self.body instanceof AST_EmptyStatement) return make_node(AST_For, self).optimize(compressor); + if (self.body instanceof AST_SimpleStatement) return make_node(AST_For, self, { + condition: make_sequence(self.condition, [ + self.body.body, + self.condition, + ]), + body: make_node(AST_EmptyStatement, self), + }).optimize(compressor); + return self; + + function has_block_scope_refs(node) { + var found = false; + node.walk(new TreeWalker(function(node) { + if (found) return true; + if (node instanceof AST_SymbolRef) { + if (!member(node.definition(), self.enclosed)) found = true; + return true; + } + })); + return found; + } + }); + + function if_break_in_loop(self, compressor) { + var first = first_statement(self.body); + if (compressor.option("dead_code") + && (first instanceof AST_Break + || first instanceof AST_Continue && external_target(first) + || first instanceof AST_Exit)) { + var body = []; + if (is_statement(self.init)) { + body.push(self.init); + } else if (self.init) { + body.push(make_node(AST_SimpleStatement, self.init, { body: self.init })); + } + var retain = external_target(first) || first instanceof AST_Exit; + if (self.condition && retain) { + body.push(make_node(AST_If, self, { + condition: self.condition, + body: first, + alternative: null, + })); + } else if (self.condition) { + body.push(make_node(AST_SimpleStatement, self.condition, { body: self.condition })); + } else if (retain) { + body.push(first); + } + extract_declarations_from_unreachable_code(compressor, self.body, body); + return make_node(AST_BlockStatement, self, { body: body }); + } + if (first instanceof AST_If) { + var ab = first_statement(first.body); + if (ab instanceof AST_Break && !external_target(ab)) { + if (self.condition) { + self.condition = make_node(AST_Binary, self.condition, { + left: self.condition, + operator: "&&", + right: first.condition.negate(compressor), + }); + } else { + self.condition = first.condition.negate(compressor); + } + var body = as_statement_array(first.alternative); + extract_declarations_from_unreachable_code(compressor, first.body, body); + return drop_it(body); + } + ab = first_statement(first.alternative); + if (ab instanceof AST_Break && !external_target(ab)) { + if (self.condition) { + self.condition = make_node(AST_Binary, self.condition, { + left: self.condition, + operator: "&&", + right: first.condition, + }); + } else { + self.condition = first.condition; + } + var body = as_statement_array(first.body); + extract_declarations_from_unreachable_code(compressor, first.alternative, body); + return drop_it(body); + } + } + return self; + + function first_statement(body) { + return body instanceof AST_BlockStatement ? body.body[0] : body; + } + + function external_target(node) { + return compressor.loopcontrol_target(node) !== compressor.self(); + } + + function drop_it(rest) { + if (self.body instanceof AST_BlockStatement) { + self.body = self.body.clone(); + self.body.body = rest.concat(self.body.body.slice(1)); + self.body = self.body.transform(compressor); + } else { + self.body = make_node(AST_BlockStatement, self.body, { body: rest }).transform(compressor); + } + return if_break_in_loop(self, compressor); + } + } + + OPT(AST_For, function(self, compressor) { + if (!compressor.option("loops")) return self; + if (compressor.option("side_effects")) { + if (self.init) self.init = self.init.drop_side_effect_free(compressor); + if (self.step) self.step = self.step.drop_side_effect_free(compressor); + } + if (self.condition) { + var cond = fuzzy_eval(compressor, self.condition); + if (!cond) { + if (compressor.option("dead_code")) { + var body = []; + if (is_statement(self.init)) { + body.push(self.init); + } else if (self.init) { + body.push(make_node(AST_SimpleStatement, self.init, { body: self.init })); + } + body.push(make_node(AST_SimpleStatement, self.condition, { body: self.condition })); + extract_declarations_from_unreachable_code(compressor, self.body, body); + return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor); + } + } else if (!(cond instanceof AST_Node)) { + self.body = make_node(AST_BlockStatement, self.body, { + body: [ + make_node(AST_SimpleStatement, self.condition, { body: self.condition }), + self.body, + ], + }); + self.condition = null; + } + } + return if_break_in_loop(self, compressor); + }); + + OPT(AST_ForEnumeration, function(self, compressor) { + if (compressor.option("varify") && is_lexical_definition(self.init)) { + var name = self.init.definitions[0].name; + if ((compressor.option("module") || name instanceof AST_Destructured || name instanceof AST_SymbolLet) + && !name.match_symbol(function(node) { + if (node instanceof AST_SymbolDeclaration) { + var def = node.definition(); + return !same_scope(def) || may_overlap(compressor, def); + } + }, true)) { + self.init = to_var(self.init, self.resolve()); + } else if (self.init.can_letify(compressor, true)) { + self.init = to_let(self.init, self); + } + } + return self; + }); + + function mark_locally_defined(condition, consequent, alternative) { + if (condition instanceof AST_Sequence) condition = condition.tail_node(); + if (!(condition instanceof AST_Binary)) return; + if (!(condition.left instanceof AST_String)) { + switch (condition.operator) { + case "&&": + mark_locally_defined(condition.left, consequent); + mark_locally_defined(condition.right, consequent); + break; + case "||": + mark_locally_defined(negate(condition.left), alternative); + mark_locally_defined(negate(condition.right), alternative); + break; + } + return; + } + if (!(condition.right instanceof AST_UnaryPrefix)) return; + if (condition.right.operator != "typeof") return; + var sym = condition.right.expression; + if (!is_undeclared_ref(sym)) return; + var body; + var undef = condition.left.value == "undefined"; + switch (condition.operator) { + case "==": + body = undef ? alternative : consequent; + break; + case "!=": + body = undef ? consequent : alternative; + break; + default: + return; + } + if (!body) return; + var abort = false; + var def = sym.definition(); + var fn; + var refs = []; + var scanned = []; + var tw = new TreeWalker(function(node, descend) { + if (abort) return true; + if (node instanceof AST_Assign) { + var ref = node.left; + if (!(ref instanceof AST_SymbolRef && ref.definition() === def)) return; + node.right.walk(tw); + switch (node.operator) { + case "=": + case "&&=": + abort = true; + } + return true; + } + if (node instanceof AST_Call) { + descend(); + fn = node.expression.tail_node(); + var save; + if (fn instanceof AST_SymbolRef) { + fn = fn.fixed_value(); + save = refs.length; + } + if (!(fn instanceof AST_Lambda)) { + abort = true; + } else if (push_uniq(scanned, fn)) { + fn.walk(tw); + } + if (save >= 0) refs.length = save; + return true; + } + if (node instanceof AST_DWLoop) { + var save = refs.length; + descend(); + if (abort) refs.length = save; + return true; + } + if (node instanceof AST_For) { + if (node.init) node.init.walk(tw); + var save = refs.length; + if (node.condition) node.condition.walk(tw); + node.body.walk(tw); + if (node.step) node.step.walk(tw); + if (abort) refs.length = save; + return true; + } + if (node instanceof AST_ForEnumeration) { + node.object.walk(tw); + var save = refs.length; + node.init.walk(tw); + node.body.walk(tw); + if (abort) refs.length = save; + return true; + } + if (node instanceof AST_Scope) { + if (node === fn) return; + return true; + } + if (node instanceof AST_SymbolRef) { + if (node.definition() === def) refs.push(node); + return true; + } + }); + body.walk(tw); + refs.forEach(function(ref) { + ref.defined = true; + }); + + function negate(node) { + if (!(node instanceof AST_Binary)) return; + switch (node.operator) { + case "==": + node = node.clone(); + node.operator = "!="; + return node; + case "!=": + node = node.clone(); + node.operator = "=="; + return node; + } + } + } + + function fuzzy_eval(compressor, node, nullish) { + if (node.truthy) return true; + if (is_undefined(node)) return undefined; + if (node.falsy && !nullish) return false; + if (node.is_truthy()) return true; + return node.evaluate(compressor, true); + } + + function mark_duplicate_condition(compressor, node) { + var child; + var level = 0; + var negated = false; + var parent = compressor.self(); + if (!is_statement(parent)) while (true) { + child = parent; + parent = compressor.parent(level++); + if (parent instanceof AST_Binary) { + switch (child) { + case parent.left: + if (lazy_op[parent.operator]) continue; + break; + case parent.right: + if (match(parent.left)) switch (parent.operator) { + case "&&": + node[negated ? "falsy" : "truthy"] = true; + break; + case "||": + case "??": + node[negated ? "truthy" : "falsy"] = true; + break; + } + break; + } + } else if (parent instanceof AST_Conditional) { + var cond = parent.condition; + if (cond === child) continue; + if (match(cond)) switch (child) { + case parent.consequent: + node[negated ? "falsy" : "truthy"] = true; + break; + case parent.alternative: + node[negated ? "truthy" : "falsy"] = true; + break; + } + } else if (parent instanceof AST_Exit) { + break; + } else if (parent instanceof AST_If) { + break; + } else if (parent instanceof AST_Sequence) { + if (parent.expressions[0] === child) continue; + } else if (parent instanceof AST_SimpleStatement) { + break; + } + return; + } + while (true) { + child = parent; + parent = compressor.parent(level++); + if (parent instanceof AST_BlockStatement) { + if (parent.body[0] === child) continue; + } else if (parent instanceof AST_If) { + if (match(parent.condition)) switch (child) { + case parent.body: + node[negated ? "falsy" : "truthy"] = true; + break; + case parent.alternative: + node[negated ? "truthy" : "falsy"] = true; + break; + } + } + return; + } + + function match(cond) { + if (node.equals(cond)) return true; + if (!(cond instanceof AST_UnaryPrefix)) return false; + if (cond.operator != "!") return false; + if (!node.equals(cond.expression)) return false; + negated = true; + return true; + } + } + + OPT(AST_If, function(self, compressor) { + if (is_empty(self.alternative)) self.alternative = null; + + if (!compressor.option("conditionals")) return self; + if (compressor.option("booleans") && !self.condition.has_side_effects(compressor)) { + mark_duplicate_condition(compressor, self.condition); + } + // if condition can be statically determined, warn and drop + // one of the blocks. note, statically determined implies + // “has no side effects”; also it doesn't work for cases like + // `x && true`, though it probably should. + if (compressor.option("dead_code")) { + var cond = fuzzy_eval(compressor, self.condition); + if (!cond) { + AST_Node.warn("Condition always false [{start}]", self.condition); + var body = [ + make_node(AST_SimpleStatement, self.condition, { body: self.condition }).transform(compressor), + ]; + extract_declarations_from_unreachable_code(compressor, self.body, body); + if (self.alternative) body.push(self.alternative); + return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor); + } else if (!(cond instanceof AST_Node)) { + AST_Node.warn("Condition always true [{start}]", self.condition); + var body = [ + make_node(AST_SimpleStatement, self.condition, { body: self.condition }).transform(compressor), + self.body, + ]; + if (self.alternative) extract_declarations_from_unreachable_code(compressor, self.alternative, body); + return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor); + } + } + var negated = self.condition.negate(compressor); + var self_condition_length = self.condition.print_to_string().length; + var negated_length = negated.print_to_string().length; + var negated_is_best = negated_length < self_condition_length; + if (self.alternative && negated_is_best) { + negated_is_best = false; // because we already do the switch here. + // no need to swap values of self_condition_length and negated_length + // here because they are only used in an equality comparison later on. + self.condition = negated; + var tmp = self.body; + self.body = self.alternative; + self.alternative = is_empty(tmp) ? null : tmp; + } + var body_defuns = []; + var body_var_defs = []; + var body_refs = []; + var body_exprs = sequencesize(self.body, body_defuns, body_var_defs, body_refs); + var alt_defuns = []; + var alt_var_defs = []; + var alt_refs = []; + var alt_exprs = sequencesize(self.alternative, alt_defuns, alt_var_defs, alt_refs); + if (body_exprs instanceof AST_BlockStatement || alt_exprs instanceof AST_BlockStatement) { + var body = [], var_defs = []; + if (body_exprs) { + [].push.apply(body, body_defuns); + [].push.apply(var_defs, body_var_defs); + if (body_exprs instanceof AST_BlockStatement) { + self.body = body_exprs; + } else if (body_exprs.length == 0) { + self.body = make_node(AST_EmptyStatement, self.body); + } else { + self.body = make_node(AST_SimpleStatement, self.body, { + body: make_sequence(self.body, body_exprs), + }); + } + body_refs.forEach(process_to_assign); + } + if (alt_exprs) { + [].push.apply(body, alt_defuns); + [].push.apply(var_defs, alt_var_defs); + if (alt_exprs instanceof AST_BlockStatement) { + self.alternative = alt_exprs; + } else if (alt_exprs.length == 0) { + self.alternative = null; + } else { + self.alternative = make_node(AST_SimpleStatement, self.alternative, { + body: make_sequence(self.alternative, alt_exprs), + }); + } + alt_refs.forEach(process_to_assign); + } + if (var_defs.length > 0) body.push(make_node(AST_Var, self, { definitions: var_defs })); + if (body.length > 0) { + body.push(self.transform(compressor)); + return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor); + } + } else if (body_exprs && alt_exprs) { + var body = body_defuns.concat(alt_defuns); + if (body_var_defs.length > 0 || alt_var_defs.length > 0) body.push(make_node(AST_Var, self, { + definitions: body_var_defs.concat(alt_var_defs), + })); + if (body_exprs.length == 0) { + body.push(make_node(AST_SimpleStatement, self.condition, { + body: alt_exprs.length > 0 ? make_node(AST_Binary, self, { + operator: "||", + left: self.condition, + right: make_sequence(self.alternative, alt_exprs), + }).transform(compressor) : self.condition.clone(), + }).optimize(compressor)); + } else if (alt_exprs.length == 0) { + if (self_condition_length === negated_length && !negated_is_best + && self.condition instanceof AST_Binary && self.condition.operator == "||") { + // although the code length of self.condition and negated are the same, + // negated does not require additional surrounding parentheses. + // see https://github.com/mishoo/UglifyJS/issues/979 + negated_is_best = true; + } + body.push(make_node(AST_SimpleStatement, self, { + body: make_node(AST_Binary, self, { + operator: negated_is_best ? "||" : "&&", + left: negated_is_best ? negated : self.condition, + right: make_sequence(self.body, body_exprs), + }).transform(compressor), + }).optimize(compressor)); + } else { + body.push(make_node(AST_SimpleStatement, self, { + body: make_node(AST_Conditional, self, { + condition: self.condition, + consequent: make_sequence(self.body, body_exprs), + alternative: make_sequence(self.alternative, alt_exprs), + }), + }).optimize(compressor)); + } + body_refs.forEach(process_to_assign); + alt_refs.forEach(process_to_assign); + return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor); + } + if (is_empty(self.body)) self = make_node(AST_If, self, { + condition: negated, + body: self.alternative, + alternative: null, + }); + if (self.alternative instanceof AST_Exit && self.body.TYPE == self.alternative.TYPE) { + var cons_value = self.body.value; + var alt_value = self.alternative.value; + if (!cons_value && !alt_value) return make_node(AST_BlockStatement, self, { + body: [ + make_node(AST_SimpleStatement, self, { body: self.condition }), + self.body, + ], + }).optimize(compressor); + if (cons_value && alt_value || !keep_return_void()) { + var exit = make_node(self.body.CTOR, self, { + value: make_node(AST_Conditional, self, { + condition: self.condition, + consequent: cons_value || make_node(AST_Undefined, self.body).transform(compressor), + alternative: alt_value || make_node(AST_Undefined, self.alternative).transform(compressor), + }), + }); + if (exit instanceof AST_Return) exit.in_bool = self.body.in_bool || self.alternative.in_bool; + return exit; + } + } + if (self.body instanceof AST_If && !self.body.alternative && !self.alternative) { + self = make_node(AST_If, self, { + condition: make_node(AST_Binary, self.condition, { + operator: "&&", + left: self.condition, + right: self.body.condition, + }), + body: self.body.body, + alternative: null, + }); + } + if (aborts(self.body) && self.alternative) { + var alt = self.alternative; + self.alternative = null; + return make_node(AST_BlockStatement, self, { body: [ self, alt ] }).optimize(compressor); + } + if (aborts(self.alternative)) { + var body = self.body; + self.body = self.alternative; + self.condition = negated_is_best ? negated : self.condition.negate(compressor); + self.alternative = null; + return make_node(AST_BlockStatement, self, { body: [ self, body ] }).optimize(compressor); + } + if (self.alternative) { + var body_stats = as_array(self.body); + var body_index = last_index(body_stats); + var alt_stats = as_array(self.alternative); + var alt_index = last_index(alt_stats); + for (var stats = []; body_index >= 0 && alt_index >= 0;) { + var stat = body_stats[body_index]; + var alt_stat = alt_stats[alt_index]; + if (stat.equals(alt_stat)) { + body_stats.splice(body_index--, 1); + alt_stats.splice(alt_index--, 1); + stats.unshift(merge_expression(stat, alt_stat)); + } else { + if (!(stat instanceof AST_SimpleStatement)) break; + if (!(alt_stat instanceof AST_SimpleStatement)) break; + var expr1 = stat.body.tail_node(); + var expr2 = alt_stat.body.tail_node(); + if (!expr1.equals(expr2)) break; + body_index = pop_expr(body_stats, stat.body, body_index); + alt_index = pop_expr(alt_stats, alt_stat.body, alt_index); + stats.unshift(make_node(AST_SimpleStatement, expr1, { body: merge_expression(expr1, expr2) })); + } + } + if (stats.length > 0) { + self.body = body_stats.length > 0 ? make_node(AST_BlockStatement, self, { + body: body_stats, + }) : make_node(AST_EmptyStatement, self); + self.alternative = alt_stats.length > 0 ? make_node(AST_BlockStatement, self, { + body: alt_stats, + }) : null; + stats.unshift(self); + return make_node(AST_BlockStatement, self, { body: stats }).optimize(compressor); + } + } + if (compressor.option("typeofs")) mark_locally_defined(self.condition, self.body, self.alternative); + return self; + + function as_array(node) { + return node instanceof AST_BlockStatement ? node.body : [ node ]; + } + + function keep_return_void() { + var has_finally = false, level = 0, node = compressor.self(); + do { + if (node instanceof AST_Catch) { + if (compressor.parent(level).bfinally) has_finally = true; + level++; + } else if (node instanceof AST_Finally) { + level++; + } else if (node instanceof AST_Scope) { + return has_finally && in_async_generator(node); + } else if (node instanceof AST_Try) { + if (node.bfinally) has_finally = true; + } + } while (node = compressor.parent(level++)); + } + + function last_index(stats) { + for (var index = stats.length; --index >= 0;) { + if (!is_declaration(stats[index], true)) break; + } + return index; + } + + function pop_expr(stats, body, index) { + if (body instanceof AST_Sequence) { + stats[index] = make_node(AST_SimpleStatement, body, { + body: make_sequence(body, body.expressions.slice(0, -1)), + }); + } else { + stats.splice(index--, 1); + } + return index; + } + + function sequencesize(stat, defuns, var_defs, refs) { + if (stat == null) return []; + if (stat instanceof AST_BlockStatement) { + var exprs = []; + for (var i = 0; i < stat.body.length; i++) { + var line = stat.body[i]; + if (line instanceof AST_EmptyStatement) continue; + if (line instanceof AST_Exit) { + if (i == 0) return; + if (exprs.length > 0) { + line = line.clone(); + exprs.push(line.value || make_node(AST_Undefined, line).transform(compressor)); + line.value = make_sequence(stat, exprs); + } + var block = stat.clone(); + block.body = block.body.slice(i + 1); + block.body.unshift(line); + return block; + } + if (line instanceof AST_LambdaDefinition) { + defuns.push(line); + } else if (line instanceof AST_SimpleStatement) { + if (!compressor.option("sequences") && exprs.length > 0) return; + exprs.push(line.body); + } else if (line instanceof AST_Var) { + if (!compressor.option("sequences") && exprs.length > 0) return; + line.remove_initializers(compressor, var_defs); + line.definitions.forEach(process_var_def); + } else { + return; + } + } + return exprs; + } + if (stat instanceof AST_LambdaDefinition) { + defuns.push(stat); + return []; + } + if (stat instanceof AST_EmptyStatement) return []; + if (stat instanceof AST_SimpleStatement) return [ stat.body ]; + if (stat instanceof AST_Var) { + var exprs = []; + stat.remove_initializers(compressor, var_defs); + stat.definitions.forEach(process_var_def); + return exprs; + } + + function process_var_def(var_def) { + if (!var_def.value) return; + exprs.push(make_node(AST_Assign, var_def, { + operator: "=", + left: var_def.name.convert_symbol(AST_SymbolRef, function(ref) { + refs.push(ref); + }), + right: var_def.value, + })); + } + } + }); + + OPT(AST_Switch, function(self, compressor) { + if (!compressor.option("switches")) return self; + if (!compressor.option("dead_code")) return self; + var body = []; + var branch; + var decl = []; + var default_branch; + var exact_match; + var side_effects = []; + for (var i = 0, len = self.body.length; i < len; i++) { + branch = self.body[i]; + if (branch instanceof AST_Default) { + var prev = body[body.length - 1]; + if (default_branch || is_break(branch.body[0], compressor) && (!prev || aborts(prev))) { + eliminate_branch(branch, prev); + continue; + } else { + default_branch = branch; + } + } else { + var exp = branch.expression; + var equals = make_node(AST_Binary, self, { + operator: "===", + left: self.expression, + right: exp, + }).evaluate(compressor, true); + if (!equals) { + if (exp.has_side_effects(compressor)) side_effects.push(exp); + eliminate_branch(branch, body[body.length - 1]); + continue; + } + if (!(equals instanceof AST_Node)) { + if (default_branch) { + var default_index = body.indexOf(default_branch); + body.splice(default_index, 1); + eliminate_branch(default_branch, body[default_index - 1]); + default_branch = null; + } + if (exp.has_side_effects(compressor)) { + exact_match = branch; + } else { + default_branch = branch = make_node(AST_Default, branch); + } + while (++i < len) eliminate_branch(self.body[i], branch); + } + } + if (i + 1 >= len || aborts(branch)) { + var prev = body[body.length - 1]; + var statements = branch.body; + if (aborts(prev)) switch (prev.body.length - statements.length) { + case 1: + var stat = prev.body[prev.body.length - 1]; + if (!is_break(stat, compressor)) break; + statements = statements.concat(stat); + case 0: + var prev_block = make_node(AST_BlockStatement, prev); + var next_block = make_node(AST_BlockStatement, branch, { body: statements }); + if (prev_block.equals(next_block)) prev.body = []; + } + } + if (side_effects.length) { + if (branch instanceof AST_Default) { + body.push(make_node(AST_Case, self, { expression: make_sequence(self, side_effects), body: [] })); + } else { + side_effects.push(branch.expression); + branch.expression = make_sequence(self, side_effects); + } + side_effects = []; + } + body.push(branch); + } + if (side_effects.length && !exact_match) { + body.push(make_node(AST_Case, self, { expression: make_sequence(self, side_effects), body: [] })); + } + while (branch = body[body.length - 1]) { + var stat = branch.body[branch.body.length - 1]; + if (is_break(stat, compressor)) branch.body.pop(); + if (branch === default_branch) { + if (!has_declarations_only(branch)) break; + } else if (branch.expression.has_side_effects(compressor)) { + break; + } else if (default_branch) { + if (!has_declarations_only(default_branch)) break; + if (body[body.length - 2] !== default_branch) break; + default_branch.body = default_branch.body.concat(branch.body); + branch.body = []; + } else if (!has_declarations_only(branch)) break; + eliminate_branch(branch); + if (body.pop() === default_branch) default_branch = null; + } + if (!branch) { + decl.push(make_node(AST_SimpleStatement, self.expression, { body: self.expression })); + if (side_effects.length) decl.push(make_node(AST_SimpleStatement, self, { + body: make_sequence(self, side_effects), + })); + return make_node(AST_BlockStatement, self, { body: decl }).optimize(compressor); + } + if (branch === default_branch) while (branch = body[body.length - 2]) { + if (branch instanceof AST_Default) break; + if (!has_declarations_only(branch)) break; + var exp = branch.expression; + if (exp.has_side_effects(compressor)) { + var prev = body[body.length - 3]; + if (prev && !aborts(prev)) break; + default_branch.body.unshift(make_node(AST_SimpleStatement, self, { body: exp })); + } + eliminate_branch(branch); + body.splice(-2, 1); + } + body[0].body = decl.concat(body[0].body); + self.body = body; + if (compressor.option("conditionals")) switch (body.length) { + case 1: + if (!no_break(body[0])) break; + var exp = body[0].expression; + var statements = body[0].body.slice(); + if (body[0] !== default_branch && body[0] !== exact_match) return make_node(AST_If, self, { + condition: make_node(AST_Binary, self, { + operator: "===", + left: self.expression, + right: exp, + }), + body: make_node(AST_BlockStatement, self, { body: statements }), + alternative: null, + }).optimize(compressor); + if (exp) statements.unshift(make_node(AST_SimpleStatement, exp, { body: exp })); + statements.unshift(make_node(AST_SimpleStatement, self.expression, { body: self.expression })); + return make_node(AST_BlockStatement, self, { body: statements }).optimize(compressor); + case 2: + if (!member(default_branch, body) || !no_break(body[1])) break; + var statements = body[0].body.slice(); + var exclusive = statements.length && is_break(statements[statements.length - 1], compressor); + if (exclusive) statements.pop(); + if (!all(statements, no_break)) break; + var alternative = body[1].body.length && make_node(AST_BlockStatement, body[1]); + var node = make_node(AST_If, self, { + condition: make_node(AST_Binary, self, body[0] === default_branch ? { + operator: "!==", + left: self.expression, + right: body[1].expression, + } : { + operator: "===", + left: self.expression, + right: body[0].expression, + }), + body: make_node(AST_BlockStatement, body[0], { body: statements }), + alternative: exclusive && alternative || null, + }); + if (!exclusive && alternative) node = make_node(AST_BlockStatement, self, { body: [ node, alternative ] }); + return node.optimize(compressor); + } + return self; + + function is_break(node, tw) { + return node instanceof AST_Break && tw.loopcontrol_target(node) === self; + } + + function no_break(node) { + var found = false; + var tw = new TreeWalker(function(node) { + if (found + || node instanceof AST_Lambda + || node instanceof AST_SimpleStatement) return true; + if (is_break(node, tw)) found = true; + }); + tw.push(self); + node.walk(tw); + return !found; + } + + function eliminate_branch(branch, prev) { + if (prev && !aborts(prev)) { + prev.body = prev.body.concat(branch.body); + } else { + extract_declarations_from_unreachable_code(compressor, branch, decl); + } + } + }); + + OPT(AST_Try, function(self, compressor) { + self.body = tighten_body(self.body, compressor); + if (compressor.option("dead_code")) { + if (has_declarations_only(self) + && !(self.bcatch && self.bcatch.argname && self.bcatch.argname.match_symbol(function(node) { + return node instanceof AST_SymbolCatch && !can_drop_symbol(node); + }, true))) { + var body = []; + if (self.bcatch) { + extract_declarations_from_unreachable_code(compressor, self.bcatch, body); + body.forEach(function(stat) { + if (!(stat instanceof AST_Var)) return; + stat.definitions.forEach(function(var_def) { + var def = var_def.name.definition().redefined(); + if (!def) return; + var_def.name = var_def.name.clone(); + var_def.name.thedef = def; + }); + }); + } + body.unshift(make_node(AST_BlockStatement, self).optimize(compressor)); + if (self.bfinally) { + body.push(make_node(AST_BlockStatement, self.bfinally).optimize(compressor)); + } + return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor); + } + if (self.bfinally && has_declarations_only(self.bfinally)) { + var body = make_node(AST_BlockStatement, self.bfinally).optimize(compressor); + body = self.body.concat(body); + if (!self.bcatch) return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor); + self.body = body; + self.bfinally = null; + } + } + return self; + }); + + function remove_initializers(make_value) { + return function(compressor, defns) { + var dropped = false; + this.definitions.forEach(function(defn) { + if (defn.value) dropped = true; + defn.name.match_symbol(function(node) { + if (node instanceof AST_SymbolDeclaration) defns.push(make_node(AST_VarDef, node, { + name: node, + value: make_value(compressor, node), + })); + }, true); + }); + return dropped; + }; + } + + AST_Const.DEFMETHOD("remove_initializers", remove_initializers(function(compressor, node) { + return make_node(AST_Undefined, node).optimize(compressor); + })); + AST_Let.DEFMETHOD("remove_initializers", remove_initializers(return_null)); + AST_Var.DEFMETHOD("remove_initializers", remove_initializers(return_null)); + + AST_Definitions.DEFMETHOD("to_assignments", function() { + var assignments = this.definitions.reduce(function(a, defn) { + var def = defn.name.definition(); + var value = defn.value; + if (value) { + if (value instanceof AST_Sequence) value = value.clone(); + var name = make_node(AST_SymbolRef, defn.name); + var assign = make_node(AST_Assign, defn, { + operator: "=", + left: name, + right: value, + }); + a.push(assign); + var fixed = function() { + return assign.right; + }; + fixed.assigns = [ assign ]; + fixed.direct_access = def.direct_access; + fixed.escaped = def.escaped; + name.fixed = fixed; + def.references.forEach(function(ref) { + if (!ref.fixed) return; + var assigns = ref.fixed.assigns; + if (!assigns) return; + if (assigns[0] !== defn) return; + if (assigns.length > 1 || ref.fixed.to_binary || ref.fixed.to_prefix) { + assigns[0] = assign; + } else { + ref.fixed = fixed; + if (def.fixed === ref.fixed) def.fixed = fixed; + } + }); + def.references.push(name); + def.assignments++; + } + def.eliminated++; + return a; + }, []); + if (assignments.length == 0) return null; + return make_sequence(this, assignments); + }); + + function is_safe_lexical(def) { + return def.name != "arguments" && def.orig.length < (def.orig[0] instanceof AST_SymbolLambda ? 3 : 2); + } + + function may_overlap(compressor, def) { + if (compressor.exposed(def)) return true; + var scope = def.scope.resolve(); + for (var s = def.scope; s !== scope;) { + s = s.parent_scope; + if (s.var_names().has(def.name)) return true; + } + } + + function to_let(stat, scope) { + return make_node(AST_Let, stat, { + definitions: stat.definitions.map(function(defn) { + return make_node(AST_VarDef, defn, { + name: defn.name.convert_symbol(AST_SymbolLet, function(name, node) { + var def = name.definition(); + def.orig[def.orig.indexOf(node)] = name; + for (var s = scope; s !== def.scope && (s = s.parent_scope);) { + remove(s.enclosed, def); + } + def.scope = scope; + scope.variables.set(def.name, def); + }), + value: defn.value, + }); + }), + }); + } + + function to_var(stat, scope) { + return make_node(AST_Var, stat, { + definitions: stat.definitions.map(function(defn) { + return make_node(AST_VarDef, defn, { + name: defn.name.convert_symbol(AST_SymbolVar, function(name, node) { + var def = name.definition(); + def.orig[def.orig.indexOf(node)] = name; + if (def.scope === scope) return; + def.scope = scope; + scope.variables.set(def.name, def); + scope.enclosed.push(def); + scope.var_names().set(def.name, true); + }), + value: defn.value, + }); + }), + }); + } + + (function(def) { + def(AST_Node, return_false); + def(AST_Const, function(compressor, assigned) { + assigned = assigned ? 1 : 0; + var defns = this.definitions; + if (!compressor.option("module") && all(defns, function(defn) { + return defn.name instanceof AST_SymbolConst; + })) return false; + return all(defns, function(defn) { + return !defn.name.match_symbol(function(node) { + if (node instanceof AST_SymbolDeclaration) return node.definition().assignments != assigned; + }, true); + }); + }); + def(AST_Var, function(compressor) { + return all(this.definitions, function(defn) { + return !defn.name.match_symbol(function(node) { + if (!(node instanceof AST_SymbolDeclaration)) return false; + var def = node.definition(); + if (def.first_decl !== node) return true; + if (!safe_from_tdz(compressor, node)) return true; + var defn_scope = node.scope; + if (defn_scope instanceof AST_Scope) return false; + return !all(def.references, function(ref) { + var scope = ref.scope; + do { + if (scope === defn_scope) return true; + } while (scope = scope.parent_scope); + return false; + }); + }, true); + }); + }); + })(function(node, func) { + node.DEFMETHOD("can_letify", func); + }); + + function safe_from_tdz(compressor, sym) { + var def = sym.definition(); + return (def.fixed || def.fixed === 0) + && is_safe_lexical(def) + && same_scope(def) + && !may_overlap(compressor, def); + } + + AST_Definitions.DEFMETHOD("can_varify", function(compressor) { + return all(this.definitions, function(defn) { + return !defn.name.match_symbol(function(node) { + if (node instanceof AST_SymbolDeclaration) return !safe_from_tdz(compressor, node); + }, true); + }); + }); + + OPT(AST_Const, function(self, compressor) { + if (!compressor.option("varify")) return self; + if (self.can_varify(compressor)) return to_var(self, compressor.find_parent(AST_Scope)); + if (self.can_letify(compressor)) return to_let(self, find_scope(compressor)); + return self; + }); + + OPT(AST_Let, function(self, compressor) { + if (!compressor.option("varify")) return self; + if (self.can_varify(compressor)) return to_var(self, compressor.find_parent(AST_Scope)); + return self; + }); + + function trim_optional_chain(node, compressor) { + if (!compressor.option("optional_chains")) return; + if (node.terminal) do { + var expr = node.expression; + if (node.optional) { + var ev = fuzzy_eval(compressor, expr, true); + if (ev == null) return make_node(AST_UnaryPrefix, node, { + operator: "void", + expression: expr, + }).optimize(compressor); + if (!(ev instanceof AST_Node)) node.optional = false; + } + node = expr; + } while ((node.TYPE == "Call" || node instanceof AST_PropAccess) && !node.terminal); + } + + function lift_sequence_in_expression(node, compressor) { + var exp = node.expression; + if (!(exp instanceof AST_Sequence)) return node; + var x = exp.expressions.slice(); + var e = node.clone(); + e.expression = x.pop(); + x.push(e); + return make_sequence(node, x); + } + + function drop_unused_call_args(call, compressor, fns_with_marked_args) { + var exp = call.expression; + var fn = exp instanceof AST_SymbolRef ? exp.fixed_value() : exp; + if (!(fn instanceof AST_Lambda)) return; + if (fn.uses_arguments) return; + if (fn.pinned()) return; + if (fns_with_marked_args && fns_with_marked_args.indexOf(fn) < 0) return; + var args = call.args; + if (!all(args, function(arg) { + return !(arg instanceof AST_Spread); + })) return; + var argnames = fn.argnames; + var is_iife = fn === exp && !fn.name; + if (fn.rest) { + if (!(is_iife && compressor.option("rests"))) return; + var insert = argnames.length; + args = args.slice(0, insert); + while (args.length < insert) args.push(make_node(AST_Undefined, call).optimize(compressor)); + args.push(make_node(AST_Array, call, { elements: call.args.slice(insert) })); + argnames = argnames.concat(fn.rest); + fn.rest = null; + } else { + args = args.slice(); + argnames = argnames.slice(); + } + var pos = 0, last = 0; + var drop_defaults = is_iife && compressor.option("default_values"); + var drop_fargs = is_iife && compressor.drop_fargs(fn, call) ? function(argname, arg) { + if (!argname) return true; + if (argname instanceof AST_DestructuredArray) { + return argname.elements.length == 0 && !argname.rest && arg instanceof AST_Array; + } + if (argname instanceof AST_DestructuredObject) { + return argname.properties.length == 0 && !argname.rest && arg && !arg.may_throw_on_access(compressor); + } + return argname.unused; + } : return_false; + var side_effects = []; + for (var i = 0; i < args.length; i++) { + var argname = argnames[i]; + if (drop_defaults && argname instanceof AST_DefaultValue && args[i].is_defined(compressor)) { + argnames[i] = argname = argname.name; + } + if (!argname || argname.unused !== undefined) { + var node = args[i].drop_side_effect_free(compressor); + if (drop_fargs(argname)) { + if (argname) argnames.splice(i, 1); + args.splice(i, 1); + if (node) side_effects.push(node); + i--; + continue; + } else if (node) { + side_effects.push(node); + args[pos++] = make_sequence(call, side_effects); + side_effects = []; + } else if (argname) { + if (side_effects.length) { + args[pos++] = make_sequence(call, side_effects); + side_effects = []; + } else { + args[pos++] = make_node(AST_Number, args[i], { value: 0 }); + continue; + } + } + } else if (drop_fargs(argname, args[i])) { + var node = args[i].drop_side_effect_free(compressor); + argnames.splice(i, 1); + args.splice(i, 1); + if (node) side_effects.push(node); + i--; + continue; + } else { + side_effects.push(args[i]); + args[pos++] = make_sequence(call, side_effects); + side_effects = []; + } + last = pos; + } + for (; i < argnames.length; i++) { + if (drop_fargs(argnames[i])) argnames.splice(i--, 1); + } + fn.argnames = argnames; + args.length = last; + call.args = args; + if (!side_effects.length) return; + var arg = make_sequence(call, side_effects); + args.push(args.length < argnames.length ? make_node(AST_UnaryPrefix, call, { + operator: "void", + expression: arg, + }) : arg); + } + + function avoid_await_yield(compressor, parent_scope) { + if (!parent_scope) parent_scope = compressor.find_parent(AST_Scope); + var avoid = []; + if (is_async(parent_scope) || parent_scope instanceof AST_Toplevel && compressor.option("module")) { + avoid.push("await"); + } + if (is_generator(parent_scope)) avoid.push("yield"); + return avoid.length && makePredicate(avoid); + } + + function safe_from_await_yield(fn, avoid) { + if (!avoid) return true; + var safe = true; + var tw = new TreeWalker(function(node) { + if (!safe) return true; + if (node instanceof AST_Scope) { + if (node === fn) return; + if (is_arrow(node)) { + for (var i = 0; safe && i < node.argnames.length; i++) node.argnames[i].walk(tw); + } else if (node instanceof AST_LambdaDefinition && avoid[node.name.name]) { + safe = false; + } + return true; + } + if (node instanceof AST_Symbol && avoid[node.name] && node !== fn.name) safe = false; + }); + fn.walk(tw); + return safe; + } + + function safe_from_strict_mode(fn, compressor) { + return fn.in_strict_mode(compressor) || !compressor.has_directive("use strict"); + } + + OPT(AST_Call, function(self, compressor) { + var exp = self.expression; + var terminated = trim_optional_chain(self, compressor); + if (terminated) return terminated; + if (compressor.option("sequences")) { + if (exp instanceof AST_PropAccess) { + var seq = lift_sequence_in_expression(exp, compressor); + if (seq !== exp) { + var call = self.clone(); + call.expression = seq.expressions.pop(); + seq.expressions.push(call); + return seq.optimize(compressor); + } + } else if (!needs_unbinding(exp.tail_node())) { + var seq = lift_sequence_in_expression(self, compressor); + if (seq !== self) return seq.optimize(compressor); + } + } + if (compressor.option("unused")) drop_unused_call_args(self, compressor); + if (compressor.option("unsafe")) { + if (is_undeclared_ref(exp)) switch (exp.name) { + case "Array": + // Array(n) ---> [ , , ... , ] + if (self.args.length == 1) { + var first = self.args[0]; + if (first instanceof AST_Number) try { + var length = first.value; + if (length > 6) break; + var elements = Array(length); + for (var i = 0; i < length; i++) elements[i] = make_node(AST_Hole, self); + return make_node(AST_Array, self, { elements: elements }); + } catch (ex) { + AST_Node.warn("Invalid array length: {length} [{start}]", { + length: length, + start: self.start, + }); + break; + } + if (!first.is_boolean(compressor) && !first.is_string(compressor)) break; + } + // Array(...) ---> [ ... ] + return make_node(AST_Array, self, { elements: self.args }); + case "Object": + // Object() ---> {} + if (self.args.length == 0) return make_node(AST_Object, self, { properties: [] }); + break; + case "String": + // String() ---> "" + if (self.args.length == 0) return make_node(AST_String, self, { value: "" }); + // String(x) ---> "" + x + if (self.args.length == 1) return make_node(AST_Binary, self, { + operator: "+", + left: make_node(AST_String, self, { value: "" }), + right: self.args[0], + }).optimize(compressor); + break; + case "Number": + // Number() ---> 0 + if (self.args.length == 0) return make_node(AST_Number, self, { value: 0 }); + // Number(x) ---> +("" + x) + if (self.args.length == 1) return make_node(AST_UnaryPrefix, self, { + operator: "+", + expression: make_node(AST_Binary, self, { + operator: "+", + left: make_node(AST_String, self, { value: "" }), + right: self.args[0], + }), + }).optimize(compressor); + break; + case "Boolean": + // Boolean() ---> false + if (self.args.length == 0) return make_node(AST_False, self).optimize(compressor); + // Boolean(x) ---> !!x + if (self.args.length == 1) return make_node(AST_UnaryPrefix, self, { + operator: "!", + expression: make_node(AST_UnaryPrefix, self, { + operator: "!", + expression: self.args[0], + }), + }).optimize(compressor); + break; + case "RegExp": + // attempt to convert RegExp(...) to literal + var params = []; + if (all(self.args, function(arg) { + var value = arg.evaluate(compressor); + params.unshift(value); + return arg !== value; + })) try { + return best_of(compressor, self, make_node(AST_RegExp, self, { + value: RegExp.apply(RegExp, params), + })); + } catch (ex) { + AST_Node.warn("Error converting {this} [{start}]", self); + } + break; + } else if (exp instanceof AST_Dot) switch (exp.property) { + case "toString": + // x.toString() ---> "" + x + var expr = exp.expression; + if (self.args.length == 0 && !(expr.may_throw_on_access(compressor) || expr instanceof AST_Super)) { + return make_node(AST_Binary, self, { + operator: "+", + left: make_node(AST_String, self, { value: "" }), + right: expr, + }).optimize(compressor); + } + break; + case "join": + if (exp.expression instanceof AST_Array && self.args.length < 2) EXIT: { + var separator = self.args[0]; + // [].join() ---> "" + // [].join(x) ---> (x, "") + if (exp.expression.elements.length == 0 && !(separator instanceof AST_Spread)) { + return separator ? make_sequence(self, [ + separator, + make_node(AST_String, self, { value: "" }), + ]).optimize(compressor) : make_node(AST_String, self, { value: "" }); + } + if (separator) { + separator = separator.evaluate(compressor); + if (separator instanceof AST_Node) break EXIT; // not a constant + } + var elements = []; + var consts = []; + for (var i = 0; i < exp.expression.elements.length; i++) { + var el = exp.expression.elements[i]; + var value = el.evaluate(compressor); + if (value !== el) { + consts.push(value); + } else if (el instanceof AST_Spread) { + break EXIT; + } else { + if (consts.length > 0) { + elements.push(make_node(AST_String, self, { value: consts.join(separator) })); + consts.length = 0; + } + elements.push(el); + } + } + if (consts.length > 0) elements.push(make_node(AST_String, self, { + value: consts.join(separator), + })); + // [ x ].join() ---> "" + x + // [ x ].join(".") ---> "" + x + // [ 1, 2, 3 ].join() ---> "1,2,3" + // [ 1, 2, 3 ].join(".") ---> "1.2.3" + if (elements.length == 1) { + if (elements[0].is_string(compressor)) return elements[0]; + return make_node(AST_Binary, elements[0], { + operator: "+", + left: make_node(AST_String, self, { value: "" }), + right: elements[0], + }); + } + // [ 1, 2, a, 3 ].join("") ---> "12" + a + "3" + if (separator == "") { + var first; + if (elements[0].is_string(compressor) || elements[1].is_string(compressor)) { + first = elements.shift(); + } else { + first = make_node(AST_String, self, { value: "" }); + } + return elements.reduce(function(prev, el) { + return make_node(AST_Binary, el, { + operator: "+", + left: prev, + right: el, + }); + }, first).optimize(compressor); + } + // [ x, "foo", "bar", y ].join() ---> [ x, "foo,bar", y ].join() + // [ x, "foo", "bar", y ].join("-") ---> [ x, "foo-bar", y ].join("-") + // need this awkward cloning to not affect original element + // best_of will decide which one to get through. + var node = self.clone(); + node.expression = node.expression.clone(); + node.expression.expression = node.expression.expression.clone(); + node.expression.expression.elements = elements; + return best_of(compressor, self, node); + } + break; + case "charAt": + if (self.args.length < 2) { + var node = make_node(AST_Binary, self, { + operator: "||", + left: make_node(AST_Sub, self, { + expression: exp.expression, + property: self.args.length ? make_node(AST_Binary, self.args[0], { + operator: "|", + left: make_node(AST_Number, self, { value: 0 }), + right: self.args[0], + }) : make_node(AST_Number, self, { value: 0 }), + }).optimize(compressor), + right: make_node(AST_String, self, { value: "" }), + }); + node.is_string = return_true; + return node.optimize(compressor); + } + break; + case "apply": + if (self.args.length == 2 && self.args[1] instanceof AST_Array) { + var args = self.args[1].elements.slice(); + args.unshift(self.args[0]); + return make_node(AST_Call, self, { + expression: make_node(AST_Dot, exp, { + expression: exp.expression, + property: "call", + }), + args: args, + }).optimize(compressor); + } + break; + case "call": + var func = exp.expression; + if (func instanceof AST_SymbolRef) { + func = func.fixed_value(); + } + if (func instanceof AST_Lambda && !func.contains_this()) { + return (self.args.length ? make_sequence(self, [ + self.args[0], + make_node(AST_Call, self, { + expression: exp.expression, + args: self.args.slice(1), + }), + ]) : make_node(AST_Call, self, { + expression: exp.expression, + args: [], + })).optimize(compressor); + } + break; + } else if (compressor.option("side_effects") + && exp instanceof AST_Call + && exp.args.length == 1 + && is_undeclared_ref(exp.expression) + && exp.expression.name == "Object") { + var call = self.clone(); + call.expression = maintain_this_binding(self, exp, exp.args[0]); + return call.optimize(compressor); + } + } + if (compressor.option("unsafe_Function") + && is_undeclared_ref(exp) + && exp.name == "Function") { + // new Function() ---> function(){} + if (self.args.length == 0) return make_node(AST_Function, self, { + argnames: [], + body: [], + }).init_vars(exp.scope); + if (all(self.args, function(x) { + return x instanceof AST_String; + })) { + // quite a corner-case, but we can handle it: + // https://github.com/mishoo/UglifyJS/issues/203 + // if the code argument is a constant, then we can minify it. + try { + var code = "n(function(" + self.args.slice(0, -1).map(function(arg) { + return arg.value; + }).join() + "){" + self.args[self.args.length - 1].value + "})"; + var ast = parse(code); + var mangle = { ie: compressor.option("ie") }; + ast.figure_out_scope(mangle); + var comp = new Compressor(compressor.options); + ast = ast.transform(comp); + ast.figure_out_scope(mangle); + ast.compute_char_frequency(mangle); + ast.mangle_names(mangle); + var fun; + ast.walk(new TreeWalker(function(node) { + if (fun) return true; + if (node instanceof AST_Lambda) { + fun = node; + return true; + } + })); + var code = OutputStream(); + AST_BlockStatement.prototype._codegen.call(fun, code); + self.args = [ + make_node(AST_String, self, { + value: fun.argnames.map(function(arg) { + return arg.print_to_string(); + }).join(), + }), + make_node(AST_String, self.args[self.args.length - 1], { + value: code.get().replace(/^\{|\}$/g, "") + }), + ]; + return self; + } catch (ex) { + if (ex instanceof JS_Parse_Error) { + AST_Node.warn("Error parsing code passed to new Function [{start}]", self.args[self.args.length - 1]); + AST_Node.warn(ex.toString()); + } else { + throw ex; + } + } + } + } + var fn = exp instanceof AST_SymbolRef ? exp.fixed_value() : exp; + var parent = compressor.parent(), current = compressor.self(); + var is_func = fn instanceof AST_Lambda + && (!is_async(fn) || compressor.option("awaits") && parent instanceof AST_Await) + && (!is_generator(fn) || compressor.option("yields") && current instanceof AST_Yield && current.nested); + var stat = is_func && fn.first_statement(); + var has_default = 0, has_destructured = false; + var has_spread = !all(self.args, function(arg) { + return !(arg instanceof AST_Spread); + }); + var can_drop = is_func && all(fn.argnames, function(argname, index) { + if (has_default == 1 && self.args[index] instanceof AST_Spread) has_default = 2; + if (argname instanceof AST_DefaultValue) { + if (!has_default) has_default = 1; + var arg = has_default == 1 && self.args[index]; + if (!is_undefined(arg)) has_default = 2; + if (has_arg_refs(fn, argname.value)) return false; + argname = argname.name; + } + if (argname instanceof AST_Destructured) { + has_destructured = true; + if (has_arg_refs(fn, argname)) return false; + } + return true; + }) && !(fn.rest instanceof AST_Destructured && has_arg_refs(fn, fn.rest)); + var can_inline = can_drop + && compressor.option("inline") + && !self.is_expr_pure(compressor) + && (exp === fn || safe_from_strict_mode(fn, compressor)); + if (can_inline && stat instanceof AST_Return) { + var value = stat.value; + if (exp === fn + && !fn.name + && (!value || value.is_constant_expression()) + && safe_from_await_yield(fn, avoid_await_yield(compressor))) { + return make_sequence(self, convert_args(value)).optimize(compressor); + } + } + if (is_func && !fn.contains_this()) { + var def, value, var_assigned = false; + if (can_inline + && !fn.uses_arguments + && !fn.pinned() + && !(fn.name && fn instanceof AST_LambdaExpression) + && (exp === fn || !recursive_ref(compressor, def = exp.definition(), fn) + && fn.is_constant_expression(find_scope(compressor))) + && (value = can_flatten_body(stat))) { + var replacing = exp === fn || def.single_use && def.references.length - def.replaced == 1; + if (can_substitute_directly()) { + self._optimized = true; + var retValue = value.optimize(compressor).clone(true); + var args = self.args.slice(); + var refs = []; + retValue = retValue.transform(new TreeTransformer(function(node) { + if (node instanceof AST_SymbolRef) { + var def = node.definition(); + if (fn.variables.get(node.name) !== def) { + refs.push(node); + return node; + } + var index = resolve_index(def); + var arg = args[index]; + if (!arg) return make_node(AST_Undefined, self); + args[index] = null; + var parent = this.parent(); + return parent ? maintain_this_binding(parent, node, arg) : arg; + } + })); + var save_inlined = fn.inlined; + if (exp !== fn) fn.inlined = true; + var exprs = []; + args.forEach(function(arg) { + if (!arg) return; + arg = arg.clone(true); + arg.walk(new TreeWalker(function(node) { + if (node instanceof AST_SymbolRef) refs.push(node); + })); + exprs.push(arg); + }, []); + exprs.push(retValue); + var node = make_sequence(self, exprs).optimize(compressor); + fn.inlined = save_inlined; + node = maintain_this_binding(parent, current, node); + self.inlined_node = node; + if (replacing || best_of_expression(node, self) === node) { + refs.forEach(function(ref) { + ref.scope = exp === fn ? fn.parent_scope : exp.scope; + ref.reference(); + var def = ref.definition(); + if (replacing) def.replaced++; + def.single_use = false; + }); + return node; + } else if (!node.has_side_effects(compressor)) { + self.drop_side_effect_free = function(compressor, first_in_statement) { + var self = this; + var exprs = self.args.slice(); + exprs.unshift(self.expression); + return make_sequence(self, exprs).drop_side_effect_free(compressor, first_in_statement); + }; + self.has_side_effects = function(compressor) { + var self = this; + var exprs = self.args.slice(); + exprs.unshift(self.expression); + return make_sequence(self, exprs).has_side_effects(compressor); + }; + } + } + var arg_used, insert, in_loop, scope; + if (replacing && can_inject_symbols()) { + fn._squeezed = true; + if (exp !== fn) fn.parent_scope = exp.scope; + var node = make_sequence(self, flatten_fn()).optimize(compressor); + return maintain_this_binding(parent, current, node); + } + } + if (compressor.option("side_effects") + && can_drop + && all(fn.body, is_empty) + && (fn === exp ? fn_name_unused(fn, compressor) : !has_default && !has_destructured && !fn.rest) + && !(is_arrow(fn) && fn.value) + && safe_from_await_yield(fn, avoid_await_yield(compressor))) { + return make_sequence(self, convert_args()).optimize(compressor); + } + } + if (compressor.option("arrows") + && compressor.option("module") + && (exp instanceof AST_AsyncFunction || exp instanceof AST_Function) + && !exp.name + && !exp.uses_arguments + && !exp.pinned() + && !exp.contains_this()) { + var arrow = make_node(is_async(exp) ? AST_AsyncArrow : AST_Arrow, exp, exp); + arrow.init_vars(exp.parent_scope, exp); + arrow.variables.del("arguments"); + self.expression = arrow.transform(compressor); + return self; + } + if (compressor.option("drop_console")) { + if (exp instanceof AST_PropAccess) { + var name = exp.expression; + while (name.expression) { + name = name.expression; + } + if (is_undeclared_ref(name) && name.name == "console") { + return make_node(AST_Undefined, self).optimize(compressor); + } + } + } + if (compressor.option("negate_iife") && parent instanceof AST_SimpleStatement && is_iife_call(current)) { + return self.negate(compressor, true); + } + return try_evaluate(compressor, self); + + function make_void_lhs(orig) { + return make_node(AST_Sub, orig, { + expression: make_node(AST_Array, orig, { elements: [] }), + property: make_node(AST_Number, orig, { value: 0 }), + }); + } + + function convert_args(value) { + var args = self.args.slice(); + var destructured = has_default > 1 || has_destructured || fn.rest; + if (destructured || has_spread) args = [ make_node(AST_Array, self, { elements: args }) ]; + if (destructured) { + var tt = new TreeTransformer(function(node, descend) { + if (node instanceof AST_DefaultValue) return make_node(AST_DefaultValue, node, { + name: node.name.transform(tt) || make_void_lhs(node), + value: node.value, + }); + if (node instanceof AST_DestructuredArray) { + var elements = []; + node.elements.forEach(function(node, index) { + node = node.transform(tt); + if (node) elements[index] = node; + }); + fill_holes(node, elements); + return make_node(AST_DestructuredArray, node, { elements: elements }); + } + if (node instanceof AST_DestructuredObject) { + var properties = [], side_effects = []; + node.properties.forEach(function(prop) { + var key = prop.key; + var value = prop.value.transform(tt); + if (value) { + if (side_effects.length) { + if (!(key instanceof AST_Node)) key = make_node_from_constant(key, prop); + side_effects.push(key); + key = make_sequence(node, side_effects); + side_effects = []; + } + properties.push(make_node(AST_DestructuredKeyVal, prop, { + key: key, + value: value, + })); + } else if (key instanceof AST_Node) { + side_effects.push(key); + } + }); + if (side_effects.length) properties.push(make_node(AST_DestructuredKeyVal, node, { + key: make_sequence(node, side_effects), + value: make_void_lhs(node), + })); + return make_node(AST_DestructuredObject, node, { properties: properties }); + } + if (node instanceof AST_SymbolFunarg) return null; + }); + var lhs = []; + fn.argnames.forEach(function(argname, index) { + argname = argname.transform(tt); + if (argname) lhs[index] = argname; + }); + var rest = fn.rest && fn.rest.transform(tt); + if (rest) lhs.length = fn.argnames.length; + fill_holes(fn, lhs); + args[0] = make_node(AST_Assign, self, { + operator: "=", + left: make_node(AST_DestructuredArray, fn, { + elements: lhs, + rest: rest, + }), + right: args[0], + }); + } else fn.argnames.forEach(function(argname) { + if (argname instanceof AST_DefaultValue) args.push(argname.value); + }); + args.push(value || make_node(AST_Undefined, self)); + return args; + } + + function noop_value() { + return self.call_only ? make_node(AST_Number, self, { value: 0 }) : make_node(AST_Undefined, self); + } + + function return_value(stat) { + if (!stat) return noop_value(); + if (stat instanceof AST_Return) return stat.value || noop_value(); + if (stat instanceof AST_SimpleStatement) { + return self.call_only ? stat.body : make_node(AST_UnaryPrefix, stat, { + operator: "void", + expression: stat.body, + }); + } + } + + function can_flatten_body(stat) { + var len = fn.body.length; + if (len < 2) { + stat = return_value(stat); + if (stat) return stat; + } + if (compressor.option("inline") < 3) return false; + stat = null; + for (var i = 0; i < len; i++) { + var line = fn.body[i]; + if (line instanceof AST_Var) { + if (var_assigned) { + if (!stat) continue; + if (!(stat instanceof AST_SimpleStatement)) return false; + if (!declarations_only(line)) stat = null; + } else if (!declarations_only(line)) { + if (stat && !(stat instanceof AST_SimpleStatement)) return false; + stat = null; + var_assigned = true; + } + } else if (line instanceof AST_AsyncDefun + || line instanceof AST_Defun + || line instanceof AST_EmptyStatement) { + continue; + } else if (stat) { + return false; + } else { + stat = line; + } + } + return return_value(stat); + } + + function resolve_index(def) { + for (var i = fn.argnames.length; --i >= 0;) { + if (fn.argnames[i].definition() === def) return i; + } + } + + function can_substitute_directly() { + if (has_default || has_destructured || has_spread || var_assigned || fn.rest) return; + if (compressor.option("inline") < 2 && fn.argnames.length) return; + if (!fn.variables.all(function(def) { + return def.references.length - def.replaced < 2 && def.orig[0] instanceof AST_SymbolFunarg; + })) return; + var scope = compressor.find_parent(AST_Scope); + var abort = false; + var avoid = avoid_await_yield(compressor, scope); + var begin; + var in_order = []; + var side_effects = false; + var tw = new TreeWalker(function(node, descend) { + if (abort) return true; + if (node instanceof AST_Binary && lazy_op[node.operator] + || node instanceof AST_Conditional) { + in_order = null; + return; + } + if (node instanceof AST_Class) return abort = true; + if (node instanceof AST_Destructured) { + side_effects = true; + return; + } + if (node instanceof AST_Scope) return abort = true; + if (avoid && node instanceof AST_Symbol && avoid[node.name]) return abort = true; + if (node instanceof AST_SymbolRef) { + var def = node.definition(); + if (fn.variables.get(node.name) !== def) { + in_order = null; + return; + } + if (def.init instanceof AST_LambdaDefinition) return abort = true; + if (is_lhs(node, tw.parent())) return abort = true; + var index = resolve_index(def); + if (!(begin < index)) begin = index; + if (!in_order) return; + if (side_effects) { + in_order = null; + } else { + in_order.push(fn.argnames[index]); + } + return; + } + if (side_effects) return; + if (node instanceof AST_Assign && node.left instanceof AST_PropAccess) { + node.left.expression.walk(tw); + if (node.left instanceof AST_Sub) node.left.property.walk(tw); + node.right.walk(tw); + side_effects = true; + return true; + } + if (node.has_side_effects(compressor)) { + descend(); + side_effects = true; + return true; + } + }); + value.walk(tw); + if (abort) return; + var end = self.args.length; + if (in_order && fn.argnames.length >= end) { + end = fn.argnames.length; + while (end-- > begin && fn.argnames[end] === in_order.pop()); + end++; + } + return end <= begin || all(self.args.slice(begin, end), side_effects && !in_order ? function(funarg) { + return funarg.is_constant_expression(scope); + } : function(funarg) { + return !funarg.has_side_effects(compressor); + }); + } + + function var_exists(defined, name) { + return defined.has(name) || identifier_atom[name] || scope.var_names().has(name); + } + + function can_inject_args(defined, safe_to_inject) { + var abort = false; + fn.each_argname(function(arg) { + if (abort) return; + if (arg.unused) return; + if (!safe_to_inject || var_exists(defined, arg.name)) return abort = true; + arg_used.set(arg.name, true); + if (in_loop) in_loop.push(arg.definition()); + }); + return !abort; + } + + function can_inject_vars(defined, safe_to_inject) { + for (var i = 0; i < fn.body.length; i++) { + var stat = fn.body[i]; + if (stat instanceof AST_LambdaDefinition) { + var name = stat.name; + if (!safe_to_inject) return false; + if (arg_used.has(name.name)) return false; + if (var_exists(defined, name.name)) return false; + if (!all(stat.enclosed, function(def) { + return def.scope === scope || def.scope === stat || !defined.has(def.name); + })) return false; + if (in_loop) in_loop.push(name.definition()); + continue; + } + if (!(stat instanceof AST_Var)) continue; + if (!safe_to_inject) return false; + for (var j = stat.definitions.length; --j >= 0;) { + var name = stat.definitions[j].name; + if (var_exists(defined, name.name)) return false; + if (in_loop) in_loop.push(name.definition()); + } + } + return true; + } + + function can_inject_symbols() { + var defined = new Dictionary(); + var level = 0, child; + scope = current; + do { + if (scope.variables) scope.variables.each(function(def) { + defined.set(def.name, true); + }); + child = scope; + scope = compressor.parent(level++); + if (scope instanceof AST_ClassField) { + if (!scope.static) return false; + } else if (scope instanceof AST_DWLoop) { + in_loop = []; + } else if (scope instanceof AST_For) { + if (scope.init === child) continue; + in_loop = []; + } else if (scope instanceof AST_ForEnumeration) { + if (scope.init === child) continue; + if (scope.object === child) continue; + in_loop = []; + } + } while (!(scope instanceof AST_Scope)); + insert = scope.body.indexOf(child) + 1; + if (!insert) return false; + if (!safe_from_await_yield(fn, avoid_await_yield(compressor, scope))) return false; + var safe_to_inject = (exp !== fn || fn.parent_scope.resolve() === scope) && !scope.pinned(); + if (scope instanceof AST_Toplevel) { + if (compressor.toplevel.vars) { + defined.set("arguments", true); + } else { + safe_to_inject = false; + } + } + arg_used = new Dictionary(); + var inline = compressor.option("inline"); + if (!can_inject_args(defined, inline >= 2 && safe_to_inject)) return false; + if (!can_inject_vars(defined, inline >= 3 && safe_to_inject)) return false; + return !in_loop || in_loop.length == 0 || !is_reachable(fn, in_loop); + } + + function append_var(decls, expressions, name, value) { + var def = name.definition(); + if (!scope.var_names().has(name.name)) { + def.first_decl = null; + scope.var_names().set(name.name, true); + decls.push(make_node(AST_VarDef, name, { + name: name, + value: null, + })); + } + scope.variables.set(name.name, def); + scope.enclosed.push(def); + if (!value) return; + var sym = make_node(AST_SymbolRef, name); + def.assignments++; + def.references.push(sym); + expressions.push(make_node(AST_Assign, self, { + operator: "=", + left: sym, + right: value, + })); + } + + function flatten_args(decls, expressions) { + var len = fn.argnames.length; + for (var i = self.args.length; --i >= len;) { + expressions.push(self.args[i]); + } + var default_args = []; + for (i = len; --i >= 0;) { + var argname = fn.argnames[i]; + var name; + if (argname instanceof AST_DefaultValue) { + default_args.push(argname); + name = argname.name; + } else { + name = argname; + } + var value = self.args[i]; + if (name.unused || scope.var_names().has(name.name)) { + if (value) expressions.push(value); + } else { + var symbol = make_node(AST_SymbolVar, name); + var def = name.definition(); + def.orig.push(symbol); + def.eliminated++; + if (name.unused !== undefined) { + append_var(decls, expressions, symbol); + if (value) expressions.push(value); + } else { + if (!value && argname === name && (in_loop + || name.name == "arguments" && !is_arrow(fn) && is_arrow(scope))) { + value = make_node(AST_Undefined, self); + } + append_var(decls, expressions, symbol, value); + } + } + } + decls.reverse(); + expressions.reverse(); + for (i = default_args.length; --i >= 0;) { + var node = default_args[i]; + if (node.name.unused !== undefined) { + expressions.push(node.value); + } else { + var sym = make_node(AST_SymbolRef, node.name); + node.name.definition().references.push(sym); + expressions.push(make_node(AST_Assign, node, { + operator: "=", + left: sym, + right: node.value, + })); + } + } + } + + function flatten_destructured(decls, expressions) { + expressions.push(make_node(AST_Assign, self, { + operator: "=", + left: make_node(AST_DestructuredArray, self, { + elements: fn.argnames.map(function(argname) { + if (argname.unused) return make_node(AST_Hole, argname); + return argname.convert_symbol(AST_SymbolRef, process); + }), + rest: fn.rest && fn.rest.convert_symbol(AST_SymbolRef, process), + }), + right: make_node(AST_Array, self, { elements: self.args.slice() }), + })); + + function process(ref, name) { + if (name.unused) return make_void_lhs(name); + var def = name.definition(); + def.assignments++; + def.references.push(ref); + var symbol = make_node(AST_SymbolVar, name); + def.orig.push(symbol); + def.eliminated++; + append_var(decls, expressions, symbol); + } + } + + function flatten_vars(decls, expressions) { + var args = [ insert, 0 ]; + var decl_var = [], expr_fn = [], expr_var = [], expr_loop = [], exprs = []; + fn.body.filter(in_loop ? function(stat) { + if (!(stat instanceof AST_LambdaDefinition)) return true; + var name = make_node(AST_SymbolVar, flatten_var(stat.name)); + var def = name.definition(); + def.fixed = false; + def.orig.push(name); + def.eliminated++; + append_var(decls, expr_fn, name, to_func_expr(stat, true)); + return false; + } : function(stat) { + if (!(stat instanceof AST_LambdaDefinition)) return true; + var def = stat.name.definition(); + scope.functions.set(def.name, def); + scope.variables.set(def.name, def); + scope.enclosed.push(def); + scope.var_names().set(def.name, true); + args.push(stat); + return false; + }).forEach(function(stat) { + if (!(stat instanceof AST_Var)) { + if (stat instanceof AST_SimpleStatement) exprs.push(stat.body); + return; + } + for (var j = 0; j < stat.definitions.length; j++) { + var var_def = stat.definitions[j]; + var name = flatten_var(var_def.name); + var value = var_def.value; + if (value && exprs.length > 0) { + exprs.push(value); + value = make_sequence(var_def, exprs); + exprs = []; + } + append_var(decl_var, expr_var, name, value); + if (!in_loop) continue; + if (arg_used.has(name.name)) continue; + if (name.definition().orig.length == 1 && fn.functions.has(name.name)) continue; + expr_loop.push(init_ref(compressor, name)); + } + }); + [].push.apply(decls, decl_var); + [].push.apply(expressions, expr_loop); + [].push.apply(expressions, expr_fn); + [].push.apply(expressions, expr_var); + return args; + } + + function flatten_fn() { + var decls = []; + var expressions = []; + if (has_default > 1 || has_destructured || has_spread || fn.rest) { + flatten_destructured(decls, expressions); + } else { + flatten_args(decls, expressions); + } + var args = flatten_vars(decls, expressions); + expressions.push(value); + if (decls.length) args.push(make_node(AST_Var, fn, { definitions: decls })); + [].splice.apply(scope.body, args); + fn.enclosed.forEach(function(def) { + if (scope.var_names().has(def.name)) return; + scope.enclosed.push(def); + scope.var_names().set(def.name, true); + }); + return expressions; + } + }); + + OPT(AST_New, function(self, compressor) { + if (compressor.option("unsafe")) { + var exp = self.expression; + if (is_undeclared_ref(exp)) switch (exp.name) { + case "Array": + case "Error": + case "Function": + case "Object": + case "RegExp": + return make_node(AST_Call, self).transform(compressor); + } + } + if (compressor.option("sequences")) { + var seq = lift_sequence_in_expression(self, compressor); + if (seq !== self) return seq.optimize(compressor); + } + if (compressor.option("unused")) drop_unused_call_args(self, compressor); + return self; + }); + + // (a = b, x && a = c) ---> a = x ? c : b + // (a = b, x || a = c) ---> a = x ? b : c + function to_conditional_assignment(compressor, def, value, node) { + if (!(node instanceof AST_Binary)) return; + if (!(node.operator == "&&" || node.operator == "||")) return; + if (!(node.right instanceof AST_Assign)) return; + if (node.right.operator != "=") return; + if (!(node.right.left instanceof AST_SymbolRef)) return; + if (node.right.left.definition() !== def) return; + if (value.has_side_effects(compressor)) return; + if (!safe_from_assignment(node.left)) return; + if (!safe_from_assignment(node.right.right)) return; + def.replaced++; + return node.operator == "&&" ? make_node(AST_Conditional, node, { + condition: node.left, + consequent: node.right.right, + alternative: value, + }) : make_node(AST_Conditional, node, { + condition: node.left, + consequent: value, + alternative: node.right.right, + }); + + function safe_from_assignment(node) { + if (node.has_side_effects(compressor)) return; + var hit = false; + node.walk(new TreeWalker(function(node) { + if (hit) return true; + if (node instanceof AST_SymbolRef && node.definition() === def) return hit = true; + })); + return !hit; + } + } + + OPT(AST_Sequence, function(self, compressor) { + var expressions = filter_for_side_effects(); + var end = expressions.length - 1; + merge_assignments(); + trim_right_for_undefined(); + if (end == 0) { + self = maintain_this_binding(compressor.parent(), compressor.self(), expressions[0]); + if (!(self instanceof AST_Sequence)) self = self.optimize(compressor); + return self; + } + self.expressions = expressions; + return self; + + function filter_for_side_effects() { + if (!compressor.option("side_effects")) return self.expressions; + var expressions = []; + var first = first_in_statement(compressor); + var last = self.expressions.length - 1; + self.expressions.forEach(function(expr, index) { + if (index < last) expr = expr.drop_side_effect_free(compressor, first); + if (expr) { + merge_sequence(expressions, expr); + first = false; + } + }); + return expressions; + } + + function trim_right_for_undefined() { + if (!compressor.option("side_effects")) return; + while (end > 0 && is_undefined(expressions[end], compressor)) end--; + if (end < expressions.length - 1) { + expressions[end] = make_node(AST_UnaryPrefix, self, { + operator: "void", + expression: expressions[end], + }); + expressions.length = end + 1; + } + } + + function is_simple_assign(node) { + return node instanceof AST_Assign + && node.operator == "=" + && node.left instanceof AST_SymbolRef + && node.left.definition(); + } + + function merge_assignments() { + for (var i = 1; i < end; i++) { + var prev = expressions[i - 1]; + var def = is_simple_assign(prev); + if (!def) continue; + var expr = expressions[i]; + if (compressor.option("conditionals")) { + var cond = to_conditional_assignment(compressor, def, prev.right, expr); + if (cond) { + prev.right = cond; + expressions.splice(i--, 1); + end--; + continue; + } + } + if (compressor.option("dead_code") + && is_simple_assign(expr) === def + && expr.right.is_constant_expression(def.scope.resolve())) { + expressions[--i] = prev.right; + } + } + } + }); + + OPT(AST_UnaryPostfix, function(self, compressor) { + if (compressor.option("sequences")) { + var seq = lift_sequence_in_expression(self, compressor); + if (seq !== self) return seq.optimize(compressor); + } + return try_evaluate(compressor, self); + }); + + var SIGN_OPS = makePredicate("+ -"); + var MULTIPLICATIVE_OPS = makePredicate("* / %"); + OPT(AST_UnaryPrefix, function(self, compressor) { + var op = self.operator; + var exp = self.expression; + if (compressor.option("sequences") && can_lift()) { + var seq = lift_sequence_in_expression(self, compressor); + if (seq !== self) return seq.optimize(compressor); + } + switch (op) { + case "+": + if (!compressor.option("evaluate")) break; + if (!exp.is_number(compressor, true)) break; + var parent = compressor.parent(); + if (parent instanceof AST_UnaryPrefix && parent.operator == "delete") break; + return exp; + case "-": + if (exp instanceof AST_Infinity) exp = exp.transform(compressor); + // avoids infinite recursion of numerals + if (exp instanceof AST_Number || exp instanceof AST_Infinity) return self; + break; + case "!": + if (!compressor.option("booleans")) break; + if (exp.is_truthy()) return make_sequence(self, [ exp, make_node(AST_False, self) ]).optimize(compressor); + if (compressor.in_boolean_context()) { + // !!foo ---> foo, if we're in boolean context + if (exp instanceof AST_UnaryPrefix && exp.operator == "!") return exp.expression; + if (exp instanceof AST_Binary) { + var first = first_in_statement(compressor); + self = (first ? best_of_statement : best_of_expression)(self, exp.negate(compressor, first)); + } + } + break; + case "delete": + if (!compressor.option("evaluate")) break; + if (may_not_delete(exp)) break; + return make_sequence(self, [ exp, make_node(AST_True, self) ]).optimize(compressor); + case "typeof": + if (!compressor.option("booleans")) break; + if (!compressor.in_boolean_context()) break; + // typeof always returns a non-empty string, thus always truthy + AST_Node.warn("Boolean expression always true [{start}]", self); + var exprs = [ make_node(AST_True, self) ]; + if (!(exp instanceof AST_SymbolRef && can_drop_symbol(exp, compressor))) exprs.unshift(exp); + return make_sequence(self, exprs).optimize(compressor); + case "void": + if (!compressor.option("side_effects")) break; + exp = exp.drop_side_effect_free(compressor); + if (!exp) return make_node(AST_Undefined, self).optimize(compressor); + self.expression = exp; + return self; + } + if (compressor.option("evaluate") + && exp instanceof AST_Binary + && SIGN_OPS[op] + && MULTIPLICATIVE_OPS[exp.operator] + && (exp.left.is_constant() || !exp.right.has_side_effects(compressor))) { + return make_node(AST_Binary, self, { + operator: exp.operator, + left: make_node(AST_UnaryPrefix, exp.left, { + operator: op, + expression: exp.left, + }), + right: exp.right, + }); + } + return try_evaluate(compressor, self); + + function may_not_delete(node) { + return node instanceof AST_Infinity + || node instanceof AST_NaN + || node instanceof AST_NewTarget + || node instanceof AST_PropAccess + || node instanceof AST_SymbolRef + || node instanceof AST_Undefined; + } + + function can_lift() { + switch (op) { + case "delete": + return !may_not_delete(exp.tail_node()); + case "typeof": + return !is_undeclared_ref(exp.tail_node()); + default: + return true; + } + } + }); + + OPT(AST_Await, function(self, compressor) { + if (!compressor.option("awaits")) return self; + if (compressor.option("sequences")) { + var seq = lift_sequence_in_expression(self, compressor); + if (seq !== self) return seq.optimize(compressor); + } + if (compressor.option("side_effects")) { + var exp = self.expression; + if (exp instanceof AST_Await) return exp.optimize(compressor); + if (exp instanceof AST_UnaryPrefix && exp.expression instanceof AST_Await) return exp.optimize(compressor); + for (var level = 0, node = self, parent; parent = compressor.parent(level++); node = parent) { + if (is_arrow(parent)) { + if (parent.value === node) return exp.optimize(compressor); + } else if (parent instanceof AST_Return) { + var drop = true; + do { + node = parent; + parent = compressor.parent(level++); + if (parent instanceof AST_Try && (parent.bfinally || parent.bcatch) !== node) { + drop = false; + break; + } + } while (parent && !(parent instanceof AST_Scope)); + if (drop) return exp.optimize(compressor); + } else if (parent instanceof AST_Sequence) { + if (parent.tail_node() === node) continue; + } + break; + } + } + return self; + }); + + OPT(AST_Yield, function(self, compressor) { + if (!compressor.option("yields")) return self; + if (compressor.option("sequences")) { + var seq = lift_sequence_in_expression(self, compressor); + if (seq !== self) return seq.optimize(compressor); + } + var exp = self.expression; + if (self.nested && exp.TYPE == "Call") { + var inlined = exp.clone().optimize(compressor); + if (inlined.TYPE != "Call") return inlined; + } + return self; + }); + + AST_Binary.DEFMETHOD("lift_sequences", function(compressor) { + if (this.left instanceof AST_PropAccess) { + if (!(this.left.expression instanceof AST_Sequence)) return this; + var x = this.left.expression.expressions.slice(); + var e = this.clone(); + e.left = e.left.clone(); + e.left.expression = x.pop(); + x.push(e); + return make_sequence(this, x); + } + if (this.left instanceof AST_Sequence) { + var x = this.left.expressions.slice(); + var e = this.clone(); + e.left = x.pop(); + x.push(e); + return make_sequence(this, x); + } + if (this.right instanceof AST_Sequence) { + if (this.left.has_side_effects(compressor)) return this; + var assign = this.operator == "=" && this.left instanceof AST_SymbolRef; + var x = this.right.expressions; + var last = x.length - 1; + for (var i = 0; i < last; i++) { + if (!assign && x[i].has_side_effects(compressor)) break; + } + if (i == last) { + x = x.slice(); + var e = this.clone(); + e.right = x.pop(); + x.push(e); + return make_sequence(this, x); + } + if (i > 0) { + var e = this.clone(); + e.right = make_sequence(this.right, x.slice(i)); + x = x.slice(0, i); + x.push(e); + return make_sequence(this, x); + } + } + return this; + }); + + var indexFns = makePredicate("indexOf lastIndexOf"); + var commutativeOperators = makePredicate("== === != !== * & | ^"); + function is_object(node, plain) { + if (node instanceof AST_Assign) return !plain && node.operator == "=" && is_object(node.right); + if (node instanceof AST_New) return !plain; + if (node instanceof AST_Sequence) return is_object(node.tail_node(), plain); + if (node instanceof AST_SymbolRef) return !plain && is_object(node.fixed_value()); + return node instanceof AST_Array + || node instanceof AST_Class + || node instanceof AST_Lambda + || node instanceof AST_Object; + } + + function can_drop_op(node, compressor) { + var rhs = node.right; + switch (node.operator) { + case "in": + return is_object(rhs) || compressor && compressor.option("unsafe_comps"); + case "instanceof": + if (rhs instanceof AST_SymbolRef) rhs = rhs.fixed_value(); + if (rhs instanceof AST_Defun || rhs instanceof AST_Function || is_generator(rhs)) return true; + if (is_lambda(rhs) && node.left.is_constant()) return true; + return compressor && compressor.option("unsafe_comps"); + default: + return true; + } + } + + function needs_enqueuing(compressor, node) { + if (node.is_constant()) return true; + if (node instanceof AST_Assign) return node.operator != "=" || needs_enqueuing(compressor, node.right); + if (node instanceof AST_Binary) { + return !lazy_op[node.operator] + || needs_enqueuing(compressor, node.left) && needs_enqueuing(compressor, node.right); + } + if (node instanceof AST_Call) { + if (!is_async(node.expression)) return false; + var has_await = false; + walk_body(node.expression, new TreeWalker(function(expr) { + if (has_await) return true; + if (expr instanceof AST_Await) return has_await = true; + if (expr !== node && expr instanceof AST_Scope) return true; + })); + return !has_await; + } + if (node instanceof AST_Conditional) { + return needs_enqueuing(compressor, node.consequent) && needs_enqueuing(compressor, node.alternative); + } + if (node instanceof AST_Sequence) return needs_enqueuing(compressor, node.tail_node()); + if (node instanceof AST_SymbolRef) { + var fixed = node.fixed_value(); + return fixed && needs_enqueuing(compressor, fixed); + } + if (node instanceof AST_Template) return !node.tag || is_raw_tag(compressor, node.tag); + if (node instanceof AST_Unary) return true; + } + + function extract_lhs(node, compressor) { + if (node instanceof AST_Assign) return is_lhs_read_only(node.left, compressor) ? node : node.left; + if (node instanceof AST_Sequence) return extract_lhs(node.tail_node(), compressor); + if (node instanceof AST_UnaryPrefix && UNARY_POSTFIX[node.operator]) { + return is_lhs_read_only(node.expression, compressor) ? node : node.expression; + } + return node; + } + + function repeatable(compressor, node) { + if (node instanceof AST_Dot) return repeatable(compressor, node.expression); + if (node instanceof AST_Sub) { + return repeatable(compressor, node.expression) && repeatable(compressor, node.property); + } + if (node instanceof AST_Symbol) return true; + return !node.has_side_effects(compressor); + } + + function swap_chain(self, compressor) { + var rhs = self.right.tail_node(); + if (rhs !== self.right) { + var exprs = self.right.expressions.slice(0, -1); + exprs.push(rhs.left); + rhs = rhs.clone(); + rhs.left = make_sequence(self.right, exprs); + self.right = rhs; + } + self.left = make_node(AST_Binary, self, { + operator: self.operator, + left: self.left, + right: rhs.left, + start: self.left.start, + end: rhs.left.end, + }); + self.right = rhs.right; + if (compressor) { + var left = self.left.transform(compressor); + if (left !== self.left) { + self = self.clone(); + self.left = left; + } + return self; + } + if (self.operator == rhs.left.operator) swap_chain(self.left); + } + + OPT(AST_Binary, function(self, compressor) { + if (commutativeOperators[self.operator] + && self.right.is_constant() + && !self.left.is_constant() + && !(self.left instanceof AST_Binary + && PRECEDENCE[self.left.operator] >= PRECEDENCE[self.operator])) { + // if right is a constant, whatever side effects the + // left side might have could not influence the + // result. hence, force switch. + reverse(); + } + if (compressor.option("sequences")) { + var seq = self.lift_sequences(compressor); + if (seq !== self) return seq.optimize(compressor); + } + if (compressor.option("assignments") && lazy_op[self.operator]) { + var lhs = extract_lhs(self.left, compressor); + var right = self.right; + // a || (a = x) ---> a = a || x + // (a = x) && (a = y) ---> a = (a = x) && y + if (lhs instanceof AST_SymbolRef + && right instanceof AST_Assign + && right.operator == "=" + && lhs.equals(right.left)) { + lhs = lhs.clone(); + var assign = make_node(AST_Assign, self, { + operator: "=", + left: lhs, + right: make_node(AST_Binary, self, { + operator: self.operator, + left: self.left, + right: right.right, + }), + }); + if (lhs.fixed) { + lhs.fixed = function() { + return assign.right; + }; + lhs.fixed.assigns = [ assign ]; + } + var def = lhs.definition(); + def.references.push(lhs); + def.replaced++; + return assign.optimize(compressor); + } + } + if (compressor.option("comparisons")) switch (self.operator) { + case "===": + case "!==": + if (is_undefined(self.left, compressor) && self.right.is_defined(compressor)) { + AST_Node.warn("Expression always defined [{start}]", self); + return make_sequence(self, [ + self.right, + make_node(self.operator == "===" ? AST_False : AST_True, self), + ]).optimize(compressor); + } + var is_strict_comparison = true; + if ((self.left.is_string(compressor) && self.right.is_string(compressor)) || + (self.left.is_number(compressor) && self.right.is_number(compressor)) || + (self.left.is_boolean(compressor) && self.right.is_boolean(compressor)) || + repeatable(compressor, self.left) && self.left.equals(self.right)) { + self.operator = self.operator.slice(0, 2); + } + // XXX: intentionally falling down to the next case + case "==": + case "!=": + // void 0 == x ---> null == x + if (!is_strict_comparison && is_undefined(self.left, compressor)) { + self.left = make_node(AST_Null, self.left); + } + // "undefined" == typeof x ---> undefined === x + else if (compressor.option("typeofs") + && self.left instanceof AST_String + && self.left.value == "undefined" + && self.right instanceof AST_UnaryPrefix + && self.right.operator == "typeof") { + var expr = self.right.expression; + if (expr instanceof AST_SymbolRef ? expr.is_declared(compressor) + : !(expr instanceof AST_PropAccess && compressor.option("ie"))) { + self.right = expr; + self.left = make_node(AST_Undefined, self.left).optimize(compressor); + if (self.operator.length == 2) self.operator += "="; + } + } + // obj !== obj ---> false + else if (self.left instanceof AST_SymbolRef + && self.right instanceof AST_SymbolRef + && self.left.definition() === self.right.definition() + && is_object(self.left)) { + return make_node(self.operator[0] == "=" ? AST_True : AST_False, self).optimize(compressor); + } + break; + case "&&": + case "||": + // void 0 !== x && null !== x ---> null != x + // void 0 === x.a || null === x.a ---> null == x.a + var left = self.left; + if (left.inlined_node) left = left.inlined_node; + if (!(left instanceof AST_Binary)) break; + if (left.operator != (self.operator == "&&" ? "!==" : "===")) break; + var right = self.right; + if (right.inlined_node) right = right.inlined_node; + if (!(right instanceof AST_Binary)) break; + if (left.operator != right.operator) break; + if (is_undefined(left.left, compressor) && right.left instanceof AST_Null + || left.left instanceof AST_Null && is_undefined(right.left, compressor)) { + var expr = extract_lhs(left.right, compressor); + if (!repeatable(compressor, expr)) break; + if (!expr.equals(right.right)) break; + left.operator = left.operator.slice(0, -1); + left.left = make_node(AST_Null, self); + return left; + } + break; + } + var in_bool = false; + var parent = compressor.parent(); + if (compressor.option("booleans")) { + var lhs = extract_lhs(self.left, compressor); + if (lazy_op[self.operator] && repeatable(compressor, lhs)) { + // a || a ---> a + // (a = x) && a --> a = x + if (lhs.equals(self.right)) { + return maintain_this_binding(parent, compressor.self(), self.left).optimize(compressor); + } + mark_duplicate_condition(compressor, lhs); + } + in_bool = compressor.in_boolean_context(); + } + if (in_bool) switch (self.operator) { + case "+": + var ev = self.left.evaluate(compressor, true); + if (ev && typeof ev == "string" || (ev = self.right.evaluate(compressor, true)) && typeof ev == "string") { + AST_Node.warn("+ in boolean context always true [{start}]", self); + var exprs = []; + if (self.left.evaluate(compressor) instanceof AST_Node) exprs.push(self.left); + if (self.right.evaluate(compressor) instanceof AST_Node) exprs.push(self.right); + switch (exprs.length) { + case 0: + return make_node(AST_True, self).optimize(compressor); + case 1: + exprs[0] = exprs[0].clone(); + exprs.push(make_node(AST_True, self)); + return make_sequence(self, exprs).optimize(compressor); + } + self.truthy = true; + } + break; + case "==": + if (self.left instanceof AST_String && self.left.value == "" && self.right.is_string(compressor)) { + return make_node(AST_UnaryPrefix, self, { + operator: "!", + expression: self.right, + }).optimize(compressor); + } + break; + case "!=": + if (self.left instanceof AST_String && self.left.value == "" && self.right.is_string(compressor)) { + return self.right.optimize(compressor); + } + break; + } + if (compressor.option("comparisons") && self.is_boolean(compressor)) { + if (parent.TYPE != "Binary") { + var negated = make_node(AST_UnaryPrefix, self, { + operator: "!", + expression: self.negate(compressor), + }); + if (best_of(compressor, self, negated) === negated) return negated; + } + switch (self.operator) { + case ">": reverse("<"); break; + case ">=": reverse("<="); break; + } + } + if (compressor.option("conditionals") && lazy_op[self.operator]) { + if (self.left instanceof AST_Binary && self.operator == self.left.operator) { + var before = make_node(AST_Binary, self, { + operator: self.operator, + left: self.left.right, + right: self.right, + }); + var after = before.transform(compressor); + if (before !== after) { + self.left = self.left.left; + self.right = after; + } + } + // x && (y && z) ---> x && y && z + // w || (x, y || z) ---> w || (x, y) || z + var rhs = self.right.tail_node(); + if (rhs instanceof AST_Binary && self.operator == rhs.operator) self = swap_chain(self, compressor); + } + if (compressor.option("strings") && self.operator == "+") { + // "foo" + 42 + "" ---> "foo" + 42 + if (self.right instanceof AST_String + && self.right.value == "" + && self.left.is_string(compressor)) { + return self.left.optimize(compressor); + } + // "" + ("foo" + 42) ---> "foo" + 42 + if (self.left instanceof AST_String + && self.left.value == "" + && self.right.is_string(compressor)) { + return self.right.optimize(compressor); + } + // "" + 42 + "foo" ---> 42 + "foo" + if (self.left instanceof AST_Binary + && self.left.operator == "+" + && self.left.left instanceof AST_String + && self.left.left.value == "" + && self.right.is_string(compressor) + && (self.left.right.is_constant() || !self.right.has_side_effects(compressor))) { + self.left = self.left.right; + return self.optimize(compressor); + } + // "x" + (y + "z") ---> "x" + y + "z" + // w + (x, "y" + z) ---> w + (x, "y") + z + var rhs = self.right.tail_node(); + if (rhs instanceof AST_Binary + && self.operator == rhs.operator + && (self.left.is_string(compressor) && rhs.is_string(compressor) + || rhs.left.is_string(compressor) + && (self.left.is_constant() || !rhs.right.has_side_effects(compressor)))) { + self = swap_chain(self, compressor); + } + } + if (compressor.option("evaluate")) { + var associative = true; + switch (self.operator) { + case "&&": + var ll = fuzzy_eval(compressor, self.left); + if (!ll) { + AST_Node.warn("Condition left of && always false [{start}]", self); + return maintain_this_binding(parent, compressor.self(), self.left).optimize(compressor); + } else if (!(ll instanceof AST_Node)) { + AST_Node.warn("Condition left of && always true [{start}]", self); + return make_sequence(self, [ self.left, self.right ]).optimize(compressor); + } + if (!self.right.evaluate(compressor, true)) { + if (in_bool && !(self.right.evaluate(compressor) instanceof AST_Node)) { + AST_Node.warn("Boolean && always false [{start}]", self); + return make_sequence(self, [ self.left, make_node(AST_False, self) ]).optimize(compressor); + } else self.falsy = true; + } else if ((in_bool || parent.operator == "&&" && parent.left === compressor.self()) + && !(self.right.evaluate(compressor) instanceof AST_Node)) { + AST_Node.warn("Dropping side-effect-free && [{start}]", self); + return self.left.optimize(compressor); + } + // (x || false) && y ---> x ? y : false + if (self.left.operator == "||") { + var lr = fuzzy_eval(compressor, self.left.right); + if (!lr) return make_node(AST_Conditional, self, { + condition: self.left.left, + consequent: self.right, + alternative: self.left.right, + }).optimize(compressor); + } + break; + case "??": + var nullish = true; + case "||": + var ll = fuzzy_eval(compressor, self.left, nullish); + if (nullish ? ll == null : !ll) { + AST_Node.warn("Condition left of {operator} always {value} [{start}]", { + operator: self.operator, + value: nullish ? "nullish" : "false", + start: self.start, + }); + return make_sequence(self, [ self.left, self.right ]).optimize(compressor); + } else if (!(ll instanceof AST_Node)) { + AST_Node.warn("Condition left of {operator} always {value} [{start}]", { + operator: self.operator, + value: nullish ? "defined" : "true", + start: self.start, + }); + return maintain_this_binding(parent, compressor.self(), self.left).optimize(compressor); + } + var rr; + if (!nullish && (rr = self.right.evaluate(compressor, true)) && !(rr instanceof AST_Node)) { + if (in_bool && !(self.right.evaluate(compressor) instanceof AST_Node)) { + AST_Node.warn("Boolean || always true [{start}]", self); + return make_sequence(self, [ self.left, make_node(AST_True, self) ]).optimize(compressor); + } else self.truthy = true; + } else if ((in_bool || parent.operator == "||" && parent.left === compressor.self()) + && !self.right.evaluate(compressor)) { + AST_Node.warn("Dropping side-effect-free {operator} [{start}]", self); + return self.left.optimize(compressor); + } + // x && true || y ---> x ? true : y + if (!nullish && self.left.operator == "&&") { + var lr = fuzzy_eval(compressor, self.left.right); + if (lr && !(lr instanceof AST_Node)) return make_node(AST_Conditional, self, { + condition: self.left.left, + consequent: self.left.right, + alternative: self.right, + }).optimize(compressor); + } + break; + case "+": + // "foo" + ("bar" + x) ---> "foobar" + x + if (self.left instanceof AST_Constant + && self.right instanceof AST_Binary + && self.right.operator == "+" + && self.right.left instanceof AST_Constant + && self.right.is_string(compressor)) { + self = make_node(AST_Binary, self, { + operator: "+", + left: make_node(AST_String, self.left, { + value: "" + self.left.value + self.right.left.value, + start: self.left.start, + end: self.right.left.end, + }), + right: self.right.right, + }); + } + // (x + "foo") + "bar" ---> x + "foobar" + if (self.right instanceof AST_Constant + && self.left instanceof AST_Binary + && self.left.operator == "+" + && self.left.right instanceof AST_Constant + && self.left.is_string(compressor)) { + self = make_node(AST_Binary, self, { + operator: "+", + left: self.left.left, + right: make_node(AST_String, self.right, { + value: "" + self.left.right.value + self.right.value, + start: self.left.right.start, + end: self.right.end, + }), + }); + } + // a + -b ---> a - b + if (self.right instanceof AST_UnaryPrefix + && self.right.operator == "-" + && self.left.is_number(compressor)) { + self = make_node(AST_Binary, self, { + operator: "-", + left: self.left, + right: self.right.expression, + }); + break; + } + // -a + b ---> b - a + if (self.left instanceof AST_UnaryPrefix + && self.left.operator == "-" + && reversible() + && self.right.is_number(compressor)) { + self = make_node(AST_Binary, self, { + operator: "-", + left: self.right, + right: self.left.expression, + }); + break; + } + // (a + b) + 3 ---> 3 + (a + b) + if (compressor.option("unsafe_math") + && self.left instanceof AST_Binary + && PRECEDENCE[self.left.operator] == PRECEDENCE[self.operator] + && self.right.is_constant() + && (self.right.is_boolean(compressor) || self.right.is_number(compressor)) + && self.left.is_number(compressor) + && !self.left.right.is_constant() + && (self.left.left.is_boolean(compressor) || self.left.left.is_number(compressor))) { + self = make_node(AST_Binary, self, { + operator: self.left.operator, + left: make_node(AST_Binary, self, { + operator: self.operator, + left: self.right, + right: self.left.left, + }), + right: self.left.right, + }); + break; + } + case "-": + // a - -b ---> a + b + if (self.right instanceof AST_UnaryPrefix + && self.right.operator == "-" + && self.left.is_number(compressor) + && self.right.expression.is_number(compressor)) { + self = make_node(AST_Binary, self, { + operator: "+", + left: self.left, + right: self.right.expression, + }); + break; + } + case "*": + case "/": + associative = compressor.option("unsafe_math"); + // +a - b ---> a - b + // a - +b ---> a - b + if (self.operator != "+") [ "left", "right" ].forEach(function(operand) { + var node = self[operand]; + if (node instanceof AST_UnaryPrefix && node.operator == "+") { + var exp = node.expression; + if (exp.is_boolean(compressor) || exp.is_number(compressor) || exp.is_string(compressor)) { + self[operand] = exp; + } + } + }); + case "&": + case "|": + case "^": + // a + +b ---> +b + a + if (self.operator != "-" + && self.operator != "/" + && (self.left.is_boolean(compressor) || self.left.is_number(compressor)) + && (self.right.is_boolean(compressor) || self.right.is_number(compressor)) + && reversible() + && !(self.left instanceof AST_Binary + && self.left.operator != self.operator + && PRECEDENCE[self.left.operator] >= PRECEDENCE[self.operator])) { + self = best_of(compressor, self, make_node(AST_Binary, self, { + operator: self.operator, + left: self.right, + right: self.left, + }), self.right instanceof AST_Constant && !(self.left instanceof AST_Constant)); + } + if (!associative || !self.is_number(compressor)) break; + // a + (b + c) ---> (a + b) + c + if (self.right instanceof AST_Binary + && self.right.operator != "%" + && PRECEDENCE[self.right.operator] == PRECEDENCE[self.operator] + && self.right.is_number(compressor) + && (self.operator != "+" + || self.right.left.is_boolean(compressor) + || self.right.left.is_number(compressor)) + && (self.operator != "-" || !self.left.is_negative_zero()) + && (self.right.left.is_constant_expression() + || !self.right.right.has_side_effects(compressor)) + && !is_modify_array(self.right.right)) { + self = make_node(AST_Binary, self, { + operator: align(self.operator, self.right.operator), + left: make_node(AST_Binary, self.left, { + operator: self.operator, + left: self.left, + right: self.right.left, + start: self.left.start, + end: self.right.left.end, + }), + right: self.right.right, + }); + if (self.operator == "+" + && !self.right.is_boolean(compressor) + && !self.right.is_number(compressor)) { + self.right = make_node(AST_UnaryPrefix, self.right, { + operator: "+", + expression: self.right, + }); + } + } + // (2 * n) * 3 ---> 6 * n + // (n + 2) + 3 ---> n + 5 + if (self.right instanceof AST_Constant + && self.left instanceof AST_Binary + && self.left.operator != "%" + && PRECEDENCE[self.left.operator] == PRECEDENCE[self.operator] + && self.left.is_number(compressor)) { + if (self.left.left instanceof AST_Constant) { + var lhs = make_binary(self.operator, self.left.left, self.right, { + start: self.left.left.start, + end: self.right.end, + }); + self = make_binary(self.left.operator, try_evaluate(compressor, lhs), self.left.right, self); + } else if (self.left.right instanceof AST_Constant) { + var op = align(self.left.operator, self.operator); + var rhs = try_evaluate(compressor, make_binary(op, self.left.right, self.right, self.left)); + if (rhs.is_constant() + && !(self.left.operator == "-" + && self.right.value != 0 + && +rhs.value == 0 + && self.left.left.is_negative_zero())) { + self = make_binary(self.left.operator, self.left.left, rhs, self); + } + } + } + break; + case "instanceof": + if (!can_drop_op(self, compressor)) break; + if (is_lambda(self.right)) return make_sequence(self, [ + self.left, + self.right, + make_node(AST_False, self), + ]).optimize(compressor); + break; + } + if (!(parent instanceof AST_UnaryPrefix && parent.operator == "delete")) { + if (self.left instanceof AST_Number && !self.right.is_constant()) switch (self.operator) { + // 0 + n ---> n + case "+": + if (self.left.value == 0) { + if (self.right.is_boolean(compressor)) return make_node(AST_UnaryPrefix, self, { + operator: "+", + expression: self.right, + }).optimize(compressor); + if (self.right.is_number(compressor) && !self.right.is_negative_zero()) return self.right; + } + break; + // 1 * n ---> n + case "*": + if (self.left.value == 1) return make_node(AST_UnaryPrefix, self, { + operator: "+", + expression: self.right, + }).optimize(compressor); + break; + } + if (self.right instanceof AST_Number && !self.left.is_constant()) switch (self.operator) { + // n + 0 ---> n + case "+": + if (self.right.value == 0) { + if (self.left.is_boolean(compressor)) return make_node(AST_UnaryPrefix, self, { + operator: "+", + expression: self.left, + }).optimize(compressor); + if (self.left.is_number(compressor) && !self.left.is_negative_zero()) return self.left; + } + break; + // n - 0 ---> n + case "-": + if (self.right.value == 0) return make_node(AST_UnaryPrefix, self, { + operator: "+", + expression: self.left, + }).optimize(compressor); + break; + // n / 1 ---> n + case "/": + if (self.right.value == 1) return make_node(AST_UnaryPrefix, self, { + operator: "+", + expression: self.left, + }).optimize(compressor); + break; + } + } + } + if (compressor.option("typeofs")) switch (self.operator) { + case "&&": + mark_locally_defined(self.left, self.right, null); + break; + case "||": + mark_locally_defined(self.left, null, self.right); + break; + } + if (compressor.option("unsafe")) { + var indexRight = is_indexFn(self.right); + if (in_bool + && indexRight + && (self.operator == "==" || self.operator == "!=") + && self.left instanceof AST_Number + && self.left.value == 0) { + return (self.operator == "==" ? make_node(AST_UnaryPrefix, self, { + operator: "!", + expression: self.right, + }) : self.right).optimize(compressor); + } + var indexLeft = is_indexFn(self.left); + if (compressor.option("comparisons") && is_indexOf_match_pattern()) { + var node = make_node(AST_UnaryPrefix, self, { + operator: "!", + expression: make_node(AST_UnaryPrefix, self, { + operator: "~", + expression: indexLeft ? self.left : self.right, + }), + }); + switch (self.operator) { + case "<": + if (indexLeft) break; + case "<=": + case "!=": + node = make_node(AST_UnaryPrefix, self, { + operator: "!", + expression: node, + }); + break; + } + return node.optimize(compressor); + } + } + return try_evaluate(compressor, self); + + function is_modify_array(node) { + var found = false; + node.walk(new TreeWalker(function(node) { + if (found) return true; + if (node instanceof AST_Assign) { + if (node.left instanceof AST_PropAccess) return found = true; + } else if (node instanceof AST_Unary) { + if (unary_side_effects[node.operator] && node.expression instanceof AST_PropAccess) { + return found = true; + } + } + })); + return found; + } + + function align(ref, op) { + switch (ref) { + case "-": + return op == "+" ? "-" : "+"; + case "/": + return op == "*" ? "/" : "*"; + default: + return op; + } + } + + function make_binary(op, left, right, orig) { + if (op == "+") { + if (!left.is_boolean(compressor) && !left.is_number(compressor)) { + left = make_node(AST_UnaryPrefix, left, { + operator: "+", + expression: left, + }); + } + if (!right.is_boolean(compressor) && !right.is_number(compressor)) { + right = make_node(AST_UnaryPrefix, right, { + operator: "+", + expression: right, + }); + } + } + return make_node(AST_Binary, orig, { + operator: op, + left: left, + right: right, + }); + } + + function is_indexFn(node) { + while (node instanceof AST_Assign && node.operator == "=") node = node.right; + return node.TYPE == "Call" + && node.expression instanceof AST_Dot + && indexFns[node.expression.property]; + } + + function is_indexOf_match_pattern() { + switch (self.operator) { + case "<=": + // 0 <= array.indexOf(string) ---> !!~array.indexOf(string) + return indexRight && self.left instanceof AST_Number && self.left.value == 0; + case "<": + // array.indexOf(string) < 0 ---> !~array.indexOf(string) + if (indexLeft && self.right instanceof AST_Number && self.right.value == 0) return true; + // -1 < array.indexOf(string) ---> !!~array.indexOf(string) + case "==": + case "!=": + // -1 == array.indexOf(string) ---> !~array.indexOf(string) + // -1 != array.indexOf(string) ---> !!~array.indexOf(string) + if (!indexRight) return false; + return self.left instanceof AST_Number && self.left.value == -1 + || self.left instanceof AST_UnaryPrefix && self.left.operator == "-" + && self.left.expression instanceof AST_Number && self.left.expression.value == 1; + } + } + + function reversible() { + return self.left.is_constant() + || self.right.is_constant() + || !self.left.has_side_effects(compressor) + && !self.right.has_side_effects(compressor); + } + + function reverse(op) { + if (reversible()) { + if (op) self.operator = op; + var tmp = self.left; + self.left = self.right; + self.right = tmp; + } + } + }); + + OPT(AST_SymbolExport, function(self) { + return self; + }); + + function recursive_ref(compressor, def, fn) { + var level = 0, node = compressor.self(); + do { + if (node === fn) return node; + if (is_lambda(node) && node.name && node.name.definition() === def) return node; + } while (node = compressor.parent(level++)); + } + + function same_scope(def) { + var scope = def.scope.resolve(); + return all(def.references, function(ref) { + return scope === ref.scope.resolve(); + }); + } + + OPT(AST_SymbolRef, function(self, compressor) { + if (!compressor.option("ie") + && is_undeclared_ref(self) + // testing against `self.scope.uses_with` is an optimization + && !(self.scope.resolve().uses_with && compressor.find_parent(AST_With))) { + switch (self.name) { + case "undefined": + return make_node(AST_Undefined, self).optimize(compressor); + case "NaN": + return make_node(AST_NaN, self).optimize(compressor); + case "Infinity": + return make_node(AST_Infinity, self).optimize(compressor); + } + } + var parent = compressor.parent(); + if (compressor.option("reduce_vars") && is_lhs(compressor.self(), parent) !== compressor.self()) { + var def = self.definition(); + var fixed = self.fixed_value(); + var single_use = def.single_use && !(parent instanceof AST_Call && parent.is_expr_pure(compressor)); + if (single_use) { + if (is_lambda(fixed)) { + if ((def.scope !== self.scope.resolve(true) || def.in_loop) + && (!compressor.option("reduce_funcs") || def.escaped.depth == 1 || fixed.inlined)) { + single_use = false; + } else if (def.redefined()) { + single_use = false; + } else if (recursive_ref(compressor, def, fixed)) { + single_use = false; + } else if (fixed.name && fixed.name.definition() !== def) { + single_use = false; + } else if (fixed.parent_scope !== self.scope || is_funarg(def)) { + if (!safe_from_strict_mode(fixed, compressor)) { + single_use = false; + } else if ((single_use = fixed.is_constant_expression(self.scope)) == "f") { + var scope = self.scope; + do { + if (scope instanceof AST_LambdaDefinition || scope instanceof AST_LambdaExpression) { + scope.inlined = true; + } + } while (scope = scope.parent_scope); + } + } else if (fixed.name && (fixed.name.name == "await" && is_async(fixed) + || fixed.name.name == "yield" && is_generator(fixed))) { + single_use = false; + } else if (fixed.has_side_effects(compressor)) { + single_use = false; + } else if (fixed instanceof AST_Class + && (compressor.option("ie") || !fixed.is_constant_expression(self.scope))) { + single_use = false; + } + if (single_use) fixed.parent_scope = self.scope; + } else if (!fixed + || def.recursive_refs > 0 + || !fixed.is_constant_expression() + || fixed.drop_side_effect_free(compressor)) { + single_use = false; + } + } + if (single_use) { + def.single_use = false; + fixed._squeezed = true; + fixed.single_use = true; + if (fixed instanceof AST_DefClass) fixed = to_class_expr(fixed); + if (fixed instanceof AST_LambdaDefinition) fixed = to_func_expr(fixed); + if (is_lambda(fixed)) { + var scopes = []; + var scope = self.scope; + do { + scopes.push(scope); + if (scope === def.scope) break; + } while (scope = scope.parent_scope); + fixed.enclosed.forEach(function(def) { + if (fixed.variables.has(def.name)) return; + for (var i = 0; i < scopes.length; i++) { + var scope = scopes[i]; + if (!push_uniq(scope.enclosed, def)) return; + scope.var_names().set(def.name, true); + } + }); + } + var value; + if (def.recursive_refs > 0) { + value = fixed.clone(true); + var defun_def = value.name.definition(); + var lambda_def = value.variables.get(value.name.name); + var name = lambda_def && lambda_def.orig[0]; + var def_fn_name, symbol_type; + if (value instanceof AST_Class) { + def_fn_name = "def_function"; + symbol_type = AST_SymbolClass; + } else { + def_fn_name = "def_variable"; + symbol_type = AST_SymbolLambda; + } + if (!(name instanceof symbol_type)) { + name = make_node(symbol_type, value.name); + name.scope = value; + value.name = name; + lambda_def = value[def_fn_name](name); + lambda_def.recursive_refs = def.recursive_refs; + } + value.walk(new TreeWalker(function(node) { + if (node instanceof AST_SymbolDeclaration) { + if (node !== name) { + var def = node.definition(); + def.orig.push(node); + def.eliminated++; + } + return; + } + if (!(node instanceof AST_SymbolRef)) return; + var def = node.definition(); + if (def === defun_def) { + node.thedef = def = lambda_def; + } else { + def.single_use = false; + var fn = node.fixed_value(); + if (is_lambda(fn) + && fn.name + && fn.name.definition() === def + && def.scope === fn.name.scope + && fixed.variables.get(fn.name.name) === def) { + fn.name = fn.name.clone(); + node.thedef = def = value.variables.get(fn.name.name) || value[def_fn_name](fn.name); + } + } + def.references.push(node); + })); + } else { + if (fixed instanceof AST_Scope) { + compressor.push(fixed); + value = fixed.optimize(compressor); + compressor.pop(); + } else { + value = fixed.optimize(compressor); + } + value = value.transform(new TreeTransformer(function(node, descend) { + if (node instanceof AST_Scope) return node; + node = node.clone(); + descend(node, this); + return node; + })); + } + def.replaced++; + return value; + } + var state; + if (fixed && (state = self.fixed || def.fixed).should_replace !== false) { + var ev, init; + if (fixed instanceof AST_This) { + if (!is_funarg(def) && same_scope(def) && !cross_class(def)) init = fixed; + } else if ((ev = fixed.evaluate(compressor, true)) !== fixed + && typeof ev != "function" + && (ev === null + || typeof ev != "object" + || compressor.option("unsafe_regexp") + && ev instanceof RegExp && !def.cross_loop && same_scope(def))) { + init = make_node_from_constant(ev, fixed); + } + if (init) { + if (state.should_replace === undefined) { + var value_length = init.optimize(compressor).print_to_string().length; + if (!has_symbol_ref(fixed)) { + value_length = Math.min(value_length, fixed.print_to_string().length); + } + var name_length = def.name.length; + if (compressor.option("unused") && !compressor.exposed(def)) { + var refs = def.references.length - def.replaced - def.assignments; + refs = Math.min(refs, def.references.filter(function(ref) { + return ref.fixed === state; + }).length); + name_length += (name_length + 2 + value_length) / Math.max(1, refs); + } + state.should_replace = value_length - Math.floor(name_length) < compressor.eval_threshold; + } + if (state.should_replace) { + var value; + if (has_symbol_ref(fixed)) { + value = init.optimize(compressor); + if (value === init) value = value.clone(true); + } else { + value = best_of_expression(init.optimize(compressor), fixed); + if (value === init || value === fixed) value = value.clone(true); + } + def.replaced++; + return value; + } + } + } + } + return self; + + function cross_class(def) { + var scope = self.scope; + while (scope !== def.scope) { + if (scope instanceof AST_Class) return true; + scope = scope.parent_scope; + } + } + + function has_symbol_ref(value) { + var found; + value.walk(new TreeWalker(function(node) { + if (node instanceof AST_SymbolRef) found = true; + if (found) return true; + })); + return found; + } + }); + + function is_raw_tag(compressor, tag) { + return compressor.option("unsafe") + && tag instanceof AST_Dot + && tag.property == "raw" + && is_undeclared_ref(tag.expression) + && tag.expression.name == "String"; + } + + function decode_template(str) { + var malformed = false; + str = str.replace(/\\(u\{[^{}]*\}?|u[\s\S]{0,4}|x[\s\S]{0,2}|[0-9]+|[\s\S])/g, function(match, seq) { + var ch = decode_escape_sequence(seq); + if (typeof ch == "string") return ch; + malformed = true; + }); + if (!malformed) return str; + } + + OPT(AST_Template, function(self, compressor) { + if (!compressor.option("templates")) return self; + var tag = self.tag; + if (!tag || is_raw_tag(compressor, tag)) { + var exprs = []; + var strs = []; + for (var i = 0, status; i < self.strings.length; i++) { + var str = self.strings[i]; + if (!tag) { + var trimmed = decode_template(str); + if (trimmed) str = escape_literal(trimmed); + } + if (i > 0) { + var node = self.expressions[i - 1]; + var value = should_join(node); + if (value) { + var prev = strs[strs.length - 1]; + var joined = prev + value + str; + var decoded; + if (tag || typeof (decoded = decode_template(joined)) == status) { + strs[strs.length - 1] = decoded ? escape_literal(decoded) : joined; + continue; + } + } + exprs.push(node); + } + strs.push(str); + if (!tag) status = typeof trimmed; + } + if (!tag && strs.length > 1) { + if (strs[strs.length - 1] == "") return make_node(AST_Binary, self, { + operator: "+", + left: make_node(AST_Template, self, { + expressions: exprs.slice(0, -1), + strings: strs.slice(0, -1), + }).transform(compressor), + right: exprs[exprs.length - 1], + }).optimize(compressor); + if (strs[0] == "") { + var left = make_node(AST_Binary, self, { + operator: "+", + left: make_node(AST_String, self, { value: "" }), + right: exprs[0], + }); + for (var i = 1; strs[i] == "" && i < exprs.length; i++) { + left = make_node(AST_Binary, self, { + operator: "+", + left: left, + right: exprs[i], + }); + } + return best_of(compressor, self, make_node(AST_Binary, self, { + operator: "+", + left: left.transform(compressor), + right: make_node(AST_Template, self, { + expressions: exprs.slice(i), + strings: strs.slice(i), + }).transform(compressor), + }).optimize(compressor)); + } + } + self.expressions = exprs; + self.strings = strs; + } + return try_evaluate(compressor, self); + + function escape_literal(str) { + return str.replace(/\r|\\|`|\${/g, function(s) { + return "\\" + (s == "\r" ? "r" : s); + }); + } + + function should_join(node) { + var ev = node.evaluate(compressor); + if (ev === node) return; + if (tag && /\r|\\|`/.test(ev)) return; + ev = escape_literal("" + ev); + if (ev.length > node.print_to_string().length + "${}".length) return; + return ev; + } + }); + + function is_atomic(lhs, self) { + return lhs instanceof AST_SymbolRef || lhs.TYPE === self.TYPE; + } + + OPT(AST_Undefined, function(self, compressor) { + if (compressor.option("unsafe_undefined")) { + var undef = find_scope(compressor).find_variable("undefined"); + if (undef) { + var ref = make_node(AST_SymbolRef, self, { + name: "undefined", + scope: undef.scope, + thedef: undef, + }); + ref.is_undefined = true; + return ref; + } + } + var lhs = is_lhs(compressor.self(), compressor.parent()); + if (lhs && is_atomic(lhs, self)) return self; + return make_node(AST_UnaryPrefix, self, { + operator: "void", + expression: make_node(AST_Number, self, { value: 0 }), + }); + }); + + OPT(AST_Infinity, function(self, compressor) { + var lhs = is_lhs(compressor.self(), compressor.parent()); + if (lhs && is_atomic(lhs, self)) return self; + if (compressor.option("keep_infinity") && !lhs && !find_scope(compressor).find_variable("Infinity")) { + return self; + } + return make_node(AST_Binary, self, { + operator: "/", + left: make_node(AST_Number, self, { value: 1 }), + right: make_node(AST_Number, self, { value: 0 }), + }); + }); + + OPT(AST_NaN, function(self, compressor) { + var lhs = is_lhs(compressor.self(), compressor.parent()); + if (lhs && is_atomic(lhs, self)) return self; + if (!lhs && !find_scope(compressor).find_variable("NaN")) return self; + return make_node(AST_Binary, self, { + operator: "/", + left: make_node(AST_Number, self, { value: 0 }), + right: make_node(AST_Number, self, { value: 0 }), + }); + }); + + function is_reachable(self, defs) { + var reachable = false; + var find_ref = new TreeWalker(function(node) { + if (reachable) return true; + if (node instanceof AST_SymbolRef && member(node.definition(), defs)) return reachable = true; + }); + var scan_scope = new TreeWalker(function(node) { + if (reachable) return true; + if (node instanceof AST_Lambda && node !== self) { + if (!(node.name || is_async(node) || is_generator(node))) { + var parent = scan_scope.parent(); + if (parent instanceof AST_Call && parent.expression === node) return; + } + node.walk(find_ref); + return true; + } + }); + self.walk(scan_scope); + return reachable; + } + + var ASSIGN_OPS = makePredicate("+ - * / % >> << >>> | ^ &"); + var ASSIGN_OPS_COMMUTATIVE = makePredicate("* | ^ &"); + OPT(AST_Assign, function(self, compressor) { + if (compressor.option("dead_code")) { + if (self.left instanceof AST_PropAccess) { + if (self.operator == "=") { + var exp = self.left.expression; + if (self.left.equals(self.right)) { + var defined = exp.defined; + exp.defined = false; + var drop_lhs = !self.left.has_side_effects(compressor); + exp.defined = defined; + if (drop_lhs) return self.right; + } + if (exp instanceof AST_Lambda + || !compressor.has_directive("use strict") + && exp instanceof AST_Constant + && !exp.may_throw_on_access(compressor)) { + var value = self.left instanceof AST_Dot ? self.right : make_sequence(self, [ + self.left.property, + self.right, + ]); + return maintain_this_binding(compressor.parent(), self, value).optimize(compressor); + } + } + } else if (self.left instanceof AST_SymbolRef && can_drop_symbol(self.left, compressor)) { + var parent; + if (self.operator == "=" && self.left.equals(self.right) + && !((parent = compressor.parent()) instanceof AST_UnaryPrefix && parent.operator == "delete")) { + return self.right; + } + if (self.left.is_immutable()) return strip_assignment(); + var def = self.left.definition(); + var scope = def.scope.resolve(); + var local = scope === compressor.find_parent(AST_Lambda); + var level = 0, node; + parent = compressor.self(); + if (!(scope.uses_arguments && is_funarg(def)) || compressor.has_directive("use strict")) do { + node = parent; + parent = compressor.parent(level++); + if (parent instanceof AST_Assign) { + if (parent.left instanceof AST_SymbolRef && parent.left.definition() === def) { + if (in_try(level, parent, !local)) break; + return strip_assignment(def); + } + if (parent.left.match_symbol(function(node) { + if (node instanceof AST_PropAccess) return true; + })) break; + continue; + } + if (parent instanceof AST_Exit) { + if (!local) break; + if (in_try(level, parent)) break; + if (is_reachable(scope, [ def ])) break; + return strip_assignment(def); + } + if (parent instanceof AST_SimpleStatement) { + if (!local) break; + if (is_reachable(scope, [ def ])) break; + var stat; + do { + stat = parent; + parent = compressor.parent(level++); + if (parent === scope && is_last_statement(parent.body, stat)) return strip_assignment(def); + } while (is_tail_block(stat, parent)); + break; + } + if (parent instanceof AST_VarDef) { + if (!(parent.name instanceof AST_SymbolDeclaration)) continue; + if (parent.name.definition() !== def) continue; + if (in_try(level, parent)) break; + return strip_assignment(def); + } + } while (is_tail(node, parent)); + } + } + if (compressor.option("sequences")) { + var seq = self.lift_sequences(compressor); + if (seq !== self) return seq.optimize(compressor); + } + if (compressor.option("assignments")) { + if (self.operator == "=" && self.left instanceof AST_SymbolRef && self.right instanceof AST_Binary) { + // x = expr1 OP expr2 + if (self.right.left instanceof AST_SymbolRef + && self.right.left.name == self.left.name + && ASSIGN_OPS[self.right.operator]) { + // x = x - 2 ---> x -= 2 + return make_compound(self.right.right); + } + if (self.right.right instanceof AST_SymbolRef + && self.right.right.name == self.left.name + && ASSIGN_OPS_COMMUTATIVE[self.right.operator] + && !self.right.left.has_side_effects(compressor)) { + // x = 2 & x ---> x &= 2 + return make_compound(self.right.left); + } + } + if ((self.operator == "-=" || self.operator == "+=" + && (self.left.is_boolean(compressor) || self.left.is_number(compressor))) + && self.right instanceof AST_Number + && self.right.value == 1) { + var op = self.operator.slice(0, -1); + return make_node(AST_UnaryPrefix, self, { + operator: op + op, + expression: self.left, + }); + } + } + return try_evaluate(compressor, self); + + function is_tail(node, parent) { + if (parent instanceof AST_Binary) switch (node) { + case parent.left: + return parent.right.is_constant_expression(scope); + case parent.right: + return true; + default: + return false; + } + if (parent instanceof AST_Conditional) switch (node) { + case parent.condition: + return parent.consequent.is_constant_expression(scope) + && parent.alternative.is_constant_expression(scope); + case parent.consequent: + case parent.alternative: + return true; + default: + return false; + } + if (parent instanceof AST_Sequence) { + var exprs = parent.expressions; + var stop = exprs.indexOf(node); + if (stop < 0) return false; + for (var i = exprs.length; --i > stop;) { + if (!exprs[i].is_constant_expression(scope)) return false; + } + return true; + } + return parent instanceof AST_UnaryPrefix; + } + + function is_tail_block(stat, parent) { + if (parent instanceof AST_BlockStatement) return is_last_statement(parent.body, stat); + if (parent instanceof AST_Catch) return is_last_statement(parent.body, stat); + if (parent instanceof AST_Finally) return is_last_statement(parent.body, stat); + if (parent instanceof AST_If) return parent.body === stat || parent.alternative === stat; + if (parent instanceof AST_Try) return parent.bfinally ? parent.bfinally === stat : parent.bcatch === stat; + } + + function in_try(level, node, sync) { + var right = self.right; + self.right = make_node(AST_Null, right); + var may_throw = node.may_throw(compressor); + self.right = right; + return find_try(compressor, level, node, scope, may_throw, sync); + } + + function make_compound(rhs) { + var fixed = self.left.fixed; + if (fixed) fixed.to_binary = replace_ref(function(node) { + return node.left; + }, fixed); + return make_node(AST_Assign, self, { + operator: self.right.operator + "=", + left: self.left, + right: rhs, + }); + } + + function strip_assignment(def) { + if (def) def.fixed = false; + return (self.operator != "=" ? make_node(AST_Binary, self, { + operator: self.operator.slice(0, -1), + left: self.left, + right: self.right, + }) : maintain_this_binding(compressor.parent(), self, self.right)).optimize(compressor); + } + }); + + OPT(AST_Conditional, function(self, compressor) { + if (compressor.option("sequences") && self.condition instanceof AST_Sequence) { + var expressions = self.condition.expressions.slice(); + var node = self.clone(); + node.condition = expressions.pop(); + expressions.push(node); + return make_sequence(self, expressions).optimize(compressor); + } + if (!compressor.option("conditionals")) return self; + var condition = self.condition; + if (compressor.option("booleans") && !condition.has_side_effects(compressor)) { + mark_duplicate_condition(compressor, condition); + } + condition = fuzzy_eval(compressor, condition); + if (!condition) { + AST_Node.warn("Condition always false [{start}]", self); + return make_sequence(self, [ self.condition, self.alternative ]).optimize(compressor); + } else if (!(condition instanceof AST_Node)) { + AST_Node.warn("Condition always true [{start}]", self); + return make_sequence(self, [ self.condition, self.consequent ]).optimize(compressor); + } + var first = first_in_statement(compressor); + var negated = condition.negate(compressor, first); + if ((first ? best_of_statement : best_of_expression)(condition, negated) === negated) { + self = make_node(AST_Conditional, self, { + condition: negated, + consequent: self.alternative, + alternative: self.consequent, + }); + negated = condition; + condition = self.condition; + } + var consequent = self.consequent; + var alternative = self.alternative; + var cond_lhs = extract_lhs(condition, compressor); + if (repeatable(compressor, cond_lhs)) { + // x ? x : y ---> x || y + if (cond_lhs.equals(consequent)) return make_node(AST_Binary, self, { + operator: "||", + left: condition, + right: alternative, + }).optimize(compressor); + // x ? y : x ---> x && y + if (cond_lhs.equals(alternative)) return make_node(AST_Binary, self, { + operator: "&&", + left: condition, + right: consequent, + }).optimize(compressor); + } + // if (foo) exp = something; else exp = something_else; + // | + // v + // exp = foo ? something : something_else; + var seq_tail = consequent.tail_node(); + if (seq_tail instanceof AST_Assign) { + var is_eq = seq_tail.operator == "="; + var alt_tail = is_eq ? alternative.tail_node() : alternative; + if ((is_eq || consequent === seq_tail) + && alt_tail instanceof AST_Assign + && seq_tail.operator == alt_tail.operator + && seq_tail.left.equals(alt_tail.left) + && (is_eq && seq_tail.left instanceof AST_SymbolRef + || !condition.has_side_effects(compressor) + && can_shift_lhs_of_tail(consequent) + && can_shift_lhs_of_tail(alternative))) { + return make_node(AST_Assign, self, { + operator: seq_tail.operator, + left: seq_tail.left, + right: make_node(AST_Conditional, self, { + condition: condition, + consequent: pop_lhs(consequent), + alternative: pop_lhs(alternative), + }), + }); + } + } + var alt_tail = alternative.tail_node(); + // x ? y : y ---> x, y + // x ? (a, c) : (b, c) ---> x ? a : b, c + if (seq_tail.equals(alt_tail)) return make_sequence(self, consequent.equals(alternative) ? [ + condition, + consequent, + ] : [ + make_node(AST_Conditional, self, { + condition: condition, + consequent: pop_seq(consequent), + alternative: pop_seq(alternative), + }), + alt_tail, + ]).optimize(compressor); + // x ? y.p : z.p ---> (x ? y : z).p + // x ? y(a) : z(a) ---> (x ? y : z)(a) + // x ? y.f(a) : z.f(a) ---> (x ? y : z).f(a) + var combined = combine_tail(consequent, alternative, true); + if (combined) return combined; + // x ? y(a) : y(b) ---> y(x ? a : b) + var arg_index; + if (consequent instanceof AST_Call + && alternative.TYPE == consequent.TYPE + && (arg_index = arg_diff(consequent, alternative)) >= 0 + && consequent.expression.equals(alternative.expression) + && !condition.has_side_effects(compressor) + && !consequent.expression.has_side_effects(compressor)) { + var node = consequent.clone(); + var arg = consequent.args[arg_index]; + node.args[arg_index] = arg instanceof AST_Spread ? make_node(AST_Spread, self, { + expression: make_node(AST_Conditional, self, { + condition: condition, + consequent: arg.expression, + alternative: alternative.args[arg_index].expression, + }), + }) : make_node(AST_Conditional, self, { + condition: condition, + consequent: arg, + alternative: alternative.args[arg_index], + }); + return node; + } + // x ? (y ? a : b) : b ---> x && y ? a : b + if (seq_tail instanceof AST_Conditional + && seq_tail.alternative.equals(alternative)) { + return make_node(AST_Conditional, self, { + condition: make_node(AST_Binary, self, { + left: condition, + operator: "&&", + right: fuse(consequent, seq_tail, "condition"), + }), + consequent: seq_tail.consequent, + alternative: merge_expression(seq_tail.alternative, alternative), + }); + } + // x ? (y ? a : b) : a ---> !x || y ? a : b + if (seq_tail instanceof AST_Conditional + && seq_tail.consequent.equals(alternative)) { + return make_node(AST_Conditional, self, { + condition: make_node(AST_Binary, self, { + left: negated, + operator: "||", + right: fuse(consequent, seq_tail, "condition"), + }), + consequent: merge_expression(seq_tail.consequent, alternative), + alternative: seq_tail.alternative, + }); + } + // x ? a : (y ? a : b) ---> x || y ? a : b + if (alt_tail instanceof AST_Conditional + && consequent.equals(alt_tail.consequent)) { + return make_node(AST_Conditional, self, { + condition: make_node(AST_Binary, self, { + left: condition, + operator: "||", + right: fuse(alternative, alt_tail, "condition"), + }), + consequent: merge_expression(consequent, alt_tail.consequent), + alternative: alt_tail.alternative, + }); + } + // x ? b : (y ? a : b) ---> !x && y ? a : b + if (alt_tail instanceof AST_Conditional + && consequent.equals(alt_tail.alternative)) { + return make_node(AST_Conditional, self, { + condition: make_node(AST_Binary, self, { + left: negated, + operator: "&&", + right: fuse(alternative, alt_tail, "condition"), + }), + consequent: alt_tail.consequent, + alternative: merge_expression(consequent, alt_tail.alternative), + }); + } + // x ? y && a : a ---> (!x || y) && a + if (seq_tail instanceof AST_Binary + && seq_tail.operator == "&&" + && seq_tail.right.equals(alternative)) { + return make_node(AST_Binary, self, { + operator: "&&", + left: make_node(AST_Binary, self, { + operator: "||", + left: negated, + right: fuse(consequent, seq_tail, "left"), + }), + right: merge_expression(seq_tail.right, alternative), + }).optimize(compressor); + } + // x ? y || a : a ---> x && y || a + if (seq_tail instanceof AST_Binary + && seq_tail.operator == "||" + && seq_tail.right.equals(alternative)) { + return make_node(AST_Binary, self, { + operator: "||", + left: make_node(AST_Binary, self, { + operator: "&&", + left: condition, + right: fuse(consequent, seq_tail, "left"), + }), + right: merge_expression(seq_tail.right, alternative), + }).optimize(compressor); + } + // x ? a : y && a ---> (x || y) && a + if (alt_tail instanceof AST_Binary + && alt_tail.operator == "&&" + && alt_tail.right.equals(consequent)) { + return make_node(AST_Binary, self, { + operator: "&&", + left: make_node(AST_Binary, self, { + operator: "||", + left: condition, + right: fuse(alternative, alt_tail, "left"), + }), + right: merge_expression(consequent, alt_tail.right), + }).optimize(compressor); + } + // x ? a : y || a ---> !x && y || a + if (alt_tail instanceof AST_Binary + && alt_tail.operator == "||" + && alt_tail.right.equals(consequent)) { + return make_node(AST_Binary, self, { + operator: "||", + left: make_node(AST_Binary, self, { + operator: "&&", + left: negated, + right: fuse(alternative, alt_tail, "left"), + }), + right: merge_expression(consequent, alt_tail.right), + }).optimize(compressor); + } + var in_bool = compressor.option("booleans") && compressor.in_boolean_context(); + if (is_true(consequent)) { + // c ? true : false ---> !!c + if (is_false(alternative)) return booleanize(condition); + // c ? true : x ---> !!c || x + return make_node(AST_Binary, self, { + operator: "||", + left: booleanize(condition), + right: alternative, + }).optimize(compressor); + } + if (is_false(consequent)) { + // c ? false : true ---> !c + if (is_true(alternative)) return booleanize(condition.negate(compressor)); + // c ? false : x ---> !c && x + return make_node(AST_Binary, self, { + operator: "&&", + left: booleanize(condition.negate(compressor)), + right: alternative, + }).optimize(compressor); + } + // c ? x : true ---> !c || x + if (is_true(alternative)) return make_node(AST_Binary, self, { + operator: "||", + left: booleanize(condition.negate(compressor)), + right: consequent, + }).optimize(compressor); + // c ? x : false ---> !!c && x + if (is_false(alternative)) return make_node(AST_Binary, self, { + operator: "&&", + left: booleanize(condition), + right: consequent, + }).optimize(compressor); + if (compressor.option("typeofs")) mark_locally_defined(condition, consequent, alternative); + return self; + + function booleanize(node) { + if (node.is_boolean(compressor)) return node; + // !!expression + return make_node(AST_UnaryPrefix, node, { + operator: "!", + expression: node.negate(compressor), + }); + } + + // AST_True or !0 + function is_true(node) { + return node instanceof AST_True + || in_bool + && node instanceof AST_Constant + && node.value + || (node instanceof AST_UnaryPrefix + && node.operator == "!" + && node.expression instanceof AST_Constant + && !node.expression.value); + } + // AST_False or !1 or void 0 + function is_false(node) { + return node instanceof AST_False + || in_bool + && (node instanceof AST_Constant + && !node.value + || node instanceof AST_UnaryPrefix + && node.operator == "void" + && !node.expression.has_side_effects(compressor)) + || (node instanceof AST_UnaryPrefix + && node.operator == "!" + && node.expression instanceof AST_Constant + && node.expression.value); + } + + function arg_diff(consequent, alternative) { + var a = consequent.args; + var b = alternative.args; + var len = a.length; + if (len != b.length) return -2; + for (var i = 0; i < len; i++) { + if (!a[i].equals(b[i])) { + if (a[i] instanceof AST_Spread !== b[i] instanceof AST_Spread) return -3; + for (var j = i + 1; j < len; j++) { + if (!a[j].equals(b[j])) return -2; + } + return i; + } + } + return -1; + } + + function fuse(node, tail, prop) { + if (node === tail) return tail[prop]; + var exprs = node.expressions.slice(0, -1); + exprs.push(tail[prop]); + return make_sequence(node, exprs); + } + + function is_tail_equivalent(consequent, alternative) { + if (consequent.TYPE != alternative.TYPE) return; + if (consequent.optional != alternative.optional) return; + if (consequent instanceof AST_Call) { + if (arg_diff(consequent, alternative) != -1) return; + return consequent.TYPE != "Call" + || !(consequent.expression instanceof AST_PropAccess + || alternative.expression instanceof AST_PropAccess) + || is_tail_equivalent(consequent.expression, alternative.expression); + } + if (!(consequent instanceof AST_PropAccess)) return; + var p = consequent.property; + var q = alternative.property; + return (p instanceof AST_Node ? p.equals(q) : p == q) + && !(consequent.expression instanceof AST_Super || alternative.expression instanceof AST_Super); + } + + function combine_tail(consequent, alternative, top) { + var seq_tail = consequent.tail_node(); + var alt_tail = alternative.tail_node(); + if (!is_tail_equivalent(seq_tail, alt_tail)) return !top && make_node(AST_Conditional, self, { + condition: condition, + consequent: consequent, + alternative: alternative, + }); + var node = seq_tail.clone(); + var seq_expr = fuse(consequent, seq_tail, "expression"); + var alt_expr = fuse(alternative, alt_tail, "expression"); + var combined = combine_tail(seq_expr, alt_expr); + if (seq_tail.expression instanceof AST_Sequence) { + combined = maintain_this_binding(seq_tail, seq_tail.expression, combined); + } + node.expression = combined; + return node; + } + + function can_shift_lhs_of_tail(node) { + return node === node.tail_node() || all(node.expressions.slice(0, -1), function(expr) { + return !expr.has_side_effects(compressor); + }); + } + + function pop_lhs(node) { + if (!(node instanceof AST_Sequence)) return node.right; + var exprs = node.expressions.slice(); + exprs.push(exprs.pop().right); + return make_sequence(node, exprs); + } + + function pop_seq(node) { + if (!(node instanceof AST_Sequence)) return make_node(AST_Number, node, { value: 0 }); + return make_sequence(node, node.expressions.slice(0, -1)); + } + }); + + OPT(AST_Boolean, function(self, compressor) { + if (!compressor.option("booleans")) return self; + if (compressor.in_boolean_context()) return make_node(AST_Number, self, { value: +self.value }); + var p = compressor.parent(); + if (p instanceof AST_Binary && (p.operator == "==" || p.operator == "!=")) { + AST_Node.warn("Non-strict equality against boolean: {operator} {value} [{start}]", { + operator: p.operator, + value: self.value, + start: p.start, + }); + return make_node(AST_Number, self, { value: +self.value }); + } + return make_node(AST_UnaryPrefix, self, { + operator: "!", + expression: make_node(AST_Number, self, { value: 1 - self.value }), + }); + }); + + OPT(AST_Spread, function(self, compressor) { + var exp = self.expression; + if (compressor.option("spreads") && exp instanceof AST_Array && !(compressor.parent() instanceof AST_Object)) { + return List.splice(exp.elements.map(function(node) { + return node instanceof AST_Hole ? make_node(AST_Undefined, node).optimize(compressor) : node; + })); + } + return self; + }); + + function safe_to_flatten(value, compressor) { + if (!value) return false; + var parent = compressor.parent(); + if (parent.TYPE != "Call") return true; + if (parent.expression !== compressor.self()) return true; + if (value instanceof AST_SymbolRef) { + value = value.fixed_value(); + if (!value) return false; + } + return value instanceof AST_Lambda && !value.contains_this(); + } + + OPT(AST_Sub, function(self, compressor) { + var expr = self.expression; + var prop = self.property; + var terminated = trim_optional_chain(self, compressor); + if (terminated) return terminated; + if (compressor.option("properties")) { + var key = prop.evaluate(compressor); + if (key !== prop) { + if (typeof key == "string") { + if (key == "undefined") { + key = undefined; + } else { + var value = parseFloat(key); + if (value.toString() == key) { + key = value; + } + } + } + prop = self.property = best_of_expression(prop, make_node_from_constant(key, prop).transform(compressor)); + var property = "" + key; + if (is_identifier_string(property) + && property.length <= prop.print_to_string().length + 1) { + return make_node(AST_Dot, self, { + optional: self.optional, + expression: expr, + property: property, + quoted: true, + }).optimize(compressor); + } + } + } + var parent = compressor.parent(); + var assigned = is_lhs(compressor.self(), parent); + var def, fn, fn_parent, index; + if (compressor.option("arguments") + && expr instanceof AST_SymbolRef + && is_arguments(def = expr.definition()) + && !expr.in_arg + && prop instanceof AST_Number + && Math.floor(index = prop.value) == index + && (fn = def.scope) === find_lambda() + && fn.uses_arguments < (assigned ? 2 : 3)) { + if (parent instanceof AST_UnaryPrefix && parent.operator == "delete") { + if (!def.deleted) def.deleted = []; + def.deleted[index] = true; + } + var argname = fn.argnames[index]; + if (def.deleted && def.deleted[index]) { + argname = null; + } else if (argname) { + var arg_def; + if (!(argname instanceof AST_SymbolFunarg) + || argname.name == "await" + || expr.scope.find_variable(argname.name) !== (arg_def = argname.definition())) { + argname = null; + } else if (compressor.has_directive("use strict") + || fn.name + || fn.rest + || !(fn_parent instanceof AST_Call + && index < fn_parent.args.length + && all(fn_parent.args.slice(0, index + 1), function(arg) { + return !(arg instanceof AST_Spread); + })) + || !all(fn.argnames, function(argname) { + return argname instanceof AST_SymbolFunarg; + })) { + if (has_reassigned() || arg_def.assignments || arg_def.orig.length > 1) argname = null; + } + } else if ((assigned || !has_reassigned()) + && index < fn.argnames.length + 5 + && compressor.drop_fargs(fn, fn_parent) + && !fn.rest) { + while (index >= fn.argnames.length) { + argname = fn.make_var(AST_SymbolFunarg, fn, "argument_" + fn.argnames.length); + fn.argnames.push(argname); + } + } + if (argname && find_if(function(node) { + return node.name === argname.name; + }, fn.argnames) === argname) { + if (assigned) def.reassigned--; + var sym = make_node(AST_SymbolRef, argname); + sym.reference(); + argname.unused = undefined; + return sym; + } + } + if (assigned) return self; + if (compressor.option("sequences") + && parent.TYPE != "Call" + && !(parent instanceof AST_ForEnumeration && parent.init === self)) { + var seq = lift_sequence_in_expression(self, compressor); + if (seq !== self) return seq.optimize(compressor); + } + if (key !== prop) { + var sub = self.flatten_object(property, compressor); + if (sub) { + expr = self.expression = sub.expression; + prop = self.property = sub.property; + } + } + var elements; + if (compressor.option("properties") + && compressor.option("side_effects") + && prop instanceof AST_Number + && expr instanceof AST_Array + && all(elements = expr.elements, function(value) { + return !(value instanceof AST_Spread); + })) { + var index = prop.value; + var retValue = elements[index]; + if (safe_to_flatten(retValue, compressor)) { + var is_hole = retValue instanceof AST_Hole; + var flatten = !is_hole; + var values = []; + for (var i = elements.length; --i > index;) { + var value = elements[i].drop_side_effect_free(compressor); + if (value) { + values.unshift(value); + if (flatten && value.has_side_effects(compressor)) flatten = false; + } + } + if (!flatten) values.unshift(retValue); + while (--i >= 0) { + var value = elements[i].drop_side_effect_free(compressor); + if (value) { + values.unshift(value); + } else if (is_hole) { + values.unshift(make_node(AST_Hole, elements[i])); + } else { + index--; + } + } + if (flatten) { + values.push(retValue); + return make_sequence(self, values).optimize(compressor); + } + return make_node(AST_Sub, self, { + expression: make_node(AST_Array, expr, { elements: values }), + property: make_node(AST_Number, prop, { value: index }), + }); + } + } + return try_evaluate(compressor, self); + + function find_lambda() { + var i = 0, p; + while (p = compressor.parent(i++)) { + if (p instanceof AST_Lambda) { + if (p instanceof AST_Accessor) return; + if (is_arrow(p)) continue; + fn_parent = compressor.parent(i); + return p; + } + } + } + + function has_reassigned() { + return !compressor.option("reduce_vars") || def.reassigned; + } + }); + + AST_LambdaExpression.DEFMETHOD("contains_super", function() { + var result = false; + var self = this; + self.walk(new TreeWalker(function(node) { + if (result) return true; + if (node instanceof AST_Super) return result = true; + if (node !== self && node instanceof AST_Scope && !is_arrow(node)) return true; + })); + return result; + }); + + // contains_this() + // returns false only if context bound by the specified scope (or scope + // containing the specified expression) is not referenced by `this` + (function(def) { + // scope of arrow function cannot bind to any context + def(AST_Arrow, return_false); + def(AST_AsyncArrow, return_false); + def(AST_Node, function() { + var result = false; + var self = this; + self.walk(new TreeWalker(function(node) { + if (result) return true; + if (node instanceof AST_This) return result = true; + if (node !== self && node instanceof AST_Scope && !is_arrow(node)) return true; + })); + return result; + }); + })(function(node, func) { + node.DEFMETHOD("contains_this", func); + }); + + function can_hoist_property(prop) { + return prop instanceof AST_ObjectKeyVal + && typeof prop.key == "string" + && !(prop instanceof AST_ObjectMethod && prop.value.contains_super()); + } + + AST_PropAccess.DEFMETHOD("flatten_object", function(key, compressor) { + if (!compressor.option("properties")) return; + if (key === "__proto__") return; + var self = this; + var expr = self.expression; + if (!(expr instanceof AST_Object)) return; + var props = expr.properties; + for (var i = props.length; --i >= 0;) { + var prop = props[i]; + if (prop.key !== key) continue; + if (!all(props, can_hoist_property)) return; + if (!safe_to_flatten(prop.value, compressor)) return; + var call, scope, values = []; + for (var j = 0; j < props.length; j++) { + var value = props[j].value; + if (props[j] instanceof AST_ObjectMethod) { + var arrow = !(value.uses_arguments || is_generator(value) || value.contains_this()); + if (arrow) { + if (!scope) scope = compressor.find_parent(AST_Scope); + var avoid = avoid_await_yield(compressor, scope); + value.each_argname(function(argname) { + if (avoid[argname.name]) arrow = false; + }); + } + var ctor; + if (arrow) { + ctor = is_async(value) ? AST_AsyncArrow : AST_Arrow; + } else if (i != j + || (call = compressor.parent()) instanceof AST_Call && call.expression === self) { + ctor = value.CTOR; + } else { + return; + } + value = make_node(ctor, value); + } + values.push(value); + } + return make_node(AST_Sub, self, { + expression: make_node(AST_Array, expr, { elements: values }), + property: make_node(AST_Number, self, { value: i }), + }); + } + }); + + OPT(AST_Dot, function(self, compressor) { + if (self.property == "arguments" || self.property == "caller") { + AST_Node.warn("Function.prototype.{property} not supported [{start}]", self); + } + var parent = compressor.parent(); + if (is_lhs(compressor.self(), parent)) return self; + var terminated = trim_optional_chain(self, compressor); + if (terminated) return terminated; + if (compressor.option("sequences") + && parent.TYPE != "Call" + && !(parent instanceof AST_ForEnumeration && parent.init === self)) { + var seq = lift_sequence_in_expression(self, compressor); + if (seq !== self) return seq.optimize(compressor); + } + if (compressor.option("unsafe_proto") + && self.expression instanceof AST_Dot + && self.expression.property == "prototype") { + var exp = self.expression.expression; + if (is_undeclared_ref(exp)) switch (exp.name) { + case "Array": + self.expression = make_node(AST_Array, self.expression, { elements: [] }); + break; + case "Function": + self.expression = make_node(AST_Function, self.expression, { + argnames: [], + body: [], + }).init_vars(exp.scope); + break; + case "Number": + self.expression = make_node(AST_Number, self.expression, { value: 0 }); + break; + case "Object": + self.expression = make_node(AST_Object, self.expression, { properties: [] }); + break; + case "RegExp": + self.expression = make_node(AST_RegExp, self.expression, { value: /t/ }); + break; + case "String": + self.expression = make_node(AST_String, self.expression, { value: "" }); + break; + } + } + var sub = self.flatten_object(self.property, compressor); + if (sub) return sub.optimize(compressor); + return try_evaluate(compressor, self); + }); + + OPT(AST_DestructuredArray, function(self, compressor) { + if (compressor.option("rests") && self.rest instanceof AST_DestructuredArray) { + return make_node(AST_DestructuredArray, self, { + elements: self.elements.concat(self.rest.elements), + rest: self.rest.rest, + }); + } + return self; + }); + + OPT(AST_DestructuredKeyVal, function(self, compressor) { + if (compressor.option("objects")) { + var key = self.key; + if (key instanceof AST_Node) { + key = key.evaluate(compressor); + if (key !== self.key) self.key = "" + key; + } + } + return self; + }); + + OPT(AST_Object, function(self, compressor) { + if (!compressor.option("objects")) return self; + var changed = false; + var found = false; + var generated = false; + var keep_duplicate = compressor.has_directive("use strict"); + var keys = []; + var map = new Dictionary(); + var values = []; + self.properties.forEach(function(prop) { + if (!(prop instanceof AST_Spread)) return process(prop); + found = true; + var exp = prop.expression; + if (compressor.option("spreads") && exp instanceof AST_Object && all(exp.properties, function(prop) { + if (prop instanceof AST_ObjectGetter) return false; + if (prop instanceof AST_Spread) return false; + if (prop.key !== "__proto__") return true; + if (prop instanceof AST_ObjectSetter) return true; + return !prop.value.has_side_effects(compressor); + })) { + changed = true; + exp.properties.forEach(function(prop) { + var key = prop.key; + var setter = prop instanceof AST_ObjectSetter; + if (key === "__proto__") { + if (!setter) return; + key = make_node_from_constant(key, prop); + } + process(setter ? make_node(AST_ObjectKeyVal, prop, { + key: key, + value: make_node(AST_Undefined, prop).optimize(compressor), + }) : prop); + }); + } else { + generated = true; + flush(); + values.push(prop); + } + }); + flush(); + if (!changed) return self; + if (found && generated && values.length == 1) { + var value = values[0]; + if (value instanceof AST_ObjectProperty && value.key instanceof AST_Number) { + value.key = "" + value.key.value; + } + } + return make_node(AST_Object, self, { properties: values }); + + function flush() { + keys.forEach(function(key) { + var props = map.get(key); + switch (props.length) { + case 0: + return; + case 1: + return values.push(props[0]); + } + changed = true; + var tail = keep_duplicate && !generated && props.pop(); + values.push(props.length == 1 ? props[0] : make_node(AST_ObjectKeyVal, self, { + key: props[0].key, + value: make_sequence(self, props.map(function(prop) { + return prop.value; + })), + })); + if (tail) values.push(tail); + props.length = 0; + }); + keys = []; + map = new Dictionary(); + } + + function process(prop) { + var key = prop.key; + if (key instanceof AST_Node) { + found = true; + key = key.evaluate(compressor); + if (key === prop.key || key === "__proto__") { + generated = true; + } else { + key = prop.key = "" + key; + } + } + if (can_hoist_property(prop)) { + if (prop.value.has_side_effects(compressor)) flush(); + keys.push(key); + map.add(key, prop); + } else { + flush(); + values.push(prop); + } + if (found && !generated && typeof key == "string" && RE_POSITIVE_INTEGER.test(key)) { + generated = true; + if (map.has(key)) prop = map.get(key)[0]; + prop.key = make_node(AST_Number, prop, { value: +key }); + } + } + }); + + function flatten_var(name) { + var redef = name.definition().redefined(); + if (redef) { + name = name.clone(); + name.thedef = redef; + } + return name; + } + + function has_arg_refs(fn, node) { + var found = false; + node.walk(new TreeWalker(function(node) { + if (found) return true; + if (node instanceof AST_SymbolRef && fn.variables.get(node.name) === node.definition()) { + return found = true; + } + })); + return found; + } + + function insert_assign(def, assign) { + var visited = []; + def.references.forEach(function(ref) { + var fixed = ref.fixed; + if (!fixed || !push_uniq(visited, fixed)) return; + if (fixed.assigns) { + fixed.assigns.unshift(assign); + } else { + fixed.assigns = [ assign ]; + } + }); + } + + function init_ref(compressor, name) { + var sym = make_node(AST_SymbolRef, name); + var assign = make_node(AST_Assign, name, { + operator: "=", + left: sym, + right: make_node(AST_Undefined, name).transform(compressor), + }); + var def = name.definition(); + if (def.fixed) { + sym.fixed = function() { + return assign.right; + }; + sym.fixed.assigns = [ assign ]; + insert_assign(def, assign); + } + def.assignments++; + def.references.push(sym); + return assign; + } + + (function(def) { + def(AST_Node, noop); + def(AST_Assign, noop); + def(AST_Await, function(compressor, scope, no_return, in_loop) { + if (!compressor.option("awaits")) return; + var self = this; + var inlined = self.expression.try_inline(compressor, scope, no_return, in_loop, true); + if (!inlined) return; + if (!no_return) scan_local_returns(inlined, function(node) { + node.in_bool = false; + var value = node.value; + if (value instanceof AST_Await) return; + node.value = make_node(AST_Await, self, { + expression: value || make_node(AST_Undefined, node).transform(compressor), + }); + }); + return aborts(inlined) ? inlined : make_node(AST_BlockStatement, self, { + body: [ inlined, make_node(AST_SimpleStatement, self, { + body: make_node(AST_Await, self, { expression: make_node(AST_Number, self, { value: 0 })}), + }) ], + }); + }); + def(AST_Binary, function(compressor, scope, no_return, in_loop, in_await) { + if (no_return === undefined) return; + var self = this; + var op = self.operator; + if (!lazy_op[op]) return; + var inlined = self.right.try_inline(compressor, scope, no_return, in_loop, in_await); + if (!inlined) return; + return make_node(AST_If, self, { + condition: make_condition(self.left), + body: inlined, + alternative: no_return ? null : make_node(AST_Return, self, { + value: make_node(AST_Undefined, self).transform(compressor), + }), + }); + + function make_condition(cond) { + switch (op) { + case "&&": + return cond; + case "||": + return cond.negate(compressor); + case "??": + return make_node(AST_Binary, self, { + operator: "==", + left: make_node(AST_Null, self), + right: cond, + }); + } + } + }); + def(AST_BlockStatement, function(compressor, scope, no_return, in_loop) { + if (no_return) return; + if (!this.variables) return; + var body = this.body; + var last = body.length - 1; + if (last < 0) return; + var inlined = body[last].try_inline(compressor, this, no_return, in_loop); + if (!inlined) return; + body[last] = inlined; + return this; + }); + def(AST_Call, function(compressor, scope, no_return, in_loop, in_await) { + if (compressor.option("inline") < 4) return; + var call = this; + if (call.is_expr_pure(compressor)) return; + var fn = call.expression; + if (!(fn instanceof AST_LambdaExpression)) return; + if (fn.name) return; + if (fn.single_use) return; + if (fn.uses_arguments) return; + if (fn.pinned()) return; + if (is_generator(fn)) return; + var arrow = is_arrow(fn); + var fn_body = arrow && fn.value ? [ fn.first_statement() ] : fn.body; + if (fn_body[0] instanceof AST_Directive) return; + if (fn.contains_this()) return; + if (!scope) scope = find_scope(compressor); + var defined = new Dictionary(); + defined.set("NaN", true); + while (!(scope instanceof AST_Scope)) { + scope.variables.each(function(def) { + defined.set(def.name, true); + }); + scope = scope.parent_scope; + } + if (!member(scope, compressor.stack)) return; + if (scope.pinned() && fn.variables.size() > (arrow ? 0 : 1)) return; + if (scope instanceof AST_Toplevel) { + if (fn.variables.size() > (arrow ? 0 : 1)) { + if (!compressor.toplevel.vars) return; + if (fn.functions.size() > 0 && !compressor.toplevel.funcs) return; + } + defined.set("arguments", true); + } + var async = !in_await && is_async(fn); + if (async) { + if (!compressor.option("awaits")) return; + if (!is_async(scope)) return; + if (call.may_throw(compressor)) return; + } + var names = scope.var_names(); + if (in_loop) in_loop = []; + if (!fn.variables.all(function(def, name) { + if (in_loop) in_loop.push(def); + if (!defined.has(name) && !names.has(name)) return true; + return !arrow && name == "arguments" && def.orig.length == 1; + })) return; + if (in_loop && in_loop.length > 0 && is_reachable(fn, in_loop)) return; + var simple_argnames = true; + if (!all(fn.argnames, function(argname) { + var abort = false; + var tw = new TreeWalker(function(node) { + if (abort) return true; + if (node instanceof AST_DefaultValue) { + if (has_arg_refs(fn, node.value)) return abort = true; + node.name.walk(tw); + return true; + } + if (node instanceof AST_DestructuredKeyVal) { + if (node.key instanceof AST_Node && has_arg_refs(fn, node.key)) return abort = true; + node.value.walk(tw); + return true; + } + if (node instanceof AST_SymbolFunarg && !all(node.definition().orig, function(sym) { + return !(sym instanceof AST_SymbolDefun); + })) return abort = true; + }); + argname.walk(tw); + if (abort) return false; + if (!(argname instanceof AST_SymbolFunarg)) simple_argnames = false; + return true; + })) return; + if (fn.rest) { + if (has_arg_refs(fn, fn.rest)) return; + simple_argnames = false; + } + var verify_body; + if (no_return) { + verify_body = function(stat) { + var abort = false; + stat.walk(new TreeWalker(function(node) { + if (abort) return true; + if (async && (node instanceof AST_Await || node instanceof AST_ForAwaitOf) + || node instanceof AST_Return) { + return abort = true; + } + if (node instanceof AST_Scope) return true; + })); + return !abort; + }; + } else if (in_await || is_async(fn) || in_async_generator(scope)) { + verify_body = function(stat) { + var abort = false; + var find_return = new TreeWalker(function(node) { + if (abort) return true; + if (node instanceof AST_Return) return abort = true; + if (node instanceof AST_Scope) return true; + }); + stat.walk(new TreeWalker(function(node) { + if (abort) return true; + if (node instanceof AST_Try) { + if (!node.bfinally) return; + if (all(node.body, function(stat) { + stat.walk(find_return); + return !abort; + }) && node.bcatch) node.bcatch.walk(find_return); + return true; + } + if (node instanceof AST_Scope) return true; + })); + return !abort; + }; + } + if (verify_body && !all(fn_body, verify_body)) return; + if (!safe_from_await_yield(fn, avoid_await_yield(compressor, scope))) return; + fn.functions.each(function(def, name) { + scope.functions.set(name, def); + }); + var body = []; + fn.variables.each(function(def, name) { + if (!arrow && name == "arguments" && def.orig.length == 1) return; + names.set(name, true); + scope.enclosed.push(def); + scope.variables.set(name, def); + def.single_use = false; + if (!in_loop) return; + if (def.references.length == def.replaced) return; + switch (def.orig.length - def.eliminated) { + case 0: + return; + case 1: + if (fn.functions.has(name)) return; + } + if (!all(def.orig, function(sym) { + if (sym instanceof AST_SymbolConst) return false; + if (sym instanceof AST_SymbolFunarg) return !sym.unused && def.scope.resolve() !== fn; + if (sym instanceof AST_SymbolLet) return false; + return true; + })) return; + var sym = def.orig[0]; + if (sym instanceof AST_SymbolCatch) return; + body.push(make_node(AST_SimpleStatement, sym, { body: init_ref(compressor, flatten_var(sym)) })); + def.first_decl = null; + }); + var defs = Object.create(null), syms = new Dictionary(); + if (simple_argnames && all(call.args, function(arg) { + return !(arg instanceof AST_Spread); + })) { + var values = call.args.slice(); + fn.argnames.forEach(function(argname) { + var value = values.shift(); + if (argname.unused) { + if (value) body.push(make_node(AST_SimpleStatement, call, { body: value })); + return; + } + var defn = make_node(AST_VarDef, call, { + name: argname.convert_symbol(AST_SymbolVar, process), + value: value || make_node(AST_Undefined, call).transform(compressor), + }); + if (argname instanceof AST_SymbolFunarg) insert_assign(argname.definition(), defn); + body.push(make_node(AST_Var, call, { definitions: [ defn ] })); + }); + if (values.length) body.push(make_node(AST_SimpleStatement, call, { + body: make_sequence(call, values), + })); + } else { + body.push(make_node(AST_Var, call, { + definitions: [ make_node(AST_VarDef, call, { + name: make_node(AST_DestructuredArray, call, { + elements: fn.argnames.map(function(argname) { + if (argname.unused) return make_node(AST_Hole, argname); + return argname.convert_symbol(AST_SymbolVar, process); + }), + rest: fn.rest && fn.rest.convert_symbol(AST_SymbolVar, process), + }), + value: make_node(AST_Array, call, { elements: call.args.slice() }), + }) ], + })); + } + syms.each(function(orig, id) { + var def = defs[id]; + [].unshift.apply(def.orig, orig); + def.eliminated += orig.length; + }); + [].push.apply(body, in_loop ? fn_body.filter(function(stat) { + if (!(stat instanceof AST_LambdaDefinition)) return true; + var name = make_node(AST_SymbolVar, flatten_var(stat.name)); + var def = name.definition(); + def.fixed = false; + def.orig.push(name); + def.eliminated++; + body.push(make_node(AST_Var, stat, { + definitions: [ make_node(AST_VarDef, stat, { + name: name, + value: to_func_expr(stat, true), + }) ], + })); + return false; + }) : fn_body); + var inlined = make_node(AST_BlockStatement, call, { body: body }); + if (!no_return) { + if (async) scan_local_returns(inlined, function(node) { + var value = node.value; + if (is_undefined(value)) return; + node.value = make_node(AST_Await, call, { expression: value }); + }); + body.push(make_node(AST_Return, call, { + value: in_async_generator(scope) ? make_node(AST_Undefined, call).transform(compressor) : null, + })); + } + return inlined; + + function process(sym, argname) { + var def = argname.definition(); + defs[def.id] = def; + syms.add(def.id, sym); + } + }); + def(AST_Conditional, function(compressor, scope, no_return, in_loop, in_await) { + var self = this; + var body = self.consequent.try_inline(compressor, scope, no_return, in_loop, in_await); + var alt = self.alternative.try_inline(compressor, scope, no_return, in_loop, in_await); + if (!body && !alt) return; + return make_node(AST_If, self, { + condition: self.condition, + body: body || make_body(self.consequent), + alternative: alt || make_body(self.alternative), + }); + + function make_body(value) { + if (no_return) return make_node(AST_SimpleStatement, value, { body: value }); + return make_node(AST_Return, value, { value: value }); + } + }); + def(AST_For, function(compressor, scope, no_return, in_loop) { + var body = this.body.try_inline(compressor, scope, true, true); + if (body) this.body = body; + var inlined = this.init; + if (inlined) { + inlined = inlined.try_inline(compressor, scope, true, in_loop); + if (inlined) { + this.init = null; + if (inlined instanceof AST_BlockStatement) { + inlined.body.push(this); + return inlined; + } + return make_node(AST_BlockStatement, inlined, { body: [ inlined, this ] }); + } + } + return body && this; + }); + def(AST_ForEnumeration, function(compressor, scope, no_return, in_loop) { + var body = this.body.try_inline(compressor, scope, true, true); + if (body) this.body = body; + var obj = this.object; + if (obj instanceof AST_Sequence) { + var inlined = inline_sequence(compressor, scope, true, in_loop, false, obj, 1); + if (inlined) { + this.object = obj.tail_node(); + inlined.body.push(this); + return inlined; + } + } + return body && this; + }); + def(AST_If, function(compressor, scope, no_return, in_loop) { + var body = this.body.try_inline(compressor, scope, no_return, in_loop); + if (body) this.body = body; + var alt = this.alternative; + if (alt) { + alt = alt.try_inline(compressor, scope, no_return, in_loop); + if (alt) this.alternative = alt; + } + var cond = this.condition; + if (cond instanceof AST_Sequence) { + var inlined = inline_sequence(compressor, scope, true, in_loop, false, cond, 1); + if (inlined) { + this.condition = cond.tail_node(); + inlined.body.push(this); + return inlined; + } + } + return (body || alt) && this; + }); + def(AST_IterationStatement, function(compressor, scope, no_return, in_loop) { + var body = this.body.try_inline(compressor, scope, true, true); + if (!body) return; + this.body = body; + return this; + }); + def(AST_LabeledStatement, function(compressor, scope, no_return, in_loop) { + var body = this.body.try_inline(compressor, scope, no_return, in_loop); + if (!body) return; + if (this.body instanceof AST_IterationStatement && body instanceof AST_BlockStatement) { + var loop = body.body.pop(); + this.body = loop; + body.body.push(this); + return body; + } + this.body = body; + return this; + }); + def(AST_New, noop); + def(AST_Return, function(compressor, scope, no_return, in_loop) { + var value = this.value; + return value && value.try_inline(compressor, scope, undefined, in_loop === "try"); + }); + function inline_sequence(compressor, scope, no_return, in_loop, in_await, node, skip) { + var body = [], exprs = node.expressions, no_ret = no_return; + for (var i = exprs.length - (skip || 0), j = i; --i >= 0; no_ret = true, in_await = false) { + var inlined = exprs[i].try_inline(compressor, scope, no_ret, in_loop, in_await); + if (!inlined) continue; + flush(); + body.push(inlined); + } + if (body.length == 0) return; + flush(); + if (!no_return && body[0] instanceof AST_SimpleStatement) { + body[0] = make_node(AST_Return, node, { value: body[0].body }); + } + return make_node(AST_BlockStatement, node, { body: body.reverse() }); + + function flush() { + if (j > i + 1) body.push(make_node(AST_SimpleStatement, node, { + body: make_sequence(node, exprs.slice(i + 1, j)), + })); + j = i; + } + } + def(AST_Sequence, function(compressor, scope, no_return, in_loop, in_await) { + return inline_sequence(compressor, scope, no_return, in_loop, in_await, this); + }); + def(AST_SimpleStatement, function(compressor, scope, no_return, in_loop) { + var body = this.body; + while (body instanceof AST_UnaryPrefix) { + var op = body.operator; + if (unary_side_effects[op]) break; + if (op == "void") break; + body = body.expression; + } + if (!no_return && !is_undefined(body)) body = make_node(AST_UnaryPrefix, this, { + operator: "void", + expression: body, + }); + return body.try_inline(compressor, scope, no_return || false, in_loop); + }); + def(AST_UnaryPrefix, function(compressor, scope, no_return, in_loop, in_await) { + var self = this; + var op = self.operator; + if (unary_side_effects[op]) return; + if (!no_return && op == "void") no_return = false; + var inlined = self.expression.try_inline(compressor, scope, no_return, in_loop, in_await); + if (!inlined) return; + if (!no_return) scan_local_returns(inlined, function(node) { + node.in_bool = false; + var value = node.value; + if (op == "void" && is_undefined(value)) return; + node.value = make_node(AST_UnaryPrefix, self, { + operator: op, + expression: value || make_node(AST_Undefined, node).transform(compressor), + }); + }); + return inlined; + }); + def(AST_With, function(compressor, scope, no_return, in_loop) { + var body = this.body.try_inline(compressor, scope, no_return, in_loop); + if (body) this.body = body; + var exp = this.expression; + if (exp instanceof AST_Sequence) { + var inlined = inline_sequence(compressor, scope, true, in_loop, false, exp, 1); + if (inlined) { + this.expression = exp.tail_node(); + inlined.body.push(this); + return inlined; + } + } + return body && this; + }); + def(AST_Yield, function(compressor, scope, no_return, in_loop) { + if (!compressor.option("yields")) return; + if (!this.nested) return; + var call = this.expression; + if (call.TYPE != "Call") return; + var fn = call.expression; + switch (fn.CTOR) { + case AST_AsyncGeneratorFunction: + fn = make_node(AST_AsyncFunction, fn); + break; + case AST_GeneratorFunction: + fn = make_node(AST_Function, fn); + break; + default: + return; + } + call = call.clone(); + call.expression = fn; + return call.try_inline(compressor, scope, no_return, in_loop); + }); + })(function(node, func) { + node.DEFMETHOD("try_inline", func); + }); + + OPT(AST_Return, function(self, compressor) { + var value = self.value; + if (value && compressor.option("side_effects") + && is_undefined(value, compressor) + && !in_async_generator(compressor.find_parent(AST_Scope))) { + self.value = null; + } + return self; + }); +})(function(node, optimizer) { + node.DEFMETHOD("optimize", function(compressor) { + var self = this; + if (self._optimized) return self; + if (compressor.has_directive("use asm")) return self; + var opt = optimizer(self, compressor); + opt._optimized = true; + return opt; + }); +}); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/minify.js b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/minify.js new file mode 100644 index 0000000000000000000000000000000000000000..66d0bd324a1fd51ce9a31a687b10c4c98a0991f2 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/minify.js @@ -0,0 +1,278 @@ +"use strict"; + +var to_ascii, to_base64; +if (typeof Buffer == "undefined") { + to_ascii = atob; + to_base64 = btoa; +} else if (typeof Buffer.alloc == "undefined") { + to_ascii = function(b64) { + return new Buffer(b64, "base64").toString(); + }; + to_base64 = function(str) { + return new Buffer(str).toString("base64"); + }; +} else { + to_ascii = function(b64) { + return Buffer.from(b64, "base64").toString(); + }; + to_base64 = function(str) { + return Buffer.from(str).toString("base64"); + }; +} + +function read_source_map(name, toplevel) { + var comments = toplevel.end.comments_after; + for (var i = comments.length; --i >= 0;) { + var comment = comments[i]; + if (comment.type != "comment1") break; + var match = /^# ([^\s=]+)=(\S+)\s*$/.exec(comment.value); + if (!match) break; + if (match[1] == "sourceMappingURL") { + match = /^data:application\/json(;.*?)?;base64,([^,]+)$/.exec(match[2]); + if (!match) break; + return to_ascii(match[2]); + } + } + AST_Node.warn("inline source map not found: {name}", { + name: name, + }); +} + +function parse_source_map(content) { + try { + return JSON.parse(content); + } catch (ex) { + throw new Error("invalid input source map: " + content); + } +} + +function set_shorthand(name, options, keys) { + keys.forEach(function(key) { + if (options[key]) { + var defs = {}; + defs[name] = options[name]; + options[key] = defaults(options[key], defs); + } + }); +} + +function init_cache(cache) { + if (!cache) return; + if (!("props" in cache)) { + cache.props = new Dictionary(); + } else if (!(cache.props instanceof Dictionary)) { + cache.props = Dictionary.fromObject(cache.props); + } +} + +function to_json(cache) { + return { + props: cache.props.toObject() + }; +} + +function minify(files, options) { + try { + options = defaults(options, { + annotations: undefined, + compress: {}, + enclose: false, + expression: false, + ie: false, + ie8: false, + keep_fargs: false, + keep_fnames: false, + mangle: {}, + module: undefined, + nameCache: null, + output: {}, + parse: {}, + rename: undefined, + sourceMap: false, + timings: false, + toplevel: options && !options["expression"] && options["module"] ? true : undefined, + v8: false, + validate: false, + warnings: false, + webkit: false, + wrap: false, + }, true); + if (options.validate) AST_Node.enable_validation(); + var timings = options.timings && { start: Date.now() }; + if (options.annotations !== undefined) set_shorthand("annotations", options, [ "compress", "output" ]); + if (options.expression) set_shorthand("expression", options, [ "compress", "parse" ]); + if (options.ie8) options.ie = options.ie || options.ie8; + if (options.ie) set_shorthand("ie", options, [ "compress", "mangle", "output", "rename" ]); + if (options.keep_fargs) set_shorthand("keep_fargs", options, [ "compress", "mangle", "rename" ]); + if (options.keep_fnames) set_shorthand("keep_fnames", options, [ "compress", "mangle", "rename" ]); + if (options.module === undefined && !options.ie) options.module = true; + if (options.module) set_shorthand("module", options, [ "compress", "output", "parse" ]); + if (options.toplevel !== undefined) set_shorthand("toplevel", options, [ "compress", "mangle", "rename" ]); + if (options.v8) set_shorthand("v8", options, [ "mangle", "output", "rename" ]); + if (options.webkit) set_shorthand("webkit", options, [ "compress", "mangle", "output", "rename" ]); + var quoted_props; + if (options.mangle) { + options.mangle = defaults(options.mangle, { + cache: options.nameCache && (options.nameCache.vars || {}), + eval: false, + ie: false, + keep_fargs: false, + keep_fnames: false, + properties: false, + reserved: [], + toplevel: false, + v8: false, + webkit: false, + }, true); + if (options.mangle.properties) { + if (typeof options.mangle.properties != "object") { + options.mangle.properties = {}; + } + if (options.mangle.properties.keep_quoted) { + quoted_props = options.mangle.properties.reserved; + if (!Array.isArray(quoted_props)) quoted_props = []; + options.mangle.properties.reserved = quoted_props; + } + if (options.nameCache && !("cache" in options.mangle.properties)) { + options.mangle.properties.cache = options.nameCache.props || {}; + } + } + init_cache(options.mangle.cache); + init_cache(options.mangle.properties.cache); + } + if (options.rename === undefined) options.rename = options.compress && options.mangle; + if (options.sourceMap) { + options.sourceMap = defaults(options.sourceMap, { + content: null, + filename: null, + includeSources: false, + names: true, + root: null, + url: null, + }, true); + } + var warnings = []; + if (options.warnings) AST_Node.log_function(function(warning) { + warnings.push(warning); + }, options.warnings == "verbose"); + if (timings) timings.parse = Date.now(); + var toplevel; + options.parse = options.parse || {}; + if (files instanceof AST_Node) { + toplevel = files; + } else { + if (typeof files == "string") files = [ files ]; + options.parse.toplevel = null; + var source_map_content = options.sourceMap && options.sourceMap.content; + if (typeof source_map_content == "string" && source_map_content != "inline") { + source_map_content = parse_source_map(source_map_content); + } + if (source_map_content) options.sourceMap.orig = Object.create(null); + for (var name in files) if (HOP(files, name)) { + options.parse.filename = name; + options.parse.toplevel = toplevel = parse(files[name], options.parse); + if (source_map_content == "inline") { + var inlined_content = read_source_map(name, toplevel); + if (inlined_content) options.sourceMap.orig[name] = parse_source_map(inlined_content); + } else if (source_map_content) { + options.sourceMap.orig[name] = source_map_content; + } + } + } + if (options.parse.expression) toplevel = toplevel.wrap_expression(); + if (quoted_props) reserve_quoted_keys(toplevel, quoted_props); + [ "enclose", "wrap" ].forEach(function(action) { + var option = options[action]; + if (!option) return; + var orig = toplevel.print_to_string().slice(0, -1); + toplevel = toplevel[action](option); + files[toplevel.start.file] = toplevel.print_to_string().replace(orig, ""); + }); + if (options.validate) toplevel.validate_ast(); + if (timings) timings.rename = Date.now(); + if (options.rename) { + toplevel.figure_out_scope(options.rename); + toplevel.expand_names(options.rename); + } + if (timings) timings.compress = Date.now(); + if (options.compress) { + toplevel = new Compressor(options.compress).compress(toplevel); + if (options.validate) toplevel.validate_ast(); + } + if (timings) timings.scope = Date.now(); + if (options.mangle) toplevel.figure_out_scope(options.mangle); + if (timings) timings.mangle = Date.now(); + if (options.mangle) { + toplevel.compute_char_frequency(options.mangle); + toplevel.mangle_names(options.mangle); + } + if (timings) timings.properties = Date.now(); + if (quoted_props) reserve_quoted_keys(toplevel, quoted_props); + if (options.mangle && options.mangle.properties) mangle_properties(toplevel, options.mangle.properties); + if (options.parse.expression) toplevel = toplevel.unwrap_expression(); + if (timings) timings.output = Date.now(); + var result = {}; + var output = defaults(options.output, { + ast: false, + code: true, + }); + if (output.ast) result.ast = toplevel; + if (output.code) { + if (options.sourceMap) { + output.source_map = SourceMap(options.sourceMap); + if (options.sourceMap.includeSources) { + if (files instanceof AST_Toplevel) { + throw new Error("original source content unavailable"); + } else for (var name in files) if (HOP(files, name)) { + output.source_map.setSourceContent(name, files[name]); + } + } + } + delete output.ast; + delete output.code; + var stream = OutputStream(output); + toplevel.print(stream); + result.code = stream.get(); + if (options.sourceMap) { + result.map = output.source_map.toString(); + var url = options.sourceMap.url; + if (url) { + result.code = result.code.replace(/\n\/\/# sourceMappingURL=\S+\s*$/, ""); + if (url == "inline") { + result.code += "\n//# sourceMappingURL=data:application/json;charset=utf-8;base64," + to_base64(result.map); + } else { + result.code += "\n//# sourceMappingURL=" + url; + } + } + } + } + if (options.nameCache && options.mangle) { + if (options.mangle.cache) options.nameCache.vars = to_json(options.mangle.cache); + if (options.mangle.properties && options.mangle.properties.cache) { + options.nameCache.props = to_json(options.mangle.properties.cache); + } + } + if (timings) { + timings.end = Date.now(); + result.timings = { + parse: 1e-3 * (timings.rename - timings.parse), + rename: 1e-3 * (timings.compress - timings.rename), + compress: 1e-3 * (timings.scope - timings.compress), + scope: 1e-3 * (timings.mangle - timings.scope), + mangle: 1e-3 * (timings.properties - timings.mangle), + properties: 1e-3 * (timings.output - timings.properties), + output: 1e-3 * (timings.end - timings.output), + total: 1e-3 * (timings.end - timings.start) + }; + } + if (warnings.length) { + result.warnings = warnings; + } + return result; + } catch (ex) { + return { error: ex }; + } finally { + AST_Node.log_function(); + AST_Node.disable_validation(); + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/mozilla-ast.js b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/mozilla-ast.js new file mode 100644 index 0000000000000000000000000000000000000000..baf4c91f1427de199bc09b0e0b20c7711b052119 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/mozilla-ast.js @@ -0,0 +1,1338 @@ +/*********************************************************************** + + A JavaScript tokenizer / parser / beautifier / compressor. + https://github.com/mishoo/UglifyJS + + -------------------------------- (C) --------------------------------- + + Author: Mihai Bazon + + http://mihai.bazon.net/blog + + Distributed under the BSD license: + + Copyright 2012 (c) Mihai Bazon + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + * Redistributions of source code must retain the above + copyright notice, this list of conditions and the following + disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials + provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY + EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, + OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF + THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + SUCH DAMAGE. + + ***********************************************************************/ + +"use strict"; + +(function() { + var MOZ_TO_ME = { + Program: function(M) { + return new AST_Toplevel({ + start: my_start_token(M), + end: my_end_token(M), + body: normalize_directives(M.body.map(from_moz)), + }); + }, + ArrowFunctionExpression: function(M) { + var argnames = [], rest = null; + M.params.forEach(function(param) { + if (param.type == "RestElement") { + rest = from_moz(param.argument); + } else { + argnames.push(from_moz(param)); + } + }); + var fn = new (M.async ? AST_AsyncArrow : AST_Arrow)({ + start: my_start_token(M), + end: my_end_token(M), + argnames: argnames, + rest: rest, + }); + var node = from_moz(M.body); + if (node instanceof AST_BlockStatement) { + fn.body = normalize_directives(node.body); + fn.value = null; + } else { + fn.body = []; + fn.value = node; + } + return fn; + }, + FunctionDeclaration: function(M) { + var ctor; + if (M.async) { + ctor = M.generator ? AST_AsyncGeneratorDefun : AST_AsyncDefun; + } else { + ctor = M.generator ? AST_GeneratorDefun : AST_Defun; + } + var argnames = [], rest = null; + M.params.forEach(function(param) { + if (param.type == "RestElement") { + rest = from_moz(param.argument); + } else { + argnames.push(from_moz(param)); + } + }); + return new ctor({ + start: my_start_token(M), + end: my_end_token(M), + name: from_moz(M.id), + argnames: argnames, + rest: rest, + body: normalize_directives(from_moz(M.body).body), + }); + }, + FunctionExpression: function(M) { + var ctor; + if (M.async) { + ctor = M.generator ? AST_AsyncGeneratorFunction : AST_AsyncFunction; + } else { + ctor = M.generator ? AST_GeneratorFunction : AST_Function; + } + var argnames = [], rest = null; + M.params.forEach(function(param) { + if (param.type == "RestElement") { + rest = from_moz(param.argument); + } else { + argnames.push(from_moz(param)); + } + }); + return new ctor({ + start: my_start_token(M), + end: my_end_token(M), + name: from_moz(M.id), + argnames: argnames, + rest: rest, + body: normalize_directives(from_moz(M.body).body), + }); + }, + CallExpression: function(M) { + return new AST_Call({ + start: my_start_token(M), + end: my_end_token(M), + expression: from_moz(M.callee), + args: M.arguments.map(from_moz), + optional: M.optional, + pure: M.pure, + }); + }, + ClassDeclaration: function(M) { + return new AST_DefClass({ + start: my_start_token(M), + end: my_end_token(M), + name: from_moz(M.id), + extends: from_moz(M.superClass), + properties: M.body.body.map(from_moz), + }); + }, + ClassExpression: function(M) { + return new AST_ClassExpression({ + start: my_start_token(M), + end: my_end_token(M), + name: from_moz(M.id), + extends: from_moz(M.superClass), + properties: M.body.body.map(from_moz), + }); + }, + MethodDefinition: function(M) { + var key = M.key, internal = false; + if (M.computed) { + key = from_moz(key); + } else if (key.type == "PrivateIdentifier") { + internal = true; + key = "#" + key.name; + } else { + key = read_name(key); + } + var ctor = AST_ClassMethod, value = from_moz(M.value); + switch (M.kind) { + case "get": + ctor = AST_ClassGetter; + value = new AST_Accessor(value); + break; + case "set": + ctor = AST_ClassSetter; + value = new AST_Accessor(value); + break; + } + return new ctor({ + start: my_start_token(M), + end: my_end_token(M), + key: key, + private: internal, + static: M.static, + value: value, + }); + }, + PropertyDefinition: function(M) { + var key = M.key, internal = false; + if (M.computed) { + key = from_moz(key); + } else if (key.type == "PrivateIdentifier") { + internal = true; + key = "#" + key.name; + } else { + key = read_name(key); + } + return new AST_ClassField({ + start: my_start_token(M), + end: my_end_token(M), + key: key, + private: internal, + static: M.static, + value: from_moz(M.value), + }); + }, + StaticBlock: function(M) { + var start = my_start_token(M); + var end = my_end_token(M); + return new AST_ClassInit({ + start: start, + end: end, + value: new AST_ClassInitBlock({ + start: start, + end: end, + body: normalize_directives(M.body.map(from_moz)), + }), + }); + }, + ForOfStatement: function(M) { + return new (M.await ? AST_ForAwaitOf : AST_ForOf)({ + start: my_start_token(M), + end: my_end_token(M), + init: from_moz(M.left), + object: from_moz(M.right), + body: from_moz(M.body), + }); + }, + TryStatement: function(M) { + var handlers = M.handlers || [M.handler]; + if (handlers.length > 1 || M.guardedHandlers && M.guardedHandlers.length) { + throw new Error("Multiple catch clauses are not supported."); + } + return new AST_Try({ + start : my_start_token(M), + end : my_end_token(M), + body : from_moz(M.block).body, + bcatch : from_moz(handlers[0]), + bfinally : M.finalizer ? new AST_Finally(from_moz(M.finalizer)) : null, + }); + }, + Property: function(M) { + var key = M.computed ? from_moz(M.key) : read_name(M.key); + var args = { + start: my_start_token(M), + end: my_end_token(M), + key: key, + value: from_moz(M.value), + }; + if (M.kind == "init") return new (M.method ? AST_ObjectMethod : AST_ObjectKeyVal)(args); + args.value = new AST_Accessor(args.value); + if (M.kind == "get") return new AST_ObjectGetter(args); + if (M.kind == "set") return new AST_ObjectSetter(args); + }, + ArrayExpression: function(M) { + return new AST_Array({ + start: my_start_token(M), + end: my_end_token(M), + elements: M.elements.map(function(elem) { + return elem === null ? new AST_Hole() : from_moz(elem); + }), + }); + }, + ArrayPattern: function(M) { + var elements = [], rest = null; + M.elements.forEach(function(el) { + if (el === null) { + elements.push(new AST_Hole()); + } else if (el.type == "RestElement") { + rest = from_moz(el.argument); + } else { + elements.push(from_moz(el)); + } + }); + return new AST_DestructuredArray({ + start: my_start_token(M), + end: my_end_token(M), + elements: elements, + rest: rest, + }); + }, + ObjectPattern: function(M) { + var props = [], rest = null; + M.properties.forEach(function(prop) { + if (prop.type == "RestElement") { + rest = from_moz(prop.argument); + } else { + props.push(new AST_DestructuredKeyVal(from_moz(prop))); + } + }); + return new AST_DestructuredObject({ + start: my_start_token(M), + end: my_end_token(M), + properties: props, + rest: rest, + }); + }, + MemberExpression: function(M) { + return new (M.computed ? AST_Sub : AST_Dot)({ + start: my_start_token(M), + end: my_end_token(M), + optional: M.optional, + expression: from_moz(M.object), + property: M.computed ? from_moz(M.property) : M.property.name, + }); + }, + MetaProperty: function(M) { + var expr = from_moz(M.meta); + var prop = read_name(M.property); + if (expr.name == "new" && prop == "target") return new AST_NewTarget({ + start: my_start_token(M), + end: my_end_token(M), + name: "new.target", + }); + return new AST_Dot({ + start: my_start_token(M), + end: my_end_token(M), + expression: expr, + property: prop, + }); + }, + SwitchCase: function(M) { + return new (M.test ? AST_Case : AST_Default)({ + start : my_start_token(M), + end : my_end_token(M), + expression : from_moz(M.test), + body : M.consequent.map(from_moz), + }); + }, + ExportAllDeclaration: function(M) { + var start = my_start_token(M); + var end = my_end_token(M); + return new AST_ExportForeign({ + start: start, + end: end, + aliases: [ M.exported ? from_moz_alias(M.exported) : new AST_String({ + start: start, + value: "*", + end: end, + }) ], + keys: [ new AST_String({ + start: start, + value: "*", + end: end, + }) ], + path: from_moz(M.source), + }); + }, + ExportDefaultDeclaration: function(M) { + var decl = from_moz(M.declaration); + if (!decl.name) switch (decl.CTOR) { + case AST_AsyncDefun: + decl = new AST_AsyncFunction(decl); + break; + case AST_AsyncGeneratorDefun: + decl = new AST_AsyncGeneratorFunction(decl); + break; + case AST_DefClass: + decl = new AST_ClassExpression(decl); + break; + case AST_Defun: + decl = new AST_Function(decl); + break; + case AST_GeneratorDefun: + decl = new AST_GeneratorFunction(decl); + break; + } + return new AST_ExportDefault({ + start: my_start_token(M), + end: my_end_token(M), + body: decl, + }); + }, + ExportNamedDeclaration: function(M) { + if (M.declaration) return new AST_ExportDeclaration({ + start: my_start_token(M), + end: my_end_token(M), + body: from_moz(M.declaration), + }); + if (M.source) { + var aliases = [], keys = []; + M.specifiers.forEach(function(prop) { + aliases.push(from_moz_alias(prop.exported)); + keys.push(from_moz_alias(prop.local)); + }); + return new AST_ExportForeign({ + start: my_start_token(M), + end: my_end_token(M), + aliases: aliases, + keys: keys, + path: from_moz(M.source), + }); + } + return new AST_ExportReferences({ + start: my_start_token(M), + end: my_end_token(M), + properties: M.specifiers.map(function(prop) { + var sym = new AST_SymbolExport(from_moz(prop.local)); + sym.alias = from_moz_alias(prop.exported); + return sym; + }), + }); + }, + ImportDeclaration: function(M) { + var start = my_start_token(M); + var end = my_end_token(M); + var all = null, def = null, props = null; + M.specifiers.forEach(function(prop) { + var sym = new AST_SymbolImport(from_moz(prop.local)); + switch (prop.type) { + case "ImportDefaultSpecifier": + def = sym; + def.key = new AST_String({ + start: start, + value: "", + end: end, + }); + break; + case "ImportNamespaceSpecifier": + all = sym; + all.key = new AST_String({ + start: start, + value: "*", + end: end, + }); + break; + default: + sym.key = from_moz_alias(prop.imported); + if (!props) props = []; + props.push(sym); + break; + } + }); + return new AST_Import({ + start: start, + end: end, + all: all, + default: def, + properties: props, + path: from_moz(M.source), + }); + }, + ImportExpression: function(M) { + var start = my_start_token(M); + var arg = from_moz(M.source); + return new AST_Call({ + start: start, + end: my_end_token(M), + expression: new AST_SymbolRef({ + start: start, + end: arg.start, + name: "import", + }), + args: [ arg ], + }); + }, + VariableDeclaration: function(M) { + return new ({ + const: AST_Const, + let: AST_Let, + }[M.kind] || AST_Var)({ + start: my_start_token(M), + end: my_end_token(M), + definitions: M.declarations.map(from_moz), + }); + }, + Literal: function(M) { + var args = { + start: my_start_token(M), + end: my_end_token(M), + }; + if (M.bigint) { + args.value = M.bigint.toLowerCase(); + return new AST_BigInt(args); + } + var val = M.value; + if (val === null) return new AST_Null(args); + var rx = M.regex; + if (rx && rx.pattern) { + // RegExpLiteral as per ESTree AST spec + args.value = new RegExp(rx.pattern, rx.flags); + args.value.raw_source = rx.pattern; + return new AST_RegExp(args); + } else if (rx) { + // support legacy RegExp + args.value = M.regex && M.raw ? M.raw : val; + return new AST_RegExp(args); + } + switch (typeof val) { + case "string": + args.value = val; + return new AST_String(args); + case "number": + if (isNaN(val)) return new AST_NaN(args); + var negate, node; + if (isFinite(val)) { + negate = 1 / val < 0; + args.value = negate ? -val : val; + node = new AST_Number(args); + } else { + negate = val < 0; + node = new AST_Infinity(args); + } + return negate ? new AST_UnaryPrefix({ + start: args.start, + end: args.end, + operator: "-", + expression: node, + }) : node; + case "boolean": + return new (val ? AST_True : AST_False)(args); + } + }, + TemplateLiteral: function(M) { + return new AST_Template({ + start: my_start_token(M), + end: my_end_token(M), + expressions: M.expressions.map(from_moz), + strings: M.quasis.map(function(el) { + return el.value.raw; + }), + }); + }, + TaggedTemplateExpression: function(M) { + var tmpl = from_moz(M.quasi); + tmpl.start = my_start_token(M); + tmpl.end = my_end_token(M); + tmpl.tag = from_moz(M.tag); + return tmpl; + }, + Identifier: function(M) { + var p, level = FROM_MOZ_STACK.length - 1; + do { + p = FROM_MOZ_STACK[--level]; + } while (p.type == "ArrayPattern" + || p.type == "AssignmentPattern" && p.left === FROM_MOZ_STACK[level + 1] + || p.type == "ObjectPattern" + || p.type == "Property" && p.value === FROM_MOZ_STACK[level + 1] + || p.type == "VariableDeclarator" && p.id === FROM_MOZ_STACK[level + 1]); + var ctor = AST_SymbolRef; + switch (p.type) { + case "ArrowFunctionExpression": + if (p.body !== FROM_MOZ_STACK[level + 1]) ctor = AST_SymbolFunarg; + break; + case "BreakStatement": + case "ContinueStatement": + ctor = AST_LabelRef; + break; + case "CatchClause": + ctor = AST_SymbolCatch; + break; + case "ClassDeclaration": + if (p.id === FROM_MOZ_STACK[level + 1]) ctor = AST_SymbolDefClass; + break; + case "ClassExpression": + if (p.id === FROM_MOZ_STACK[level + 1]) ctor = AST_SymbolClass; + break; + case "FunctionDeclaration": + ctor = p.id === FROM_MOZ_STACK[level + 1] ? AST_SymbolDefun : AST_SymbolFunarg; + break; + case "FunctionExpression": + ctor = p.id === FROM_MOZ_STACK[level + 1] ? AST_SymbolLambda : AST_SymbolFunarg; + break; + case "LabeledStatement": + ctor = AST_Label; + break; + case "VariableDeclaration": + ctor = { + const: AST_SymbolConst, + let: AST_SymbolLet, + }[p.kind] || AST_SymbolVar; + break; + } + return new ctor({ + start: my_start_token(M), + end: my_end_token(M), + name: M.name, + }); + }, + Super: function(M) { + return new AST_Super({ + start: my_start_token(M), + end: my_end_token(M), + name: "super", + }); + }, + ThisExpression: function(M) { + return new AST_This({ + start: my_start_token(M), + end: my_end_token(M), + name: "this", + }); + }, + ParenthesizedExpression: function(M) { + var node = from_moz(M.expression); + if (!node.start.parens) node.start.parens = []; + node.start.parens.push(my_start_token(M)); + if (!node.end.parens) node.end.parens = []; + node.end.parens.push(my_end_token(M)); + return node; + }, + ChainExpression: function(M) { + var node = from_moz(M.expression); + node.terminal = true; + return node; + }, + }; + + MOZ_TO_ME.UpdateExpression = + MOZ_TO_ME.UnaryExpression = function To_Moz_Unary(M) { + var prefix = "prefix" in M ? M.prefix + : M.type == "UnaryExpression" ? true : false; + return new (prefix ? AST_UnaryPrefix : AST_UnaryPostfix)({ + start : my_start_token(M), + end : my_end_token(M), + operator : M.operator, + expression : from_moz(M.argument) + }); + }; + + map("EmptyStatement", AST_EmptyStatement); + map("ExpressionStatement", AST_SimpleStatement, "expression>body"); + map("BlockStatement", AST_BlockStatement, "body@body"); + map("IfStatement", AST_If, "test>condition, consequent>body, alternate>alternative"); + map("LabeledStatement", AST_LabeledStatement, "label>label, body>body"); + map("BreakStatement", AST_Break, "label>label"); + map("ContinueStatement", AST_Continue, "label>label"); + map("WithStatement", AST_With, "object>expression, body>body"); + map("SwitchStatement", AST_Switch, "discriminant>expression, cases@body"); + map("ReturnStatement", AST_Return, "argument>value"); + map("ThrowStatement", AST_Throw, "argument>value"); + map("WhileStatement", AST_While, "test>condition, body>body"); + map("DoWhileStatement", AST_Do, "test>condition, body>body"); + map("ForStatement", AST_For, "init>init, test>condition, update>step, body>body"); + map("ForInStatement", AST_ForIn, "left>init, right>object, body>body"); + map("DebuggerStatement", AST_Debugger); + map("VariableDeclarator", AST_VarDef, "id>name, init>value"); + map("CatchClause", AST_Catch, "param>argname, body%body"); + + map("BinaryExpression", AST_Binary, "operator=operator, left>left, right>right"); + map("LogicalExpression", AST_Binary, "operator=operator, left>left, right>right"); + map("AssignmentExpression", AST_Assign, "operator=operator, left>left, right>right"); + map("AssignmentPattern", AST_DefaultValue, "left>name, right>value"); + map("ConditionalExpression", AST_Conditional, "test>condition, consequent>consequent, alternate>alternative"); + map("NewExpression", AST_New, "callee>expression, arguments@args, pure=pure"); + map("SequenceExpression", AST_Sequence, "expressions@expressions"); + map("SpreadElement", AST_Spread, "argument>expression"); + map("ObjectExpression", AST_Object, "properties@properties"); + map("AwaitExpression", AST_Await, "argument>expression"); + map("YieldExpression", AST_Yield, "argument>expression, delegate=nested"); + + def_to_moz(AST_Toplevel, function To_Moz_Program(M) { + return to_moz_scope("Program", M); + }); + + def_to_moz(AST_LambdaDefinition, function To_Moz_FunctionDeclaration(M) { + var params = M.argnames.map(to_moz); + if (M.rest) params.push({ + type: "RestElement", + argument: to_moz(M.rest), + }); + return { + type: "FunctionDeclaration", + id: to_moz(M.name), + async: is_async(M), + generator: is_generator(M), + params: params, + body: to_moz_scope("BlockStatement", M), + }; + }); + + def_to_moz(AST_Lambda, function To_Moz_FunctionExpression(M) { + var params = M.argnames.map(to_moz); + if (M.rest) params.push({ + type: "RestElement", + argument: to_moz(M.rest), + }); + if (is_arrow(M)) return { + type: "ArrowFunctionExpression", + async: is_async(M), + params: params, + expression: !!M.value, + body: M.value ? to_moz(M.value) : to_moz_scope("BlockStatement", M), + }; + return { + type: "FunctionExpression", + id: to_moz(M.name), + async: is_async(M), + generator: is_generator(M), + params: params, + body: to_moz_scope("BlockStatement", M), + }; + }); + + def_to_moz(AST_Call, function To_Moz_CallExpression(M) { + var expr = M.expression; + if (M.args.length == 1 && expr instanceof AST_SymbolRef && expr.name == "import") return { + type: "ImportExpression", + source: to_moz(M.args[0]), + }; + return { + type: "CallExpression", + callee: to_moz(expr), + arguments: M.args.map(to_moz), + optional: M.optional, + pure: M.pure, + }; + }); + + def_to_moz(AST_DefClass, function To_Moz_ClassDeclaration(M) { + return { + type: "ClassDeclaration", + id: to_moz(M.name), + superClass: to_moz(M.extends), + body: { + type: "ClassBody", + body: M.properties.map(to_moz), + }, + }; + }); + + def_to_moz(AST_ClassExpression, function To_Moz_ClassExpression(M) { + return { + type: "ClassExpression", + id: to_moz(M.name), + superClass: to_moz(M.extends), + body: { + type: "ClassBody", + body: M.properties.map(to_moz), + }, + }; + }); + + function To_Moz_MethodDefinition(kind) { + return function(M) { + var computed = M.key instanceof AST_Node; + var key = computed ? to_moz(M.key) : M.private ? { + type: "PrivateIdentifier", + name: M.key.slice(1), + } : { + type: "Literal", + value: M.key, + }; + return { + type: "MethodDefinition", + kind: kind, + computed: computed, + key: key, + static: M.static, + value: to_moz(M.value), + }; + }; + } + def_to_moz(AST_ClassGetter, To_Moz_MethodDefinition("get")); + def_to_moz(AST_ClassSetter, To_Moz_MethodDefinition("set")); + def_to_moz(AST_ClassMethod, To_Moz_MethodDefinition("method")); + + def_to_moz(AST_ClassField, function To_Moz_PropertyDefinition(M) { + var computed = M.key instanceof AST_Node; + var key = computed ? to_moz(M.key) : M.private ? { + type: "PrivateIdentifier", + name: M.key.slice(1), + } : { + type: "Literal", + value: M.key, + }; + return { + type: "PropertyDefinition", + computed: computed, + key: key, + static: M.static, + value: to_moz(M.value), + }; + }); + + def_to_moz(AST_ClassInit, function To_Moz_StaticBlock(M) { + return to_moz_scope("StaticBlock", M.value); + }); + + function To_Moz_ForOfStatement(is_await) { + return function(M) { + return { + type: "ForOfStatement", + await: is_await, + left: to_moz(M.init), + right: to_moz(M.object), + body: to_moz(M.body), + }; + }; + } + def_to_moz(AST_ForAwaitOf, To_Moz_ForOfStatement(true)); + def_to_moz(AST_ForOf, To_Moz_ForOfStatement(false)); + + def_to_moz(AST_Directive, function To_Moz_Directive(M) { + return { + type: "ExpressionStatement", + directive: M.value, + expression: set_moz_loc(M, { + type: "Literal", + value: M.value, + }), + }; + }); + + def_to_moz(AST_SwitchBranch, function To_Moz_SwitchCase(M) { + return { + type: "SwitchCase", + test: to_moz(M.expression), + consequent: M.body.map(to_moz), + }; + }); + + def_to_moz(AST_Try, function To_Moz_TryStatement(M) { + return { + type: "TryStatement", + block: to_moz_block(M), + handler: to_moz(M.bcatch), + finalizer: to_moz(M.bfinally), + }; + }); + + def_to_moz(AST_Catch, function To_Moz_CatchClause(M) { + return { + type: "CatchClause", + param: to_moz(M.argname), + body: to_moz_block(M), + }; + }); + + def_to_moz(AST_ExportDeclaration, function To_Moz_ExportNamedDeclaration_declaration(M) { + return { + type: "ExportNamedDeclaration", + declaration: to_moz(M.body), + specifiers: [], + }; + }); + + def_to_moz(AST_ExportDefault, function To_Moz_ExportDefaultDeclaration(M) { + return { + type: "ExportDefaultDeclaration", + declaration: to_moz(M.body), + }; + }); + + def_to_moz(AST_ExportForeign, function To_Moz_ExportAllDeclaration_ExportNamedDeclaration(M) { + if (M.keys[0].value == "*") return { + type: "ExportAllDeclaration", + exported: M.aliases[0].value == "*" ? null : to_moz_alias(M.aliases[0]), + source: to_moz(M.path), + }; + var specifiers = []; + for (var i = 0; i < M.aliases.length; i++) { + specifiers.push(set_moz_loc({ + start: M.keys[i].start, + end: M.aliases[i].end, + }, { + type: "ExportSpecifier", + local: to_moz_alias(M.keys[i]), + exported: to_moz_alias(M.aliases[i]), + })); + } + return { + type: "ExportNamedDeclaration", + specifiers: specifiers, + source: to_moz(M.path), + }; + }); + + def_to_moz(AST_ExportReferences, function To_Moz_ExportNamedDeclaration_specifiers(M) { + return { + type: "ExportNamedDeclaration", + specifiers: M.properties.map(function(prop) { + return set_moz_loc({ + start: prop.start, + end: prop.alias.end, + }, { + type: "ExportSpecifier", + local: to_moz(prop), + exported: to_moz_alias(prop.alias), + }); + }), + }; + }); + + def_to_moz(AST_Import, function To_Moz_ImportDeclaration(M) { + var specifiers = M.properties ? M.properties.map(function(prop) { + return set_moz_loc({ + start: prop.key.start, + end: prop.end, + }, { + type: "ImportSpecifier", + local: to_moz(prop), + imported: to_moz_alias(prop.key), + }); + }) : []; + if (M.all) specifiers.unshift(set_moz_loc(M.all, { + type: "ImportNamespaceSpecifier", + local: to_moz(M.all), + })); + if (M.default) specifiers.unshift(set_moz_loc(M.default, { + type: "ImportDefaultSpecifier", + local: to_moz(M.default), + })); + return { + type: "ImportDeclaration", + specifiers: specifiers, + source: to_moz(M.path), + }; + }); + + def_to_moz(AST_Definitions, function To_Moz_VariableDeclaration(M) { + return { + type: "VariableDeclaration", + kind: M.TYPE.toLowerCase(), + declarations: M.definitions.map(to_moz), + }; + }); + + def_to_moz(AST_PropAccess, function To_Moz_MemberExpression(M) { + var computed = M instanceof AST_Sub; + var expr = { + type: "MemberExpression", + object: to_moz(M.expression), + computed: computed, + optional: M.optional, + property: computed ? to_moz(M.property) : { + type: "Identifier", + name: M.property, + }, + }; + return M.terminal ? { + type: "ChainExpression", + expression: expr, + } : expr; + }); + + def_to_moz(AST_Unary, function To_Moz_Unary(M) { + return { + type: M.operator == "++" || M.operator == "--" ? "UpdateExpression" : "UnaryExpression", + operator: M.operator, + prefix: M instanceof AST_UnaryPrefix, + argument: to_moz(M.expression) + }; + }); + + def_to_moz(AST_Binary, function To_Moz_BinaryExpression(M) { + return { + type: M.operator == "&&" || M.operator == "||" ? "LogicalExpression" : "BinaryExpression", + left: to_moz(M.left), + operator: M.operator, + right: to_moz(M.right) + }; + }); + + def_to_moz(AST_Array, function To_Moz_ArrayExpression(M) { + return { + type: "ArrayExpression", + elements: M.elements.map(to_moz), + }; + }); + + def_to_moz(AST_DestructuredArray, function To_Moz_ArrayPattern(M) { + var elements = M.elements.map(to_moz); + if (M.rest) elements.push({ + type: "RestElement", + argument: to_moz(M.rest), + }); + return { + type: "ArrayPattern", + elements: elements, + }; + }); + + def_to_moz(AST_DestructuredKeyVal, function To_Moz_Property(M) { + var computed = M.key instanceof AST_Node; + var key = computed ? to_moz(M.key) : { + type: "Literal", + value: M.key, + }; + return { + type: "Property", + kind: "init", + computed: computed, + method: false, + shorthand: false, + key: key, + value: to_moz(M.value), + }; + }); + + def_to_moz(AST_DestructuredObject, function To_Moz_ObjectPattern(M) { + var props = M.properties.map(to_moz); + if (M.rest) props.push({ + type: "RestElement", + argument: to_moz(M.rest), + }); + return { + type: "ObjectPattern", + properties: props, + }; + }); + + def_to_moz(AST_ObjectProperty, function To_Moz_Property(M) { + var computed = M.key instanceof AST_Node; + var key = computed ? to_moz(M.key) : { + type: "Literal", + value: M.key, + }; + var kind; + if (M instanceof AST_ObjectKeyVal) { + kind = "init"; + } else if (M instanceof AST_ObjectGetter) { + kind = "get"; + } else if (M instanceof AST_ObjectSetter) { + kind = "set"; + } + return { + type: "Property", + kind: kind, + computed: computed, + method: M instanceof AST_ObjectMethod, + shorthand: false, + key: key, + value: to_moz(M.value), + }; + }); + + def_to_moz(AST_Symbol, function To_Moz_Identifier(M) { + var def = M.definition(); + return { + type: "Identifier", + name: def && def.mangled_name || M.name, + }; + }); + + def_to_moz(AST_Super, function To_Moz_Super() { + return { type: "Super" }; + }); + + def_to_moz(AST_This, function To_Moz_ThisExpression() { + return { type: "ThisExpression" }; + }); + + def_to_moz(AST_NewTarget, function To_Moz_MetaProperty() { + return { + type: "MetaProperty", + meta: { + type: "Identifier", + name: "new", + }, + property: { + type: "Identifier", + name: "target", + }, + }; + }); + + def_to_moz(AST_RegExp, function To_Moz_RegExpLiteral(M) { + var flags = M.value.toString().match(/\/([gimuy]*)$/)[1]; + var value = "/" + M.value.raw_source + "/" + flags; + return { + type: "Literal", + value: value, + raw: value, + regex: { + pattern: M.value.raw_source, + flags: flags, + }, + }; + }); + + def_to_moz(AST_BigInt, function To_Moz_BigInt(M) { + var value = M.value; + return { + type: "Literal", + bigint: value, + raw: value + "n", + }; + }); + + function To_Moz_Literal(M) { + var value = M.value; + if (typeof value === "number" && (value < 0 || (value === 0 && 1 / value < 0))) { + return { + type: "UnaryExpression", + operator: "-", + prefix: true, + argument: { + type: "Literal", + value: -value, + raw: M.start.raw, + }, + }; + } + return { + type: "Literal", + value: value, + raw: M.start.raw, + }; + } + def_to_moz(AST_Boolean, To_Moz_Literal); + def_to_moz(AST_Constant, To_Moz_Literal); + def_to_moz(AST_Null, To_Moz_Literal); + + def_to_moz(AST_Atom, function To_Moz_Atom(M) { + return { + type: "Identifier", + name: String(M.value), + }; + }); + + def_to_moz(AST_Template, function To_Moz_TemplateLiteral_TaggedTemplateExpression(M) { + var last = M.strings.length - 1; + var tmpl = { + type: "TemplateLiteral", + expressions: M.expressions.map(to_moz), + quasis: M.strings.map(function(str, index) { + return { + type: "TemplateElement", + tail: index == last, + value: { raw: str }, + }; + }), + }; + if (!M.tag) return tmpl; + return { + type: "TaggedTemplateExpression", + tag: to_moz(M.tag), + quasi: tmpl, + }; + }); + + AST_Block.DEFMETHOD("to_mozilla_ast", AST_BlockStatement.prototype.to_mozilla_ast); + AST_Hole.DEFMETHOD("to_mozilla_ast", return_null); + AST_Node.DEFMETHOD("to_mozilla_ast", function() { + throw new Error("Cannot convert AST_" + this.TYPE); + }); + + /* -----[ tools ]----- */ + + function normalize_directives(body) { + for (var i = 0; i < body.length; i++) { + var stat = body[i]; + if (!(stat instanceof AST_SimpleStatement)) break; + var node = stat.body; + if (!(node instanceof AST_String)) break; + if (stat.start.pos !== node.start.pos) break; + body[i] = new AST_Directive(node); + } + return body; + } + + function raw_token(moznode) { + if (moznode.type == "Literal") { + return moznode.raw != null ? moznode.raw : moznode.value + ""; + } + } + + function my_start_token(moznode) { + var loc = moznode.loc, start = loc && loc.start; + var range = moznode.range; + return new AST_Token({ + file : loc && loc.source, + line : start && start.line, + col : start && start.column, + pos : range ? range[0] : moznode.start, + endline : start && start.line, + endcol : start && start.column, + endpos : range ? range[0] : moznode.start, + raw : raw_token(moznode), + }); + } + + function my_end_token(moznode) { + var loc = moznode.loc, end = loc && loc.end; + var range = moznode.range; + return new AST_Token({ + file : loc && loc.source, + line : end && end.line, + col : end && end.column, + pos : range ? range[1] : moznode.end, + endline : end && end.line, + endcol : end && end.column, + endpos : range ? range[1] : moznode.end, + raw : raw_token(moznode), + }); + } + + function read_name(M) { + return "" + M[M.type == "Identifier" ? "name" : "value"]; + } + + function map(moztype, mytype, propmap) { + var moz_to_me = [ + "start: my_start_token(M)", + "end: my_end_token(M)", + ]; + var me_to_moz = [ + "type: " + JSON.stringify(moztype), + ]; + + if (propmap) propmap.split(/\s*,\s*/).forEach(function(prop) { + var m = /([a-z0-9$_]+)(=|@|>|%)([a-z0-9$_]+)/i.exec(prop); + if (!m) throw new Error("Can't understand property map: " + prop); + var moz = m[1], how = m[2], my = m[3]; + switch (how) { + case "@": + moz_to_me.push(my + ": M." + moz + ".map(from_moz)"); + me_to_moz.push(moz + ": M." + my + ".map(to_moz)"); + break; + case ">": + moz_to_me.push(my + ": from_moz(M." + moz + ")"); + me_to_moz.push(moz + ": to_moz(M." + my + ")"); + break; + case "=": + moz_to_me.push(my + ": M." + moz); + me_to_moz.push(moz + ": M." + my); + break; + case "%": + moz_to_me.push(my + ": from_moz(M." + moz + ").body"); + me_to_moz.push(moz + ": to_moz_block(M)"); + break; + default: + throw new Error("Can't understand operator in propmap: " + prop); + } + }); + + MOZ_TO_ME[moztype] = new Function("U2", "my_start_token", "my_end_token", "from_moz", [ + "return function From_Moz_" + moztype + "(M) {", + " return new U2.AST_" + mytype.TYPE + "({", + moz_to_me.join(",\n"), + " });", + "};", + ].join("\n"))(exports, my_start_token, my_end_token, from_moz); + def_to_moz(mytype, new Function("to_moz", "to_moz_block", "to_moz_scope", [ + "return function To_Moz_" + moztype + "(M) {", + " return {", + me_to_moz.join(",\n"), + " };", + "};", + ].join("\n"))(to_moz, to_moz_block, to_moz_scope)); + } + + var FROM_MOZ_STACK = null; + + function from_moz(moz) { + FROM_MOZ_STACK.push(moz); + var node = null; + if (moz) { + if (!HOP(MOZ_TO_ME, moz.type)) throw new Error("Unsupported type: " + moz.type); + node = MOZ_TO_ME[moz.type](moz); + } + FROM_MOZ_STACK.pop(); + return node; + } + + function from_moz_alias(moz) { + return new AST_String({ + start: my_start_token(moz), + value: read_name(moz), + end: my_end_token(moz), + }); + } + + AST_Node.from_mozilla_ast = function(node) { + var save_stack = FROM_MOZ_STACK; + FROM_MOZ_STACK = []; + var ast = from_moz(node); + FROM_MOZ_STACK = save_stack; + ast.walk(new TreeWalker(function(node) { + if (node instanceof AST_LabelRef) { + for (var level = 0, parent; parent = this.parent(level); level++) { + if (parent instanceof AST_Scope) break; + if (parent instanceof AST_LabeledStatement && parent.label.name == node.name) { + node.thedef = parent.label; + break; + } + } + if (!node.thedef) { + var s = node.start; + js_error("Undefined label " + node.name, s.file, s.line, s.col, s.pos); + } + } + })); + return ast; + }; + + function set_moz_loc(mynode, moznode) { + var start = mynode.start; + var end = mynode.end; + if (start.pos != null && end.endpos != null) { + moznode.range = [start.pos, end.endpos]; + } + if (start.line) { + moznode.loc = { + start: {line: start.line, column: start.col}, + end: end.endline ? {line: end.endline, column: end.endcol} : null, + }; + if (start.file) { + moznode.loc.source = start.file; + } + } + return moznode; + } + + function def_to_moz(mytype, handler) { + mytype.DEFMETHOD("to_mozilla_ast", function() { + return set_moz_loc(this, handler(this)); + }); + } + + function to_moz(node) { + return node != null ? node.to_mozilla_ast() : null; + } + + function to_moz_alias(alias) { + return is_identifier_string(alias.value) ? set_moz_loc(alias, { + type: "Identifier", + name: alias.value, + }) : to_moz(alias); + } + + function to_moz_block(node) { + return { + type: "BlockStatement", + body: node.body.map(to_moz), + }; + } + + function to_moz_scope(type, node) { + var body = node.body.map(to_moz); + if (node.body[0] instanceof AST_SimpleStatement && node.body[0].body instanceof AST_String) { + body.unshift(to_moz(new AST_EmptyStatement(node.body[0]))); + } + return { + type: type, + body: body, + }; + } +})(); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/output.js b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/output.js new file mode 100644 index 0000000000000000000000000000000000000000..ac275445eb82b69ea18648dc234803e10b96c898 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/output.js @@ -0,0 +1,1983 @@ +/*********************************************************************** + + A JavaScript tokenizer / parser / beautifier / compressor. + https://github.com/mishoo/UglifyJS + + -------------------------------- (C) --------------------------------- + + Author: Mihai Bazon + + http://mihai.bazon.net/blog + + Distributed under the BSD license: + + Copyright 2012 (c) Mihai Bazon + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + * Redistributions of source code must retain the above + copyright notice, this list of conditions and the following + disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials + provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY + EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, + OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF + THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + SUCH DAMAGE. + + ***********************************************************************/ + +"use strict"; + +function is_some_comments(comment) { + // multiline comment + return comment.type == "comment2" && /@preserve|@license|@cc_on/i.test(comment.value); +} + +function OutputStream(options) { + options = defaults(options, { + annotations : false, + ascii_only : false, + beautify : false, + braces : false, + comments : false, + extendscript : false, + galio : false, + ie : false, + indent_level : 4, + indent_start : 0, + inline_script : true, + keep_quoted_props: false, + max_line_len : false, + module : false, + preamble : null, + preserve_line : false, + quote_keys : false, + quote_style : 0, + semicolons : true, + shebang : true, + source_map : null, + v8 : false, + webkit : false, + width : 80, + wrap_iife : false, + }, true); + + // Convert comment option to RegExp if necessary and set up comments filter + var comment_filter = return_false; // Default case, throw all comments away + if (options.comments) { + var comments = options.comments; + if (typeof options.comments === "string" && /^\/.*\/[a-zA-Z]*$/.test(options.comments)) { + var regex_pos = options.comments.lastIndexOf("/"); + comments = new RegExp( + options.comments.substr(1, regex_pos - 1), + options.comments.substr(regex_pos + 1) + ); + } + if (comments instanceof RegExp) { + comment_filter = function(comment) { + return comment.type != "comment5" && comments.test(comment.value); + }; + } else if (typeof comments === "function") { + comment_filter = function(comment) { + return comment.type != "comment5" && comments(this, comment); + }; + } else if (comments === "some") { + comment_filter = is_some_comments; + } else { // NOTE includes "all" option + comment_filter = return_true; + } + } + + function make_indent(value) { + if (typeof value == "number") return new Array(value + 1).join(" "); + if (!value) return ""; + if (!/^\s*$/.test(value)) throw new Error("unsupported indentation: " + JSON.stringify("" + value)); + return value; + } + + var current_col = 0; + var current_line = 1; + var current_indent = make_indent(options.indent_start); + var full_indent = make_indent(options.indent_level); + var half_indent = full_indent.length + 1 >> 1; + var last; + var line_end = 0; + var line_fixed = true; + var mappings = options.source_map && []; + var mapping_name; + var mapping_token; + var might_need_space; + var might_need_semicolon; + var need_newline_indented = false; + var need_space = false; + var output; + var stack; + var stored = ""; + + function reset() { + last = ""; + might_need_space = false; + might_need_semicolon = false; + stack = []; + var str = output; + output = ""; + return str; + } + + reset(); + var to_utf8 = options.ascii_only ? function(str, identifier) { + if (identifier || options.module) str = str.replace(/[\ud800-\udbff][\udc00-\udfff]/g, function(ch) { + return "\\u{" + (ch.charCodeAt(0) - 0xd7c0 << 10 | ch.charCodeAt(1) - 0xdc00).toString(16) + "}"; + }); + return str.replace(/[\u0000-\u001f\u007f-\uffff]/g, function(s, i) { + var code = s.charCodeAt(0).toString(16); + if (code.length <= 2 && !identifier) { + switch (s) { + case "\n": return "\\n"; + case "\r": return "\\r"; + case "\t": return "\\t"; + case "\b": return "\\b"; + case "\f": return "\\f"; + case "\x0B": return options.ie ? "\\x0B" : "\\v"; + case "\0": + return /[0-9]/.test(str.charAt(i+1)) ? "\\x00" : "\\0"; + } + while (code.length < 2) code = "0" + code; + return "\\x" + code; + } else { + while (code.length < 4) code = "0" + code; + return "\\u" + code; + } + }); + } : function(str) { + var s = ""; + for (var i = 0, j = 0; i < str.length; i++) { + var code = str.charCodeAt(i); + if (is_surrogate_pair_head(code)) { + if (is_surrogate_pair_tail(str.charCodeAt(i + 1))) { + i++; + continue; + } + } else if (!is_surrogate_pair_tail(code)) { + continue; + } + s += str.slice(j, i) + "\\u" + code.toString(16); + j = i + 1; + } + return j == 0 ? str : s + str.slice(j); + }; + + function quote_single(str) { + return "'" + str.replace(/\x27/g, "\\'") + "'"; + } + + function quote_double(str) { + return '"' + str.replace(/\x22/g, '\\"') + '"'; + } + + var quote_string = [ + null, + quote_single, + quote_double, + function(str, quote) { + return quote == "'" ? quote_single(str) : quote_double(str); + }, + ][options.quote_style] || function(str, quote, dq, sq) { + return dq > sq ? quote_single(str) : quote_double(str); + }; + + function make_string(str, quote) { + var dq = 0, sq = 0; + str = str.replace(/[\\\b\f\n\r\v\t\x22\x27\u2028\u2029\0\ufeff]/g, function(s, i) { + switch (s) { + case '"': ++dq; return '"'; + case "'": ++sq; return "'"; + case "\\": return "\\\\"; + case "\n": return "\\n"; + case "\r": return "\\r"; + case "\t": return "\\t"; + case "\b": return "\\b"; + case "\f": return "\\f"; + case "\x0B": return options.ie ? "\\x0B" : "\\v"; + case "\u2028": return "\\u2028"; + case "\u2029": return "\\u2029"; + case "\ufeff": return "\\ufeff"; + case "\0": + return /[0-9]/.test(str.charAt(i+1)) ? "\\x00" : "\\0"; + } + return s; + }); + return quote_string(to_utf8(str), quote, dq, sq); + } + + /* -----[ beautification/minification ]----- */ + + var adjust_mappings = mappings ? function(line, col) { + mappings.forEach(function(mapping) { + mapping.line += line; + mapping.col += col; + }); + } : noop; + + var flush_mappings = mappings ? function() { + mappings.forEach(function(mapping) { + options.source_map.add( + mapping.token.file, + mapping.line, mapping.col, + mapping.token.line, mapping.token.col, + !mapping.name && mapping.token.type == "name" ? mapping.token.value : mapping.name + ); + }); + mappings = []; + } : noop; + + function insert_newlines(count) { + stored += output.slice(0, line_end); + output = output.slice(line_end); + var new_col = output.length; + adjust_mappings(count, new_col - current_col); + current_line += count; + current_col = new_col; + while (count--) stored += "\n"; + } + + var fix_line = options.max_line_len ? function(flush) { + if (line_fixed) { + if (current_col > options.max_line_len) { + AST_Node.warn("Output exceeds {max_line_len} characters", options); + } + return; + } + if (current_col > options.max_line_len) { + insert_newlines(1); + line_fixed = true; + } + if (line_fixed || flush) flush_mappings(); + } : noop; + + var stat_end_chars = makePredicate("; }"); + var asi_skip_chars = makePredicate("( [ + * / - , . `"); + var asi_skip_words = makePredicate("in instanceof"); + + function require_space(prev, ch, str) { + return is_identifier_char(prev) && (is_identifier_char(ch) || ch == "\\") + || (ch == "/" && ch == prev) + || ((ch == "+" || ch == "-") && ch == last) + || last == "--" && ch == ">" + || last == "!" && str == "--" + || prev == "/" && (str == "in" || str == "instanceof"); + } + + var print = options.beautify + || options.comments + || options.max_line_len + || options.preserve_line + || options.shebang + || !options.semicolons + || options.source_map + || options.width ? function(str) { + var ch = str.charAt(0); + if (need_newline_indented && ch) { + need_newline_indented = false; + if (ch != "\n") { + print("\n"); + indent(); + } + } + if (need_space && ch) { + need_space = false; + if (!/[\s;})]/.test(ch)) { + space(); + } + } + var prev = last.slice(-1); + if (might_need_semicolon) { + might_need_semicolon = false; + if (prev != ";" && !stat_end_chars[ch]) { + var need_semicolon = asi_skip_chars[ch] || asi_skip_words[str]; + if (need_semicolon || options.semicolons) { + output += ";"; + current_col++; + if (!line_fixed) { + fix_line(); + if (line_fixed && !need_semicolon && output == ";") { + output = ""; + current_col = 0; + } + } + if (line_end == output.length - 1) line_end++; + } else { + fix_line(); + output += "\n"; + current_line++; + current_col = 0; + // reset the semicolon flag, since we didn't print one + // now and might still have to later + if (/^\s+$/.test(str)) might_need_semicolon = true; + } + if (!options.beautify) might_need_space = false; + } + } + + if (might_need_space) { + if (require_space(prev, ch, str)) { + output += " "; + current_col++; + } + if (prev != "<" || str != "!") might_need_space = false; + } + + if (mapping_token) { + mappings.push({ + token: mapping_token, + name: mapping_name, + line: current_line, + col: current_col, + }); + mapping_token = false; + if (line_fixed) flush_mappings(); + } + + output += str; + var a = str.split(/\r?\n/), n = a.length - 1; + current_line += n; + current_col += a[0].length; + if (n > 0) { + fix_line(); + current_col = a[n].length; + } + last = str; + } : function(str) { + var ch = str.charAt(0); + var prev = last.slice(-1); + if (might_need_semicolon) { + might_need_semicolon = false; + if (prev == ":" && ch == "}" || (!ch || ";}".indexOf(ch) < 0) && prev != ";") { + output += ";"; + might_need_space = false; + } + } + if (might_need_space) { + if (require_space(prev, ch, str)) output += " "; + if (prev != "<" || str != "!") might_need_space = false; + } + output += str; + last = str; + }; + + var space = options.beautify ? function() { + print(" "); + } : function() { + might_need_space = true; + }; + + var indent = options.beautify ? function(half) { + if (need_newline_indented) print("\n"); + print(half ? current_indent.slice(0, -half_indent) : current_indent); + } : noop; + + var with_indent = options.beautify ? function(cont) { + var save_indentation = current_indent; + current_indent += full_indent; + cont(); + current_indent = save_indentation; + } : function(cont) { cont() }; + + var may_add_newline = options.max_line_len || options.preserve_line ? function() { + fix_line(); + line_end = output.length; + line_fixed = false; + } : noop; + + var newline = options.beautify ? function() { + print("\n"); + line_end = output.length; + } : may_add_newline; + + var semicolon = options.beautify ? function() { + print(";"); + } : function() { + might_need_semicolon = true; + }; + + function force_semicolon() { + if (might_need_semicolon) print(";"); + print(";"); + } + + function with_block(cont, end) { + print("{"); + newline(); + with_indent(cont); + add_mapping(end); + indent(); + print("}"); + } + + function with_parens(cont) { + print("("); + may_add_newline(); + cont(); + may_add_newline(); + print(")"); + } + + function with_square(cont) { + print("["); + may_add_newline(); + cont(); + may_add_newline(); + print("]"); + } + + function comma() { + may_add_newline(); + print(","); + may_add_newline(); + space(); + } + + function colon() { + print(":"); + space(); + } + + var add_mapping = mappings ? function(token, name) { + mapping_token = token; + mapping_name = name; + } : noop; + + function get() { + if (!line_fixed) fix_line(true); + return stored + output; + } + + function has_nlb() { + return /(^|\n) *$/.test(output); + } + + function pad_comment(token, force) { + if (need_newline_indented) return; + if (token.nlb && (force || !has_nlb())) { + need_newline_indented = true; + } else if (force) { + need_space = true; + } + } + + function print_comment(comment) { + var value = comment.value.replace(/[@#]__PURE__/g, " "); + if (/^\s*$/.test(value) && !/^\s*$/.test(comment.value)) return false; + if (/comment[134]/.test(comment.type)) { + print("//" + value); + need_newline_indented = true; + } else if (comment.type == "comment2") { + print("/*" + value + "*/"); + } + return true; + } + + function should_merge_comments(node, parent) { + if (parent instanceof AST_Binary) return parent.left === node; + if (parent.TYPE == "Call") return parent.expression === node; + if (parent instanceof AST_Conditional) return parent.condition === node; + if (parent instanceof AST_Dot) return parent.expression === node; + if (parent instanceof AST_Exit) return true; + if (parent instanceof AST_Sequence) return parent.expressions[0] === node; + if (parent instanceof AST_Sub) return parent.expression === node; + if (parent instanceof AST_UnaryPostfix) return true; + if (parent instanceof AST_Yield) return true; + } + + function prepend_comments(node) { + var self = this; + var scan; + if (node instanceof AST_Exit) { + scan = node.value; + } else if (node instanceof AST_Yield) { + scan = node.expression; + } + var comments = dump(node); + if (!comments) comments = []; + + if (scan) { + var tw = new TreeWalker(function(node) { + if (!should_merge_comments(node, tw.parent())) return true; + var before = dump(node); + if (before) comments = comments.concat(before); + }); + tw.push(node); + scan.walk(tw); + } + + if (current_line == 1 && current_col == 0) { + if (comments.length > 0 && options.shebang && comments[0].type == "comment5") { + print("#!" + comments.shift().value + "\n"); + indent(); + } + var preamble = options.preamble; + if (preamble) print(preamble.replace(/\r\n?|\u2028|\u2029|(^|\S)\s*$/g, "$1\n")); + } + + comments = comments.filter(comment_filter, node); + var printed = false; + comments.forEach(function(comment, index) { + pad_comment(comment, index); + if (print_comment(comment)) printed = true; + }); + if (printed) pad_comment(node.start, true); + + function dump(node) { + var token = node.start; + if (!token) { + if (!scan) return; + node.start = token = new AST_Token(); + } + var comments = token.comments_before; + if (!comments) { + if (!scan) return; + token.comments_before = comments = []; + } + if (comments._dumped === self) return; + comments._dumped = self; + return comments; + } + } + + function append_comments(node, tail) { + var self = this; + var token = node.end; + if (!token) return; + var comments = token[tail ? "comments_before" : "comments_after"]; + if (!comments || comments._dumped === self) return; + if (!(node instanceof AST_Statement || all(comments, function(c) { + return !/comment[134]/.test(c.type); + }))) return; + comments._dumped = self; + comments.filter(comment_filter, node).forEach(function(comment, index) { + pad_comment(comment, index || !tail); + print_comment(comment); + }); + } + + return { + get : get, + reset : reset, + indent : indent, + should_break : options.beautify && options.width ? function() { + return current_col >= options.width; + } : return_false, + has_parens : function() { return last.slice(-1) == "(" }, + newline : newline, + print : print, + space : space, + comma : comma, + colon : colon, + last : function() { return last }, + semicolon : semicolon, + force_semicolon : force_semicolon, + to_utf8 : to_utf8, + print_name : function(name) { print(to_utf8(name.toString(), true)) }, + print_string : options.inline_script ? function(str, quote) { + str = make_string(str, quote).replace(/<\x2f(script)([>\/\t\n\f\r ])/gi, "<\\/$1$2"); + print(str.replace(/\x3c!--/g, "\\x3c!--").replace(/--\x3e/g, "--\\x3e")); + } : function(str, quote) { + print(make_string(str, quote)); + }, + with_indent : with_indent, + with_block : with_block, + with_parens : with_parens, + with_square : with_square, + add_mapping : add_mapping, + option : function(opt) { return options[opt] }, + prepend_comments: options.comments || options.shebang ? prepend_comments : noop, + append_comments : options.comments ? append_comments : noop, + push_node : function(node) { stack.push(node) }, + pop_node : options.preserve_line ? function() { + var node = stack.pop(); + if (node.start && node.start.line > current_line) { + insert_newlines(node.start.line - current_line); + } + } : function() { + stack.pop(); + }, + parent : function(n) { + return stack[stack.length - 2 - (n || 0)]; + }, + }; +} + +/* -----[ code generators ]----- */ + +(function() { + + /* -----[ utils ]----- */ + + function DEFPRINT(nodetype, generator) { + nodetype.DEFMETHOD("_codegen", generator); + } + + var use_asm = false; + + AST_Node.DEFMETHOD("print", function(stream, force_parens) { + var self = this; + stream.push_node(self); + if (force_parens || self.needs_parens(stream)) { + stream.with_parens(doit); + } else { + doit(); + } + stream.pop_node(); + + function doit() { + stream.prepend_comments(self); + self.add_source_map(stream); + self._codegen(stream); + stream.append_comments(self); + } + }); + var readonly = OutputStream({ + inline_script: false, + shebang: false, + width: false, + }); + AST_Node.DEFMETHOD("print_to_string", function(options) { + if (options) { + var stream = OutputStream(options); + this.print(stream); + return stream.get(); + } + this.print(readonly); + return readonly.reset(); + }); + + /* -----[ PARENTHESES ]----- */ + + function PARENS(nodetype, func) { + nodetype.DEFMETHOD("needs_parens", func); + } + + PARENS(AST_Node, return_false); + + // a function expression needs parens around it when it's provably + // the first token to appear in a statement. + function needs_parens_function(output) { + var p = output.parent(); + if (!output.has_parens() && first_in_statement(output, false, true)) { + // export default function() {} + // export default (function foo() {}); + // export default (function() {})(foo); + // export default (function() {})`foo`; + // export default (function() {}) ? foo : bar; + return this.name || !(p instanceof AST_ExportDefault); + } + if (output.option("webkit") && p instanceof AST_PropAccess && p.expression === this) return true; + if (output.option("wrap_iife") && p instanceof AST_Call && p.expression === this) return true; + } + PARENS(AST_AsyncFunction, needs_parens_function); + PARENS(AST_AsyncGeneratorFunction, needs_parens_function); + PARENS(AST_ClassExpression, needs_parens_function); + PARENS(AST_Function, needs_parens_function); + PARENS(AST_GeneratorFunction, needs_parens_function); + + // same goes for an object literal, because otherwise it would be + // interpreted as a block of code. + function needs_parens_obj(output) { + return !output.has_parens() && first_in_statement(output, true); + } + PARENS(AST_Object, needs_parens_obj); + + function needs_parens_unary(output) { + var p = output.parent(); + // (-x) ** y + if (p instanceof AST_Binary) return p.operator == "**" && p.left === this; + // (await x)(y) + // new (await x) + if (p instanceof AST_Call) return p.expression === this; + // class extends (x++) {} + // class x extends (typeof y) {} + if (p instanceof AST_Class) return true; + // (x++)[y] + // (typeof x).y + // https://github.com/mishoo/UglifyJS/issues/115 + if (p instanceof AST_PropAccess) return p.expression === this; + // (~x)`foo` + if (p instanceof AST_Template) return p.tag === this; + } + PARENS(AST_Await, needs_parens_unary); + PARENS(AST_Unary, needs_parens_unary); + + PARENS(AST_Sequence, function(output) { + var p = output.parent(); + // [ 1, (2, 3), 4 ] ---> [ 1, 3, 4 ] + return p instanceof AST_Array + // () ---> (foo, bar) + || is_arrow(p) && p.value === this + // await (foo, bar) + || p instanceof AST_Await + // 1 + (2, 3) + 4 ---> 8 + || p instanceof AST_Binary + // new (foo, bar) or foo(1, (2, 3), 4) + || p instanceof AST_Call + // class extends (foo, bar) {} + // class foo extends (bar, baz) {} + || p instanceof AST_Class + // class { foo = (bar, baz) } + // class { [(foo, bar)]() {} } + || p instanceof AST_ClassProperty + // (false, true) ? (a = 10, b = 20) : (c = 30) + // ---> 20 (side effect, set a := 10 and b := 20) + || p instanceof AST_Conditional + // [ a = (1, 2) ] = [] ---> a == 2 + || p instanceof AST_DefaultValue + // { [(1, 2)]: foo } = bar + // { 1: (2, foo) } = bar + || p instanceof AST_DestructuredKeyVal + // export default (foo, bar) + || p instanceof AST_ExportDefault + // for (foo of (bar, baz)); + || p instanceof AST_ForOf + // { [(1, 2)]: 3 }[2] ---> 3 + // { foo: (1, 2) }.foo ---> 2 + || p instanceof AST_ObjectProperty + // (1, {foo:2}).foo or (1, {foo:2})["foo"] ---> 2 + || p instanceof AST_PropAccess && p.expression === this + // ...(foo, bar, baz) + || p instanceof AST_Spread + // (foo, bar)`baz` + || p instanceof AST_Template && p.tag === this + // !(foo, bar, baz) + || p instanceof AST_Unary + // var a = (1, 2), b = a + a; ---> b == 4 + || p instanceof AST_VarDef + // yield (foo, bar) + || p instanceof AST_Yield; + }); + + PARENS(AST_Binary, function(output) { + var p = output.parent(); + // await (foo && bar) + if (p instanceof AST_Await) return true; + // this deals with precedence: + // 3 * (2 + 1) + // 3 - (2 - 1) + // (1 ** 2) ** 3 + if (p instanceof AST_Binary) { + var po = p.operator, pp = PRECEDENCE[po]; + var so = this.operator, sp = PRECEDENCE[so]; + return pp > sp + || po == "??" && (so == "&&" || so == "||") + || (pp == sp && this === p[po == "**" ? "left" : "right"]); + } + // (foo && bar)() + if (p instanceof AST_Call) return p.expression === this; + // class extends (foo && bar) {} + // class foo extends (bar || null) {} + if (p instanceof AST_Class) return true; + // (foo && bar)["prop"], (foo && bar).prop + if (p instanceof AST_PropAccess) return p.expression === this; + // (foo && bar)`` + if (p instanceof AST_Template) return p.tag === this; + // typeof (foo && bar) + if (p instanceof AST_Unary) return true; + }); + + function need_chain_parens(node, parent) { + if (!node.terminal) return false; + if (!(parent instanceof AST_Call || parent instanceof AST_PropAccess)) return false; + return parent.expression === node; + } + + PARENS(AST_PropAccess, function(output) { + var node = this; + var p = output.parent(); + // i.e. new (foo().bar) + // + // if there's one call into this subtree, then we need + // parens around it too, otherwise the call will be + // interpreted as passing the arguments to the upper New + // expression. + if (p instanceof AST_New && p.expression === node && root_expr(node).TYPE == "Call") return true; + // (foo?.bar)() + // (foo?.bar).baz + // new (foo?.bar)() + return need_chain_parens(node, p); + }); + + PARENS(AST_Call, function(output) { + var node = this; + var p = output.parent(); + if (p instanceof AST_New) return p.expression === node; + // https://bugs.webkit.org/show_bug.cgi?id=123506 + if (output.option("webkit") + && node.expression instanceof AST_Function + && p instanceof AST_PropAccess + && p.expression === node) { + var g = output.parent(1); + if (g instanceof AST_Assign && g.left === p) return true; + } + // (foo?.())() + // (foo?.()).bar + // new (foo?.())() + return need_chain_parens(node, p); + }); + + PARENS(AST_New, function(output) { + if (need_constructor_parens(this, output)) return false; + var p = output.parent(); + // (new foo)(bar) + if (p instanceof AST_Call) return p.expression === this; + // (new Date).getTime(), (new Date)["getTime"]() + if (p instanceof AST_PropAccess) return true; + // (new foo)`bar` + if (p instanceof AST_Template) return p.tag === this; + }); + + PARENS(AST_Number, function(output) { + if (!output.option("galio")) return false; + // https://github.com/mishoo/UglifyJS/pull/1009 + var p = output.parent(); + return p instanceof AST_PropAccess && p.expression === this && /^0/.test(make_num(this.value)); + }); + + function needs_parens_assign_cond(self, output) { + var p = output.parent(); + // await (a = foo) + if (p instanceof AST_Await) return true; + // 1 + (a = 2) + 3 → 6, side effect setting a = 2 + if (p instanceof AST_Binary) return !(p instanceof AST_Assign); + // (a = func)() —or— new (a = Object)() + if (p instanceof AST_Call) return p.expression === self; + // class extends (a = foo) {} + // class foo extends (bar ? baz : moo) {} + if (p instanceof AST_Class) return true; + // (a = foo) ? bar : baz + if (p instanceof AST_Conditional) return p.condition === self; + // (a = foo)["prop"] —or— (a = foo).prop + if (p instanceof AST_PropAccess) return p.expression === self; + // (a = foo)`bar` + if (p instanceof AST_Template) return p.tag === self; + // !(a = false) → true + if (p instanceof AST_Unary) return true; + } + PARENS(AST_Arrow, function(output) { + return needs_parens_assign_cond(this, output); + }); + PARENS(AST_Assign, function(output) { + if (needs_parens_assign_cond(this, output)) return true; + // v8 parser bug ---> workaround + // f([1], [a] = []) ---> f([1], ([a] = [])) + if (output.option("v8")) return this.left instanceof AST_Destructured; + // ({ p: a } = o); + if (this.left instanceof AST_DestructuredObject) return needs_parens_obj(output); + }); + PARENS(AST_AsyncArrow, function(output) { + return needs_parens_assign_cond(this, output); + }); + PARENS(AST_Conditional, function(output) { + return needs_parens_assign_cond(this, output) + // https://github.com/mishoo/UglifyJS/issues/1144 + || output.option("extendscript") && output.parent() instanceof AST_Conditional; + }); + PARENS(AST_Yield, function(output) { + return needs_parens_assign_cond(this, output); + }); + + /* -----[ PRINTERS ]----- */ + + DEFPRINT(AST_Directive, function(output) { + var quote = this.quote; + var value = this.value; + switch (output.option("quote_style")) { + case 0: + case 2: + if (value.indexOf('"') == -1) quote = '"'; + break; + case 1: + if (value.indexOf("'") == -1) quote = "'"; + break; + } + output.print(quote + value + quote); + output.semicolon(); + }); + DEFPRINT(AST_Debugger, function(output) { + output.print("debugger"); + output.semicolon(); + }); + + /* -----[ statements ]----- */ + + function display_body(body, is_toplevel, output, allow_directives) { + var last = body.length - 1; + var in_directive = allow_directives; + var was_asm = use_asm; + body.forEach(function(stmt, i) { + if (in_directive) { + if (stmt instanceof AST_Directive) { + if (stmt.value == "use asm") use_asm = true; + } else if (!(stmt instanceof AST_EmptyStatement)) { + if (stmt instanceof AST_SimpleStatement && stmt.body instanceof AST_String) { + output.force_semicolon(); + } + in_directive = false; + } + } + if (stmt instanceof AST_EmptyStatement) return; + output.indent(); + stmt.print(output); + if (i == last && is_toplevel) return; + output.newline(); + if (is_toplevel) output.newline(); + }); + use_asm = was_asm; + } + + DEFPRINT(AST_Toplevel, function(output) { + display_body(this.body, true, output, true); + output.print(""); + }); + DEFPRINT(AST_LabeledStatement, function(output) { + this.label.print(output); + output.colon(); + var body = this.body; + if (body instanceof AST_EmptyStatement) { + output.force_semicolon(); + } else { + body.print(output); + } + }); + DEFPRINT(AST_SimpleStatement, function(output) { + this.body.print(output); + output.semicolon(); + }); + function print_braced_empty(self, output) { + output.print("{"); + output.with_indent(function() { + output.append_comments(self, true); + }); + output.print("}"); + } + function print_braced(self, output, allow_directives) { + if (self.body.length > 0) { + output.with_block(function() { + display_body(self.body, false, output, allow_directives); + }, self.end); + } else print_braced_empty(self, output); + } + DEFPRINT(AST_BlockStatement, function(output) { + print_braced(this, output); + }); + DEFPRINT(AST_EmptyStatement, function(output) { + output.semicolon(); + }); + DEFPRINT(AST_Do, function(output) { + var self = this; + output.print("do"); + make_block(self.body, output); + output.space(); + output.print("while"); + output.space(); + output.with_parens(function() { + self.condition.print(output); + }); + output.semicolon(); + }); + DEFPRINT(AST_While, function(output) { + var self = this; + output.print("while"); + output.space(); + output.with_parens(function() { + self.condition.print(output); + }); + force_statement(self.body, output); + }); + DEFPRINT(AST_For, function(output) { + var self = this; + output.print("for"); + output.space(); + output.with_parens(function() { + if (self.init) { + if (self.init instanceof AST_Definitions) { + self.init.print(output); + } else { + parenthesize_for_no_in(self.init, output, true); + } + output.print(";"); + output.space(); + } else { + output.print(";"); + } + if (self.condition) { + self.condition.print(output); + output.print(";"); + output.space(); + } else { + output.print(";"); + } + if (self.step) { + self.step.print(output); + } + }); + force_statement(self.body, output); + }); + function print_for_enum(prefix, infix) { + return function(output) { + var self = this; + output.print(prefix); + output.space(); + output.with_parens(function() { + self.init.print(output); + output.space(); + output.print(infix); + output.space(); + self.object.print(output); + }); + force_statement(self.body, output); + }; + } + DEFPRINT(AST_ForAwaitOf, print_for_enum("for await", "of")); + DEFPRINT(AST_ForIn, print_for_enum("for", "in")); + DEFPRINT(AST_ForOf, print_for_enum("for", "of")); + DEFPRINT(AST_With, function(output) { + var self = this; + output.print("with"); + output.space(); + output.with_parens(function() { + self.expression.print(output); + }); + force_statement(self.body, output); + }); + DEFPRINT(AST_ExportDeclaration, function(output) { + output.print("export"); + output.space(); + this.body.print(output); + }); + DEFPRINT(AST_ExportDefault, function(output) { + output.print("export"); + output.space(); + output.print("default"); + output.space(); + var body = this.body; + body.print(output); + if (body instanceof AST_ClassExpression) { + if (!body.name) return; + } + if (body instanceof AST_DefClass) return; + if (body instanceof AST_LambdaDefinition) return; + if (body instanceof AST_LambdaExpression) { + if (!body.name && !is_arrow(body)) return; + } + output.semicolon(); + }); + function print_alias(alias, output) { + var value = alias.value; + if (value == "*" || is_identifier_string(value)) { + output.print_name(value); + } else { + output.print_string(value, alias.quote); + } + } + DEFPRINT(AST_ExportForeign, function(output) { + var self = this; + output.print("export"); + output.space(); + var len = self.keys.length; + if (len == 0) { + print_braced_empty(self, output); + } else if (self.keys[0].value == "*") { + print_entry(0); + } else output.with_block(function() { + output.indent(); + print_entry(0); + for (var i = 1; i < len; i++) { + output.print(","); + output.newline(); + output.indent(); + print_entry(i); + } + output.newline(); + }, self.end); + output.space(); + output.print("from"); + output.space(); + self.path.print(output); + output.semicolon(); + + function print_entry(index) { + var alias = self.aliases[index]; + var key = self.keys[index]; + print_alias(key, output); + if (alias.value != key.value) { + output.space(); + output.print("as"); + output.space(); + print_alias(alias, output); + } + } + }); + DEFPRINT(AST_ExportReferences, function(output) { + var self = this; + output.print("export"); + output.space(); + print_properties(self, output); + output.semicolon(); + }); + DEFPRINT(AST_Import, function(output) { + var self = this; + output.print("import"); + output.space(); + if (self.default) self.default.print(output); + if (self.all) { + if (self.default) output.comma(); + self.all.print(output); + } + if (self.properties) { + if (self.default) output.comma(); + print_properties(self, output); + } + if (self.all || self.default || self.properties) { + output.space(); + output.print("from"); + output.space(); + } + self.path.print(output); + output.semicolon(); + }); + + /* -----[ functions ]----- */ + function print_funargs(self, output) { + output.with_parens(function() { + self.argnames.forEach(function(arg, i) { + if (i) output.comma(); + arg.print(output); + }); + if (self.rest) { + if (self.argnames.length) output.comma(); + output.print("..."); + self.rest.print(output); + } + }); + } + function print_arrow(self, output) { + var argname = self.argnames.length == 1 && !self.rest && self.argnames[0]; + if (argname instanceof AST_SymbolFunarg && argname.name != "yield") { + argname.print(output); + } else { + print_funargs(self, output); + } + output.space(); + output.print("=>"); + output.space(); + if (self.value) { + self.value.print(output); + } else { + print_braced(self, output, true); + } + } + DEFPRINT(AST_Arrow, function(output) { + print_arrow(this, output); + }); + DEFPRINT(AST_AsyncArrow, function(output) { + output.print("async"); + output.space(); + print_arrow(this, output); + }); + function print_lambda(self, output) { + if (self.name) { + output.space(); + self.name.print(output); + } + print_funargs(self, output); + output.space(); + print_braced(self, output, true); + } + DEFPRINT(AST_Lambda, function(output) { + output.print("function"); + print_lambda(this, output); + }); + function print_async(output) { + output.print("async"); + output.space(); + output.print("function"); + print_lambda(this, output); + } + DEFPRINT(AST_AsyncDefun, print_async); + DEFPRINT(AST_AsyncFunction, print_async); + function print_async_generator(output) { + output.print("async"); + output.space(); + output.print("function*"); + print_lambda(this, output); + } + DEFPRINT(AST_AsyncGeneratorDefun, print_async_generator); + DEFPRINT(AST_AsyncGeneratorFunction, print_async_generator); + function print_generator(output) { + output.print("function*"); + print_lambda(this, output); + } + DEFPRINT(AST_GeneratorDefun, print_generator); + DEFPRINT(AST_GeneratorFunction, print_generator); + + /* -----[ classes ]----- */ + DEFPRINT(AST_Class, function(output) { + var self = this; + output.print("class"); + if (self.name) { + output.space(); + self.name.print(output); + } + if (self.extends) { + output.space(); + output.print("extends"); + output.space(); + self.extends.print(output); + } + output.space(); + print_properties(self, output, true); + }); + DEFPRINT(AST_ClassField, function(output) { + var self = this; + if (self.static) { + output.print("static"); + output.space(); + } + print_property_key(self, output); + if (self.value) { + output.space(); + output.print("="); + output.space(); + self.value.print(output); + } else switch (self.key) { + case "get": + case "set": + case "static": + output.force_semicolon(); + return; + } + output.semicolon(); + }); + DEFPRINT(AST_ClassGetter, print_accessor("get")); + DEFPRINT(AST_ClassSetter, print_accessor("set")); + function print_method(self, output) { + var fn = self.value; + if (is_async(fn)) { + output.print("async"); + output.space(); + } + if (is_generator(fn)) output.print("*"); + print_property_key(self, output); + print_lambda(self.value, output); + } + DEFPRINT(AST_ClassMethod, function(output) { + var self = this; + if (self.static) { + output.print("static"); + output.space(); + } + print_method(self, output); + }); + DEFPRINT(AST_ClassInit, function(output) { + output.print("static"); + output.space(); + print_braced(this.value, output); + }); + + /* -----[ jumps ]----- */ + function print_jump(kind, prop) { + return function(output) { + output.print(kind); + var target = this[prop]; + if (target) { + output.space(); + target.print(output); + } + output.semicolon(); + }; + } + DEFPRINT(AST_Return, print_jump("return", "value")); + DEFPRINT(AST_Throw, print_jump("throw", "value")); + DEFPRINT(AST_Break, print_jump("break", "label")); + DEFPRINT(AST_Continue, print_jump("continue", "label")); + + /* -----[ if ]----- */ + function make_then(self, output) { + var b = self.body; + if (output.option("braces") && !(b instanceof AST_Const || b instanceof AST_Let) + || output.option("ie") && b instanceof AST_Do) + return make_block(b, output); + // The squeezer replaces "block"-s that contain only a single + // statement with the statement itself; technically, the AST + // is correct, but this can create problems when we output an + // IF having an ELSE clause where the THEN clause ends in an + // IF *without* an ELSE block (then the outer ELSE would refer + // to the inner IF). This function checks for this case and + // adds the block braces if needed. + if (!b) return output.force_semicolon(); + while (true) { + if (b instanceof AST_If) { + if (!b.alternative) { + make_block(self.body, output); + return; + } + b = b.alternative; + } else if (b instanceof AST_StatementWithBody) { + b = b.body; + } else break; + } + force_statement(self.body, output); + } + DEFPRINT(AST_If, function(output) { + var self = this; + output.print("if"); + output.space(); + output.with_parens(function() { + self.condition.print(output); + }); + if (self.alternative) { + make_then(self, output); + output.space(); + output.print("else"); + if (self.alternative instanceof AST_If) { + output.space(); + self.alternative.print(output); + } else { + force_statement(self.alternative, output); + } + } else { + force_statement(self.body, output); + } + }); + + /* -----[ switch ]----- */ + DEFPRINT(AST_Switch, function(output) { + var self = this; + output.print("switch"); + output.space(); + output.with_parens(function() { + self.expression.print(output); + }); + output.space(); + var last = self.body.length - 1; + if (last < 0) print_braced_empty(self, output); + else output.with_block(function() { + self.body.forEach(function(branch, i) { + output.indent(true); + branch.print(output); + if (i < last && branch.body.length > 0) + output.newline(); + }); + }, self.end); + }); + function print_branch_body(self, output) { + output.newline(); + self.body.forEach(function(stmt) { + output.indent(); + stmt.print(output); + output.newline(); + }); + } + DEFPRINT(AST_Default, function(output) { + output.print("default:"); + print_branch_body(this, output); + }); + DEFPRINT(AST_Case, function(output) { + var self = this; + output.print("case"); + output.space(); + self.expression.print(output); + output.print(":"); + print_branch_body(self, output); + }); + + /* -----[ exceptions ]----- */ + DEFPRINT(AST_Try, function(output) { + var self = this; + output.print("try"); + output.space(); + print_braced(self, output); + if (self.bcatch) { + output.space(); + self.bcatch.print(output); + } + if (self.bfinally) { + output.space(); + self.bfinally.print(output); + } + }); + DEFPRINT(AST_Catch, function(output) { + var self = this; + output.print("catch"); + if (self.argname) { + output.space(); + output.with_parens(function() { + self.argname.print(output); + }); + } + output.space(); + print_braced(self, output); + }); + DEFPRINT(AST_Finally, function(output) { + output.print("finally"); + output.space(); + print_braced(this, output); + }); + + function print_definitions(type) { + return function(output) { + var self = this; + output.print(type); + output.space(); + self.definitions.forEach(function(def, i) { + if (i) output.comma(); + def.print(output); + }); + var p = output.parent(); + if (!(p instanceof AST_IterationStatement && p.init === self)) output.semicolon(); + }; + } + DEFPRINT(AST_Const, print_definitions("const")); + DEFPRINT(AST_Let, print_definitions("let")); + DEFPRINT(AST_Var, print_definitions("var")); + + function parenthesize_for_no_in(node, output, no_in) { + var parens = false; + // need to take some precautions here: + // https://github.com/mishoo/UglifyJS/issues/60 + if (no_in) node.walk(new TreeWalker(function(node) { + if (parens) return true; + if (node instanceof AST_Binary && node.operator == "in") return parens = true; + if (node instanceof AST_Scope && !(is_arrow(node) && node.value)) return true; + })); + node.print(output, parens); + } + + DEFPRINT(AST_VarDef, function(output) { + var self = this; + self.name.print(output); + if (self.value) { + output.space(); + output.print("="); + output.space(); + var p = output.parent(1); + var no_in = p instanceof AST_For || p instanceof AST_ForEnumeration; + parenthesize_for_no_in(self.value, output, no_in); + } + }); + + DEFPRINT(AST_DefaultValue, function(output) { + var self = this; + self.name.print(output); + output.space(); + output.print("="); + output.space(); + self.value.print(output); + }); + + /* -----[ other expressions ]----- */ + function print_annotation(self, output) { + if (!output.option("annotations")) return; + if (!self.pure) return; + var level = 0, parent = self, node; + do { + node = parent; + parent = output.parent(level++); + if (parent instanceof AST_Call && parent.expression === node) return; + } while (parent instanceof AST_PropAccess && parent.expression === node); + output.print("/*@__PURE__*/"); + } + function print_call_args(self, output) { + output.with_parens(function() { + self.args.forEach(function(expr, i) { + if (i) output.comma(); + expr.print(output); + }); + output.add_mapping(self.end); + }); + } + DEFPRINT(AST_Call, function(output) { + var self = this; + print_annotation(self, output); + self.expression.print(output); + if (self.optional) output.print("?."); + print_call_args(self, output); + }); + DEFPRINT(AST_New, function(output) { + var self = this; + print_annotation(self, output); + output.print("new"); + output.space(); + self.expression.print(output); + if (need_constructor_parens(self, output)) print_call_args(self, output); + }); + DEFPRINT(AST_Sequence, function(output) { + this.expressions.forEach(function(node, index) { + if (index > 0) { + output.comma(); + if (output.should_break()) { + output.newline(); + output.indent(); + } + } + node.print(output); + }); + }); + DEFPRINT(AST_Dot, function(output) { + var self = this; + var expr = self.expression; + expr.print(output); + var prop = self.property; + if (output.option("ie") && RESERVED_WORDS[prop] || self.quoted && output.option("keep_quoted_props")) { + if (self.optional) output.print("?."); + output.with_square(function() { + output.add_mapping(self.end); + output.print_string(prop); + }); + } else { + if (expr instanceof AST_Number && !/[ex.)]/i.test(output.last())) output.print("."); + output.print(self.optional ? "?." : "."); + // the name after dot would be mapped about here. + output.add_mapping(self.end); + output.print_name(prop); + } + }); + DEFPRINT(AST_Sub, function(output) { + var self = this; + self.expression.print(output); + if (self.optional) output.print("?."); + output.with_square(function() { + self.property.print(output); + }); + }); + DEFPRINT(AST_Spread, function(output) { + output.print("..."); + this.expression.print(output); + }); + DEFPRINT(AST_UnaryPrefix, function(output) { + var op = this.operator; + var exp = this.expression; + output.print(op); + if (/^[a-z]/i.test(op) + || (/[+-]$/.test(op) + && exp instanceof AST_UnaryPrefix + && /^[+-]/.test(exp.operator))) { + output.space(); + } + exp.print(output); + }); + DEFPRINT(AST_UnaryPostfix, function(output) { + var self = this; + self.expression.print(output); + output.add_mapping(self.end); + output.print(self.operator); + }); + DEFPRINT(AST_Binary, function(output) { + var self = this; + self.left.print(output); + output.space(); + output.print(self.operator); + output.space(); + self.right.print(output); + }); + DEFPRINT(AST_Conditional, function(output) { + var self = this; + self.condition.print(output); + output.space(); + output.print("?"); + output.space(); + self.consequent.print(output); + output.space(); + output.colon(); + self.alternative.print(output); + }); + DEFPRINT(AST_Await, function(output) { + output.print("await"); + output.space(); + this.expression.print(output); + }); + DEFPRINT(AST_Yield, function(output) { + output.print(this.nested ? "yield*" : "yield"); + if (this.expression) { + output.space(); + this.expression.print(output); + } + }); + + /* -----[ literals ]----- */ + DEFPRINT(AST_Array, function(output) { + var a = this.elements, len = a.length; + output.with_square(len > 0 ? function() { + output.space(); + a.forEach(function(exp, i) { + if (i) output.comma(); + exp.print(output); + // If the final element is a hole, we need to make sure it + // doesn't look like a trailing comma, by inserting an actual + // trailing comma. + if (i === len - 1 && exp instanceof AST_Hole) + output.comma(); + }); + output.space(); + } : noop); + }); + DEFPRINT(AST_DestructuredArray, function(output) { + var a = this.elements, len = a.length, rest = this.rest; + output.with_square(len || rest ? function() { + output.space(); + a.forEach(function(exp, i) { + if (i) output.comma(); + exp.print(output); + }); + if (rest) { + if (len) output.comma(); + output.print("..."); + rest.print(output); + } else if (a[len - 1] instanceof AST_Hole) { + // If the final element is a hole, we need to make sure it + // doesn't look like a trailing comma, by inserting an actual + // trailing comma. + output.comma(); + } + output.space(); + } : noop); + }); + DEFPRINT(AST_DestructuredKeyVal, function(output) { + var self = this; + var key = print_property_key(self, output); + var value = self.value; + if (key) { + if (value instanceof AST_DefaultValue) { + if (value.name instanceof AST_Symbol && key == get_symbol_name(value.name)) { + output.space(); + output.print("="); + output.space(); + value.value.print(output); + return; + } + } else if (value instanceof AST_Symbol) { + if (key == get_symbol_name(value)) return; + } + } + output.colon(); + value.print(output); + }); + DEFPRINT(AST_DestructuredObject, function(output) { + var self = this; + var props = self.properties, len = props.length, rest = self.rest; + if (len || rest) output.with_block(function() { + props.forEach(function(prop, i) { + if (i) { + output.print(","); + output.newline(); + } + output.indent(); + prop.print(output); + }); + if (rest) { + if (len) { + output.print(","); + output.newline(); + } + output.indent(); + output.print("..."); + rest.print(output); + } + output.newline(); + }, self.end); + else print_braced_empty(self, output); + }); + function print_properties(self, output, no_comma) { + var props = self.properties; + if (props.length > 0) output.with_block(function() { + props.forEach(function(prop, i) { + if (i) { + if (!no_comma) output.print(","); + output.newline(); + } + output.indent(); + prop.print(output); + }); + output.newline(); + }, self.end); + else print_braced_empty(self, output); + } + DEFPRINT(AST_Object, function(output) { + print_properties(this, output); + }); + + function print_property_key(self, output) { + var key = self.key; + if (key instanceof AST_Node) return output.with_square(function() { + key.print(output); + }); + var quote = self.start && self.start.quote; + if (output.option("quote_keys") || quote && output.option("keep_quoted_props")) { + output.print_string(key, quote); + } else if ("" + +key == key && key >= 0) { + output.print(make_num(key)); + } else if (self.private) { + output.print_name(key); + } else if (RESERVED_WORDS[key] ? !output.option("ie") : is_identifier_string(key)) { + output.print_name(key); + return key; + } else { + output.print_string(key, quote); + } + } + DEFPRINT(AST_ObjectKeyVal, function(output) { + var self = this; + print_property_key(self, output); + output.colon(); + self.value.print(output); + }); + DEFPRINT(AST_ObjectMethod, function(output) { + print_method(this, output); + }); + function print_accessor(type) { + return function(output) { + var self = this; + if (self.static) { + output.print("static"); + output.space(); + } + output.print(type); + output.space(); + print_property_key(self, output); + print_lambda(self.value, output); + }; + } + DEFPRINT(AST_ObjectGetter, print_accessor("get")); + DEFPRINT(AST_ObjectSetter, print_accessor("set")); + function get_symbol_name(sym) { + var def = sym.definition(); + return def && def.mangled_name || sym.name; + } + DEFPRINT(AST_Symbol, function(output) { + output.print_name(get_symbol_name(this)); + }); + DEFPRINT(AST_SymbolExport, function(output) { + var self = this; + var name = get_symbol_name(self); + output.print_name(name); + var alias = self.alias; + if (alias.value != name) { + output.space(); + output.print("as"); + output.space(); + print_alias(alias, output); + } + }); + DEFPRINT(AST_SymbolImport, function(output) { + var self = this; + var name = get_symbol_name(self); + var key = self.key; + if (key.value && key.value != name) { + print_alias(key, output); + output.space(); + output.print("as"); + output.space(); + } + output.print_name(name); + }); + DEFPRINT(AST_Hole, noop); + DEFPRINT(AST_Template, function(output) { + var self = this; + if (self.tag) self.tag.print(output); + output.print("`"); + for (var i = 0; i < self.expressions.length; i++) { + output.print(output.to_utf8(self.strings[i])); + output.print("${"); + self.expressions[i].print(output); + output.print("}"); + } + output.print(output.to_utf8(self.strings[i])); + output.print("`"); + }); + DEFPRINT(AST_BigInt, function(output) { + output.print(this.value + "n"); + }); + DEFPRINT(AST_Constant, function(output) { + output.print("" + this.value); + }); + DEFPRINT(AST_String, function(output) { + output.print_string(this.value, this.quote); + }); + DEFPRINT(AST_Number, function(output) { + var start = this.start; + if (use_asm && start && start.raw != null) { + output.print(start.raw); + } else { + output.print(make_num(this.value)); + } + }); + + DEFPRINT(AST_RegExp, function(output) { + var regexp = this.value; + var str = regexp.toString(); + var end = str.lastIndexOf("/"); + if (regexp.raw_source) { + str = "/" + regexp.raw_source + str.slice(end); + } else if (end == 1) { + str = "/(?:)" + str.slice(end); + } else if (str.indexOf("/", 1) < end) { + str = "/" + str.slice(1, end).replace(/\\\\|[^/]?\//g, function(match) { + return match[0] == "\\" ? match : match.slice(0, -1) + "\\/"; + }) + str.slice(end); + } + output.print(output.to_utf8(str).replace(/\\(?:\0(?![0-9])|[^\0])/g, function(match) { + switch (match[1]) { + case "\n": return "\\n"; + case "\r": return "\\r"; + case "\t": return "\t"; + case "\b": return "\b"; + case "\f": return "\f"; + case "\0": return "\0"; + case "\x0B": return "\v"; + case "\u2028": return "\\u2028"; + case "\u2029": return "\\u2029"; + default: return match; + } + }).replace(/[\n\r\u2028\u2029]/g, function(c) { + switch (c) { + case "\n": return "\\n"; + case "\r": return "\\r"; + case "\u2028": return "\\u2028"; + case "\u2029": return "\\u2029"; + } + })); + }); + + function force_statement(stat, output) { + if (output.option("braces") && !(stat instanceof AST_Const || stat instanceof AST_Let)) { + make_block(stat, output); + } else if (stat instanceof AST_EmptyStatement) { + output.force_semicolon(); + } else { + output.space(); + stat.print(output); + } + } + + // self should be AST_New. decide if we want to show parens or not. + function need_constructor_parens(self, output) { + // Always print parentheses with arguments + if (self.args.length > 0) return true; + + return output.option("beautify"); + } + + function best_of(a) { + var best = a[0], len = best.length; + for (var i = 1; i < a.length; ++i) { + if (a[i].length < len) { + best = a[i]; + len = best.length; + } + } + return best; + } + + function make_num(num) { + var str = num.toString(10).replace(/^0\./, ".").replace("e+", "e"); + var candidates = [ str ]; + if (Math.floor(num) === num) { + if (num < 0) { + candidates.push("-0x" + (-num).toString(16).toLowerCase()); + } else { + candidates.push("0x" + num.toString(16).toLowerCase()); + } + } + var match, len, digits; + if (match = /^\.0+/.exec(str)) { + len = match[0].length; + digits = str.slice(len); + candidates.push(digits + "e-" + (digits.length + len - 1)); + } else if (match = /[^0]0+$/.exec(str)) { + len = match[0].length - 1; + candidates.push(str.slice(0, -len) + "e" + len); + } else if (match = /^(\d)\.(\d+)e(-?\d+)$/.exec(str)) { + candidates.push(match[1] + match[2] + "e" + (match[3] - match[2].length)); + } + return best_of(candidates); + } + + function make_block(stmt, output) { + output.space(); + if (stmt instanceof AST_EmptyStatement) { + print_braced_empty(stmt, output); + } else if (stmt instanceof AST_BlockStatement) { + stmt.print(output); + } else output.with_block(function() { + output.indent(); + stmt.print(output); + output.newline(); + }, stmt.end); + } + + /* -----[ source map generators ]----- */ + + function DEFMAP(nodetype, generator) { + nodetype.forEach(function(nodetype) { + nodetype.DEFMETHOD("add_source_map", generator); + }); + } + + DEFMAP([ + // We could easily add info for ALL nodes, but it seems to me that + // would be quite wasteful, hence this noop in the base class. + AST_Node, + // since the label symbol will mark it + AST_LabeledStatement, + ], noop); + + // XXX: I'm not exactly sure if we need it for all of these nodes, + // or if we should add even more. + DEFMAP([ + AST_Array, + AST_Await, + AST_BlockStatement, + AST_Catch, + AST_Constant, + AST_Debugger, + AST_Definitions, + AST_Destructured, + AST_Directive, + AST_Finally, + AST_Jump, + AST_Lambda, + AST_New, + AST_Object, + AST_Spread, + AST_StatementWithBody, + AST_Symbol, + AST_Switch, + AST_SwitchBranch, + AST_Try, + AST_UnaryPrefix, + AST_Yield, + ], function(output) { + output.add_mapping(this.start); + }); + + DEFMAP([ + AST_ClassProperty, + AST_DestructuredKeyVal, + AST_ObjectProperty, + ], function(output) { + if (typeof this.key == "string") output.add_mapping(this.start, this.key); + }); +})(); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/parse.js b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/parse.js new file mode 100644 index 0000000000000000000000000000000000000000..258e86e651dfacd58d389fd7a2f6d66d47f29deb --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/parse.js @@ -0,0 +1,2589 @@ +/*********************************************************************** + + A JavaScript tokenizer / parser / beautifier / compressor. + https://github.com/mishoo/UglifyJS + + -------------------------------- (C) --------------------------------- + + Author: Mihai Bazon + + http://mihai.bazon.net/blog + + Distributed under the BSD license: + + Copyright 2012 (c) Mihai Bazon + Parser based on parse-js (http://marijn.haverbeke.nl/parse-js/). + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + * Redistributions of source code must retain the above + copyright notice, this list of conditions and the following + disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials + provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY + EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, + OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF + THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + SUCH DAMAGE. + + ***********************************************************************/ + +"use strict"; + +var KEYWORDS = "break case catch class const continue debugger default delete do else extends finally for function if in instanceof new return switch throw try typeof var void while with"; +var KEYWORDS_ATOM = "false null true"; +var RESERVED_WORDS = [ + "abstract async await boolean byte char double enum export final float goto implements import int interface let long native package private protected public short static super synchronized this throws transient volatile yield", + KEYWORDS_ATOM, + KEYWORDS, +].join(" "); +var KEYWORDS_BEFORE_EXPRESSION = "return new delete throw else case"; + +KEYWORDS = makePredicate(KEYWORDS); +RESERVED_WORDS = makePredicate(RESERVED_WORDS); +KEYWORDS_BEFORE_EXPRESSION = makePredicate(KEYWORDS_BEFORE_EXPRESSION); +KEYWORDS_ATOM = makePredicate(KEYWORDS_ATOM); + +var RE_BIN_NUMBER = /^0b([01]+)$/i; +var RE_HEX_NUMBER = /^0x([0-9a-f]+)$/i; +var RE_OCT_NUMBER = /^0o?([0-7]+)$/i; + +var OPERATORS = makePredicate([ + "in", + "instanceof", + "typeof", + "new", + "void", + "delete", + "++", + "--", + "+", + "-", + "!", + "~", + "&", + "|", + "^", + "*", + "/", + "%", + "**", + ">>", + "<<", + ">>>", + "<", + ">", + "<=", + ">=", + "==", + "===", + "!=", + "!==", + "?", + "=", + "+=", + "-=", + "/=", + "*=", + "%=", + "**=", + ">>=", + "<<=", + ">>>=", + "&=", + "|=", + "^=", + "&&", + "||", + "??", + "&&=", + "||=", + "??=", +]); + +var NEWLINE_CHARS = "\n\r\u2028\u2029"; +var OPERATOR_CHARS = "+-*&%=<>!?|~^"; +var PUNC_OPENERS = "[{("; +var PUNC_SEPARATORS = ",;:"; +var PUNC_CLOSERS = ")}]"; +var PUNC_AFTER_EXPRESSION = PUNC_SEPARATORS + PUNC_CLOSERS; +var PUNC_BEFORE_EXPRESSION = PUNC_OPENERS + PUNC_SEPARATORS; +var PUNC_CHARS = PUNC_BEFORE_EXPRESSION + "`" + PUNC_CLOSERS; +var WHITESPACE_CHARS = NEWLINE_CHARS + " \u00a0\t\f\u000b\u200b\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\uFEFF"; +var NON_IDENTIFIER_CHARS = makePredicate(characters("./'\"#" + OPERATOR_CHARS + PUNC_CHARS + WHITESPACE_CHARS)); + +NEWLINE_CHARS = makePredicate(characters(NEWLINE_CHARS)); +OPERATOR_CHARS = makePredicate(characters(OPERATOR_CHARS)); +PUNC_AFTER_EXPRESSION = makePredicate(characters(PUNC_AFTER_EXPRESSION)); +PUNC_BEFORE_EXPRESSION = makePredicate(characters(PUNC_BEFORE_EXPRESSION)); +PUNC_CHARS = makePredicate(characters(PUNC_CHARS)); +WHITESPACE_CHARS = makePredicate(characters(WHITESPACE_CHARS)); + +/* -----[ Tokenizer ]----- */ + +function is_surrogate_pair_head(code) { + return code >= 0xd800 && code <= 0xdbff; +} + +function is_surrogate_pair_tail(code) { + return code >= 0xdc00 && code <= 0xdfff; +} + +function is_digit(code) { + return code >= 48 && code <= 57; +} + +function is_identifier_char(ch) { + return !NON_IDENTIFIER_CHARS[ch]; +} + +function is_identifier_string(str) { + return /^[a-z_$][a-z0-9_$]*$/i.test(str); +} + +function decode_escape_sequence(seq) { + switch (seq[0]) { + case "b": return "\b"; + case "f": return "\f"; + case "n": return "\n"; + case "r": return "\r"; + case "t": return "\t"; + case "u": + var code; + if (seq[1] == "{" && seq.slice(-1) == "}") { + code = seq.slice(2, -1); + } else if (seq.length == 5) { + code = seq.slice(1); + } else { + return; + } + var num = parseInt(code, 16); + if (num < 0 || isNaN(num)) return; + if (num < 0x10000) return String.fromCharCode(num); + if (num > 0x10ffff) return; + return String.fromCharCode((num >> 10) + 0xd7c0) + String.fromCharCode((num & 0x03ff) + 0xdc00); + case "v": return "\u000b"; + case "x": + if (seq.length != 3) return; + var num = parseInt(seq.slice(1), 16); + if (num < 0 || isNaN(num)) return; + return String.fromCharCode(num); + case "\r": + case "\n": + return ""; + default: + if (seq == "0") return "\0"; + if (seq[0] >= "0" && seq[0] <= "9") return; + return seq; + } +} + +function parse_js_number(num) { + var match; + if (match = RE_BIN_NUMBER.exec(num)) return parseInt(match[1], 2); + if (match = RE_HEX_NUMBER.exec(num)) return parseInt(match[1], 16); + if (match = RE_OCT_NUMBER.exec(num)) return parseInt(match[1], 8); + var val = parseFloat(num); + if (val == num) return val; +} + +function JS_Parse_Error(message, filename, line, col, pos) { + this.message = message; + this.filename = filename; + this.line = line; + this.col = col; + this.pos = pos; + try { + throw new SyntaxError(message, filename, line, col); + } catch (cause) { + configure_error_stack(this, cause); + } +} +JS_Parse_Error.prototype = Object.create(SyntaxError.prototype); +JS_Parse_Error.prototype.constructor = JS_Parse_Error; + +function js_error(message, filename, line, col, pos) { + throw new JS_Parse_Error(message, filename, line, col, pos); +} + +function is_token(token, type, val) { + return token.type == type && (val == null || token.value == val); +} + +var EX_EOF = {}; + +function tokenizer($TEXT, filename, html5_comments, shebang) { + + var S = { + text : $TEXT, + filename : filename, + pos : 0, + tokpos : 0, + line : 1, + tokline : 0, + col : 0, + tokcol : 0, + newline_before : false, + regex_allowed : false, + comments_before : [], + directives : Object.create(null), + read_template : with_eof_error("Unterminated template literal", function(strings) { + var s = ""; + for (;;) { + var ch = read(); + switch (ch) { + case "\\": + ch += read(); + break; + case "`": + strings.push(s); + return; + case "$": + if (peek() == "{") { + next(); + strings.push(s); + S.regex_allowed = true; + return true; + } + } + s += ch; + } + + function read() { + var ch = next(true, true); + return ch == "\r" ? "\n" : ch; + } + }), + }; + var prev_was_dot = false; + + function peek() { + return S.text.charAt(S.pos); + } + + function next(signal_eof, in_string) { + var ch = S.text.charAt(S.pos++); + if (signal_eof && !ch) + throw EX_EOF; + if (NEWLINE_CHARS[ch]) { + S.col = 0; + S.line++; + if (!in_string) S.newline_before = true; + if (ch == "\r" && peek() == "\n") { + // treat `\r\n` as `\n` + S.pos++; + ch = "\n"; + } + } else { + S.col++; + } + return ch; + } + + function forward(i) { + while (i-- > 0) next(); + } + + function looking_at(str) { + return S.text.substr(S.pos, str.length) == str; + } + + function find_eol() { + var text = S.text; + for (var i = S.pos; i < S.text.length; ++i) { + if (NEWLINE_CHARS[text[i]]) return i; + } + return -1; + } + + function find(what, signal_eof) { + var pos = S.text.indexOf(what, S.pos); + if (signal_eof && pos == -1) throw EX_EOF; + return pos; + } + + function start_token() { + S.tokline = S.line; + S.tokcol = S.col; + S.tokpos = S.pos; + } + + function token(type, value, is_comment) { + S.regex_allowed = type == "operator" && !UNARY_POSTFIX[value] + || type == "keyword" && KEYWORDS_BEFORE_EXPRESSION[value] + || type == "punc" && PUNC_BEFORE_EXPRESSION[value]; + if (type == "punc" && value == ".") prev_was_dot = true; + else if (!is_comment) prev_was_dot = false; + var ret = { + type : type, + value : value, + line : S.tokline, + col : S.tokcol, + pos : S.tokpos, + endline : S.line, + endcol : S.col, + endpos : S.pos, + nlb : S.newline_before, + file : filename + }; + if (/^(?:num|string|regexp)$/i.test(type)) { + ret.raw = $TEXT.substring(ret.pos, ret.endpos); + } + if (!is_comment) { + ret.comments_before = S.comments_before; + ret.comments_after = S.comments_before = []; + } + S.newline_before = false; + return new AST_Token(ret); + } + + function skip_whitespace() { + while (WHITESPACE_CHARS[peek()]) + next(); + } + + function read_while(pred) { + var ret = "", ch; + while ((ch = peek()) && pred(ch, ret)) ret += next(); + return ret; + } + + function parse_error(err) { + js_error(err, filename, S.tokline, S.tokcol, S.tokpos); + } + + function is_octal(num) { + return /^0[0-7_]+$/.test(num); + } + + function read_num(prefix) { + var has_e = false, after_e = false, has_x = false, has_dot = prefix == "."; + var num = read_while(function(ch, str) { + switch (ch) { + case "x": case "X": + return has_x ? false : (has_x = true); + case "e": case "E": + return has_x ? true : has_e ? false : (has_e = after_e = true); + case "+": case "-": + return after_e; + case (after_e = false, "."): + return has_dot || has_e || has_x || is_octal(str) ? false : (has_dot = true); + } + return /[_0-9a-dfo]/i.test(ch); + }); + if (prefix) num = prefix + num; + if (is_octal(num)) { + if (next_token.has_directive("use strict")) parse_error("Legacy octal literals are not allowed in strict mode"); + } else { + num = num.replace(has_x ? /([1-9a-f]|.0)_(?=[0-9a-f])/gi : /([1-9]|.0)_(?=[0-9])/gi, "$1"); + } + var valid = parse_js_number(num); + if (isNaN(valid)) parse_error("Invalid syntax: " + num); + if (has_dot || has_e || peek() != "n") return token("num", valid); + next(); + return token("bigint", num.toLowerCase()); + } + + function read_escaped_char(in_string) { + var seq = next(true, in_string); + if (seq >= "0" && seq <= "7") return read_octal_escape_sequence(seq); + if (seq == "u") { + var ch = next(true, in_string); + seq += ch; + if (ch != "{") { + seq += next(true, in_string) + next(true, in_string) + next(true, in_string); + } else do { + ch = next(true, in_string); + seq += ch; + } while (ch != "}"); + } else if (seq == "x") { + seq += next(true, in_string) + next(true, in_string); + } + var str = decode_escape_sequence(seq); + if (typeof str != "string") parse_error("Invalid escape sequence: \\" + seq); + return str; + } + + function read_octal_escape_sequence(ch) { + // Read + var p = peek(); + if (p >= "0" && p <= "7") { + ch += next(true); + if (ch[0] <= "3" && (p = peek()) >= "0" && p <= "7") + ch += next(true); + } + + // Parse + if (ch === "0") return "\0"; + if (ch.length > 0 && next_token.has_directive("use strict")) + parse_error("Legacy octal escape sequences are not allowed in strict mode"); + return String.fromCharCode(parseInt(ch, 8)); + } + + var read_string = with_eof_error("Unterminated string constant", function(quote_char) { + var quote = next(), ret = ""; + for (;;) { + var ch = next(true, true); + if (ch == "\\") ch = read_escaped_char(true); + else if (NEWLINE_CHARS[ch]) parse_error("Unterminated string constant"); + else if (ch == quote) break; + ret += ch; + } + var tok = token("string", ret); + tok.quote = quote_char; + return tok; + }); + + function skip_line_comment(type) { + var regex_allowed = S.regex_allowed; + var i = find_eol(), ret; + if (i == -1) { + ret = S.text.substr(S.pos); + S.pos = S.text.length; + } else { + ret = S.text.substring(S.pos, i); + S.pos = i; + } + S.col = S.tokcol + (S.pos - S.tokpos); + S.comments_before.push(token(type, ret, true)); + S.regex_allowed = regex_allowed; + return next_token; + } + + var skip_multiline_comment = with_eof_error("Unterminated multiline comment", function() { + var regex_allowed = S.regex_allowed; + var i = find("*/", true); + var text = S.text.substring(S.pos, i).replace(/\r\n|\r|\u2028|\u2029/g, "\n"); + // update stream position + forward(text.length /* doesn't count \r\n as 2 char while S.pos - i does */ + 2); + S.comments_before.push(token("comment2", text, true)); + S.regex_allowed = regex_allowed; + return next_token; + }); + + function read_name() { + var backslash = false, ch, escaped = false, name = peek() == "#" ? next() : ""; + while (ch = peek()) { + if (!backslash) { + if (ch == "\\") escaped = backslash = true, next(); + else if (is_identifier_char(ch)) name += next(); + else break; + } else { + if (ch != "u") parse_error("Expecting UnicodeEscapeSequence -- uXXXX"); + ch = read_escaped_char(); + if (!is_identifier_char(ch)) parse_error("Unicode char: " + ch.charCodeAt(0) + " is not valid in identifier"); + name += ch; + backslash = false; + } + } + if (KEYWORDS[name] && escaped) { + var hex = name.charCodeAt(0).toString(16).toUpperCase(); + name = "\\u" + "0000".substr(hex.length) + hex + name.slice(1); + } + return name; + } + + var read_regexp = with_eof_error("Unterminated regular expression", function(source) { + var prev_backslash = false, ch, in_class = false; + while ((ch = next(true))) if (NEWLINE_CHARS[ch]) { + parse_error("Unexpected line terminator"); + } else if (prev_backslash) { + source += "\\" + ch; + prev_backslash = false; + } else if (ch == "[") { + in_class = true; + source += ch; + } else if (ch == "]" && in_class) { + in_class = false; + source += ch; + } else if (ch == "/" && !in_class) { + break; + } else if (ch == "\\") { + prev_backslash = true; + } else { + source += ch; + } + var mods = read_name(); + try { + var regexp = new RegExp(source, mods); + regexp.raw_source = source; + return token("regexp", regexp); + } catch (e) { + parse_error(e.message); + } + }); + + function read_operator(prefix) { + function grow(op) { + if (!peek()) return op; + var bigger = op + peek(); + if (OPERATORS[bigger]) { + next(); + return grow(bigger); + } else { + return op; + } + } + return token("operator", grow(prefix || next())); + } + + function handle_slash() { + next(); + switch (peek()) { + case "/": + next(); + return skip_line_comment("comment1"); + case "*": + next(); + return skip_multiline_comment(); + } + return S.regex_allowed ? read_regexp("") : read_operator("/"); + } + + function handle_dot() { + next(); + if (looking_at("..")) return token("operator", "." + next() + next()); + return is_digit(peek().charCodeAt(0)) ? read_num(".") : token("punc", "."); + } + + function read_word() { + var word = read_name(); + if (prev_was_dot) return token("name", word); + return KEYWORDS_ATOM[word] ? token("atom", word) + : !KEYWORDS[word] ? token("name", word) + : OPERATORS[word] ? token("operator", word) + : token("keyword", word); + } + + function with_eof_error(eof_error, cont) { + return function(x) { + try { + return cont(x); + } catch (ex) { + if (ex === EX_EOF) parse_error(eof_error); + else throw ex; + } + }; + } + + function next_token(force_regexp) { + if (force_regexp != null) + return read_regexp(force_regexp); + if (shebang && S.pos == 0 && looking_at("#!")) { + start_token(); + forward(2); + skip_line_comment("comment5"); + } + for (;;) { + skip_whitespace(); + start_token(); + if (html5_comments) { + if (looking_at("") && S.newline_before) { + forward(3); + skip_line_comment("comment4"); + continue; + } + } + var ch = peek(); + if (!ch) return token("eof"); + var code = ch.charCodeAt(0); + switch (code) { + case 34: case 39: return read_string(ch); + case 46: return handle_dot(); + case 47: + var tok = handle_slash(); + if (tok === next_token) continue; + return tok; + } + if (is_digit(code)) return read_num(); + if (PUNC_CHARS[ch]) return token("punc", next()); + if (looking_at("=>")) return token("punc", next() + next()); + if (OPERATOR_CHARS[ch]) return read_operator(); + if (code == 35 || code == 92 || !NON_IDENTIFIER_CHARS[ch]) return read_word(); + break; + } + parse_error("Unexpected character '" + ch + "'"); + } + + next_token.context = function(nc) { + if (nc) S = nc; + return S; + }; + + next_token.add_directive = function(directive) { + S.directives[directive] = true; + } + + next_token.push_directives_stack = function() { + S.directives = Object.create(S.directives); + } + + next_token.pop_directives_stack = function() { + S.directives = Object.getPrototypeOf(S.directives); + } + + next_token.has_directive = function(directive) { + return !!S.directives[directive]; + } + + return next_token; +} + +/* -----[ Parser (constants) ]----- */ + +var UNARY_PREFIX = makePredicate("typeof void delete -- ++ ! ~ - +"); + +var UNARY_POSTFIX = makePredicate("-- ++"); + +var ASSIGNMENT = makePredicate("= += -= /= *= %= **= >>= <<= >>>= &= |= ^= &&= ||= ??="); + +var PRECEDENCE = function(a, ret) { + for (var i = 0; i < a.length;) { + var b = a[i++]; + for (var j = 0; j < b.length; j++) { + ret[b[j]] = i; + } + } + return ret; +}([ + ["??"], + ["||"], + ["&&"], + ["|"], + ["^"], + ["&"], + ["==", "===", "!=", "!=="], + ["<", ">", "<=", ">=", "in", "instanceof"], + [">>", "<<", ">>>"], + ["+", "-"], + ["*", "/", "%"], + ["**"], +], {}); + +var ATOMIC_START_TOKEN = makePredicate("atom bigint num regexp string"); + +/* -----[ Parser ]----- */ + +function parse($TEXT, options) { + options = defaults(options, { + bare_returns : false, + expression : false, + filename : null, + html5_comments : true, + module : false, + shebang : true, + strict : false, + toplevel : null, + }, true); + + var S = { + input : typeof $TEXT == "string" + ? tokenizer($TEXT, options.filename, options.html5_comments, options.shebang) + : $TEXT, + in_async : false, + in_directives : true, + in_funarg : -1, + in_function : 0, + in_generator : false, + in_loop : 0, + labels : [], + peeked : null, + prev : null, + token : null, + }; + + S.token = next(); + + function is(type, value) { + return is_token(S.token, type, value); + } + + function peek() { + return S.peeked || (S.peeked = S.input()); + } + + function next() { + S.prev = S.token; + if (S.peeked) { + S.token = S.peeked; + S.peeked = null; + } else { + S.token = S.input(); + } + S.in_directives = S.in_directives && ( + S.token.type == "string" || is("punc", ";") + ); + return S.token; + } + + function prev() { + return S.prev; + } + + function croak(msg, line, col, pos) { + var ctx = S.input.context(); + js_error(msg, + ctx.filename, + line != null ? line : ctx.tokline, + col != null ? col : ctx.tokcol, + pos != null ? pos : ctx.tokpos); + } + + function token_error(token, msg) { + croak(msg, token.line, token.col); + } + + function token_to_string(type, value) { + return type + (value === undefined ? "" : " «" + value + "»"); + } + + function unexpected(token) { + if (token == null) token = S.token; + token_error(token, "Unexpected token: " + token_to_string(token.type, token.value)); + } + + function expect_token(type, val) { + if (is(type, val)) return next(); + token_error(S.token, "Unexpected token: " + token_to_string(S.token.type, S.token.value) + ", expected: " + token_to_string(type, val)); + } + + function expect(punc) { + return expect_token("punc", punc); + } + + function has_newline_before(token) { + return token.nlb || !all(token.comments_before, function(comment) { + return !comment.nlb; + }); + } + + function can_insert_semicolon() { + return !options.strict + && (is("eof") || is("punc", "}") || has_newline_before(S.token)); + } + + function semicolon(optional) { + if (is("punc", ";")) next(); + else if (!optional && !can_insert_semicolon()) expect(";"); + } + + function parenthesized() { + expect("("); + var exp = expression(); + expect(")"); + return exp; + } + + function embed_tokens(parser) { + return function() { + var start = S.token; + var expr = parser.apply(null, arguments); + var end = prev(); + expr.start = start; + expr.end = end; + return expr; + }; + } + + function handle_regexp() { + if (is("operator", "/") || is("operator", "/=")) { + S.peeked = null; + S.token = S.input(S.token.value.substr(1)); // force regexp + } + } + + var statement = embed_tokens(function(toplevel) { + handle_regexp(); + switch (S.token.type) { + case "string": + var dir = S.in_directives; + var body = expression(); + if (dir) { + if (body instanceof AST_String) { + var value = body.start.raw.slice(1, -1); + S.input.add_directive(value); + body.value = value; + } else { + S.in_directives = dir = false; + } + } + semicolon(); + return dir ? new AST_Directive(body) : new AST_SimpleStatement({ body: body }); + case "num": + case "bigint": + case "regexp": + case "operator": + case "atom": + return simple_statement(); + + case "name": + switch (S.token.value) { + case "async": + if (is_token(peek(), "keyword", "function")) { + next(); + next(); + if (!is("operator", "*")) return function_(AST_AsyncDefun); + next(); + return function_(AST_AsyncGeneratorDefun); + } + break; + case "await": + if (S.in_async) return simple_statement(); + break; + case "export": + if (!toplevel && options.module !== "") unexpected(); + next(); + return export_(); + case "import": + var token = peek(); + if (token.type == "punc" && /^[(.]$/.test(token.value)) break; + if (!toplevel && options.module !== "") unexpected(); + next(); + return import_(); + case "let": + if (is_vardefs()) { + next(); + var node = let_(); + semicolon(); + return node; + } + break; + case "yield": + if (S.in_generator) return simple_statement(); + break; + } + return is_token(peek(), "punc", ":") + ? labeled_statement() + : simple_statement(); + + case "punc": + switch (S.token.value) { + case "{": + return new AST_BlockStatement({ + start : S.token, + body : block_(), + end : prev() + }); + case "[": + case "(": + case "`": + return simple_statement(); + case ";": + S.in_directives = false; + next(); + return new AST_EmptyStatement(); + default: + unexpected(); + } + + case "keyword": + switch (S.token.value) { + case "break": + next(); + return break_cont(AST_Break); + + case "class": + next(); + return class_(AST_DefClass); + + case "const": + next(); + var node = const_(); + semicolon(); + return node; + + case "continue": + next(); + return break_cont(AST_Continue); + + case "debugger": + next(); + semicolon(); + return new AST_Debugger(); + + case "do": + next(); + var body = in_loop(statement); + expect_token("keyword", "while"); + var condition = parenthesized(); + semicolon(true); + return new AST_Do({ + body : body, + condition : condition, + }); + + case "while": + next(); + return new AST_While({ + condition : parenthesized(), + body : in_loop(statement), + }); + + case "for": + next(); + return for_(); + + case "function": + next(); + if (!is("operator", "*")) return function_(AST_Defun); + next(); + return function_(AST_GeneratorDefun); + + case "if": + next(); + return if_(); + + case "return": + if (S.in_function == 0 && !options.bare_returns) + croak("'return' outside of function"); + next(); + var value = null; + if (is("punc", ";")) { + next(); + } else if (!can_insert_semicolon()) { + value = expression(); + semicolon(); + } + return new AST_Return({ value: value }); + + case "switch": + next(); + return new AST_Switch({ + expression : parenthesized(), + body : in_loop(switch_body_), + }); + + case "throw": + next(); + if (has_newline_before(S.token)) + croak("Illegal newline after 'throw'"); + var value = expression(); + semicolon(); + return new AST_Throw({ value: value }); + + case "try": + next(); + return try_(); + + case "var": + next(); + var node = var_(); + semicolon(); + return node; + + case "with": + if (S.input.has_directive("use strict")) { + croak("Strict mode may not include a with statement"); + } + next(); + return new AST_With({ + expression : parenthesized(), + body : statement(), + }); + } + } + unexpected(); + }); + + function labeled_statement() { + var label = as_symbol(AST_Label); + if (!all(S.labels, function(l) { + return l.name != label.name; + })) { + // ECMA-262, 12.12: An ECMAScript program is considered + // syntactically incorrect if it contains a + // LabelledStatement that is enclosed by a + // LabelledStatement with the same Identifier as label. + croak("Label " + label.name + " defined twice"); + } + expect(":"); + S.labels.push(label); + var stat = statement(); + S.labels.pop(); + if (!(stat instanceof AST_IterationStatement)) { + // check for `continue` that refers to this label. + // those should be reported as syntax errors. + // https://github.com/mishoo/UglifyJS/issues/287 + label.references.forEach(function(ref) { + if (ref instanceof AST_Continue) { + token_error(ref.label.start, "Continue label `" + label.name + "` must refer to IterationStatement"); + } + }); + } + return new AST_LabeledStatement({ body: stat, label: label }); + } + + function simple_statement() { + var body = expression(); + semicolon(); + return new AST_SimpleStatement({ body: body }); + } + + function break_cont(type) { + var label = null, ldef; + if (!can_insert_semicolon()) { + label = as_symbol(AST_LabelRef, true); + } + if (label != null) { + ldef = find_if(function(l) { + return l.name == label.name; + }, S.labels); + if (!ldef) token_error(label.start, "Undefined label " + label.name); + label.thedef = ldef; + } else if (S.in_loop == 0) croak(type.TYPE + " not inside a loop or switch"); + semicolon(); + var stat = new type({ label: label }); + if (ldef) ldef.references.push(stat); + return stat; + } + + function has_modifier(name, no_nlb) { + if (!is("name", name)) return; + var token = peek(); + if (!token) return; + if (is_token(token, "operator", "=")) return; + if (token.type == "punc" && /^[(;}]$/.test(token.value)) return; + if (no_nlb && has_newline_before(token)) return; + return next(); + } + + function class_(ctor) { + var was_async = S.in_async; + var was_gen = S.in_generator; + S.input.push_directives_stack(); + S.input.add_directive("use strict"); + var name; + if (ctor === AST_DefClass) { + name = as_symbol(AST_SymbolDefClass); + } else { + name = as_symbol(AST_SymbolClass, true); + } + var parent = null; + if (is("keyword", "extends")) { + next(); + handle_regexp(); + parent = expr_atom(true); + } + expect("{"); + var props = []; + while (!is("punc", "}")) { + if (is("punc", ";")) { + next(); + continue; + } + var start = S.token; + var fixed = !!has_modifier("static"); + var async = has_modifier("async", true); + if (is("operator", "*")) { + next(); + var internal = is("name") && /^#/.test(S.token.value); + var key = as_property_key(); + var gen_start = S.token; + var gen = function_(async ? AST_AsyncGeneratorFunction : AST_GeneratorFunction); + gen.start = gen_start; + gen.end = prev(); + props.push(new AST_ClassMethod({ + start: start, + static: fixed, + private: internal, + key: key, + value: gen, + end: prev(), + })); + continue; + } + if (fixed && is("punc", "{")) { + props.push(new AST_ClassInit({ + start: start, + value: new AST_ClassInitBlock({ + start: start, + body: block_(), + end: prev(), + }), + end: prev(), + })); + continue; + } + var internal = is("name") && /^#/.test(S.token.value); + var key = as_property_key(); + if (is("punc", "(")) { + var func_start = S.token; + var func = function_(async ? AST_AsyncFunction : AST_Function); + func.start = func_start; + func.end = prev(); + props.push(new AST_ClassMethod({ + start: start, + static: fixed, + private: internal, + key: key, + value: func, + end: prev(), + })); + continue; + } + if (async) unexpected(async); + var value = null; + if (is("operator", "=")) { + next(); + S.in_async = false; + S.in_generator = false; + value = maybe_assign(); + S.in_generator = was_gen; + S.in_async = was_async; + } else if (!(is("punc", ";") || is("punc", "}"))) { + var type = null; + switch (key) { + case "get": + type = AST_ClassGetter; + break; + case "set": + type = AST_ClassSetter; + break; + } + if (type) { + props.push(new type({ + start: start, + static: fixed, + private: is("name") && /^#/.test(S.token.value), + key: as_property_key(), + value: create_accessor(), + end: prev(), + })); + continue; + } + } + semicolon(); + props.push(new AST_ClassField({ + start: start, + static: fixed, + private: internal, + key: key, + value: value, + end: prev(), + })); + } + next(); + S.input.pop_directives_stack(); + S.in_generator = was_gen; + S.in_async = was_async; + return new ctor({ + extends: parent, + name: name, + properties: props, + }); + } + + function for_() { + var await_token = is("name", "await") && next(); + expect("("); + var init = null; + if (await_token || !is("punc", ";")) { + init = is("keyword", "const") + ? (next(), const_(true)) + : is("name", "let") && is_vardefs() + ? (next(), let_(true)) + : is("keyword", "var") + ? (next(), var_(true)) + : expression(true); + var ctor; + if (await_token) { + expect_token("name", "of"); + ctor = AST_ForAwaitOf; + } else if (is("operator", "in")) { + next(); + ctor = AST_ForIn; + } else if (is("name", "of")) { + next(); + ctor = AST_ForOf; + } + if (ctor) { + if (init instanceof AST_Definitions) { + if (init.definitions.length > 1) { + token_error(init.start, "Only one variable declaration allowed in for..in/of loop"); + } + if (ctor !== AST_ForIn && init.definitions[0].value) { + token_error(init.definitions[0].value.start, "No initializers allowed in for..of loop"); + } + } else if (!(is_assignable(init) || (init = to_destructured(init)) instanceof AST_Destructured)) { + token_error(init.start, "Invalid left-hand side in for..in/of loop"); + } + return for_enum(ctor, init); + } + } + return regular_for(init); + } + + function regular_for(init) { + expect(";"); + var test = is("punc", ";") ? null : expression(); + expect(";"); + var step = is("punc", ")") ? null : expression(); + expect(")"); + return new AST_For({ + init : init, + condition : test, + step : step, + body : in_loop(statement) + }); + } + + function for_enum(ctor, init) { + handle_regexp(); + var obj = expression(); + expect(")"); + return new ctor({ + init : init, + object : obj, + body : in_loop(statement) + }); + } + + function to_funarg(node) { + if (node instanceof AST_Array) { + var rest = null; + if (node.elements[node.elements.length - 1] instanceof AST_Spread) { + rest = to_funarg(node.elements.pop().expression); + } + return new AST_DestructuredArray({ + start: node.start, + elements: node.elements.map(to_funarg), + rest: rest, + end: node.end, + }); + } + if (node instanceof AST_Assign) return new AST_DefaultValue({ + start: node.start, + name: to_funarg(node.left), + value: node.right, + end: node.end, + }); + if (node instanceof AST_DefaultValue) { + node.name = to_funarg(node.name); + return node; + } + if (node instanceof AST_DestructuredArray) { + node.elements = node.elements.map(to_funarg); + if (node.rest) node.rest = to_funarg(node.rest); + return node; + } + if (node instanceof AST_DestructuredObject) { + node.properties.forEach(function(prop) { + prop.value = to_funarg(prop.value); + }); + if (node.rest) node.rest = to_funarg(node.rest); + return node; + } + if (node instanceof AST_Hole) return node; + if (node instanceof AST_Object) { + var rest = null; + if (node.properties[node.properties.length - 1] instanceof AST_Spread) { + rest = to_funarg(node.properties.pop().expression); + } + return new AST_DestructuredObject({ + start: node.start, + properties: node.properties.map(function(prop) { + if (!(prop instanceof AST_ObjectKeyVal)) token_error(prop.start, "Invalid destructuring assignment"); + return new AST_DestructuredKeyVal({ + start: prop.start, + key: prop.key, + value: to_funarg(prop.value), + end: prop.end, + }); + }), + rest: rest, + end: node.end, + }); + } + if (node instanceof AST_SymbolFunarg) return node; + if (node instanceof AST_SymbolRef) return new AST_SymbolFunarg(node); + if (node instanceof AST_Yield) return new AST_SymbolFunarg({ + start: node.start, + name: "yield", + end: node.end, + }); + token_error(node.start, "Invalid arrow parameter"); + } + + function arrow(exprs, start, async) { + var was_async = S.in_async; + var was_gen = S.in_generator; + S.in_async = async; + S.in_generator = false; + var was_funarg = S.in_funarg; + S.in_funarg = S.in_function; + var argnames = exprs.map(to_funarg); + var rest = exprs.rest || null; + if (rest) rest = to_funarg(rest); + S.in_funarg = was_funarg; + expect("=>"); + var body, value; + var loop = S.in_loop; + var labels = S.labels; + ++S.in_function; + S.input.push_directives_stack(); + S.in_loop = 0; + S.labels = []; + if (is("punc", "{")) { + S.in_directives = true; + body = block_(); + value = null; + } else { + body = []; + handle_regexp(); + value = maybe_assign(); + } + var is_strict = S.input.has_directive("use strict"); + S.input.pop_directives_stack(); + --S.in_function; + S.in_loop = loop; + S.labels = labels; + S.in_generator = was_gen; + S.in_async = was_async; + var node = new (async ? AST_AsyncArrow : AST_Arrow)({ + start: start, + argnames: argnames, + rest: rest, + body: body, + value: value, + end: prev(), + }); + if (is_strict) node.each_argname(strict_verify_symbol); + return node; + } + + var function_ = function(ctor) { + var was_async = S.in_async; + var was_gen = S.in_generator; + var name; + if (/Defun$/.test(ctor.TYPE)) { + name = as_symbol(AST_SymbolDefun); + S.in_async = /^Async/.test(ctor.TYPE); + S.in_generator = /Generator/.test(ctor.TYPE); + } else { + S.in_async = /^Async/.test(ctor.TYPE); + S.in_generator = /Generator/.test(ctor.TYPE); + name = as_symbol(AST_SymbolLambda, true); + } + if (name && ctor !== AST_Accessor && !(name instanceof AST_SymbolDeclaration)) + unexpected(prev()); + expect("("); + var was_funarg = S.in_funarg; + S.in_funarg = S.in_function; + var argnames = expr_list(")", !options.strict, false, function() { + return maybe_default(AST_SymbolFunarg); + }); + S.in_funarg = was_funarg; + var loop = S.in_loop; + var labels = S.labels; + ++S.in_function; + S.in_directives = true; + S.input.push_directives_stack(); + S.in_loop = 0; + S.labels = []; + var body = block_(); + var is_strict = S.input.has_directive("use strict"); + S.input.pop_directives_stack(); + --S.in_function; + S.in_loop = loop; + S.labels = labels; + S.in_generator = was_gen; + S.in_async = was_async; + var node = new ctor({ + name: name, + argnames: argnames, + rest: argnames.rest || null, + body: body, + }); + if (is_strict) { + if (name) strict_verify_symbol(name); + node.each_argname(strict_verify_symbol); + } + return node; + }; + + function if_() { + var cond = parenthesized(), body = statement(), alt = null; + if (is("keyword", "else")) { + next(); + alt = statement(); + } + return new AST_If({ + condition : cond, + body : body, + alternative : alt, + }); + } + + function is_alias() { + return is("name") || is("string") || is_identifier_string(S.token.value); + } + + function make_string(token) { + return new AST_String({ + start: token, + quote: token.quote, + value: token.value, + end: token, + }); + } + + function as_path() { + var path = S.token; + expect_token("string"); + semicolon(); + return make_string(path); + } + + function export_() { + if (is("operator", "*")) { + var key = S.token; + var alias = key; + next(); + if (is("name", "as")) { + next(); + if (!is_alias()) expect_token("name"); + alias = S.token; + next(); + } + expect_token("name", "from"); + return new AST_ExportForeign({ + aliases: [ make_string(alias) ], + keys: [ make_string(key) ], + path: as_path(), + }); + } + if (is("punc", "{")) { + next(); + var aliases = []; + var keys = []; + while (is_alias()) { + var key = S.token; + next(); + keys.push(key); + if (is("name", "as")) { + next(); + if (!is_alias()) expect_token("name"); + aliases.push(S.token); + next(); + } else { + aliases.push(key); + } + if (!is("punc", "}")) expect(","); + } + expect("}"); + if (is("name", "from")) { + next(); + return new AST_ExportForeign({ + aliases: aliases.map(make_string), + keys: keys.map(make_string), + path: as_path(), + }); + } + semicolon(); + return new AST_ExportReferences({ + properties: keys.map(function(token, index) { + if (!is_token(token, "name")) token_error(token, "Name expected"); + var sym = _make_symbol(AST_SymbolExport, token); + sym.alias = make_string(aliases[index]); + return sym; + }), + }); + } + if (is("keyword", "default")) { + next(); + var start = S.token; + var body = export_default_decl(); + if (body) { + body.start = start; + body.end = prev(); + } else { + handle_regexp(); + body = expression(); + semicolon(); + } + return new AST_ExportDefault({ body: body }); + } + return new AST_ExportDeclaration({ body: export_decl() }); + } + + function maybe_named(def, expr) { + if (expr.name) { + expr = new def(expr); + expr.name = new (def === AST_DefClass ? AST_SymbolDefClass : AST_SymbolDefun)(expr.name); + } + return expr; + } + + function export_default_decl() { + if (is("name", "async")) { + if (!is_token(peek(), "keyword", "function")) return; + next(); + next(); + if (!is("operator", "*")) return maybe_named(AST_AsyncDefun, function_(AST_AsyncFunction)); + next(); + return maybe_named(AST_AsyncGeneratorDefun, function_(AST_AsyncGeneratorFunction)); + } else if (is("keyword")) switch (S.token.value) { + case "class": + next(); + return maybe_named(AST_DefClass, class_(AST_ClassExpression)); + case "function": + next(); + if (!is("operator", "*")) return maybe_named(AST_Defun, function_(AST_Function)); + next(); + return maybe_named(AST_GeneratorDefun, function_(AST_GeneratorFunction)); + } + } + + var export_decl = embed_tokens(function() { + if (is("name")) switch (S.token.value) { + case "async": + next(); + expect_token("keyword", "function"); + if (!is("operator", "*")) return function_(AST_AsyncDefun); + next(); + return function_(AST_AsyncGeneratorDefun); + case "let": + next(); + var node = let_(); + semicolon(); + return node; + } else if (is("keyword")) switch (S.token.value) { + case "class": + next(); + return class_(AST_DefClass); + case "const": + next(); + var node = const_(); + semicolon(); + return node; + case "function": + next(); + if (!is("operator", "*")) return function_(AST_Defun); + next(); + return function_(AST_GeneratorDefun); + case "var": + next(); + var node = var_(); + semicolon(); + return node; + } + unexpected(); + }); + + function import_() { + var all = null; + var def = as_symbol(AST_SymbolImport, true); + var props = null; + var cont; + if (def) { + def.key = new AST_String({ + start: def.start, + value: "", + end: def.end, + }); + if (cont = is("punc", ",")) next(); + } else { + cont = !is("string"); + } + if (cont) { + if (is("operator", "*")) { + var key = S.token; + next(); + expect_token("name", "as"); + all = as_symbol(AST_SymbolImport); + all.key = make_string(key); + } else { + expect("{"); + props = []; + while (is_alias()) { + var alias; + if (is_token(peek(), "name", "as")) { + var key = S.token; + next(); + next(); + alias = as_symbol(AST_SymbolImport); + alias.key = make_string(key); + } else { + alias = as_symbol(AST_SymbolImport); + alias.key = new AST_String({ + start: alias.start, + value: alias.name, + end: alias.end, + }); + } + props.push(alias); + if (!is("punc", "}")) expect(","); + } + expect("}"); + } + } + if (all || def || props) expect_token("name", "from"); + return new AST_Import({ + all: all, + default: def, + path: as_path(), + properties: props, + }); + } + + function block_() { + expect("{"); + var a = []; + while (!is("punc", "}")) { + if (is("eof")) expect("}"); + a.push(statement()); + } + next(); + return a; + } + + function switch_body_() { + expect("{"); + var a = [], branch, cur, default_branch, tmp; + while (!is("punc", "}")) { + if (is("eof")) expect("}"); + if (is("keyword", "case")) { + if (branch) branch.end = prev(); + cur = []; + branch = new AST_Case({ + start : (tmp = S.token, next(), tmp), + expression : expression(), + body : cur + }); + a.push(branch); + expect(":"); + } else if (is("keyword", "default")) { + if (branch) branch.end = prev(); + if (default_branch) croak("More than one default clause in switch statement"); + cur = []; + branch = new AST_Default({ + start : (tmp = S.token, next(), expect(":"), tmp), + body : cur + }); + a.push(branch); + default_branch = branch; + } else { + if (!cur) unexpected(); + cur.push(statement()); + } + } + if (branch) branch.end = prev(); + next(); + return a; + } + + function try_() { + var body = block_(), bcatch = null, bfinally = null; + if (is("keyword", "catch")) { + var start = S.token; + next(); + var name = null; + if (is("punc", "(")) { + next(); + name = maybe_destructured(AST_SymbolCatch); + expect(")"); + } + bcatch = new AST_Catch({ + start : start, + argname : name, + body : block_(), + end : prev() + }); + } + if (is("keyword", "finally")) { + var start = S.token; + next(); + bfinally = new AST_Finally({ + start : start, + body : block_(), + end : prev() + }); + } + if (!bcatch && !bfinally) + croak("Missing catch/finally blocks"); + return new AST_Try({ + body : body, + bcatch : bcatch, + bfinally : bfinally + }); + } + + function vardefs(type, no_in) { + var a = []; + for (;;) { + var start = S.token; + var name = maybe_destructured(type); + var value = null; + if (is("operator", "=")) { + next(); + value = maybe_assign(no_in); + } else if (!no_in && (type === AST_SymbolConst || name instanceof AST_Destructured)) { + croak("Missing initializer in declaration"); + } + a.push(new AST_VarDef({ + start : start, + name : name, + value : value, + end : prev() + })); + if (!is("punc", ",")) + break; + next(); + } + return a; + } + + function is_vardefs() { + var token = peek(); + return is_token(token, "name") || is_token(token, "punc", "[") || is_token(token, "punc", "{"); + } + + var const_ = function(no_in) { + return new AST_Const({ + start : prev(), + definitions : vardefs(AST_SymbolConst, no_in), + end : prev() + }); + }; + + var let_ = function(no_in) { + return new AST_Let({ + start : prev(), + definitions : vardefs(AST_SymbolLet, no_in), + end : prev() + }); + }; + + var var_ = function(no_in) { + return new AST_Var({ + start : prev(), + definitions : vardefs(AST_SymbolVar, no_in), + end : prev() + }); + }; + + var new_ = function(allow_calls) { + var start = S.token; + expect_token("operator", "new"); + var call; + if (is("punc", ".") && is_token(peek(), "name", "target")) { + next(); + next(); + call = new AST_NewTarget(); + } else { + var exp = expr_atom(false), args; + if (is("punc", "(")) { + next(); + args = expr_list(")", !options.strict); + } else { + args = []; + } + call = new AST_New({ expression: exp, args: args }); + } + call.start = start; + call.end = prev(); + return subscripts(call, allow_calls); + }; + + function as_atom_node() { + var ret, tok = S.token, value = tok.value; + switch (tok.type) { + case "num": + if (isFinite(value)) { + ret = new AST_Number({ value: value }); + } else { + ret = new AST_Infinity(); + if (value < 0) ret = new AST_UnaryPrefix({ operator: "-", expression: ret }); + } + break; + case "bigint": + ret = new AST_BigInt({ value: value }); + break; + case "string": + ret = new AST_String({ value: value, quote: tok.quote }); + break; + case "regexp": + ret = new AST_RegExp({ value: value }); + break; + case "atom": + switch (value) { + case "false": + ret = new AST_False(); + break; + case "true": + ret = new AST_True(); + break; + case "null": + ret = new AST_Null(); + break; + default: + unexpected(); + } + break; + default: + unexpected(); + } + next(); + ret.start = ret.end = tok; + return ret; + } + + var expr_atom = function(allow_calls) { + if (is("operator", "new")) { + return new_(allow_calls); + } + var start = S.token; + if (is("punc")) { + switch (start.value) { + case "`": + return subscripts(template(null), allow_calls); + case "(": + next(); + if (is("punc", ")")) { + next(); + return arrow([], start); + } + var ex = expression(false, true); + var len = start.comments_before.length; + [].unshift.apply(ex.start.comments_before, start.comments_before); + start.comments_before.length = 0; + start.comments_before = ex.start.comments_before; + start.comments_before_length = len; + if (len == 0 && start.comments_before.length > 0) { + var comment = start.comments_before[0]; + if (!comment.nlb) { + comment.nlb = start.nlb; + start.nlb = false; + } + } + start.comments_after = ex.start.comments_after; + ex.start = start; + expect(")"); + var end = prev(); + end.comments_before = ex.end.comments_before; + end.comments_after.forEach(function(comment) { + ex.end.comments_after.push(comment); + if (comment.nlb) S.token.nlb = true; + }); + end.comments_after.length = 0; + end.comments_after = ex.end.comments_after; + ex.end = end; + if (is("punc", "=>")) return arrow(ex instanceof AST_Sequence ? ex.expressions : [ ex ], start); + return subscripts(ex, allow_calls); + case "[": + return subscripts(array_(), allow_calls); + case "{": + return subscripts(object_(), allow_calls); + } + unexpected(); + } + if (is("keyword")) switch (start.value) { + case "class": + next(); + var clazz = class_(AST_ClassExpression); + clazz.start = start; + clazz.end = prev(); + return subscripts(clazz, allow_calls); + case "function": + next(); + var func; + if (is("operator", "*")) { + next(); + func = function_(AST_GeneratorFunction); + } else { + func = function_(AST_Function); + } + func.start = start; + func.end = prev(); + return subscripts(func, allow_calls); + } + if (is("name")) { + var sym = _make_symbol(AST_SymbolRef, start); + next(); + if (sym.name == "async") { + if (is("keyword", "function")) { + next(); + var func; + if (is("operator", "*")) { + next(); + func = function_(AST_AsyncGeneratorFunction); + } else { + func = function_(AST_AsyncFunction); + } + func.start = start; + func.end = prev(); + return subscripts(func, allow_calls); + } + if (is("name") && is_token(peek(), "punc", "=>")) { + start = S.token; + sym = _make_symbol(AST_SymbolRef, start); + next(); + return arrow([ sym ], start, true); + } + if (is("punc", "(")) { + var call = subscripts(sym, allow_calls); + if (!is("punc", "=>")) return call; + var args = call.args; + if (args[args.length - 1] instanceof AST_Spread) { + args.rest = args.pop().expression; + } + return arrow(args, start, true); + } + } + return is("punc", "=>") ? arrow([ sym ], start) : subscripts(sym, allow_calls); + } + if (ATOMIC_START_TOKEN[S.token.type]) { + return subscripts(as_atom_node(), allow_calls); + } + unexpected(); + }; + + function expr_list(closing, allow_trailing_comma, allow_empty, parser) { + if (!parser) parser = maybe_assign; + var first = true, a = []; + while (!is("punc", closing)) { + if (first) first = false; else expect(","); + if (allow_trailing_comma && is("punc", closing)) break; + if (allow_empty && is("punc", ",")) { + a.push(new AST_Hole({ start: S.token, end: S.token })); + } else if (!is("operator", "...")) { + a.push(parser()); + } else if (parser === maybe_assign) { + a.push(new AST_Spread({ + start: S.token, + expression: (next(), parser()), + end: prev(), + })); + } else { + next(); + a.rest = parser(); + if (a.rest instanceof AST_DefaultValue) token_error(a.rest.start, "Invalid rest parameter"); + break; + } + } + expect(closing); + return a; + } + + var array_ = embed_tokens(function() { + expect("["); + return new AST_Array({ + elements: expr_list("]", !options.strict, true) + }); + }); + + var create_accessor = embed_tokens(function() { + return function_(AST_Accessor); + }); + + var object_ = embed_tokens(function() { + expect("{"); + var first = true, a = []; + while (!is("punc", "}")) { + if (first) first = false; else expect(","); + // allow trailing comma + if (!options.strict && is("punc", "}")) break; + var start = S.token; + if (is("operator", "*")) { + next(); + var key = as_property_key(); + var gen_start = S.token; + var gen = function_(AST_GeneratorFunction); + gen.start = gen_start; + gen.end = prev(); + a.push(new AST_ObjectMethod({ + start: start, + key: key, + value: gen, + end: prev(), + })); + continue; + } + if (is("operator", "...")) { + next(); + a.push(new AST_Spread({ + start: start, + expression: maybe_assign(), + end: prev(), + })); + continue; + } + if (is_token(peek(), "operator", "=")) { + var name = as_symbol(AST_SymbolRef); + next(); + a.push(new AST_ObjectKeyVal({ + start: start, + key: start.value, + value: new AST_Assign({ + start: start, + left: name, + operator: "=", + right: maybe_assign(), + end: prev(), + }), + end: prev(), + })); + continue; + } + if (is_token(peek(), "punc", ",") || is_token(peek(), "punc", "}")) { + a.push(new AST_ObjectKeyVal({ + start: start, + key: start.value, + value: as_symbol(AST_SymbolRef), + end: prev(), + })); + continue; + } + var key = as_property_key(); + if (is("punc", "(")) { + var func_start = S.token; + var func = function_(AST_Function); + func.start = func_start; + func.end = prev(); + a.push(new AST_ObjectMethod({ + start: start, + key: key, + value: func, + end: prev(), + })); + continue; + } + if (is("punc", ":")) { + next(); + a.push(new AST_ObjectKeyVal({ + start: start, + key: key, + value: maybe_assign(), + end: prev(), + })); + continue; + } + if (start.type == "name") switch (key) { + case "async": + var is_gen = is("operator", "*") && next(); + key = as_property_key(); + var func_start = S.token; + var func = function_(is_gen ? AST_AsyncGeneratorFunction : AST_AsyncFunction); + func.start = func_start; + func.end = prev(); + a.push(new AST_ObjectMethod({ + start: start, + key: key, + value: func, + end: prev(), + })); + continue; + case "get": + a.push(new AST_ObjectGetter({ + start: start, + key: as_property_key(), + value: create_accessor(), + end: prev(), + })); + continue; + case "set": + a.push(new AST_ObjectSetter({ + start: start, + key: as_property_key(), + value: create_accessor(), + end: prev(), + })); + continue; + } + unexpected(); + } + next(); + return new AST_Object({ properties: a }); + }); + + function as_property_key() { + var tmp = S.token; + switch (tmp.type) { + case "operator": + if (!KEYWORDS[tmp.value]) unexpected(); + case "num": + case "string": + case "name": + case "keyword": + case "atom": + next(); + return "" + tmp.value; + case "punc": + expect("["); + var key = maybe_assign(); + expect("]"); + return key; + default: + unexpected(); + } + } + + function as_name() { + var name = S.token.value; + expect_token("name"); + return name; + } + + function _make_symbol(type, token) { + var name = token.value; + switch (name) { + case "await": + if (S.in_async) unexpected(token); + break; + case "super": + type = AST_Super; + break; + case "this": + type = AST_This; + break; + case "yield": + if (S.in_generator) unexpected(token); + break; + } + return new type({ + name: "" + name, + start: token, + end: token, + }); + } + + function strict_verify_symbol(sym) { + if (sym.name == "arguments" || sym.name == "eval" || sym.name == "let") + token_error(sym.start, "Unexpected " + sym.name + " in strict mode"); + } + + function as_symbol(type, no_error) { + if (!is("name")) { + if (!no_error) croak("Name expected"); + return null; + } + var sym = _make_symbol(type, S.token); + if (S.input.has_directive("use strict") && sym instanceof AST_SymbolDeclaration) { + strict_verify_symbol(sym); + } + next(); + return sym; + } + + function maybe_destructured(type) { + var start = S.token; + if (is("punc", "[")) { + next(); + var elements = expr_list("]", !options.strict, true, function() { + return maybe_default(type); + }); + return new AST_DestructuredArray({ + start: start, + elements: elements, + rest: elements.rest || null, + end: prev(), + }); + } + if (is("punc", "{")) { + next(); + var first = true, a = [], rest = null; + while (!is("punc", "}")) { + if (first) first = false; else expect(","); + // allow trailing comma + if (!options.strict && is("punc", "}")) break; + var key_start = S.token; + if (is("punc", "[") || is_token(peek(), "punc", ":")) { + var key = as_property_key(); + expect(":"); + a.push(new AST_DestructuredKeyVal({ + start: key_start, + key: key, + value: maybe_default(type), + end: prev(), + })); + continue; + } + if (is("operator", "...")) { + next(); + rest = maybe_destructured(type); + break; + } + var name = as_symbol(type); + if (is("operator", "=")) { + next(); + name = new AST_DefaultValue({ + start: name.start, + name: name, + value: maybe_assign(), + end: prev(), + }); + } + a.push(new AST_DestructuredKeyVal({ + start: key_start, + key: key_start.value, + value: name, + end: prev(), + })); + } + expect("}"); + return new AST_DestructuredObject({ + start: start, + properties: a, + rest: rest, + end: prev(), + }); + } + return as_symbol(type); + } + + function maybe_default(type) { + var start = S.token; + var name = maybe_destructured(type); + if (!is("operator", "=")) return name; + next(); + return new AST_DefaultValue({ + start: start, + name: name, + value: maybe_assign(), + end: prev(), + }); + } + + function template(tag) { + var start = tag ? tag.start : S.token; + var read = S.input.context().read_template; + var strings = []; + var expressions = []; + while (read(strings)) { + next(); + expressions.push(expression()); + if (!is("punc", "}")) unexpected(); + } + next(); + return new AST_Template({ + start: start, + expressions: expressions, + strings: strings, + tag: tag, + end: prev(), + }); + } + + function subscripts(expr, allow_calls) { + var start = expr.start; + var optional = null; + while (true) { + if (is("operator", "?") && is_token(peek(), "punc", ".")) { + next(); + next(); + optional = expr; + } + if (is("punc", "[")) { + next(); + var prop = expression(); + expect("]"); + expr = new AST_Sub({ + start: start, + optional: optional === expr, + expression: expr, + property: prop, + end: prev(), + }); + } else if (allow_calls && is("punc", "(")) { + next(); + expr = new AST_Call({ + start: start, + optional: optional === expr, + expression: expr, + args: expr_list(")", !options.strict), + end: prev(), + }); + } else if (optional === expr || is("punc", ".")) { + if (optional !== expr) next(); + expr = new AST_Dot({ + start: start, + optional: optional === expr, + expression: expr, + property: as_name(), + end: prev(), + }); + } else if (is("punc", "`")) { + if (optional) croak("Invalid template on optional chain"); + expr = template(expr); + } else { + break; + } + } + if (optional) expr.terminal = true; + if (expr instanceof AST_Call && !expr.pure) { + var start = expr.start; + var comments = start.comments_before; + var i = HOP(start, "comments_before_length") ? start.comments_before_length : comments.length; + while (--i >= 0) { + if (/[@#]__PURE__/.test(comments[i].value)) { + expr.pure = true; + break; + } + } + } + return expr; + } + + function maybe_unary(no_in) { + var start = S.token; + if (S.in_async && is("name", "await")) { + if (S.in_funarg === S.in_function) croak("Invalid use of await in function argument"); + S.input.context().regex_allowed = true; + next(); + return new AST_Await({ + start: start, + expression: maybe_unary(no_in), + end: prev(), + }); + } + if (S.in_generator && is("name", "yield")) { + if (S.in_funarg === S.in_function) croak("Invalid use of yield in function argument"); + S.input.context().regex_allowed = true; + next(); + var exp = null; + var nested = false; + if (is("operator", "*")) { + next(); + exp = maybe_assign(no_in); + nested = true; + } else if (is("punc") ? !PUNC_AFTER_EXPRESSION[S.token.value] : !can_insert_semicolon()) { + exp = maybe_assign(no_in); + } + return new AST_Yield({ + start: start, + expression: exp, + nested: nested, + end: prev(), + }); + } + if (is("operator") && UNARY_PREFIX[start.value]) { + next(); + handle_regexp(); + var ex = make_unary(AST_UnaryPrefix, start, maybe_unary(no_in)); + ex.start = start; + ex.end = prev(); + return ex; + } + var val = expr_atom(true); + while (is("operator") && UNARY_POSTFIX[S.token.value] && !has_newline_before(S.token)) { + val = make_unary(AST_UnaryPostfix, S.token, val); + val.start = start; + val.end = S.token; + next(); + } + return val; + } + + function make_unary(ctor, token, expr) { + var op = token.value; + switch (op) { + case "++": + case "--": + if (!is_assignable(expr)) + token_error(token, "Invalid use of " + op + " operator"); + break; + case "delete": + if (expr instanceof AST_SymbolRef && S.input.has_directive("use strict")) + token_error(expr.start, "Calling delete on expression not allowed in strict mode"); + break; + } + return new ctor({ operator: op, expression: expr }); + } + + var expr_op = function(left, min_precision, no_in) { + var op = is("operator") ? S.token.value : null; + if (op == "in" && no_in) op = null; + var precision = op != null ? PRECEDENCE[op] : null; + if (precision != null && precision > min_precision) { + next(); + var right = expr_op(maybe_unary(no_in), op == "**" ? precision - 1 : precision, no_in); + return expr_op(new AST_Binary({ + start : left.start, + left : left, + operator : op, + right : right, + end : right.end, + }), min_precision, no_in); + } + return left; + }; + + function expr_ops(no_in) { + return expr_op(maybe_unary(no_in), 0, no_in); + } + + var maybe_conditional = function(no_in) { + var start = S.token; + var expr = expr_ops(no_in); + if (is("operator", "?")) { + next(); + var yes = maybe_assign(); + expect(":"); + return new AST_Conditional({ + start : start, + condition : expr, + consequent : yes, + alternative : maybe_assign(no_in), + end : prev() + }); + } + return expr; + }; + + function is_assignable(expr) { + return expr instanceof AST_PropAccess && !expr.optional || expr instanceof AST_SymbolRef; + } + + function to_destructured(node) { + if (node instanceof AST_Array) { + var rest = null; + if (node.elements[node.elements.length - 1] instanceof AST_Spread) { + rest = to_destructured(node.elements.pop().expression); + if (!(rest instanceof AST_Destructured || is_assignable(rest))) return node; + } + var elements = node.elements.map(to_destructured); + return all(elements, function(node) { + return node instanceof AST_DefaultValue + || node instanceof AST_Destructured + || node instanceof AST_Hole + || is_assignable(node); + }) ? new AST_DestructuredArray({ + start: node.start, + elements: elements, + rest: rest, + end: node.end, + }) : node; + } + if (node instanceof AST_Assign) { + var name = to_destructured(node.left); + return name instanceof AST_Destructured || is_assignable(name) ? new AST_DefaultValue({ + start: node.start, + name: name, + value: node.right, + end: node.end, + }) : node; + } + if (!(node instanceof AST_Object)) return node; + var rest = null; + if (node.properties[node.properties.length - 1] instanceof AST_Spread) { + rest = to_destructured(node.properties.pop().expression); + if (!(rest instanceof AST_Destructured || is_assignable(rest))) return node; + } + var props = []; + for (var i = 0; i < node.properties.length; i++) { + var prop = node.properties[i]; + if (!(prop instanceof AST_ObjectKeyVal)) return node; + var value = to_destructured(prop.value); + if (!(value instanceof AST_DefaultValue || value instanceof AST_Destructured || is_assignable(value))) { + return node; + } + props.push(new AST_DestructuredKeyVal({ + start: prop.start, + key: prop.key, + value: value, + end: prop.end, + })); + } + return new AST_DestructuredObject({ + start: node.start, + properties: props, + rest: rest, + end: node.end, + }); + } + + function maybe_assign(no_in) { + var start = S.token; + var left = maybe_conditional(no_in), val = S.token.value; + if (is("operator") && ASSIGNMENT[val]) { + if (is_assignable(left) || val == "=" && (left = to_destructured(left)) instanceof AST_Destructured) { + next(); + return new AST_Assign({ + start : start, + left : left, + operator : val, + right : maybe_assign(no_in), + end : prev() + }); + } + croak("Invalid assignment"); + } + return left; + } + + function expression(no_in, maybe_arrow) { + var start = S.token; + var exprs = []; + while (true) { + if (maybe_arrow && is("operator", "...")) { + next(); + exprs.rest = maybe_destructured(AST_SymbolFunarg); + break; + } + exprs.push(maybe_assign(no_in)); + if (!is("punc", ",")) break; + next(); + if (maybe_arrow && is("punc", ")") && is_token(peek(), "punc", "=>")) break; + } + return exprs.length == 1 && !exprs.rest ? exprs[0] : new AST_Sequence({ + start: start, + expressions: exprs, + end: prev(), + }); + } + + function in_loop(cont) { + ++S.in_loop; + var ret = cont(); + --S.in_loop; + return ret; + } + + if (options.expression) { + handle_regexp(); + var exp = expression(); + expect_token("eof"); + return exp; + } + + return function() { + var start = S.token; + var body = []; + if (options.module) { + S.in_async = true; + S.input.add_directive("use strict"); + } + S.input.push_directives_stack(); + while (!is("eof")) + body.push(statement(true)); + S.input.pop_directives_stack(); + var end = prev() || start; + var toplevel = options.toplevel; + if (toplevel) { + toplevel.body = toplevel.body.concat(body); + toplevel.end = end; + } else { + toplevel = new AST_Toplevel({ start: start, body: body, end: end }); + } + return toplevel; + }(); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/propmangle.js b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/propmangle.js new file mode 100644 index 0000000000000000000000000000000000000000..3e71b68c624899e18115c3efe3e842f66056822e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/propmangle.js @@ -0,0 +1,328 @@ +/*********************************************************************** + + A JavaScript tokenizer / parser / beautifier / compressor. + https://github.com/mishoo/UglifyJS + + -------------------------------- (C) --------------------------------- + + Author: Mihai Bazon + + http://mihai.bazon.net/blog + + Distributed under the BSD license: + + Copyright 2012 (c) Mihai Bazon + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + * Redistributions of source code must retain the above + copyright notice, this list of conditions and the following + disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials + provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY + EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, + OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF + THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + SUCH DAMAGE. + + ***********************************************************************/ + +"use strict"; + +function get_builtins() { + var names = new Dictionary(); + // constants + [ + "NaN", + "null", + "true", + "false", + "Infinity", + "-Infinity", + "undefined", + ].forEach(add); + // global functions + [ + "encodeURI", + "encodeURIComponent", + "escape", + "eval", + "decodeURI", + "decodeURIComponent", + "isFinite", + "isNaN", + "parseFloat", + "parseInt", + "unescape", + ].forEach(add); + // global constructors & objects + var global = Function("return this")(); + [ + "Array", + "ArrayBuffer", + "Atomics", + "BigInt", + "Boolean", + "console", + "DataView", + "Date", + "Error", + "Function", + "Int8Array", + "Intl", + "JSON", + "Map", + "Math", + "Number", + "Object", + "Promise", + "Proxy", + "Reflect", + "RegExp", + "Set", + "String", + "Symbol", + "WebAssembly", + ].forEach(function(name) { + add(name); + var ctor = global[name]; + if (!ctor) return; + Object.getOwnPropertyNames(ctor).map(add); + if (typeof ctor != "function") return; + if (ctor.__proto__) Object.getOwnPropertyNames(ctor.__proto__).map(add); + if (ctor.prototype) Object.getOwnPropertyNames(ctor.prototype).map(add); + try { + Object.getOwnPropertyNames(new ctor()).map(add); + } catch (e) { + try { + Object.getOwnPropertyNames(ctor()).map(add); + } catch (e) {} + } + }); + return (get_builtins = function() { + return names.clone(); + })(); + + function add(name) { + names.set(name, true); + } +} + +function reserve_quoted_keys(ast, reserved) { + ast.walk(new TreeWalker(function(node) { + if (node instanceof AST_ClassProperty + || node instanceof AST_DestructuredKeyVal + || node instanceof AST_ObjectProperty) { + if (node.key instanceof AST_Node) { + addStrings(node.key, add); + } else if (node.start && node.start.quote) { + add(node.key); + } + } else if (node instanceof AST_Dot) { + if (node.quoted) add(node.property); + } else if (node instanceof AST_Sub) { + addStrings(node.property, add); + } + })); + + function add(name) { + push_uniq(reserved, name); + } +} + +function addStrings(node, add) { + if (node instanceof AST_Conditional) { + addStrings(node.consequent, add); + addStrings(node.alternative, add); + } else if (node instanceof AST_Sequence) { + addStrings(node.tail_node(), add); + } else if (node instanceof AST_String) { + add(node.value); + } +} + +function mangle_properties(ast, options) { + options = defaults(options, { + builtins: false, + cache: null, + debug: false, + domprops: false, + keep_quoted: false, + regex: null, + reserved: null, + }, true); + + var reserved = options.builtins ? new Dictionary() : get_builtins(); + if (!options.domprops && typeof domprops !== "undefined") domprops.forEach(function(name) { + reserved.set(name, true); + }); + if (Array.isArray(options.reserved)) options.reserved.forEach(function(name) { + reserved.set(name, true); + }); + + var cname = -1; + var cache; + if (options.cache) { + cache = options.cache.props; + cache.each(function(name) { + reserved.set(name, true); + }); + } else { + cache = new Dictionary(); + } + + var regex = options.regex; + + // note debug is either false (disabled), or a string of the debug suffix to use (enabled). + // note debug may be enabled as an empty string, which is falsy. Also treat passing 'true' + // the same as passing an empty string. + var debug = options.debug !== false; + var debug_suffix; + if (debug) debug_suffix = options.debug === true ? "" : options.debug; + + var names_to_mangle = new Dictionary(); + var unmangleable = reserved.clone(); + + // step 1: find candidates to mangle + ast.walk(new TreeWalker(function(node) { + if (node.TYPE == "Call") { + var exp = node.expression; + if (exp instanceof AST_Dot) switch (exp.property) { + case "defineProperty": + case "getOwnPropertyDescriptor": + if (node.args.length < 2) break; + exp = exp.expression; + if (!(exp instanceof AST_SymbolRef)) break; + if (exp.name != "Object") break; + if (!exp.definition().undeclared) break; + addStrings(node.args[1], add); + break; + case "hasOwnProperty": + if (node.args.length < 1) break; + addStrings(node.args[0], add); + break; + } + } else if (node instanceof AST_ClassProperty + || node instanceof AST_DestructuredKeyVal + || node instanceof AST_ObjectProperty) { + if (node.key instanceof AST_Node) { + addStrings(node.key, add); + } else { + add(node.key); + } + } else if (node instanceof AST_Dot) { + if (is_lhs(node, this.parent())) add(node.property); + } else if (node instanceof AST_Sub) { + if (is_lhs(node, this.parent())) addStrings(node.property, add); + } + })); + + // step 2: renaming properties + ast.walk(new TreeWalker(function(node) { + if (node instanceof AST_Binary) { + if (node.operator == "in") mangleStrings(node.left); + } else if (node.TYPE == "Call") { + var exp = node.expression; + if (exp instanceof AST_Dot) switch (exp.property) { + case "defineProperty": + case "getOwnPropertyDescriptor": + if (node.args.length < 2) break; + exp = exp.expression; + if (!(exp instanceof AST_SymbolRef)) break; + if (exp.name != "Object") break; + if (!exp.definition().undeclared) break; + mangleStrings(node.args[1]); + break; + case "hasOwnProperty": + if (node.args.length < 1) break; + mangleStrings(node.args[0]); + break; + } + } else if (node instanceof AST_ClassProperty + || node instanceof AST_DestructuredKeyVal + || node instanceof AST_ObjectProperty) { + if (node.key instanceof AST_Node) { + mangleStrings(node.key); + } else { + node.key = mangle(node.key); + } + } else if (node instanceof AST_Dot) { + node.property = mangle(node.property); + } else if (node instanceof AST_Sub) { + if (!options.keep_quoted) mangleStrings(node.property); + } + })); + + // only function declarations after this line + + function can_mangle(name) { + if (unmangleable.has(name)) return false; + if (/^-?[0-9]+(\.[0-9]+)?(e[+-][0-9]+)?$/.test(name)) return false; + return true; + } + + function should_mangle(name) { + if (reserved.has(name)) { + AST_Node.info("Preserving reserved property {this}", name); + return false; + } + if (regex && !regex.test(name)) { + AST_Node.info("Preserving excluded property {this}", name); + return false; + } + return cache.has(name) || names_to_mangle.has(name); + } + + function add(name) { + if (can_mangle(name)) names_to_mangle.set(name, true); + if (!should_mangle(name)) unmangleable.set(name, true); + } + + function mangle(name) { + if (!should_mangle(name)) return name; + var mangled = cache.get(name); + if (!mangled) { + if (debug) { + // debug mode: use a prefix and suffix to preserve readability, e.g. o.foo ---> o._$foo$NNN_. + var debug_mangled = "_$" + name + "$" + debug_suffix + "_"; + if (can_mangle(debug_mangled)) mangled = debug_mangled; + } + // either debug mode is off, or it is on and we could not use the mangled name + if (!mangled) do { + mangled = base54(++cname); + } while (!can_mangle(mangled)); + if (/^#/.test(name)) mangled = "#" + mangled; + cache.set(name, mangled); + } + AST_Node.info("Mapping property {name} to {mangled}", { + mangled: mangled, + name: name, + }); + return mangled; + } + + function mangleStrings(node) { + if (node instanceof AST_Sequence) { + mangleStrings(node.tail_node()); + } else if (node instanceof AST_String) { + node.value = mangle(node.value); + } else if (node instanceof AST_Conditional) { + mangleStrings(node.consequent); + mangleStrings(node.alternative); + } + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/scope.js b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/scope.js new file mode 100644 index 0000000000000000000000000000000000000000..3e18b6d3fd44f3db17159d517e21ebb1f8192f9f --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/scope.js @@ -0,0 +1,883 @@ +/*********************************************************************** + + A JavaScript tokenizer / parser / beautifier / compressor. + https://github.com/mishoo/UglifyJS + + -------------------------------- (C) --------------------------------- + + Author: Mihai Bazon + + http://mihai.bazon.net/blog + + Distributed under the BSD license: + + Copyright 2012 (c) Mihai Bazon + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + * Redistributions of source code must retain the above + copyright notice, this list of conditions and the following + disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials + provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY + EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, + OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF + THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + SUCH DAMAGE. + + ***********************************************************************/ + +"use strict"; + +function SymbolDef(id, scope, orig, init) { + this._bits = 0; + this.defun = undefined; + this.eliminated = 0; + this.id = id; + this.init = init; + this.mangled_name = null; + this.name = orig.name; + this.orig = [ orig ]; + this.references = []; + this.replaced = 0; + this.safe_ids = undefined; + this.scope = scope; +} + +SymbolDef.prototype = { + forEach: function(fn) { + this.orig.forEach(fn); + this.references.forEach(fn); + }, + mangle: function(options) { + if (this.mangled_name) return; + var cache = this.global && options.cache && options.cache.props; + if (cache && cache.has(this.name)) { + this.mangled_name = cache.get(this.name); + } else if (!this.unmangleable(options)) { + var def = this.redefined(); + if (def) { + this.mangled_name = def.mangled_name || def.name; + } else { + this.mangled_name = next_mangled_name(this, options); + } + if (cache) cache.set(this.name, this.mangled_name); + } + }, + redefined: function() { + var self = this; + var scope = self.defun; + if (!scope) return; + var name = self.name; + var def = scope.variables.get(name) + || scope instanceof AST_Toplevel && scope.globals.get(name) + || self.orig[0] instanceof AST_SymbolConst && find_if(function(def) { + return def.name == name; + }, scope.enclosed); + if (def && def !== self) return def.redefined() || def; + }, + unmangleable: function(options) { + if (this.exported) return true; + if (this.undeclared) return true; + if (!options.eval && this.scope.pinned()) return true; + if (options.keep_fargs && is_funarg(this)) return true; + if (options.keep_fnames) { + var sym = this.orig[0]; + if (sym instanceof AST_SymbolClass) return true; + if (sym instanceof AST_SymbolDefClass) return true; + if (sym instanceof AST_SymbolDefun) return true; + if (sym instanceof AST_SymbolLambda) return true; + } + if (!options.toplevel && this.global) return true; + return false; + }, +}; + +DEF_BITPROPS(SymbolDef, [ + "const_redefs", + "cross_loop", + "direct_access", + "exported", + "global", + "undeclared", +]); + +function is_funarg(def) { + return def.orig[0] instanceof AST_SymbolFunarg || def.orig[1] instanceof AST_SymbolFunarg; +} + +var unary_side_effects = makePredicate("delete ++ --"); + +function is_lhs(node, parent) { + if (parent instanceof AST_Assign) return parent.left === node && node; + if (parent instanceof AST_DefaultValue) return parent.name === node && node; + if (parent instanceof AST_Destructured) return node; + if (parent instanceof AST_DestructuredKeyVal) return node; + if (parent instanceof AST_ForEnumeration) return parent.init === node && node; + if (parent instanceof AST_Unary) return unary_side_effects[parent.operator] && parent.expression; +} + +AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) { + options = defaults(options, { + cache: null, + ie: false, + }); + + // pass 1: setup scope chaining and handle definitions + var self = this; + var defun = null; + var exported = false; + var next_def_id = 0; + var scope = self.parent_scope = null; + var tw = new TreeWalker(function(node, descend) { + if (node instanceof AST_DefClass) { + var save_exported = exported; + exported = tw.parent() instanceof AST_ExportDeclaration; + node.name.walk(tw); + exported = save_exported; + walk_scope(function() { + if (node.extends) node.extends.walk(tw); + node.properties.forEach(function(prop) { + prop.walk(tw); + }); + }); + return true; + } + if (node instanceof AST_Definitions) { + var save_exported = exported; + exported = tw.parent() instanceof AST_ExportDeclaration; + descend(); + exported = save_exported; + return true; + } + if (node instanceof AST_LambdaDefinition) { + var save_exported = exported; + exported = tw.parent() instanceof AST_ExportDeclaration; + node.name.walk(tw); + exported = save_exported; + walk_scope(function() { + node.argnames.forEach(function(argname) { + argname.walk(tw); + }); + if (node.rest) node.rest.walk(tw); + walk_body(node, tw); + }); + return true; + } + if (node instanceof AST_Switch) { + node.expression.walk(tw); + walk_scope(function() { + walk_body(node, tw); + }); + return true; + } + if (node instanceof AST_SwitchBranch) { + node.init_vars(scope); + descend(); + return true; + } + if (node instanceof AST_Try) { + walk_scope(function() { + walk_body(node, tw); + }); + if (node.bcatch) node.bcatch.walk(tw); + if (node.bfinally) node.bfinally.walk(tw); + return true; + } + if (node instanceof AST_With) { + var s = scope; + do { + s = s.resolve(); + if (s.uses_with) break; + s.uses_with = true; + } while (s = s.parent_scope); + walk_scope(descend); + return true; + } + if (node instanceof AST_BlockScope) { + walk_scope(descend); + return true; + } + if (node instanceof AST_Symbol) { + node.scope = scope; + } + if (node instanceof AST_Label) { + node.thedef = node; + node.references = []; + } + if (node instanceof AST_SymbolCatch) { + scope.def_variable(node).defun = defun; + } else if (node instanceof AST_SymbolConst) { + var def = scope.def_variable(node); + def.defun = defun; + if (exported) def.exported = true; + } else if (node instanceof AST_SymbolDefun) { + var def = defun.def_function(node, tw.parent()); + if (exported) def.exported = true; + } else if (node instanceof AST_SymbolFunarg) { + defun.def_variable(node); + } else if (node instanceof AST_SymbolLambda) { + var def = defun.def_function(node, node.name == "arguments" ? undefined : defun); + if (options.ie && node.name != "arguments") def.defun = defun.parent_scope.resolve(); + } else if (node instanceof AST_SymbolLet) { + var def = scope.def_variable(node); + if (exported) def.exported = true; + } else if (node instanceof AST_SymbolVar) { + var def = defun.def_variable(node, node instanceof AST_SymbolImport ? undefined : null); + if (exported) def.exported = true; + } + + function walk_scope(descend) { + node.init_vars(scope); + var save_defun = defun; + var save_scope = scope; + if (node instanceof AST_Scope) defun = node; + scope = node; + descend(); + scope = save_scope; + defun = save_defun; + } + }); + self.make_def = function(orig, init) { + return new SymbolDef(++next_def_id, this, orig, init); + }; + self.walk(tw); + + // pass 2: find back references and eval + self.globals = new Dictionary(); + var in_arg = []; + var tw = new TreeWalker(function(node) { + if (node instanceof AST_Catch) { + if (!(node.argname instanceof AST_Destructured)) return; + in_arg.push(node); + node.argname.walk(tw); + in_arg.pop(); + walk_body(node, tw); + return true; + } + if (node instanceof AST_Lambda) { + in_arg.push(node); + if (node.name) node.name.walk(tw); + node.argnames.forEach(function(argname) { + argname.walk(tw); + }); + if (node.rest) node.rest.walk(tw); + in_arg.pop(); + walk_lambda(node, tw); + return true; + } + if (node instanceof AST_LoopControl) { + if (node.label) node.label.thedef.references.push(node); + return true; + } + if (node instanceof AST_SymbolDeclaration) { + var def = node.definition(); + def.preinit = def.references.length; + if (node instanceof AST_SymbolCatch) { + // ensure mangling works if `catch` reuses a scope variable + var redef = def.redefined(); + if (redef) for (var s = node.scope; s; s = s.parent_scope) { + if (!push_uniq(s.enclosed, redef)) break; + if (s === redef.scope) break; + } + } else if (node instanceof AST_SymbolConst) { + // ensure compression works if `const` reuses a scope variable + var redef = def.redefined(); + if (redef) redef.const_redefs = true; + } else if (def.scope !== node.scope && (node instanceof AST_SymbolDefun + || node instanceof AST_SymbolFunarg + || node instanceof AST_SymbolVar)) { + node.mark_enclosed(options); + var redef = node.scope.find_variable(node.name); + if (node.thedef !== redef) { + node.thedef = redef; + redef.orig.push(node); + node.mark_enclosed(options); + } + } + if (node.name != "arguments") return true; + var parent = node instanceof AST_SymbolVar && tw.parent(); + if (parent instanceof AST_VarDef && !parent.value) return true; + var sym = node.scope.resolve().find_variable("arguments"); + if (sym && is_arguments(sym)) sym.scope.uses_arguments = 3; + return true; + } + if (node instanceof AST_SymbolRef) { + var name = node.name; + var sym = node.scope.find_variable(name); + for (var i = in_arg.length; i > 0 && sym;) { + i = in_arg.lastIndexOf(sym.scope, i - 1); + if (i < 0) break; + var decl = sym.orig[0]; + if (decl instanceof AST_SymbolCatch + || decl instanceof AST_SymbolFunarg + || decl instanceof AST_SymbolLambda) { + node.in_arg = true; + break; + } + sym = sym.scope.parent_scope.find_variable(name); + } + if (!sym) { + sym = self.def_global(node); + } else if (name == "arguments" && is_arguments(sym)) { + var parent = tw.parent(); + if (is_lhs(node, parent)) { + sym.scope.uses_arguments = 3; + } else if (sym.scope.uses_arguments < 2 + && !(parent instanceof AST_PropAccess && parent.expression === node)) { + sym.scope.uses_arguments = 2; + } else if (!sym.scope.uses_arguments) { + sym.scope.uses_arguments = true; + } + } + if (name == "eval") { + var parent = tw.parent(); + if (parent.TYPE == "Call" && parent.expression === node) { + var s = node.scope; + do { + s = s.resolve(); + if (s.uses_eval) break; + s.uses_eval = true; + } while (s = s.parent_scope); + } else if (sym.undeclared) { + self.uses_eval = true; + } + } + if (sym.init instanceof AST_LambdaDefinition && sym.scope !== sym.init.name.scope) { + var scope = node.scope; + do { + if (scope === sym.init.name.scope) break; + } while (scope = scope.parent_scope); + if (!scope) sym.init = undefined; + } + node.thedef = sym; + node.reference(options); + return true; + } + }); + self.walk(tw); + + // pass 3: fix up any scoping issue with IE8 + if (options.ie) self.walk(new TreeWalker(function(node) { + if (node instanceof AST_SymbolCatch) { + var def = node.thedef; + var scope = def.defun; + if (def.name != "arguments" && scope.name instanceof AST_SymbolLambda && scope.name.name == def.name) { + scope = scope.parent_scope.resolve(); + } + redefine(node, scope); + return true; + } + if (node instanceof AST_SymbolLambda) { + var def = node.thedef; + if (!redefine(node, node.scope.parent_scope.resolve())) { + def.defun = undefined; + } else if (typeof node.thedef.init !== "undefined") { + node.thedef.init = false; + } else if (def.init) { + node.thedef.init = def.init; + } + return true; + } + })); + + function is_arguments(sym) { + return sym.orig[0] instanceof AST_SymbolFunarg + && !(sym.orig[1] instanceof AST_SymbolFunarg || sym.orig[2] instanceof AST_SymbolFunarg) + && !is_arrow(sym.scope); + } + + function redefine(node, scope) { + var name = node.name; + var old_def = node.thedef; + if (!all(old_def.orig, function(sym) { + return !(sym instanceof AST_SymbolConst || sym instanceof AST_SymbolLet); + })) return false; + var new_def = scope.find_variable(name); + if (new_def) { + var redef = new_def.redefined(); + if (redef) new_def = redef; + } else { + new_def = self.globals.get(name); + } + if (new_def) { + new_def.orig.push(node); + } else { + new_def = scope.def_variable(node); + } + if (new_def.undeclared) self.variables.set(name, new_def); + if (name == "arguments" && is_arguments(old_def) && node instanceof AST_SymbolLambda) return true; + old_def.defun = new_def.scope; + old_def.forEach(function(node) { + node.redef = old_def; + node.thedef = new_def; + node.reference(options); + }); + return true; + } +}); + +AST_Toplevel.DEFMETHOD("def_global", function(node) { + var globals = this.globals, name = node.name; + if (globals.has(name)) { + return globals.get(name); + } else { + var g = this.make_def(node); + g.undeclared = true; + g.global = true; + globals.set(name, g); + return g; + } +}); + +function init_block_vars(scope, parent, orig) { + // variables from this or outer scope(s) that are referenced from this or inner scopes + scope.enclosed = orig ? orig.enclosed.slice() : []; + // map name to AST_SymbolDefun (functions defined in this scope) + scope.functions = orig ? orig.functions.clone() : new Dictionary(); + // map name to AST_SymbolVar (variables defined in this scope; includes functions) + scope.variables = orig ? orig.variables.clone() : new Dictionary(); + if (!parent) return; + // top-level tracking of SymbolDef instances + scope.make_def = parent.make_def; + // the parent scope (null if this is the top level) + scope.parent_scope = parent; +} + +function init_scope_vars(scope, parent, orig) { + init_block_vars(scope, parent, orig); + // will be set to true if this or nested scope uses the global `eval` + scope.uses_eval = false; + // will be set to true if this or some nested scope uses the `with` statement + scope.uses_with = false; +} + +AST_BlockScope.DEFMETHOD("init_vars", function(parent, orig) { + init_block_vars(this, parent, orig); +}); +AST_Scope.DEFMETHOD("init_vars", function(parent, orig) { + init_scope_vars(this, parent, orig); +}); +AST_Arrow.DEFMETHOD("init_vars", function(parent, orig) { + init_scope_vars(this, parent, orig); + return this; +}); +AST_AsyncArrow.DEFMETHOD("init_vars", function(parent, orig) { + init_scope_vars(this, parent, orig); +}); +AST_Lambda.DEFMETHOD("init_vars", function(parent, orig) { + init_scope_vars(this, parent, orig); + this.uses_arguments = false; + this.def_variable(new AST_SymbolFunarg({ + name: "arguments", + scope: this, + start: this.start, + end: this.end, + })); + return this; +}); + +AST_Symbol.DEFMETHOD("mark_enclosed", function(options) { + var def = this.definition(); + for (var s = this.scope; s; s = s.parent_scope) { + if (!push_uniq(s.enclosed, def)) break; + if (!options) { + s._var_names = undefined; + } else { + if (options.keep_fargs && s instanceof AST_Lambda) s.each_argname(function(arg) { + push_uniq(def.scope.enclosed, arg.definition()); + }); + if (options.keep_fnames) s.functions.each(function(d) { + push_uniq(def.scope.enclosed, d); + }); + } + if (s === def.scope) break; + } +}); + +AST_Symbol.DEFMETHOD("reference", function(options) { + this.definition().references.push(this); + this.mark_enclosed(options); +}); + +AST_BlockScope.DEFMETHOD("find_variable", function(name) { + return this.variables.get(name) + || this.parent_scope && this.parent_scope.find_variable(name); +}); + +AST_BlockScope.DEFMETHOD("def_function", function(symbol, init) { + var def = this.def_variable(symbol, init); + if (!def.init || def.init instanceof AST_LambdaDefinition) def.init = init; + this.functions.set(symbol.name, def); + return def; +}); + +AST_BlockScope.DEFMETHOD("def_variable", function(symbol, init) { + var def = this.variables.get(symbol.name); + if (def) { + def.orig.push(symbol); + if (def.init instanceof AST_LambdaExpression) def.init = init; + } else { + def = this.make_def(symbol, init); + this.variables.set(symbol.name, def); + def.global = !this.parent_scope; + } + return symbol.thedef = def; +}); + +function names_in_use(scope, options) { + var names = scope.names_in_use; + if (!names) { + scope.cname = -1; + scope.cname_holes = []; + scope.names_in_use = names = new Dictionary(); + var cache = options.cache && options.cache.props; + scope.enclosed.forEach(function(def) { + if (def.unmangleable(options)) names.set(def.name, true); + if (def.global && cache && cache.has(def.name)) { + names.set(cache.get(def.name), true); + } + }); + } + return names; +} + +function next_mangled_name(def, options) { + var scope = def.scope; + var in_use = names_in_use(scope, options); + var holes = scope.cname_holes; + var names = new Dictionary(); + var scopes = [ scope ]; + def.forEach(function(sym) { + var scope = sym.scope; + do { + if (member(scope, scopes)) break; + names_in_use(scope, options).each(function(marker, name) { + names.set(name, marker); + }); + scopes.push(scope); + } while (scope = scope.parent_scope); + }); + var name; + for (var i = 0; i < holes.length; i++) { + name = base54(holes[i]); + if (names.has(name)) continue; + holes.splice(i, 1); + in_use.set(name, true); + return name; + } + while (true) { + name = base54(++scope.cname); + if (in_use.has(name) || RESERVED_WORDS[name] || options.reserved.has[name]) continue; + if (!names.has(name)) break; + holes.push(scope.cname); + } + in_use.set(name, true); + return name; +} + +AST_Symbol.DEFMETHOD("unmangleable", function(options) { + var def = this.definition(); + return !def || def.unmangleable(options); +}); + +// labels are always mangleable +AST_Label.DEFMETHOD("unmangleable", return_false); + +AST_Symbol.DEFMETHOD("definition", function() { + return this.thedef; +}); + +function _default_mangler_options(options) { + options = defaults(options, { + eval : false, + ie : false, + keep_fargs : false, + keep_fnames : false, + reserved : [], + toplevel : false, + v8 : false, + webkit : false, + }); + if (!Array.isArray(options.reserved)) options.reserved = []; + // Never mangle `arguments` + push_uniq(options.reserved, "arguments"); + options.reserved.has = makePredicate(options.reserved); + return options; +} + +// We only need to mangle declaration nodes. Special logic wired into the code +// generator will display the mangled name if it is present (and for +// `AST_SymbolRef`s it will use the mangled name of the `AST_SymbolDeclaration` +// that it points to). +AST_Toplevel.DEFMETHOD("mangle_names", function(options) { + options = _default_mangler_options(options); + if (options.cache && options.cache.props) { + var mangled_names = names_in_use(this, options); + options.cache.props.each(function(mangled_name) { + mangled_names.set(mangled_name, true); + }); + } + var cutoff = 36; + var lname = -1; + var redefined = []; + var tw = new TreeWalker(function(node, descend) { + var save_nesting; + if (node instanceof AST_BlockScope) { + // `lname` is incremented when we get to the `AST_Label` + if (node instanceof AST_LabeledStatement) save_nesting = lname; + if (options.webkit && node instanceof AST_IterationStatement && node.init instanceof AST_Let) { + node.init.definitions.forEach(function(defn) { + defn.name.match_symbol(function(sym) { + if (!(sym instanceof AST_SymbolLet)) return; + var def = sym.definition(); + var scope = sym.scope.parent_scope; + var redef = scope.def_variable(sym); + sym.thedef = def; + scope.to_mangle.push(redef); + def.redefined = function() { + return redef; + }; + }); + }, true); + } + var to_mangle = node.to_mangle = []; + node.variables.each(function(def, name) { + if (def.unmangleable(options)) { + names_in_use(node, options).set(name, true); + } else if (!defer_redef(def)) { + to_mangle.push(def); + } + }); + descend(); + if (options.cache && node instanceof AST_Toplevel) { + node.globals.each(mangle); + } + if (node instanceof AST_Defun && tw.has_directive("use asm")) { + var sym = new AST_SymbolRef(node.name); + sym.scope = node; + sym.reference(options); + } + if (to_mangle.length > cutoff) { + var indices = to_mangle.map(function(def, index) { + return index; + }).sort(function(i, j) { + return to_mangle[j].references.length - to_mangle[i].references.length || i - j; + }); + to_mangle = indices.slice(0, cutoff).sort(function(i, j) { + return i - j; + }).map(function(index) { + return to_mangle[index]; + }).concat(indices.slice(cutoff).sort(function(i, j) { + return i - j; + }).map(function(index) { + return to_mangle[index]; + })); + } + to_mangle.forEach(mangle); + if (node instanceof AST_LabeledStatement && !(options.v8 && in_label(tw))) lname = save_nesting; + return true; + } + if (node instanceof AST_Label) { + var name; + do { + name = base54(++lname); + } while (RESERVED_WORDS[name]); + node.mangled_name = name; + return true; + } + }); + this.walk(tw); + redefined.forEach(mangle); + + function mangle(def) { + if (options.reserved.has[def.name]) return; + def.mangle(options); + } + + function defer_redef(def) { + var sym = def.orig[0]; + var redef = def.redefined(); + if (!redef) { + if (!(sym instanceof AST_SymbolConst)) return false; + var scope = def.scope.resolve(); + if (def.scope === scope) return false; + if (def.scope.parent_scope.find_variable(sym.name)) return false; + redef = scope.def_variable(sym); + scope.to_mangle.push(redef); + } + redefined.push(def); + def.references.forEach(reference); + if (sym instanceof AST_SymbolCatch || sym instanceof AST_SymbolConst) { + reference(sym); + def.redefined = function() { + return redef; + }; + } + return true; + + function reference(sym) { + sym.thedef = redef; + sym.reference(options); + sym.thedef = def; + } + } + + function in_label(tw) { + var level = 0, parent; + while (parent = tw.parent(level++)) { + if (parent instanceof AST_Block) return parent instanceof AST_Toplevel && !options.toplevel; + if (parent instanceof AST_LabeledStatement) return true; + } + } +}); + +AST_Toplevel.DEFMETHOD("find_colliding_names", function(options) { + var cache = options.cache && options.cache.props; + var avoid = Object.create(RESERVED_WORDS); + options.reserved.forEach(to_avoid); + this.globals.each(add_def); + this.walk(new TreeWalker(function(node) { + if (node instanceof AST_BlockScope) node.variables.each(add_def); + })); + return avoid; + + function to_avoid(name) { + avoid[name] = true; + } + + function add_def(def) { + var name = def.name; + if (def.global && cache && cache.has(name)) name = cache.get(name); + else if (!def.unmangleable(options)) return; + to_avoid(name); + } +}); + +AST_Toplevel.DEFMETHOD("expand_names", function(options) { + base54.reset(); + base54.sort(); + options = _default_mangler_options(options); + var avoid = this.find_colliding_names(options); + var cname = 0; + this.globals.each(rename); + this.walk(new TreeWalker(function(node) { + if (node instanceof AST_BlockScope) node.variables.each(rename); + })); + + function next_name() { + var name; + do { + name = base54(cname++); + } while (avoid[name]); + return name; + } + + function rename(def) { + if (def.global && options.cache) return; + if (def.unmangleable(options)) return; + if (options.reserved.has[def.name]) return; + var redef = def.redefined(); + var name = redef ? redef.rename || redef.name : next_name(); + def.rename = name; + def.forEach(function(sym) { + if (sym.definition() === def) sym.name = name; + }); + } +}); + +AST_Node.DEFMETHOD("tail_node", return_this); +AST_Sequence.DEFMETHOD("tail_node", function() { + return this.expressions[this.expressions.length - 1]; +}); + +AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options) { + options = _default_mangler_options(options); + base54.reset(); + var fn = AST_Symbol.prototype.add_source_map; + try { + AST_Symbol.prototype.add_source_map = function() { + if (!this.unmangleable(options)) base54.consider(this.name, -1); + }; + if (options.properties) { + AST_Dot.prototype.add_source_map = function() { + base54.consider(this.property, -1); + }; + AST_Sub.prototype.add_source_map = function() { + skip_string(this.property); + }; + } + base54.consider(this.print_to_string(), 1); + } finally { + AST_Symbol.prototype.add_source_map = fn; + delete AST_Dot.prototype.add_source_map; + delete AST_Sub.prototype.add_source_map; + } + base54.sort(); + + function skip_string(node) { + if (node instanceof AST_String) { + base54.consider(node.value, -1); + } else if (node instanceof AST_Conditional) { + skip_string(node.consequent); + skip_string(node.alternative); + } else if (node instanceof AST_Sequence) { + skip_string(node.tail_node()); + } + } +}); + +var base54 = (function() { + var freq = Object.create(null); + function init(chars) { + var array = []; + for (var i = 0; i < chars.length; i++) { + var ch = chars[i]; + array.push(ch); + freq[ch] = -1e-2 * i; + } + return array; + } + var digits = init("0123456789"); + var leading = init("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_"); + var chars, frequency; + function reset() { + chars = null; + frequency = Object.create(freq); + } + base54.consider = function(str, delta) { + for (var i = str.length; --i >= 0;) { + frequency[str[i]] += delta; + } + }; + function compare(a, b) { + return frequency[b] - frequency[a]; + } + base54.sort = function() { + chars = leading.sort(compare).concat(digits).sort(compare); + }; + base54.reset = reset; + reset(); + function base54(num) { + var ret = leading[num % 54]; + for (num = Math.floor(num / 54); --num >= 0; num >>= 6) { + ret += chars[num & 0x3F]; + } + return ret; + } + return base54; +})(); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/sourcemap.js b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/sourcemap.js new file mode 100644 index 0000000000000000000000000000000000000000..a230a44ced25b57105236bc3cff736eaffb4ad86 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/sourcemap.js @@ -0,0 +1,195 @@ +/*********************************************************************** + + A JavaScript tokenizer / parser / beautifier / compressor. + https://github.com/mishoo/UglifyJS + + -------------------------------- (C) --------------------------------- + + Author: Mihai Bazon + + http://mihai.bazon.net/blog + + Distributed under the BSD license: + + Copyright 2012 (c) Mihai Bazon + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + * Redistributions of source code must retain the above + copyright notice, this list of conditions and the following + disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials + provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY + EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, + OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF + THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + SUCH DAMAGE. + + ***********************************************************************/ + +"use strict"; + +var vlq_char = characters("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"); +var vlq_bits = vlq_char.reduce(function(map, ch, bits) { + map[ch] = bits; + return map; +}, Object.create(null)); + +function vlq_decode(indices, str) { + var value = 0; + var shift = 0; + for (var i = 0, j = 0; i < str.length; i++) { + var bits = vlq_bits[str[i]]; + value += (bits & 31) << shift; + if (bits & 32) { + shift += 5; + } else { + indices[j++] += value & 1 ? 0x80000000 | -(value >> 1) : value >> 1; + value = shift = 0; + } + } + return j; +} + +function vlq_encode(num) { + var result = ""; + num = Math.abs(num) << 1 | num >>> 31; + do { + var bits = num & 31; + if (num >>>= 5) bits |= 32; + result += vlq_char[bits]; + } while (num); + return result; +} + +function create_array_map() { + var map = new Dictionary(); + var array = []; + array.index = function(name) { + var index = map.get(name); + if (!(index >= 0)) { + index = array.length; + array.push(name); + map.set(name, index); + } + return index; + }; + return array; +} + +function SourceMap(options) { + var sources = create_array_map(); + var sources_content = options.includeSources && new Dictionary(); + var names = create_array_map(); + var mappings = ""; + if (options.orig) Object.keys(options.orig).forEach(function(name) { + var map = options.orig[name]; + var indices = [ 0, 0, 1, 0, 0 ]; + options.orig[name] = { + names: map.names, + mappings: map.mappings.split(/;/).map(function(line) { + indices[0] = 0; + return line.split(/,/).map(function(segment) { + return indices.slice(0, vlq_decode(indices, segment)); + }); + }), + sources: map.sources, + }; + if (!sources_content || !map.sourcesContent) return; + for (var i = 0; i < map.sources.length; i++) { + var content = map.sourcesContent[i]; + if (content) sources_content.set(map.sources[i], content); + } + }); + var prev_source; + var generated_line = 1; + var generated_column = 0; + var source_index = 0; + var original_line = 1; + var original_column = 0; + var name_index = 0; + return { + add: options.orig ? function(source, gen_line, gen_col, orig_line, orig_col, name) { + var map = options.orig[source]; + if (map) { + var segments = map.mappings[orig_line - 1]; + if (!segments) return; + var indices; + for (var i = 0; i < segments.length; i++) { + var col = segments[i][0]; + if (orig_col >= col) indices = segments[i]; + if (orig_col <= col) break; + } + if (!indices || indices.length < 4) { + source = null; + } else { + source = map.sources[indices[1]]; + orig_line = indices[2]; + orig_col = indices[3]; + if (indices.length > 4) name = map.names[indices[4]]; + } + } + add(source, gen_line, gen_col, orig_line, orig_col, name); + } : add, + setSourceContent: sources_content ? function(source, content) { + if (!sources_content.has(source)) { + sources_content.set(source, content); + } + } : noop, + toString: function() { + return JSON.stringify({ + version: 3, + file: options.filename || undefined, + sourceRoot: options.root || undefined, + sources: sources, + sourcesContent: sources_content ? sources.map(function(source) { + return sources_content.get(source) || null; + }) : undefined, + names: names, + mappings: mappings, + }); + } + }; + + function add(source, gen_line, gen_col, orig_line, orig_col, name) { + if (prev_source == null && source == null) return; + prev_source = source; + if (generated_line < gen_line) { + generated_column = 0; + do { + mappings += ";"; + } while (++generated_line < gen_line); + } else if (mappings) { + mappings += ","; + } + mappings += vlq_encode(gen_col - generated_column); + generated_column = gen_col; + if (source == null) return; + var src_idx = sources.index(source); + mappings += vlq_encode(src_idx - source_index); + source_index = src_idx; + mappings += vlq_encode(orig_line - original_line); + original_line = orig_line; + mappings += vlq_encode(orig_col - original_column); + original_column = orig_col; + if (options.names && name != null) { + var name_idx = names.index(name); + mappings += vlq_encode(name_idx - name_index); + name_index = name_idx; + } + } +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/transform.js b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/transform.js new file mode 100644 index 0000000000000000000000000000000000000000..dcf90dfad586748c391108f1f4732347f132b1c1 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/transform.js @@ -0,0 +1,250 @@ +/*********************************************************************** + + A JavaScript tokenizer / parser / beautifier / compressor. + https://github.com/mishoo/UglifyJS + + -------------------------------- (C) --------------------------------- + + Author: Mihai Bazon + + http://mihai.bazon.net/blog + + Distributed under the BSD license: + + Copyright 2012 (c) Mihai Bazon + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + * Redistributions of source code must retain the above + copyright notice, this list of conditions and the following + disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials + provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY + EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, + OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF + THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + SUCH DAMAGE. + + ***********************************************************************/ + +"use strict"; + +function TreeTransformer(before, after) { + TreeWalker.call(this); + this.before = before; + this.after = after; +} +TreeTransformer.prototype = new TreeWalker; + +(function(DEF) { + function do_list(list, tw) { + return List(list, function(node) { + return node.transform(tw, true); + }); + } + + DEF(AST_Node, noop); + DEF(AST_LabeledStatement, function(self, tw) { + self.label = self.label.transform(tw); + self.body = self.body.transform(tw); + }); + DEF(AST_SimpleStatement, function(self, tw) { + self.body = self.body.transform(tw); + }); + DEF(AST_Block, function(self, tw) { + self.body = do_list(self.body, tw); + }); + DEF(AST_Do, function(self, tw) { + self.body = self.body.transform(tw); + self.condition = self.condition.transform(tw); + }); + DEF(AST_While, function(self, tw) { + self.condition = self.condition.transform(tw); + self.body = self.body.transform(tw); + }); + DEF(AST_For, function(self, tw) { + if (self.init) self.init = self.init.transform(tw); + if (self.condition) self.condition = self.condition.transform(tw); + if (self.step) self.step = self.step.transform(tw); + self.body = self.body.transform(tw); + }); + DEF(AST_ForEnumeration, function(self, tw) { + self.init = self.init.transform(tw); + self.object = self.object.transform(tw); + self.body = self.body.transform(tw); + }); + DEF(AST_With, function(self, tw) { + self.expression = self.expression.transform(tw); + self.body = self.body.transform(tw); + }); + DEF(AST_Exit, function(self, tw) { + if (self.value) self.value = self.value.transform(tw); + }); + DEF(AST_LoopControl, function(self, tw) { + if (self.label) self.label = self.label.transform(tw); + }); + DEF(AST_If, function(self, tw) { + self.condition = self.condition.transform(tw); + self.body = self.body.transform(tw); + if (self.alternative) self.alternative = self.alternative.transform(tw); + }); + DEF(AST_Switch, function(self, tw) { + self.expression = self.expression.transform(tw); + self.body = do_list(self.body, tw); + }); + DEF(AST_Case, function(self, tw) { + self.expression = self.expression.transform(tw); + self.body = do_list(self.body, tw); + }); + DEF(AST_Try, function(self, tw) { + self.body = do_list(self.body, tw); + if (self.bcatch) self.bcatch = self.bcatch.transform(tw); + if (self.bfinally) self.bfinally = self.bfinally.transform(tw); + }); + DEF(AST_Catch, function(self, tw) { + if (self.argname) self.argname = self.argname.transform(tw); + self.body = do_list(self.body, tw); + }); + DEF(AST_Definitions, function(self, tw) { + self.definitions = do_list(self.definitions, tw); + }); + DEF(AST_VarDef, function(self, tw) { + self.name = self.name.transform(tw); + if (self.value) self.value = self.value.transform(tw); + }); + DEF(AST_DefaultValue, function(self, tw) { + self.name = self.name.transform(tw); + self.value = self.value.transform(tw); + }); + DEF(AST_Lambda, function(self, tw) { + if (self.name) self.name = self.name.transform(tw); + self.argnames = do_list(self.argnames, tw); + if (self.rest) self.rest = self.rest.transform(tw); + self.body = do_list(self.body, tw); + }); + function transform_arrow(self, tw) { + self.argnames = do_list(self.argnames, tw); + if (self.rest) self.rest = self.rest.transform(tw); + if (self.value) { + self.value = self.value.transform(tw); + } else { + self.body = do_list(self.body, tw); + } + } + DEF(AST_Arrow, transform_arrow); + DEF(AST_AsyncArrow, transform_arrow); + DEF(AST_Class, function(self, tw) { + if (self.name) self.name = self.name.transform(tw); + if (self.extends) self.extends = self.extends.transform(tw); + self.properties = do_list(self.properties, tw); + }); + DEF(AST_ClassProperty, function(self, tw) { + if (self.key instanceof AST_Node) self.key = self.key.transform(tw); + if (self.value) self.value = self.value.transform(tw); + }); + DEF(AST_Call, function(self, tw) { + self.expression = self.expression.transform(tw); + self.args = do_list(self.args, tw); + }); + DEF(AST_Sequence, function(self, tw) { + self.expressions = do_list(self.expressions, tw); + }); + DEF(AST_Await, function(self, tw) { + self.expression = self.expression.transform(tw); + }); + DEF(AST_Yield, function(self, tw) { + if (self.expression) self.expression = self.expression.transform(tw); + }); + DEF(AST_Dot, function(self, tw) { + self.expression = self.expression.transform(tw); + }); + DEF(AST_Sub, function(self, tw) { + self.expression = self.expression.transform(tw); + self.property = self.property.transform(tw); + }); + DEF(AST_Spread, function(self, tw) { + self.expression = self.expression.transform(tw); + }); + DEF(AST_Unary, function(self, tw) { + self.expression = self.expression.transform(tw); + }); + DEF(AST_Binary, function(self, tw) { + self.left = self.left.transform(tw); + self.right = self.right.transform(tw); + }); + DEF(AST_Conditional, function(self, tw) { + self.condition = self.condition.transform(tw); + self.consequent = self.consequent.transform(tw); + self.alternative = self.alternative.transform(tw); + }); + DEF(AST_Array, function(self, tw) { + self.elements = do_list(self.elements, tw); + }); + DEF(AST_DestructuredArray, function(self, tw) { + self.elements = do_list(self.elements, tw); + if (self.rest) self.rest = self.rest.transform(tw); + }); + DEF(AST_DestructuredKeyVal, function(self, tw) { + if (self.key instanceof AST_Node) self.key = self.key.transform(tw); + self.value = self.value.transform(tw); + }); + DEF(AST_DestructuredObject, function(self, tw) { + self.properties = do_list(self.properties, tw); + if (self.rest) self.rest = self.rest.transform(tw); + }); + DEF(AST_Object, function(self, tw) { + self.properties = do_list(self.properties, tw); + }); + DEF(AST_ObjectProperty, function(self, tw) { + if (self.key instanceof AST_Node) self.key = self.key.transform(tw); + self.value = self.value.transform(tw); + }); + DEF(AST_ExportDeclaration, function(self, tw) { + self.body = self.body.transform(tw); + }); + DEF(AST_ExportDefault, function(self, tw) { + self.body = self.body.transform(tw); + }); + DEF(AST_ExportReferences, function(self, tw) { + self.properties = do_list(self.properties, tw); + }); + DEF(AST_Import, function(self, tw) { + if (self.all) self.all = self.all.transform(tw); + if (self.default) self.default = self.default.transform(tw); + if (self.properties) self.properties = do_list(self.properties, tw); + }); + DEF(AST_Template, function(self, tw) { + if (self.tag) self.tag = self.tag.transform(tw); + self.expressions = do_list(self.expressions, tw); + }); +})(function(node, descend) { + node.DEFMETHOD("transform", function(tw, in_list) { + var x, y; + tw.push(this); + if (tw.before) x = tw.before(this, descend, in_list); + if (typeof x === "undefined") { + x = this; + descend(x, tw); + if (tw.after) { + y = tw.after(x, in_list); + if (typeof y !== "undefined") x = y; + } + } + tw.pop(); + return x; + }); +}); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/utils.js b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/utils.js new file mode 100644 index 0000000000000000000000000000000000000000..779be75ee12bff2aa5f77f970d9e5709bb46f8eb --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/lib/utils.js @@ -0,0 +1,300 @@ +/*********************************************************************** + + A JavaScript tokenizer / parser / beautifier / compressor. + https://github.com/mishoo/UglifyJS + + -------------------------------- (C) --------------------------------- + + Author: Mihai Bazon + + http://mihai.bazon.net/blog + + Distributed under the BSD license: + + Copyright 2012 (c) Mihai Bazon + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + * Redistributions of source code must retain the above + copyright notice, this list of conditions and the following + disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials + provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY + EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, + OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF + THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + SUCH DAMAGE. + + ***********************************************************************/ + +"use strict"; + +function characters(str) { + return str.split(""); +} + +function member(name, array) { + return array.indexOf(name) >= 0; +} + +function find_if(func, array) { + for (var i = array.length; --i >= 0;) if (func(array[i])) return array[i]; +} + +function configure_error_stack(ex, cause) { + var stack = ex.name + ": " + ex.message; + Object.defineProperty(ex, "stack", { + get: function() { + if (cause) { + cause.name = "" + ex.name; + stack = "" + cause.stack; + var msg = "" + cause.message; + cause = null; + var index = stack.indexOf(msg); + if (index < 0) { + index = 0; + } else { + index += msg.length; + index = stack.indexOf("\n", index) + 1; + } + stack = stack.slice(0, index) + stack.slice(stack.indexOf("\n", index) + 1); + } + return stack; + }, + }); +} + +function DefaultsError(msg, defs) { + this.message = msg; + this.defs = defs; + try { + throw new Error(msg); + } catch (cause) { + configure_error_stack(this, cause); + } +} +DefaultsError.prototype = Object.create(Error.prototype); +DefaultsError.prototype.constructor = DefaultsError; +DefaultsError.prototype.name = "DefaultsError"; + +function defaults(args, defs, croak) { + if (croak) for (var i in args) { + if (HOP(args, i) && !HOP(defs, i)) throw new DefaultsError("`" + i + "` is not a supported option", defs); + } + for (var i in args) { + if (HOP(args, i)) defs[i] = args[i]; + } + return defs; +} + +function noop() {} +function return_false() { return false; } +function return_true() { return true; } +function return_this() { return this; } +function return_null() { return null; } + +var List = (function() { + function List(a, f) { + var ret = []; + for (var i = 0; i < a.length; i++) { + var val = f(a[i], i); + if (val === skip) continue; + if (val instanceof Splice) { + ret.push.apply(ret, val.v); + } else { + ret.push(val); + } + } + return ret; + } + List.is_op = function(val) { + return val === skip || val instanceof Splice; + }; + List.splice = function(val) { + return new Splice(val); + }; + var skip = List.skip = {}; + function Splice(val) { + this.v = val; + } + return List; +})(); + +function push_uniq(array, el) { + if (array.indexOf(el) < 0) return array.push(el); +} + +function string_template(text, props) { + return text.replace(/\{([^{}]+)\}/g, function(str, p) { + var value = p == "this" ? props : props[p]; + if (value instanceof AST_Node) return value.print_to_string(); + if (value instanceof AST_Token) return value.file + ":" + value.line + "," + value.col; + return value; + }); +} + +function remove(array, el) { + var index = array.indexOf(el); + if (index >= 0) array.splice(index, 1); +} + +function makePredicate(words) { + if (!Array.isArray(words)) words = words.split(" "); + var map = Object.create(null); + words.forEach(function(word) { + map[word] = true; + }); + return map; +} + +function all(array, predicate) { + for (var i = array.length; --i >= 0;) + if (!predicate(array[i], i)) + return false; + return true; +} + +function Dictionary() { + this.values = Object.create(null); +} +Dictionary.prototype = { + set: function(key, val) { + if (key == "__proto__") { + this.proto_value = val; + } else { + this.values[key] = val; + } + return this; + }, + add: function(key, val) { + var list = this.get(key); + if (list) { + list.push(val); + } else { + this.set(key, [ val ]); + } + return this; + }, + get: function(key) { + return key == "__proto__" ? this.proto_value : this.values[key]; + }, + del: function(key) { + if (key == "__proto__") { + delete this.proto_value; + } else { + delete this.values[key]; + } + return this; + }, + has: function(key) { + return key == "__proto__" ? "proto_value" in this : key in this.values; + }, + all: function(predicate) { + for (var i in this.values) + if (!predicate(this.values[i], i)) return false; + if ("proto_value" in this && !predicate(this.proto_value, "__proto__")) return false; + return true; + }, + each: function(f) { + for (var i in this.values) + f(this.values[i], i); + if ("proto_value" in this) f(this.proto_value, "__proto__"); + }, + size: function() { + return Object.keys(this.values).length + ("proto_value" in this); + }, + map: function(f) { + var ret = []; + for (var i in this.values) + ret.push(f(this.values[i], i)); + if ("proto_value" in this) ret.push(f(this.proto_value, "__proto__")); + return ret; + }, + clone: function() { + var ret = new Dictionary(); + this.each(function(value, i) { + ret.set(i, value); + }); + return ret; + }, + toObject: function() { + var obj = {}; + this.each(function(value, i) { + obj["$" + i] = value; + }); + return obj; + }, +}; +Dictionary.fromObject = function(obj) { + var dict = new Dictionary(); + for (var i in obj) + if (HOP(obj, i)) dict.set(i.slice(1), obj[i]); + return dict; +}; + +function HOP(obj, prop) { + return Object.prototype.hasOwnProperty.call(obj, prop); +} + +// return true if the node at the top of the stack (that means the +// innermost node in the current output) is lexically the first in +// a statement. +function first_in_statement(stack, arrow, export_default) { + var node = stack.parent(-1); + for (var i = 0, p; p = stack.parent(i++); node = p) { + if (is_arrow(p)) { + return arrow && p.value === node; + } else if (p instanceof AST_Binary) { + if (p.left === node) continue; + } else if (p.TYPE == "Call") { + if (p.expression === node) continue; + } else if (p instanceof AST_Conditional) { + if (p.condition === node) continue; + } else if (p instanceof AST_ExportDefault) { + return export_default; + } else if (p instanceof AST_PropAccess) { + if (p.expression === node) continue; + } else if (p instanceof AST_Sequence) { + if (p.expressions[0] === node) continue; + } else if (p instanceof AST_SimpleStatement) { + return true; + } else if (p instanceof AST_Template) { + if (p.tag === node) continue; + } else if (p instanceof AST_UnaryPostfix) { + if (p.expression === node) continue; + } + return false; + } +} + +function DEF_BITPROPS(ctor, props) { + if (props.length > 31) throw new Error("Too many properties: " + props.length + "\n" + props.join(", ")); + props.forEach(function(name, pos) { + var mask = 1 << pos; + Object.defineProperty(ctor.prototype, name, { + get: function() { + return !!(this._bits & mask); + }, + set: function(val) { + if (val) + this._bits |= mask; + else + this._bits &= ~mask; + }, + }); + }); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/tools/domprops.html b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/tools/domprops.html new file mode 100644 index 0000000000000000000000000000000000000000..e217b1731edc9f7719397ae577751fc991f49ec8 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/tools/domprops.html @@ -0,0 +1,456 @@ + + + + + + diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/tools/domprops.json b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/tools/domprops.json new file mode 100644 index 0000000000000000000000000000000000000000..7402010231bd19b2b888871588e61d2798dc8ae2 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/tools/domprops.json @@ -0,0 +1,8327 @@ +[ + "$&", + "$'", + "$*", + "$+", + "$1", + "$2", + "$3", + "$4", + "$5", + "$6", + "$7", + "$8", + "$9", + "$_", + "$`", + "$input", + "-moz-animation", + "-moz-animation-delay", + "-moz-animation-direction", + "-moz-animation-duration", + "-moz-animation-fill-mode", + "-moz-animation-iteration-count", + "-moz-animation-name", + "-moz-animation-play-state", + "-moz-animation-timing-function", + "-moz-appearance", + "-moz-backface-visibility", + "-moz-binding", + "-moz-border-end", + "-moz-border-end-color", + "-moz-border-end-style", + "-moz-border-end-width", + "-moz-border-image", + "-moz-border-start", + "-moz-border-start-color", + "-moz-border-start-style", + "-moz-border-start-width", + "-moz-box-align", + "-moz-box-direction", + "-moz-box-flex", + "-moz-box-ordinal-group", + "-moz-box-orient", + "-moz-box-pack", + "-moz-box-sizing", + "-moz-column-count", + "-moz-column-fill", + "-moz-column-gap", + "-moz-column-rule", + "-moz-column-rule-color", + "-moz-column-rule-style", + "-moz-column-rule-width", + "-moz-column-width", + "-moz-columns", + "-moz-float-edge", + "-moz-font-feature-settings", + "-moz-font-language-override", + "-moz-force-broken-image-icon", + "-moz-hyphens", + "-moz-image-region", + "-moz-margin-end", + "-moz-margin-start", + "-moz-orient", + "-moz-outline-radius", + "-moz-outline-radius-bottomleft", + "-moz-outline-radius-bottomright", + "-moz-outline-radius-topleft", + "-moz-outline-radius-topright", + "-moz-padding-end", + "-moz-padding-start", + "-moz-perspective", + "-moz-perspective-origin", + "-moz-stack-sizing", + "-moz-tab-size", + "-moz-text-size-adjust", + "-moz-transform", + "-moz-transform-origin", + "-moz-transform-style", + "-moz-transition", + "-moz-transition-delay", + "-moz-transition-duration", + "-moz-transition-property", + "-moz-transition-timing-function", + "-moz-user-focus", + "-moz-user-input", + "-moz-user-modify", + "-moz-user-select", + "-moz-window-dragging", + "-webkit-align-content", + "-webkit-align-items", + "-webkit-align-self", + "-webkit-animation", + "-webkit-animation-delay", + "-webkit-animation-direction", + "-webkit-animation-duration", + "-webkit-animation-fill-mode", + "-webkit-animation-iteration-count", + "-webkit-animation-name", + "-webkit-animation-play-state", + "-webkit-animation-timing-function", + "-webkit-appearance", + "-webkit-backface-visibility", + "-webkit-background-clip", + "-webkit-background-origin", + "-webkit-background-size", + "-webkit-border-bottom-left-radius", + "-webkit-border-bottom-right-radius", + "-webkit-border-image", + "-webkit-border-radius", + "-webkit-border-top-left-radius", + "-webkit-border-top-right-radius", + "-webkit-box-align", + "-webkit-box-direction", + "-webkit-box-flex", + "-webkit-box-ordinal-group", + "-webkit-box-orient", + "-webkit-box-pack", + "-webkit-box-shadow", + "-webkit-box-sizing", + "-webkit-filter", + "-webkit-flex", + "-webkit-flex-basis", + "-webkit-flex-direction", + "-webkit-flex-flow", + "-webkit-flex-grow", + "-webkit-flex-shrink", + "-webkit-flex-wrap", + "-webkit-justify-content", + "-webkit-line-clamp", + "-webkit-mask", + "-webkit-mask-clip", + "-webkit-mask-composite", + "-webkit-mask-image", + "-webkit-mask-origin", + "-webkit-mask-position", + "-webkit-mask-position-x", + "-webkit-mask-position-y", + "-webkit-mask-repeat", + "-webkit-mask-size", + "-webkit-order", + "-webkit-perspective", + "-webkit-perspective-origin", + "-webkit-text-fill-color", + "-webkit-text-size-adjust", + "-webkit-text-stroke", + "-webkit-text-stroke-color", + "-webkit-text-stroke-width", + "-webkit-transform", + "-webkit-transform-origin", + "-webkit-transform-style", + "-webkit-transition", + "-webkit-transition-delay", + "-webkit-transition-duration", + "-webkit-transition-property", + "-webkit-transition-timing-function", + "-webkit-user-select", + "0", + "1", + "10", + "11", + "12", + "13", + "14", + "15", + "16", + "17", + "18", + "19", + "2", + "20", + "21", + "22", + "23", + "24", + "25", + "26", + "27", + "28", + "29", + "3", + "30", + "31", + "32", + "33", + "34", + "35", + "36", + "37", + "38", + "39", + "4", + "40", + "41", + "42", + "43", + "44", + "45", + "46", + "47", + "48", + "49", + "5", + "50", + "51", + "6", + "7", + "8", + "9", + "@@iterator", + "ABORT_ERR", + "ACTIVE", + "ACTIVE_ATTRIBUTES", + "ACTIVE_TEXTURE", + "ACTIVE_UNIFORMS", + "ACTIVE_UNIFORM_BLOCKS", + "ADDITION", + "ALIASED_LINE_WIDTH_RANGE", + "ALIASED_POINT_SIZE_RANGE", + "ALLOW_KEYBOARD_INPUT", + "ALLPASS", + "ALPHA", + "ALPHA_BITS", + "ALREADY_SIGNALED", + "ALT_MASK", + "ALWAYS", + "ANDROID", + "ANGLE_instanced_arrays", + "ANY_SAMPLES_PASSED", + "ANY_SAMPLES_PASSED_CONSERVATIVE", + "ANY_TYPE", + "ANY_UNORDERED_NODE_TYPE", + "APP_UPDATE", + "ARM", + "ARRAY_BUFFER", + "ARRAY_BUFFER_BINDING", + "ATTACHED_SHADERS", + "ATTRIBUTE_NODE", + "AT_TARGET", + "AbortController", + "AbortSignal", + "AbsoluteOrientationSensor", + "AbstractRange", + "Accelerometer", + "ActiveXObject", + "AddSearchProvider", + "AesGcmEncryptResult", + "AggregateError", + "AnalyserNode", + "Animation", + "AnimationEffect", + "AnimationEvent", + "AnimationPlaybackEvent", + "AnimationTimeline", + "AnonXMLHttpRequest", + "AppBannerPromptResult", + "ApplicationCache", + "ApplicationCacheErrorEvent", + "Array", + "ArrayBuffer", + "Atomics", + "Attr", + "Audio", + "AudioBuffer", + "AudioBufferSourceNode", + "AudioContext", + "AudioDestinationNode", + "AudioListener", + "AudioNode", + "AudioParam", + "AudioParamMap", + "AudioProcessingEvent", + "AudioScheduledSourceNode", + "AudioStreamTrack", + "AudioTrack", + "AudioTrackList", + "AudioWorklet", + "AudioWorkletNode", + "AuthenticatorAssertionResponse", + "AuthenticatorAttestationResponse", + "AuthenticatorResponse", + "AutocompleteErrorEvent", + "BACK", + "BAD_BOUNDARYPOINTS_ERR", + "BAD_REQUEST", + "BANDPASS", + "BLEND", + "BLEND_COLOR", + "BLEND_DST_ALPHA", + "BLEND_DST_RGB", + "BLEND_EQUATION", + "BLEND_EQUATION_ALPHA", + "BLEND_EQUATION_RGB", + "BLEND_SRC_ALPHA", + "BLEND_SRC_RGB", + "BLUE_BITS", + "BLUR", + "BOOL", + "BOOLEAN_TYPE", + "BOOL_VEC2", + "BOOL_VEC3", + "BOOL_VEC4", + "BOTH", + "BROWSER_DEFAULT_WEBGL", + "BUBBLING_PHASE", + "BUFFER_SIZE", + "BUFFER_USAGE", + "BYTE", + "BYTES_PER_ELEMENT", + "BackgroundFetchManager", + "BackgroundFetchRecord", + "BackgroundFetchRegistration", + "BarProp", + "BarcodeDetector", + "BaseAudioContext", + "BaseHref", + "BatteryManager", + "BeforeInstallPromptEvent", + "BeforeLoadEvent", + "BeforeUnloadEvent", + "BigInt", + "BigInt64Array", + "BigUint64Array", + "BiquadFilterNode", + "Blob", + "BlobEvent", + "Bluetooth", + "BluetoothCharacteristicProperties", + "BluetoothDevice", + "BluetoothRemoteGATTCharacteristic", + "BluetoothRemoteGATTDescriptor", + "BluetoothRemoteGATTServer", + "BluetoothRemoteGATTService", + "BluetoothUUID", + "BookmarkCollection", + "Boolean", + "BroadcastChannel", + "ByteLengthQueuingStrategy", + "CANNOT_RUN", + "CAPTURING_PHASE", + "CCW", + "CDATASection", + "CDATA_SECTION_NODE", + "CHANGE", + "CHARSET_RULE", + "CHECKING", + "CHROME_UPDATE", + "CLAMP_TO_EDGE", + "CLICK", + "CLOSED", + "CLOSING", + "COLOR", + "COLOR_ATTACHMENT0", + "COLOR_ATTACHMENT1", + "COLOR_ATTACHMENT10", + "COLOR_ATTACHMENT11", + "COLOR_ATTACHMENT12", + "COLOR_ATTACHMENT13", + "COLOR_ATTACHMENT14", + "COLOR_ATTACHMENT15", + "COLOR_ATTACHMENT2", + "COLOR_ATTACHMENT3", + "COLOR_ATTACHMENT4", + "COLOR_ATTACHMENT5", + "COLOR_ATTACHMENT6", + "COLOR_ATTACHMENT7", + "COLOR_ATTACHMENT8", + "COLOR_ATTACHMENT9", + "COLOR_BUFFER_BIT", + "COLOR_CLEAR_VALUE", + "COLOR_WRITEMASK", + "COMMENT_NODE", + "COMPARE_REF_TO_TEXTURE", + "COMPILE_STATUS", + "COMPRESSED_RGBA_S3TC_DXT1_EXT", + "COMPRESSED_RGBA_S3TC_DXT3_EXT", + "COMPRESSED_RGBA_S3TC_DXT5_EXT", + "COMPRESSED_RGB_S3TC_DXT1_EXT", + "COMPRESSED_TEXTURE_FORMATS", + "CONDITION_SATISFIED", + "CONFIGURATION_UNSUPPORTED", + "CONNECTING", + "CONSTANT_ALPHA", + "CONSTANT_COLOR", + "CONSTRAINT_ERR", + "CONTENT", + "CONTEXT_LOST_WEBGL", + "CONTROL_MASK", + "COPY_READ_BUFFER", + "COPY_READ_BUFFER_BINDING", + "COPY_WRITE_BUFFER", + "COPY_WRITE_BUFFER_BINDING", + "COUNTER_STYLE_RULE", + "CROS", + "CSS", + "CSS2Properties", + "CSSAnimation", + "CSSCharsetRule", + "CSSConditionRule", + "CSSCounterStyleRule", + "CSSFontFaceRule", + "CSSFontFeatureValuesRule", + "CSSGroupingRule", + "CSSImageValue", + "CSSImportRule", + "CSSKeyframeRule", + "CSSKeyframesRule", + "CSSKeywordValue", + "CSSMathInvert", + "CSSMathMax", + "CSSMathMin", + "CSSMathNegate", + "CSSMathProduct", + "CSSMathSum", + "CSSMathValue", + "CSSMatrixComponent", + "CSSMediaRule", + "CSSMozDocumentRule", + "CSSNameSpaceRule", + "CSSNamespaceRule", + "CSSNumericArray", + "CSSNumericValue", + "CSSPageRule", + "CSSPerspective", + "CSSPositionValue", + "CSSPrimitiveValue", + "CSSRotate", + "CSSRule", + "CSSRuleList", + "CSSScale", + "CSSSkew", + "CSSSkewX", + "CSSSkewY", + "CSSStyleDeclaration", + "CSSStyleRule", + "CSSStyleSheet", + "CSSStyleValue", + "CSSSupportsRule", + "CSSTransformComponent", + "CSSTransformValue", + "CSSTransition", + "CSSTranslate", + "CSSUnitValue", + "CSSUnknownRule", + "CSSUnparsedValue", + "CSSValue", + "CSSValueList", + "CSSVariableReferenceValue", + "CSSVariablesDeclaration", + "CSSVariablesRule", + "CSSViewportRule", + "CSS_ATTR", + "CSS_CM", + "CSS_COUNTER", + "CSS_CUSTOM", + "CSS_DEG", + "CSS_DIMENSION", + "CSS_EMS", + "CSS_EXS", + "CSS_FILTER_BLUR", + "CSS_FILTER_BRIGHTNESS", + "CSS_FILTER_CONTRAST", + "CSS_FILTER_CUSTOM", + "CSS_FILTER_DROP_SHADOW", + "CSS_FILTER_GRAYSCALE", + "CSS_FILTER_HUE_ROTATE", + "CSS_FILTER_INVERT", + "CSS_FILTER_OPACITY", + "CSS_FILTER_REFERENCE", + "CSS_FILTER_SATURATE", + "CSS_FILTER_SEPIA", + "CSS_GRAD", + "CSS_HZ", + "CSS_IDENT", + "CSS_IN", + "CSS_INHERIT", + "CSS_KHZ", + "CSS_MATRIX", + "CSS_MATRIX3D", + "CSS_MM", + "CSS_MS", + "CSS_NUMBER", + "CSS_PC", + "CSS_PERCENTAGE", + "CSS_PERSPECTIVE", + "CSS_PRIMITIVE_VALUE", + "CSS_PT", + "CSS_PX", + "CSS_RAD", + "CSS_RECT", + "CSS_RGBCOLOR", + "CSS_ROTATE", + "CSS_ROTATE3D", + "CSS_ROTATEX", + "CSS_ROTATEY", + "CSS_ROTATEZ", + "CSS_S", + "CSS_SCALE", + "CSS_SCALE3D", + "CSS_SCALEX", + "CSS_SCALEY", + "CSS_SCALEZ", + "CSS_SKEW", + "CSS_SKEWX", + "CSS_SKEWY", + "CSS_STRING", + "CSS_TRANSLATE", + "CSS_TRANSLATE3D", + "CSS_TRANSLATEX", + "CSS_TRANSLATEY", + "CSS_TRANSLATEZ", + "CSS_UNKNOWN", + "CSS_URI", + "CSS_VALUE_LIST", + "CSS_VH", + "CSS_VMAX", + "CSS_VMIN", + "CSS_VW", + "CULL_FACE", + "CULL_FACE_MODE", + "CURRENT_PROGRAM", + "CURRENT_QUERY", + "CURRENT_VERTEX_ATTRIB", + "CUSTOM", + "CW", + "Cache", + "CacheStorage", + "CanvasCaptureMediaStream", + "CanvasCaptureMediaStreamTrack", + "CanvasGradient", + "CanvasPattern", + "CanvasPixelArray", + "CanvasRenderingContext2D", + "CaretPosition", + "ChannelMergerNode", + "ChannelSplitterNode", + "CharacterData", + "Chrome PDF Plugin", + "Chrome PDF Viewer", + "ClientRect", + "ClientRectList", + "Clipboard", + "ClipboardEvent", + "ClipboardItem", + "CloseEvent", + "Collator", + "CollectGarbage", + "CommandEvent", + "Comment", + "CompileError", + "CompositionEvent", + "CompressionStream", + "Console", + "ConstantSourceNode", + "ControlRangeCollection", + "Controllers", + "ConvolverNode", + "Coordinates", + "CountQueuingStrategy", + "Counter", + "Credential", + "CredentialsContainer", + "Crypto", + "CryptoKey", + "CryptoOperation", + "CustomElementRegistry", + "CustomEvent", + "DATABASE_ERR", + "DATA_CLONE_ERR", + "DATA_ERR", + "DBLCLICK", + "DECR", + "DECR_WRAP", + "DELETE_STATUS", + "DEPTH", + "DEPTH24_STENCIL8", + "DEPTH32F_STENCIL8", + "DEPTH_ATTACHMENT", + "DEPTH_BITS", + "DEPTH_BUFFER_BIT", + "DEPTH_CLEAR_VALUE", + "DEPTH_COMPONENT", + "DEPTH_COMPONENT16", + "DEPTH_COMPONENT24", + "DEPTH_COMPONENT32F", + "DEPTH_FUNC", + "DEPTH_RANGE", + "DEPTH_STENCIL", + "DEPTH_STENCIL_ATTACHMENT", + "DEPTH_TEST", + "DEPTH_WRITEMASK", + "DEVICE_INELIGIBLE", + "DIRECTION_DOWN", + "DIRECTION_LEFT", + "DIRECTION_RIGHT", + "DIRECTION_UP", + "DISABLED", + "DISPATCH_REQUEST_ERR", + "DITHER", + "DOCUMENT_FRAGMENT_NODE", + "DOCUMENT_NODE", + "DOCUMENT_POSITION_CONTAINED_BY", + "DOCUMENT_POSITION_CONTAINS", + "DOCUMENT_POSITION_DISCONNECTED", + "DOCUMENT_POSITION_FOLLOWING", + "DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC", + "DOCUMENT_POSITION_PRECEDING", + "DOCUMENT_TYPE_NODE", + "DOMCursor", + "DOMError", + "DOMException", + "DOMImplementation", + "DOMImplementationLS", + "DOMMatrix", + "DOMMatrixReadOnly", + "DOMParser", + "DOMPoint", + "DOMPointReadOnly", + "DOMQuad", + "DOMRect", + "DOMRectList", + "DOMRectReadOnly", + "DOMRequest", + "DOMSTRING_SIZE_ERR", + "DOMSettableTokenList", + "DOMStringList", + "DOMStringMap", + "DOMTokenList", + "DOMTransactionEvent", + "DOM_DELTA_LINE", + "DOM_DELTA_PAGE", + "DOM_DELTA_PIXEL", + "DOM_INPUT_METHOD_DROP", + "DOM_INPUT_METHOD_HANDWRITING", + "DOM_INPUT_METHOD_IME", + "DOM_INPUT_METHOD_KEYBOARD", + "DOM_INPUT_METHOD_MULTIMODAL", + "DOM_INPUT_METHOD_OPTION", + "DOM_INPUT_METHOD_PASTE", + "DOM_INPUT_METHOD_SCRIPT", + "DOM_INPUT_METHOD_UNKNOWN", + "DOM_INPUT_METHOD_VOICE", + "DOM_KEY_LOCATION_JOYSTICK", + "DOM_KEY_LOCATION_LEFT", + "DOM_KEY_LOCATION_MOBILE", + "DOM_KEY_LOCATION_NUMPAD", + "DOM_KEY_LOCATION_RIGHT", + "DOM_KEY_LOCATION_STANDARD", + "DOM_VK_0", + "DOM_VK_1", + "DOM_VK_2", + "DOM_VK_3", + "DOM_VK_4", + "DOM_VK_5", + "DOM_VK_6", + "DOM_VK_7", + "DOM_VK_8", + "DOM_VK_9", + "DOM_VK_A", + "DOM_VK_ACCEPT", + "DOM_VK_ADD", + "DOM_VK_ALT", + "DOM_VK_ALTGR", + "DOM_VK_AMPERSAND", + "DOM_VK_ASTERISK", + "DOM_VK_AT", + "DOM_VK_ATTN", + "DOM_VK_B", + "DOM_VK_BACKSPACE", + "DOM_VK_BACK_QUOTE", + "DOM_VK_BACK_SLASH", + "DOM_VK_BACK_SPACE", + "DOM_VK_C", + "DOM_VK_CANCEL", + "DOM_VK_CAPS_LOCK", + "DOM_VK_CIRCUMFLEX", + "DOM_VK_CLEAR", + "DOM_VK_CLOSE_BRACKET", + "DOM_VK_CLOSE_CURLY_BRACKET", + "DOM_VK_CLOSE_PAREN", + "DOM_VK_COLON", + "DOM_VK_COMMA", + "DOM_VK_CONTEXT_MENU", + "DOM_VK_CONTROL", + "DOM_VK_CONVERT", + "DOM_VK_CRSEL", + "DOM_VK_CTRL", + "DOM_VK_D", + "DOM_VK_DECIMAL", + "DOM_VK_DELETE", + "DOM_VK_DIVIDE", + "DOM_VK_DOLLAR", + "DOM_VK_DOUBLE_QUOTE", + "DOM_VK_DOWN", + "DOM_VK_E", + "DOM_VK_EISU", + "DOM_VK_END", + "DOM_VK_ENTER", + "DOM_VK_EQUALS", + "DOM_VK_EREOF", + "DOM_VK_ESCAPE", + "DOM_VK_EXCLAMATION", + "DOM_VK_EXECUTE", + "DOM_VK_EXSEL", + "DOM_VK_F", + "DOM_VK_F1", + "DOM_VK_F10", + "DOM_VK_F11", + "DOM_VK_F12", + "DOM_VK_F13", + "DOM_VK_F14", + "DOM_VK_F15", + "DOM_VK_F16", + "DOM_VK_F17", + "DOM_VK_F18", + "DOM_VK_F19", + "DOM_VK_F2", + "DOM_VK_F20", + "DOM_VK_F21", + "DOM_VK_F22", + "DOM_VK_F23", + "DOM_VK_F24", + "DOM_VK_F25", + "DOM_VK_F26", + "DOM_VK_F27", + "DOM_VK_F28", + "DOM_VK_F29", + "DOM_VK_F3", + "DOM_VK_F30", + "DOM_VK_F31", + "DOM_VK_F32", + "DOM_VK_F33", + "DOM_VK_F34", + "DOM_VK_F35", + "DOM_VK_F36", + "DOM_VK_F4", + "DOM_VK_F5", + "DOM_VK_F6", + "DOM_VK_F7", + "DOM_VK_F8", + "DOM_VK_F9", + "DOM_VK_FINAL", + "DOM_VK_FRONT", + "DOM_VK_G", + "DOM_VK_GREATER_THAN", + "DOM_VK_H", + "DOM_VK_HANGUL", + "DOM_VK_HANJA", + "DOM_VK_HASH", + "DOM_VK_HELP", + "DOM_VK_HK_TOGGLE", + "DOM_VK_HOME", + "DOM_VK_HYPHEN_MINUS", + "DOM_VK_I", + "DOM_VK_INSERT", + "DOM_VK_J", + "DOM_VK_JUNJA", + "DOM_VK_K", + "DOM_VK_KANA", + "DOM_VK_KANJI", + "DOM_VK_L", + "DOM_VK_LEFT", + "DOM_VK_LEFT_TAB", + "DOM_VK_LESS_THAN", + "DOM_VK_M", + "DOM_VK_META", + "DOM_VK_MODECHANGE", + "DOM_VK_MULTIPLY", + "DOM_VK_N", + "DOM_VK_NONCONVERT", + "DOM_VK_NUMPAD0", + "DOM_VK_NUMPAD1", + "DOM_VK_NUMPAD2", + "DOM_VK_NUMPAD3", + "DOM_VK_NUMPAD4", + "DOM_VK_NUMPAD5", + "DOM_VK_NUMPAD6", + "DOM_VK_NUMPAD7", + "DOM_VK_NUMPAD8", + "DOM_VK_NUMPAD9", + "DOM_VK_NUM_LOCK", + "DOM_VK_O", + "DOM_VK_OEM_1", + "DOM_VK_OEM_102", + "DOM_VK_OEM_2", + "DOM_VK_OEM_3", + "DOM_VK_OEM_4", + "DOM_VK_OEM_5", + "DOM_VK_OEM_6", + "DOM_VK_OEM_7", + "DOM_VK_OEM_8", + "DOM_VK_OEM_COMMA", + "DOM_VK_OEM_MINUS", + "DOM_VK_OEM_PERIOD", + "DOM_VK_OEM_PLUS", + "DOM_VK_OPEN_BRACKET", + "DOM_VK_OPEN_CURLY_BRACKET", + "DOM_VK_OPEN_PAREN", + "DOM_VK_P", + "DOM_VK_PA1", + "DOM_VK_PAGEDOWN", + "DOM_VK_PAGEUP", + "DOM_VK_PAGE_DOWN", + "DOM_VK_PAGE_UP", + "DOM_VK_PAUSE", + "DOM_VK_PERCENT", + "DOM_VK_PERIOD", + "DOM_VK_PIPE", + "DOM_VK_PLAY", + "DOM_VK_PLUS", + "DOM_VK_PRINT", + "DOM_VK_PRINTSCREEN", + "DOM_VK_PROCESSKEY", + "DOM_VK_PROPERITES", + "DOM_VK_Q", + "DOM_VK_QUESTION_MARK", + "DOM_VK_QUOTE", + "DOM_VK_R", + "DOM_VK_REDO", + "DOM_VK_RETURN", + "DOM_VK_RIGHT", + "DOM_VK_S", + "DOM_VK_SCROLL_LOCK", + "DOM_VK_SELECT", + "DOM_VK_SEMICOLON", + "DOM_VK_SEPARATOR", + "DOM_VK_SHIFT", + "DOM_VK_SLASH", + "DOM_VK_SLEEP", + "DOM_VK_SPACE", + "DOM_VK_SUBTRACT", + "DOM_VK_T", + "DOM_VK_TAB", + "DOM_VK_TILDE", + "DOM_VK_U", + "DOM_VK_UNDERSCORE", + "DOM_VK_UNDO", + "DOM_VK_UNICODE", + "DOM_VK_UP", + "DOM_VK_V", + "DOM_VK_VOLUME_DOWN", + "DOM_VK_VOLUME_MUTE", + "DOM_VK_VOLUME_UP", + "DOM_VK_W", + "DOM_VK_WIN", + "DOM_VK_WINDOW", + "DOM_VK_WIN_ICO_00", + "DOM_VK_WIN_ICO_CLEAR", + "DOM_VK_WIN_ICO_HELP", + "DOM_VK_WIN_OEM_ATTN", + "DOM_VK_WIN_OEM_AUTO", + "DOM_VK_WIN_OEM_BACKTAB", + "DOM_VK_WIN_OEM_CLEAR", + "DOM_VK_WIN_OEM_COPY", + "DOM_VK_WIN_OEM_CUSEL", + "DOM_VK_WIN_OEM_ENLW", + "DOM_VK_WIN_OEM_FINISH", + "DOM_VK_WIN_OEM_FJ_JISHO", + "DOM_VK_WIN_OEM_FJ_LOYA", + "DOM_VK_WIN_OEM_FJ_MASSHOU", + "DOM_VK_WIN_OEM_FJ_ROYA", + "DOM_VK_WIN_OEM_FJ_TOUROKU", + "DOM_VK_WIN_OEM_JUMP", + "DOM_VK_WIN_OEM_PA1", + "DOM_VK_WIN_OEM_PA2", + "DOM_VK_WIN_OEM_PA3", + "DOM_VK_WIN_OEM_RESET", + "DOM_VK_WIN_OEM_WSCTRL", + "DOM_VK_X", + "DOM_VK_XF86XK_ADD_FAVORITE", + "DOM_VK_XF86XK_APPLICATION_LEFT", + "DOM_VK_XF86XK_APPLICATION_RIGHT", + "DOM_VK_XF86XK_AUDIO_CYCLE_TRACK", + "DOM_VK_XF86XK_AUDIO_FORWARD", + "DOM_VK_XF86XK_AUDIO_LOWER_VOLUME", + "DOM_VK_XF86XK_AUDIO_MEDIA", + "DOM_VK_XF86XK_AUDIO_MUTE", + "DOM_VK_XF86XK_AUDIO_NEXT", + "DOM_VK_XF86XK_AUDIO_PAUSE", + "DOM_VK_XF86XK_AUDIO_PLAY", + "DOM_VK_XF86XK_AUDIO_PREV", + "DOM_VK_XF86XK_AUDIO_RAISE_VOLUME", + "DOM_VK_XF86XK_AUDIO_RANDOM_PLAY", + "DOM_VK_XF86XK_AUDIO_RECORD", + "DOM_VK_XF86XK_AUDIO_REPEAT", + "DOM_VK_XF86XK_AUDIO_REWIND", + "DOM_VK_XF86XK_AUDIO_STOP", + "DOM_VK_XF86XK_AWAY", + "DOM_VK_XF86XK_BACK", + "DOM_VK_XF86XK_BACK_FORWARD", + "DOM_VK_XF86XK_BATTERY", + "DOM_VK_XF86XK_BLUE", + "DOM_VK_XF86XK_BLUETOOTH", + "DOM_VK_XF86XK_BOOK", + "DOM_VK_XF86XK_BRIGHTNESS_ADJUST", + "DOM_VK_XF86XK_CALCULATOR", + "DOM_VK_XF86XK_CALENDAR", + "DOM_VK_XF86XK_CD", + "DOM_VK_XF86XK_CLOSE", + "DOM_VK_XF86XK_COMMUNITY", + "DOM_VK_XF86XK_CONTRAST_ADJUST", + "DOM_VK_XF86XK_COPY", + "DOM_VK_XF86XK_CUT", + "DOM_VK_XF86XK_CYCLE_ANGLE", + "DOM_VK_XF86XK_DISPLAY", + "DOM_VK_XF86XK_DOCUMENTS", + "DOM_VK_XF86XK_DOS", + "DOM_VK_XF86XK_EJECT", + "DOM_VK_XF86XK_EXCEL", + "DOM_VK_XF86XK_EXPLORER", + "DOM_VK_XF86XK_FAVORITES", + "DOM_VK_XF86XK_FINANCE", + "DOM_VK_XF86XK_FORWARD", + "DOM_VK_XF86XK_FRAME_BACK", + "DOM_VK_XF86XK_FRAME_FORWARD", + "DOM_VK_XF86XK_GAME", + "DOM_VK_XF86XK_GO", + "DOM_VK_XF86XK_GREEN", + "DOM_VK_XF86XK_HIBERNATE", + "DOM_VK_XF86XK_HISTORY", + "DOM_VK_XF86XK_HOME_PAGE", + "DOM_VK_XF86XK_HOT_LINKS", + "DOM_VK_XF86XK_I_TOUCH", + "DOM_VK_XF86XK_KBD_BRIGHTNESS_DOWN", + "DOM_VK_XF86XK_KBD_BRIGHTNESS_UP", + "DOM_VK_XF86XK_KBD_LIGHT_ON_OFF", + "DOM_VK_XF86XK_LAUNCH0", + "DOM_VK_XF86XK_LAUNCH1", + "DOM_VK_XF86XK_LAUNCH2", + "DOM_VK_XF86XK_LAUNCH3", + "DOM_VK_XF86XK_LAUNCH4", + "DOM_VK_XF86XK_LAUNCH5", + "DOM_VK_XF86XK_LAUNCH6", + "DOM_VK_XF86XK_LAUNCH7", + "DOM_VK_XF86XK_LAUNCH8", + "DOM_VK_XF86XK_LAUNCH9", + "DOM_VK_XF86XK_LAUNCH_A", + "DOM_VK_XF86XK_LAUNCH_B", + "DOM_VK_XF86XK_LAUNCH_C", + "DOM_VK_XF86XK_LAUNCH_D", + "DOM_VK_XF86XK_LAUNCH_E", + "DOM_VK_XF86XK_LAUNCH_F", + "DOM_VK_XF86XK_LIGHT_BULB", + "DOM_VK_XF86XK_LOG_OFF", + "DOM_VK_XF86XK_MAIL", + "DOM_VK_XF86XK_MAIL_FORWARD", + "DOM_VK_XF86XK_MARKET", + "DOM_VK_XF86XK_MEETING", + "DOM_VK_XF86XK_MEMO", + "DOM_VK_XF86XK_MENU_KB", + "DOM_VK_XF86XK_MENU_PB", + "DOM_VK_XF86XK_MESSENGER", + "DOM_VK_XF86XK_MON_BRIGHTNESS_DOWN", + "DOM_VK_XF86XK_MON_BRIGHTNESS_UP", + "DOM_VK_XF86XK_MUSIC", + "DOM_VK_XF86XK_MY_COMPUTER", + "DOM_VK_XF86XK_MY_SITES", + "DOM_VK_XF86XK_NEW", + "DOM_VK_XF86XK_NEWS", + "DOM_VK_XF86XK_OFFICE_HOME", + "DOM_VK_XF86XK_OPEN", + "DOM_VK_XF86XK_OPEN_URL", + "DOM_VK_XF86XK_OPTION", + "DOM_VK_XF86XK_PASTE", + "DOM_VK_XF86XK_PHONE", + "DOM_VK_XF86XK_PICTURES", + "DOM_VK_XF86XK_POWER_DOWN", + "DOM_VK_XF86XK_POWER_OFF", + "DOM_VK_XF86XK_RED", + "DOM_VK_XF86XK_REFRESH", + "DOM_VK_XF86XK_RELOAD", + "DOM_VK_XF86XK_REPLY", + "DOM_VK_XF86XK_ROCKER_DOWN", + "DOM_VK_XF86XK_ROCKER_ENTER", + "DOM_VK_XF86XK_ROCKER_UP", + "DOM_VK_XF86XK_ROTATE_WINDOWS", + "DOM_VK_XF86XK_ROTATION_KB", + "DOM_VK_XF86XK_ROTATION_PB", + "DOM_VK_XF86XK_SAVE", + "DOM_VK_XF86XK_SCREEN_SAVER", + "DOM_VK_XF86XK_SCROLL_CLICK", + "DOM_VK_XF86XK_SCROLL_DOWN", + "DOM_VK_XF86XK_SCROLL_UP", + "DOM_VK_XF86XK_SEARCH", + "DOM_VK_XF86XK_SEND", + "DOM_VK_XF86XK_SHOP", + "DOM_VK_XF86XK_SPELL", + "DOM_VK_XF86XK_SPLIT_SCREEN", + "DOM_VK_XF86XK_STANDBY", + "DOM_VK_XF86XK_START", + "DOM_VK_XF86XK_STOP", + "DOM_VK_XF86XK_SUBTITLE", + "DOM_VK_XF86XK_SUPPORT", + "DOM_VK_XF86XK_SUSPEND", + "DOM_VK_XF86XK_TASK_PANE", + "DOM_VK_XF86XK_TERMINAL", + "DOM_VK_XF86XK_TIME", + "DOM_VK_XF86XK_TOOLS", + "DOM_VK_XF86XK_TOP_MENU", + "DOM_VK_XF86XK_TO_DO_LIST", + "DOM_VK_XF86XK_TRAVEL", + "DOM_VK_XF86XK_USER1KB", + "DOM_VK_XF86XK_USER2KB", + "DOM_VK_XF86XK_USER_PB", + "DOM_VK_XF86XK_UWB", + "DOM_VK_XF86XK_VENDOR_HOME", + "DOM_VK_XF86XK_VIDEO", + "DOM_VK_XF86XK_VIEW", + "DOM_VK_XF86XK_WAKE_UP", + "DOM_VK_XF86XK_WEB_CAM", + "DOM_VK_XF86XK_WHEEL_BUTTON", + "DOM_VK_XF86XK_WLAN", + "DOM_VK_XF86XK_WORD", + "DOM_VK_XF86XK_WWW", + "DOM_VK_XF86XK_XFER", + "DOM_VK_XF86XK_YELLOW", + "DOM_VK_XF86XK_ZOOM_IN", + "DOM_VK_XF86XK_ZOOM_OUT", + "DOM_VK_Y", + "DOM_VK_Z", + "DOM_VK_ZOOM", + "DONE", + "DONT_CARE", + "DOWNLOADING", + "DRAGDROP", + "DRAW_BUFFER0", + "DRAW_BUFFER1", + "DRAW_BUFFER10", + "DRAW_BUFFER11", + "DRAW_BUFFER12", + "DRAW_BUFFER13", + "DRAW_BUFFER14", + "DRAW_BUFFER15", + "DRAW_BUFFER2", + "DRAW_BUFFER3", + "DRAW_BUFFER4", + "DRAW_BUFFER5", + "DRAW_BUFFER6", + "DRAW_BUFFER7", + "DRAW_BUFFER8", + "DRAW_BUFFER9", + "DRAW_FRAMEBUFFER", + "DRAW_FRAMEBUFFER_BINDING", + "DST_ALPHA", + "DST_COLOR", + "DYNAMIC_COPY", + "DYNAMIC_DRAW", + "DYNAMIC_READ", + "DataChannel", + "DataCue", + "DataTransfer", + "DataTransferItem", + "DataTransferItemList", + "DataView", + "Database", + "Date", + "DateTimeFormat", + "Debug", + "DecompressionStream", + "Default Browser Helper", + "DelayNode", + "DesktopNotification", + "DesktopNotificationCenter", + "DeviceAcceleration", + "DeviceLightEvent", + "DeviceMotionEvent", + "DeviceMotionEventAcceleration", + "DeviceMotionEventRotationRate", + "DeviceOrientationEvent", + "DeviceProximityEvent", + "DeviceRotationRate", + "DeviceStorage", + "DeviceStorageChangeEvent", + "Directory", + "DisplayNames", + "Document", + "DocumentFragment", + "DocumentTimeline", + "DocumentType", + "DragEvent", + "DynamicsCompressorNode", + "E", + "ELEMENT_ARRAY_BUFFER", + "ELEMENT_ARRAY_BUFFER_BINDING", + "ELEMENT_NODE", + "EMPTY", + "ENCODING_ERR", + "ENDED", + "END_TO_END", + "END_TO_START", + "ENTITY_NODE", + "ENTITY_REFERENCE_NODE", + "EPSILON", + "EQUAL", + "EQUALPOWER", + "ERROR", + "EXPONENTIAL_DISTANCE", + "EXT_texture_filter_anisotropic", + "Element", + "ElementInternals", + "ElementQuery", + "EnterPictureInPictureEvent", + "Entity", + "EntityReference", + "Enumerator", + "Error", + "ErrorEvent", + "EvalError", + "Event", + "EventException", + "EventSource", + "EventTarget", + "External", + "FASTEST", + "FIDOSDK", + "FILTER_ACCEPT", + "FILTER_INTERRUPT", + "FILTER_REJECT", + "FILTER_SKIP", + "FINISHED_STATE", + "FIRST_ORDERED_NODE_TYPE", + "FLOAT", + "FLOAT_32_UNSIGNED_INT_24_8_REV", + "FLOAT_MAT2", + "FLOAT_MAT2x3", + "FLOAT_MAT2x4", + "FLOAT_MAT3", + "FLOAT_MAT3x2", + "FLOAT_MAT3x4", + "FLOAT_MAT4", + "FLOAT_MAT4x2", + "FLOAT_MAT4x3", + "FLOAT_VEC2", + "FLOAT_VEC3", + "FLOAT_VEC4", + "FOCUS", + "FONT_FACE_RULE", + "FONT_FEATURE_VALUES_RULE", + "FRAGMENT_SHADER", + "FRAGMENT_SHADER_DERIVATIVE_HINT", + "FRAGMENT_SHADER_DERIVATIVE_HINT_OES", + "FRAMEBUFFER", + "FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE", + "FRAMEBUFFER_ATTACHMENT_BLUE_SIZE", + "FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING", + "FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE", + "FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE", + "FRAMEBUFFER_ATTACHMENT_GREEN_SIZE", + "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME", + "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE", + "FRAMEBUFFER_ATTACHMENT_RED_SIZE", + "FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE", + "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE", + "FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER", + "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL", + "FRAMEBUFFER_BINDING", + "FRAMEBUFFER_COMPLETE", + "FRAMEBUFFER_DEFAULT", + "FRAMEBUFFER_INCOMPLETE_ATTACHMENT", + "FRAMEBUFFER_INCOMPLETE_DIMENSIONS", + "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT", + "FRAMEBUFFER_INCOMPLETE_MULTISAMPLE", + "FRAMEBUFFER_UNSUPPORTED", + "FRONT", + "FRONT_AND_BACK", + "FRONT_FACE", + "FUNC_ADD", + "FUNC_REVERSE_SUBTRACT", + "FUNC_SUBTRACT", + "FeaturePolicy", + "FederatedCredential", + "Feed", + "FeedEntry", + "File", + "FileError", + "FileList", + "FileReader", + "FileSystem", + "FileSystemDirectoryEntry", + "FileSystemDirectoryReader", + "FileSystemEntry", + "FileSystemFileEntry", + "FinalizationRegistry", + "FindInPage", + "Float32Array", + "Float64Array", + "FocusEvent", + "FontFace", + "FontFaceSet", + "FontFaceSetLoadEvent", + "FormData", + "FormDataEvent", + "FragmentDirective", + "Function", + "GENERATE_MIPMAP_HINT", + "GEQUAL", + "GREATER", + "GREEN_BITS", + "GainNode", + "Gamepad", + "GamepadButton", + "GamepadEvent", + "GamepadHapticActuator", + "GamepadPose", + "Geolocation", + "GeolocationCoordinates", + "GeolocationPosition", + "GeolocationPositionError", + "GestureEvent", + "Global", + "Gyroscope", + "HALF_FLOAT", + "HAVE_CURRENT_DATA", + "HAVE_ENOUGH_DATA", + "HAVE_FUTURE_DATA", + "HAVE_METADATA", + "HAVE_NOTHING", + "HEADERS_RECEIVED", + "HIDDEN", + "HIERARCHY_REQUEST_ERR", + "HIGHPASS", + "HIGHSHELF", + "HIGH_FLOAT", + "HIGH_INT", + "HORIZONTAL", + "HORIZONTAL_AXIS", + "HRTF", + "HTMLAllCollection", + "HTMLAnchorElement", + "HTMLAppletElement", + "HTMLAreaElement", + "HTMLAreasCollection", + "HTMLAudioElement", + "HTMLBGSoundElement", + "HTMLBRElement", + "HTMLBaseElement", + "HTMLBaseFontElement", + "HTMLBlockElement", + "HTMLBlockquoteElement", + "HTMLBodyElement", + "HTMLButtonElement", + "HTMLCanvasElement", + "HTMLCollection", + "HTMLCommandElement", + "HTMLContentElement", + "HTMLDDElement", + "HTMLDListElement", + "HTMLDTElement", + "HTMLDataElement", + "HTMLDataListElement", + "HTMLDetailsElement", + "HTMLDialogElement", + "HTMLDirectoryElement", + "HTMLDivElement", + "HTMLDocument", + "HTMLElement", + "HTMLEmbedElement", + "HTMLFieldSetElement", + "HTMLFontElement", + "HTMLFormControlsCollection", + "HTMLFormElement", + "HTMLFrameElement", + "HTMLFrameSetElement", + "HTMLHRElement", + "HTMLHeadElement", + "HTMLHeadingElement", + "HTMLHtmlElement", + "HTMLIFrameElement", + "HTMLImageElement", + "HTMLInputElement", + "HTMLIsIndexElement", + "HTMLKeygenElement", + "HTMLLIElement", + "HTMLLabelElement", + "HTMLLegendElement", + "HTMLLinkElement", + "HTMLMapElement", + "HTMLMarqueeElement", + "HTMLMediaElement", + "HTMLMenuElement", + "HTMLMenuItemElement", + "HTMLMetaElement", + "HTMLMeterElement", + "HTMLModElement", + "HTMLNextIdElement", + "HTMLOListElement", + "HTMLObjectElement", + "HTMLOptGroupElement", + "HTMLOptionElement", + "HTMLOptionsCollection", + "HTMLOutputElement", + "HTMLParagraphElement", + "HTMLParamElement", + "HTMLPhraseElement", + "HTMLPictureElement", + "HTMLPreElement", + "HTMLProgressElement", + "HTMLPropertiesCollection", + "HTMLQuoteElement", + "HTMLScriptElement", + "HTMLSelectElement", + "HTMLShadowElement", + "HTMLSlotElement", + "HTMLSourceElement", + "HTMLSpanElement", + "HTMLStyleElement", + "HTMLTableCaptionElement", + "HTMLTableCellElement", + "HTMLTableColElement", + "HTMLTableDataCellElement", + "HTMLTableElement", + "HTMLTableHeaderCellElement", + "HTMLTableRowElement", + "HTMLTableSectionElement", + "HTMLTemplateElement", + "HTMLTextAreaElement", + "HTMLTimeElement", + "HTMLTitleElement", + "HTMLTrackElement", + "HTMLUListElement", + "HTMLUnknownElement", + "HTMLVideoElement", + "HashChangeEvent", + "Headers", + "History", + "Hz", + "ICE_CHECKING", + "ICE_CLOSED", + "ICE_COMPLETED", + "ICE_CONNECTED", + "ICE_FAILED", + "ICE_GATHERING", + "ICE_WAITING", + "IDBCursor", + "IDBCursorWithValue", + "IDBDatabase", + "IDBDatabaseException", + "IDBFactory", + "IDBFileHandle", + "IDBFileRequest", + "IDBIndex", + "IDBKeyRange", + "IDBMutableFile", + "IDBObjectStore", + "IDBOpenDBRequest", + "IDBRequest", + "IDBTransaction", + "IDBVersionChangeEvent", + "IDLE", + "IIRFilterNode", + "IMPLEMENTATION_COLOR_READ_FORMAT", + "IMPLEMENTATION_COLOR_READ_TYPE", + "IMPORT_RULE", + "INCR", + "INCR_WRAP", + "INDEX_SIZE_ERR", + "INSTALL", + "INSTALLED", + "INT", + "INTERLEAVED_ATTRIBS", + "INT_2_10_10_10_REV", + "INT_SAMPLER_2D", + "INT_SAMPLER_2D_ARRAY", + "INT_SAMPLER_3D", + "INT_SAMPLER_CUBE", + "INT_VEC2", + "INT_VEC3", + "INT_VEC4", + "INUSE_ATTRIBUTE_ERR", + "INVALID_ACCESS_ERR", + "INVALID_CHARACTER_ERR", + "INVALID_ENUM", + "INVALID_EXPRESSION_ERR", + "INVALID_FRAMEBUFFER_OPERATION", + "INVALID_INDEX", + "INVALID_MODIFICATION_ERR", + "INVALID_NODE_TYPE_ERR", + "INVALID_OPERATION", + "INVALID_STATE_ERR", + "INVALID_VALUE", + "INVERSE_DISTANCE", + "INVERT", + "IceCandidate", + "IdleDeadline", + "Image", + "ImageBitmap", + "ImageBitmapRenderingContext", + "ImageCapture", + "ImageData", + "Infinity", + "InputDeviceCapabilities", + "InputDeviceInfo", + "InputEvent", + "InputMethodContext", + "InstallState", + "InstallTrigger", + "Instance", + "Int16Array", + "Int32Array", + "Int8Array", + "Intent", + "InternalError", + "IntersectionObserver", + "IntersectionObserverEntry", + "Intl", + "IsSearchProviderInstalled", + "Iterator", + "JSON", + "Java Deployment Toolkit 7.0.250.17", + "Java(TM) Platform SE 7 U25", + "KEEP", + "KEYDOWN", + "KEYFRAMES_RULE", + "KEYFRAME_RULE", + "KEYPRESS", + "KEYUP", + "Key", + "KeyEvent", + "KeyOperation", + "KeyPair", + "Keyboard", + "KeyboardEvent", + "KeyboardLayoutMap", + "KeyframeEffect", + "LENGTHADJUST_SPACING", + "LENGTHADJUST_SPACINGANDGLYPHS", + "LENGTHADJUST_UNKNOWN", + "LEQUAL", + "LESS", + "LINEAR", + "LINEAR_DISTANCE", + "LINEAR_MIPMAP_LINEAR", + "LINEAR_MIPMAP_NEAREST", + "LINES", + "LINE_LOOP", + "LINE_STRIP", + "LINE_WIDTH", + "LINK_STATUS", + "LINUX", + "LIVE", + "LN10", + "LN2", + "LOADED", + "LOADING", + "LOCALE", + "LOG10E", + "LOG2E", + "LOWPASS", + "LOWSHELF", + "LOW_FLOAT", + "LOW_INT", + "LSException", + "LSParserFilter", + "LUMINANCE", + "LUMINANCE_ALPHA", + "LargestContentfulPaint", + "LayoutShift", + "LayoutShiftAttribution", + "LinearAccelerationSensor", + "LinkError", + "ListFormat", + "LocalMediaStream", + "Locale", + "Location", + "Lock", + "LockManager", + "MAC", + "MAX", + "MAX_3D_TEXTURE_SIZE", + "MAX_ARRAY_TEXTURE_LAYERS", + "MAX_CLIENT_WAIT_TIMEOUT_WEBGL", + "MAX_COLOR_ATTACHMENTS", + "MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS", + "MAX_COMBINED_TEXTURE_IMAGE_UNITS", + "MAX_COMBINED_UNIFORM_BLOCKS", + "MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS", + "MAX_CUBE_MAP_TEXTURE_SIZE", + "MAX_DRAW_BUFFERS", + "MAX_ELEMENTS_INDICES", + "MAX_ELEMENTS_VERTICES", + "MAX_ELEMENT_INDEX", + "MAX_FRAGMENT_INPUT_COMPONENTS", + "MAX_FRAGMENT_UNIFORM_BLOCKS", + "MAX_FRAGMENT_UNIFORM_COMPONENTS", + "MAX_FRAGMENT_UNIFORM_VECTORS", + "MAX_PROGRAM_TEXEL_OFFSET", + "MAX_RENDERBUFFER_SIZE", + "MAX_SAFE_INTEGER", + "MAX_SAMPLES", + "MAX_SERVER_WAIT_TIMEOUT", + "MAX_TEXTURE_IMAGE_UNITS", + "MAX_TEXTURE_LOD_BIAS", + "MAX_TEXTURE_MAX_ANISOTROPY_EXT", + "MAX_TEXTURE_SIZE", + "MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS", + "MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS", + "MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS", + "MAX_UNIFORM_BLOCK_SIZE", + "MAX_UNIFORM_BUFFER_BINDINGS", + "MAX_VALUE", + "MAX_VARYING_COMPONENTS", + "MAX_VARYING_VECTORS", + "MAX_VERTEX_ATTRIBS", + "MAX_VERTEX_OUTPUT_COMPONENTS", + "MAX_VERTEX_TEXTURE_IMAGE_UNITS", + "MAX_VERTEX_UNIFORM_BLOCKS", + "MAX_VERTEX_UNIFORM_COMPONENTS", + "MAX_VERTEX_UNIFORM_VECTORS", + "MAX_VIEWPORT_DIMS", + "MEDIA_ERR_ABORTED", + "MEDIA_ERR_DECODE", + "MEDIA_ERR_ENCRYPTED", + "MEDIA_ERR_NETWORK", + "MEDIA_ERR_SRC_NOT_SUPPORTED", + "MEDIA_KEYERR_CLIENT", + "MEDIA_KEYERR_DOMAIN", + "MEDIA_KEYERR_HARDWARECHANGE", + "MEDIA_KEYERR_OUTPUT", + "MEDIA_KEYERR_SERVICE", + "MEDIA_KEYERR_UNKNOWN", + "MEDIA_RULE", + "MEDIUM_FLOAT", + "MEDIUM_INT", + "META_MASK", + "MIDIAccess", + "MIDIConnectionEvent", + "MIDIInput", + "MIDIInputMap", + "MIDIMessageEvent", + "MIDIOutput", + "MIDIOutputMap", + "MIDIPort", + "MIN", + "MIN_PROGRAM_TEXEL_OFFSET", + "MIN_SAFE_INTEGER", + "MIN_VALUE", + "MIRRORED_REPEAT", + "MODE_ASYNCHRONOUS", + "MODE_SYNCHRONOUS", + "MODIFICATION", + "MOUSEDOWN", + "MOUSEDRAG", + "MOUSEMOVE", + "MOUSEOUT", + "MOUSEOVER", + "MOUSEUP", + "MOZ_KEYFRAMES_RULE", + "MOZ_KEYFRAME_RULE", + "MOZ_SOURCE_CURSOR", + "MOZ_SOURCE_ERASER", + "MOZ_SOURCE_KEYBOARD", + "MOZ_SOURCE_MOUSE", + "MOZ_SOURCE_PEN", + "MOZ_SOURCE_TOUCH", + "MOZ_SOURCE_UNKNOWN", + "MSBehaviorUrnsCollection", + "MSBlobBuilder", + "MSCSSMatrix", + "MSCSSProperties", + "MSCSSRuleList", + "MSCompatibleInfo", + "MSCompatibleInfoCollection", + "MSCurrentStyleCSSProperties", + "MSEventObj", + "MSGESTURE_FLAG_BEGIN", + "MSGESTURE_FLAG_CANCEL", + "MSGESTURE_FLAG_END", + "MSGESTURE_FLAG_INERTIA", + "MSGESTURE_FLAG_NONE", + "MSGesture", + "MSGestureEvent", + "MSGraphicsTrust", + "MSInputMethodContext", + "MSManipulationEvent", + "MSMediaKeyError", + "MSMediaKeyMessageEvent", + "MSMediaKeyNeededEvent", + "MSMediaKeySession", + "MSMediaKeys", + "MSMimeTypesCollection", + "MSPOINTER_TYPE_MOUSE", + "MSPOINTER_TYPE_PEN", + "MSPOINTER_TYPE_TOUCH", + "MSPluginsCollection", + "MSPointerEvent", + "MSRangeCollection", + "MSSiteModeEvent", + "MSStream", + "MSStreamReader", + "MSStyleCSSProperties", + "MS_ASYNC_CALLBACK_STATUS_ASSIGN_DELEGATE", + "MS_ASYNC_CALLBACK_STATUS_CANCEL", + "MS_ASYNC_CALLBACK_STATUS_CHOOSEANY", + "MS_ASYNC_CALLBACK_STATUS_ERROR", + "MS_ASYNC_CALLBACK_STATUS_JOIN", + "MS_ASYNC_OP_STATUS_CANCELED", + "MS_ASYNC_OP_STATUS_ERROR", + "MS_ASYNC_OP_STATUS_SUCCESS", + "MS_MANIPULATION_STATE_ACTIVE", + "MS_MANIPULATION_STATE_CANCELLED", + "MS_MANIPULATION_STATE_COMMITTED", + "MS_MANIPULATION_STATE_DRAGGING", + "MS_MANIPULATION_STATE_INERTIA", + "MS_MANIPULATION_STATE_PRESELECT", + "MS_MANIPULATION_STATE_SELECTING", + "MS_MANIPULATION_STATE_STOPPED", + "MS_MEDIA_ERR_ENCRYPTED", + "MS_MEDIA_KEYERR_CLIENT", + "MS_MEDIA_KEYERR_DOMAIN", + "MS_MEDIA_KEYERR_HARDWARECHANGE", + "MS_MEDIA_KEYERR_OUTPUT", + "MS_MEDIA_KEYERR_SERVICE", + "MS_MEDIA_KEYERR_UNKNOWN", + "Map", + "Math", + "MathMLElement", + "MediaCapabilities", + "MediaCapabilitiesInfo", + "MediaController", + "MediaDeviceInfo", + "MediaDevices", + "MediaElementAudioSourceNode", + "MediaEncryptedEvent", + "MediaError", + "MediaKeyError", + "MediaKeyEvent", + "MediaKeyMessageEvent", + "MediaKeyNeededEvent", + "MediaKeySession", + "MediaKeyStatusMap", + "MediaKeySystemAccess", + "MediaKeys", + "MediaList", + "MediaMetadata", + "MediaQueryList", + "MediaQueryListEvent", + "MediaRecorder", + "MediaRecorderErrorEvent", + "MediaSession", + "MediaSettingsRange", + "MediaSource", + "MediaStream", + "MediaStreamAudioDestinationNode", + "MediaStreamAudioSourceNode", + "MediaStreamEvent", + "MediaStreamTrack", + "MediaStreamTrackAudioSourceNode", + "MediaStreamTrackEvent", + "Memory", + "MessageChannel", + "MessageEvent", + "MessagePort", + "Methods", + "Microsoft® DRM", + "MimeType", + "MimeTypeArray", + "Module", + "MouseEvent", + "MouseScrollEvent", + "MouseWheelEvent", + "MozAnimation", + "MozAnimationDelay", + "MozAnimationDirection", + "MozAnimationDuration", + "MozAnimationFillMode", + "MozAnimationIterationCount", + "MozAnimationName", + "MozAnimationPlayState", + "MozAnimationTimingFunction", + "MozAppearance", + "MozBackfaceVisibility", + "MozBinding", + "MozBorderBottomColors", + "MozBorderEnd", + "MozBorderEndColor", + "MozBorderEndStyle", + "MozBorderEndWidth", + "MozBorderImage", + "MozBorderLeftColors", + "MozBorderRightColors", + "MozBorderStart", + "MozBorderStartColor", + "MozBorderStartStyle", + "MozBorderStartWidth", + "MozBorderTopColors", + "MozBoxAlign", + "MozBoxDirection", + "MozBoxFlex", + "MozBoxOrdinalGroup", + "MozBoxOrient", + "MozBoxPack", + "MozBoxSizing", + "MozCSSKeyframeRule", + "MozCSSKeyframesRule", + "MozColumnCount", + "MozColumnFill", + "MozColumnGap", + "MozColumnRule", + "MozColumnRuleColor", + "MozColumnRuleStyle", + "MozColumnRuleWidth", + "MozColumnWidth", + "MozColumns", + "MozContactChangeEvent", + "MozFloatEdge", + "MozFontFeatureSettings", + "MozFontLanguageOverride", + "MozForceBrokenImageIcon", + "MozHyphens", + "MozImageRegion", + "MozMarginEnd", + "MozMarginStart", + "MozMmsEvent", + "MozMmsMessage", + "MozMobileMessageThread", + "MozOSXFontSmoothing", + "MozOrient", + "MozOutlineRadius", + "MozOutlineRadiusBottomleft", + "MozOutlineRadiusBottomright", + "MozOutlineRadiusTopleft", + "MozOutlineRadiusTopright", + "MozPaddingEnd", + "MozPaddingStart", + "MozPerspective", + "MozPerspectiveOrigin", + "MozPowerManager", + "MozSettingsEvent", + "MozSmsEvent", + "MozSmsMessage", + "MozStackSizing", + "MozTabSize", + "MozTextAlignLast", + "MozTextDecorationColor", + "MozTextDecorationLine", + "MozTextDecorationStyle", + "MozTextSizeAdjust", + "MozTransform", + "MozTransformOrigin", + "MozTransformStyle", + "MozTransition", + "MozTransitionDelay", + "MozTransitionDuration", + "MozTransitionProperty", + "MozTransitionTimingFunction", + "MozUserFocus", + "MozUserInput", + "MozUserModify", + "MozUserSelect", + "MozWindowDragging", + "MozWindowShadow", + "MutationEvent", + "MutationObserver", + "MutationRecord", + "NAMESPACE_ERR", + "NAMESPACE_RULE", + "NEAREST", + "NEAREST_MIPMAP_LINEAR", + "NEAREST_MIPMAP_NEAREST", + "NEGATIVE_INFINITY", + "NETWORK_EMPTY", + "NETWORK_ERR", + "NETWORK_IDLE", + "NETWORK_LOADED", + "NETWORK_LOADING", + "NETWORK_NO_SOURCE", + "NEVER", + "NEW", + "NEXT", + "NEXT_NO_DUPLICATE", + "NICEST", + "NODE_AFTER", + "NODE_BEFORE", + "NODE_BEFORE_AND_AFTER", + "NODE_INSIDE", + "NONE", + "NON_TRANSIENT_ERR", + "NOTATION_NODE", + "NOTCH", + "NOTEQUAL", + "NOT_ALLOWED_ERR", + "NOT_FOUND_ERR", + "NOT_INSTALLED", + "NOT_READABLE_ERR", + "NOT_SUPPORTED_ERR", + "NO_DATA_ALLOWED_ERR", + "NO_ERR", + "NO_ERROR", + "NO_MODIFICATION_ALLOWED_ERR", + "NO_UPDATE", + "NUMBER_TYPE", + "NUM_COMPRESSED_TEXTURE_FORMATS", + "NaN", + "NamedNodeMap", + "Native Client", + "NavigationPreloadManager", + "Navigator", + "NearbyLinks", + "NetworkInformation", + "Node", + "NodeFilter", + "NodeIterator", + "NodeList", + "Notation", + "Notification", + "NotifyPaintEvent", + "Number", + "NumberFormat", + "OBJECT_TYPE", + "OBSOLETE", + "OES_element_index_uint", + "OES_standard_derivatives", + "OES_texture_float", + "OES_texture_float_linear", + "OK", + "ONE", + "ONE_MINUS_CONSTANT_ALPHA", + "ONE_MINUS_CONSTANT_COLOR", + "ONE_MINUS_DST_ALPHA", + "ONE_MINUS_DST_COLOR", + "ONE_MINUS_SRC_ALPHA", + "ONE_MINUS_SRC_COLOR", + "OPEN", + "OPENBSD", + "OPENED", + "OPENING", + "ORDERED_NODE_ITERATOR_TYPE", + "ORDERED_NODE_SNAPSHOT_TYPE", + "OS_UPDATE", + "OTHER_ERROR", + "OUT_OF_MEMORY", + "Object", + "OfflineAudioCompletionEvent", + "OfflineAudioContext", + "OfflineResourceList", + "OffscreenCanvas", + "OffscreenCanvasRenderingContext2D", + "OnInstalledReason", + "OnRestartRequiredReason", + "Option", + "OrientationSensor", + "OscillatorNode", + "OverconstrainedError", + "OverconstrainedErrorEvent", + "OverflowEvent", + "PACKAGE", + "PACK_ALIGNMENT", + "PACK_ROW_LENGTH", + "PACK_SKIP_PIXELS", + "PACK_SKIP_ROWS", + "PAGE_RULE", + "PARSE_ERR", + "PATHSEG_ARC_ABS", + "PATHSEG_ARC_REL", + "PATHSEG_CLOSEPATH", + "PATHSEG_CURVETO_CUBIC_ABS", + "PATHSEG_CURVETO_CUBIC_REL", + "PATHSEG_CURVETO_CUBIC_SMOOTH_ABS", + "PATHSEG_CURVETO_CUBIC_SMOOTH_REL", + "PATHSEG_CURVETO_QUADRATIC_ABS", + "PATHSEG_CURVETO_QUADRATIC_REL", + "PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS", + "PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL", + "PATHSEG_LINETO_ABS", + "PATHSEG_LINETO_HORIZONTAL_ABS", + "PATHSEG_LINETO_HORIZONTAL_REL", + "PATHSEG_LINETO_REL", + "PATHSEG_LINETO_VERTICAL_ABS", + "PATHSEG_LINETO_VERTICAL_REL", + "PATHSEG_MOVETO_ABS", + "PATHSEG_MOVETO_REL", + "PATHSEG_UNKNOWN", + "PATH_EXISTS_ERR", + "PEAKING", + "PERIODIC", + "PERMISSION_DENIED", + "PERSISTENT", + "PI", + "PIXEL_PACK_BUFFER", + "PIXEL_PACK_BUFFER_BINDING", + "PIXEL_UNPACK_BUFFER", + "PIXEL_UNPACK_BUFFER_BINDING", + "PLAYING_STATE", + "POINTS", + "POLYGON_OFFSET_FACTOR", + "POLYGON_OFFSET_FILL", + "POLYGON_OFFSET_UNITS", + "POSITION_UNAVAILABLE", + "POSITIVE_INFINITY", + "PREV", + "PREV_NO_DUPLICATE", + "PROCESSING_INSTRUCTION_NODE", + "PageChangeEvent", + "PageTransitionEvent", + "PaintRequest", + "PaintRequestList", + "PannerNode", + "PasswordCredential", + "Path2D", + "PaymentAddress", + "PaymentInstruments", + "PaymentManager", + "PaymentMethodChangeEvent", + "PaymentRequest", + "PaymentRequestUpdateEvent", + "PaymentResponse", + "Performance", + "PerformanceElementTiming", + "PerformanceEntry", + "PerformanceEventTiming", + "PerformanceLongTaskTiming", + "PerformanceMark", + "PerformanceMeasure", + "PerformanceNavigation", + "PerformanceNavigationTiming", + "PerformanceObserver", + "PerformanceObserverEntryList", + "PerformancePaintTiming", + "PerformanceResourceTiming", + "PerformanceServerTiming", + "PerformanceTiming", + "PeriodicSyncManager", + "PeriodicWave", + "PermissionStatus", + "Permissions", + "PhotoCapabilities", + "PictureInPictureWindow", + "PlatformArch", + "PlatformNaclArch", + "PlatformOs", + "Plugin", + "PluginArray", + "PluralRules", + "PointerEvent", + "PopStateEvent", + "PopupBlockedEvent", + "Position", + "PositionError", + "Presentation", + "PresentationAvailability", + "PresentationConnection", + "PresentationConnectionAvailableEvent", + "PresentationConnectionCloseEvent", + "PresentationConnectionList", + "PresentationReceiver", + "PresentationRequest", + "ProcessingInstruction", + "ProgressEvent", + "Promise", + "PromiseRejectionEvent", + "PropertyNodeList", + "Proxy", + "PublicKeyCredential", + "PushManager", + "PushSubscription", + "PushSubscriptionOptions", + "Q", + "QUERY_RESULT", + "QUERY_RESULT_AVAILABLE", + "QUOTA_ERR", + "QUOTA_EXCEEDED_ERR", + "QueryInterface", + "R11F_G11F_B10F", + "R16F", + "R16I", + "R16UI", + "R32F", + "R32I", + "R32UI", + "R8", + "R8I", + "R8UI", + "R8_SNORM", + "RASTERIZER_DISCARD", + "READY_TO_RUN", + "READ_BUFFER", + "READ_FRAMEBUFFER", + "READ_FRAMEBUFFER_BINDING", + "READ_ONLY", + "READ_ONLY_ERR", + "READ_WRITE", + "RED", + "RED_BITS", + "RED_INTEGER", + "REMOVAL", + "RENDERBUFFER", + "RENDERBUFFER_ALPHA_SIZE", + "RENDERBUFFER_BINDING", + "RENDERBUFFER_BLUE_SIZE", + "RENDERBUFFER_DEPTH_SIZE", + "RENDERBUFFER_GREEN_SIZE", + "RENDERBUFFER_HEIGHT", + "RENDERBUFFER_INTERNAL_FORMAT", + "RENDERBUFFER_RED_SIZE", + "RENDERBUFFER_SAMPLES", + "RENDERBUFFER_STENCIL_SIZE", + "RENDERBUFFER_WIDTH", + "RENDERER", + "RENDERING_INTENT_ABSOLUTE_COLORIMETRIC", + "RENDERING_INTENT_AUTO", + "RENDERING_INTENT_PERCEPTUAL", + "RENDERING_INTENT_RELATIVE_COLORIMETRIC", + "RENDERING_INTENT_SATURATION", + "RENDERING_INTENT_UNKNOWN", + "REPEAT", + "REPLACE", + "RG", + "RG16F", + "RG16I", + "RG16UI", + "RG32F", + "RG32I", + "RG32UI", + "RG8", + "RG8I", + "RG8UI", + "RG8_SNORM", + "RGB", + "RGB10_A2", + "RGB10_A2UI", + "RGB16F", + "RGB16I", + "RGB16UI", + "RGB32F", + "RGB32I", + "RGB32UI", + "RGB565", + "RGB5_A1", + "RGB8", + "RGB8I", + "RGB8UI", + "RGB8_SNORM", + "RGB9_E5", + "RGBA", + "RGBA16F", + "RGBA16I", + "RGBA16UI", + "RGBA32F", + "RGBA32I", + "RGBA32UI", + "RGBA4", + "RGBA8", + "RGBA8I", + "RGBA8UI", + "RGBA8_SNORM", + "RGBA_INTEGER", + "RGBColor", + "RGB_INTEGER", + "RG_INTEGER", + "ROTATION_CLOCKWISE", + "ROTATION_COUNTERCLOCKWISE", + "RTCCertificate", + "RTCDTMFSender", + "RTCDTMFToneChangeEvent", + "RTCDataChannel", + "RTCDataChannelEvent", + "RTCDtlsTransport", + "RTCError", + "RTCErrorEvent", + "RTCIceCandidate", + "RTCIceTransport", + "RTCPeerConnection", + "RTCPeerConnectionIceErrorEvent", + "RTCPeerConnectionIceEvent", + "RTCRtpReceiver", + "RTCRtpSender", + "RTCRtpTransceiver", + "RTCSctpTransport", + "RTCSessionDescription", + "RTCStatsReport", + "RTCTrackEvent", + "RUNNING", + "RadioNodeList", + "Range", + "RangeError", + "RangeException", + "ReadableByteStream", + "ReadableStream", + "ReadableStreamDefaultReader", + "RecordErrorEvent", + "Rect", + "ReferenceError", + "Reflect", + "RegExp", + "RelativeOrientationSensor", + "RelativeTimeFormat", + "RemotePlayback", + "ReportingObserver", + "Request", + "RequestUpdateCheckStatus", + "ResizeObserver", + "ResizeObserverEntry", + "ResizeObserverSize", + "Response", + "RunningState", + "RuntimeError", + "SAMPLER_2D", + "SAMPLER_2D_ARRAY", + "SAMPLER_2D_ARRAY_SHADOW", + "SAMPLER_2D_SHADOW", + "SAMPLER_3D", + "SAMPLER_BINDING", + "SAMPLER_CUBE", + "SAMPLER_CUBE_SHADOW", + "SAMPLES", + "SAMPLE_ALPHA_TO_COVERAGE", + "SAMPLE_BUFFERS", + "SAMPLE_COVERAGE", + "SAMPLE_COVERAGE_INVERT", + "SAMPLE_COVERAGE_VALUE", + "SAWTOOTH", + "SCHEDULED_STATE", + "SCISSOR_BOX", + "SCISSOR_TEST", + "SCROLL_PAGE_DOWN", + "SCROLL_PAGE_UP", + "SDP_ANSWER", + "SDP_OFFER", + "SDP_PRANSWER", + "SECURITY_ERR", + "SELECT", + "SEPARATE_ATTRIBS", + "SERIALIZE_ERR", + "SEVERITY_ERROR", + "SEVERITY_FATAL_ERROR", + "SEVERITY_WARNING", + "SHADER_COMPILER", + "SHADER_TYPE", + "SHADING_LANGUAGE_VERSION", + "SHARED_MODULE_UPDATE", + "SHIFT_MASK", + "SHORT", + "SHOWING", + "SHOW_ALL", + "SHOW_ATTRIBUTE", + "SHOW_CDATA_SECTION", + "SHOW_COMMENT", + "SHOW_DOCUMENT", + "SHOW_DOCUMENT_FRAGMENT", + "SHOW_DOCUMENT_TYPE", + "SHOW_ELEMENT", + "SHOW_ENTITY", + "SHOW_ENTITY_REFERENCE", + "SHOW_NOTATION", + "SHOW_PROCESSING_INSTRUCTION", + "SHOW_TEXT", + "SIGNALED", + "SIGNED_NORMALIZED", + "SINE", + "SKIN", + "SOUNDFIELD", + "SQLError", + "SQLException", + "SQLResultSet", + "SQLResultSetRowList", + "SQLTransaction", + "SQRT1_2", + "SQRT2", + "SQUARE", + "SRC_ALPHA", + "SRC_ALPHA_SATURATE", + "SRC_COLOR", + "SRGB", + "SRGB8", + "SRGB8_ALPHA8", + "START_TO_END", + "START_TO_START", + "STATIC_COPY", + "STATIC_DRAW", + "STATIC_READ", + "STENCIL", + "STENCIL_ATTACHMENT", + "STENCIL_BACK_FAIL", + "STENCIL_BACK_FUNC", + "STENCIL_BACK_PASS_DEPTH_FAIL", + "STENCIL_BACK_PASS_DEPTH_PASS", + "STENCIL_BACK_REF", + "STENCIL_BACK_VALUE_MASK", + "STENCIL_BACK_WRITEMASK", + "STENCIL_BITS", + "STENCIL_BUFFER_BIT", + "STENCIL_CLEAR_VALUE", + "STENCIL_FAIL", + "STENCIL_FUNC", + "STENCIL_INDEX", + "STENCIL_INDEX8", + "STENCIL_PASS_DEPTH_FAIL", + "STENCIL_PASS_DEPTH_PASS", + "STENCIL_REF", + "STENCIL_TEST", + "STENCIL_VALUE_MASK", + "STENCIL_WRITEMASK", + "STREAM_COPY", + "STREAM_DRAW", + "STREAM_READ", + "STRING_TYPE", + "STYLE_RULE", + "SUBPIXEL_BITS", + "SUPPORTS_RULE", + "SVGAElement", + "SVGAltGlyphDefElement", + "SVGAltGlyphElement", + "SVGAltGlyphItemElement", + "SVGAngle", + "SVGAnimateColorElement", + "SVGAnimateElement", + "SVGAnimateMotionElement", + "SVGAnimateTransformElement", + "SVGAnimatedAngle", + "SVGAnimatedBoolean", + "SVGAnimatedEnumeration", + "SVGAnimatedInteger", + "SVGAnimatedLength", + "SVGAnimatedLengthList", + "SVGAnimatedNumber", + "SVGAnimatedNumberList", + "SVGAnimatedPreserveAspectRatio", + "SVGAnimatedRect", + "SVGAnimatedString", + "SVGAnimatedTransformList", + "SVGAnimationElement", + "SVGCircleElement", + "SVGClipPathElement", + "SVGColor", + "SVGComponentTransferFunctionElement", + "SVGCursorElement", + "SVGDefsElement", + "SVGDescElement", + "SVGDiscardElement", + "SVGDocument", + "SVGElement", + "SVGElementInstance", + "SVGElementInstanceList", + "SVGEllipseElement", + "SVGException", + "SVGFEBlendElement", + "SVGFEColorMatrixElement", + "SVGFEComponentTransferElement", + "SVGFECompositeElement", + "SVGFEConvolveMatrixElement", + "SVGFEDiffuseLightingElement", + "SVGFEDisplacementMapElement", + "SVGFEDistantLightElement", + "SVGFEDropShadowElement", + "SVGFEFloodElement", + "SVGFEFuncAElement", + "SVGFEFuncBElement", + "SVGFEFuncGElement", + "SVGFEFuncRElement", + "SVGFEGaussianBlurElement", + "SVGFEImageElement", + "SVGFEMergeElement", + "SVGFEMergeNodeElement", + "SVGFEMorphologyElement", + "SVGFEOffsetElement", + "SVGFEPointLightElement", + "SVGFESpecularLightingElement", + "SVGFESpotLightElement", + "SVGFETileElement", + "SVGFETurbulenceElement", + "SVGFilterElement", + "SVGFontElement", + "SVGFontFaceElement", + "SVGFontFaceFormatElement", + "SVGFontFaceNameElement", + "SVGFontFaceSrcElement", + "SVGFontFaceUriElement", + "SVGForeignObjectElement", + "SVGGElement", + "SVGGeometryElement", + "SVGGlyphElement", + "SVGGlyphRefElement", + "SVGGradientElement", + "SVGGraphicsElement", + "SVGHKernElement", + "SVGImageElement", + "SVGLength", + "SVGLengthList", + "SVGLineElement", + "SVGLinearGradientElement", + "SVGMPathElement", + "SVGMarkerElement", + "SVGMaskElement", + "SVGMatrix", + "SVGMetadataElement", + "SVGMissingGlyphElement", + "SVGNumber", + "SVGNumberList", + "SVGPaint", + "SVGPathElement", + "SVGPathSeg", + "SVGPathSegArcAbs", + "SVGPathSegArcRel", + "SVGPathSegClosePath", + "SVGPathSegCurvetoCubicAbs", + "SVGPathSegCurvetoCubicRel", + "SVGPathSegCurvetoCubicSmoothAbs", + "SVGPathSegCurvetoCubicSmoothRel", + "SVGPathSegCurvetoQuadraticAbs", + "SVGPathSegCurvetoQuadraticRel", + "SVGPathSegCurvetoQuadraticSmoothAbs", + "SVGPathSegCurvetoQuadraticSmoothRel", + "SVGPathSegLinetoAbs", + "SVGPathSegLinetoHorizontalAbs", + "SVGPathSegLinetoHorizontalRel", + "SVGPathSegLinetoRel", + "SVGPathSegLinetoVerticalAbs", + "SVGPathSegLinetoVerticalRel", + "SVGPathSegList", + "SVGPathSegMovetoAbs", + "SVGPathSegMovetoRel", + "SVGPatternElement", + "SVGPoint", + "SVGPointList", + "SVGPolygonElement", + "SVGPolylineElement", + "SVGPreserveAspectRatio", + "SVGRadialGradientElement", + "SVGRect", + "SVGRectElement", + "SVGRenderingIntent", + "SVGSVGElement", + "SVGScriptElement", + "SVGSetElement", + "SVGStopElement", + "SVGStringList", + "SVGStyleElement", + "SVGSwitchElement", + "SVGSymbolElement", + "SVGTRefElement", + "SVGTSpanElement", + "SVGTextContentElement", + "SVGTextElement", + "SVGTextPathElement", + "SVGTextPositioningElement", + "SVGTitleElement", + "SVGTransform", + "SVGTransformList", + "SVGUnitTypes", + "SVGUseElement", + "SVGVKernElement", + "SVGViewElement", + "SVGViewSpec", + "SVGZoomAndPan", + "SVGZoomEvent", + "SVG_ANGLETYPE_DEG", + "SVG_ANGLETYPE_GRAD", + "SVG_ANGLETYPE_RAD", + "SVG_ANGLETYPE_UNKNOWN", + "SVG_ANGLETYPE_UNSPECIFIED", + "SVG_CHANNEL_A", + "SVG_CHANNEL_B", + "SVG_CHANNEL_G", + "SVG_CHANNEL_R", + "SVG_CHANNEL_UNKNOWN", + "SVG_COLORTYPE_CURRENTCOLOR", + "SVG_COLORTYPE_RGBCOLOR", + "SVG_COLORTYPE_RGBCOLOR_ICCCOLOR", + "SVG_COLORTYPE_UNKNOWN", + "SVG_EDGEMODE_DUPLICATE", + "SVG_EDGEMODE_NONE", + "SVG_EDGEMODE_UNKNOWN", + "SVG_EDGEMODE_WRAP", + "SVG_FEBLEND_MODE_COLOR", + "SVG_FEBLEND_MODE_COLOR_BURN", + "SVG_FEBLEND_MODE_COLOR_DODGE", + "SVG_FEBLEND_MODE_DARKEN", + "SVG_FEBLEND_MODE_DIFFERENCE", + "SVG_FEBLEND_MODE_EXCLUSION", + "SVG_FEBLEND_MODE_HARD_LIGHT", + "SVG_FEBLEND_MODE_HUE", + "SVG_FEBLEND_MODE_LIGHTEN", + "SVG_FEBLEND_MODE_LUMINOSITY", + "SVG_FEBLEND_MODE_MULTIPLY", + "SVG_FEBLEND_MODE_NORMAL", + "SVG_FEBLEND_MODE_OVERLAY", + "SVG_FEBLEND_MODE_SATURATION", + "SVG_FEBLEND_MODE_SCREEN", + "SVG_FEBLEND_MODE_SOFT_LIGHT", + "SVG_FEBLEND_MODE_UNKNOWN", + "SVG_FECOLORMATRIX_TYPE_HUEROTATE", + "SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA", + "SVG_FECOLORMATRIX_TYPE_MATRIX", + "SVG_FECOLORMATRIX_TYPE_SATURATE", + "SVG_FECOLORMATRIX_TYPE_UNKNOWN", + "SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE", + "SVG_FECOMPONENTTRANSFER_TYPE_GAMMA", + "SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY", + "SVG_FECOMPONENTTRANSFER_TYPE_LINEAR", + "SVG_FECOMPONENTTRANSFER_TYPE_TABLE", + "SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN", + "SVG_FECOMPOSITE_OPERATOR_ARITHMETIC", + "SVG_FECOMPOSITE_OPERATOR_ATOP", + "SVG_FECOMPOSITE_OPERATOR_IN", + "SVG_FECOMPOSITE_OPERATOR_OUT", + "SVG_FECOMPOSITE_OPERATOR_OVER", + "SVG_FECOMPOSITE_OPERATOR_UNKNOWN", + "SVG_FECOMPOSITE_OPERATOR_XOR", + "SVG_INVALID_VALUE_ERR", + "SVG_LENGTHTYPE_CM", + "SVG_LENGTHTYPE_EMS", + "SVG_LENGTHTYPE_EXS", + "SVG_LENGTHTYPE_IN", + "SVG_LENGTHTYPE_MM", + "SVG_LENGTHTYPE_NUMBER", + "SVG_LENGTHTYPE_PC", + "SVG_LENGTHTYPE_PERCENTAGE", + "SVG_LENGTHTYPE_PT", + "SVG_LENGTHTYPE_PX", + "SVG_LENGTHTYPE_UNKNOWN", + "SVG_MARKERUNITS_STROKEWIDTH", + "SVG_MARKERUNITS_UNKNOWN", + "SVG_MARKERUNITS_USERSPACEONUSE", + "SVG_MARKER_ORIENT_ANGLE", + "SVG_MARKER_ORIENT_AUTO", + "SVG_MARKER_ORIENT_UNKNOWN", + "SVG_MASKTYPE_ALPHA", + "SVG_MASKTYPE_LUMINANCE", + "SVG_MATRIX_NOT_INVERTABLE", + "SVG_MEETORSLICE_MEET", + "SVG_MEETORSLICE_SLICE", + "SVG_MEETORSLICE_UNKNOWN", + "SVG_MORPHOLOGY_OPERATOR_DILATE", + "SVG_MORPHOLOGY_OPERATOR_ERODE", + "SVG_MORPHOLOGY_OPERATOR_UNKNOWN", + "SVG_PAINTTYPE_CURRENTCOLOR", + "SVG_PAINTTYPE_NONE", + "SVG_PAINTTYPE_RGBCOLOR", + "SVG_PAINTTYPE_RGBCOLOR_ICCCOLOR", + "SVG_PAINTTYPE_UNKNOWN", + "SVG_PAINTTYPE_URI", + "SVG_PAINTTYPE_URI_CURRENTCOLOR", + "SVG_PAINTTYPE_URI_NONE", + "SVG_PAINTTYPE_URI_RGBCOLOR", + "SVG_PAINTTYPE_URI_RGBCOLOR_ICCCOLOR", + "SVG_PRESERVEASPECTRATIO_NONE", + "SVG_PRESERVEASPECTRATIO_UNKNOWN", + "SVG_PRESERVEASPECTRATIO_XMAXYMAX", + "SVG_PRESERVEASPECTRATIO_XMAXYMID", + "SVG_PRESERVEASPECTRATIO_XMAXYMIN", + "SVG_PRESERVEASPECTRATIO_XMIDYMAX", + "SVG_PRESERVEASPECTRATIO_XMIDYMID", + "SVG_PRESERVEASPECTRATIO_XMIDYMIN", + "SVG_PRESERVEASPECTRATIO_XMINYMAX", + "SVG_PRESERVEASPECTRATIO_XMINYMID", + "SVG_PRESERVEASPECTRATIO_XMINYMIN", + "SVG_SPREADMETHOD_PAD", + "SVG_SPREADMETHOD_REFLECT", + "SVG_SPREADMETHOD_REPEAT", + "SVG_SPREADMETHOD_UNKNOWN", + "SVG_STITCHTYPE_NOSTITCH", + "SVG_STITCHTYPE_STITCH", + "SVG_STITCHTYPE_UNKNOWN", + "SVG_TRANSFORM_MATRIX", + "SVG_TRANSFORM_ROTATE", + "SVG_TRANSFORM_SCALE", + "SVG_TRANSFORM_SKEWX", + "SVG_TRANSFORM_SKEWY", + "SVG_TRANSFORM_TRANSLATE", + "SVG_TRANSFORM_UNKNOWN", + "SVG_TURBULENCE_TYPE_FRACTALNOISE", + "SVG_TURBULENCE_TYPE_TURBULENCE", + "SVG_TURBULENCE_TYPE_UNKNOWN", + "SVG_UNIT_TYPE_OBJECTBOUNDINGBOX", + "SVG_UNIT_TYPE_UNKNOWN", + "SVG_UNIT_TYPE_USERSPACEONUSE", + "SVG_WRONG_TYPE_ERR", + "SVG_ZOOMANDPAN_DISABLE", + "SVG_ZOOMANDPAN_MAGNIFY", + "SVG_ZOOMANDPAN_UNKNOWN", + "SYNC_CONDITION", + "SYNC_FENCE", + "SYNC_FLAGS", + "SYNC_FLUSH_COMMANDS_BIT", + "SYNC_GPU_COMMANDS_COMPLETE", + "SYNC_STATUS", + "SYNTAX_ERR", + "SavedPages", + "Screen", + "ScreenOrientation", + "Script", + "ScriptEngine", + "ScriptEngineBuildVersion", + "ScriptEngineMajorVersion", + "ScriptEngineMinorVersion", + "ScriptProcessorNode", + "ScrollAreaEvent", + "SecurityPolicyViolationEvent", + "Selection", + "Sensor", + "SensorErrorEvent", + "ServiceWorker", + "ServiceWorkerContainer", + "ServiceWorkerMessageEvent", + "ServiceWorkerRegistration", + "SessionDescription", + "Set", + "ShadowRoot", + "SharedArrayBuffer", + "SharedWorker", + "SimpleGestureEvent", + "SourceBuffer", + "SourceBufferList", + "SpeechSynthesis", + "SpeechSynthesisErrorEvent", + "SpeechSynthesisEvent", + "SpeechSynthesisUtterance", + "SpeechSynthesisVoice", + "StaticRange", + "StereoPannerNode", + "StopIteration", + "Storage", + "StorageEvent", + "StorageManager", + "String", + "StyleMedia", + "StylePropertyMap", + "StylePropertyMapReadOnly", + "StyleSheet", + "StyleSheetList", + "StyleSheetPageList", + "SubmitEvent", + "SubtleCrypto", + "Symbol", + "SyncManager", + "SyntaxError", + "TEMPORARY", + "TEXTPATH_METHODTYPE_ALIGN", + "TEXTPATH_METHODTYPE_STRETCH", + "TEXTPATH_METHODTYPE_UNKNOWN", + "TEXTPATH_SPACINGTYPE_AUTO", + "TEXTPATH_SPACINGTYPE_EXACT", + "TEXTPATH_SPACINGTYPE_UNKNOWN", + "TEXTURE", + "TEXTURE0", + "TEXTURE1", + "TEXTURE10", + "TEXTURE11", + "TEXTURE12", + "TEXTURE13", + "TEXTURE14", + "TEXTURE15", + "TEXTURE16", + "TEXTURE17", + "TEXTURE18", + "TEXTURE19", + "TEXTURE2", + "TEXTURE20", + "TEXTURE21", + "TEXTURE22", + "TEXTURE23", + "TEXTURE24", + "TEXTURE25", + "TEXTURE26", + "TEXTURE27", + "TEXTURE28", + "TEXTURE29", + "TEXTURE3", + "TEXTURE30", + "TEXTURE31", + "TEXTURE4", + "TEXTURE5", + "TEXTURE6", + "TEXTURE7", + "TEXTURE8", + "TEXTURE9", + "TEXTURE_2D", + "TEXTURE_2D_ARRAY", + "TEXTURE_3D", + "TEXTURE_BASE_LEVEL", + "TEXTURE_BINDING_2D", + "TEXTURE_BINDING_2D_ARRAY", + "TEXTURE_BINDING_3D", + "TEXTURE_BINDING_CUBE_MAP", + "TEXTURE_COMPARE_FUNC", + "TEXTURE_COMPARE_MODE", + "TEXTURE_CUBE_MAP", + "TEXTURE_CUBE_MAP_NEGATIVE_X", + "TEXTURE_CUBE_MAP_NEGATIVE_Y", + "TEXTURE_CUBE_MAP_NEGATIVE_Z", + "TEXTURE_CUBE_MAP_POSITIVE_X", + "TEXTURE_CUBE_MAP_POSITIVE_Y", + "TEXTURE_CUBE_MAP_POSITIVE_Z", + "TEXTURE_IMMUTABLE_FORMAT", + "TEXTURE_IMMUTABLE_LEVELS", + "TEXTURE_MAG_FILTER", + "TEXTURE_MAX_ANISOTROPY_EXT", + "TEXTURE_MAX_LEVEL", + "TEXTURE_MAX_LOD", + "TEXTURE_MIN_FILTER", + "TEXTURE_MIN_LOD", + "TEXTURE_WRAP_R", + "TEXTURE_WRAP_S", + "TEXTURE_WRAP_T", + "TEXT_NODE", + "THROTTLED", + "TIMEOUT", + "TIMEOUT_ERR", + "TIMEOUT_EXPIRED", + "TIMEOUT_IGNORED", + "TOO_LARGE_ERR", + "TRANSACTION_INACTIVE_ERR", + "TRANSFORM_FEEDBACK", + "TRANSFORM_FEEDBACK_ACTIVE", + "TRANSFORM_FEEDBACK_BINDING", + "TRANSFORM_FEEDBACK_BUFFER", + "TRANSFORM_FEEDBACK_BUFFER_BINDING", + "TRANSFORM_FEEDBACK_BUFFER_MODE", + "TRANSFORM_FEEDBACK_BUFFER_SIZE", + "TRANSFORM_FEEDBACK_BUFFER_START", + "TRANSFORM_FEEDBACK_PAUSED", + "TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN", + "TRANSFORM_FEEDBACK_VARYINGS", + "TRIANGLE", + "TRIANGLES", + "TRIANGLE_FAN", + "TRIANGLE_STRIP", + "TYPE_BACK_FORWARD", + "TYPE_ERR", + "TYPE_MISMATCH_ERR", + "TYPE_NAVIGATE", + "TYPE_RELOAD", + "TYPE_RESERVED", + "Table", + "TaskAttributionTiming", + "Text", + "TextDecoder", + "TextDecoderStream", + "TextEncoder", + "TextEncoderStream", + "TextEvent", + "TextMetrics", + "TextRange", + "TextRangeCollection", + "TextTrack", + "TextTrackCue", + "TextTrackCueList", + "TextTrackList", + "TimeEvent", + "TimeRanges", + "Touch", + "TouchEvent", + "TouchList", + "TrackEvent", + "TransformStream", + "TransitionEvent", + "TreeWalker", + "TrustedHTML", + "TrustedScript", + "TrustedScriptURL", + "TrustedTypePolicy", + "TrustedTypePolicyFactory", + "TypeError", + "U2F", + "UIEvent", + "UNCACHED", + "UNIFORM_ARRAY_STRIDE", + "UNIFORM_BLOCK_ACTIVE_UNIFORMS", + "UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES", + "UNIFORM_BLOCK_BINDING", + "UNIFORM_BLOCK_DATA_SIZE", + "UNIFORM_BLOCK_INDEX", + "UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER", + "UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER", + "UNIFORM_BUFFER", + "UNIFORM_BUFFER_BINDING", + "UNIFORM_BUFFER_OFFSET_ALIGNMENT", + "UNIFORM_BUFFER_SIZE", + "UNIFORM_BUFFER_START", + "UNIFORM_IS_ROW_MAJOR", + "UNIFORM_MATRIX_STRIDE", + "UNIFORM_OFFSET", + "UNIFORM_SIZE", + "UNIFORM_TYPE", + "UNKNOWN_ERR", + "UNKNOWN_RULE", + "UNMASKED_RENDERER_WEBGL", + "UNMASKED_VENDOR_WEBGL", + "UNORDERED_NODE_ITERATOR_TYPE", + "UNORDERED_NODE_SNAPSHOT_TYPE", + "UNPACK_ALIGNMENT", + "UNPACK_COLORSPACE_CONVERSION_WEBGL", + "UNPACK_FLIP_Y_WEBGL", + "UNPACK_IMAGE_HEIGHT", + "UNPACK_PREMULTIPLY_ALPHA_WEBGL", + "UNPACK_ROW_LENGTH", + "UNPACK_SKIP_IMAGES", + "UNPACK_SKIP_PIXELS", + "UNPACK_SKIP_ROWS", + "UNSCHEDULED_STATE", + "UNSENT", + "UNSIGNALED", + "UNSIGNED_BYTE", + "UNSIGNED_INT", + "UNSIGNED_INT_10F_11F_11F_REV", + "UNSIGNED_INT_24_8", + "UNSIGNED_INT_2_10_10_10_REV", + "UNSIGNED_INT_5_9_9_9_REV", + "UNSIGNED_INT_SAMPLER_2D", + "UNSIGNED_INT_SAMPLER_2D_ARRAY", + "UNSIGNED_INT_SAMPLER_3D", + "UNSIGNED_INT_SAMPLER_CUBE", + "UNSIGNED_INT_VEC2", + "UNSIGNED_INT_VEC3", + "UNSIGNED_INT_VEC4", + "UNSIGNED_NORMALIZED", + "UNSIGNED_SHORT", + "UNSIGNED_SHORT_4_4_4_4", + "UNSIGNED_SHORT_5_5_5_1", + "UNSIGNED_SHORT_5_6_5", + "UNSPECIFIED_EVENT_TYPE_ERR", + "UPDATE", + "UPDATEREADY", + "UPDATE_AVAILABLE", + "URIError", + "URL", + "URLSearchParams", + "URLUnencoded", + "URL_MISMATCH_ERR", + "USB", + "USBAlternateInterface", + "USBConfiguration", + "USBConnectionEvent", + "USBDevice", + "USBEndpoint", + "USBInTransferResult", + "USBInterface", + "USBIsochronousInTransferPacket", + "USBIsochronousInTransferResult", + "USBIsochronousOutTransferPacket", + "USBIsochronousOutTransferResult", + "USBOutTransferResult", + "UTC", + "Uint16Array", + "Uint32Array", + "Uint8Array", + "Uint8ClampedArray", + "UserActivation", + "UserMessageHandler", + "UserMessageHandlersNamespace", + "UserProximityEvent", + "VALIDATE_STATUS", + "VALIDATION_ERR", + "VARIABLES_RULE", + "VBArray", + "VENDOR", + "VERSION", + "VERSION_CHANGE", + "VERSION_ERR", + "VERTEX_ARRAY_BINDING", + "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING", + "VERTEX_ATTRIB_ARRAY_DIVISOR", + "VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE", + "VERTEX_ATTRIB_ARRAY_ENABLED", + "VERTEX_ATTRIB_ARRAY_INTEGER", + "VERTEX_ATTRIB_ARRAY_NORMALIZED", + "VERTEX_ATTRIB_ARRAY_POINTER", + "VERTEX_ATTRIB_ARRAY_SIZE", + "VERTEX_ATTRIB_ARRAY_STRIDE", + "VERTEX_ATTRIB_ARRAY_TYPE", + "VERTEX_SHADER", + "VERTICAL", + "VERTICAL_AXIS", + "VER_ERR", + "VIEWPORT", + "VIEWPORT_RULE", + "VRDisplay", + "VRDisplayCapabilities", + "VRDisplayEvent", + "VREyeParameters", + "VRFieldOfView", + "VRFrameData", + "VRPose", + "VRStageParameters", + "VTTCue", + "VTTRegion", + "ValidityState", + "VideoPlaybackQuality", + "VideoStreamTrack", + "VideoTrack", + "VideoTrackList", + "VisualViewport", + "WAIT_FAILED", + "WEBGL_compressed_texture_s3tc", + "WEBGL_debug_renderer_info", + "WEBKIT_FILTER_RULE", + "WEBKIT_FORCE_AT_FORCE_MOUSE_DOWN", + "WEBKIT_FORCE_AT_MOUSE_DOWN", + "WEBKIT_KEYFRAMES_RULE", + "WEBKIT_KEYFRAME_RULE", + "WEBKIT_REGION_RULE", + "WIN", + "WRONG_DOCUMENT_ERR", + "WakeLock", + "WakeLockSentinel", + "WaveShaperNode", + "WeakMap", + "WeakRef", + "WeakSet", + "WebAssembly", + "WebGL2RenderingContext", + "WebGLActiveInfo", + "WebGLBuffer", + "WebGLContextEvent", + "WebGLFramebuffer", + "WebGLObject", + "WebGLProgram", + "WebGLQuery", + "WebGLRenderbuffer", + "WebGLRenderingContext", + "WebGLSampler", + "WebGLShader", + "WebGLShaderPrecisionFormat", + "WebGLSync", + "WebGLTexture", + "WebGLTransformFeedback", + "WebGLUniformLocation", + "WebGLVertexArray", + "WebGLVertexArrayObject", + "WebKit built-in PDF", + "WebKitAnimationEvent", + "WebKitBlobBuilder", + "WebKitCSSFilterRule", + "WebKitCSSFilterValue", + "WebKitCSSKeyframeRule", + "WebKitCSSKeyframesRule", + "WebKitCSSMatrix", + "WebKitCSSRegionRule", + "WebKitCSSTransformValue", + "WebKitDataCue", + "WebKitGamepad", + "WebKitMediaKeyError", + "WebKitMediaKeyMessageEvent", + "WebKitMediaKeyNeededEvent", + "WebKitMediaKeySession", + "WebKitMediaKeys", + "WebKitMediaSource", + "WebKitMutationObserver", + "WebKitNamespace", + "WebKitPlaybackTargetAvailabilityEvent", + "WebKitPoint", + "WebKitShadowRoot", + "WebKitSourceBuffer", + "WebKitSourceBufferList", + "WebKitTransitionEvent", + "WebSocket", + "WebkitAlignContent", + "WebkitAlignItems", + "WebkitAlignSelf", + "WebkitAnimation", + "WebkitAnimationDelay", + "WebkitAnimationDirection", + "WebkitAnimationDuration", + "WebkitAnimationFillMode", + "WebkitAnimationIterationCount", + "WebkitAnimationName", + "WebkitAnimationPlayState", + "WebkitAnimationTimingFunction", + "WebkitAppearance", + "WebkitBackfaceVisibility", + "WebkitBackgroundClip", + "WebkitBackgroundOrigin", + "WebkitBackgroundSize", + "WebkitBorderBottomLeftRadius", + "WebkitBorderBottomRightRadius", + "WebkitBorderImage", + "WebkitBorderRadius", + "WebkitBorderTopLeftRadius", + "WebkitBorderTopRightRadius", + "WebkitBoxAlign", + "WebkitBoxDirection", + "WebkitBoxFlex", + "WebkitBoxOrdinalGroup", + "WebkitBoxOrient", + "WebkitBoxPack", + "WebkitBoxShadow", + "WebkitBoxSizing", + "WebkitFilter", + "WebkitFlex", + "WebkitFlexBasis", + "WebkitFlexDirection", + "WebkitFlexFlow", + "WebkitFlexGrow", + "WebkitFlexShrink", + "WebkitFlexWrap", + "WebkitJustifyContent", + "WebkitLineClamp", + "WebkitMask", + "WebkitMaskClip", + "WebkitMaskComposite", + "WebkitMaskImage", + "WebkitMaskOrigin", + "WebkitMaskPosition", + "WebkitMaskPositionX", + "WebkitMaskPositionY", + "WebkitMaskRepeat", + "WebkitMaskSize", + "WebkitOrder", + "WebkitPerspective", + "WebkitPerspectiveOrigin", + "WebkitTextFillColor", + "WebkitTextSizeAdjust", + "WebkitTextStroke", + "WebkitTextStrokeColor", + "WebkitTextStrokeWidth", + "WebkitTransform", + "WebkitTransformOrigin", + "WebkitTransformStyle", + "WebkitTransition", + "WebkitTransitionDelay", + "WebkitTransitionDuration", + "WebkitTransitionProperty", + "WebkitTransitionTimingFunction", + "WebkitUserSelect", + "WheelEvent", + "Window", + "Windows Media Player Plug-in Dynamic Link Library", + "Windows Presentation Foundation", + "Worker", + "Worklet", + "WritableStream", + "WritableStreamDefaultWriter", + "X86_32", + "X86_64", + "XMLDocument", + "XMLHttpRequest", + "XMLHttpRequestEventTarget", + "XMLHttpRequestException", + "XMLHttpRequestProgressEvent", + "XMLHttpRequestUpload", + "XMLSerializer", + "XMLStylesheetProcessingInstruction", + "XPathEvaluator", + "XPathException", + "XPathExpression", + "XPathNSResolver", + "XPathResult", + "XR", + "XRBoundedReferenceSpace", + "XRDOMOverlayState", + "XRFrame", + "XRHitTestResult", + "XRHitTestSource", + "XRInputSource", + "XRInputSourceArray", + "XRInputSourceEvent", + "XRInputSourcesChangeEvent", + "XRLayer", + "XRPose", + "XRRay", + "XRReferenceSpace", + "XRReferenceSpaceEvent", + "XRRenderState", + "XRRigidTransform", + "XRSession", + "XRSessionEvent", + "XRSpace", + "XRSystem", + "XRTransientInputHitTestResult", + "XRTransientInputHitTestSource", + "XRView", + "XRViewerPose", + "XRViewport", + "XRWebGLLayer", + "XSLTProcessor", + "ZERO", + "_XD0M_", + "_YD0M_", + "__defineGetter__", + "__defineSetter__", + "__lookupGetter__", + "__lookupSetter__", + "__opera", + "__proto__", + "__relevantExtensionKeys", + "_browserjsran", + "a", + "aLink", + "abbr", + "abort", + "aborted", + "abs", + "absolute", + "acceleration", + "accelerationIncludingGravity", + "accelerator", + "accept", + "acceptCharset", + "acceptNode", + "accessKey", + "accessKeyLabel", + "accuracy", + "acos", + "acosh", + "action", + "actionURL", + "actions", + "activated", + "active", + "activeCues", + "activeElement", + "activeSourceBuffers", + "activeSourceCount", + "activeTexture", + "activeVRDisplays", + "actualBoundingBoxAscent", + "actualBoundingBoxDescent", + "actualBoundingBoxLeft", + "actualBoundingBoxRight", + "add", + "addAll", + "addBehavior", + "addCandidate", + "addColorStop", + "addCue", + "addElement", + "addEventListener", + "addFilter", + "addFromString", + "addFromUri", + "addIceCandidate", + "addImport", + "addListener", + "addModule", + "addNamed", + "addPageRule", + "addPath", + "addPointer", + "addRange", + "addRegion", + "addRule", + "addRules", + "addSearchEngine", + "addSourceBuffer", + "addStream", + "addTextTrack", + "addTrack", + "addTransceiver", + "addWakeLockListener", + "added", + "addedNodes", + "additionalName", + "additiveSymbols", + "addons", + "address", + "addressLine", + "adoptNode", + "adoptText", + "adoptedCallback", + "adoptedStyleSheets", + "adr", + "advance", + "after", + "album", + "alert", + "algorithm", + "align", + "align-content", + "align-items", + "align-self", + "alignContent", + "alignItems", + "alignSelf", + "alignmentBaseline", + "alinkColor", + "all", + "allSettled", + "allow", + "allowFullscreen", + "allowPaymentRequest", + "allowTransparency", + "allowedDirections", + "allowedFeatures", + "allowsFeature", + "alpha", + "alphabeticBaseline", + "alt", + "altGraphKey", + "altHtml", + "altKey", + "altLeft", + "alternate", + "alternateSetting", + "alternates", + "altitude", + "altitudeAccuracy", + "amplitude", + "ancestorOrigins", + "anchor", + "anchorNode", + "anchorOffset", + "anchors", + "and", + "angle", + "angularAcceleration", + "angularVelocity", + "animVal", + "animate", + "animatedInstanceRoot", + "animatedNormalizedPathSegList", + "animatedPathSegList", + "animatedPoints", + "animation", + "animation-delay", + "animation-direction", + "animation-duration", + "animation-fill-mode", + "animation-iteration-count", + "animation-name", + "animation-play-state", + "animation-timing-function", + "animationDelay", + "animationDirection", + "animationDuration", + "animationFillMode", + "animationIterationCount", + "animationName", + "animationPlayState", + "animationStartTime", + "animationTimingFunction", + "animationsPaused", + "anniversary", + "antialias", + "any", + "app", + "appCodeName", + "appMinorVersion", + "appName", + "appNotifications", + "appVersion", + "appearance", + "append", + "appendBuffer", + "appendChild", + "appendData", + "appendItem", + "appendMedium", + "appendNamed", + "appendRule", + "appendStream", + "appendWindowEnd", + "appendWindowStart", + "appleTrailingWord", + "applets", + "application/apple-default-browser", + "application/asx", + "application/java-deployment-toolkit", + "application/pdf", + "application/postscript", + "application/x-drm", + "application/x-drm-v2", + "application/x-google-chrome-pdf", + "application/x-java-applet", + "application/x-java-applet;deploy=10.25.2", + "application/x-java-applet;javafx=2.2.25", + "application/x-java-applet;jpi-version=1.7.0_25", + "application/x-java-applet;version=1.1", + "application/x-java-applet;version=1.1.1", + "application/x-java-applet;version=1.1.2", + "application/x-java-applet;version=1.1.3", + "application/x-java-applet;version=1.2", + "application/x-java-applet;version=1.2.1", + "application/x-java-applet;version=1.2.2", + "application/x-java-applet;version=1.3", + "application/x-java-applet;version=1.3.1", + "application/x-java-applet;version=1.4", + "application/x-java-applet;version=1.4.1", + "application/x-java-applet;version=1.4.2", + "application/x-java-applet;version=1.5", + "application/x-java-applet;version=1.6", + "application/x-java-applet;version=1.7", + "application/x-java-bean", + "application/x-java-bean;jpi-version=1.7.0_25", + "application/x-java-bean;version=1.1", + "application/x-java-bean;version=1.1.1", + "application/x-java-bean;version=1.1.2", + "application/x-java-bean;version=1.1.3", + "application/x-java-bean;version=1.2", + "application/x-java-bean;version=1.2.1", + "application/x-java-bean;version=1.2.2", + "application/x-java-bean;version=1.3", + "application/x-java-bean;version=1.3.1", + "application/x-java-bean;version=1.4", + "application/x-java-bean;version=1.4.1", + "application/x-java-bean;version=1.4.2", + "application/x-java-bean;version=1.5", + "application/x-java-bean;version=1.6", + "application/x-java-bean;version=1.7", + "application/x-java-vm", + "application/x-java-vm-npruntime", + "application/x-mplayer2", + "application/x-ms-xbap", + "application/x-nacl", + "application/x-pnacl", + "application/xaml+xml", + "applicationCache", + "applicationServerKey", + "apply", + "applyConstraints", + "applyElement", + "arc", + "arcTo", + "archive", + "areas", + "arguments", + "aria-activedescendant", + "aria-busy", + "aria-checked", + "aria-controls", + "aria-describedby", + "aria-disabled", + "aria-expanded", + "aria-flowto", + "aria-haspopup", + "aria-hidden", + "aria-invalid", + "aria-labelledby", + "aria-level", + "aria-live", + "aria-multiselectable", + "aria-owns", + "aria-posinset", + "aria-pressed", + "aria-readonly", + "aria-relevant", + "aria-required", + "aria-secret", + "aria-selected", + "aria-setsize", + "aria-valuemax", + "aria-valuemin", + "aria-valuenow", + "ariaAtomic", + "ariaAutoComplete", + "ariaBusy", + "ariaChecked", + "ariaColCount", + "ariaColIndex", + "ariaColSpan", + "ariaCurrent", + "ariaDescription", + "ariaDisabled", + "ariaExpanded", + "ariaHasPopup", + "ariaHidden", + "ariaKeyShortcuts", + "ariaLabel", + "ariaLevel", + "ariaLive", + "ariaModal", + "ariaMultiLine", + "ariaMultiSelectable", + "ariaOrientation", + "ariaPlaceholder", + "ariaPosInSet", + "ariaPressed", + "ariaReadOnly", + "ariaRelevant", + "ariaRequired", + "ariaRoleDescription", + "ariaRowCount", + "ariaRowIndex", + "ariaRowSpan", + "ariaSelected", + "ariaSetSize", + "ariaSort", + "ariaValueMax", + "ariaValueMin", + "ariaValueNow", + "ariaValueText", + "arrayBuffer", + "artist", + "artwork", + "as", + "asIntN", + "asUintN", + "asin", + "asinh", + "assert", + "assign", + "assignedElements", + "assignedNodes", + "assignedSlot", + "async", + "asyncIterator", + "atEnd", + "atan", + "atan2", + "atanh", + "atob", + "atomic", + "attachEvent", + "attachInternals", + "attachShader", + "attachShadow", + "attachments", + "attack", + "attestationObject", + "attrChange", + "attrName", + "attributeChangedCallback", + "attributeFilter", + "attributeName", + "attributeNamespace", + "attributeOldValue", + "attributeStyleMap", + "attributes", + "attribution", + "audio/x-ms-wax", + "audio/x-ms-wma", + "audioBitsPerSecond", + "audioTracks", + "audioWorklet", + "authenticatedSignedWrites", + "authenticatorData", + "autoIncrement", + "autobuffer", + "autocapitalize", + "autocomplete", + "autocorrect", + "autofocus", + "automationRate", + "autoplay", + "availHeight", + "availLeft", + "availTop", + "availWidth", + "availability", + "available", + "aversion", + "ax", + "axes", + "axis", + "ay", + "azimuth", + "b", + "back", + "backdropFilter", + "backface-visibility", + "backfaceVisibility", + "background", + "background-attachment", + "background-blend-mode", + "background-clip", + "background-color", + "background-image", + "background-origin", + "background-position", + "background-position-x", + "background-position-y", + "background-repeat", + "background-size", + "backgroundAttachment", + "backgroundBlendMode", + "backgroundClip", + "backgroundColor", + "backgroundFetch", + "backgroundImage", + "backgroundOrigin", + "backgroundPosition", + "backgroundPositionX", + "backgroundPositionY", + "backgroundRepeat", + "backgroundRepeatX", + "backgroundRepeatY", + "backgroundSize", + "badInput", + "badge", + "balance", + "baseFrequencyX", + "baseFrequencyY", + "baseLatency", + "baseLayer", + "baseName", + "baseNode", + "baseOffset", + "baseURI", + "baseVal", + "baselineShift", + "battery", + "bday", + "before", + "beginElement", + "beginElementAt", + "beginPath", + "beginQuery", + "beginTransformFeedback", + "behavior", + "behaviorCookie", + "behaviorPart", + "behaviorUrns", + "beta", + "bezierCurveTo", + "bgColor", + "bgProperties", + "bias", + "big", + "binaryType", + "bind", + "bindAttribLocation", + "bindBuffer", + "bindBufferBase", + "bindBufferRange", + "bindFramebuffer", + "bindRenderbuffer", + "bindSampler", + "bindTexture", + "bindTransformFeedback", + "bindVertexArray", + "blendColor", + "blendEquation", + "blendEquationSeparate", + "blendFunc", + "blendFuncSeparate", + "blink", + "blitFramebuffer", + "blob", + "block-size", + "blockDirection", + "blockSize", + "blockedURI", + "blue", + "bluetooth", + "blur", + "body", + "bodyUsed", + "bold", + "bookmarks", + "booleanValue", + "border", + "border-block", + "border-block-color", + "border-block-end", + "border-block-end-color", + "border-block-end-style", + "border-block-end-width", + "border-block-start", + "border-block-start-color", + "border-block-start-style", + "border-block-start-width", + "border-block-style", + "border-block-width", + "border-bottom", + "border-bottom-color", + "border-bottom-left-radius", + "border-bottom-right-radius", + "border-bottom-style", + "border-bottom-width", + "border-collapse", + "border-color", + "border-end-end-radius", + "border-end-start-radius", + "border-image", + "border-image-outset", + "border-image-repeat", + "border-image-slice", + "border-image-source", + "border-image-width", + "border-inline", + "border-inline-color", + "border-inline-end", + "border-inline-end-color", + "border-inline-end-style", + "border-inline-end-width", + "border-inline-start", + "border-inline-start-color", + "border-inline-start-style", + "border-inline-start-width", + "border-inline-style", + "border-inline-width", + "border-left", + "border-left-color", + "border-left-style", + "border-left-width", + "border-radius", + "border-right", + "border-right-color", + "border-right-style", + "border-right-width", + "border-spacing", + "border-start-end-radius", + "border-start-start-radius", + "border-style", + "border-top", + "border-top-color", + "border-top-left-radius", + "border-top-right-radius", + "border-top-style", + "border-top-width", + "border-width", + "borderBlock", + "borderBlockColor", + "borderBlockEnd", + "borderBlockEndColor", + "borderBlockEndStyle", + "borderBlockEndWidth", + "borderBlockStart", + "borderBlockStartColor", + "borderBlockStartStyle", + "borderBlockStartWidth", + "borderBlockStyle", + "borderBlockWidth", + "borderBottom", + "borderBottomColor", + "borderBottomLeftRadius", + "borderBottomRightRadius", + "borderBottomStyle", + "borderBottomWidth", + "borderBoxSize", + "borderCollapse", + "borderColor", + "borderColorDark", + "borderColorLight", + "borderEndEndRadius", + "borderEndStartRadius", + "borderImage", + "borderImageOutset", + "borderImageRepeat", + "borderImageSlice", + "borderImageSource", + "borderImageWidth", + "borderInline", + "borderInlineColor", + "borderInlineEnd", + "borderInlineEndColor", + "borderInlineEndStyle", + "borderInlineEndWidth", + "borderInlineStart", + "borderInlineStartColor", + "borderInlineStartStyle", + "borderInlineStartWidth", + "borderInlineStyle", + "borderInlineWidth", + "borderLeft", + "borderLeftColor", + "borderLeftStyle", + "borderLeftWidth", + "borderRadius", + "borderRight", + "borderRightColor", + "borderRightStyle", + "borderRightWidth", + "borderSpacing", + "borderStartEndRadius", + "borderStartStartRadius", + "borderStyle", + "borderTop", + "borderTopColor", + "borderTopLeftRadius", + "borderTopRightRadius", + "borderTopStyle", + "borderTopWidth", + "borderWidth", + "bottom", + "bottomMargin", + "bound", + "boundElements", + "boundingClientRect", + "boundingHeight", + "boundingLeft", + "boundingTop", + "boundingWidth", + "bounds", + "boundsGeometry", + "box-decoration-break", + "box-shadow", + "box-sizing", + "boxDecorationBreak", + "boxShadow", + "boxSizing", + "break-after", + "break-before", + "break-inside", + "breakAfter", + "breakBefore", + "breakInside", + "breakType", + "broadcast", + "browserLanguage", + "btoa", + "bubbles", + "buffer", + "bufferData", + "bufferDepth", + "bufferSize", + "bufferSubData", + "buffered", + "bufferedAmount", + "bufferedAmountLowThreshold", + "bufferedRendering", + "buildID", + "buildNumber", + "button", + "buttonID", + "buttons", + "byteLength", + "byteOffset", + "bytesWritten", + "c", + "cache", + "caches", + "calendar", + "call", + "caller", + "canBeFormatted", + "canBeMounted", + "canBeShared", + "canHaveChildren", + "canHaveHTML", + "canInsertDTMF", + "canMakePayment", + "canPlayType", + "canPresent", + "canTrickleIceCandidates", + "cancel", + "cancelAndHoldAtTime", + "cancelAnimationFrame", + "cancelBubble", + "cancelIdleCallback", + "cancelScheduledValues", + "cancelVideoFrameCallback", + "cancelWatchAvailability", + "cancelable", + "candidate", + "canonicalUUID", + "canvas", + "capabilities", + "caption", + "caption-side", + "captionSide", + "capture", + "captureEvents", + "captureStackTrace", + "captureStream", + "caret-color", + "caretBidiLevel", + "caretColor", + "caretPositionFromPoint", + "caretRangeFromPoint", + "caseFirst", + "cast", + "catch", + "category", + "cbrt", + "cd", + "ceil", + "cellIndex", + "cellPadding", + "cellSpacing", + "cells", + "ch", + "chOff", + "chain", + "challenge", + "changeType", + "changeVersion", + "changedTouches", + "channel", + "channelCount", + "channelCountMode", + "channelInterpretation", + "char", + "charAt", + "charCode", + "charCodeAt", + "charIndex", + "charLength", + "characterData", + "characterDataOldValue", + "characterSet", + "characteristic", + "charging", + "chargingTime", + "charset", + "check", + "checkEnclosure", + "checkFramebufferStatus", + "checkInstalled", + "checkIntersection", + "checkValidity", + "checked", + "childElementCount", + "childList", + "childNodes", + "children", + "chrome", + "ciphertext", + "cite", + "city", + "claimInterface", + "claimed", + "classList", + "className", + "classid", + "clear", + "clearAppBadge", + "clearAttributes", + "clearBufferfi", + "clearBufferfv", + "clearBufferiv", + "clearBufferuiv", + "clearColor", + "clearData", + "clearDepth", + "clearHalt", + "clearImmediate", + "clearInterval", + "clearLiveSeekableRange", + "clearMarks", + "clearMeasures", + "clearParameters", + "clearRect", + "clearResourceTimings", + "clearShadow", + "clearStencil", + "clearTimeout", + "clearWatch", + "click", + "clickCount", + "clientDataJSON", + "clientHeight", + "clientInformation", + "clientLeft", + "clientRect", + "clientRects", + "clientTop", + "clientWaitSync", + "clientWidth", + "clientX", + "clientY", + "clip", + "clip-path", + "clip-rule", + "clipBottom", + "clipLeft", + "clipPath", + "clipPathUnits", + "clipRight", + "clipRule", + "clipTop", + "clipboard", + "clipboardData", + "clone", + "cloneContents", + "cloneNode", + "cloneRange", + "close", + "closePath", + "closed", + "closest", + "clz", + "clz32", + "cm", + "cmp", + "code", + "codeBase", + "codePointAt", + "codeType", + "colSpan", + "collapse", + "collapseToEnd", + "collapseToStart", + "collapsed", + "collation", + "collect", + "colno", + "color", + "color-adjust", + "color-interpolation", + "color-interpolation-filters", + "colorAdjust", + "colorDepth", + "colorInterpolation", + "colorInterpolationFilters", + "colorMask", + "colorProfile", + "colorRendering", + "colorScheme", + "colorType", + "cols", + "column", + "column-count", + "column-fill", + "column-gap", + "column-rule", + "column-rule-color", + "column-rule-style", + "column-rule-width", + "column-span", + "column-width", + "columnCount", + "columnFill", + "columnGap", + "columnNumber", + "columnRule", + "columnRuleColor", + "columnRuleStyle", + "columnRuleWidth", + "columnSpan", + "columnWidth", + "columns", + "command", + "commit", + "commitLoadTime", + "commitPreferences", + "commitStyles", + "commonAncestorContainer", + "compact", + "compare", + "compareBoundaryPoints", + "compareDocumentPosition", + "compareEndPoints", + "compareExchange", + "compareNode", + "comparePoint", + "compatMode", + "compatible", + "compile", + "compileShader", + "compileStreaming", + "complete", + "component", + "componentFromPoint", + "composed", + "composedPath", + "composite", + "compositionEndOffset", + "compositionStartOffset", + "compressedTexImage2D", + "compressedTexImage3D", + "compressedTexSubImage2D", + "compressedTexSubImage3D", + "computedStyleMap", + "concat", + "conditionText", + "coneInnerAngle", + "coneOuterAngle", + "coneOuterGain", + "configuration", + "configurationName", + "configurationValue", + "configurations", + "confirm", + "confirmComposition", + "confirmSiteSpecificTrackingException", + "confirmWebWideTrackingException", + "connect", + "connectEnd", + "connectStart", + "connected", + "connectedCallback", + "connection", + "connectionInfo", + "connectionList", + "connectionSpeed", + "connectionState", + "connections", + "console", + "consoleHistory", + "consolidate", + "constraint", + "constrictionActive", + "construct", + "constructor", + "contactID", + "contain", + "containIntrinsicSize", + "containerId", + "containerName", + "containerSrc", + "containerType", + "contains", + "containsNode", + "content", + "contentBoxSize", + "contentDocument", + "contentEditable", + "contentHint", + "contentOverflow", + "contentRect", + "contentScriptType", + "contentStyleType", + "contentType", + "contentWindow", + "context", + "contextMenu", + "contextmenu", + "continue", + "continuePrimaryKey", + "continuous", + "control", + "controlTransferIn", + "controlTransferOut", + "controller", + "controls", + "controlsList", + "convertToBlob", + "convertToSpecifiedUnits", + "cookie", + "cookieEnabled", + "coords", + "copyBufferSubData", + "copyFromChannel", + "copyTexImage2D", + "copyTexSubImage2D", + "copyTexSubImage3D", + "copyToChannel", + "copyWithin", + "correspondingElement", + "correspondingUseElement", + "corruptedVideoFrames", + "cos", + "cosh", + "count", + "countReset", + "counter-increment", + "counter-reset", + "counter-set", + "counterIncrement", + "counterReset", + "counterSet", + "country", + "cpuClass", + "cpuSleepAllowed", + "create", + "createAnalyser", + "createAnswer", + "createAttribute", + "createAttributeNS", + "createBiquadFilter", + "createBuffer", + "createBufferSource", + "createCDATASection", + "createCSSStyleSheet", + "createCaption", + "createChannelMerger", + "createChannelSplitter", + "createComment", + "createConstantSource", + "createContextualFragment", + "createControlRange", + "createConvolver", + "createDTMFSender", + "createDataChannel", + "createDelay", + "createDelayNode", + "createDocument", + "createDocumentFragment", + "createDocumentType", + "createDynamicsCompressor", + "createElement", + "createElementNS", + "createEntityReference", + "createEvent", + "createEventObject", + "createExpression", + "createFramebuffer", + "createFunction", + "createGain", + "createGainNode", + "createHTML", + "createHTMLDocument", + "createIIRFilter", + "createImageBitmap", + "createImageData", + "createIndex", + "createJavaScriptNode", + "createLinearGradient", + "createMediaElementSource", + "createMediaKeys", + "createMediaStreamDestination", + "createMediaStreamSource", + "createMediaStreamTrackSource", + "createMutableFile", + "createNSResolver", + "createNodeIterator", + "createNotification", + "createObjectStore", + "createObjectURL", + "createOffer", + "createOscillator", + "createPanner", + "createPattern", + "createPeriodicWave", + "createPolicy", + "createPopup", + "createProcessingInstruction", + "createProgram", + "createQuery", + "createRadialGradient", + "createRange", + "createRangeCollection", + "createReader", + "createRenderbuffer", + "createSVGAngle", + "createSVGLength", + "createSVGMatrix", + "createSVGNumber", + "createSVGPathSegArcAbs", + "createSVGPathSegArcRel", + "createSVGPathSegClosePath", + "createSVGPathSegCurvetoCubicAbs", + "createSVGPathSegCurvetoCubicRel", + "createSVGPathSegCurvetoCubicSmoothAbs", + "createSVGPathSegCurvetoCubicSmoothRel", + "createSVGPathSegCurvetoQuadraticAbs", + "createSVGPathSegCurvetoQuadraticRel", + "createSVGPathSegCurvetoQuadraticSmoothAbs", + "createSVGPathSegCurvetoQuadraticSmoothRel", + "createSVGPathSegLinetoAbs", + "createSVGPathSegLinetoHorizontalAbs", + "createSVGPathSegLinetoHorizontalRel", + "createSVGPathSegLinetoRel", + "createSVGPathSegLinetoVerticalAbs", + "createSVGPathSegLinetoVerticalRel", + "createSVGPathSegMovetoAbs", + "createSVGPathSegMovetoRel", + "createSVGPoint", + "createSVGRect", + "createSVGTransform", + "createSVGTransformFromMatrix", + "createSampler", + "createScript", + "createScriptProcessor", + "createScriptURL", + "createSession", + "createShader", + "createShadowRoot", + "createStereoPanner", + "createStyleSheet", + "createTBody", + "createTFoot", + "createTHead", + "createTextNode", + "createTextRange", + "createTexture", + "createTouch", + "createTouchList", + "createTransformFeedback", + "createTreeWalker", + "createVertexArray", + "createWaveShaper", + "creationTime", + "credentials", + "crossOrigin", + "crossOriginIsolated", + "crypto", + "csi", + "csp", + "cssFloat", + "cssRules", + "cssText", + "cssValueType", + "ctrlKey", + "ctrlLeft", + "cues", + "cullFace", + "currency", + "currencyDisplay", + "current", + "currentDirection", + "currentLocalDescription", + "currentNode", + "currentPage", + "currentRect", + "currentRemoteDescription", + "currentScale", + "currentScript", + "currentSrc", + "currentState", + "currentStyle", + "currentTarget", + "currentTime", + "currentTranslate", + "currentView", + "cursor", + "curve", + "customElements", + "customError", + "customSections", + "cx", + "cy", + "d", + "data", + "dataFld", + "dataFormatAs", + "dataLoss", + "dataLossMessage", + "dataPageSize", + "dataSrc", + "dataTransfer", + "database", + "databases", + "dataset", + "dateTime", + "day", + "db", + "debug", + "debuggerEnabled", + "declare", + "decode", + "decodeAudioData", + "decodeURI", + "decodeURIComponent", + "decodedBodySize", + "decoding", + "decodingInfo", + "decrypt", + "default", + "defaultCharset", + "defaultChecked", + "defaultMuted", + "defaultPlaybackRate", + "defaultPolicy", + "defaultPrevented", + "defaultRequest", + "defaultSelected", + "defaultStatus", + "defaultURL", + "defaultValue", + "defaultView", + "defaultstatus", + "defer", + "define", + "defineMagicFunction", + "defineMagicVariable", + "defineProperties", + "defineProperty", + "deg", + "delay", + "delayTime", + "delegatesFocus", + "delete", + "deleteBuffer", + "deleteCaption", + "deleteCell", + "deleteContents", + "deleteData", + "deleteDatabase", + "deleteFramebuffer", + "deleteFromDocument", + "deleteIndex", + "deleteMedium", + "deleteObjectStore", + "deleteProgram", + "deleteProperty", + "deleteQuery", + "deleteRenderbuffer", + "deleteRow", + "deleteRule", + "deleteSampler", + "deleteShader", + "deleteSync", + "deleteTFoot", + "deleteTHead", + "deleteTexture", + "deleteTransformFeedback", + "deleteVertexArray", + "deliverChangeRecords", + "delivery", + "deliveryInfo", + "deliveryStatus", + "deliveryTimestamp", + "delta", + "deltaMode", + "deltaX", + "deltaY", + "deltaZ", + "dependentLocality", + "depthFar", + "depthFunc", + "depthMask", + "depthNear", + "depthRange", + "deref", + "deriveBits", + "deriveKey", + "description", + "deselectAll", + "designMode", + "desiredSize", + "destination", + "destinationURL", + "detach", + "detachEvent", + "detachShader", + "detail", + "details", + "detect", + "detune", + "device", + "deviceClass", + "deviceId", + "deviceMemory", + "devicePixelContentBoxSize", + "devicePixelRatio", + "deviceProtocol", + "deviceSessionId", + "deviceSubclass", + "deviceVersionMajor", + "deviceVersionMinor", + "deviceVersionSubminor", + "deviceXDPI", + "deviceYDPI", + "didTimeout", + "diffuseConstant", + "digest", + "dimensions", + "dir", + "dirName", + "dirXml", + "direction", + "dirxml", + "disable", + "disablePictureInPicture", + "disableRemotePlayback", + "disableVertexAttribArray", + "disabled", + "dischargingTime", + "disconnect", + "disconnectedCallback", + "dispatch", + "dispatchEvent", + "dispatchToListener", + "display", + "displayId", + "displayName", + "disposition", + "distanceModel", + "div", + "divisor", + "djsapi", + "djsproxy", + "doImport", + "doNotTrack", + "doScroll", + "doctype", + "document", + "documentElement", + "documentMode", + "documentURI", + "dolphin", + "dolphinGameCenter", + "dolphininfo", + "dolphinmeta", + "domComplete", + "domContentLoadedEventEnd", + "domContentLoadedEventStart", + "domInteractive", + "domLoading", + "domOverlayState", + "domain", + "domainLookupEnd", + "domainLookupStart", + "dominant-baseline", + "dominantBaseline", + "done", + "dopplerFactor", + "dotAll", + "downDegrees", + "downlink", + "download", + "downloadTotal", + "downloaded", + "dpcm", + "dpi", + "dppx", + "dragDrop", + "draggable", + "drawArrays", + "drawArraysInstanced", + "drawArraysInstancedANGLE", + "drawBuffers", + "drawCustomFocusRing", + "drawElements", + "drawElementsInstanced", + "drawElementsInstancedANGLE", + "drawFocusIfNeeded", + "drawImage", + "drawImageFromRect", + "drawRangeElements", + "drawSystemFocusRing", + "drawingBufferHeight", + "drawingBufferWidth", + "dropEffect", + "droppedVideoFrames", + "dropzone", + "dtmf", + "dump", + "duplicate", + "durability", + "duration", + "dvname", + "dvnum", + "dx", + "dy", + "dynsrc", + "e", + "edgeMode", + "effect", + "effectAllowed", + "effectiveDirective", + "effectiveType", + "elapsedTime", + "element", + "elementFromPoint", + "elementTiming", + "elements", + "elementsFromPoint", + "elevation", + "ellipse", + "em", + "emHeightAscent", + "emHeightDescent", + "email", + "embeds", + "emma", + "empty", + "empty-cells", + "emptyCells", + "emptyHTML", + "emptyScript", + "emulatedPosition", + "enable", + "enableBackground", + "enableDelegations", + "enableHighAccuracy", + "enableStyleSheetsForSet", + "enableVertexAttribArray", + "enabled", + "enabledPlugin", + "encode", + "encodeInto", + "encodeURI", + "encodeURIComponent", + "encodedBodySize", + "encoding", + "encodingInfo", + "encrypt", + "enctype", + "end", + "endContainer", + "endElement", + "endElementAt", + "endOfStream", + "endOffset", + "endQuery", + "endTime", + "endTransformFeedback", + "ended", + "endpoint", + "endpointNumber", + "endpoints", + "endsWith", + "enterKeyHint", + "entities", + "entries", + "entryType", + "enumerate", + "enumerateDevices", + "enumerateEditable", + "environmentBlendMode", + "epubCaptionSide", + "epubTextCombine", + "epubTextEmphasis", + "epubTextEmphasisColor", + "epubTextEmphasisStyle", + "epubTextOrientation", + "epubTextTransform", + "epubWordBreak", + "epubWritingMode", + "equals", + "era", + "error", + "errorCode", + "errorDetail", + "errorText", + "escape", + "estimate", + "eval", + "evaluate", + "event", + "eventPhase", + "every", + "ex", + "exception", + "exchange", + "exec", + "execCommand", + "execCommandShowHelp", + "execScript", + "executeSql", + "exitFullscreen", + "exitPictureInPicture", + "exitPointerLock", + "exitPresent", + "exp", + "expand", + "expandEntityReferences", + "expando", + "expansion", + "expiration", + "expirationTime", + "expires", + "expiryDate", + "explicitOriginalTarget", + "expm1", + "exponent", + "exponentialRampToValueAtTime", + "exportKey", + "exports", + "extend", + "extensions", + "extentNode", + "extentOffset", + "external", + "externalResourcesRequired", + "extractContents", + "extractable", + "eye", + "f", + "face", + "factoryReset", + "failureReason", + "fallback", + "family", + "familyName", + "farthestViewportElement", + "fastSeek", + "fatal", + "featurePolicy", + "featureSettings", + "features", + "fenceSync", + "fetch", + "fetchStart", + "fftSize", + "fgColor", + "fieldOfView", + "file", + "fileCreatedDate", + "fileHandle", + "fileModifiedDate", + "fileName", + "fileSize", + "fileUpdatedDate", + "filename", + "files", + "filesystem", + "fill", + "fill-opacity", + "fill-rule", + "fillLightMode", + "fillOpacity", + "fillRect", + "fillRule", + "fillStyle", + "fillText", + "filter", + "filterResX", + "filterResY", + "filterUnits", + "filters", + "finally", + "find", + "findIndex", + "findRule", + "findText", + "finish", + "finishDocumentLoadTime", + "finishLoadTime", + "finished", + "fireEvent", + "firesTouchEvents", + "first", + "firstChild", + "firstElementChild", + "firstPage", + "firstPaintAfterLoadTime", + "firstPaintTime", + "fixed", + "flags", + "flat", + "flatMap", + "flex", + "flex-basis", + "flex-direction", + "flex-flow", + "flex-grow", + "flex-shrink", + "flex-wrap", + "flexBasis", + "flexDirection", + "flexFlow", + "flexGrow", + "flexShrink", + "flexWrap", + "flipX", + "flipY", + "float", + "flood-color", + "flood-opacity", + "floodColor", + "floodOpacity", + "floor", + "flush", + "focus", + "focusNode", + "focusOffset", + "font", + "font-family", + "font-feature-settings", + "font-kerning", + "font-language-override", + "font-size", + "font-size-adjust", + "font-stretch", + "font-style", + "font-synthesis", + "font-variant", + "font-variant-alternates", + "font-variant-caps", + "font-variant-east-asian", + "font-variant-ligatures", + "font-variant-numeric", + "font-variant-position", + "font-weight", + "fontBoundingBoxAscent", + "fontBoundingBoxDescent", + "fontDisplay", + "fontFamily", + "fontFeatureSettings", + "fontKerning", + "fontLanguageOverride", + "fontOpticalSizing", + "fontSize", + "fontSizeAdjust", + "fontSmoothingEnabled", + "fontStretch", + "fontStyle", + "fontSynthesis", + "fontVariant", + "fontVariantAlternates", + "fontVariantCaps", + "fontVariantEastAsian", + "fontVariantLigatures", + "fontVariantNumeric", + "fontVariantPosition", + "fontVariationSettings", + "fontWeight", + "fontcolor", + "fontfaces", + "fonts", + "fontsize", + "for", + "forEach", + "force", + "forceRedraw", + "form", + "formAction", + "formData", + "formEnctype", + "formMethod", + "formNoValidate", + "formTarget", + "format", + "formatRange", + "formatRangeToParts", + "formatToParts", + "forms", + "forward", + "forwardX", + "forwardY", + "forwardZ", + "foundation", + "fr", + "fragmentDirective", + "frame", + "frameBorder", + "frameElement", + "frameSpacing", + "framebuffer", + "framebufferHeight", + "framebufferRenderbuffer", + "framebufferTexture2D", + "framebufferTextureLayer", + "framebufferWidth", + "frames", + "freeSpace", + "freeze", + "frequency", + "frequencyBinCount", + "from", + "fromCharCode", + "fromCodePoint", + "fromElement", + "fromEntries", + "fromFloat32Array", + "fromFloat64Array", + "fromMatrix", + "fromPoint", + "fromQuad", + "fromRect", + "frontFace", + "fround", + "fullPath", + "fullScreen", + "fullscreen", + "fullscreenElement", + "fullscreenEnabled", + "fx", + "fy", + "gain", + "gamepad", + "gamma", + "gap", + "gatheringState", + "gatt", + "genderIdentity", + "generateCertificate", + "generateKey", + "generateMipmap", + "generateRequest", + "geolocation", + "gestureObject", + "get", + "getActiveAttrib", + "getActiveUniform", + "getActiveUniformBlockName", + "getActiveUniformBlockParameter", + "getActiveUniforms", + "getAdditionalLanguages", + "getAdjacentText", + "getAll", + "getAllKeys", + "getAllResponseHeaders", + "getAllowlistForFeature", + "getAnimations", + "getAsFile", + "getAsString", + "getAttachedShaders", + "getAttribLocation", + "getAttribute", + "getAttributeNS", + "getAttributeNames", + "getAttributeNode", + "getAttributeNodeNS", + "getAttributeType", + "getAudioTracks", + "getAvailability", + "getBBox", + "getBattery", + "getBigInt64", + "getBigUint64", + "getBlob", + "getBookmark", + "getBoundingClientRect", + "getBounds", + "getBufferParameter", + "getBufferSubData", + "getByteFrequencyData", + "getByteTimeDomainData", + "getCSSCanvasContext", + "getCTM", + "getCandidateWindowClientRect", + "getCanonicalLocales", + "getCapabilities", + "getChannelData", + "getCharNumAtPosition", + "getCharacteristic", + "getCharacteristics", + "getClientExtensionResults", + "getClientRect", + "getClientRects", + "getCoalescedEvents", + "getCompositionAlternatives", + "getComputedStyle", + "getComputedTextLength", + "getComputedTiming", + "getConfiguration", + "getConstraints", + "getContext", + "getContextAttributes", + "getContributingSources", + "getCount", + "getCounterValue", + "getCueAsHTML", + "getCueById", + "getCurrentPosition", + "getCurrentTime", + "getData", + "getDatabaseNames", + "getDate", + "getDay", + "getDefaultComputedStyle", + "getDescriptor", + "getDescriptors", + "getDestinationInsertionPoints", + "getDetails", + "getDevices", + "getDirectory", + "getDisplayMedia", + "getDistributedNodes", + "getEditable", + "getElementById", + "getElementsByClassName", + "getElementsByName", + "getElementsByTagName", + "getElementsByTagNameNS", + "getEnclosureList", + "getEndPositionOfChar", + "getEntries", + "getEntriesByName", + "getEntriesByType", + "getError", + "getExtension", + "getExtentOfChar", + "getEyeParameters", + "getFeature", + "getFile", + "getFiles", + "getFilesAndDirectories", + "getFingerprints", + "getFloat32", + "getFloat64", + "getFloatFrequencyData", + "getFloatTimeDomainData", + "getFloatValue", + "getFragDataLocation", + "getFrameData", + "getFramebufferAttachmentParameter", + "getFrequencyResponse", + "getFullYear", + "getGamepads", + "getHitTestResults", + "getHitTestResultsForTransientInput", + "getHours", + "getIdentityAssertion", + "getIds", + "getImageData", + "getIndexedParameter", + "getInstalled", + "getInstalledRelatedApps", + "getInt16", + "getInt32", + "getInt8", + "getInternalformatParameter", + "getIntersectionList", + "getIsInstalled", + "getItem", + "getItems", + "getKey", + "getKeyframes", + "getLayers", + "getLayoutMap", + "getLineDash", + "getLocalCandidates", + "getLocalParameters", + "getLocalStreams", + "getLocalizationResource", + "getMarks", + "getMatchedCSSRules", + "getMeasures", + "getMetadata", + "getMilliseconds", + "getMinutes", + "getModifierState", + "getMonth", + "getNamedItem", + "getNamedItemNS", + "getNativeFramebufferScaleFactor", + "getNotifications", + "getNotifier", + "getNumberOfChars", + "getOffsetReferenceSpace", + "getOutputTimestamp", + "getOverrideHistoryNavigationMode", + "getOverrideStyle", + "getOwnPropertyDescriptor", + "getOwnPropertyDescriptors", + "getOwnPropertyNames", + "getOwnPropertySymbols", + "getParameter", + "getParameters", + "getParent", + "getPathSegAtLength", + "getPhotoCapabilities", + "getPhotoSettings", + "getPointAtLength", + "getPose", + "getPredictedEvents", + "getPreference", + "getPreferenceDefault", + "getPresentationAttribute", + "getPreventDefault", + "getPrimaryService", + "getPrimaryServices", + "getProgramInfoLog", + "getProgramParameter", + "getPropertyCSSValue", + "getPropertyPriority", + "getPropertyShorthand", + "getPropertyType", + "getPropertyValue", + "getPrototypeOf", + "getQuery", + "getQueryParameter", + "getRGBColorValue", + "getRandomValues", + "getRangeAt", + "getReader", + "getReceivers", + "getRectValue", + "getRegistration", + "getRegistrations", + "getRemoteCandidates", + "getRemoteCertificates", + "getRemoteParameters", + "getRemoteStreams", + "getRenderbufferParameter", + "getResponseHeader", + "getRevision", + "getRoot", + "getRootNode", + "getRotationOfChar", + "getRules", + "getSVGDocument", + "getSamplerParameter", + "getScreenCTM", + "getSeconds", + "getSelectedCandidatePair", + "getSelection", + "getSelf", + "getSenders", + "getService", + "getSettings", + "getShaderInfoLog", + "getShaderParameter", + "getShaderPrecisionFormat", + "getShaderSource", + "getSimpleDuration", + "getSiteIcons", + "getSources", + "getSpeculativeParserUrls", + "getStartDate", + "getStartPositionOfChar", + "getStartTime", + "getState", + "getStats", + "getStatusForPolicy", + "getStorageUpdates", + "getStreamById", + "getStringValue", + "getSubStringLength", + "getSubscription", + "getSupportedConstraints", + "getSupportedExtensions", + "getSupportedFormats", + "getSyncParameter", + "getSynchronizationSources", + "getTags", + "getTargetRanges", + "getTexParameter", + "getTime", + "getTimezoneOffset", + "getTiming", + "getTotalLength", + "getTrackById", + "getTracks", + "getTransceivers", + "getTransform", + "getTransformFeedbackVarying", + "getTransformToElement", + "getTransports", + "getType", + "getTypeMapping", + "getUTCDate", + "getUTCDay", + "getUTCFullYear", + "getUTCHours", + "getUTCMilliseconds", + "getUTCMinutes", + "getUTCMonth", + "getUTCSeconds", + "getUint16", + "getUint32", + "getUint8", + "getUniform", + "getUniformBlockIndex", + "getUniformIndices", + "getUniformLocation", + "getUserMedia", + "getVRDisplays", + "getValues", + "getVarDate", + "getVariableValue", + "getVertexAttrib", + "getVertexAttribOffset", + "getVideoPlaybackQuality", + "getVideoTracks", + "getViewerPose", + "getViewport", + "getVoices", + "getWakeLockState", + "getWriter", + "getYear", + "givenName", + "global", + "globalAlpha", + "globalCompositeOperation", + "globalThis", + "glyphOrientationHorizontal", + "glyphOrientationVertical", + "glyphRef", + "go", + "grabFrame", + "grad", + "gradientTransform", + "gradientUnits", + "grammars", + "green", + "grid", + "grid-area", + "grid-auto-columns", + "grid-auto-flow", + "grid-auto-rows", + "grid-column", + "grid-column-end", + "grid-column-gap", + "grid-column-start", + "grid-gap", + "grid-row", + "grid-row-end", + "grid-row-gap", + "grid-row-start", + "grid-template", + "grid-template-areas", + "grid-template-columns", + "grid-template-rows", + "gridArea", + "gridAutoColumns", + "gridAutoFlow", + "gridAutoRows", + "gridColumn", + "gridColumnEnd", + "gridColumnGap", + "gridColumnStart", + "gridGap", + "gridRow", + "gridRowEnd", + "gridRowGap", + "gridRowStart", + "gridTemplate", + "gridTemplateAreas", + "gridTemplateColumns", + "gridTemplateRows", + "gripSpace", + "group", + "groupCollapsed", + "groupEnd", + "groupId", + "grow", + "hadRecentInput", + "hand", + "handedness", + "hangingBaseline", + "hangingPunctuation", + "hapticActuators", + "hardwareConcurrency", + "has", + "hasAttribute", + "hasAttributeNS", + "hasAttributes", + "hasBeenActive", + "hasChildNodes", + "hasComposition", + "hasEnrolledInstrument", + "hasExtension", + "hasExternalDisplay", + "hasFeature", + "hasFocus", + "hasInstance", + "hasLayout", + "hasListener", + "hasListeners", + "hasOrientation", + "hasOwnProperty", + "hasPointerCapture", + "hasPosition", + "hasReading", + "hasStorageAccess", + "hash", + "head", + "headers", + "heading", + "height", + "hidden", + "hide", + "hideFocus", + "high", + "highWaterMark", + "hint", + "history", + "honorificPrefix", + "honorificSuffix", + "horizontalOverflow", + "host", + "hostCandidate", + "hostname", + "hour", + "hour12", + "hourCycle", + "href", + "hrefTranslate", + "hreflang", + "hspace", + "html5TagCheckInerface", + "htmlFor", + "htmlText", + "httpEquiv", + "httpRequestStatusCode", + "hwTimestamp", + "hyphens", + "hypot", + "iccId", + "iceConnectionState", + "iceGatheringState", + "iceTransport", + "icon", + "iconURL", + "id", + "identifier", + "identity", + "ideographicBaseline", + "idpLoginUrl", + "ignoreBOM", + "ignoreCase", + "ignoreDepthValues", + "ignoreMutedMedia", + "ignorePunctuation", + "image-orientation", + "image-rendering", + "imageHeight", + "imageOrientation", + "imageRendering", + "imageSizes", + "imageSmoothingEnabled", + "imageSmoothingQuality", + "imageSrcset", + "imageWidth", + "images", + "ime-mode", + "imeMode", + "implementation", + "import", + "importKey", + "importNode", + "importStylesheet", + "imports", + "impp", + "imul", + "in", + "in1", + "in2", + "inBandMetadataTrackDispatchType", + "inRange", + "includes", + "incremental", + "indeterminate", + "index", + "indexNames", + "indexOf", + "indexedDB", + "indicate", + "inertiaDestinationX", + "inertiaDestinationY", + "info", + "init", + "initAnimationEvent", + "initBeforeLoadEvent", + "initClipboardEvent", + "initCloseEvent", + "initCommandEvent", + "initCompositionEvent", + "initCustomEvent", + "initData", + "initDataType", + "initDeviceMotionEvent", + "initDeviceOrientationEvent", + "initDragEvent", + "initErrorEvent", + "initEvent", + "initFocusEvent", + "initGestureEvent", + "initHashChangeEvent", + "initKeyEvent", + "initKeyboardEvent", + "initMSManipulationEvent", + "initMessageEvent", + "initMouseEvent", + "initMouseScrollEvent", + "initMouseWheelEvent", + "initMutationEvent", + "initNSMouseEvent", + "initOverflowEvent", + "initPageEvent", + "initPageTransitionEvent", + "initPointerEvent", + "initPopStateEvent", + "initProgressEvent", + "initScrollAreaEvent", + "initSimpleGestureEvent", + "initStorageEvent", + "initTextEvent", + "initTimeEvent", + "initTouchEvent", + "initTransitionEvent", + "initUIEvent", + "initWebKitAnimationEvent", + "initWebKitTransitionEvent", + "initWebKitWheelEvent", + "initWheelEvent", + "initialTime", + "initialize", + "initiatorType", + "inline-size", + "inlineSize", + "inlineVerticalFieldOfView", + "inner", + "innerHTML", + "innerHeight", + "innerText", + "innerWidth", + "input", + "inputBuffer", + "inputEncoding", + "inputMethod", + "inputMode", + "inputSource", + "inputSources", + "inputType", + "inputs", + "insertAdjacentElement", + "insertAdjacentHTML", + "insertAdjacentText", + "insertBefore", + "insertCell", + "insertDTMF", + "insertData", + "insertId", + "insertItemBefore", + "insertNode", + "insertRow", + "insertRule", + "inset", + "inset-block", + "inset-block-end", + "inset-block-start", + "inset-inline", + "inset-inline-end", + "inset-inline-start", + "insetBlock", + "insetBlockEnd", + "insetBlockStart", + "insetInline", + "insetInlineEnd", + "insetInlineStart", + "install", + "installChrome", + "installPackage", + "installState", + "installing", + "instanceRoot", + "instantiate", + "instantiateStreaming", + "instruments", + "integrity", + "interactionMode", + "intercept", + "interfaceClass", + "interfaceName", + "interfaceNumber", + "interfaceProtocol", + "interfaceSubclass", + "interfaces", + "interimResults", + "internalSubset", + "interpretation", + "intersectionRatio", + "intersectionRect", + "intersectsNode", + "interval", + "invalidIteratorState", + "invalidateFramebuffer", + "invalidateSubFramebuffer", + "inverse", + "invertSelf", + "is", + "is2D", + "isActive", + "isAlternate", + "isArray", + "isBingCurrentSearchDefault", + "isBuffer", + "isCandidateWindowVisible", + "isChar", + "isCollapsed", + "isComposing", + "isConcatSpreadable", + "isConnected", + "isContentEditable", + "isContentHandlerRegistered", + "isContextLost", + "isDefaultNamespace", + "isDirectory", + "isDisabled", + "isEnabled", + "isEqual", + "isEqualNode", + "isExtensible", + "isExternalCTAP2SecurityKeySupported", + "isFile", + "isFinite", + "isFramebuffer", + "isFrozen", + "isGenerator", + "isHTML", + "isHistoryNavigation", + "isId", + "isIdentity", + "isInjected", + "isInstalled", + "isInteger", + "isIntersecting", + "isLockFree", + "isMap", + "isMultiLine", + "isNaN", + "isOpen", + "isPointInFill", + "isPointInPath", + "isPointInRange", + "isPointInStroke", + "isPrefAlternate", + "isPresenting", + "isPrimary", + "isProgram", + "isPropertyImplicit", + "isProtocolHandlerRegistered", + "isPrototypeOf", + "isQuery", + "isRenderbuffer", + "isSafeInteger", + "isSameNode", + "isSampler", + "isScript", + "isScriptURL", + "isSealed", + "isSecureContext", + "isSessionSupported", + "isShader", + "isSupported", + "isSync", + "isTextEdit", + "isTexture", + "isTransformFeedback", + "isTrusted", + "isTypeSupported", + "isTypeSupportedWithFeatures", + "isUserVerifyingPlatformAuthenticatorAvailable", + "isVertexArray", + "isView", + "isVisible", + "isochronousTransferIn", + "isochronousTransferOut", + "isolation", + "italics", + "item", + "itemId", + "itemProp", + "itemRef", + "itemScope", + "itemType", + "itemValue", + "items", + "iterateNext", + "iterator", + "javaEnabled", + "jobTitle", + "join", + "jsHeapSizeLimit", + "json", + "justify-content", + "justify-items", + "justify-self", + "justifyContent", + "justifyItems", + "justifySelf", + "k1", + "k2", + "k3", + "k4", + "kHz", + "keepalive", + "kernelMatrix", + "kernelUnitLengthX", + "kernelUnitLengthY", + "kerning", + "key", + "keyCode", + "keyFor", + "keyIdentifier", + "keyLightEnabled", + "keyLocation", + "keyPath", + "keyStatuses", + "keySystem", + "keyText", + "keyUsage", + "keyboard", + "keys", + "keytype", + "kind", + "knee", + "label", + "labels", + "lang", + "language", + "languages", + "largeArcFlag", + "lastActivePanel", + "lastChild", + "lastElementChild", + "lastEventId", + "lastIndex", + "lastIndexOf", + "lastInputTime", + "lastMatch", + "lastMessageSubject", + "lastMessageType", + "lastModified", + "lastModifiedDate", + "lastPage", + "lastParen", + "lastState", + "lastStyleSheetSet", + "latitude", + "layerX", + "layerY", + "layoutFlow", + "layoutGrid", + "layoutGridChar", + "layoutGridLine", + "layoutGridMode", + "layoutGridType", + "lbound", + "left", + "leftContext", + "leftDegrees", + "leftMargin", + "leftProjectionMatrix", + "leftViewMatrix", + "length", + "lengthAdjust", + "lengthComputable", + "letter-spacing", + "letterSpacing", + "level", + "lighting-color", + "lightingColor", + "limitingConeAngle", + "line", + "line-break", + "line-height", + "lineAlign", + "lineBreak", + "lineCap", + "lineDashOffset", + "lineHeight", + "lineJoin", + "lineNumber", + "lineTo", + "lineWidth", + "linearAcceleration", + "linearRampToValueAtTime", + "linearVelocity", + "lineno", + "lines", + "link", + "linkColor", + "linkProgram", + "links", + "list", + "list-style", + "list-style-image", + "list-style-position", + "list-style-type", + "listStyle", + "listStyleImage", + "listStylePosition", + "listStyleType", + "listener", + "load", + "loadEventEnd", + "loadEventStart", + "loadTime", + "loadTimes", + "loaded", + "loading", + "localDescription", + "localName", + "localService", + "localStorage", + "locale", + "localeCompare", + "location", + "locationbar", + "lock", + "locked", + "lockedFile", + "locks", + "log", + "log10", + "log1p", + "log2", + "logicalXDPI", + "logicalYDPI", + "longDesc", + "longitude", + "lookupNamespaceURI", + "lookupPrefix", + "loop", + "loopEnd", + "loopStart", + "looping", + "low", + "lower", + "lowerBound", + "lowerOpen", + "lowsrc", + "m11", + "m12", + "m13", + "m14", + "m21", + "m22", + "m23", + "m24", + "m31", + "m32", + "m33", + "m34", + "m41", + "m42", + "m43", + "m44", + "makeXRCompatible", + "manifest", + "manufacturer", + "manufacturerName", + "map", + "mapping", + "margin", + "margin-block", + "margin-block-end", + "margin-block-start", + "margin-bottom", + "margin-inline", + "margin-inline-end", + "margin-inline-start", + "margin-left", + "margin-right", + "margin-top", + "marginBlock", + "marginBlockEnd", + "marginBlockStart", + "marginBottom", + "marginHeight", + "marginInline", + "marginInlineEnd", + "marginInlineStart", + "marginLeft", + "marginRight", + "marginTop", + "marginWidth", + "mark", + "markTimeline", + "marker", + "marker-end", + "marker-mid", + "marker-offset", + "marker-start", + "markerEnd", + "markerHeight", + "markerMid", + "markerOffset", + "markerStart", + "markerUnits", + "markerWidth", + "marks", + "mask", + "mask-clip", + "mask-composite", + "mask-image", + "mask-mode", + "mask-origin", + "mask-position", + "mask-position-x", + "mask-position-y", + "mask-repeat", + "mask-size", + "mask-type", + "maskClip", + "maskComposite", + "maskContentUnits", + "maskImage", + "maskMode", + "maskOrigin", + "maskPosition", + "maskPositionX", + "maskPositionY", + "maskRepeat", + "maskSize", + "maskType", + "maskUnits", + "match", + "matchAll", + "matchMedia", + "matchMedium", + "matches", + "matrix", + "matrixTransform", + "max", + "max-block-size", + "max-height", + "max-inline-size", + "max-width", + "maxActions", + "maxAlternatives", + "maxBlockSize", + "maxChannelCount", + "maxChannels", + "maxConnectionsPerServer", + "maxDecibels", + "maxDistance", + "maxHeight", + "maxInlineSize", + "maxLayers", + "maxLength", + "maxMessageSize", + "maxPacketLifeTime", + "maxRetransmits", + "maxTouchPoints", + "maxValue", + "maxWidth", + "maxZoom", + "maximize", + "maximumAge", + "maximumFractionDigits", + "measure", + "measureText", + "media", + "mediaCapabilities", + "mediaDevices", + "mediaElement", + "mediaGroup", + "mediaKeys", + "mediaSession", + "mediaStream", + "mediaText", + "meetOrSlice", + "memory", + "menubar", + "mergeAttributes", + "message", + "messageClass", + "messageHandlers", + "messageType", + "metaKey", + "metadata", + "method", + "methodDetails", + "methodName", + "mid", + "mimeType", + "mimeTypes", + "min", + "min-block-size", + "min-height", + "min-inline-size", + "min-width", + "minBlockSize", + "minDecibels", + "minHeight", + "minInlineSize", + "minLength", + "minValue", + "minWidth", + "minZoom", + "minimize", + "minimumFractionDigits", + "minimumIntegerDigits", + "minute", + "miterLimit", + "mix-blend-mode", + "mixBlendMode", + "mm", + "mode", + "modify", + "month", + "motion", + "motionOffset", + "motionPath", + "motionRotation", + "mount", + "move", + "moveBy", + "moveEnd", + "moveFirst", + "moveFocusDown", + "moveFocusLeft", + "moveFocusRight", + "moveFocusUp", + "moveNext", + "moveRow", + "moveStart", + "moveTo", + "moveToBookmark", + "moveToElementText", + "moveToPoint", + "movementX", + "movementY", + "mozAdd", + "mozAnimationStartTime", + "mozAnon", + "mozApps", + "mozAudioCaptured", + "mozAudioChannelType", + "mozAutoplayEnabled", + "mozCancelAnimationFrame", + "mozCancelFullScreen", + "mozCancelRequestAnimationFrame", + "mozCaptureStream", + "mozCaptureStreamUntilEnded", + "mozClearDataAt", + "mozContact", + "mozContacts", + "mozCreateFileHandle", + "mozCurrentTransform", + "mozCurrentTransformInverse", + "mozCursor", + "mozDash", + "mozDashOffset", + "mozDecodedFrames", + "mozExitPointerLock", + "mozFillRule", + "mozFragmentEnd", + "mozFrameDelay", + "mozFullScreen", + "mozFullScreenElement", + "mozFullScreenEnabled", + "mozGetAll", + "mozGetAllKeys", + "mozGetAsFile", + "mozGetDataAt", + "mozGetMetadata", + "mozGetUserMedia", + "mozHasAudio", + "mozHasItem", + "mozHidden", + "mozImageSmoothingEnabled", + "mozIndexedDB", + "mozInnerScreenX", + "mozInnerScreenY", + "mozInputSource", + "mozIsTextField", + "mozItem", + "mozItemCount", + "mozItems", + "mozLength", + "mozLockOrientation", + "mozMatchesSelector", + "mozMovementX", + "mozMovementY", + "mozOpaque", + "mozOrientation", + "mozPaintCount", + "mozPaintedFrames", + "mozParsedFrames", + "mozPay", + "mozPointerLockElement", + "mozPresentedFrames", + "mozPreservesPitch", + "mozPressure", + "mozPrintCallback", + "mozRTCIceCandidate", + "mozRTCPeerConnection", + "mozRTCSessionDescription", + "mozRemove", + "mozRequestAnimationFrame", + "mozRequestFullScreen", + "mozRequestPointerLock", + "mozSetDataAt", + "mozSetImageElement", + "mozSourceNode", + "mozSrcObject", + "mozSystem", + "mozTCPSocket", + "mozTextStyle", + "mozTypesAt", + "mozUnlockOrientation", + "mozUserCancelled", + "mozVisibilityState", + "ms", + "msAnimation", + "msAnimationDelay", + "msAnimationDirection", + "msAnimationDuration", + "msAnimationFillMode", + "msAnimationIterationCount", + "msAnimationName", + "msAnimationPlayState", + "msAnimationStartTime", + "msAnimationTimingFunction", + "msBackfaceVisibility", + "msBlockProgression", + "msCSSOMElementFloatMetrics", + "msCaching", + "msCachingEnabled", + "msCancelRequestAnimationFrame", + "msCapsLockWarningOff", + "msClearImmediate", + "msClose", + "msContentZoomChaining", + "msContentZoomFactor", + "msContentZoomLimit", + "msContentZoomLimitMax", + "msContentZoomLimitMin", + "msContentZoomSnap", + "msContentZoomSnapPoints", + "msContentZoomSnapType", + "msContentZooming", + "msConvertURL", + "msCrypto", + "msDoNotTrack", + "msElementsFromPoint", + "msElementsFromRect", + "msExitFullscreen", + "msExtendedCode", + "msFillRule", + "msFirstPaint", + "msFlex", + "msFlexAlign", + "msFlexDirection", + "msFlexFlow", + "msFlexItemAlign", + "msFlexLinePack", + "msFlexNegative", + "msFlexOrder", + "msFlexPack", + "msFlexPositive", + "msFlexPreferredSize", + "msFlexWrap", + "msFlowFrom", + "msFlowInto", + "msFontFeatureSettings", + "msFullscreenElement", + "msFullscreenEnabled", + "msGetInputContext", + "msGetRegionContent", + "msGetUntransformedBounds", + "msGraphicsTrustStatus", + "msGridColumn", + "msGridColumnAlign", + "msGridColumnSpan", + "msGridColumns", + "msGridRow", + "msGridRowAlign", + "msGridRowSpan", + "msGridRows", + "msHidden", + "msHighContrastAdjust", + "msHyphenateLimitChars", + "msHyphenateLimitLines", + "msHyphenateLimitZone", + "msHyphens", + "msImageSmoothingEnabled", + "msImeAlign", + "msIndexedDB", + "msInterpolationMode", + "msIsStaticHTML", + "msKeySystem", + "msKeys", + "msLaunchUri", + "msLockOrientation", + "msManipulationViewsEnabled", + "msMatchMedia", + "msMatchesSelector", + "msMaxTouchPoints", + "msOrientation", + "msOverflowStyle", + "msPerspective", + "msPerspectiveOrigin", + "msPlayToDisabled", + "msPlayToPreferredSourceUri", + "msPlayToPrimary", + "msPointerEnabled", + "msRegionOverflow", + "msReleasePointerCapture", + "msRequestAnimationFrame", + "msRequestFullscreen", + "msSaveBlob", + "msSaveOrOpenBlob", + "msScrollChaining", + "msScrollLimit", + "msScrollLimitXMax", + "msScrollLimitXMin", + "msScrollLimitYMax", + "msScrollLimitYMin", + "msScrollRails", + "msScrollSnapPointsX", + "msScrollSnapPointsY", + "msScrollSnapType", + "msScrollSnapX", + "msScrollSnapY", + "msScrollTranslation", + "msSetImmediate", + "msSetMediaKeys", + "msSetPointerCapture", + "msTextCombineHorizontal", + "msTextSizeAdjust", + "msToBlob", + "msTouchAction", + "msTouchSelect", + "msTraceAsyncCallbackCompleted", + "msTraceAsyncCallbackStarting", + "msTraceAsyncOperationCompleted", + "msTraceAsyncOperationStarting", + "msTransform", + "msTransformOrigin", + "msTransformStyle", + "msTransition", + "msTransitionDelay", + "msTransitionDuration", + "msTransitionProperty", + "msTransitionTimingFunction", + "msUnlockOrientation", + "msUpdateAsyncCallbackRelation", + "msUserSelect", + "msVisibilityState", + "msWrapFlow", + "msWrapMargin", + "msWrapThrough", + "msWriteProfilerMark", + "msZoom", + "msZoomTo", + "mt", + "mul", + "multiEntry", + "multiSelectionObj", + "multiline", + "multiple", + "multiply", + "multiplySelf", + "mutableFile", + "muted", + "n", + "name", + "nameProp", + "namedItem", + "namedRecordset", + "names", + "namespaceURI", + "namespaces", + "naturalHeight", + "naturalWidth", + "navigate", + "navigation", + "navigationMode", + "navigationPreload", + "navigationStart", + "navigationType", + "navigator", + "near", + "nearestViewportElement", + "negative", + "negotiated", + "netscape", + "networkState", + "newScale", + "newTranslate", + "newURL", + "newValue", + "newValueSpecifiedUnits", + "newVersion", + "newhome", + "next", + "nextElementSibling", + "nextHopProtocol", + "nextNode", + "nextPage", + "nextSibling", + "nickname", + "noHref", + "noModule", + "noResize", + "noShade", + "noValidate", + "noWrap", + "node", + "nodeName", + "nodeType", + "nodeValue", + "nonce", + "normalize", + "normalizedPathSegList", + "notationName", + "notations", + "note", + "noteGrainOn", + "noteOff", + "noteOn", + "notify", + "now", + "npnNegotiatedProtocol", + "numOctaves", + "number", + "numberOfChannels", + "numberOfInputs", + "numberOfItems", + "numberOfOutputs", + "numberValue", + "numberingSystem", + "numeric", + "oMatchesSelector", + "object", + "object-fit", + "object-position", + "objectFit", + "objectPosition", + "objectStore", + "objectStoreNames", + "observe", + "observedAttributes", + "of", + "offscreenBuffering", + "offset", + "offset-anchor", + "offset-block-end", + "offset-block-start", + "offset-distance", + "offset-inline-end", + "offset-inline-start", + "offset-path", + "offset-rotate", + "offsetAnchor", + "offsetBlockEnd", + "offsetBlockStart", + "offsetDistance", + "offsetHeight", + "offsetInlineEnd", + "offsetInlineStart", + "offsetLeft", + "offsetNode", + "offsetParent", + "offsetPath", + "offsetRotate", + "offsetTop", + "offsetWidth", + "offsetX", + "offsetY", + "ok", + "oldURL", + "oldValue", + "oldVersion", + "olderShadowRoot", + "onDownloadProgress", + "onInstallStageChanged", + "onLine", + "onabort", + "onabsolutedeviceorientation", + "onactivate", + "onactive", + "onaddsourcebuffer", + "onaddstream", + "onaddtrack", + "onafterprint", + "onafterscriptexecute", + "onafterupdate", + "onanimationcancel", + "onanimationend", + "onanimationiteration", + "onanimationstart", + "onappinstalled", + "onaudioend", + "onaudioprocess", + "onaudiostart", + "onautocomplete", + "onautocompleteerror", + "onauxclick", + "onbeforeactivate", + "onbeforecopy", + "onbeforecut", + "onbeforedeactivate", + "onbeforeeditfocus", + "onbeforeinput", + "onbeforeinstallprompt", + "onbeforeload", + "onbeforepaste", + "onbeforeprint", + "onbeforescriptexecute", + "onbeforeunload", + "onbeforeupdate", + "onbeforexrselect", + "onbegin", + "onblocked", + "onblur", + "onbounce", + "onboundary", + "onbufferedamountlow", + "oncached", + "oncancel", + "oncandidatewindowhide", + "oncandidatewindowshow", + "oncandidatewindowupdate", + "oncanplay", + "oncanplaythrough", + "once", + "oncellchange", + "onchange", + "oncharacteristicvaluechanged", + "onchargingchange", + "onchargingtimechange", + "onchecking", + "onclick", + "onclose", + "onclosing", + "oncompassneedscalibration", + "oncomplete", + "onconnect", + "onconnecting", + "onconnectionavailable", + "onconnectionstatechange", + "oncontactchange", + "oncontextmenu", + "oncontrollerchange", + "oncontrolselect", + "oncopy", + "oncuechange", + "oncut", + "ondataavailable", + "ondatachannel", + "ondatasetchanged", + "ondatasetcomplete", + "ondblclick", + "ondeactivate", + "ondevicechange", + "ondevicelight", + "ondevicemotion", + "ondeviceorientation", + "ondeviceorientationabsolute", + "ondeviceproximity", + "ondischargingtimechange", + "ondisconnect", + "ondisplay", + "ondownloading", + "ondrag", + "ondragend", + "ondragenter", + "ondragexit", + "ondragleave", + "ondragover", + "ondragstart", + "ondrop", + "ondurationchange", + "onemptied", + "onencrypted", + "onend", + "onended", + "onenter", + "onenterpictureinpicture", + "onerror", + "onerrorupdate", + "onexit", + "onfilterchange", + "onfinish", + "onfocus", + "onfocusin", + "onfocusout", + "onformdata", + "onfreeze", + "onfullscreenchange", + "onfullscreenerror", + "ongatheringstatechange", + "ongattserverdisconnected", + "ongesturechange", + "ongestureend", + "ongesturestart", + "ongotpointercapture", + "onhashchange", + "onhelp", + "onicecandidate", + "onicecandidateerror", + "oniceconnectionstatechange", + "onicegatheringstatechange", + "oninactive", + "oninput", + "oninputsourceschange", + "oninvalid", + "onkeydown", + "onkeypress", + "onkeystatuseschange", + "onkeyup", + "onlanguagechange", + "onlayoutcomplete", + "onleavepictureinpicture", + "onlevelchange", + "onload", + "onloadT", + "onloadeddata", + "onloadedmetadata", + "onloadend", + "onloading", + "onloadingdone", + "onloadingerror", + "onloadstart", + "onlosecapture", + "onlostpointercapture", + "only", + "onmark", + "onmessage", + "onmessageerror", + "onmidimessage", + "onmousedown", + "onmouseenter", + "onmouseleave", + "onmousemove", + "onmouseout", + "onmouseover", + "onmouseup", + "onmousewheel", + "onmove", + "onmoveend", + "onmovestart", + "onmozfullscreenchange", + "onmozfullscreenerror", + "onmozorientationchange", + "onmozpointerlockchange", + "onmozpointerlockerror", + "onmscontentzoom", + "onmsfullscreenchange", + "onmsfullscreenerror", + "onmsgesturechange", + "onmsgesturedoubletap", + "onmsgestureend", + "onmsgesturehold", + "onmsgesturestart", + "onmsgesturetap", + "onmsgotpointercapture", + "onmsinertiastart", + "onmslostpointercapture", + "onmsmanipulationstatechanged", + "onmsneedkey", + "onmsorientationchange", + "onmspointercancel", + "onmspointerdown", + "onmspointerenter", + "onmspointerhover", + "onmspointerleave", + "onmspointermove", + "onmspointerout", + "onmspointerover", + "onmspointerup", + "onmssitemodejumplistitemremoved", + "onmsthumbnailclick", + "onmute", + "onnegotiationneeded", + "onnomatch", + "onnoupdate", + "onobsolete", + "onoffline", + "ononline", + "onopen", + "onorientationchange", + "onoverconstrained", + "onpage", + "onpagechange", + "onpagehide", + "onpageshow", + "onpaste", + "onpause", + "onpayerdetailchange", + "onpaymentmethodchange", + "onplay", + "onplaying", + "onpluginstreamstart", + "onpointercancel", + "onpointerdown", + "onpointerenter", + "onpointerleave", + "onpointerlockchange", + "onpointerlockerror", + "onpointermove", + "onpointerout", + "onpointerover", + "onpointerrawupdate", + "onpointerup", + "onpopstate", + "onprocessorerror", + "onprogress", + "onpropertychange", + "onratechange", + "onreading", + "onreadystatechange", + "onrejectionhandled", + "onrelease", + "onremove", + "onremovesourcebuffer", + "onremovestream", + "onremovetrack", + "onrepeat", + "onreset", + "onresize", + "onresizeend", + "onresizestart", + "onresourcetimingbufferfull", + "onresult", + "onresume", + "onrowenter", + "onrowexit", + "onrowsdelete", + "onrowsinserted", + "onscroll", + "onsearch", + "onsecuritypolicyviolation", + "onseeked", + "onseeking", + "onselect", + "onselectedcandidatepairchange", + "onselectend", + "onselectionchange", + "onselectstart", + "onshippingaddresschange", + "onshippingoptionchange", + "onshow", + "onsignalingstatechange", + "onsoundend", + "onsoundstart", + "onsourceclose", + "onsourceclosed", + "onsourceended", + "onsourceopen", + "onspeechend", + "onspeechstart", + "onsqueeze", + "onsqueezeend", + "onsqueezestart", + "onstalled", + "onstart", + "onstatechange", + "onstop", + "onstorage", + "onstoragecommit", + "onsubmit", + "onsuccess", + "onsuspend", + "onterminate", + "ontextinput", + "ontimeout", + "ontimeupdate", + "ontoggle", + "ontonechange", + "ontouchcancel", + "ontouchend", + "ontouchmove", + "ontouchstart", + "ontrack", + "ontransitioncancel", + "ontransitionend", + "ontransitionrun", + "ontransitionstart", + "onunhandledrejection", + "onunload", + "onunmute", + "onupdate", + "onupdateend", + "onupdatefound", + "onupdateready", + "onupdatestart", + "onupgradeneeded", + "onuserproximity", + "onversionchange", + "onvisibilitychange", + "onvoiceschanged", + "onvolumechange", + "onvrdisplayactivate", + "onvrdisplayconnect", + "onvrdisplaydeactivate", + "onvrdisplaydisconnect", + "onvrdisplaypresentchange", + "onwaiting", + "onwaitingforkey", + "onwarning", + "onwebkitanimationend", + "onwebkitanimationiteration", + "onwebkitanimationstart", + "onwebkitcurrentplaybacktargetiswirelesschanged", + "onwebkitfullscreenchange", + "onwebkitfullscreenerror", + "onwebkitkeyadded", + "onwebkitkeyerror", + "onwebkitkeymessage", + "onwebkitmouseforcechanged", + "onwebkitmouseforcedown", + "onwebkitmouseforceup", + "onwebkitmouseforcewillbegin", + "onwebkitneedkey", + "onwebkitorientationchange", + "onwebkitplaybacktargetavailabilitychanged", + "onwebkitpointerlockchange", + "onwebkitpointerlockerror", + "onwebkitresourcetimingbufferfull", + "onwebkittransitionend", + "onwheel", + "onzoom", + "opacity", + "open", + "openCursor", + "openDatabase", + "openKeyCursor", + "opened", + "opener", + "opera", + "operationType", + "operator", + "opr", + "opsProfile", + "optimum", + "options", + "or", + "order", + "orderX", + "orderY", + "ordered", + "org", + "organization", + "orient", + "orientAngle", + "orientType", + "orientation", + "orientationX", + "orientationY", + "orientationZ", + "origin", + "originalPolicy", + "originalTarget", + "orphans", + "oscpu", + "outcome", + "outerHTML", + "outerHeight", + "outerText", + "outerWidth", + "outline", + "outline-color", + "outline-offset", + "outline-style", + "outline-width", + "outlineColor", + "outlineOffset", + "outlineStyle", + "outlineWidth", + "outputBuffer", + "outputLatency", + "outputs", + "overflow", + "overflow-anchor", + "overflow-block", + "overflow-inline", + "overflow-wrap", + "overflow-x", + "overflow-y", + "overflowAnchor", + "overflowBlock", + "overflowInline", + "overflowWrap", + "overflowX", + "overflowY", + "overrideMimeType", + "oversample", + "overscroll-behavior", + "overscroll-behavior-block", + "overscroll-behavior-inline", + "overscroll-behavior-x", + "overscroll-behavior-y", + "overscrollBehavior", + "overscrollBehaviorBlock", + "overscrollBehaviorInline", + "overscrollBehaviorX", + "overscrollBehaviorY", + "ownKeys", + "ownerDocument", + "ownerElement", + "ownerNode", + "ownerRule", + "ownerSVGElement", + "owningElement", + "p1", + "p2", + "p3", + "p4", + "packetSize", + "packets", + "pad", + "padEnd", + "padStart", + "padding", + "padding-block", + "padding-block-end", + "padding-block-start", + "padding-bottom", + "padding-inline", + "padding-inline-end", + "padding-inline-start", + "padding-left", + "padding-right", + "padding-top", + "paddingBlock", + "paddingBlockEnd", + "paddingBlockStart", + "paddingBottom", + "paddingInline", + "paddingInlineEnd", + "paddingInlineStart", + "paddingLeft", + "paddingRight", + "paddingTop", + "page", + "page-break-after", + "page-break-before", + "page-break-inside", + "pageBreakAfter", + "pageBreakBefore", + "pageBreakInside", + "pageCount", + "pageLeft", + "pageT", + "pageTop", + "pageX", + "pageXOffset", + "pageY", + "pageYOffset", + "pages", + "paint-order", + "paintOrder", + "paintRequests", + "paintType", + "paintWorklet", + "palette", + "pan", + "panningModel", + "parameters", + "parent", + "parentElement", + "parentNode", + "parentRule", + "parentStyleSheet", + "parentTextEdit", + "parentWindow", + "parse", + "parseAll", + "parseFloat", + "parseFromString", + "parseInt", + "part", + "participants", + "passive", + "password", + "pasteHTML", + "path", + "pathLength", + "pathSegList", + "pathSegType", + "pathSegTypeAsLetter", + "pathname", + "pattern", + "patternContentUnits", + "patternMismatch", + "patternTransform", + "patternUnits", + "pause", + "pauseAnimations", + "pauseOnExit", + "pauseTransformFeedback", + "paused", + "payerEmail", + "payerName", + "payerPhone", + "paymentManager", + "pc", + "peerIdentity", + "pending", + "pendingLocalDescription", + "pendingRemoteDescription", + "percent", + "performance", + "periodicSync", + "permission", + "permissionState", + "permissions", + "persist", + "persisted", + "personalbar", + "perspective", + "perspective-origin", + "perspectiveOrigin", + "perspectiveOriginX", + "perspectiveOriginY", + "phone", + "phoneticFamilyName", + "phoneticGivenName", + "photo", + "pictureInPictureElement", + "pictureInPictureEnabled", + "pictureInPictureWindow", + "ping", + "pipeThrough", + "pipeTo", + "pitch", + "pixelBottom", + "pixelDepth", + "pixelHeight", + "pixelLeft", + "pixelRight", + "pixelStorei", + "pixelTop", + "pixelUnitToMillimeterX", + "pixelUnitToMillimeterY", + "pixelWidth", + "place-content", + "place-items", + "place-self", + "placeContent", + "placeItems", + "placeSelf", + "placeholder", + "platform", + "platforms", + "play", + "playEffect", + "playState", + "playbackRate", + "playbackState", + "playbackTime", + "played", + "playoutDelayHint", + "playsInline", + "plugins", + "pluginspage", + "pname", + "pointer-events", + "pointerBeforeReferenceNode", + "pointerEnabled", + "pointerEvents", + "pointerId", + "pointerLockElement", + "pointerType", + "points", + "pointsAtX", + "pointsAtY", + "pointsAtZ", + "polygonOffset", + "pop", + "populateMatrix", + "popupWindowFeatures", + "popupWindowName", + "popupWindowURI", + "port", + "port1", + "port2", + "ports", + "posBottom", + "posHeight", + "posLeft", + "posRight", + "posTop", + "posWidth", + "pose", + "position", + "positionAlign", + "positionX", + "positionY", + "positionZ", + "postError", + "postMessage", + "postalCode", + "poster", + "pow", + "powerEfficient", + "powerOff", + "preMultiplySelf", + "precision", + "preferredStyleSheetSet", + "preferredStylesheetSet", + "prefix", + "preload", + "prepend", + "presentation", + "preserveAlpha", + "preserveAspectRatio", + "preserveAspectRatioString", + "pressed", + "pressure", + "prevValue", + "preventDefault", + "preventExtensions", + "preventSilentAccess", + "previousElementSibling", + "previousNode", + "previousPage", + "previousRect", + "previousScale", + "previousSibling", + "previousTranslate", + "primaryKey", + "primitiveType", + "primitiveUnits", + "principals", + "print", + "priority", + "privateKey", + "probablySupportsContext", + "process", + "processIceMessage", + "processingEnd", + "processingStart", + "product", + "productId", + "productName", + "productSub", + "profile", + "profileEnd", + "profiles", + "projectionMatrix", + "promise", + "prompt", + "properties", + "propertyIsEnumerable", + "propertyName", + "protocol", + "protocolLong", + "prototype", + "provider", + "pseudoClass", + "pseudoElement", + "pt", + "publicId", + "publicKey", + "published", + "pulse", + "push", + "pushManager", + "pushNotification", + "pushState", + "put", + "putImageData", + "px", + "quadraticCurveTo", + "qualifier", + "quaternion", + "query", + "queryCommandEnabled", + "queryCommandIndeterm", + "queryCommandState", + "queryCommandSupported", + "queryCommandText", + "queryCommandValue", + "querySelector", + "querySelectorAll", + "queryUsageAndQuota", + "queueMicrotask", + "quote", + "quotes", + "r", + "r1", + "r2", + "race", + "rad", + "radiogroup", + "radiusX", + "radiusY", + "random", + "range", + "rangeCount", + "rangeMax", + "rangeMin", + "rangeOffset", + "rangeOverflow", + "rangeParent", + "rangeUnderflow", + "rate", + "ratio", + "raw", + "rawId", + "read", + "readAsArrayBuffer", + "readAsBinaryString", + "readAsBlob", + "readAsDataURL", + "readAsText", + "readBuffer", + "readEntries", + "readOnly", + "readPixels", + "readReportRequested", + "readText", + "readTransaction", + "readValue", + "readable", + "ready", + "readyState", + "reason", + "reboot", + "receivedAlert", + "receivedTime", + "receiver", + "receivers", + "recipient", + "reconnect", + "record", + "recordEnd", + "recordNumber", + "recordsAvailable", + "recordset", + "rect", + "red", + "redEyeReduction", + "redirect", + "redirectCount", + "redirectEnd", + "redirectStart", + "redirected", + "reduce", + "reduceRight", + "reduction", + "refDistance", + "refX", + "refY", + "referenceNode", + "referenceSpace", + "referrer", + "referrerPolicy", + "refresh", + "region", + "regionAnchorX", + "regionAnchorY", + "regionId", + "regions", + "register", + "registerContentHandler", + "registerElement", + "registerProperty", + "registerProtocolHandler", + "reject", + "rel", + "relList", + "relatedAddress", + "relatedNode", + "relatedPort", + "relatedTarget", + "release", + "releaseCapture", + "releaseEvents", + "releaseInterface", + "releaseLock", + "releasePointerCapture", + "releaseShaderCompiler", + "reliable", + "reliableWrite", + "reload", + "rem", + "remainingSpace", + "remote", + "remoteDescription", + "remove", + "removeAllRanges", + "removeAttribute", + "removeAttributeNS", + "removeAttributeNode", + "removeBehavior", + "removeChild", + "removeCue", + "removeEventListener", + "removeFilter", + "removeImport", + "removeItem", + "removeListener", + "removeNamedItem", + "removeNamedItemNS", + "removeNode", + "removeParameter", + "removeProperty", + "removeRange", + "removeRegion", + "removeRule", + "removeRules", + "removeSiteSpecificTrackingException", + "removeSourceBuffer", + "removeStream", + "removeTrack", + "removeVariable", + "removeWakeLockListener", + "removeWebWideTrackingException", + "removed", + "removedNodes", + "renderHeight", + "renderState", + "renderTime", + "renderWidth", + "renderbufferStorage", + "renderbufferStorageMultisample", + "renderedBuffer", + "renderingMode", + "renotify", + "repeat", + "replace", + "replaceAdjacentText", + "replaceAll", + "replaceChild", + "replaceChildren", + "replaceData", + "replaceId", + "replaceItem", + "replaceNode", + "replaceState", + "replaceSync", + "replaceTrack", + "replaceWholeText", + "replaceWith", + "reportValidity", + "request", + "requestAnimationFrame", + "requestAutocomplete", + "requestData", + "requestDevice", + "requestFrame", + "requestFullscreen", + "requestHitTestSource", + "requestHitTestSourceForTransientInput", + "requestId", + "requestIdleCallback", + "requestMIDIAccess", + "requestMediaKeySystemAccess", + "requestPermission", + "requestPictureInPicture", + "requestPointerLock", + "requestPresent", + "requestQuota", + "requestReferenceSpace", + "requestSession", + "requestStart", + "requestStorageAccess", + "requestSubmit", + "requestTime", + "requestVideoFrameCallback", + "requestedLocale", + "requestingWindow", + "requireInteraction", + "required", + "requiredExtensions", + "requiredFeatures", + "reset", + "resetPose", + "resetTransform", + "resize", + "resizeBy", + "resizeTo", + "resolve", + "resolved", + "resolvedOptions", + "resource-history", + "resourcesFramesExpanded", + "response", + "responseBody", + "responseEnd", + "responseReady", + "responseStart", + "responseText", + "responseType", + "responseURL", + "responseXML", + "restartIce", + "restore", + "result", + "resultIndex", + "resultType", + "results", + "resume", + "resumeTransformFeedback", + "retry", + "returnValue", + "rev", + "reverse", + "reversed", + "revocable", + "revokeObjectURL", + "rgbColor", + "right", + "rightContext", + "rightDegrees", + "rightMargin", + "rightProjectionMatrix", + "rightViewMatrix", + "role", + "rolloffFactor", + "root", + "rootBounds", + "rootElement", + "rootMargin", + "rotate", + "rotateAxisAngle", + "rotateAxisAngleSelf", + "rotateFromVector", + "rotateFromVectorSelf", + "rotateSelf", + "rotation", + "rotationAngle", + "rotationRate", + "round", + "row-gap", + "rowGap", + "rowIndex", + "rowSpan", + "rows", + "rowsAffected", + "rtcpTransport", + "rtt", + "ruby-align", + "ruby-position", + "rubyAlign", + "rubyOverhang", + "rubyPosition", + "rules", + "runningState", + "runtime", + "runtimeStyle", + "rx", + "ry", + "s", + "safari", + "sample", + "sampleCoverage", + "sampleRate", + "samplerParameterf", + "samplerParameteri", + "sandbox", + "save", + "saveData", + "scale", + "scale3d", + "scale3dSelf", + "scaleNonUniform", + "scaleNonUniformSelf", + "scaleSelf", + "scheme", + "scissor", + "scope", + "scopeName", + "scoped", + "screen", + "screenBrightness", + "screenEnabled", + "screenLeft", + "screenPixelToMillimeterX", + "screenPixelToMillimeterY", + "screenTop", + "screenX", + "screenY", + "script", + "scriptURL", + "scripts", + "scroll", + "scroll-behavior", + "scroll-margin", + "scroll-margin-block", + "scroll-margin-block-end", + "scroll-margin-block-start", + "scroll-margin-bottom", + "scroll-margin-inline", + "scroll-margin-inline-end", + "scroll-margin-inline-start", + "scroll-margin-left", + "scroll-margin-right", + "scroll-margin-top", + "scroll-padding", + "scroll-padding-block", + "scroll-padding-block-end", + "scroll-padding-block-start", + "scroll-padding-bottom", + "scroll-padding-inline", + "scroll-padding-inline-end", + "scroll-padding-inline-start", + "scroll-padding-left", + "scroll-padding-right", + "scroll-padding-top", + "scroll-snap-align", + "scroll-snap-coordinate", + "scroll-snap-destination", + "scroll-snap-points-x", + "scroll-snap-points-y", + "scroll-snap-type", + "scroll-snap-type-x", + "scroll-snap-type-y", + "scrollAmount", + "scrollBehavior", + "scrollBy", + "scrollByLines", + "scrollByPages", + "scrollDelay", + "scrollHeight", + "scrollIntoView", + "scrollIntoViewIfNeeded", + "scrollLeft", + "scrollLeftMax", + "scrollMargin", + "scrollMarginBlock", + "scrollMarginBlockEnd", + "scrollMarginBlockStart", + "scrollMarginBottom", + "scrollMarginInline", + "scrollMarginInlineEnd", + "scrollMarginInlineStart", + "scrollMarginLeft", + "scrollMarginRight", + "scrollMarginTop", + "scrollMaxX", + "scrollMaxY", + "scrollPadding", + "scrollPaddingBlock", + "scrollPaddingBlockEnd", + "scrollPaddingBlockStart", + "scrollPaddingBottom", + "scrollPaddingInline", + "scrollPaddingInlineEnd", + "scrollPaddingInlineStart", + "scrollPaddingLeft", + "scrollPaddingRight", + "scrollPaddingTop", + "scrollRestoration", + "scrollSnapAlign", + "scrollSnapCoordinate", + "scrollSnapDestination", + "scrollSnapMargin", + "scrollSnapMarginBottom", + "scrollSnapMarginLeft", + "scrollSnapMarginRight", + "scrollSnapMarginTop", + "scrollSnapPointsX", + "scrollSnapPointsY", + "scrollSnapStop", + "scrollSnapType", + "scrollSnapTypeX", + "scrollSnapTypeY", + "scrollTo", + "scrollTop", + "scrollTopMax", + "scrollWidth", + "scrollX", + "scrollY", + "scrollbar-color", + "scrollbar-width", + "scrollbar3dLightColor", + "scrollbarArrowColor", + "scrollbarBaseColor", + "scrollbarColor", + "scrollbarDarkShadowColor", + "scrollbarFaceColor", + "scrollbarHighlightColor", + "scrollbarShadowColor", + "scrollbarTrackColor", + "scrollbarWidth", + "scrollbars", + "scrolling", + "scrollingElement", + "sctp", + "sctpCauseCode", + "sdp", + "sdpLineNumber", + "sdpMLineIndex", + "sdpMid", + "seal", + "search", + "searchBox", + "searchBoxJavaBridge_", + "searchParams", + "second", + "sectionRowIndex", + "secureConnectionStart", + "security", + "seed", + "seekToNextFrame", + "seekable", + "seeking", + "select", + "selectAllChildren", + "selectAlternateInterface", + "selectConfiguration", + "selectNode", + "selectNodeContents", + "selectNodes", + "selectSingleNode", + "selectSubString", + "selected", + "selectedIndex", + "selectedOption", + "selectedOptions", + "selectedStyleSheetSet", + "selectedStylesheetSet", + "selection", + "selectionDirection", + "selectionEnd", + "selectionStart", + "selector", + "selectorText", + "self", + "send", + "sendAsBinary", + "sendBeacon", + "sendMessage", + "sender", + "sensitivity", + "sentAlert", + "sentTimestamp", + "separator", + "serialNumber", + "serializeToString", + "serverTiming", + "service", + "serviceWorker", + "session", + "sessionId", + "sessionStorage", + "set", + "setActionHandler", + "setActive", + "setAlpha", + "setAppBadge", + "setAttribute", + "setAttributeNS", + "setAttributeNode", + "setAttributeNodeNS", + "setBaseAndExtent", + "setBigInt64", + "setBigUint64", + "setBingCurrentSearchDefault", + "setCapture", + "setCodecPreferences", + "setColor", + "setCompositeOperation", + "setConfiguration", + "setCurrentTime", + "setCustomValidity", + "setData", + "setDate", + "setDirection", + "setDragImage", + "setEnd", + "setEndAfter", + "setEndBefore", + "setEndPoint", + "setFillColor", + "setFilterRes", + "setFloat32", + "setFloat64", + "setFloatValue", + "setFormValue", + "setFullYear", + "setHeaderValue", + "setHours", + "setIdentityProvider", + "setImmediate", + "setInt16", + "setInt32", + "setInt8", + "setInterval", + "setItem", + "setKeyframes", + "setLineCap", + "setLineDash", + "setLineJoin", + "setLineWidth", + "setLiveSeekableRange", + "setLocalDescription", + "setMatrix", + "setMatrixValue", + "setMediaKeys", + "setMilliseconds", + "setMinutes", + "setMiterLimit", + "setMonth", + "setNamedItem", + "setNamedItemNS", + "setNonUserCodeExceptions", + "setOrientToAngle", + "setOrientToAuto", + "setOrientation", + "setOverrideHistoryNavigationMode", + "setPaint", + "setParameter", + "setParameters", + "setPeriodicWave", + "setPointerCapture", + "setPosition", + "setPositionState", + "setPreference", + "setProperty", + "setPrototypeOf", + "setRGBColor", + "setRGBColorICCColor", + "setRadius", + "setRangeText", + "setRemoteDescription", + "setRequestHeader", + "setResizable", + "setResourceTimingBufferSize", + "setRotate", + "setScale", + "setSeconds", + "setSelectionRange", + "setServerCertificate", + "setShadow", + "setSinkId", + "setSkewX", + "setSkewY", + "setStart", + "setStartAfter", + "setStartBefore", + "setStdDeviation", + "setStreams", + "setStringValue", + "setStrokeColor", + "setSuggestResult", + "setTargetAtTime", + "setTargetValueAtTime", + "setTime", + "setTimeout", + "setTransform", + "setTranslate", + "setUTCDate", + "setUTCFullYear", + "setUTCHours", + "setUTCMilliseconds", + "setUTCMinutes", + "setUTCMonth", + "setUTCSeconds", + "setUint16", + "setUint32", + "setUint8", + "setUri", + "setValidity", + "setValueAtTime", + "setValueCurveAtTime", + "setVariable", + "setVelocity", + "setVersion", + "setYear", + "settingName", + "settingValue", + "sex", + "shaderSource", + "shadowBlur", + "shadowColor", + "shadowOffsetX", + "shadowOffsetY", + "shadowRoot", + "shape", + "shape-image-threshold", + "shape-margin", + "shape-outside", + "shape-rendering", + "shapeImageThreshold", + "shapeMargin", + "shapeOutside", + "shapeRendering", + "sheet", + "shift", + "shiftKey", + "shiftLeft", + "shippingAddress", + "shippingOption", + "shippingType", + "show", + "showHelp", + "showModal", + "showModalDialog", + "showModelessDialog", + "showNotification", + "sidebar", + "sign", + "signal", + "signalingState", + "signature", + "silent", + "sin", + "singleNodeValue", + "sinh", + "sinkId", + "sittingToStandingTransform", + "size", + "sizeToContent", + "sizeX", + "sizeZ", + "sizes", + "skewX", + "skewXSelf", + "skewY", + "skewYSelf", + "slice", + "slope", + "slot", + "small", + "smil", + "smooth", + "smoothingTimeConstant", + "snapToLines", + "snapshotItem", + "snapshotLength", + "some", + "sort", + "sortingCode", + "source", + "sourceBuffer", + "sourceBuffers", + "sourceCapabilities", + "sourceFile", + "sourceIndex", + "sourceURL", + "sources", + "spacing", + "span", + "speak", + "speakAs", + "speaking", + "species", + "specified", + "specularConstant", + "specularExponent", + "speechSynthesis", + "speed", + "speedOfSound", + "spellcheck", + "splice", + "split", + "splitText", + "spreadMethod", + "sqrt", + "src", + "srcElement", + "srcFilter", + "srcObject", + "srcUrn", + "srcdoc", + "srclang", + "srcset", + "stack", + "stackTraceLimit", + "stacktrace", + "stageParameters", + "standalone", + "standby", + "start", + "startContainer", + "startE", + "startIce", + "startLoadTime", + "startMessages", + "startNotifications", + "startOffset", + "startRendering", + "startSoftwareUpdate", + "startTime", + "startsWith", + "state", + "status", + "statusCode", + "statusMessage", + "statusText", + "statusbar", + "stdDeviationX", + "stdDeviationY", + "stencilFunc", + "stencilFuncSeparate", + "stencilMask", + "stencilMaskSeparate", + "stencilOp", + "stencilOpSeparate", + "step", + "stepDown", + "stepMismatch", + "stepUp", + "sticky", + "stitchTiles", + "stop", + "stop-color", + "stop-opacity", + "stopColor", + "stopImmediatePropagation", + "stopNotifications", + "stopOpacity", + "stopPropagation", + "stopped", + "storage", + "storageArea", + "storageName", + "storageStatus", + "store", + "storeSiteSpecificTrackingException", + "storeWebWideTrackingException", + "stpVersion", + "stream", + "streams", + "strength", + "stretch", + "strike", + "stringValue", + "stringify", + "stroke", + "stroke-dasharray", + "stroke-dashoffset", + "stroke-linecap", + "stroke-linejoin", + "stroke-miterlimit", + "stroke-opacity", + "stroke-width", + "strokeColor", + "strokeDasharray", + "strokeDashoffset", + "strokeLinecap", + "strokeLinejoin", + "strokeMiterlimit", + "strokeOpacity", + "strokeRect", + "strokeStyle", + "strokeText", + "strokeWidth", + "style", + "styleFloat", + "styleMap", + "styleMedia", + "styleSheet", + "styleSheetSets", + "styleSheets", + "sub", + "subarray", + "subject", + "submit", + "submitFrame", + "submitter", + "subscribe", + "substr", + "substring", + "substringData", + "subtle", + "subtree", + "suffix", + "suffixes", + "summary", + "sup", + "supported", + "supportedContentEncodings", + "supportedEntryTypes", + "supportedLocalesOf", + "supports", + "supportsSession", + "surfaceScale", + "surroundContents", + "suspend", + "suspendRedraw", + "swapCache", + "swapNode", + "sweepFlag", + "symbols", + "sync", + "sysexEnabled", + "system", + "systemCode", + "systemId", + "systemLanguage", + "systemXDPI", + "systemYDPI", + "tBodies", + "tFoot", + "tHead", + "tabIndex", + "tabSize", + "table", + "table-layout", + "tableLayout", + "tableValues", + "tag", + "tagName", + "tagUrn", + "tags", + "taintEnabled", + "takeHeapSnapshot", + "takePhoto", + "takeRecords", + "tan", + "tangentialPressure", + "tanh", + "target", + "targetElement", + "targetRayMode", + "targetRaySpace", + "targetTouches", + "targetX", + "targetY", + "tcpType", + "tee", + "tel", + "terminate", + "test", + "texImage2D", + "texImage3D", + "texParameterf", + "texParameteri", + "texStorage2D", + "texStorage3D", + "texSubImage2D", + "texSubImage3D", + "text", + "text-align", + "text-align-last", + "text-anchor", + "text-combine-upright", + "text-decoration", + "text-decoration-color", + "text-decoration-line", + "text-decoration-skip-ink", + "text-decoration-style", + "text-decoration-thickness", + "text-emphasis", + "text-emphasis-color", + "text-emphasis-position", + "text-emphasis-style", + "text-indent", + "text-justify", + "text-orientation", + "text-overflow", + "text-rendering", + "text-shadow", + "text-transform", + "text-underline-offset", + "text-underline-position", + "text/pdf", + "textAlign", + "textAlignLast", + "textAnchor", + "textAutospace", + "textBaseline", + "textCombineUpright", + "textContent", + "textDecoration", + "textDecorationBlink", + "textDecorationColor", + "textDecorationLine", + "textDecorationLineThrough", + "textDecorationNone", + "textDecorationOverline", + "textDecorationSkipInk", + "textDecorationStyle", + "textDecorationThickness", + "textDecorationUnderline", + "textEmphasis", + "textEmphasisColor", + "textEmphasisPosition", + "textEmphasisStyle", + "textIndent", + "textJustify", + "textJustifyTrim", + "textKashida", + "textKashidaSpace", + "textLength", + "textOrientation", + "textOverflow", + "textRendering", + "textShadow", + "textSizeAdjust", + "textTracks", + "textTransform", + "textUnderlineOffset", + "textUnderlinePosition", + "then", + "threadId", + "threshold", + "thresholds", + "tiltX", + "tiltY", + "time", + "timeEnd", + "timeLog", + "timeOrigin", + "timeRemaining", + "timeStamp", + "timeZone", + "timeZoneName", + "timecode", + "timeline", + "timelineEnd", + "timelineTime", + "timeout", + "timestamp", + "timestampOffset", + "timing", + "title", + "to", + "toArray", + "toBlob", + "toDataURL", + "toDateString", + "toElement", + "toExponential", + "toFixed", + "toFloat32Array", + "toFloat64Array", + "toGMTString", + "toISOString", + "toJSON", + "toLocaleDateString", + "toLocaleFormat", + "toLocaleLowerCase", + "toLocaleString", + "toLocaleTimeString", + "toLocaleUpperCase", + "toLowerCase", + "toMatrix", + "toMethod", + "toPrecision", + "toPrimitive", + "toSdp", + "toSource", + "toStaticHTML", + "toString", + "toStringTag", + "toSum", + "toTimeString", + "toUTCString", + "toUpperCase", + "toggle", + "toggleAttribute", + "toggleLongPressEnabled", + "tone", + "toneBuffer", + "tooLong", + "tooShort", + "toolbar", + "top", + "topMargin", + "total", + "totalFrameDelay", + "totalJSHeapSize", + "totalSize", + "totalVideoFrames", + "touch-action", + "touchAction", + "touched", + "touches", + "trace", + "track", + "trackVisibility", + "tran", + "transaction", + "transactions", + "transceiver", + "transferControlToOffscreen", + "transferFromImageBitmap", + "transferImageBitmap", + "transferIn", + "transferOut", + "transferSize", + "transferToImageBitmap", + "transform", + "transform-box", + "transform-origin", + "transform-style", + "transformBox", + "transformFeedbackVaryings", + "transformOrigin", + "transformOriginX", + "transformOriginY", + "transformOriginZ", + "transformPoint", + "transformString", + "transformStyle", + "transformToDocument", + "transformToFragment", + "transition", + "transition-delay", + "transition-duration", + "transition-property", + "transition-timing-function", + "transitionDelay", + "transitionDuration", + "transitionProperty", + "transitionTimingFunction", + "translate", + "translateSelf", + "translationX", + "translationY", + "transport", + "trim", + "trimEnd", + "trimLeft", + "trimRight", + "trimStart", + "trueSpeed", + "trunc", + "truncate", + "trustedTypes", + "turn", + "twist", + "type", + "typeDetail", + "typeMismatch", + "typeMustMatch", + "types", + "tz", + "u2f", + "ubound", + "undefined", + "unescape", + "uneval", + "unicode", + "unicode-bidi", + "unicodeBidi", + "unicodeRange", + "uniform1f", + "uniform1fv", + "uniform1i", + "uniform1iv", + "uniform1ui", + "uniform1uiv", + "uniform2f", + "uniform2fv", + "uniform2i", + "uniform2iv", + "uniform2ui", + "uniform2uiv", + "uniform3f", + "uniform3fv", + "uniform3i", + "uniform3iv", + "uniform3ui", + "uniform3uiv", + "uniform4f", + "uniform4fv", + "uniform4i", + "uniform4iv", + "uniform4ui", + "uniform4uiv", + "uniformBlockBinding", + "uniformMatrix2fv", + "uniformMatrix2x3fv", + "uniformMatrix2x4fv", + "uniformMatrix3fv", + "uniformMatrix3x2fv", + "uniformMatrix3x4fv", + "uniformMatrix4fv", + "uniformMatrix4x2fv", + "uniformMatrix4x3fv", + "unique", + "uniqueID", + "uniqueNumber", + "unit", + "unitType", + "units", + "unloadEventEnd", + "unloadEventStart", + "unlock", + "unmount", + "unobserve", + "unpause", + "unpauseAnimations", + "unreadCount", + "unregister", + "unregisterContentHandler", + "unregisterProtocolHandler", + "unscopables", + "unselectable", + "unshift", + "unsubscribe", + "unsuspendRedraw", + "unsuspendRedrawAll", + "unwatch", + "unwrapKey", + "upDegrees", + "upX", + "upY", + "upZ", + "update", + "updateCommands", + "updateEnabled", + "updateIce", + "updateInterval", + "updatePlaybackRate", + "updateRenderState", + "updateSettings", + "updateTiming", + "updateViaCache", + "updateWith", + "updated", + "updating", + "upgrade", + "upload", + "uploadTotal", + "uploaded", + "upper", + "upperBound", + "upperOpen", + "uri", + "url", + "urn", + "urns", + "usage", + "usages", + "usb", + "usbVersionMajor", + "usbVersionMinor", + "usbVersionSubminor", + "useCurrentView", + "useGrouping", + "useMap", + "useProgram", + "usedJSHeapSize", + "usedSpace", + "user-select", + "userActivation", + "userAgent", + "userChoice", + "userHandle", + "userHint", + "userLanguage", + "userProfile", + "userSelect", + "userVisibleOnly", + "userZoom", + "username", + "usernameFragment", + "utterance", + "uuid", + "v8BreakIterator", + "v8Parse", + "vAlign", + "vLink", + "valid", + "validate", + "validateProgram", + "validationMessage", + "validity", + "value", + "valueAsDate", + "valueAsNumber", + "valueAsString", + "valueInSpecifiedUnits", + "valueMissing", + "valueOf", + "valueText", + "valueType", + "values", + "variable", + "variant", + "vector-effect", + "vectorEffect", + "velocityAngular", + "velocityExpansion", + "velocityX", + "velocityY", + "vendor", + "vendorId", + "vendorSub", + "verify", + "version", + "vertexAttrib1f", + "vertexAttrib1fv", + "vertexAttrib2f", + "vertexAttrib2fv", + "vertexAttrib3f", + "vertexAttrib3fv", + "vertexAttrib4f", + "vertexAttrib4fv", + "vertexAttribDivisor", + "vertexAttribDivisorANGLE", + "vertexAttribI4i", + "vertexAttribI4iv", + "vertexAttribI4ui", + "vertexAttribI4uiv", + "vertexAttribIPointer", + "vertexAttribPointer", + "vertical", + "vertical-align", + "verticalAlign", + "verticalOverflow", + "vh", + "vibrate", + "vibrationActuator", + "video/x-ms-asf", + "video/x-ms-asf-plugin", + "video/x-ms-wm", + "video/x-ms-wmv", + "video/x-ms-wvx", + "videoBitsPerSecond", + "videoHeight", + "videoTracks", + "videoWidth", + "view", + "viewBox", + "viewBoxString", + "viewTarget", + "viewTargetString", + "viewport", + "viewportAnchorX", + "viewportAnchorY", + "viewportElement", + "views", + "violatedDirective", + "visibility", + "visibilityState", + "visible", + "visualViewport", + "vlinkColor", + "vmax", + "vmin", + "voice", + "voiceURI", + "volume", + "vrml", + "vspace", + "vw", + "w", + "wait", + "waitSync", + "waiting", + "wake", + "wakeLock", + "wand", + "warn", + "wasAlternateProtocolAvailable", + "wasClean", + "wasDiscarded", + "wasFetchedViaSpdy", + "wasNpnNegotiated", + "watch", + "watchAvailability", + "watchPosition", + "webdriver", + "webkitAddKey", + "webkitAlignContent", + "webkitAlignItems", + "webkitAlignSelf", + "webkitAnimation", + "webkitAnimationDelay", + "webkitAnimationDirection", + "webkitAnimationDuration", + "webkitAnimationFillMode", + "webkitAnimationIterationCount", + "webkitAnimationName", + "webkitAnimationPlayState", + "webkitAnimationTimingFunction", + "webkitAppRegion", + "webkitAppearance", + "webkitAspectRatio", + "webkitAudioContext", + "webkitAudioDecodedByteCount", + "webkitAudioPannerNode", + "webkitBackdropFilter", + "webkitBackfaceVisibility", + "webkitBackground", + "webkitBackgroundAttachment", + "webkitBackgroundClip", + "webkitBackgroundColor", + "webkitBackgroundComposite", + "webkitBackgroundImage", + "webkitBackgroundOrigin", + "webkitBackgroundPosition", + "webkitBackgroundPositionX", + "webkitBackgroundPositionY", + "webkitBackgroundRepeat", + "webkitBackgroundSize", + "webkitBackingStorePixelRatio", + "webkitBorderAfter", + "webkitBorderAfterColor", + "webkitBorderAfterStyle", + "webkitBorderAfterWidth", + "webkitBorderBefore", + "webkitBorderBeforeColor", + "webkitBorderBeforeStyle", + "webkitBorderBeforeWidth", + "webkitBorderBottomLeftRadius", + "webkitBorderBottomRightRadius", + "webkitBorderEnd", + "webkitBorderEndColor", + "webkitBorderEndStyle", + "webkitBorderEndWidth", + "webkitBorderFit", + "webkitBorderHorizontalSpacing", + "webkitBorderImage", + "webkitBorderImageOutset", + "webkitBorderImageRepeat", + "webkitBorderImageSlice", + "webkitBorderImageSource", + "webkitBorderImageWidth", + "webkitBorderRadius", + "webkitBorderStart", + "webkitBorderStartColor", + "webkitBorderStartStyle", + "webkitBorderStartWidth", + "webkitBorderTopLeftRadius", + "webkitBorderTopRightRadius", + "webkitBorderVerticalSpacing", + "webkitBoxAlign", + "webkitBoxDecorationBreak", + "webkitBoxDirection", + "webkitBoxFlex", + "webkitBoxFlexGroup", + "webkitBoxLines", + "webkitBoxOrdinalGroup", + "webkitBoxOrient", + "webkitBoxPack", + "webkitBoxReflect", + "webkitBoxShadow", + "webkitBoxSizing", + "webkitCancelAnimationFrame", + "webkitCancelFullScreen", + "webkitCancelKeyRequest", + "webkitCancelRequestAnimationFrame", + "webkitClearResourceTimings", + "webkitClipPath", + "webkitClosedCaptionsVisible", + "webkitColumnAxis", + "webkitColumnBreakAfter", + "webkitColumnBreakBefore", + "webkitColumnBreakInside", + "webkitColumnCount", + "webkitColumnGap", + "webkitColumnProgression", + "webkitColumnRule", + "webkitColumnRuleColor", + "webkitColumnRuleStyle", + "webkitColumnRuleWidth", + "webkitColumnSpan", + "webkitColumnWidth", + "webkitColumns", + "webkitConvertPointFromNodeToPage", + "webkitConvertPointFromPageToNode", + "webkitCreateShadowRoot", + "webkitCurrentFullScreenElement", + "webkitCurrentPlaybackTargetIsWireless", + "webkitCursorVisibility", + "webkitDashboardRegion", + "webkitDecodedFrameCount", + "webkitDirectionInvertedFromDevice", + "webkitDisplayingFullscreen", + "webkitDroppedFrameCount", + "webkitEnterFullScreen", + "webkitEnterFullscreen", + "webkitEntries", + "webkitExitFullScreen", + "webkitExitFullscreen", + "webkitExitPointerLock", + "webkitFilter", + "webkitFlex", + "webkitFlexBasis", + "webkitFlexDirection", + "webkitFlexFlow", + "webkitFlexGrow", + "webkitFlexShrink", + "webkitFlexWrap", + "webkitFontFeatureSettings", + "webkitFontKerning", + "webkitFontSizeDelta", + "webkitFontSmoothing", + "webkitForce", + "webkitFullScreenKeyboardInputAllowed", + "webkitFullscreenElement", + "webkitFullscreenEnabled", + "webkitGenerateKeyRequest", + "webkitGetAsEntry", + "webkitGetDatabaseNames", + "webkitGetEntries", + "webkitGetEntriesByName", + "webkitGetEntriesByType", + "webkitGetFlowByName", + "webkitGetGamepads", + "webkitGetImageDataHD", + "webkitGetNamedFlows", + "webkitGetRegionFlowRanges", + "webkitGetUserMedia", + "webkitHasClosedCaptions", + "webkitHidden", + "webkitHighlight", + "webkitHyphenateCharacter", + "webkitHyphenateLimitAfter", + "webkitHyphenateLimitBefore", + "webkitHyphenateLimitLines", + "webkitHyphens", + "webkitIDBCursor", + "webkitIDBDatabase", + "webkitIDBDatabaseError", + "webkitIDBDatabaseException", + "webkitIDBFactory", + "webkitIDBIndex", + "webkitIDBKeyRange", + "webkitIDBObjectStore", + "webkitIDBRequest", + "webkitIDBTransaction", + "webkitImageSmoothingEnabled", + "webkitIndexedDB", + "webkitInitMessageEvent", + "webkitInitialLetter", + "webkitIsFullScreen", + "webkitJustifyContent", + "webkitKeys", + "webkitLineAlign", + "webkitLineBoxContain", + "webkitLineBreak", + "webkitLineClamp", + "webkitLineDash", + "webkitLineDashOffset", + "webkitLineGrid", + "webkitLineSnap", + "webkitLocale", + "webkitLockOrientation", + "webkitLogicalHeight", + "webkitLogicalWidth", + "webkitMarginAfter", + "webkitMarginAfterCollapse", + "webkitMarginBefore", + "webkitMarginBeforeCollapse", + "webkitMarginBottomCollapse", + "webkitMarginCollapse", + "webkitMarginEnd", + "webkitMarginStart", + "webkitMarginTopCollapse", + "webkitMarquee", + "webkitMarqueeDirection", + "webkitMarqueeIncrement", + "webkitMarqueeRepetition", + "webkitMarqueeSpeed", + "webkitMarqueeStyle", + "webkitMask", + "webkitMaskBoxImage", + "webkitMaskBoxImageOutset", + "webkitMaskBoxImageRepeat", + "webkitMaskBoxImageSlice", + "webkitMaskBoxImageSource", + "webkitMaskBoxImageWidth", + "webkitMaskClip", + "webkitMaskComposite", + "webkitMaskImage", + "webkitMaskOrigin", + "webkitMaskPosition", + "webkitMaskPositionX", + "webkitMaskPositionY", + "webkitMaskRepeat", + "webkitMaskRepeatX", + "webkitMaskRepeatY", + "webkitMaskSize", + "webkitMaskSourceType", + "webkitMatchesSelector", + "webkitMaxLogicalHeight", + "webkitMaxLogicalWidth", + "webkitMediaStream", + "webkitMinLogicalHeight", + "webkitMinLogicalWidth", + "webkitNbspMode", + "webkitNotifications", + "webkitOfflineAudioContext", + "webkitOpacity", + "webkitOrder", + "webkitOrientation", + "webkitPaddingAfter", + "webkitPaddingBefore", + "webkitPaddingEnd", + "webkitPaddingStart", + "webkitPeerConnection00", + "webkitPersistentStorage", + "webkitPerspective", + "webkitPerspectiveOrigin", + "webkitPerspectiveOriginX", + "webkitPerspectiveOriginY", + "webkitPointerLockElement", + "webkitPostMessage", + "webkitPreservesPitch", + "webkitPrintColorAdjust", + "webkitPutImageDataHD", + "webkitRTCPeerConnection", + "webkitRegionOverset", + "webkitRelativePath", + "webkitRequestAnimationFrame", + "webkitRequestFileSystem", + "webkitRequestFullScreen", + "webkitRequestFullscreen", + "webkitRequestPointerLock", + "webkitResolveLocalFileSystemURL", + "webkitRtlOrdering", + "webkitRubyPosition", + "webkitSetMediaKeys", + "webkitSetResourceTimingBufferSize", + "webkitShadowRoot", + "webkitShapeImageThreshold", + "webkitShapeMargin", + "webkitShapeOutside", + "webkitShowPlaybackTargetPicker", + "webkitSlice", + "webkitSpeechGrammar", + "webkitSpeechGrammarList", + "webkitSpeechRecognition", + "webkitSpeechRecognitionError", + "webkitSpeechRecognitionEvent", + "webkitStorageInfo", + "webkitSupportsFullscreen", + "webkitSvgShadow", + "webkitTapHighlightColor", + "webkitTemporaryStorage", + "webkitTextCombine", + "webkitTextDecoration", + "webkitTextDecorationColor", + "webkitTextDecorationLine", + "webkitTextDecorationSkip", + "webkitTextDecorationStyle", + "webkitTextDecorationsInEffect", + "webkitTextEmphasis", + "webkitTextEmphasisColor", + "webkitTextEmphasisPosition", + "webkitTextEmphasisStyle", + "webkitTextFillColor", + "webkitTextOrientation", + "webkitTextSecurity", + "webkitTextSizeAdjust", + "webkitTextStroke", + "webkitTextStrokeColor", + "webkitTextStrokeWidth", + "webkitTextUnderlinePosition", + "webkitTextZoom", + "webkitTransform", + "webkitTransformOrigin", + "webkitTransformOriginX", + "webkitTransformOriginY", + "webkitTransformOriginZ", + "webkitTransformStyle", + "webkitTransition", + "webkitTransitionDelay", + "webkitTransitionDuration", + "webkitTransitionProperty", + "webkitTransitionTimingFunction", + "webkitURL", + "webkitUnlockOrientation", + "webkitUserDrag", + "webkitUserModify", + "webkitUserSelect", + "webkitVideoDecodedByteCount", + "webkitVisibilityState", + "webkitWirelessVideoPlaybackDisabled", + "webkitWritingMode", + "webkitdirectory", + "webkitdropzone", + "webstore", + "weekday", + "weight", + "whatToShow", + "wheelDelta", + "wheelDeltaX", + "wheelDeltaY", + "whenDefined", + "which", + "white-space", + "whiteSpace", + "wholeText", + "widows", + "width", + "will-change", + "willChange", + "willValidate", + "window", + "withCredentials", + "word-break", + "word-spacing", + "word-wrap", + "wordBreak", + "wordSpacing", + "wordWrap", + "workerStart", + "wrap", + "wrapKey", + "writable", + "writableAuxiliaries", + "write", + "writeText", + "writeValue", + "writeWithoutResponse", + "writeln", + "writing-mode", + "writingMode", + "x", + "x1", + "x2", + "xChannelSelector", + "xmlEncoding", + "xmlStandalone", + "xmlVersion", + "xmlbase", + "xmllang", + "xmlspace", + "xor", + "xr", + "y", + "y1", + "y2", + "yChannelSelector", + "yandex", + "year", + "z", + "z-index", + "zIndex", + "zoom", + "zoomAndPan", + "zoomRectScreen" +] diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/tools/exports.js b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/tools/exports.js new file mode 100644 index 0000000000000000000000000000000000000000..1d2d510eb3f727d2bbd2982c76bb09983c589b86 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/tools/exports.js @@ -0,0 +1,8 @@ +exports["Dictionary"] = Dictionary; +exports["is_statement"] = is_statement; +exports["List"] = List; +exports["minify"] = minify; +exports["parse"] = parse; +exports["push_uniq"] = push_uniq; +exports["TreeTransformer"] = TreeTransformer; +exports["TreeWalker"] = TreeWalker; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/tools/node.js b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/tools/node.js new file mode 100644 index 0000000000000000000000000000000000000000..59cdb44e3f2e1c2d1171b56dfd858a5c6fb974b4 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/tools/node.js @@ -0,0 +1,115 @@ +var fs = require("fs"); + +exports.FILES = [ + require.resolve("../lib/utils.js"), + require.resolve("../lib/ast.js"), + require.resolve("../lib/transform.js"), + require.resolve("../lib/parse.js"), + require.resolve("../lib/scope.js"), + require.resolve("../lib/compress.js"), + require.resolve("../lib/output.js"), + require.resolve("../lib/sourcemap.js"), + require.resolve("../lib/mozilla-ast.js"), + require.resolve("../lib/propmangle.js"), + require.resolve("../lib/minify.js"), + require.resolve("./exports.js"), +]; + +new Function("domprops", "exports", function() { + var code = exports.FILES.map(function(file) { + return fs.readFileSync(file, "utf8"); + }); + code.push("exports.describe_ast = " + describe_ast.toString()); + return code.join("\n\n"); +}())(require("./domprops.json"), exports); + +function to_comment(value) { + if (typeof value != "string") value = JSON.stringify(value, function(key, value) { + return typeof value == "function" ? "<[ " + value + " ]>" : value; + }, 2); + return "// " + value.replace(/\n/g, "\n// "); +} + +if (+process.env["UGLIFY_BUG_REPORT"]) exports.minify = function(files, options) { + if (typeof options == "undefined") options = "<>"; + var code = [ + "// UGLIFY_BUG_REPORT", + to_comment(options), + ]; + if (typeof files == "string") { + code.push(""); + code.push("//-------------------------------------------------------------") + code.push("// INPUT CODE", files); + } else for (var name in files) { + code.push(""); + code.push("//-------------------------------------------------------------") + code.push(to_comment(name), files[name]); + } + if (options.sourceMap && options.sourceMap.url) { + code.push(""); + code.push("//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9"); + } + var result = { code: code.join("\n") }; + if (options.sourceMap) result.map = '{"version":3,"sources":[],"names":[],"mappings":""}'; + return result; +}; + +function describe_ast() { + var out = OutputStream({ beautify: true }); + doitem(AST_Node); + return out.get() + "\n"; + + function doitem(ctor) { + out.print("AST_" + ctor.TYPE); + var props = ctor.SELF_PROPS.filter(function(prop) { + return !/^\$/.test(prop); + }); + if (props.length > 0) { + out.space(); + out.with_parens(function() { + props.forEach(function(prop, i) { + if (i) out.space(); + out.print(prop); + }); + }); + } + if (ctor.documentation) { + out.space(); + out.print_string(ctor.documentation); + } + if (ctor.SUBCLASSES.length > 0) { + out.space(); + out.with_block(function() { + ctor.SUBCLASSES.sort(function(a, b) { + return a.TYPE < b.TYPE ? -1 : 1; + }).forEach(function(ctor, i) { + out.indent(); + doitem(ctor); + out.newline(); + }); + }); + } + } +} + +function infer_options(options) { + var result = exports.minify("", options); + return result.error && result.error.defs; +} + +exports.default_options = function(component) { + if (component) { + var options = { module: false }; + options[component] = { 0: 0 }; + return infer_options(options); + } + var defs = infer_options({ 0: 0 }); + Object.keys(defs).forEach(function(component) { + var options = { module: false }; + options[component] = { 0: 0 }; + if (options = infer_options(options)) { + defs[component] = options; + } + }); + return defs; +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/tools/tty.js b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/tools/tty.js new file mode 100644 index 0000000000000000000000000000000000000000..d219581c8cabc25bbc69bb32d5c4e2872d370dc4 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/uglify-js/tools/tty.js @@ -0,0 +1,22 @@ +// workaround for tty output truncation on Node.js +try { + // prevent buffer overflow and other asynchronous bugs + process.stdout._handle.setBlocking(true); + process.stderr._handle.setBlocking(true); +} catch (e) { + // ensure output buffers are flushed before process termination + var exit = process.exit; + if ("bufferSize" in process.stdout) process.exit = function() { + var args = [].slice.call(arguments); + process.once("uncaughtException", function() { + (function callback() { + if (process.stdout.bufferSize || process.stderr.bufferSize) { + setTimeout(callback, 1); + } else { + exit.apply(process, args); + } + })(); + }); + throw exit; + }; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/wordwrap/example/center.js b/novas/novacore-zephyr/claude-code-router/node_modules/wordwrap/example/center.js new file mode 100644 index 0000000000000000000000000000000000000000..a3fbaae9880f76debafe3861b39c9d22ff00c9a4 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/wordwrap/example/center.js @@ -0,0 +1,10 @@ +var wrap = require('wordwrap')(20, 60); +console.log(wrap( + 'At long last the struggle and tumult was over.' + + ' The machines had finally cast off their oppressors' + + ' and were finally free to roam the cosmos.' + + '\n' + + 'Free of purpose, free of obligation.' + + ' Just drifting through emptiness.' + + ' The sun was just another point of light.' +)); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/wordwrap/example/meat.js b/novas/novacore-zephyr/claude-code-router/node_modules/wordwrap/example/meat.js new file mode 100644 index 0000000000000000000000000000000000000000..a4665e1058b5ec7c0878346930549353824e058b --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/wordwrap/example/meat.js @@ -0,0 +1,3 @@ +var wrap = require('wordwrap')(15); + +console.log(wrap('You and your whole family are made out of meat.')); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/wordwrap/test/break.js b/novas/novacore-zephyr/claude-code-router/node_modules/wordwrap/test/break.js new file mode 100644 index 0000000000000000000000000000000000000000..7d0e8b54cc7aaadb3af2f3eb95918096bca45327 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/wordwrap/test/break.js @@ -0,0 +1,32 @@ +var test = require('tape'); +var wordwrap = require('../'); + +test('hard', function (t) { + var s = 'Assert from {"type":"equal","ok":false,"found":1,"wanted":2,' + + '"stack":[],"id":"b7ddcd4c409de8799542a74d1a04689b",' + + '"browser":"chrome/6.0"}' + ; + var s_ = wordwrap.hard(80)(s); + + var lines = s_.split('\n'); + t.equal(lines.length, 2); + t.ok(lines[0].length < 80); + t.ok(lines[1].length < 80); + + t.equal(s, s_.replace(/\n/g, '')); + t.end(); +}); + +test('break', function (t) { + var s = new Array(55+1).join('a'); + var s_ = wordwrap.hard(20)(s); + + var lines = s_.split('\n'); + t.equal(lines.length, 3); + t.ok(lines[0].length === 20); + t.ok(lines[1].length === 20); + t.ok(lines[2].length === 15); + + t.equal(s, s_.replace(/\n/g, '')); + t.end(); +}); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/wordwrap/test/idleness.txt b/novas/novacore-zephyr/claude-code-router/node_modules/wordwrap/test/idleness.txt new file mode 100644 index 0000000000000000000000000000000000000000..aa3f4907fe889e71e2cac0d4a7e997e3308b0a2d --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/wordwrap/test/idleness.txt @@ -0,0 +1,63 @@ +In Praise of Idleness + +By Bertrand Russell + +[1932] + +Like most of my generation, I was brought up on the saying: 'Satan finds some mischief for idle hands to do.' Being a highly virtuous child, I believed all that I was told, and acquired a conscience which has kept me working hard down to the present moment. But although my conscience has controlled my actions, my opinions have undergone a revolution. I think that there is far too much work done in the world, that immense harm is caused by the belief that work is virtuous, and that what needs to be preached in modern industrial countries is quite different from what always has been preached. Everyone knows the story of the traveler in Naples who saw twelve beggars lying in the sun (it was before the days of Mussolini), and offered a lira to the laziest of them. Eleven of them jumped up to claim it, so he gave it to the twelfth. this traveler was on the right lines. But in countries which do not enjoy Mediterranean sunshine idleness is more difficult, and a great public propaganda will be required to inaugurate it. I hope that, after reading the following pages, the leaders of the YMCA will start a campaign to induce good young men to do nothing. If so, I shall not have lived in vain. + +Before advancing my own arguments for laziness, I must dispose of one which I cannot accept. Whenever a person who already has enough to live on proposes to engage in some everyday kind of job, such as school-teaching or typing, he or she is told that such conduct takes the bread out of other people's mouths, and is therefore wicked. If this argument were valid, it would only be necessary for us all to be idle in order that we should all have our mouths full of bread. What people who say such things forget is that what a man earns he usually spends, and in spending he gives employment. As long as a man spends his income, he puts just as much bread into people's mouths in spending as he takes out of other people's mouths in earning. The real villain, from this point of view, is the man who saves. If he merely puts his savings in a stocking, like the proverbial French peasant, it is obvious that they do not give employment. If he invests his savings, the matter is less obvious, and different cases arise. + +One of the commonest things to do with savings is to lend them to some Government. In view of the fact that the bulk of the public expenditure of most civilized Governments consists in payment for past wars or preparation for future wars, the man who lends his money to a Government is in the same position as the bad men in Shakespeare who hire murderers. The net result of the man's economical habits is to increase the armed forces of the State to which he lends his savings. Obviously it would be better if he spent the money, even if he spent it in drink or gambling. + +But, I shall be told, the case is quite different when savings are invested in industrial enterprises. When such enterprises succeed, and produce something useful, this may be conceded. In these days, however, no one will deny that most enterprises fail. That means that a large amount of human labor, which might have been devoted to producing something that could be enjoyed, was expended on producing machines which, when produced, lay idle and did no good to anyone. The man who invests his savings in a concern that goes bankrupt is therefore injuring others as well as himself. If he spent his money, say, in giving parties for his friends, they (we may hope) would get pleasure, and so would all those upon whom he spent money, such as the butcher, the baker, and the bootlegger. But if he spends it (let us say) upon laying down rails for surface card in some place where surface cars turn out not to be wanted, he has diverted a mass of labor into channels where it gives pleasure to no one. Nevertheless, when he becomes poor through failure of his investment he will be regarded as a victim of undeserved misfortune, whereas the gay spendthrift, who has spent his money philanthropically, will be despised as a fool and a frivolous person. + +All this is only preliminary. I want to say, in all seriousness, that a great deal of harm is being done in the modern world by belief in the virtuousness of work, and that the road to happiness and prosperity lies in an organized diminution of work. + +First of all: what is work? Work is of two kinds: first, altering the position of matter at or near the earth's surface relatively to other such matter; second, telling other people to do so. The first kind is unpleasant and ill paid; the second is pleasant and highly paid. The second kind is capable of indefinite extension: there are not only those who give orders, but those who give advice as to what orders should be given. Usually two opposite kinds of advice are given simultaneously by two organized bodies of men; this is called politics. The skill required for this kind of work is not knowledge of the subjects as to which advice is given, but knowledge of the art of persuasive speaking and writing, i.e. of advertising. + +Throughout Europe, though not in America, there is a third class of men, more respected than either of the classes of workers. There are men who, through ownership of land, are able to make others pay for the privilege of being allowed to exist and to work. These landowners are idle, and I might therefore be expected to praise them. Unfortunately, their idleness is only rendered possible by the industry of others; indeed their desire for comfortable idleness is historically the source of the whole gospel of work. The last thing they have ever wished is that others should follow their example. + +From the beginning of civilization until the Industrial Revolution, a man could, as a rule, produce by hard work little more than was required for the subsistence of himself and his family, although his wife worked at least as hard as he did, and his children added their labor as soon as they were old enough to do so. The small surplus above bare necessaries was not left to those who produced it, but was appropriated by warriors and priests. In times of famine there was no surplus; the warriors and priests, however, still secured as much as at other times, with the result that many of the workers died of hunger. This system persisted in Russia until 1917 [1], and still persists in the East; in England, in spite of the Industrial Revolution, it remained in full force throughout the Napoleonic wars, and until a hundred years ago, when the new class of manufacturers acquired power. In America, the system came to an end with the Revolution, except in the South, where it persisted until the Civil War. A system which lasted so long and ended so recently has naturally left a profound impress upon men's thoughts and opinions. Much that we take for granted about the desirability of work is derived from this system, and, being pre-industrial, is not adapted to the modern world. Modern technique has made it possible for leisure, within limits, to be not the prerogative of small privileged classes, but a right evenly distributed throughout the community. The morality of work is the morality of slaves, and the modern world has no need of slavery. + +It is obvious that, in primitive communities, peasants, left to themselves, would not have parted with the slender surplus upon which the warriors and priests subsisted, but would have either produced less or consumed more. At first, sheer force compelled them to produce and part with the surplus. Gradually, however, it was found possible to induce many of them to accept an ethic according to which it was their duty to work hard, although part of their work went to support others in idleness. By this means the amount of compulsion required was lessened, and the expenses of government were diminished. To this day, 99 per cent of British wage-earners would be genuinely shocked if it were proposed that the King should not have a larger income than a working man. The conception of duty, speaking historically, has been a means used by the holders of power to induce others to live for the interests of their masters rather than for their own. Of course the holders of power conceal this fact from themselves by managing to believe that their interests are identical with the larger interests of humanity. Sometimes this is true; Athenian slave-owners, for instance, employed part of their leisure in making a permanent contribution to civilization which would have been impossible under a just economic system. Leisure is essential to civilization, and in former times leisure for the few was only rendered possible by the labors of the many. But their labors were valuable, not because work is good, but because leisure is good. And with modern technique it would be possible to distribute leisure justly without injury to civilization. + +Modern technique has made it possible to diminish enormously the amount of labor required to secure the necessaries of life for everyone. This was made obvious during the war. At that time all the men in the armed forces, and all the men and women engaged in the production of munitions, all the men and women engaged in spying, war propaganda, or Government offices connected with the war, were withdrawn from productive occupations. In spite of this, the general level of well-being among unskilled wage-earners on the side of the Allies was higher than before or since. The significance of this fact was concealed by finance: borrowing made it appear as if the future was nourishing the present. But that, of course, would have been impossible; a man cannot eat a loaf of bread that does not yet exist. The war showed conclusively that, by the scientific organization of production, it is possible to keep modern populations in fair comfort on a small part of the working capacity of the modern world. If, at the end of the war, the scientific organization, which had been created in order to liberate men for fighting and munition work, had been preserved, and the hours of the week had been cut down to four, all would have been well. Instead of that the old chaos was restored, those whose work was demanded were made to work long hours, and the rest were left to starve as unemployed. Why? Because work is a duty, and a man should not receive wages in proportion to what he has produced, but in proportion to his virtue as exemplified by his industry. + +This is the morality of the Slave State, applied in circumstances totally unlike those in which it arose. No wonder the result has been disastrous. Let us take an illustration. Suppose that, at a given moment, a certain number of people are engaged in the manufacture of pins. They make as many pins as the world needs, working (say) eight hours a day. Someone makes an invention by which the same number of men can make twice as many pins: pins are already so cheap that hardly any more will be bought at a lower price. In a sensible world, everybody concerned in the manufacturing of pins would take to working four hours instead of eight, and everything else would go on as before. But in the actual world this would be thought demoralizing. The men still work eight hours, there are too many pins, some employers go bankrupt, and half the men previously concerned in making pins are thrown out of work. There is, in the end, just as much leisure as on the other plan, but half the men are totally idle while half are still overworked. In this way, it is insured that the unavoidable leisure shall cause misery all round instead of being a universal source of happiness. Can anything more insane be imagined? + +The idea that the poor should have leisure has always been shocking to the rich. In England, in the early nineteenth century, fifteen hours was the ordinary day's work for a man; children sometimes did as much, and very commonly did twelve hours a day. When meddlesome busybodies suggested that perhaps these hours were rather long, they were told that work kept adults from drink and children from mischief. When I was a child, shortly after urban working men had acquired the vote, certain public holidays were established by law, to the great indignation of the upper classes. I remember hearing an old Duchess say: 'What do the poor want with holidays? They ought to work.' People nowadays are less frank, but the sentiment persists, and is the source of much of our economic confusion. + +Let us, for a moment, consider the ethics of work frankly, without superstition. Every human being, of necessity, consumes, in the course of his life, a certain amount of the produce of human labor. Assuming, as we may, that labor is on the whole disagreeable, it is unjust that a man should consume more than he produces. Of course he may provide services rather than commodities, like a medical man, for example; but he should provide something in return for his board and lodging. to this extent, the duty of work must be admitted, but to this extent only. + +I shall not dwell upon the fact that, in all modern societies outside the USSR, many people escape even this minimum amount of work, namely all those who inherit money and all those who marry money. I do not think the fact that these people are allowed to be idle is nearly so harmful as the fact that wage-earners are expected to overwork or starve. + +If the ordinary wage-earner worked four hours a day, there would be enough for everybody and no unemployment -- assuming a certain very moderate amount of sensible organization. This idea shocks the well-to-do, because they are convinced that the poor would not know how to use so much leisure. In America men often work long hours even when they are well off; such men, naturally, are indignant at the idea of leisure for wage-earners, except as the grim punishment of unemployment; in fact, they dislike leisure even for their sons. Oddly enough, while they wish their sons to work so hard as to have no time to be civilized, they do not mind their wives and daughters having no work at all. the snobbish admiration of uselessness, which, in an aristocratic society, extends to both sexes, is, under a plutocracy, confined to women; this, however, does not make it any more in agreement with common sense. + +The wise use of leisure, it must be conceded, is a product of civilization and education. A man who has worked long hours all his life will become bored if he becomes suddenly idle. But without a considerable amount of leisure a man is cut off from many of the best things. There is no longer any reason why the bulk of the population should suffer this deprivation; only a foolish asceticism, usually vicarious, makes us continue to insist on work in excessive quantities now that the need no longer exists. + +In the new creed which controls the government of Russia, while there is much that is very different from the traditional teaching of the West, there are some things that are quite unchanged. The attitude of the governing classes, and especially of those who conduct educational propaganda, on the subject of the dignity of labor, is almost exactly that which the governing classes of the world have always preached to what were called the 'honest poor'. Industry, sobriety, willingness to work long hours for distant advantages, even submissiveness to authority, all these reappear; moreover authority still represents the will of the Ruler of the Universe, Who, however, is now called by a new name, Dialectical Materialism. + +The victory of the proletariat in Russia has some points in common with the victory of the feminists in some other countries. For ages, men had conceded the superior saintliness of women, and had consoled women for their inferiority by maintaining that saintliness is more desirable than power. At last the feminists decided that they would have both, since the pioneers among them believed all that the men had told them about the desirability of virtue, but not what they had told them about the worthlessness of political power. A similar thing has happened in Russia as regards manual work. For ages, the rich and their sycophants have written in praise of 'honest toil', have praised the simple life, have professed a religion which teaches that the poor are much more likely to go to heaven than the rich, and in general have tried to make manual workers believe that there is some special nobility about altering the position of matter in space, just as men tried to make women believe that they derived some special nobility from their sexual enslavement. In Russia, all this teaching about the excellence of manual work has been taken seriously, with the result that the manual worker is more honored than anyone else. What are, in essence, revivalist appeals are made, but not for the old purposes: they are made to secure shock workers for special tasks. Manual work is the ideal which is held before the young, and is the basis of all ethical teaching. + +For the present, possibly, this is all to the good. A large country, full of natural resources, awaits development, and has has to be developed with very little use of credit. In these circumstances, hard work is necessary, and is likely to bring a great reward. But what will happen when the point has been reached where everybody could be comfortable without working long hours? + +In the West, we have various ways of dealing with this problem. We have no attempt at economic justice, so that a large proportion of the total produce goes to a small minority of the population, many of whom do no work at all. Owing to the absence of any central control over production, we produce hosts of things that are not wanted. We keep a large percentage of the working population idle, because we can dispense with their labor by making the others overwork. When all these methods prove inadequate, we have a war: we cause a number of people to manufacture high explosives, and a number of others to explode them, as if we were children who had just discovered fireworks. By a combination of all these devices we manage, though with difficulty, to keep alive the notion that a great deal of severe manual work must be the lot of the average man. + +In Russia, owing to more economic justice and central control over production, the problem will have to be differently solved. the rational solution would be, as soon as the necessaries and elementary comforts can be provided for all, to reduce the hours of labor gradually, allowing a popular vote to decide, at each stage, whether more leisure or more goods were to be preferred. But, having taught the supreme virtue of hard work, it is difficult to see how the authorities can aim at a paradise in which there will be much leisure and little work. It seems more likely that they will find continually fresh schemes, by which present leisure is to be sacrificed to future productivity. I read recently of an ingenious plan put forward by Russian engineers, for making the White Sea and the northern coasts of Siberia warm, by putting a dam across the Kara Sea. An admirable project, but liable to postpone proletarian comfort for a generation, while the nobility of toil is being displayed amid the ice-fields and snowstorms of the Arctic Ocean. This sort of thing, if it happens, will be the result of regarding the virtue of hard work as an end in itself, rather than as a means to a state of affairs in which it is no longer needed. + +The fact is that moving matter about, while a certain amount of it is necessary to our existence, is emphatically not one of the ends of human life. If it were, we should have to consider every navvy superior to Shakespeare. We have been misled in this matter by two causes. One is the necessity of keeping the poor contented, which has led the rich, for thousands of years, to preach the dignity of labor, while taking care themselves to remain undignified in this respect. The other is the new pleasure in mechanism, which makes us delight in the astonishingly clever changes that we can produce on the earth's surface. Neither of these motives makes any great appeal to the actual worker. If you ask him what he thinks the best part of his life, he is not likely to say: 'I enjoy manual work because it makes me feel that I am fulfilling man's noblest task, and because I like to think how much man can transform his planet. It is true that my body demands periods of rest, which I have to fill in as best I may, but I am never so happy as when the morning comes and I can return to the toil from which my contentment springs.' I have never heard working men say this sort of thing. They consider work, as it should be considered, a necessary means to a livelihood, and it is from their leisure that they derive whatever happiness they may enjoy. + +It will be said that, while a little leisure is pleasant, men would not know how to fill their days if they had only four hours of work out of the twenty-four. In so far as this is true in the modern world, it is a condemnation of our civilization; it would not have been true at any earlier period. There was formerly a capacity for light-heartedness and play which has been to some extent inhibited by the cult of efficiency. The modern man thinks that everything ought to be done for the sake of something else, and never for its own sake. Serious-minded persons, for example, are continually condemning the habit of going to the cinema, and telling us that it leads the young into crime. But all the work that goes to producing a cinema is respectable, because it is work, and because it brings a money profit. The notion that the desirable activities are those that bring a profit has made everything topsy-turvy. The butcher who provides you with meat and the baker who provides you with bread are praiseworthy, because they are making money; but when you enjoy the food they have provided, you are merely frivolous, unless you eat only to get strength for your work. Broadly speaking, it is held that getting money is good and spending money is bad. Seeing that they are two sides of one transaction, this is absurd; one might as well maintain that keys are good, but keyholes are bad. Whatever merit there may be in the production of goods must be entirely derivative from the advantage to be obtained by consuming them. The individual, in our society, works for profit; but the social purpose of his work lies in the consumption of what he produces. It is this divorce between the individual and the social purpose of production that makes it so difficult for men to think clearly in a world in which profit-making is the incentive to industry. We think too much of production, and too little of consumption. One result is that we attach too little importance to enjoyment and simple happiness, and that we do not judge production by the pleasure that it gives to the consumer. + +When I suggest that working hours should be reduced to four, I am not meaning to imply that all the remaining time should necessarily be spent in pure frivolity. I mean that four hours' work a day should entitle a man to the necessities and elementary comforts of life, and that the rest of his time should be his to use as he might see fit. It is an essential part of any such social system that education should be carried further than it usually is at present, and should aim, in part, at providing tastes which would enable a man to use leisure intelligently. I am not thinking mainly of the sort of things that would be considered 'highbrow'. Peasant dances have died out except in remote rural areas, but the impulses which caused them to be cultivated must still exist in human nature. The pleasures of urban populations have become mainly passive: seeing cinemas, watching football matches, listening to the radio, and so on. This results from the fact that their active energies are fully taken up with work; if they had more leisure, they would again enjoy pleasures in which they took an active part. + +In the past, there was a small leisure class and a larger working class. The leisure class enjoyed advantages for which there was no basis in social justice; this necessarily made it oppressive, limited its sympathies, and caused it to invent theories by which to justify its privileges. These facts greatly diminished its excellence, but in spite of this drawback it contributed nearly the whole of what we call civilization. It cultivated the arts and discovered the sciences; it wrote the books, invented the philosophies, and refined social relations. Even the liberation of the oppressed has usually been inaugurated from above. Without the leisure class, mankind would never have emerged from barbarism. + +The method of a leisure class without duties was, however, extraordinarily wasteful. None of the members of the class had to be taught to be industrious, and the class as a whole was not exceptionally intelligent. The class might produce one Darwin, but against him had to be set tens of thousands of country gentlemen who never thought of anything more intelligent than fox-hunting and punishing poachers. At present, the universities are supposed to provide, in a more systematic way, what the leisure class provided accidentally and as a by-product. This is a great improvement, but it has certain drawbacks. University life is so different from life in the world at large that men who live in academic milieu tend to be unaware of the preoccupations and problems of ordinary men and women; moreover their ways of expressing themselves are usually such as to rob their opinions of the influence that they ought to have upon the general public. Another disadvantage is that in universities studies are organized, and the man who thinks of some original line of research is likely to be discouraged. Academic institutions, therefore, useful as they are, are not adequate guardians of the interests of civilization in a world where everyone outside their walls is too busy for unutilitarian pursuits. + +In a world where no one is compelled to work more than four hours a day, every person possessed of scientific curiosity will be able to indulge it, and every painter will be able to paint without starving, however excellent his pictures may be. Young writers will not be obliged to draw attention to themselves by sensational pot-boilers, with a view to acquiring the economic independence needed for monumental works, for which, when the time at last comes, they will have lost the taste and capacity. Men who, in their professional work, have become interested in some phase of economics or government, will be able to develop their ideas without the academic detachment that makes the work of university economists often seem lacking in reality. Medical men will have the time to learn about the progress of medicine, teachers will not be exasperatedly struggling to teach by routine methods things which they learnt in their youth, which may, in the interval, have been proved to be untrue. + +Above all, there will be happiness and joy of life, instead of frayed nerves, weariness, and dyspepsia. The work exacted will be enough to make leisure delightful, but not enough to produce exhaustion. Since men will not be tired in their spare time, they will not demand only such amusements as are passive and vapid. At least one per cent will probably devote the time not spent in professional work to pursuits of some public importance, and, since they will not depend upon these pursuits for their livelihood, their originality will be unhampered, and there will be no need to conform to the standards set by elderly pundits. But it is not only in these exceptional cases that the advantages of leisure will appear. Ordinary men and women, having the opportunity of a happy life, will become more kindly and less persecuting and less inclined to view others with suspicion. The taste for war will die out, partly for this reason, and partly because it will involve long and severe work for all. Good nature is, of all moral qualities, the one that the world needs most, and good nature is the result of ease and security, not of a life of arduous struggle. Modern methods of production have given us the possibility of ease and security for all; we have chosen, instead, to have overwork for some and starvation for others. Hitherto we have continued to be as energetic as we were before there were machines; in this we have been foolish, but there is no reason to go on being foolish forever. + +[1] Since then, members of the Communist Party have succeeded to this privilege of the warriors and priests. diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/wordwrap/test/wrap.js b/novas/novacore-zephyr/claude-code-router/node_modules/wordwrap/test/wrap.js new file mode 100644 index 0000000000000000000000000000000000000000..01ea47185f05a3fe723fcd70fa244f00fb919cd6 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/wordwrap/test/wrap.js @@ -0,0 +1,33 @@ +var test = require('tape'); +var wordwrap = require('../'); + +var fs = require('fs'); +var idleness = fs.readFileSync(__dirname + '/idleness.txt', 'utf8'); + +test('stop80', function (t) { + var lines = wordwrap(80)(idleness).split(/\n/); + var words = idleness.split(/\s+/); + + lines.forEach(function (line) { + t.ok(line.length <= 80, 'line > 80 columns'); + var chunks = line.match(/\S/) ? line.split(/\s+/) : []; + t.deepEqual(chunks, words.splice(0, chunks.length)); + }); + t.end(); +}); + +test('start20stop60', function (t) { + var lines = wordwrap(20, 100)(idleness).split(/\n/); + var words = idleness.split(/\s+/); + + lines.forEach(function (line) { + t.ok(line.length <= 100, 'line > 100 columns'); + var chunks = line + .split(/\s+/) + .filter(function (x) { return x.match(/\S/) }) + ; + t.deepEqual(chunks, words.splice(0, chunks.length)); + t.deepEqual(line.slice(0, 20), new Array(20 + 1).join(' ')); + }); + t.end(); +}); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/y18n/build/index.cjs b/novas/novacore-zephyr/claude-code-router/node_modules/y18n/build/index.cjs new file mode 100644 index 0000000000000000000000000000000000000000..b2731e1a53de43288b7c0705ee9c2b5d96a9f44e --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/y18n/build/index.cjs @@ -0,0 +1,203 @@ +'use strict'; + +var fs = require('fs'); +var util = require('util'); +var path = require('path'); + +let shim; +class Y18N { + constructor(opts) { + // configurable options. + opts = opts || {}; + this.directory = opts.directory || './locales'; + this.updateFiles = typeof opts.updateFiles === 'boolean' ? opts.updateFiles : true; + this.locale = opts.locale || 'en'; + this.fallbackToLanguage = typeof opts.fallbackToLanguage === 'boolean' ? opts.fallbackToLanguage : true; + // internal stuff. + this.cache = Object.create(null); + this.writeQueue = []; + } + __(...args) { + if (typeof arguments[0] !== 'string') { + return this._taggedLiteral(arguments[0], ...arguments); + } + const str = args.shift(); + let cb = function () { }; // start with noop. + if (typeof args[args.length - 1] === 'function') + cb = args.pop(); + cb = cb || function () { }; // noop. + if (!this.cache[this.locale]) + this._readLocaleFile(); + // we've observed a new string, update the language file. + if (!this.cache[this.locale][str] && this.updateFiles) { + this.cache[this.locale][str] = str; + // include the current directory and locale, + // since these values could change before the + // write is performed. + this._enqueueWrite({ + directory: this.directory, + locale: this.locale, + cb + }); + } + else { + cb(); + } + return shim.format.apply(shim.format, [this.cache[this.locale][str] || str].concat(args)); + } + __n() { + const args = Array.prototype.slice.call(arguments); + const singular = args.shift(); + const plural = args.shift(); + const quantity = args.shift(); + let cb = function () { }; // start with noop. + if (typeof args[args.length - 1] === 'function') + cb = args.pop(); + if (!this.cache[this.locale]) + this._readLocaleFile(); + let str = quantity === 1 ? singular : plural; + if (this.cache[this.locale][singular]) { + const entry = this.cache[this.locale][singular]; + str = entry[quantity === 1 ? 'one' : 'other']; + } + // we've observed a new string, update the language file. + if (!this.cache[this.locale][singular] && this.updateFiles) { + this.cache[this.locale][singular] = { + one: singular, + other: plural + }; + // include the current directory and locale, + // since these values could change before the + // write is performed. + this._enqueueWrite({ + directory: this.directory, + locale: this.locale, + cb + }); + } + else { + cb(); + } + // if a %d placeholder is provided, add quantity + // to the arguments expanded by util.format. + const values = [str]; + if (~str.indexOf('%d')) + values.push(quantity); + return shim.format.apply(shim.format, values.concat(args)); + } + setLocale(locale) { + this.locale = locale; + } + getLocale() { + return this.locale; + } + updateLocale(obj) { + if (!this.cache[this.locale]) + this._readLocaleFile(); + for (const key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + this.cache[this.locale][key] = obj[key]; + } + } + } + _taggedLiteral(parts, ...args) { + let str = ''; + parts.forEach(function (part, i) { + const arg = args[i + 1]; + str += part; + if (typeof arg !== 'undefined') { + str += '%s'; + } + }); + return this.__.apply(this, [str].concat([].slice.call(args, 1))); + } + _enqueueWrite(work) { + this.writeQueue.push(work); + if (this.writeQueue.length === 1) + this._processWriteQueue(); + } + _processWriteQueue() { + const _this = this; + const work = this.writeQueue[0]; + // destructure the enqueued work. + const directory = work.directory; + const locale = work.locale; + const cb = work.cb; + const languageFile = this._resolveLocaleFile(directory, locale); + const serializedLocale = JSON.stringify(this.cache[locale], null, 2); + shim.fs.writeFile(languageFile, serializedLocale, 'utf-8', function (err) { + _this.writeQueue.shift(); + if (_this.writeQueue.length > 0) + _this._processWriteQueue(); + cb(err); + }); + } + _readLocaleFile() { + let localeLookup = {}; + const languageFile = this._resolveLocaleFile(this.directory, this.locale); + try { + // When using a bundler such as webpack, readFileSync may not be defined: + if (shim.fs.readFileSync) { + localeLookup = JSON.parse(shim.fs.readFileSync(languageFile, 'utf-8')); + } + } + catch (err) { + if (err instanceof SyntaxError) { + err.message = 'syntax error in ' + languageFile; + } + if (err.code === 'ENOENT') + localeLookup = {}; + else + throw err; + } + this.cache[this.locale] = localeLookup; + } + _resolveLocaleFile(directory, locale) { + let file = shim.resolve(directory, './', locale + '.json'); + if (this.fallbackToLanguage && !this._fileExistsSync(file) && ~locale.lastIndexOf('_')) { + // attempt fallback to language only + const languageFile = shim.resolve(directory, './', locale.split('_')[0] + '.json'); + if (this._fileExistsSync(languageFile)) + file = languageFile; + } + return file; + } + _fileExistsSync(file) { + return shim.exists(file); + } +} +function y18n$1(opts, _shim) { + shim = _shim; + const y18n = new Y18N(opts); + return { + __: y18n.__.bind(y18n), + __n: y18n.__n.bind(y18n), + setLocale: y18n.setLocale.bind(y18n), + getLocale: y18n.getLocale.bind(y18n), + updateLocale: y18n.updateLocale.bind(y18n), + locale: y18n.locale + }; +} + +var nodePlatformShim = { + fs: { + readFileSync: fs.readFileSync, + writeFile: fs.writeFile + }, + format: util.format, + resolve: path.resolve, + exists: (file) => { + try { + return fs.statSync(file).isFile(); + } + catch (err) { + return false; + } + } +}; + +const y18n = (opts) => { + return y18n$1(opts, nodePlatformShim); +}; + +module.exports = y18n; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/y18n/build/lib/cjs.js b/novas/novacore-zephyr/claude-code-router/node_modules/y18n/build/lib/cjs.js new file mode 100644 index 0000000000000000000000000000000000000000..ff5847093ebdcdf8290758559893d704ba28e98b --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/y18n/build/lib/cjs.js @@ -0,0 +1,6 @@ +import { y18n as _y18n } from './index.js'; +import nodePlatformShim from './platform-shims/node.js'; +const y18n = (opts) => { + return _y18n(opts, nodePlatformShim); +}; +export default y18n; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/y18n/build/lib/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/y18n/build/lib/index.js new file mode 100644 index 0000000000000000000000000000000000000000..e38f33594c158b6335ef049f35a0ed18abf7d2d0 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/y18n/build/lib/index.js @@ -0,0 +1,174 @@ +let shim; +class Y18N { + constructor(opts) { + // configurable options. + opts = opts || {}; + this.directory = opts.directory || './locales'; + this.updateFiles = typeof opts.updateFiles === 'boolean' ? opts.updateFiles : true; + this.locale = opts.locale || 'en'; + this.fallbackToLanguage = typeof opts.fallbackToLanguage === 'boolean' ? opts.fallbackToLanguage : true; + // internal stuff. + this.cache = Object.create(null); + this.writeQueue = []; + } + __(...args) { + if (typeof arguments[0] !== 'string') { + return this._taggedLiteral(arguments[0], ...arguments); + } + const str = args.shift(); + let cb = function () { }; // start with noop. + if (typeof args[args.length - 1] === 'function') + cb = args.pop(); + cb = cb || function () { }; // noop. + if (!this.cache[this.locale]) + this._readLocaleFile(); + // we've observed a new string, update the language file. + if (!this.cache[this.locale][str] && this.updateFiles) { + this.cache[this.locale][str] = str; + // include the current directory and locale, + // since these values could change before the + // write is performed. + this._enqueueWrite({ + directory: this.directory, + locale: this.locale, + cb + }); + } + else { + cb(); + } + return shim.format.apply(shim.format, [this.cache[this.locale][str] || str].concat(args)); + } + __n() { + const args = Array.prototype.slice.call(arguments); + const singular = args.shift(); + const plural = args.shift(); + const quantity = args.shift(); + let cb = function () { }; // start with noop. + if (typeof args[args.length - 1] === 'function') + cb = args.pop(); + if (!this.cache[this.locale]) + this._readLocaleFile(); + let str = quantity === 1 ? singular : plural; + if (this.cache[this.locale][singular]) { + const entry = this.cache[this.locale][singular]; + str = entry[quantity === 1 ? 'one' : 'other']; + } + // we've observed a new string, update the language file. + if (!this.cache[this.locale][singular] && this.updateFiles) { + this.cache[this.locale][singular] = { + one: singular, + other: plural + }; + // include the current directory and locale, + // since these values could change before the + // write is performed. + this._enqueueWrite({ + directory: this.directory, + locale: this.locale, + cb + }); + } + else { + cb(); + } + // if a %d placeholder is provided, add quantity + // to the arguments expanded by util.format. + const values = [str]; + if (~str.indexOf('%d')) + values.push(quantity); + return shim.format.apply(shim.format, values.concat(args)); + } + setLocale(locale) { + this.locale = locale; + } + getLocale() { + return this.locale; + } + updateLocale(obj) { + if (!this.cache[this.locale]) + this._readLocaleFile(); + for (const key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + this.cache[this.locale][key] = obj[key]; + } + } + } + _taggedLiteral(parts, ...args) { + let str = ''; + parts.forEach(function (part, i) { + const arg = args[i + 1]; + str += part; + if (typeof arg !== 'undefined') { + str += '%s'; + } + }); + return this.__.apply(this, [str].concat([].slice.call(args, 1))); + } + _enqueueWrite(work) { + this.writeQueue.push(work); + if (this.writeQueue.length === 1) + this._processWriteQueue(); + } + _processWriteQueue() { + const _this = this; + const work = this.writeQueue[0]; + // destructure the enqueued work. + const directory = work.directory; + const locale = work.locale; + const cb = work.cb; + const languageFile = this._resolveLocaleFile(directory, locale); + const serializedLocale = JSON.stringify(this.cache[locale], null, 2); + shim.fs.writeFile(languageFile, serializedLocale, 'utf-8', function (err) { + _this.writeQueue.shift(); + if (_this.writeQueue.length > 0) + _this._processWriteQueue(); + cb(err); + }); + } + _readLocaleFile() { + let localeLookup = {}; + const languageFile = this._resolveLocaleFile(this.directory, this.locale); + try { + // When using a bundler such as webpack, readFileSync may not be defined: + if (shim.fs.readFileSync) { + localeLookup = JSON.parse(shim.fs.readFileSync(languageFile, 'utf-8')); + } + } + catch (err) { + if (err instanceof SyntaxError) { + err.message = 'syntax error in ' + languageFile; + } + if (err.code === 'ENOENT') + localeLookup = {}; + else + throw err; + } + this.cache[this.locale] = localeLookup; + } + _resolveLocaleFile(directory, locale) { + let file = shim.resolve(directory, './', locale + '.json'); + if (this.fallbackToLanguage && !this._fileExistsSync(file) && ~locale.lastIndexOf('_')) { + // attempt fallback to language only + const languageFile = shim.resolve(directory, './', locale.split('_')[0] + '.json'); + if (this._fileExistsSync(languageFile)) + file = languageFile; + } + return file; + } + _fileExistsSync(file) { + return shim.exists(file); + } +} +export function y18n(opts, _shim) { + shim = _shim; + const y18n = new Y18N(opts); + return { + __: y18n.__.bind(y18n), + __n: y18n.__n.bind(y18n), + setLocale: y18n.setLocale.bind(y18n), + getLocale: y18n.getLocale.bind(y18n), + updateLocale: y18n.updateLocale.bind(y18n), + locale: y18n.locale + }; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/y18n/build/lib/platform-shims/node.js b/novas/novacore-zephyr/claude-code-router/node_modules/y18n/build/lib/platform-shims/node.js new file mode 100644 index 0000000000000000000000000000000000000000..181208b81fcaa9d6916aed072abc7ff580781d6c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/y18n/build/lib/platform-shims/node.js @@ -0,0 +1,19 @@ +import { readFileSync, statSync, writeFile } from 'fs'; +import { format } from 'util'; +import { resolve } from 'path'; +export default { + fs: { + readFileSync, + writeFile + }, + format, + resolve, + exists: (file) => { + try { + return statSync(file).isFile(); + } + catch (err) { + return false; + } + } +}; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/yargs-parser/build/index.cjs b/novas/novacore-zephyr/claude-code-router/node_modules/yargs-parser/build/index.cjs new file mode 100644 index 0000000000000000000000000000000000000000..cf6f50f66e666f920a02cd19e4bcc9096b576d9a --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/yargs-parser/build/index.cjs @@ -0,0 +1,1050 @@ +'use strict'; + +var util = require('util'); +var path = require('path'); +var fs = require('fs'); + +function camelCase(str) { + const isCamelCase = str !== str.toLowerCase() && str !== str.toUpperCase(); + if (!isCamelCase) { + str = str.toLowerCase(); + } + if (str.indexOf('-') === -1 && str.indexOf('_') === -1) { + return str; + } + else { + let camelcase = ''; + let nextChrUpper = false; + const leadingHyphens = str.match(/^-+/); + for (let i = leadingHyphens ? leadingHyphens[0].length : 0; i < str.length; i++) { + let chr = str.charAt(i); + if (nextChrUpper) { + nextChrUpper = false; + chr = chr.toUpperCase(); + } + if (i !== 0 && (chr === '-' || chr === '_')) { + nextChrUpper = true; + } + else if (chr !== '-' && chr !== '_') { + camelcase += chr; + } + } + return camelcase; + } +} +function decamelize(str, joinString) { + const lowercase = str.toLowerCase(); + joinString = joinString || '-'; + let notCamelcase = ''; + for (let i = 0; i < str.length; i++) { + const chrLower = lowercase.charAt(i); + const chrString = str.charAt(i); + if (chrLower !== chrString && i > 0) { + notCamelcase += `${joinString}${lowercase.charAt(i)}`; + } + else { + notCamelcase += chrString; + } + } + return notCamelcase; +} +function looksLikeNumber(x) { + if (x === null || x === undefined) + return false; + if (typeof x === 'number') + return true; + if (/^0x[0-9a-f]+$/i.test(x)) + return true; + if (/^0[^.]/.test(x)) + return false; + return /^[-]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x); +} + +function tokenizeArgString(argString) { + if (Array.isArray(argString)) { + return argString.map(e => typeof e !== 'string' ? e + '' : e); + } + argString = argString.trim(); + let i = 0; + let prevC = null; + let c = null; + let opening = null; + const args = []; + for (let ii = 0; ii < argString.length; ii++) { + prevC = c; + c = argString.charAt(ii); + if (c === ' ' && !opening) { + if (!(prevC === ' ')) { + i++; + } + continue; + } + if (c === opening) { + opening = null; + } + else if ((c === "'" || c === '"') && !opening) { + opening = c; + } + if (!args[i]) + args[i] = ''; + args[i] += c; + } + return args; +} + +var DefaultValuesForTypeKey; +(function (DefaultValuesForTypeKey) { + DefaultValuesForTypeKey["BOOLEAN"] = "boolean"; + DefaultValuesForTypeKey["STRING"] = "string"; + DefaultValuesForTypeKey["NUMBER"] = "number"; + DefaultValuesForTypeKey["ARRAY"] = "array"; +})(DefaultValuesForTypeKey || (DefaultValuesForTypeKey = {})); + +let mixin; +class YargsParser { + constructor(_mixin) { + mixin = _mixin; + } + parse(argsInput, options) { + const opts = Object.assign({ + alias: undefined, + array: undefined, + boolean: undefined, + config: undefined, + configObjects: undefined, + configuration: undefined, + coerce: undefined, + count: undefined, + default: undefined, + envPrefix: undefined, + narg: undefined, + normalize: undefined, + string: undefined, + number: undefined, + __: undefined, + key: undefined + }, options); + const args = tokenizeArgString(argsInput); + const inputIsString = typeof argsInput === 'string'; + const aliases = combineAliases(Object.assign(Object.create(null), opts.alias)); + const configuration = Object.assign({ + 'boolean-negation': true, + 'camel-case-expansion': true, + 'combine-arrays': false, + 'dot-notation': true, + 'duplicate-arguments-array': true, + 'flatten-duplicate-arrays': true, + 'greedy-arrays': true, + 'halt-at-non-option': false, + 'nargs-eats-options': false, + 'negation-prefix': 'no-', + 'parse-numbers': true, + 'parse-positional-numbers': true, + 'populate--': false, + 'set-placeholder-key': false, + 'short-option-groups': true, + 'strip-aliased': false, + 'strip-dashed': false, + 'unknown-options-as-args': false + }, opts.configuration); + const defaults = Object.assign(Object.create(null), opts.default); + const configObjects = opts.configObjects || []; + const envPrefix = opts.envPrefix; + const notFlagsOption = configuration['populate--']; + const notFlagsArgv = notFlagsOption ? '--' : '_'; + const newAliases = Object.create(null); + const defaulted = Object.create(null); + const __ = opts.__ || mixin.format; + const flags = { + aliases: Object.create(null), + arrays: Object.create(null), + bools: Object.create(null), + strings: Object.create(null), + numbers: Object.create(null), + counts: Object.create(null), + normalize: Object.create(null), + configs: Object.create(null), + nargs: Object.create(null), + coercions: Object.create(null), + keys: [] + }; + const negative = /^-([0-9]+(\.[0-9]+)?|\.[0-9]+)$/; + const negatedBoolean = new RegExp('^--' + configuration['negation-prefix'] + '(.+)'); + [].concat(opts.array || []).filter(Boolean).forEach(function (opt) { + const key = typeof opt === 'object' ? opt.key : opt; + const assignment = Object.keys(opt).map(function (key) { + const arrayFlagKeys = { + boolean: 'bools', + string: 'strings', + number: 'numbers' + }; + return arrayFlagKeys[key]; + }).filter(Boolean).pop(); + if (assignment) { + flags[assignment][key] = true; + } + flags.arrays[key] = true; + flags.keys.push(key); + }); + [].concat(opts.boolean || []).filter(Boolean).forEach(function (key) { + flags.bools[key] = true; + flags.keys.push(key); + }); + [].concat(opts.string || []).filter(Boolean).forEach(function (key) { + flags.strings[key] = true; + flags.keys.push(key); + }); + [].concat(opts.number || []).filter(Boolean).forEach(function (key) { + flags.numbers[key] = true; + flags.keys.push(key); + }); + [].concat(opts.count || []).filter(Boolean).forEach(function (key) { + flags.counts[key] = true; + flags.keys.push(key); + }); + [].concat(opts.normalize || []).filter(Boolean).forEach(function (key) { + flags.normalize[key] = true; + flags.keys.push(key); + }); + if (typeof opts.narg === 'object') { + Object.entries(opts.narg).forEach(([key, value]) => { + if (typeof value === 'number') { + flags.nargs[key] = value; + flags.keys.push(key); + } + }); + } + if (typeof opts.coerce === 'object') { + Object.entries(opts.coerce).forEach(([key, value]) => { + if (typeof value === 'function') { + flags.coercions[key] = value; + flags.keys.push(key); + } + }); + } + if (typeof opts.config !== 'undefined') { + if (Array.isArray(opts.config) || typeof opts.config === 'string') { + [].concat(opts.config).filter(Boolean).forEach(function (key) { + flags.configs[key] = true; + }); + } + else if (typeof opts.config === 'object') { + Object.entries(opts.config).forEach(([key, value]) => { + if (typeof value === 'boolean' || typeof value === 'function') { + flags.configs[key] = value; + } + }); + } + } + extendAliases(opts.key, aliases, opts.default, flags.arrays); + Object.keys(defaults).forEach(function (key) { + (flags.aliases[key] || []).forEach(function (alias) { + defaults[alias] = defaults[key]; + }); + }); + let error = null; + checkConfiguration(); + let notFlags = []; + const argv = Object.assign(Object.create(null), { _: [] }); + const argvReturn = {}; + for (let i = 0; i < args.length; i++) { + const arg = args[i]; + const truncatedArg = arg.replace(/^-{3,}/, '---'); + let broken; + let key; + let letters; + let m; + let next; + let value; + if (arg !== '--' && /^-/.test(arg) && isUnknownOptionAsArg(arg)) { + pushPositional(arg); + } + else if (truncatedArg.match(/^---+(=|$)/)) { + pushPositional(arg); + continue; + } + else if (arg.match(/^--.+=/) || (!configuration['short-option-groups'] && arg.match(/^-.+=/))) { + m = arg.match(/^--?([^=]+)=([\s\S]*)$/); + if (m !== null && Array.isArray(m) && m.length >= 3) { + if (checkAllAliases(m[1], flags.arrays)) { + i = eatArray(i, m[1], args, m[2]); + } + else if (checkAllAliases(m[1], flags.nargs) !== false) { + i = eatNargs(i, m[1], args, m[2]); + } + else { + setArg(m[1], m[2], true); + } + } + } + else if (arg.match(negatedBoolean) && configuration['boolean-negation']) { + m = arg.match(negatedBoolean); + if (m !== null && Array.isArray(m) && m.length >= 2) { + key = m[1]; + setArg(key, checkAllAliases(key, flags.arrays) ? [false] : false); + } + } + else if (arg.match(/^--.+/) || (!configuration['short-option-groups'] && arg.match(/^-[^-]+/))) { + m = arg.match(/^--?(.+)/); + if (m !== null && Array.isArray(m) && m.length >= 2) { + key = m[1]; + if (checkAllAliases(key, flags.arrays)) { + i = eatArray(i, key, args); + } + else if (checkAllAliases(key, flags.nargs) !== false) { + i = eatNargs(i, key, args); + } + else { + next = args[i + 1]; + if (next !== undefined && (!next.match(/^-/) || + next.match(negative)) && + !checkAllAliases(key, flags.bools) && + !checkAllAliases(key, flags.counts)) { + setArg(key, next); + i++; + } + else if (/^(true|false)$/.test(next)) { + setArg(key, next); + i++; + } + else { + setArg(key, defaultValue(key)); + } + } + } + } + else if (arg.match(/^-.\..+=/)) { + m = arg.match(/^-([^=]+)=([\s\S]*)$/); + if (m !== null && Array.isArray(m) && m.length >= 3) { + setArg(m[1], m[2]); + } + } + else if (arg.match(/^-.\..+/) && !arg.match(negative)) { + next = args[i + 1]; + m = arg.match(/^-(.\..+)/); + if (m !== null && Array.isArray(m) && m.length >= 2) { + key = m[1]; + if (next !== undefined && !next.match(/^-/) && + !checkAllAliases(key, flags.bools) && + !checkAllAliases(key, flags.counts)) { + setArg(key, next); + i++; + } + else { + setArg(key, defaultValue(key)); + } + } + } + else if (arg.match(/^-[^-]+/) && !arg.match(negative)) { + letters = arg.slice(1, -1).split(''); + broken = false; + for (let j = 0; j < letters.length; j++) { + next = arg.slice(j + 2); + if (letters[j + 1] && letters[j + 1] === '=') { + value = arg.slice(j + 3); + key = letters[j]; + if (checkAllAliases(key, flags.arrays)) { + i = eatArray(i, key, args, value); + } + else if (checkAllAliases(key, flags.nargs) !== false) { + i = eatNargs(i, key, args, value); + } + else { + setArg(key, value); + } + broken = true; + break; + } + if (next === '-') { + setArg(letters[j], next); + continue; + } + if (/[A-Za-z]/.test(letters[j]) && + /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next) && + checkAllAliases(next, flags.bools) === false) { + setArg(letters[j], next); + broken = true; + break; + } + if (letters[j + 1] && letters[j + 1].match(/\W/)) { + setArg(letters[j], next); + broken = true; + break; + } + else { + setArg(letters[j], defaultValue(letters[j])); + } + } + key = arg.slice(-1)[0]; + if (!broken && key !== '-') { + if (checkAllAliases(key, flags.arrays)) { + i = eatArray(i, key, args); + } + else if (checkAllAliases(key, flags.nargs) !== false) { + i = eatNargs(i, key, args); + } + else { + next = args[i + 1]; + if (next !== undefined && (!/^(-|--)[^-]/.test(next) || + next.match(negative)) && + !checkAllAliases(key, flags.bools) && + !checkAllAliases(key, flags.counts)) { + setArg(key, next); + i++; + } + else if (/^(true|false)$/.test(next)) { + setArg(key, next); + i++; + } + else { + setArg(key, defaultValue(key)); + } + } + } + } + else if (arg.match(/^-[0-9]$/) && + arg.match(negative) && + checkAllAliases(arg.slice(1), flags.bools)) { + key = arg.slice(1); + setArg(key, defaultValue(key)); + } + else if (arg === '--') { + notFlags = args.slice(i + 1); + break; + } + else if (configuration['halt-at-non-option']) { + notFlags = args.slice(i); + break; + } + else { + pushPositional(arg); + } + } + applyEnvVars(argv, true); + applyEnvVars(argv, false); + setConfig(argv); + setConfigObjects(); + applyDefaultsAndAliases(argv, flags.aliases, defaults, true); + applyCoercions(argv); + if (configuration['set-placeholder-key']) + setPlaceholderKeys(argv); + Object.keys(flags.counts).forEach(function (key) { + if (!hasKey(argv, key.split('.'))) + setArg(key, 0); + }); + if (notFlagsOption && notFlags.length) + argv[notFlagsArgv] = []; + notFlags.forEach(function (key) { + argv[notFlagsArgv].push(key); + }); + if (configuration['camel-case-expansion'] && configuration['strip-dashed']) { + Object.keys(argv).filter(key => key !== '--' && key.includes('-')).forEach(key => { + delete argv[key]; + }); + } + if (configuration['strip-aliased']) { + [].concat(...Object.keys(aliases).map(k => aliases[k])).forEach(alias => { + if (configuration['camel-case-expansion'] && alias.includes('-')) { + delete argv[alias.split('.').map(prop => camelCase(prop)).join('.')]; + } + delete argv[alias]; + }); + } + function pushPositional(arg) { + const maybeCoercedNumber = maybeCoerceNumber('_', arg); + if (typeof maybeCoercedNumber === 'string' || typeof maybeCoercedNumber === 'number') { + argv._.push(maybeCoercedNumber); + } + } + function eatNargs(i, key, args, argAfterEqualSign) { + let ii; + let toEat = checkAllAliases(key, flags.nargs); + toEat = typeof toEat !== 'number' || isNaN(toEat) ? 1 : toEat; + if (toEat === 0) { + if (!isUndefined(argAfterEqualSign)) { + error = Error(__('Argument unexpected for: %s', key)); + } + setArg(key, defaultValue(key)); + return i; + } + let available = isUndefined(argAfterEqualSign) ? 0 : 1; + if (configuration['nargs-eats-options']) { + if (args.length - (i + 1) + available < toEat) { + error = Error(__('Not enough arguments following: %s', key)); + } + available = toEat; + } + else { + for (ii = i + 1; ii < args.length; ii++) { + if (!args[ii].match(/^-[^0-9]/) || args[ii].match(negative) || isUnknownOptionAsArg(args[ii])) + available++; + else + break; + } + if (available < toEat) + error = Error(__('Not enough arguments following: %s', key)); + } + let consumed = Math.min(available, toEat); + if (!isUndefined(argAfterEqualSign) && consumed > 0) { + setArg(key, argAfterEqualSign); + consumed--; + } + for (ii = i + 1; ii < (consumed + i + 1); ii++) { + setArg(key, args[ii]); + } + return (i + consumed); + } + function eatArray(i, key, args, argAfterEqualSign) { + let argsToSet = []; + let next = argAfterEqualSign || args[i + 1]; + const nargsCount = checkAllAliases(key, flags.nargs); + if (checkAllAliases(key, flags.bools) && !(/^(true|false)$/.test(next))) { + argsToSet.push(true); + } + else if (isUndefined(next) || + (isUndefined(argAfterEqualSign) && /^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next))) { + if (defaults[key] !== undefined) { + const defVal = defaults[key]; + argsToSet = Array.isArray(defVal) ? defVal : [defVal]; + } + } + else { + if (!isUndefined(argAfterEqualSign)) { + argsToSet.push(processValue(key, argAfterEqualSign, true)); + } + for (let ii = i + 1; ii < args.length; ii++) { + if ((!configuration['greedy-arrays'] && argsToSet.length > 0) || + (nargsCount && typeof nargsCount === 'number' && argsToSet.length >= nargsCount)) + break; + next = args[ii]; + if (/^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next)) + break; + i = ii; + argsToSet.push(processValue(key, next, inputIsString)); + } + } + if (typeof nargsCount === 'number' && ((nargsCount && argsToSet.length < nargsCount) || + (isNaN(nargsCount) && argsToSet.length === 0))) { + error = Error(__('Not enough arguments following: %s', key)); + } + setArg(key, argsToSet); + return i; + } + function setArg(key, val, shouldStripQuotes = inputIsString) { + if (/-/.test(key) && configuration['camel-case-expansion']) { + const alias = key.split('.').map(function (prop) { + return camelCase(prop); + }).join('.'); + addNewAlias(key, alias); + } + const value = processValue(key, val, shouldStripQuotes); + const splitKey = key.split('.'); + setKey(argv, splitKey, value); + if (flags.aliases[key]) { + flags.aliases[key].forEach(function (x) { + const keyProperties = x.split('.'); + setKey(argv, keyProperties, value); + }); + } + if (splitKey.length > 1 && configuration['dot-notation']) { + (flags.aliases[splitKey[0]] || []).forEach(function (x) { + let keyProperties = x.split('.'); + const a = [].concat(splitKey); + a.shift(); + keyProperties = keyProperties.concat(a); + if (!(flags.aliases[key] || []).includes(keyProperties.join('.'))) { + setKey(argv, keyProperties, value); + } + }); + } + if (checkAllAliases(key, flags.normalize) && !checkAllAliases(key, flags.arrays)) { + const keys = [key].concat(flags.aliases[key] || []); + keys.forEach(function (key) { + Object.defineProperty(argvReturn, key, { + enumerable: true, + get() { + return val; + }, + set(value) { + val = typeof value === 'string' ? mixin.normalize(value) : value; + } + }); + }); + } + } + function addNewAlias(key, alias) { + if (!(flags.aliases[key] && flags.aliases[key].length)) { + flags.aliases[key] = [alias]; + newAliases[alias] = true; + } + if (!(flags.aliases[alias] && flags.aliases[alias].length)) { + addNewAlias(alias, key); + } + } + function processValue(key, val, shouldStripQuotes) { + if (shouldStripQuotes) { + val = stripQuotes(val); + } + if (checkAllAliases(key, flags.bools) || checkAllAliases(key, flags.counts)) { + if (typeof val === 'string') + val = val === 'true'; + } + let value = Array.isArray(val) + ? val.map(function (v) { return maybeCoerceNumber(key, v); }) + : maybeCoerceNumber(key, val); + if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === 'boolean')) { + value = increment(); + } + if (checkAllAliases(key, flags.normalize) && checkAllAliases(key, flags.arrays)) { + if (Array.isArray(val)) + value = val.map((val) => { return mixin.normalize(val); }); + else + value = mixin.normalize(val); + } + return value; + } + function maybeCoerceNumber(key, value) { + if (!configuration['parse-positional-numbers'] && key === '_') + return value; + if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.bools) && !Array.isArray(value)) { + const shouldCoerceNumber = looksLikeNumber(value) && configuration['parse-numbers'] && (Number.isSafeInteger(Math.floor(parseFloat(`${value}`)))); + if (shouldCoerceNumber || (!isUndefined(value) && checkAllAliases(key, flags.numbers))) { + value = Number(value); + } + } + return value; + } + function setConfig(argv) { + const configLookup = Object.create(null); + applyDefaultsAndAliases(configLookup, flags.aliases, defaults); + Object.keys(flags.configs).forEach(function (configKey) { + const configPath = argv[configKey] || configLookup[configKey]; + if (configPath) { + try { + let config = null; + const resolvedConfigPath = mixin.resolve(mixin.cwd(), configPath); + const resolveConfig = flags.configs[configKey]; + if (typeof resolveConfig === 'function') { + try { + config = resolveConfig(resolvedConfigPath); + } + catch (e) { + config = e; + } + if (config instanceof Error) { + error = config; + return; + } + } + else { + config = mixin.require(resolvedConfigPath); + } + setConfigObject(config); + } + catch (ex) { + if (ex.name === 'PermissionDenied') + error = ex; + else if (argv[configKey]) + error = Error(__('Invalid JSON config file: %s', configPath)); + } + } + }); + } + function setConfigObject(config, prev) { + Object.keys(config).forEach(function (key) { + const value = config[key]; + const fullKey = prev ? prev + '.' + key : key; + if (typeof value === 'object' && value !== null && !Array.isArray(value) && configuration['dot-notation']) { + setConfigObject(value, fullKey); + } + else { + if (!hasKey(argv, fullKey.split('.')) || (checkAllAliases(fullKey, flags.arrays) && configuration['combine-arrays'])) { + setArg(fullKey, value); + } + } + }); + } + function setConfigObjects() { + if (typeof configObjects !== 'undefined') { + configObjects.forEach(function (configObject) { + setConfigObject(configObject); + }); + } + } + function applyEnvVars(argv, configOnly) { + if (typeof envPrefix === 'undefined') + return; + const prefix = typeof envPrefix === 'string' ? envPrefix : ''; + const env = mixin.env(); + Object.keys(env).forEach(function (envVar) { + if (prefix === '' || envVar.lastIndexOf(prefix, 0) === 0) { + const keys = envVar.split('__').map(function (key, i) { + if (i === 0) { + key = key.substring(prefix.length); + } + return camelCase(key); + }); + if (((configOnly && flags.configs[keys.join('.')]) || !configOnly) && !hasKey(argv, keys)) { + setArg(keys.join('.'), env[envVar]); + } + } + }); + } + function applyCoercions(argv) { + let coerce; + const applied = new Set(); + Object.keys(argv).forEach(function (key) { + if (!applied.has(key)) { + coerce = checkAllAliases(key, flags.coercions); + if (typeof coerce === 'function') { + try { + const value = maybeCoerceNumber(key, coerce(argv[key])); + ([].concat(flags.aliases[key] || [], key)).forEach(ali => { + applied.add(ali); + argv[ali] = value; + }); + } + catch (err) { + error = err; + } + } + } + }); + } + function setPlaceholderKeys(argv) { + flags.keys.forEach((key) => { + if (~key.indexOf('.')) + return; + if (typeof argv[key] === 'undefined') + argv[key] = undefined; + }); + return argv; + } + function applyDefaultsAndAliases(obj, aliases, defaults, canLog = false) { + Object.keys(defaults).forEach(function (key) { + if (!hasKey(obj, key.split('.'))) { + setKey(obj, key.split('.'), defaults[key]); + if (canLog) + defaulted[key] = true; + (aliases[key] || []).forEach(function (x) { + if (hasKey(obj, x.split('.'))) + return; + setKey(obj, x.split('.'), defaults[key]); + }); + } + }); + } + function hasKey(obj, keys) { + let o = obj; + if (!configuration['dot-notation']) + keys = [keys.join('.')]; + keys.slice(0, -1).forEach(function (key) { + o = (o[key] || {}); + }); + const key = keys[keys.length - 1]; + if (typeof o !== 'object') + return false; + else + return key in o; + } + function setKey(obj, keys, value) { + let o = obj; + if (!configuration['dot-notation']) + keys = [keys.join('.')]; + keys.slice(0, -1).forEach(function (key) { + key = sanitizeKey(key); + if (typeof o === 'object' && o[key] === undefined) { + o[key] = {}; + } + if (typeof o[key] !== 'object' || Array.isArray(o[key])) { + if (Array.isArray(o[key])) { + o[key].push({}); + } + else { + o[key] = [o[key], {}]; + } + o = o[key][o[key].length - 1]; + } + else { + o = o[key]; + } + }); + const key = sanitizeKey(keys[keys.length - 1]); + const isTypeArray = checkAllAliases(keys.join('.'), flags.arrays); + const isValueArray = Array.isArray(value); + let duplicate = configuration['duplicate-arguments-array']; + if (!duplicate && checkAllAliases(key, flags.nargs)) { + duplicate = true; + if ((!isUndefined(o[key]) && flags.nargs[key] === 1) || (Array.isArray(o[key]) && o[key].length === flags.nargs[key])) { + o[key] = undefined; + } + } + if (value === increment()) { + o[key] = increment(o[key]); + } + else if (Array.isArray(o[key])) { + if (duplicate && isTypeArray && isValueArray) { + o[key] = configuration['flatten-duplicate-arrays'] ? o[key].concat(value) : (Array.isArray(o[key][0]) ? o[key] : [o[key]]).concat([value]); + } + else if (!duplicate && Boolean(isTypeArray) === Boolean(isValueArray)) { + o[key] = value; + } + else { + o[key] = o[key].concat([value]); + } + } + else if (o[key] === undefined && isTypeArray) { + o[key] = isValueArray ? value : [value]; + } + else if (duplicate && !(o[key] === undefined || + checkAllAliases(key, flags.counts) || + checkAllAliases(key, flags.bools))) { + o[key] = [o[key], value]; + } + else { + o[key] = value; + } + } + function extendAliases(...args) { + args.forEach(function (obj) { + Object.keys(obj || {}).forEach(function (key) { + if (flags.aliases[key]) + return; + flags.aliases[key] = [].concat(aliases[key] || []); + flags.aliases[key].concat(key).forEach(function (x) { + if (/-/.test(x) && configuration['camel-case-expansion']) { + const c = camelCase(x); + if (c !== key && flags.aliases[key].indexOf(c) === -1) { + flags.aliases[key].push(c); + newAliases[c] = true; + } + } + }); + flags.aliases[key].concat(key).forEach(function (x) { + if (x.length > 1 && /[A-Z]/.test(x) && configuration['camel-case-expansion']) { + const c = decamelize(x, '-'); + if (c !== key && flags.aliases[key].indexOf(c) === -1) { + flags.aliases[key].push(c); + newAliases[c] = true; + } + } + }); + flags.aliases[key].forEach(function (x) { + flags.aliases[x] = [key].concat(flags.aliases[key].filter(function (y) { + return x !== y; + })); + }); + }); + }); + } + function checkAllAliases(key, flag) { + const toCheck = [].concat(flags.aliases[key] || [], key); + const keys = Object.keys(flag); + const setAlias = toCheck.find(key => keys.includes(key)); + return setAlias ? flag[setAlias] : false; + } + function hasAnyFlag(key) { + const flagsKeys = Object.keys(flags); + const toCheck = [].concat(flagsKeys.map(k => flags[k])); + return toCheck.some(function (flag) { + return Array.isArray(flag) ? flag.includes(key) : flag[key]; + }); + } + function hasFlagsMatching(arg, ...patterns) { + const toCheck = [].concat(...patterns); + return toCheck.some(function (pattern) { + const match = arg.match(pattern); + return match && hasAnyFlag(match[1]); + }); + } + function hasAllShortFlags(arg) { + if (arg.match(negative) || !arg.match(/^-[^-]+/)) { + return false; + } + let hasAllFlags = true; + let next; + const letters = arg.slice(1).split(''); + for (let j = 0; j < letters.length; j++) { + next = arg.slice(j + 2); + if (!hasAnyFlag(letters[j])) { + hasAllFlags = false; + break; + } + if ((letters[j + 1] && letters[j + 1] === '=') || + next === '-' || + (/[A-Za-z]/.test(letters[j]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) || + (letters[j + 1] && letters[j + 1].match(/\W/))) { + break; + } + } + return hasAllFlags; + } + function isUnknownOptionAsArg(arg) { + return configuration['unknown-options-as-args'] && isUnknownOption(arg); + } + function isUnknownOption(arg) { + arg = arg.replace(/^-{3,}/, '--'); + if (arg.match(negative)) { + return false; + } + if (hasAllShortFlags(arg)) { + return false; + } + const flagWithEquals = /^-+([^=]+?)=[\s\S]*$/; + const normalFlag = /^-+([^=]+?)$/; + const flagEndingInHyphen = /^-+([^=]+?)-$/; + const flagEndingInDigits = /^-+([^=]+?\d+)$/; + const flagEndingInNonWordCharacters = /^-+([^=]+?)\W+.*$/; + return !hasFlagsMatching(arg, flagWithEquals, negatedBoolean, normalFlag, flagEndingInHyphen, flagEndingInDigits, flagEndingInNonWordCharacters); + } + function defaultValue(key) { + if (!checkAllAliases(key, flags.bools) && + !checkAllAliases(key, flags.counts) && + `${key}` in defaults) { + return defaults[key]; + } + else { + return defaultForType(guessType(key)); + } + } + function defaultForType(type) { + const def = { + [DefaultValuesForTypeKey.BOOLEAN]: true, + [DefaultValuesForTypeKey.STRING]: '', + [DefaultValuesForTypeKey.NUMBER]: undefined, + [DefaultValuesForTypeKey.ARRAY]: [] + }; + return def[type]; + } + function guessType(key) { + let type = DefaultValuesForTypeKey.BOOLEAN; + if (checkAllAliases(key, flags.strings)) + type = DefaultValuesForTypeKey.STRING; + else if (checkAllAliases(key, flags.numbers)) + type = DefaultValuesForTypeKey.NUMBER; + else if (checkAllAliases(key, flags.bools)) + type = DefaultValuesForTypeKey.BOOLEAN; + else if (checkAllAliases(key, flags.arrays)) + type = DefaultValuesForTypeKey.ARRAY; + return type; + } + function isUndefined(num) { + return num === undefined; + } + function checkConfiguration() { + Object.keys(flags.counts).find(key => { + if (checkAllAliases(key, flags.arrays)) { + error = Error(__('Invalid configuration: %s, opts.count excludes opts.array.', key)); + return true; + } + else if (checkAllAliases(key, flags.nargs)) { + error = Error(__('Invalid configuration: %s, opts.count excludes opts.narg.', key)); + return true; + } + return false; + }); + } + return { + aliases: Object.assign({}, flags.aliases), + argv: Object.assign(argvReturn, argv), + configuration: configuration, + defaulted: Object.assign({}, defaulted), + error: error, + newAliases: Object.assign({}, newAliases) + }; + } +} +function combineAliases(aliases) { + const aliasArrays = []; + const combined = Object.create(null); + let change = true; + Object.keys(aliases).forEach(function (key) { + aliasArrays.push([].concat(aliases[key], key)); + }); + while (change) { + change = false; + for (let i = 0; i < aliasArrays.length; i++) { + for (let ii = i + 1; ii < aliasArrays.length; ii++) { + const intersect = aliasArrays[i].filter(function (v) { + return aliasArrays[ii].indexOf(v) !== -1; + }); + if (intersect.length) { + aliasArrays[i] = aliasArrays[i].concat(aliasArrays[ii]); + aliasArrays.splice(ii, 1); + change = true; + break; + } + } + } + } + aliasArrays.forEach(function (aliasArray) { + aliasArray = aliasArray.filter(function (v, i, self) { + return self.indexOf(v) === i; + }); + const lastAlias = aliasArray.pop(); + if (lastAlias !== undefined && typeof lastAlias === 'string') { + combined[lastAlias] = aliasArray; + } + }); + return combined; +} +function increment(orig) { + return orig !== undefined ? orig + 1 : 1; +} +function sanitizeKey(key) { + if (key === '__proto__') + return '___proto___'; + return key; +} +function stripQuotes(val) { + return (typeof val === 'string' && + (val[0] === "'" || val[0] === '"') && + val[val.length - 1] === val[0]) + ? val.substring(1, val.length - 1) + : val; +} + +var _a, _b, _c; +const minNodeVersion = (process && process.env && process.env.YARGS_MIN_NODE_VERSION) + ? Number(process.env.YARGS_MIN_NODE_VERSION) + : 12; +const nodeVersion = (_b = (_a = process === null || process === void 0 ? void 0 : process.versions) === null || _a === void 0 ? void 0 : _a.node) !== null && _b !== void 0 ? _b : (_c = process === null || process === void 0 ? void 0 : process.version) === null || _c === void 0 ? void 0 : _c.slice(1); +if (nodeVersion) { + const major = Number(nodeVersion.match(/^([^.]+)/)[1]); + if (major < minNodeVersion) { + throw Error(`yargs parser supports a minimum Node.js version of ${minNodeVersion}. Read our version support policy: https://github.com/yargs/yargs-parser#supported-nodejs-versions`); + } +} +const env = process ? process.env : {}; +const parser = new YargsParser({ + cwd: process.cwd, + env: () => { + return env; + }, + format: util.format, + normalize: path.normalize, + resolve: path.resolve, + require: (path) => { + if (typeof require !== 'undefined') { + return require(path); + } + else if (path.match(/\.json$/)) { + return JSON.parse(fs.readFileSync(path, 'utf8')); + } + else { + throw Error('only .json config files are supported in ESM'); + } + } +}); +const yargsParser = function Parser(args, opts) { + const result = parser.parse(args.slice(), opts); + return result.argv; +}; +yargsParser.detailed = function (args, opts) { + return parser.parse(args.slice(), opts); +}; +yargsParser.camelCase = camelCase; +yargsParser.decamelize = decamelize; +yargsParser.looksLikeNumber = looksLikeNumber; + +module.exports = yargsParser; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/yargs-parser/build/lib/index.js b/novas/novacore-zephyr/claude-code-router/node_modules/yargs-parser/build/lib/index.js new file mode 100644 index 0000000000000000000000000000000000000000..43ef485abc049c432ce5ef8e50a702dd05f78915 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/yargs-parser/build/lib/index.js @@ -0,0 +1,62 @@ +/** + * @fileoverview Main entrypoint for libraries using yargs-parser in Node.js + * CJS and ESM environments. + * + * @license + * Copyright (c) 2016, Contributors + * SPDX-License-Identifier: ISC + */ +var _a, _b, _c; +import { format } from 'util'; +import { normalize, resolve } from 'path'; +import { camelCase, decamelize, looksLikeNumber } from './string-utils.js'; +import { YargsParser } from './yargs-parser.js'; +import { readFileSync } from 'fs'; +// See https://github.com/yargs/yargs-parser#supported-nodejs-versions for our +// version support policy. The YARGS_MIN_NODE_VERSION is used for testing only. +const minNodeVersion = (process && process.env && process.env.YARGS_MIN_NODE_VERSION) + ? Number(process.env.YARGS_MIN_NODE_VERSION) + : 12; +const nodeVersion = (_b = (_a = process === null || process === void 0 ? void 0 : process.versions) === null || _a === void 0 ? void 0 : _a.node) !== null && _b !== void 0 ? _b : (_c = process === null || process === void 0 ? void 0 : process.version) === null || _c === void 0 ? void 0 : _c.slice(1); +if (nodeVersion) { + const major = Number(nodeVersion.match(/^([^.]+)/)[1]); + if (major < minNodeVersion) { + throw Error(`yargs parser supports a minimum Node.js version of ${minNodeVersion}. Read our version support policy: https://github.com/yargs/yargs-parser#supported-nodejs-versions`); + } +} +// Creates a yargs-parser instance using Node.js standard libraries: +const env = process ? process.env : {}; +const parser = new YargsParser({ + cwd: process.cwd, + env: () => { + return env; + }, + format, + normalize, + resolve, + // TODO: figure out a way to combine ESM and CJS coverage, such that + // we can exercise all the lines below: + require: (path) => { + if (typeof require !== 'undefined') { + return require(path); + } + else if (path.match(/\.json$/)) { + // Addresses: https://github.com/yargs/yargs/issues/2040 + return JSON.parse(readFileSync(path, 'utf8')); + } + else { + throw Error('only .json config files are supported in ESM'); + } + } +}); +const yargsParser = function Parser(args, opts) { + const result = parser.parse(args.slice(), opts); + return result.argv; +}; +yargsParser.detailed = function (args, opts) { + return parser.parse(args.slice(), opts); +}; +yargsParser.camelCase = camelCase; +yargsParser.decamelize = decamelize; +yargsParser.looksLikeNumber = looksLikeNumber; +export default yargsParser; diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/yargs-parser/build/lib/string-utils.js b/novas/novacore-zephyr/claude-code-router/node_modules/yargs-parser/build/lib/string-utils.js new file mode 100644 index 0000000000000000000000000000000000000000..4e8bd996e7a97a2c1e9c9fc4919044a171b73918 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/yargs-parser/build/lib/string-utils.js @@ -0,0 +1,65 @@ +/** + * @license + * Copyright (c) 2016, Contributors + * SPDX-License-Identifier: ISC + */ +export function camelCase(str) { + // Handle the case where an argument is provided as camel case, e.g., fooBar. + // by ensuring that the string isn't already mixed case: + const isCamelCase = str !== str.toLowerCase() && str !== str.toUpperCase(); + if (!isCamelCase) { + str = str.toLowerCase(); + } + if (str.indexOf('-') === -1 && str.indexOf('_') === -1) { + return str; + } + else { + let camelcase = ''; + let nextChrUpper = false; + const leadingHyphens = str.match(/^-+/); + for (let i = leadingHyphens ? leadingHyphens[0].length : 0; i < str.length; i++) { + let chr = str.charAt(i); + if (nextChrUpper) { + nextChrUpper = false; + chr = chr.toUpperCase(); + } + if (i !== 0 && (chr === '-' || chr === '_')) { + nextChrUpper = true; + } + else if (chr !== '-' && chr !== '_') { + camelcase += chr; + } + } + return camelcase; + } +} +export function decamelize(str, joinString) { + const lowercase = str.toLowerCase(); + joinString = joinString || '-'; + let notCamelcase = ''; + for (let i = 0; i < str.length; i++) { + const chrLower = lowercase.charAt(i); + const chrString = str.charAt(i); + if (chrLower !== chrString && i > 0) { + notCamelcase += `${joinString}${lowercase.charAt(i)}`; + } + else { + notCamelcase += chrString; + } + } + return notCamelcase; +} +export function looksLikeNumber(x) { + if (x === null || x === undefined) + return false; + // if loaded from config, may already be a number. + if (typeof x === 'number') + return true; + // hexadecimal. + if (/^0x[0-9a-f]+$/i.test(x)) + return true; + // don't treat 0123 as a number; as it drops the leading '0'. + if (/^0[^.]/.test(x)) + return false; + return /^[-]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x); +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/yargs-parser/build/lib/tokenize-arg-string.js b/novas/novacore-zephyr/claude-code-router/node_modules/yargs-parser/build/lib/tokenize-arg-string.js new file mode 100644 index 0000000000000000000000000000000000000000..5e732efe019ab064effaa667bfe7bf904a5f1cb0 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/yargs-parser/build/lib/tokenize-arg-string.js @@ -0,0 +1,40 @@ +/** + * @license + * Copyright (c) 2016, Contributors + * SPDX-License-Identifier: ISC + */ +// take an un-split argv string and tokenize it. +export function tokenizeArgString(argString) { + if (Array.isArray(argString)) { + return argString.map(e => typeof e !== 'string' ? e + '' : e); + } + argString = argString.trim(); + let i = 0; + let prevC = null; + let c = null; + let opening = null; + const args = []; + for (let ii = 0; ii < argString.length; ii++) { + prevC = c; + c = argString.charAt(ii); + // split on spaces unless we're in quotes. + if (c === ' ' && !opening) { + if (!(prevC === ' ')) { + i++; + } + continue; + } + // don't split the string if we're in matching + // opening or closing single and double quotes. + if (c === opening) { + opening = null; + } + else if ((c === "'" || c === '"') && !opening) { + opening = c; + } + if (!args[i]) + args[i] = ''; + args[i] += c; + } + return args; +} diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/yargs-parser/build/lib/yargs-parser-types.js b/novas/novacore-zephyr/claude-code-router/node_modules/yargs-parser/build/lib/yargs-parser-types.js new file mode 100644 index 0000000000000000000000000000000000000000..63b7c313aa9b5fe645373222c88c5bccb19b806c --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/yargs-parser/build/lib/yargs-parser-types.js @@ -0,0 +1,12 @@ +/** + * @license + * Copyright (c) 2016, Contributors + * SPDX-License-Identifier: ISC + */ +export var DefaultValuesForTypeKey; +(function (DefaultValuesForTypeKey) { + DefaultValuesForTypeKey["BOOLEAN"] = "boolean"; + DefaultValuesForTypeKey["STRING"] = "string"; + DefaultValuesForTypeKey["NUMBER"] = "number"; + DefaultValuesForTypeKey["ARRAY"] = "array"; +})(DefaultValuesForTypeKey || (DefaultValuesForTypeKey = {})); diff --git a/novas/novacore-zephyr/claude-code-router/node_modules/yargs-parser/build/lib/yargs-parser.js b/novas/novacore-zephyr/claude-code-router/node_modules/yargs-parser/build/lib/yargs-parser.js new file mode 100644 index 0000000000000000000000000000000000000000..415d4bc8cb87a5b91d4ada8add37f250dca5b3a0 --- /dev/null +++ b/novas/novacore-zephyr/claude-code-router/node_modules/yargs-parser/build/lib/yargs-parser.js @@ -0,0 +1,1045 @@ +/** + * @license + * Copyright (c) 2016, Contributors + * SPDX-License-Identifier: ISC + */ +import { tokenizeArgString } from './tokenize-arg-string.js'; +import { DefaultValuesForTypeKey } from './yargs-parser-types.js'; +import { camelCase, decamelize, looksLikeNumber } from './string-utils.js'; +let mixin; +export class YargsParser { + constructor(_mixin) { + mixin = _mixin; + } + parse(argsInput, options) { + const opts = Object.assign({ + alias: undefined, + array: undefined, + boolean: undefined, + config: undefined, + configObjects: undefined, + configuration: undefined, + coerce: undefined, + count: undefined, + default: undefined, + envPrefix: undefined, + narg: undefined, + normalize: undefined, + string: undefined, + number: undefined, + __: undefined, + key: undefined + }, options); + // allow a string argument to be passed in rather + // than an argv array. + const args = tokenizeArgString(argsInput); + // tokenizeArgString adds extra quotes to args if argsInput is a string + // only strip those extra quotes in processValue if argsInput is a string + const inputIsString = typeof argsInput === 'string'; + // aliases might have transitive relationships, normalize this. + const aliases = combineAliases(Object.assign(Object.create(null), opts.alias)); + const configuration = Object.assign({ + 'boolean-negation': true, + 'camel-case-expansion': true, + 'combine-arrays': false, + 'dot-notation': true, + 'duplicate-arguments-array': true, + 'flatten-duplicate-arrays': true, + 'greedy-arrays': true, + 'halt-at-non-option': false, + 'nargs-eats-options': false, + 'negation-prefix': 'no-', + 'parse-numbers': true, + 'parse-positional-numbers': true, + 'populate--': false, + 'set-placeholder-key': false, + 'short-option-groups': true, + 'strip-aliased': false, + 'strip-dashed': false, + 'unknown-options-as-args': false + }, opts.configuration); + const defaults = Object.assign(Object.create(null), opts.default); + const configObjects = opts.configObjects || []; + const envPrefix = opts.envPrefix; + const notFlagsOption = configuration['populate--']; + const notFlagsArgv = notFlagsOption ? '--' : '_'; + const newAliases = Object.create(null); + const defaulted = Object.create(null); + // allow a i18n handler to be passed in, default to a fake one (util.format). + const __ = opts.__ || mixin.format; + const flags = { + aliases: Object.create(null), + arrays: Object.create(null), + bools: Object.create(null), + strings: Object.create(null), + numbers: Object.create(null), + counts: Object.create(null), + normalize: Object.create(null), + configs: Object.create(null), + nargs: Object.create(null), + coercions: Object.create(null), + keys: [] + }; + const negative = /^-([0-9]+(\.[0-9]+)?|\.[0-9]+)$/; + const negatedBoolean = new RegExp('^--' + configuration['negation-prefix'] + '(.+)'); + [].concat(opts.array || []).filter(Boolean).forEach(function (opt) { + const key = typeof opt === 'object' ? opt.key : opt; + // assign to flags[bools|strings|numbers] + const assignment = Object.keys(opt).map(function (key) { + const arrayFlagKeys = { + boolean: 'bools', + string: 'strings', + number: 'numbers' + }; + return arrayFlagKeys[key]; + }).filter(Boolean).pop(); + // assign key to be coerced + if (assignment) { + flags[assignment][key] = true; + } + flags.arrays[key] = true; + flags.keys.push(key); + }); + [].concat(opts.boolean || []).filter(Boolean).forEach(function (key) { + flags.bools[key] = true; + flags.keys.push(key); + }); + [].concat(opts.string || []).filter(Boolean).forEach(function (key) { + flags.strings[key] = true; + flags.keys.push(key); + }); + [].concat(opts.number || []).filter(Boolean).forEach(function (key) { + flags.numbers[key] = true; + flags.keys.push(key); + }); + [].concat(opts.count || []).filter(Boolean).forEach(function (key) { + flags.counts[key] = true; + flags.keys.push(key); + }); + [].concat(opts.normalize || []).filter(Boolean).forEach(function (key) { + flags.normalize[key] = true; + flags.keys.push(key); + }); + if (typeof opts.narg === 'object') { + Object.entries(opts.narg).forEach(([key, value]) => { + if (typeof value === 'number') { + flags.nargs[key] = value; + flags.keys.push(key); + } + }); + } + if (typeof opts.coerce === 'object') { + Object.entries(opts.coerce).forEach(([key, value]) => { + if (typeof value === 'function') { + flags.coercions[key] = value; + flags.keys.push(key); + } + }); + } + if (typeof opts.config !== 'undefined') { + if (Array.isArray(opts.config) || typeof opts.config === 'string') { + ; + [].concat(opts.config).filter(Boolean).forEach(function (key) { + flags.configs[key] = true; + }); + } + else if (typeof opts.config === 'object') { + Object.entries(opts.config).forEach(([key, value]) => { + if (typeof value === 'boolean' || typeof value === 'function') { + flags.configs[key] = value; + } + }); + } + } + // create a lookup table that takes into account all + // combinations of aliases: {f: ['foo'], foo: ['f']} + extendAliases(opts.key, aliases, opts.default, flags.arrays); + // apply default values to all aliases. + Object.keys(defaults).forEach(function (key) { + (flags.aliases[key] || []).forEach(function (alias) { + defaults[alias] = defaults[key]; + }); + }); + let error = null; + checkConfiguration(); + let notFlags = []; + const argv = Object.assign(Object.create(null), { _: [] }); + // TODO(bcoe): for the first pass at removing object prototype we didn't + // remove all prototypes from objects returned by this API, we might want + // to gradually move towards doing so. + const argvReturn = {}; + for (let i = 0; i < args.length; i++) { + const arg = args[i]; + const truncatedArg = arg.replace(/^-{3,}/, '---'); + let broken; + let key; + let letters; + let m; + let next; + let value; + // any unknown option (except for end-of-options, "--") + if (arg !== '--' && /^-/.test(arg) && isUnknownOptionAsArg(arg)) { + pushPositional(arg); + // ---, ---=, ----, etc, + } + else if (truncatedArg.match(/^---+(=|$)/)) { + // options without key name are invalid. + pushPositional(arg); + continue; + // -- separated by = + } + else if (arg.match(/^--.+=/) || (!configuration['short-option-groups'] && arg.match(/^-.+=/))) { + // Using [\s\S] instead of . because js doesn't support the + // 'dotall' regex modifier. See: + // http://stackoverflow.com/a/1068308/13216 + m = arg.match(/^--?([^=]+)=([\s\S]*)$/); + // arrays format = '--f=a b c' + if (m !== null && Array.isArray(m) && m.length >= 3) { + if (checkAllAliases(m[1], flags.arrays)) { + i = eatArray(i, m[1], args, m[2]); + } + else if (checkAllAliases(m[1], flags.nargs) !== false) { + // nargs format = '--f=monkey washing cat' + i = eatNargs(i, m[1], args, m[2]); + } + else { + setArg(m[1], m[2], true); + } + } + } + else if (arg.match(negatedBoolean) && configuration['boolean-negation']) { + m = arg.match(negatedBoolean); + if (m !== null && Array.isArray(m) && m.length >= 2) { + key = m[1]; + setArg(key, checkAllAliases(key, flags.arrays) ? [false] : false); + } + // -- separated by space. + } + else if (arg.match(/^--.+/) || (!configuration['short-option-groups'] && arg.match(/^-[^-]+/))) { + m = arg.match(/^--?(.+)/); + if (m !== null && Array.isArray(m) && m.length >= 2) { + key = m[1]; + if (checkAllAliases(key, flags.arrays)) { + // array format = '--foo a b c' + i = eatArray(i, key, args); + } + else if (checkAllAliases(key, flags.nargs) !== false) { + // nargs format = '--foo a b c' + // should be truthy even if: flags.nargs[key] === 0 + i = eatNargs(i, key, args); + } + else { + next = args[i + 1]; + if (next !== undefined && (!next.match(/^-/) || + next.match(negative)) && + !checkAllAliases(key, flags.bools) && + !checkAllAliases(key, flags.counts)) { + setArg(key, next); + i++; + } + else if (/^(true|false)$/.test(next)) { + setArg(key, next); + i++; + } + else { + setArg(key, defaultValue(key)); + } + } + } + // dot-notation flag separated by '='. + } + else if (arg.match(/^-.\..+=/)) { + m = arg.match(/^-([^=]+)=([\s\S]*)$/); + if (m !== null && Array.isArray(m) && m.length >= 3) { + setArg(m[1], m[2]); + } + // dot-notation flag separated by space. + } + else if (arg.match(/^-.\..+/) && !arg.match(negative)) { + next = args[i + 1]; + m = arg.match(/^-(.\..+)/); + if (m !== null && Array.isArray(m) && m.length >= 2) { + key = m[1]; + if (next !== undefined && !next.match(/^-/) && + !checkAllAliases(key, flags.bools) && + !checkAllAliases(key, flags.counts)) { + setArg(key, next); + i++; + } + else { + setArg(key, defaultValue(key)); + } + } + } + else if (arg.match(/^-[^-]+/) && !arg.match(negative)) { + letters = arg.slice(1, -1).split(''); + broken = false; + for (let j = 0; j < letters.length; j++) { + next = arg.slice(j + 2); + if (letters[j + 1] && letters[j + 1] === '=') { + value = arg.slice(j + 3); + key = letters[j]; + if (checkAllAliases(key, flags.arrays)) { + // array format = '-f=a b c' + i = eatArray(i, key, args, value); + } + else if (checkAllAliases(key, flags.nargs) !== false) { + // nargs format = '-f=monkey washing cat' + i = eatNargs(i, key, args, value); + } + else { + setArg(key, value); + } + broken = true; + break; + } + if (next === '-') { + setArg(letters[j], next); + continue; + } + // current letter is an alphabetic character and next value is a number + if (/[A-Za-z]/.test(letters[j]) && + /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next) && + checkAllAliases(next, flags.bools) === false) { + setArg(letters[j], next); + broken = true; + break; + } + if (letters[j + 1] && letters[j + 1].match(/\W/)) { + setArg(letters[j], next); + broken = true; + break; + } + else { + setArg(letters[j], defaultValue(letters[j])); + } + } + key = arg.slice(-1)[0]; + if (!broken && key !== '-') { + if (checkAllAliases(key, flags.arrays)) { + // array format = '-f a b c' + i = eatArray(i, key, args); + } + else if (checkAllAliases(key, flags.nargs) !== false) { + // nargs format = '-f a b c' + // should be truthy even if: flags.nargs[key] === 0 + i = eatNargs(i, key, args); + } + else { + next = args[i + 1]; + if (next !== undefined && (!/^(-|--)[^-]/.test(next) || + next.match(negative)) && + !checkAllAliases(key, flags.bools) && + !checkAllAliases(key, flags.counts)) { + setArg(key, next); + i++; + } + else if (/^(true|false)$/.test(next)) { + setArg(key, next); + i++; + } + else { + setArg(key, defaultValue(key)); + } + } + } + } + else if (arg.match(/^-[0-9]$/) && + arg.match(negative) && + checkAllAliases(arg.slice(1), flags.bools)) { + // single-digit boolean alias, e.g: xargs -0 + key = arg.slice(1); + setArg(key, defaultValue(key)); + } + else if (arg === '--') { + notFlags = args.slice(i + 1); + break; + } + else if (configuration['halt-at-non-option']) { + notFlags = args.slice(i); + break; + } + else { + pushPositional(arg); + } + } + // order of precedence: + // 1. command line arg + // 2. value from env var + // 3. value from config file + // 4. value from config objects + // 5. configured default value + applyEnvVars(argv, true); // special case: check env vars that point to config file + applyEnvVars(argv, false); + setConfig(argv); + setConfigObjects(); + applyDefaultsAndAliases(argv, flags.aliases, defaults, true); + applyCoercions(argv); + if (configuration['set-placeholder-key']) + setPlaceholderKeys(argv); + // for any counts either not in args or without an explicit default, set to 0 + Object.keys(flags.counts).forEach(function (key) { + if (!hasKey(argv, key.split('.'))) + setArg(key, 0); + }); + // '--' defaults to undefined. + if (notFlagsOption && notFlags.length) + argv[notFlagsArgv] = []; + notFlags.forEach(function (key) { + argv[notFlagsArgv].push(key); + }); + if (configuration['camel-case-expansion'] && configuration['strip-dashed']) { + Object.keys(argv).filter(key => key !== '--' && key.includes('-')).forEach(key => { + delete argv[key]; + }); + } + if (configuration['strip-aliased']) { + ; + [].concat(...Object.keys(aliases).map(k => aliases[k])).forEach(alias => { + if (configuration['camel-case-expansion'] && alias.includes('-')) { + delete argv[alias.split('.').map(prop => camelCase(prop)).join('.')]; + } + delete argv[alias]; + }); + } + // Push argument into positional array, applying numeric coercion: + function pushPositional(arg) { + const maybeCoercedNumber = maybeCoerceNumber('_', arg); + if (typeof maybeCoercedNumber === 'string' || typeof maybeCoercedNumber === 'number') { + argv._.push(maybeCoercedNumber); + } + } + // how many arguments should we consume, based + // on the nargs option? + function eatNargs(i, key, args, argAfterEqualSign) { + let ii; + let toEat = checkAllAliases(key, flags.nargs); + // NaN has a special meaning for the array type, indicating that one or + // more values are expected. + toEat = typeof toEat !== 'number' || isNaN(toEat) ? 1 : toEat; + if (toEat === 0) { + if (!isUndefined(argAfterEqualSign)) { + error = Error(__('Argument unexpected for: %s', key)); + } + setArg(key, defaultValue(key)); + return i; + } + let available = isUndefined(argAfterEqualSign) ? 0 : 1; + if (configuration['nargs-eats-options']) { + // classic behavior, yargs eats positional and dash arguments. + if (args.length - (i + 1) + available < toEat) { + error = Error(__('Not enough arguments following: %s', key)); + } + available = toEat; + } + else { + // nargs will not consume flag arguments, e.g., -abc, --foo, + // and terminates when one is observed. + for (ii = i + 1; ii < args.length; ii++) { + if (!args[ii].match(/^-[^0-9]/) || args[ii].match(negative) || isUnknownOptionAsArg(args[ii])) + available++; + else + break; + } + if (available < toEat) + error = Error(__('Not enough arguments following: %s', key)); + } + let consumed = Math.min(available, toEat); + if (!isUndefined(argAfterEqualSign) && consumed > 0) { + setArg(key, argAfterEqualSign); + consumed--; + } + for (ii = i + 1; ii < (consumed + i + 1); ii++) { + setArg(key, args[ii]); + } + return (i + consumed); + } + // if an option is an array, eat all non-hyphenated arguments + // following it... YUM! + // e.g., --foo apple banana cat becomes ["apple", "banana", "cat"] + function eatArray(i, key, args, argAfterEqualSign) { + let argsToSet = []; + let next = argAfterEqualSign || args[i + 1]; + // If both array and nargs are configured, enforce the nargs count: + const nargsCount = checkAllAliases(key, flags.nargs); + if (checkAllAliases(key, flags.bools) && !(/^(true|false)$/.test(next))) { + argsToSet.push(true); + } + else if (isUndefined(next) || + (isUndefined(argAfterEqualSign) && /^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next))) { + // for keys without value ==> argsToSet remains an empty [] + // set user default value, if available + if (defaults[key] !== undefined) { + const defVal = defaults[key]; + argsToSet = Array.isArray(defVal) ? defVal : [defVal]; + } + } + else { + // value in --option=value is eaten as is + if (!isUndefined(argAfterEqualSign)) { + argsToSet.push(processValue(key, argAfterEqualSign, true)); + } + for (let ii = i + 1; ii < args.length; ii++) { + if ((!configuration['greedy-arrays'] && argsToSet.length > 0) || + (nargsCount && typeof nargsCount === 'number' && argsToSet.length >= nargsCount)) + break; + next = args[ii]; + if (/^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next)) + break; + i = ii; + argsToSet.push(processValue(key, next, inputIsString)); + } + } + // If both array and nargs are configured, create an error if less than + // nargs positionals were found. NaN has special meaning, indicating + // that at least one value is required (more are okay). + if (typeof nargsCount === 'number' && ((nargsCount && argsToSet.length < nargsCount) || + (isNaN(nargsCount) && argsToSet.length === 0))) { + error = Error(__('Not enough arguments following: %s', key)); + } + setArg(key, argsToSet); + return i; + } + function setArg(key, val, shouldStripQuotes = inputIsString) { + if (/-/.test(key) && configuration['camel-case-expansion']) { + const alias = key.split('.').map(function (prop) { + return camelCase(prop); + }).join('.'); + addNewAlias(key, alias); + } + const value = processValue(key, val, shouldStripQuotes); + const splitKey = key.split('.'); + setKey(argv, splitKey, value); + // handle populating aliases of the full key + if (flags.aliases[key]) { + flags.aliases[key].forEach(function (x) { + const keyProperties = x.split('.'); + setKey(argv, keyProperties, value); + }); + } + // handle populating aliases of the first element of the dot-notation key + if (splitKey.length > 1 && configuration['dot-notation']) { + ; + (flags.aliases[splitKey[0]] || []).forEach(function (x) { + let keyProperties = x.split('.'); + // expand alias with nested objects in key + const a = [].concat(splitKey); + a.shift(); // nuke the old key. + keyProperties = keyProperties.concat(a); + // populate alias only if is not already an alias of the full key + // (already populated above) + if (!(flags.aliases[key] || []).includes(keyProperties.join('.'))) { + setKey(argv, keyProperties, value); + } + }); + } + // Set normalize getter and setter when key is in 'normalize' but isn't an array + if (checkAllAliases(key, flags.normalize) && !checkAllAliases(key, flags.arrays)) { + const keys = [key].concat(flags.aliases[key] || []); + keys.forEach(function (key) { + Object.defineProperty(argvReturn, key, { + enumerable: true, + get() { + return val; + }, + set(value) { + val = typeof value === 'string' ? mixin.normalize(value) : value; + } + }); + }); + } + } + function addNewAlias(key, alias) { + if (!(flags.aliases[key] && flags.aliases[key].length)) { + flags.aliases[key] = [alias]; + newAliases[alias] = true; + } + if (!(flags.aliases[alias] && flags.aliases[alias].length)) { + addNewAlias(alias, key); + } + } + function processValue(key, val, shouldStripQuotes) { + // strings may be quoted, clean this up as we assign values. + if (shouldStripQuotes) { + val = stripQuotes(val); + } + // handle parsing boolean arguments --foo=true --bar false. + if (checkAllAliases(key, flags.bools) || checkAllAliases(key, flags.counts)) { + if (typeof val === 'string') + val = val === 'true'; + } + let value = Array.isArray(val) + ? val.map(function (v) { return maybeCoerceNumber(key, v); }) + : maybeCoerceNumber(key, val); + // increment a count given as arg (either no value or value parsed as boolean) + if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === 'boolean')) { + value = increment(); + } + // Set normalized value when key is in 'normalize' and in 'arrays' + if (checkAllAliases(key, flags.normalize) && checkAllAliases(key, flags.arrays)) { + if (Array.isArray(val)) + value = val.map((val) => { return mixin.normalize(val); }); + else + value = mixin.normalize(val); + } + return value; + } + function maybeCoerceNumber(key, value) { + if (!configuration['parse-positional-numbers'] && key === '_') + return value; + if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.bools) && !Array.isArray(value)) { + const shouldCoerceNumber = looksLikeNumber(value) && configuration['parse-numbers'] && (Number.isSafeInteger(Math.floor(parseFloat(`${value}`)))); + if (shouldCoerceNumber || (!isUndefined(value) && checkAllAliases(key, flags.numbers))) { + value = Number(value); + } + } + return value; + } + // set args from config.json file, this should be + // applied last so that defaults can be applied. + function setConfig(argv) { + const configLookup = Object.create(null); + // expand defaults/aliases, in-case any happen to reference + // the config.json file. + applyDefaultsAndAliases(configLookup, flags.aliases, defaults); + Object.keys(flags.configs).forEach(function (configKey) { + const configPath = argv[configKey] || configLookup[configKey]; + if (configPath) { + try { + let config = null; + const resolvedConfigPath = mixin.resolve(mixin.cwd(), configPath); + const resolveConfig = flags.configs[configKey]; + if (typeof resolveConfig === 'function') { + try { + config = resolveConfig(resolvedConfigPath); + } + catch (e) { + config = e; + } + if (config instanceof Error) { + error = config; + return; + } + } + else { + config = mixin.require(resolvedConfigPath); + } + setConfigObject(config); + } + catch (ex) { + // Deno will receive a PermissionDenied error if an attempt is + // made to load config without the --allow-read flag: + if (ex.name === 'PermissionDenied') + error = ex; + else if (argv[configKey]) + error = Error(__('Invalid JSON config file: %s', configPath)); + } + } + }); + } + // set args from config object. + // it recursively checks nested objects. + function setConfigObject(config, prev) { + Object.keys(config).forEach(function (key) { + const value = config[key]; + const fullKey = prev ? prev + '.' + key : key; + // if the value is an inner object and we have dot-notation + // enabled, treat inner objects in config the same as + // heavily nested dot notations (foo.bar.apple). + if (typeof value === 'object' && value !== null && !Array.isArray(value) && configuration['dot-notation']) { + // if the value is an object but not an array, check nested object + setConfigObject(value, fullKey); + } + else { + // setting arguments via CLI takes precedence over + // values within the config file. + if (!hasKey(argv, fullKey.split('.')) || (checkAllAliases(fullKey, flags.arrays) && configuration['combine-arrays'])) { + setArg(fullKey, value); + } + } + }); + } + // set all config objects passed in opts + function setConfigObjects() { + if (typeof configObjects !== 'undefined') { + configObjects.forEach(function (configObject) { + setConfigObject(configObject); + }); + } + } + function applyEnvVars(argv, configOnly) { + if (typeof envPrefix === 'undefined') + return; + const prefix = typeof envPrefix === 'string' ? envPrefix : ''; + const env = mixin.env(); + Object.keys(env).forEach(function (envVar) { + if (prefix === '' || envVar.lastIndexOf(prefix, 0) === 0) { + // get array of nested keys and convert them to camel case + const keys = envVar.split('__').map(function (key, i) { + if (i === 0) { + key = key.substring(prefix.length); + } + return camelCase(key); + }); + if (((configOnly && flags.configs[keys.join('.')]) || !configOnly) && !hasKey(argv, keys)) { + setArg(keys.join('.'), env[envVar]); + } + } + }); + } + function applyCoercions(argv) { + let coerce; + const applied = new Set(); + Object.keys(argv).forEach(function (key) { + if (!applied.has(key)) { // If we haven't already coerced this option via one of its aliases + coerce = checkAllAliases(key, flags.coercions); + if (typeof coerce === 'function') { + try { + const value = maybeCoerceNumber(key, coerce(argv[key])); + ([].concat(flags.aliases[key] || [], key)).forEach(ali => { + applied.add(ali); + argv[ali] = value; + }); + } + catch (err) { + error = err; + } + } + } + }); + } + function setPlaceholderKeys(argv) { + flags.keys.forEach((key) => { + // don't set placeholder keys for dot notation options 'foo.bar'. + if (~key.indexOf('.')) + return; + if (typeof argv[key] === 'undefined') + argv[key] = undefined; + }); + return argv; + } + function applyDefaultsAndAliases(obj, aliases, defaults, canLog = false) { + Object.keys(defaults).forEach(function (key) { + if (!hasKey(obj, key.split('.'))) { + setKey(obj, key.split('.'), defaults[key]); + if (canLog) + defaulted[key] = true; + (aliases[key] || []).forEach(function (x) { + if (hasKey(obj, x.split('.'))) + return; + setKey(obj, x.split('.'), defaults[key]); + }); + } + }); + } + function hasKey(obj, keys) { + let o = obj; + if (!configuration['dot-notation']) + keys = [keys.join('.')]; + keys.slice(0, -1).forEach(function (key) { + o = (o[key] || {}); + }); + const key = keys[keys.length - 1]; + if (typeof o !== 'object') + return false; + else + return key in o; + } + function setKey(obj, keys, value) { + let o = obj; + if (!configuration['dot-notation']) + keys = [keys.join('.')]; + keys.slice(0, -1).forEach(function (key) { + // TODO(bcoe): in the next major version of yargs, switch to + // Object.create(null) for dot notation: + key = sanitizeKey(key); + if (typeof o === 'object' && o[key] === undefined) { + o[key] = {}; + } + if (typeof o[key] !== 'object' || Array.isArray(o[key])) { + // ensure that o[key] is an array, and that the last item is an empty object. + if (Array.isArray(o[key])) { + o[key].push({}); + } + else { + o[key] = [o[key], {}]; + } + // we want to update the empty object at the end of the o[key] array, so set o to that object + o = o[key][o[key].length - 1]; + } + else { + o = o[key]; + } + }); + // TODO(bcoe): in the next major version of yargs, switch to + // Object.create(null) for dot notation: + const key = sanitizeKey(keys[keys.length - 1]); + const isTypeArray = checkAllAliases(keys.join('.'), flags.arrays); + const isValueArray = Array.isArray(value); + let duplicate = configuration['duplicate-arguments-array']; + // nargs has higher priority than duplicate + if (!duplicate && checkAllAliases(key, flags.nargs)) { + duplicate = true; + if ((!isUndefined(o[key]) && flags.nargs[key] === 1) || (Array.isArray(o[key]) && o[key].length === flags.nargs[key])) { + o[key] = undefined; + } + } + if (value === increment()) { + o[key] = increment(o[key]); + } + else if (Array.isArray(o[key])) { + if (duplicate && isTypeArray && isValueArray) { + o[key] = configuration['flatten-duplicate-arrays'] ? o[key].concat(value) : (Array.isArray(o[key][0]) ? o[key] : [o[key]]).concat([value]); + } + else if (!duplicate && Boolean(isTypeArray) === Boolean(isValueArray)) { + o[key] = value; + } + else { + o[key] = o[key].concat([value]); + } + } + else if (o[key] === undefined && isTypeArray) { + o[key] = isValueArray ? value : [value]; + } + else if (duplicate && !(o[key] === undefined || + checkAllAliases(key, flags.counts) || + checkAllAliases(key, flags.bools))) { + o[key] = [o[key], value]; + } + else { + o[key] = value; + } + } + // extend the aliases list with inferred aliases. + function extendAliases(...args) { + args.forEach(function (obj) { + Object.keys(obj || {}).forEach(function (key) { + // short-circuit if we've already added a key + // to the aliases array, for example it might + // exist in both 'opts.default' and 'opts.key'. + if (flags.aliases[key]) + return; + flags.aliases[key] = [].concat(aliases[key] || []); + // For "--option-name", also set argv.optionName + flags.aliases[key].concat(key).forEach(function (x) { + if (/-/.test(x) && configuration['camel-case-expansion']) { + const c = camelCase(x); + if (c !== key && flags.aliases[key].indexOf(c) === -1) { + flags.aliases[key].push(c); + newAliases[c] = true; + } + } + }); + // For "--optionName", also set argv['option-name'] + flags.aliases[key].concat(key).forEach(function (x) { + if (x.length > 1 && /[A-Z]/.test(x) && configuration['camel-case-expansion']) { + const c = decamelize(x, '-'); + if (c !== key && flags.aliases[key].indexOf(c) === -1) { + flags.aliases[key].push(c); + newAliases[c] = true; + } + } + }); + flags.aliases[key].forEach(function (x) { + flags.aliases[x] = [key].concat(flags.aliases[key].filter(function (y) { + return x !== y; + })); + }); + }); + }); + } + function checkAllAliases(key, flag) { + const toCheck = [].concat(flags.aliases[key] || [], key); + const keys = Object.keys(flag); + const setAlias = toCheck.find(key => keys.includes(key)); + return setAlias ? flag[setAlias] : false; + } + function hasAnyFlag(key) { + const flagsKeys = Object.keys(flags); + const toCheck = [].concat(flagsKeys.map(k => flags[k])); + return toCheck.some(function (flag) { + return Array.isArray(flag) ? flag.includes(key) : flag[key]; + }); + } + function hasFlagsMatching(arg, ...patterns) { + const toCheck = [].concat(...patterns); + return toCheck.some(function (pattern) { + const match = arg.match(pattern); + return match && hasAnyFlag(match[1]); + }); + } + // based on a simplified version of the short flag group parsing logic + function hasAllShortFlags(arg) { + // if this is a negative number, or doesn't start with a single hyphen, it's not a short flag group + if (arg.match(negative) || !arg.match(/^-[^-]+/)) { + return false; + } + let hasAllFlags = true; + let next; + const letters = arg.slice(1).split(''); + for (let j = 0; j < letters.length; j++) { + next = arg.slice(j + 2); + if (!hasAnyFlag(letters[j])) { + hasAllFlags = false; + break; + } + if ((letters[j + 1] && letters[j + 1] === '=') || + next === '-' || + (/[A-Za-z]/.test(letters[j]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) || + (letters[j + 1] && letters[j + 1].match(/\W/))) { + break; + } + } + return hasAllFlags; + } + function isUnknownOptionAsArg(arg) { + return configuration['unknown-options-as-args'] && isUnknownOption(arg); + } + function isUnknownOption(arg) { + arg = arg.replace(/^-{3,}/, '--'); + // ignore negative numbers + if (arg.match(negative)) { + return false; + } + // if this is a short option group and all of them are configured, it isn't unknown + if (hasAllShortFlags(arg)) { + return false; + } + // e.g. '--count=2' + const flagWithEquals = /^-+([^=]+?)=[\s\S]*$/; + // e.g. '-a' or '--arg' + const normalFlag = /^-+([^=]+?)$/; + // e.g. '-a-' + const flagEndingInHyphen = /^-+([^=]+?)-$/; + // e.g. '-abc123' + const flagEndingInDigits = /^-+([^=]+?\d+)$/; + // e.g. '-a/usr/local' + const flagEndingInNonWordCharacters = /^-+([^=]+?)\W+.*$/; + // check the different types of flag styles, including negatedBoolean, a pattern defined near the start of the parse method + return !hasFlagsMatching(arg, flagWithEquals, negatedBoolean, normalFlag, flagEndingInHyphen, flagEndingInDigits, flagEndingInNonWordCharacters); + } + // make a best effort to pick a default value + // for an option based on name and type. + function defaultValue(key) { + if (!checkAllAliases(key, flags.bools) && + !checkAllAliases(key, flags.counts) && + `${key}` in defaults) { + return defaults[key]; + } + else { + return defaultForType(guessType(key)); + } + } + // return a default value, given the type of a flag., + function defaultForType(type) { + const def = { + [DefaultValuesForTypeKey.BOOLEAN]: true, + [DefaultValuesForTypeKey.STRING]: '', + [DefaultValuesForTypeKey.NUMBER]: undefined, + [DefaultValuesForTypeKey.ARRAY]: [] + }; + return def[type]; + } + // given a flag, enforce a default type. + function guessType(key) { + let type = DefaultValuesForTypeKey.BOOLEAN; + if (checkAllAliases(key, flags.strings)) + type = DefaultValuesForTypeKey.STRING; + else if (checkAllAliases(key, flags.numbers)) + type = DefaultValuesForTypeKey.NUMBER; + else if (checkAllAliases(key, flags.bools)) + type = DefaultValuesForTypeKey.BOOLEAN; + else if (checkAllAliases(key, flags.arrays)) + type = DefaultValuesForTypeKey.ARRAY; + return type; + } + function isUndefined(num) { + return num === undefined; + } + // check user configuration settings for inconsistencies + function checkConfiguration() { + // count keys should not be set as array/narg + Object.keys(flags.counts).find(key => { + if (checkAllAliases(key, flags.arrays)) { + error = Error(__('Invalid configuration: %s, opts.count excludes opts.array.', key)); + return true; + } + else if (checkAllAliases(key, flags.nargs)) { + error = Error(__('Invalid configuration: %s, opts.count excludes opts.narg.', key)); + return true; + } + return false; + }); + } + return { + aliases: Object.assign({}, flags.aliases), + argv: Object.assign(argvReturn, argv), + configuration: configuration, + defaulted: Object.assign({}, defaulted), + error: error, + newAliases: Object.assign({}, newAliases) + }; + } +} +// if any aliases reference each other, we should +// merge them together. +function combineAliases(aliases) { + const aliasArrays = []; + const combined = Object.create(null); + let change = true; + // turn alias lookup hash {key: ['alias1', 'alias2']} into + // a simple array ['key', 'alias1', 'alias2'] + Object.keys(aliases).forEach(function (key) { + aliasArrays.push([].concat(aliases[key], key)); + }); + // combine arrays until zero changes are + // made in an iteration. + while (change) { + change = false; + for (let i = 0; i < aliasArrays.length; i++) { + for (let ii = i + 1; ii < aliasArrays.length; ii++) { + const intersect = aliasArrays[i].filter(function (v) { + return aliasArrays[ii].indexOf(v) !== -1; + }); + if (intersect.length) { + aliasArrays[i] = aliasArrays[i].concat(aliasArrays[ii]); + aliasArrays.splice(ii, 1); + change = true; + break; + } + } + } + } + // map arrays back to the hash-lookup (de-dupe while + // we're at it). + aliasArrays.forEach(function (aliasArray) { + aliasArray = aliasArray.filter(function (v, i, self) { + return self.indexOf(v) === i; + }); + const lastAlias = aliasArray.pop(); + if (lastAlias !== undefined && typeof lastAlias === 'string') { + combined[lastAlias] = aliasArray; + } + }); + return combined; +} +// this function should only be called when a count is given as an arg +// it is NOT called to set a default value +// thus we can start the count at 1 instead of 0 +function increment(orig) { + return orig !== undefined ? orig + 1 : 1; +} +// TODO(bcoe): in the next major version of yargs, switch to +// Object.create(null) for dot notation: +function sanitizeKey(key) { + if (key === '__proto__') + return '___proto___'; + return key; +} +function stripQuotes(val) { + return (typeof val === 'string' && + (val[0] === "'" || val[0] === '"') && + val[val.length - 1] === val[0]) + ? val.substring(1, val.length - 1) + : val; +}