diff --git a/.gitattributes b/.gitattributes index aea798dd7f8e8745b21a740dcb8f0f1d3efe69c7..b6d75981cc94b4c815fce0ba071b77cca134a07f 100644 --- a/.gitattributes +++ b/.gitattributes @@ -168,3 +168,7 @@ python_libs/pypdfium2_raw/__pycache__/bindings.cpython-314.pyc filter=lfs diff=l python_libs/ttkbootstrap/__pycache__/icons.cpython-314.pyc filter=lfs diff=lfs merge=lfs -text python_libs/ttkbootstrap/__pycache__/style.cpython-314.pyc filter=lfs diff=lfs merge=lfs -text python_libs/ttkbootstrap/widgets/__pycache__/tableview.cpython-314.pyc filter=lfs diff=lfs merge=lfs -text +scripts/node_modules/@esbuild/win32-x64/esbuild.exe filter=lfs diff=lfs merge=lfs -text +scripts/node_modules/@rollup/rollup-win32-x64-gnu/rollup.win32-x64-gnu.node filter=lfs diff=lfs merge=lfs -text +scripts/node_modules/@rollup/rollup-win32-x64-msvc/rollup.win32-x64-msvc.node filter=lfs diff=lfs merge=lfs -text +scripts/node_modules/@tauri-apps/cli-win32-x64-msvc/cli.win32-x64-msvc.node filter=lfs diff=lfs merge=lfs -text diff --git a/scripts/node_modules/@babel/types/LICENSE b/scripts/node_modules/@babel/types/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/scripts/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/scripts/node_modules/@babel/types/README.md b/scripts/node_modules/@babel/types/README.md new file mode 100644 index 0000000000000000000000000000000000000000..54c9f81948972286aad02d0fcdb1bd1566ae0f0b --- /dev/null +++ b/scripts/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/scripts/node_modules/@babel/types/lib/definitions/jsx.js.map b/scripts/node_modules/@babel/types/lib/definitions/jsx.js.map new file mode 100644 index 0000000000000000000000000000000000000000..ece92936bcc5828daec2681ba3da913f8c5d550d --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/definitions/jsx.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_utils","require","defineType","defineAliasedType","visitor","aliases","fields","name","validate","assertNodeType","value","optional","builder","Object","assign","openingElement","closingElement","children","validateArrayOfType","selfClosing","assertValueType","expression","object","property","namespace","default","attributes","typeArguments","typeParameters","argument","openingFragment","closingFragment"],"sources":["../../src/definitions/jsx.ts"],"sourcesContent":["import {\n defineAliasedType,\n assertNodeType,\n assertValueType,\n validateArrayOfType,\n} from \"./utils.ts\";\n\nconst defineType = defineAliasedType(\"JSX\");\n\ndefineType(\"JSXAttribute\", {\n visitor: [\"name\", \"value\"],\n aliases: [\"Immutable\"],\n fields: {\n name: {\n validate: assertNodeType(\"JSXIdentifier\", \"JSXNamespacedName\"),\n },\n value: {\n optional: true,\n validate: assertNodeType(\n \"JSXElement\",\n \"JSXFragment\",\n \"StringLiteral\",\n \"JSXExpressionContainer\",\n ),\n },\n },\n});\n\ndefineType(\"JSXClosingElement\", {\n visitor: [\"name\"],\n aliases: [\"Immutable\"],\n fields: {\n name: {\n validate: assertNodeType(\n \"JSXIdentifier\",\n \"JSXMemberExpression\",\n \"JSXNamespacedName\",\n ),\n },\n },\n});\n\ndefineType(\"JSXElement\", {\n builder: process.env.BABEL_8_BREAKING\n ? [\"openingElement\", \"closingElement\", \"children\"]\n : [\"openingElement\", \"closingElement\", \"children\", \"selfClosing\"],\n visitor: [\"openingElement\", \"children\", \"closingElement\"],\n aliases: [\"Immutable\", \"Expression\"],\n fields: {\n openingElement: {\n validate: assertNodeType(\"JSXOpeningElement\"),\n },\n closingElement: {\n optional: true,\n validate: assertNodeType(\"JSXClosingElement\"),\n },\n children: validateArrayOfType(\n \"JSXText\",\n \"JSXExpressionContainer\",\n \"JSXSpreadChild\",\n \"JSXElement\",\n \"JSXFragment\",\n ),\n ...(process.env.BABEL_8_BREAKING\n ? {}\n : {\n selfClosing: {\n validate: assertValueType(\"boolean\"),\n optional: true,\n },\n }),\n },\n});\n\ndefineType(\"JSXEmptyExpression\", {});\n\ndefineType(\"JSXExpressionContainer\", {\n visitor: [\"expression\"],\n aliases: [\"Immutable\"],\n fields: {\n expression: {\n validate: assertNodeType(\"Expression\", \"JSXEmptyExpression\"),\n },\n },\n});\n\ndefineType(\"JSXSpreadChild\", {\n visitor: [\"expression\"],\n aliases: [\"Immutable\"],\n fields: {\n expression: {\n validate: assertNodeType(\"Expression\"),\n },\n },\n});\n\ndefineType(\"JSXIdentifier\", {\n builder: [\"name\"],\n fields: {\n name: {\n validate: assertValueType(\"string\"),\n },\n },\n});\n\ndefineType(\"JSXMemberExpression\", {\n visitor: [\"object\", \"property\"],\n fields: {\n object: {\n validate: assertNodeType(\"JSXMemberExpression\", \"JSXIdentifier\"),\n },\n property: {\n validate: assertNodeType(\"JSXIdentifier\"),\n },\n },\n});\n\ndefineType(\"JSXNamespacedName\", {\n visitor: [\"namespace\", \"name\"],\n fields: {\n namespace: {\n validate: assertNodeType(\"JSXIdentifier\"),\n },\n name: {\n validate: assertNodeType(\"JSXIdentifier\"),\n },\n },\n});\n\ndefineType(\"JSXOpeningElement\", {\n builder: [\"name\", \"attributes\", \"selfClosing\"],\n visitor: process.env.BABEL_8_BREAKING\n ? [\"name\", \"typeArguments\", \"attributes\"]\n : [\"name\", \"typeParameters\", \"typeArguments\", \"attributes\"],\n aliases: [\"Immutable\"],\n fields: {\n name: {\n validate: assertNodeType(\n \"JSXIdentifier\",\n \"JSXMemberExpression\",\n \"JSXNamespacedName\",\n ),\n },\n selfClosing: {\n default: false,\n },\n attributes: validateArrayOfType(\"JSXAttribute\", \"JSXSpreadAttribute\"),\n typeArguments: {\n validate: process.env.BABEL_8_BREAKING\n ? assertNodeType(\n \"TypeParameterInstantiation\",\n \"TSTypeParameterInstantiation\",\n )\n : assertNodeType(\"TypeParameterInstantiation\"),\n optional: true,\n },\n ...(process.env.BABEL_8_BREAKING\n ? {}\n : {\n typeParameters: {\n validate: assertNodeType(\"TSTypeParameterInstantiation\"),\n optional: true,\n },\n }),\n },\n});\n\ndefineType(\"JSXSpreadAttribute\", {\n visitor: [\"argument\"],\n fields: {\n argument: {\n validate: assertNodeType(\"Expression\"),\n },\n },\n});\n\ndefineType(\"JSXText\", {\n aliases: [\"Immutable\"],\n builder: [\"value\"],\n fields: {\n value: {\n validate: assertValueType(\"string\"),\n },\n },\n});\n\ndefineType(\"JSXFragment\", {\n builder: [\"openingFragment\", \"closingFragment\", \"children\"],\n visitor: [\"openingFragment\", \"children\", \"closingFragment\"],\n aliases: [\"Immutable\", \"Expression\"],\n fields: {\n openingFragment: {\n validate: assertNodeType(\"JSXOpeningFragment\"),\n },\n closingFragment: {\n validate: assertNodeType(\"JSXClosingFragment\"),\n },\n children: validateArrayOfType(\n \"JSXText\",\n \"JSXExpressionContainer\",\n \"JSXSpreadChild\",\n \"JSXElement\",\n \"JSXFragment\",\n ),\n },\n});\n\ndefineType(\"JSXOpeningFragment\", {\n aliases: [\"Immutable\"],\n});\n\ndefineType(\"JSXClosingFragment\", {\n aliases: [\"Immutable\"],\n});\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/definitions/misc.js b/scripts/node_modules/@babel/types/lib/definitions/misc.js new file mode 100644 index 0000000000000000000000000000000000000000..f054c618a2f40caae41fcd5af8c37bbcef7007a4 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/definitions/misc.js @@ -0,0 +1,31 @@ +"use strict"; + +var _utils = require("./utils.js"); +var _placeholders = require("./placeholders.js"); +var _core = require("./core.js"); +const defineType = (0, _utils.defineAliasedType)("Miscellaneous"); +defineType("Noop", { + visitor: [] +}); +defineType("Placeholder", { + visitor: [], + builder: ["expectedNode", "name"], + fields: Object.assign({ + name: { + validate: (0, _utils.assertNodeType)("Identifier") + }, + expectedNode: { + validate: (0, _utils.assertOneOf)(..._placeholders.PLACEHOLDERS) + } + }, (0, _core.patternLikeCommon)()) +}); +defineType("V8IntrinsicIdentifier", { + builder: ["name"], + fields: { + name: { + validate: (0, _utils.assertValueType)("string") + } + } +}); + +//# sourceMappingURL=misc.js.map diff --git a/scripts/node_modules/@babel/types/lib/definitions/misc.js.map b/scripts/node_modules/@babel/types/lib/definitions/misc.js.map new file mode 100644 index 0000000000000000000000000000000000000000..a02da9084b62e339b572c19526d5c075f3587efc --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/definitions/misc.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_utils","require","_placeholders","_core","defineType","defineAliasedType","visitor","builder","fields","Object","assign","name","validate","assertNodeType","expectedNode","assertOneOf","PLACEHOLDERS","patternLikeCommon","assertValueType"],"sources":["../../src/definitions/misc.ts"],"sourcesContent":["import {\n defineAliasedType,\n assertNodeType,\n assertOneOf,\n assertValueType,\n} from \"./utils.ts\";\nimport { PLACEHOLDERS } from \"./placeholders.ts\";\nimport { patternLikeCommon } from \"./core.ts\";\n\nconst defineType = defineAliasedType(\"Miscellaneous\");\n\nif (!process.env.BABEL_8_BREAKING) {\n defineType(\"Noop\", {\n visitor: [],\n });\n}\n\ndefineType(\"Placeholder\", {\n visitor: [],\n builder: [\"expectedNode\", \"name\"],\n // aliases: [], defined in placeholders.js\n fields: {\n name: {\n validate: assertNodeType(\"Identifier\"),\n },\n expectedNode: {\n validate: assertOneOf(...PLACEHOLDERS),\n },\n ...patternLikeCommon(),\n },\n});\n\ndefineType(\"V8IntrinsicIdentifier\", {\n builder: [\"name\"],\n fields: {\n name: {\n validate: assertValueType(\"string\"),\n },\n },\n});\n"],"mappings":";;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAMA,IAAAC,aAAA,GAAAD,OAAA;AACA,IAAAE,KAAA,GAAAF,OAAA;AAEA,MAAMG,UAAU,GAAG,IAAAC,wBAAiB,EAAC,eAAe,CAAC;AAGnDD,UAAU,CAAC,MAAM,EAAE;EACjBE,OAAO,EAAE;AACX,CAAC,CAAC;AAGJF,UAAU,CAAC,aAAa,EAAE;EACxBE,OAAO,EAAE,EAAE;EACXC,OAAO,EAAE,CAAC,cAAc,EAAE,MAAM,CAAC;EAEjCC,MAAM,EAAAC,MAAA,CAAAC,MAAA;IACJC,IAAI,EAAE;MACJC,QAAQ,EAAE,IAAAC,qBAAc,EAAC,YAAY;IACvC,CAAC;IACDC,YAAY,EAAE;MACZF,QAAQ,EAAE,IAAAG,kBAAW,EAAC,GAAGC,0BAAY;IACvC;EAAC,GACE,IAAAC,uBAAiB,EAAC,CAAC;AAE1B,CAAC,CAAC;AAEFb,UAAU,CAAC,uBAAuB,EAAE;EAClCG,OAAO,EAAE,CAAC,MAAM,CAAC;EACjBC,MAAM,EAAE;IACNG,IAAI,EAAE;MACJC,QAAQ,EAAE,IAAAM,sBAAe,EAAC,QAAQ;IACpC;EACF;AACF,CAAC,CAAC","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/definitions/placeholders.js b/scripts/node_modules/@babel/types/lib/definitions/placeholders.js new file mode 100644 index 0000000000000000000000000000000000000000..c4a4f552b9c8c5d862ef5fad054eaa4ccdd5bf40 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/definitions/placeholders.js @@ -0,0 +1,27 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.PLACEHOLDERS_FLIPPED_ALIAS = exports.PLACEHOLDERS_ALIAS = exports.PLACEHOLDERS = void 0; +var _utils = require("./utils.js"); +const PLACEHOLDERS = exports.PLACEHOLDERS = ["Identifier", "StringLiteral", "Expression", "Statement", "Declaration", "BlockStatement", "ClassBody", "Pattern"]; +const PLACEHOLDERS_ALIAS = exports.PLACEHOLDERS_ALIAS = { + Declaration: ["Statement"], + Pattern: ["PatternLike", "LVal"] +}; +for (const type of PLACEHOLDERS) { + const alias = _utils.ALIAS_KEYS[type]; + if (alias != null && alias.length) PLACEHOLDERS_ALIAS[type] = alias; +} +const PLACEHOLDERS_FLIPPED_ALIAS = exports.PLACEHOLDERS_FLIPPED_ALIAS = {}; +Object.keys(PLACEHOLDERS_ALIAS).forEach(type => { + PLACEHOLDERS_ALIAS[type].forEach(alias => { + if (!hasOwnProperty.call(PLACEHOLDERS_FLIPPED_ALIAS, alias)) { + PLACEHOLDERS_FLIPPED_ALIAS[alias] = []; + } + PLACEHOLDERS_FLIPPED_ALIAS[alias].push(type); + }); +}); + +//# sourceMappingURL=placeholders.js.map diff --git a/scripts/node_modules/@babel/types/lib/definitions/placeholders.js.map b/scripts/node_modules/@babel/types/lib/definitions/placeholders.js.map new file mode 100644 index 0000000000000000000000000000000000000000..f18218f8f20088d677ac1617336d3753ce1cbec8 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/definitions/placeholders.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_utils","require","PLACEHOLDERS","exports","PLACEHOLDERS_ALIAS","Declaration","Pattern","type","alias","ALIAS_KEYS","length","PLACEHOLDERS_FLIPPED_ALIAS","Object","keys","forEach","hasOwnProperty","call","push"],"sources":["../../src/definitions/placeholders.ts"],"sourcesContent":["import { ALIAS_KEYS } from \"./utils.ts\";\n\nexport const PLACEHOLDERS = [\n \"Identifier\",\n \"StringLiteral\",\n \"Expression\",\n \"Statement\",\n \"Declaration\",\n \"BlockStatement\",\n \"ClassBody\",\n \"Pattern\",\n] as const;\n\nexport const PLACEHOLDERS_ALIAS: Record = {\n Declaration: [\"Statement\"],\n Pattern: [\"PatternLike\", \"LVal\"],\n};\n\nfor (const type of PLACEHOLDERS) {\n const alias = ALIAS_KEYS[type];\n if (alias?.length) PLACEHOLDERS_ALIAS[type] = alias;\n}\n\nexport const PLACEHOLDERS_FLIPPED_ALIAS: Record = {};\n\nObject.keys(PLACEHOLDERS_ALIAS).forEach(type => {\n PLACEHOLDERS_ALIAS[type].forEach(alias => {\n if (!Object.hasOwn(PLACEHOLDERS_FLIPPED_ALIAS, alias)) {\n PLACEHOLDERS_FLIPPED_ALIAS[alias] = [];\n }\n PLACEHOLDERS_FLIPPED_ALIAS[alias].push(type);\n });\n});\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEO,MAAMC,YAAY,GAAAC,OAAA,CAAAD,YAAA,GAAG,CAC1B,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,WAAW,EACX,SAAS,CACD;AAEH,MAAME,kBAA4C,GAAAD,OAAA,CAAAC,kBAAA,GAAG;EAC1DC,WAAW,EAAE,CAAC,WAAW,CAAC;EAC1BC,OAAO,EAAE,CAAC,aAAa,EAAE,MAAM;AACjC,CAAC;AAED,KAAK,MAAMC,IAAI,IAAIL,YAAY,EAAE;EAC/B,MAAMM,KAAK,GAAGC,iBAAU,CAACF,IAAI,CAAC;EAC9B,IAAIC,KAAK,YAALA,KAAK,CAAEE,MAAM,EAAEN,kBAAkB,CAACG,IAAI,CAAC,GAAGC,KAAK;AACrD;AAEO,MAAMG,0BAAoD,GAAAR,OAAA,CAAAQ,0BAAA,GAAG,CAAC,CAAC;AAEtEC,MAAM,CAACC,IAAI,CAACT,kBAAkB,CAAC,CAACU,OAAO,CAACP,IAAI,IAAI;EAC9CH,kBAAkB,CAACG,IAAI,CAAC,CAACO,OAAO,CAACN,KAAK,IAAI;IACxC,IAAI,CAACO,cAAA,CAAAC,IAAA,CAAcL,0BAA0B,EAAEH,KAAK,CAAC,EAAE;MACrDG,0BAA0B,CAACH,KAAK,CAAC,GAAG,EAAE;IACxC;IACAG,0BAA0B,CAACH,KAAK,CAAC,CAACS,IAAI,CAACV,IAAI,CAAC;EAC9C,CAAC,CAAC;AACJ,CAAC,CAAC","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/definitions/typescript.js b/scripts/node_modules/@babel/types/lib/definitions/typescript.js new file mode 100644 index 0000000000000000000000000000000000000000..0e5da3fc02bc0beb66fc4957bd1bd412e0db16f7 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/definitions/typescript.js @@ -0,0 +1,528 @@ +"use strict"; + +var _utils = require("./utils.js"); +var _core = require("./core.js"); +var _is = require("../validators/is.js"); +const defineType = (0, _utils.defineAliasedType)("TypeScript"); +const bool = (0, _utils.assertValueType)("boolean"); +const tSFunctionTypeAnnotationCommon = () => ({ + returnType: { + validate: (0, _utils.assertNodeType)("TSTypeAnnotation", "Noop"), + optional: true + }, + typeParameters: { + validate: (0, _utils.assertNodeType)("TSTypeParameterDeclaration", "Noop"), + optional: true + } +}); +defineType("TSParameterProperty", { + aliases: ["LVal"], + visitor: ["parameter"], + fields: { + accessibility: { + validate: (0, _utils.assertOneOf)("public", "private", "protected"), + optional: true + }, + readonly: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + parameter: { + validate: (0, _utils.assertNodeType)("Identifier", "AssignmentPattern") + }, + override: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + decorators: { + validate: (0, _utils.arrayOfType)("Decorator"), + optional: true + } + } +}); +defineType("TSDeclareFunction", { + aliases: ["Statement", "Declaration"], + visitor: ["id", "typeParameters", "params", "returnType"], + fields: Object.assign({}, (0, _core.functionDeclarationCommon)(), tSFunctionTypeAnnotationCommon()) +}); +defineType("TSDeclareMethod", Object.assign({ + visitor: ["decorators", "key", "typeParameters", "params", "returnType"] +}, (0, _core.classMethodOrPropertyUnionShapeCommon)(), { + fields: Object.assign({}, (0, _core.classMethodOrDeclareMethodCommon)(), tSFunctionTypeAnnotationCommon()) +})); +defineType("TSQualifiedName", { + aliases: ["TSEntityName"], + visitor: ["left", "right"], + fields: { + left: (0, _utils.validateType)("TSEntityName"), + right: (0, _utils.validateType)("Identifier") + } +}); +const signatureDeclarationCommon = () => ({ + typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"), + ["parameters"]: (0, _utils.validateArrayOfType)("ArrayPattern", "Identifier", "ObjectPattern", "RestElement"), + ["typeAnnotation"]: (0, _utils.validateOptionalType)("TSTypeAnnotation") +}); +const callConstructSignatureDeclaration = { + aliases: ["TSTypeElement"], + visitor: ["typeParameters", "parameters", "typeAnnotation"], + fields: signatureDeclarationCommon() +}; +defineType("TSCallSignatureDeclaration", callConstructSignatureDeclaration); +defineType("TSConstructSignatureDeclaration", callConstructSignatureDeclaration); +const namedTypeElementCommon = () => ({ + key: (0, _utils.validateType)("Expression"), + computed: { + default: false + }, + optional: (0, _utils.validateOptional)(bool) +}); +defineType("TSPropertySignature", { + aliases: ["TSTypeElement"], + visitor: ["key", "typeAnnotation"], + fields: Object.assign({}, namedTypeElementCommon(), { + readonly: (0, _utils.validateOptional)(bool), + typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"), + kind: { + optional: true, + validate: (0, _utils.assertOneOf)("get", "set") + } + }) +}); +defineType("TSMethodSignature", { + aliases: ["TSTypeElement"], + visitor: ["key", "typeParameters", "parameters", "typeAnnotation"], + fields: Object.assign({}, signatureDeclarationCommon(), namedTypeElementCommon(), { + kind: { + validate: (0, _utils.assertOneOf)("method", "get", "set") + } + }) +}); +defineType("TSIndexSignature", { + aliases: ["TSTypeElement"], + visitor: ["parameters", "typeAnnotation"], + fields: { + readonly: (0, _utils.validateOptional)(bool), + static: (0, _utils.validateOptional)(bool), + parameters: (0, _utils.validateArrayOfType)("Identifier"), + typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation") + } +}); +const tsKeywordTypes = ["TSAnyKeyword", "TSBooleanKeyword", "TSBigIntKeyword", "TSIntrinsicKeyword", "TSNeverKeyword", "TSNullKeyword", "TSNumberKeyword", "TSObjectKeyword", "TSStringKeyword", "TSSymbolKeyword", "TSUndefinedKeyword", "TSUnknownKeyword", "TSVoidKeyword"]; +for (const type of tsKeywordTypes) { + defineType(type, { + aliases: ["TSType", "TSBaseType"], + visitor: [], + fields: {} + }); +} +defineType("TSThisType", { + aliases: ["TSType", "TSBaseType"], + visitor: [], + fields: {} +}); +const fnOrCtrBase = { + aliases: ["TSType"], + visitor: ["typeParameters", "parameters", "typeAnnotation"] +}; +defineType("TSFunctionType", Object.assign({}, fnOrCtrBase, { + fields: signatureDeclarationCommon() +})); +defineType("TSConstructorType", Object.assign({}, fnOrCtrBase, { + fields: Object.assign({}, signatureDeclarationCommon(), { + abstract: (0, _utils.validateOptional)(bool) + }) +})); +defineType("TSTypeReference", { + aliases: ["TSType"], + visitor: ["typeName", "typeParameters"], + fields: { + typeName: (0, _utils.validateType)("TSEntityName"), + ["typeParameters"]: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") + } +}); +defineType("TSTypePredicate", { + aliases: ["TSType"], + visitor: ["parameterName", "typeAnnotation"], + builder: ["parameterName", "typeAnnotation", "asserts"], + fields: { + parameterName: (0, _utils.validateType)("Identifier", "TSThisType"), + typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"), + asserts: (0, _utils.validateOptional)(bool) + } +}); +defineType("TSTypeQuery", { + aliases: ["TSType"], + visitor: ["exprName", "typeParameters"], + fields: { + exprName: (0, _utils.validateType)("TSEntityName", "TSImportType"), + ["typeParameters"]: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") + } +}); +defineType("TSTypeLiteral", { + aliases: ["TSType"], + visitor: ["members"], + fields: { + members: (0, _utils.validateArrayOfType)("TSTypeElement") + } +}); +defineType("TSArrayType", { + aliases: ["TSType"], + visitor: ["elementType"], + fields: { + elementType: (0, _utils.validateType)("TSType") + } +}); +defineType("TSTupleType", { + aliases: ["TSType"], + visitor: ["elementTypes"], + fields: { + elementTypes: (0, _utils.validateArrayOfType)("TSType", "TSNamedTupleMember") + } +}); +defineType("TSOptionalType", { + aliases: ["TSType"], + visitor: ["typeAnnotation"], + fields: { + typeAnnotation: (0, _utils.validateType)("TSType") + } +}); +defineType("TSRestType", { + aliases: ["TSType"], + visitor: ["typeAnnotation"], + fields: { + typeAnnotation: (0, _utils.validateType)("TSType") + } +}); +defineType("TSNamedTupleMember", { + visitor: ["label", "elementType"], + builder: ["label", "elementType", "optional"], + fields: { + label: (0, _utils.validateType)("Identifier"), + optional: { + validate: bool, + default: false + }, + elementType: (0, _utils.validateType)("TSType") + } +}); +const unionOrIntersection = { + aliases: ["TSType"], + visitor: ["types"], + fields: { + types: (0, _utils.validateArrayOfType)("TSType") + } +}; +defineType("TSUnionType", unionOrIntersection); +defineType("TSIntersectionType", unionOrIntersection); +defineType("TSConditionalType", { + aliases: ["TSType"], + visitor: ["checkType", "extendsType", "trueType", "falseType"], + fields: { + checkType: (0, _utils.validateType)("TSType"), + extendsType: (0, _utils.validateType)("TSType"), + trueType: (0, _utils.validateType)("TSType"), + falseType: (0, _utils.validateType)("TSType") + } +}); +defineType("TSInferType", { + aliases: ["TSType"], + visitor: ["typeParameter"], + fields: { + typeParameter: (0, _utils.validateType)("TSTypeParameter") + } +}); +defineType("TSParenthesizedType", { + aliases: ["TSType"], + visitor: ["typeAnnotation"], + fields: { + typeAnnotation: (0, _utils.validateType)("TSType") + } +}); +defineType("TSTypeOperator", { + aliases: ["TSType"], + visitor: ["typeAnnotation"], + builder: ["typeAnnotation", "operator"], + fields: { + operator: { + validate: (0, _utils.assertValueType)("string"), + default: "keyof" + }, + typeAnnotation: (0, _utils.validateType)("TSType") + } +}); +defineType("TSIndexedAccessType", { + aliases: ["TSType"], + visitor: ["objectType", "indexType"], + fields: { + objectType: (0, _utils.validateType)("TSType"), + indexType: (0, _utils.validateType)("TSType") + } +}); +defineType("TSMappedType", { + aliases: ["TSType"], + visitor: ["typeParameter", "nameType", "typeAnnotation"], + builder: ["typeParameter", "typeAnnotation", "nameType"], + fields: Object.assign({}, { + typeParameter: (0, _utils.validateType)("TSTypeParameter") + }, { + readonly: (0, _utils.validateOptional)((0, _utils.assertOneOf)(true, false, "+", "-")), + optional: (0, _utils.validateOptional)((0, _utils.assertOneOf)(true, false, "+", "-")), + typeAnnotation: (0, _utils.validateOptionalType)("TSType"), + nameType: (0, _utils.validateOptionalType)("TSType") + }) +}); +defineType("TSTemplateLiteralType", { + aliases: ["TSType", "TSBaseType"], + visitor: ["quasis", "types"], + fields: { + quasis: (0, _utils.validateArrayOfType)("TemplateElement"), + types: { + validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSType")), function (node, key, val) { + if (node.quasis.length !== val.length + 1) { + throw new TypeError(`Number of ${node.type} quasis should be exactly one more than the number of types.\nExpected ${val.length + 1} quasis but got ${node.quasis.length}`); + } + }) + } + } +}); +defineType("TSLiteralType", { + aliases: ["TSType", "TSBaseType"], + visitor: ["literal"], + fields: { + literal: { + validate: function () { + const unaryExpression = (0, _utils.assertNodeType)("NumericLiteral", "BigIntLiteral"); + const unaryOperator = (0, _utils.assertOneOf)("-"); + const literal = (0, _utils.assertNodeType)("NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral"); + const validator = function validator(parent, key, node) { + if ((0, _is.default)("UnaryExpression", node)) { + unaryOperator(node, "operator", node.operator); + unaryExpression(node, "argument", node.argument); + } else { + literal(parent, key, node); + } + }; + validator.oneOfNodeTypes = ["NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral", "UnaryExpression"]; + return validator; + }() + } + } +}); +defineType("TSExpressionWithTypeArguments", { + aliases: ["TSType"], + visitor: ["expression", "typeParameters"], + fields: { + expression: (0, _utils.validateType)("TSEntityName"), + typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") + } +}); +defineType("TSInterfaceDeclaration", { + aliases: ["Statement", "Declaration"], + visitor: ["id", "typeParameters", "extends", "body"], + fields: { + declare: (0, _utils.validateOptional)(bool), + id: (0, _utils.validateType)("Identifier"), + typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"), + extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("TSExpressionWithTypeArguments")), + body: (0, _utils.validateType)("TSInterfaceBody") + } +}); +defineType("TSInterfaceBody", { + visitor: ["body"], + fields: { + body: (0, _utils.validateArrayOfType)("TSTypeElement") + } +}); +defineType("TSTypeAliasDeclaration", { + aliases: ["Statement", "Declaration"], + visitor: ["id", "typeParameters", "typeAnnotation"], + fields: { + declare: (0, _utils.validateOptional)(bool), + id: (0, _utils.validateType)("Identifier"), + typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"), + typeAnnotation: (0, _utils.validateType)("TSType") + } +}); +defineType("TSInstantiationExpression", { + aliases: ["Expression"], + visitor: ["expression", "typeParameters"], + fields: { + expression: (0, _utils.validateType)("Expression"), + ["typeParameters"]: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") + } +}); +const TSTypeExpression = { + aliases: ["Expression", "LVal", "PatternLike"], + visitor: ["expression", "typeAnnotation"], + fields: { + expression: (0, _utils.validateType)("Expression"), + typeAnnotation: (0, _utils.validateType)("TSType") + } +}; +defineType("TSAsExpression", TSTypeExpression); +defineType("TSSatisfiesExpression", TSTypeExpression); +defineType("TSTypeAssertion", { + aliases: ["Expression", "LVal", "PatternLike"], + visitor: ["typeAnnotation", "expression"], + fields: { + typeAnnotation: (0, _utils.validateType)("TSType"), + expression: (0, _utils.validateType)("Expression") + } +}); +defineType("TSEnumBody", { + visitor: ["members"], + fields: { + members: (0, _utils.validateArrayOfType)("TSEnumMember") + } +}); +defineType("TSEnumDeclaration", { + aliases: ["Statement", "Declaration"], + visitor: ["id", "members"], + fields: { + declare: (0, _utils.validateOptional)(bool), + const: (0, _utils.validateOptional)(bool), + id: (0, _utils.validateType)("Identifier"), + members: (0, _utils.validateArrayOfType)("TSEnumMember"), + initializer: (0, _utils.validateOptionalType)("Expression"), + body: (0, _utils.validateOptionalType)("TSEnumBody") + } +}); +defineType("TSEnumMember", { + visitor: ["id", "initializer"], + fields: { + id: (0, _utils.validateType)("Identifier", "StringLiteral"), + initializer: (0, _utils.validateOptionalType)("Expression") + } +}); +defineType("TSModuleDeclaration", { + aliases: ["Statement", "Declaration"], + visitor: ["id", "body"], + fields: Object.assign({ + kind: { + validate: (0, _utils.assertOneOf)("global", "module", "namespace") + }, + declare: (0, _utils.validateOptional)(bool) + }, { + global: (0, _utils.validateOptional)(bool) + }, { + id: (0, _utils.validateType)("Identifier", "StringLiteral"), + body: (0, _utils.validateType)("TSModuleBlock", "TSModuleDeclaration") + }) +}); +defineType("TSModuleBlock", { + aliases: ["Scopable", "Block", "BlockParent", "FunctionParent"], + visitor: ["body"], + fields: { + body: (0, _utils.validateArrayOfType)("Statement") + } +}); +defineType("TSImportType", { + aliases: ["TSType"], + builder: ["argument", "qualifier", "typeParameters"], + visitor: ["argument", "options", "qualifier", "typeParameters"], + fields: Object.assign({}, { + argument: (0, _utils.validateType)("StringLiteral") + }, { + qualifier: (0, _utils.validateOptionalType)("TSEntityName") + }, { + typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") + }, { + options: { + validate: (0, _utils.assertNodeType)("ObjectExpression"), + optional: true + } + }) +}); +defineType("TSImportEqualsDeclaration", { + aliases: ["Statement", "Declaration"], + visitor: ["id", "moduleReference"], + fields: Object.assign({}, { + isExport: (0, _utils.validate)(bool) + }, { + id: (0, _utils.validateType)("Identifier"), + moduleReference: (0, _utils.validateType)("TSEntityName", "TSExternalModuleReference"), + importKind: { + validate: (0, _utils.assertOneOf)("type", "value"), + optional: true + } + }) +}); +defineType("TSExternalModuleReference", { + visitor: ["expression"], + fields: { + expression: (0, _utils.validateType)("StringLiteral") + } +}); +defineType("TSNonNullExpression", { + aliases: ["Expression", "LVal", "PatternLike"], + visitor: ["expression"], + fields: { + expression: (0, _utils.validateType)("Expression") + } +}); +defineType("TSExportAssignment", { + aliases: ["Statement"], + visitor: ["expression"], + fields: { + expression: (0, _utils.validateType)("Expression") + } +}); +defineType("TSNamespaceExportDeclaration", { + aliases: ["Statement"], + visitor: ["id"], + fields: { + id: (0, _utils.validateType)("Identifier") + } +}); +defineType("TSTypeAnnotation", { + visitor: ["typeAnnotation"], + fields: { + typeAnnotation: { + validate: (0, _utils.assertNodeType)("TSType") + } + } +}); +defineType("TSTypeParameterInstantiation", { + visitor: ["params"], + fields: { + params: (0, _utils.validateArrayOfType)("TSType") + } +}); +defineType("TSTypeParameterDeclaration", { + visitor: ["params"], + fields: { + params: (0, _utils.validateArrayOfType)("TSTypeParameter") + } +}); +defineType("TSTypeParameter", { + builder: ["constraint", "default", "name"], + visitor: ["constraint", "default"], + fields: { + name: { + validate: (0, _utils.assertValueType)("string") + }, + in: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + out: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + const: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + constraint: { + validate: (0, _utils.assertNodeType)("TSType"), + optional: true + }, + default: { + validate: (0, _utils.assertNodeType)("TSType"), + optional: true + } + } +}); + +//# sourceMappingURL=typescript.js.map diff --git a/scripts/node_modules/@babel/types/lib/definitions/typescript.js.map b/scripts/node_modules/@babel/types/lib/definitions/typescript.js.map new file mode 100644 index 0000000000000000000000000000000000000000..6ec163b3bb330896973a8674b2cd05df8a4d2e8f --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/definitions/typescript.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_utils","require","_core","_is","defineType","defineAliasedType","bool","assertValueType","tSFunctionTypeAnnotationCommon","returnType","validate","assertNodeType","optional","typeParameters","aliases","visitor","fields","accessibility","assertOneOf","readonly","parameter","override","decorators","arrayOfType","Object","assign","functionDeclarationCommon","classMethodOrPropertyUnionShapeCommon","classMethodOrDeclareMethodCommon","left","validateType","right","signatureDeclarationCommon","validateOptionalType","validateArrayOfType","callConstructSignatureDeclaration","namedTypeElementCommon","key","computed","default","validateOptional","typeAnnotation","kind","static","parameters","tsKeywordTypes","type","fnOrCtrBase","abstract","typeName","builder","parameterName","asserts","exprName","members","elementType","elementTypes","label","unionOrIntersection","types","checkType","extendsType","trueType","falseType","typeParameter","operator","objectType","indexType","nameType","quasis","chain","assertEach","node","val","length","TypeError","literal","unaryExpression","unaryOperator","validator","parent","is","argument","oneOfNodeTypes","expression","declare","id","extends","body","TSTypeExpression","const","initializer","global","qualifier","options","isExport","moduleReference","importKind","params","name","in","out","constraint"],"sources":["../../src/definitions/typescript.ts"],"sourcesContent":["import type * as t from \"../index.ts\";\nimport {\n defineAliasedType,\n arrayOfType,\n assertEach,\n assertNodeType,\n assertOneOf,\n assertValueType,\n chain,\n validate,\n validateArrayOfType,\n validateOptional,\n validateOptionalType,\n validateType,\n type ValidatorImpl,\n type ValidatorOneOfNodeTypes,\n} from \"./utils.ts\";\nimport {\n functionDeclarationCommon,\n classMethodOrDeclareMethodCommon,\n classMethodOrPropertyUnionShapeCommon,\n} from \"./core.ts\";\nimport is from \"../validators/is.ts\";\n\nconst defineType = defineAliasedType(\"TypeScript\");\n\nconst bool = assertValueType(\"boolean\");\n\nconst tSFunctionTypeAnnotationCommon = () => ({\n returnType: {\n validate: process.env.BABEL_8_BREAKING\n ? assertNodeType(\"TSTypeAnnotation\")\n : // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST\n assertNodeType(\"TSTypeAnnotation\", \"Noop\"),\n optional: true,\n },\n typeParameters: {\n validate: process.env.BABEL_8_BREAKING\n ? assertNodeType(\"TSTypeParameterDeclaration\")\n : // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST\n assertNodeType(\"TSTypeParameterDeclaration\", \"Noop\"),\n optional: true,\n },\n});\n\ndefineType(\"TSParameterProperty\", {\n aliases: process.env.BABEL_8_BREAKING ? [] : [\"LVal\"],\n visitor: [\"parameter\"],\n fields: {\n accessibility: {\n validate: assertOneOf(\"public\", \"private\", \"protected\"),\n optional: true,\n },\n readonly: {\n validate: assertValueType(\"boolean\"),\n optional: true,\n },\n parameter: {\n validate: assertNodeType(\"Identifier\", \"AssignmentPattern\"),\n },\n override: {\n validate: assertValueType(\"boolean\"),\n optional: true,\n },\n decorators: {\n validate: arrayOfType(\"Decorator\"),\n optional: true,\n },\n },\n});\n\ndefineType(\"TSDeclareFunction\", {\n aliases: [\"Statement\", \"Declaration\"],\n visitor: [\"id\", \"typeParameters\", \"params\", \"returnType\"],\n fields: {\n ...functionDeclarationCommon(),\n ...tSFunctionTypeAnnotationCommon(),\n },\n});\n\ndefineType(\"TSDeclareMethod\", {\n visitor: [\"decorators\", \"key\", \"typeParameters\", \"params\", \"returnType\"],\n ...classMethodOrPropertyUnionShapeCommon(),\n fields: {\n ...classMethodOrDeclareMethodCommon(),\n ...tSFunctionTypeAnnotationCommon(),\n },\n});\n\ndefineType(\"TSQualifiedName\", {\n aliases: [\"TSEntityName\"],\n visitor: [\"left\", \"right\"],\n fields: {\n left: validateType(\"TSEntityName\"),\n right: validateType(\"Identifier\"),\n },\n});\n\nconst signatureDeclarationCommon = () => ({\n typeParameters: validateOptionalType(\"TSTypeParameterDeclaration\"),\n [process.env.BABEL_8_BREAKING ? \"params\" : \"parameters\"]: validateArrayOfType(\n \"ArrayPattern\",\n \"Identifier\",\n \"ObjectPattern\",\n \"RestElement\",\n ),\n [process.env.BABEL_8_BREAKING ? \"returnType\" : \"typeAnnotation\"]:\n validateOptionalType(\"TSTypeAnnotation\"),\n});\n\nconst callConstructSignatureDeclaration = {\n aliases: [\"TSTypeElement\"],\n visitor: [\n \"typeParameters\",\n process.env.BABEL_8_BREAKING ? \"params\" : \"parameters\",\n process.env.BABEL_8_BREAKING ? \"returnType\" : \"typeAnnotation\",\n ],\n fields: signatureDeclarationCommon(),\n};\n\ndefineType(\"TSCallSignatureDeclaration\", callConstructSignatureDeclaration);\ndefineType(\n \"TSConstructSignatureDeclaration\",\n callConstructSignatureDeclaration,\n);\n\nconst namedTypeElementCommon = () => ({\n key: validateType(\"Expression\"),\n computed: { default: false },\n optional: validateOptional(bool),\n});\n\ndefineType(\"TSPropertySignature\", {\n aliases: [\"TSTypeElement\"],\n visitor: [\"key\", \"typeAnnotation\"],\n fields: {\n ...namedTypeElementCommon(),\n readonly: validateOptional(bool),\n typeAnnotation: validateOptionalType(\"TSTypeAnnotation\"),\n kind: {\n optional: true,\n validate: assertOneOf(\"get\", \"set\"),\n },\n },\n});\n\ndefineType(\"TSMethodSignature\", {\n aliases: [\"TSTypeElement\"],\n visitor: [\n \"key\",\n \"typeParameters\",\n process.env.BABEL_8_BREAKING ? \"params\" : \"parameters\",\n process.env.BABEL_8_BREAKING ? \"returnType\" : \"typeAnnotation\",\n ],\n fields: {\n ...signatureDeclarationCommon(),\n ...namedTypeElementCommon(),\n kind: {\n validate: assertOneOf(\"method\", \"get\", \"set\"),\n },\n },\n});\n\ndefineType(\"TSIndexSignature\", {\n aliases: [\"TSTypeElement\"],\n visitor: [\"parameters\", \"typeAnnotation\"],\n fields: {\n readonly: validateOptional(bool),\n static: validateOptional(bool),\n parameters: validateArrayOfType(\"Identifier\"), // Length must be 1\n typeAnnotation: validateOptionalType(\"TSTypeAnnotation\"),\n },\n});\n\nconst tsKeywordTypes = [\n \"TSAnyKeyword\",\n \"TSBooleanKeyword\",\n \"TSBigIntKeyword\",\n \"TSIntrinsicKeyword\",\n \"TSNeverKeyword\",\n \"TSNullKeyword\",\n \"TSNumberKeyword\",\n \"TSObjectKeyword\",\n \"TSStringKeyword\",\n \"TSSymbolKeyword\",\n \"TSUndefinedKeyword\",\n \"TSUnknownKeyword\",\n \"TSVoidKeyword\",\n] as const;\n\nfor (const type of tsKeywordTypes) {\n defineType(type, {\n aliases: [\"TSType\", \"TSBaseType\"],\n visitor: [],\n fields: {},\n });\n}\n\ndefineType(\"TSThisType\", {\n aliases: [\"TSType\", \"TSBaseType\"],\n visitor: [],\n fields: {},\n});\n\nconst fnOrCtrBase = {\n aliases: [\"TSType\"],\n visitor: [\n \"typeParameters\",\n process.env.BABEL_8_BREAKING ? \"params\" : \"parameters\",\n process.env.BABEL_8_BREAKING ? \"returnType\" : \"typeAnnotation\",\n ],\n};\n\ndefineType(\"TSFunctionType\", {\n ...fnOrCtrBase,\n fields: signatureDeclarationCommon(),\n});\ndefineType(\"TSConstructorType\", {\n ...fnOrCtrBase,\n fields: {\n ...signatureDeclarationCommon(),\n abstract: validateOptional(bool),\n },\n});\n\ndefineType(\"TSTypeReference\", {\n aliases: [\"TSType\"],\n visitor: [\n \"typeName\",\n process.env.BABEL_8_BREAKING ? \"typeArguments\" : \"typeParameters\",\n ],\n fields: {\n typeName: validateType(\"TSEntityName\"),\n [process.env.BABEL_8_BREAKING ? \"typeArguments\" : \"typeParameters\"]:\n validateOptionalType(\"TSTypeParameterInstantiation\"),\n },\n});\n\ndefineType(\"TSTypePredicate\", {\n aliases: [\"TSType\"],\n visitor: [\"parameterName\", \"typeAnnotation\"],\n builder: [\"parameterName\", \"typeAnnotation\", \"asserts\"],\n fields: {\n parameterName: validateType(\"Identifier\", \"TSThisType\"),\n typeAnnotation: validateOptionalType(\"TSTypeAnnotation\"),\n asserts: validateOptional(bool),\n },\n});\n\ndefineType(\"TSTypeQuery\", {\n aliases: [\"TSType\"],\n visitor: [\n \"exprName\",\n process.env.BABEL_8_BREAKING ? \"typeArguments\" : \"typeParameters\",\n ],\n fields: {\n exprName: validateType(\"TSEntityName\", \"TSImportType\"),\n [process.env.BABEL_8_BREAKING ? \"typeArguments\" : \"typeParameters\"]:\n validateOptionalType(\"TSTypeParameterInstantiation\"),\n },\n});\n\ndefineType(\"TSTypeLiteral\", {\n aliases: [\"TSType\"],\n visitor: [\"members\"],\n fields: {\n members: validateArrayOfType(\"TSTypeElement\"),\n },\n});\n\ndefineType(\"TSArrayType\", {\n aliases: [\"TSType\"],\n visitor: [\"elementType\"],\n fields: {\n elementType: validateType(\"TSType\"),\n },\n});\n\ndefineType(\"TSTupleType\", {\n aliases: [\"TSType\"],\n visitor: [\"elementTypes\"],\n fields: {\n elementTypes: validateArrayOfType(\"TSType\", \"TSNamedTupleMember\"),\n },\n});\n\ndefineType(\"TSOptionalType\", {\n aliases: [\"TSType\"],\n visitor: [\"typeAnnotation\"],\n fields: {\n typeAnnotation: validateType(\"TSType\"),\n },\n});\n\ndefineType(\"TSRestType\", {\n aliases: [\"TSType\"],\n visitor: [\"typeAnnotation\"],\n fields: {\n typeAnnotation: validateType(\"TSType\"),\n },\n});\n\ndefineType(\"TSNamedTupleMember\", {\n visitor: [\"label\", \"elementType\"],\n builder: [\"label\", \"elementType\", \"optional\"],\n fields: {\n label: validateType(\"Identifier\"),\n optional: {\n validate: bool,\n default: false,\n },\n elementType: validateType(\"TSType\"),\n },\n});\n\nconst unionOrIntersection = {\n aliases: [\"TSType\"],\n visitor: [\"types\"],\n fields: {\n types: validateArrayOfType(\"TSType\"),\n },\n};\n\ndefineType(\"TSUnionType\", unionOrIntersection);\ndefineType(\"TSIntersectionType\", unionOrIntersection);\n\ndefineType(\"TSConditionalType\", {\n aliases: [\"TSType\"],\n visitor: [\"checkType\", \"extendsType\", \"trueType\", \"falseType\"],\n fields: {\n checkType: validateType(\"TSType\"),\n extendsType: validateType(\"TSType\"),\n trueType: validateType(\"TSType\"),\n falseType: validateType(\"TSType\"),\n },\n});\n\ndefineType(\"TSInferType\", {\n aliases: [\"TSType\"],\n visitor: [\"typeParameter\"],\n fields: {\n typeParameter: validateType(\"TSTypeParameter\"),\n },\n});\n\ndefineType(\"TSParenthesizedType\", {\n aliases: [\"TSType\"],\n visitor: [\"typeAnnotation\"],\n fields: {\n typeAnnotation: validateType(\"TSType\"),\n },\n});\n\ndefineType(\"TSTypeOperator\", {\n aliases: [\"TSType\"],\n visitor: [\"typeAnnotation\"],\n builder: [\"typeAnnotation\", \"operator\"],\n fields: {\n operator: {\n validate: process.env.BABEL_8_BREAKING\n ? assertOneOf(\"keyof\", \"readonly\", \"unique\")\n : assertValueType(\"string\"),\n // \"keyof\" is not a good default, but as this field is required better\n // pick one. We need it for backwards compatibility with older versions\n // of Babel 7.\n default: process.env.BABEL_8_BREAKING ? undefined : \"keyof\",\n },\n typeAnnotation: validateType(\"TSType\"),\n },\n});\n\ndefineType(\"TSIndexedAccessType\", {\n aliases: [\"TSType\"],\n visitor: [\"objectType\", \"indexType\"],\n fields: {\n objectType: validateType(\"TSType\"),\n indexType: validateType(\"TSType\"),\n },\n});\n\ndefineType(\"TSMappedType\", {\n aliases: [\"TSType\"],\n visitor: process.env.BABEL_8_BREAKING\n ? [\"key\", \"constraint\", \"nameType\", \"typeAnnotation\"]\n : [\"typeParameter\", \"nameType\", \"typeAnnotation\"],\n builder: process.env.BABEL_8_BREAKING\n ? [\"key\", \"constraint\", \"nameType\", \"typeAnnotation\"]\n : [\"typeParameter\", \"typeAnnotation\", \"nameType\"],\n fields: {\n ...(process.env.BABEL_8_BREAKING\n ? {\n key: validateType(\"Identifier\"),\n constraint: validateType(\"TSType\"),\n }\n : {\n typeParameter: validateType(\"TSTypeParameter\"),\n }),\n readonly: validateOptional(assertOneOf(true, false, \"+\", \"-\")),\n optional: validateOptional(assertOneOf(true, false, \"+\", \"-\")),\n typeAnnotation: validateOptionalType(\"TSType\"),\n nameType: validateOptionalType(\"TSType\"),\n },\n});\n\ndefineType(\"TSTemplateLiteralType\", {\n aliases: [\"TSType\", \"TSBaseType\"],\n visitor: [\"quasis\", \"types\"],\n fields: {\n quasis: validateArrayOfType(\"TemplateElement\"),\n types: {\n validate: chain(\n assertValueType(\"array\"),\n assertEach(assertNodeType(\"TSType\")),\n function (node: t.TSTemplateLiteralType, key, val) {\n if (node.quasis.length !== val.length + 1) {\n throw new TypeError(\n `Number of ${\n node.type\n } quasis should be exactly one more than the number of types.\\nExpected ${\n val.length + 1\n } quasis but got ${node.quasis.length}`,\n );\n }\n } satisfies ValidatorImpl,\n ),\n },\n },\n});\n\ndefineType(\"TSLiteralType\", {\n aliases: [\"TSType\", \"TSBaseType\"],\n visitor: [\"literal\"],\n fields: {\n literal: {\n validate: (function () {\n const unaryExpression = assertNodeType(\n \"NumericLiteral\",\n \"BigIntLiteral\",\n );\n const unaryOperator = assertOneOf(\"-\");\n\n const literal = assertNodeType(\n \"NumericLiteral\",\n \"StringLiteral\",\n \"BooleanLiteral\",\n \"BigIntLiteral\",\n \"TemplateLiteral\",\n );\n const validator: ValidatorOneOfNodeTypes = function validator(\n parent: t.Node,\n key: string,\n node: t.Node,\n ) {\n // type A = -1 | 1;\n if (is(\"UnaryExpression\", node)) {\n // check operator first\n unaryOperator(node, \"operator\", node.operator);\n unaryExpression(node, \"argument\", node.argument);\n } else {\n // type A = 'foo' | 'bar' | false | 1;\n literal(parent, key, node);\n }\n };\n\n validator.oneOfNodeTypes = [\n \"NumericLiteral\",\n \"StringLiteral\",\n \"BooleanLiteral\",\n \"BigIntLiteral\",\n \"TemplateLiteral\",\n \"UnaryExpression\",\n ];\n\n return validator;\n })(),\n },\n },\n});\n\nif (process.env.BABEL_8_BREAKING) {\n defineType(\"TSClassImplements\", {\n aliases: [\"TSType\"],\n visitor: [\"expression\", \"typeArguments\"],\n fields: {\n expression: validateType(\"Expression\"),\n typeArguments: validateOptionalType(\"TSTypeParameterInstantiation\"),\n },\n });\n defineType(\"TSInterfaceHeritage\", {\n aliases: [\"TSType\"],\n visitor: [\"expression\", \"typeArguments\"],\n fields: {\n expression: validateType(\"Expression\"),\n typeArguments: validateOptionalType(\"TSTypeParameterInstantiation\"),\n },\n });\n} else {\n defineType(\"TSExpressionWithTypeArguments\", {\n aliases: [\"TSType\"],\n visitor: [\"expression\", \"typeParameters\"],\n fields: {\n expression: validateType(\"TSEntityName\"),\n typeParameters: validateOptionalType(\"TSTypeParameterInstantiation\"),\n },\n });\n}\n\ndefineType(\"TSInterfaceDeclaration\", {\n // \"Statement\" alias prevents a semicolon from appearing after it in an export declaration.\n aliases: [\"Statement\", \"Declaration\"],\n visitor: [\"id\", \"typeParameters\", \"extends\", \"body\"],\n fields: {\n declare: validateOptional(bool),\n id: validateType(\"Identifier\"),\n typeParameters: validateOptionalType(\"TSTypeParameterDeclaration\"),\n extends: validateOptional(\n arrayOfType(\n // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST\n process.env.BABEL_8_BREAKING\n ? \"TSClassImplements\"\n : \"TSExpressionWithTypeArguments\",\n ),\n ),\n body: validateType(\"TSInterfaceBody\"),\n },\n});\n\ndefineType(\"TSInterfaceBody\", {\n visitor: [\"body\"],\n fields: {\n body: validateArrayOfType(\"TSTypeElement\"),\n },\n});\n\ndefineType(\"TSTypeAliasDeclaration\", {\n aliases: [\"Statement\", \"Declaration\"],\n visitor: [\"id\", \"typeParameters\", \"typeAnnotation\"],\n fields: {\n declare: validateOptional(bool),\n id: validateType(\"Identifier\"),\n typeParameters: validateOptionalType(\"TSTypeParameterDeclaration\"),\n typeAnnotation: validateType(\"TSType\"),\n },\n});\n\ndefineType(\"TSInstantiationExpression\", {\n aliases: [\"Expression\"],\n visitor: process.env.BABEL_8_BREAKING\n ? [\"expression\", \"typeArguments\"]\n : [\"expression\", \"typeParameters\"],\n fields: {\n expression: validateType(\"Expression\"),\n [process.env.BABEL_8_BREAKING ? \"typeArguments\" : \"typeParameters\"]:\n validateOptionalType(\"TSTypeParameterInstantiation\"),\n },\n});\n\nconst TSTypeExpression = {\n aliases: [\"Expression\", \"LVal\", \"PatternLike\"],\n visitor: [\"expression\", \"typeAnnotation\"],\n fields: {\n expression: validateType(\"Expression\"),\n typeAnnotation: validateType(\"TSType\"),\n },\n};\n\ndefineType(\"TSAsExpression\", TSTypeExpression);\ndefineType(\"TSSatisfiesExpression\", TSTypeExpression);\n\ndefineType(\"TSTypeAssertion\", {\n aliases: [\"Expression\", \"LVal\", \"PatternLike\"],\n visitor: [\"typeAnnotation\", \"expression\"],\n fields: {\n typeAnnotation: validateType(\"TSType\"),\n expression: validateType(\"Expression\"),\n },\n});\n\ndefineType(\"TSEnumBody\", {\n visitor: [\"members\"],\n fields: {\n members: validateArrayOfType(\"TSEnumMember\"),\n },\n});\n\nif (process.env.BABEL_8_BREAKING) {\n defineType(\"TSEnumDeclaration\", {\n // \"Statement\" alias prevents a semicolon from appearing after it in an export declaration.\n aliases: [\"Statement\", \"Declaration\"],\n visitor: [\"id\", \"body\"],\n fields: {\n declare: validateOptional(bool),\n const: validateOptional(bool),\n id: validateType(\"Identifier\"),\n // @ts-ignore(Babel 7 vs Babel 8) Babel 8 AST\n body: validateType(\"TSEnumBody\"),\n },\n });\n} else {\n defineType(\"TSEnumDeclaration\", {\n // \"Statement\" alias prevents a semicolon from appearing after it in an export declaration.\n aliases: [\"Statement\", \"Declaration\"],\n visitor: [\"id\", \"members\"],\n fields: {\n declare: validateOptional(bool),\n const: validateOptional(bool),\n id: validateType(\"Identifier\"),\n members: validateArrayOfType(\"TSEnumMember\"),\n initializer: validateOptionalType(\"Expression\"),\n body: validateOptionalType(\"TSEnumBody\"),\n },\n });\n}\n\ndefineType(\"TSEnumMember\", {\n visitor: [\"id\", \"initializer\"],\n fields: {\n id: validateType(\"Identifier\", \"StringLiteral\"),\n initializer: validateOptionalType(\"Expression\"),\n },\n});\n\ndefineType(\"TSModuleDeclaration\", {\n aliases: [\"Statement\", \"Declaration\"],\n visitor: [\"id\", \"body\"],\n fields: {\n kind: {\n validate: assertOneOf(\"global\", \"module\", \"namespace\"),\n },\n declare: validateOptional(bool),\n ...(!process.env.BABEL_8_BREAKING && { global: validateOptional(bool) }),\n id: process.env.BABEL_8_BREAKING\n ? validateType(\"TSEntityName\", \"StringLiteral\")\n : validateType(\"Identifier\", \"StringLiteral\"),\n body: process.env.BABEL_8_BREAKING\n ? validateType(\"TSModuleBlock\")\n : validateType(\"TSModuleBlock\", \"TSModuleDeclaration\"),\n },\n});\n\ndefineType(\"TSModuleBlock\", {\n aliases: [\"Scopable\", \"Block\", \"BlockParent\", \"FunctionParent\"],\n visitor: [\"body\"],\n fields: {\n body: validateArrayOfType(\"Statement\"),\n },\n});\n\ndefineType(\"TSImportType\", {\n aliases: [\"TSType\"],\n builder: [\n process.env.BABEL_8_BREAKING ? \"source\" : \"argument\",\n \"qualifier\",\n process.env.BABEL_8_BREAKING ? \"typeArguments\" : \"typeParameters\",\n ],\n visitor: [\n process.env.BABEL_8_BREAKING ? \"source\" : \"argument\",\n \"options\",\n \"qualifier\",\n process.env.BABEL_8_BREAKING ? \"typeArguments\" : \"typeParameters\",\n ],\n fields: {\n ...(process.env.BABEL_8_BREAKING\n ? { source: validateType(\"StringLiteral\") }\n : { argument: validateType(\"StringLiteral\") }),\n qualifier: validateOptionalType(\"TSEntityName\"),\n ...(process.env.BABEL_8_BREAKING\n ? {\n typeArguments: validateOptionalType(\"TSTypeParameterInstantiation\"),\n }\n : {\n typeParameters: validateOptionalType(\"TSTypeParameterInstantiation\"),\n }),\n options: {\n validate: assertNodeType(\"ObjectExpression\"),\n optional: true,\n },\n },\n});\n\ndefineType(\"TSImportEqualsDeclaration\", {\n aliases: [\"Statement\", \"Declaration\"],\n visitor: [\"id\", \"moduleReference\"],\n fields: {\n ...(process.env.BABEL_8_BREAKING ? {} : { isExport: validate(bool) }),\n id: validateType(\"Identifier\"),\n moduleReference: validateType(\"TSEntityName\", \"TSExternalModuleReference\"),\n importKind: {\n validate: assertOneOf(\"type\", \"value\"),\n optional: true,\n },\n },\n});\n\ndefineType(\"TSExternalModuleReference\", {\n visitor: [\"expression\"],\n fields: {\n expression: validateType(\"StringLiteral\"),\n },\n});\n\ndefineType(\"TSNonNullExpression\", {\n aliases: [\"Expression\", \"LVal\", \"PatternLike\"],\n visitor: [\"expression\"],\n fields: {\n expression: validateType(\"Expression\"),\n },\n});\n\ndefineType(\"TSExportAssignment\", {\n aliases: [\"Statement\"],\n visitor: [\"expression\"],\n fields: {\n expression: validateType(\"Expression\"),\n },\n});\n\ndefineType(\"TSNamespaceExportDeclaration\", {\n aliases: [\"Statement\"],\n visitor: [\"id\"],\n fields: {\n id: validateType(\"Identifier\"),\n },\n});\n\ndefineType(\"TSTypeAnnotation\", {\n visitor: [\"typeAnnotation\"],\n fields: {\n typeAnnotation: {\n validate: assertNodeType(\"TSType\"),\n },\n },\n});\n\ndefineType(\"TSTypeParameterInstantiation\", {\n visitor: [\"params\"],\n fields: {\n params: validateArrayOfType(\"TSType\"),\n },\n});\n\ndefineType(\"TSTypeParameterDeclaration\", {\n visitor: [\"params\"],\n fields: {\n params: validateArrayOfType(\"TSTypeParameter\"),\n },\n});\n\ndefineType(\"TSTypeParameter\", {\n builder: [\"constraint\", \"default\", \"name\"],\n visitor: process.env.BABEL_8_BREAKING\n ? [\"name\", \"constraint\", \"default\"]\n : [\"constraint\", \"default\"],\n fields: {\n name: {\n validate: !process.env.BABEL_8_BREAKING\n ? assertValueType(\"string\")\n : assertNodeType(\"Identifier\"),\n },\n in: {\n validate: assertValueType(\"boolean\"),\n optional: true,\n },\n out: {\n validate: assertValueType(\"boolean\"),\n optional: true,\n },\n const: {\n validate: assertValueType(\"boolean\"),\n optional: true,\n },\n constraint: {\n validate: assertNodeType(\"TSType\"),\n optional: true,\n },\n default: {\n validate: assertNodeType(\"TSType\"),\n optional: true,\n },\n },\n});\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/definitions/utils.js b/scripts/node_modules/@babel/types/lib/definitions/utils.js new file mode 100644 index 0000000000000000000000000000000000000000..ec7c0942a9b92e2b3bd1f3b00345d4d2f8700009 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/definitions/utils.js @@ -0,0 +1,296 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.allExpandedTypes = exports.VISITOR_KEYS = exports.NODE_UNION_SHAPES__PRIVATE = exports.NODE_PARENT_VALIDATIONS = exports.NODE_FIELDS = exports.FLIPPED_ALIAS_KEYS = exports.DEPRECATED_KEYS = exports.BUILDER_KEYS = exports.ALIAS_KEYS = void 0; +exports.arrayOf = arrayOf; +exports.arrayOfType = arrayOfType; +exports.assertEach = assertEach; +exports.assertNodeOrValueType = assertNodeOrValueType; +exports.assertNodeType = assertNodeType; +exports.assertOneOf = assertOneOf; +exports.assertOptionalChainStart = assertOptionalChainStart; +exports.assertShape = assertShape; +exports.assertValueType = assertValueType; +exports.chain = chain; +exports.default = defineType; +exports.defineAliasedType = defineAliasedType; +exports.validate = validate; +exports.validateArrayOfType = validateArrayOfType; +exports.validateOptional = validateOptional; +exports.validateOptionalType = validateOptionalType; +exports.validateType = validateType; +var _is = require("../validators/is.js"); +var _validate = require("../validators/validate.js"); +const VISITOR_KEYS = exports.VISITOR_KEYS = {}; +const ALIAS_KEYS = exports.ALIAS_KEYS = {}; +const FLIPPED_ALIAS_KEYS = exports.FLIPPED_ALIAS_KEYS = {}; +const NODE_FIELDS = exports.NODE_FIELDS = {}; +const BUILDER_KEYS = exports.BUILDER_KEYS = {}; +const DEPRECATED_KEYS = exports.DEPRECATED_KEYS = {}; +const NODE_PARENT_VALIDATIONS = exports.NODE_PARENT_VALIDATIONS = {}; +const NODE_UNION_SHAPES__PRIVATE = exports.NODE_UNION_SHAPES__PRIVATE = {}; +function getType(val) { + if (Array.isArray(val)) { + return "array"; + } else if (val === null) { + return "null"; + } else { + return typeof val; + } +} +function validate(validate) { + return { + validate + }; +} +function validateType(...typeNames) { + return validate(assertNodeType(...typeNames)); +} +function validateOptional(validate) { + return { + validate, + optional: true + }; +} +function validateOptionalType(...typeNames) { + return { + validate: assertNodeType(...typeNames), + optional: true + }; +} +function arrayOf(elementType) { + return chain(assertValueType("array"), assertEach(elementType)); +} +function arrayOfType(...typeNames) { + return arrayOf(assertNodeType(...typeNames)); +} +function validateArrayOfType(...typeNames) { + return validate(arrayOfType(...typeNames)); +} +function assertEach(callback) { + const childValidator = process.env.BABEL_TYPES_8_BREAKING ? _validate.validateChild : () => {}; + function validator(node, key, val) { + if (!Array.isArray(val)) return; + let i = 0; + const subKey = { + toString() { + return `${key}[${i}]`; + } + }; + for (; i < val.length; i++) { + const v = val[i]; + callback(node, subKey, v); + childValidator(node, subKey, v); + } + } + validator.each = callback; + return validator; +} +function assertOneOf(...values) { + function validate(node, key, val) { + if (!values.includes(val)) { + throw new TypeError(`Property ${key} expected value to be one of ${JSON.stringify(values)} but got ${JSON.stringify(val)}`); + } + } + validate.oneOf = values; + return validate; +} +const allExpandedTypes = exports.allExpandedTypes = []; +function assertNodeType(...types) { + const expandedTypes = new Set(); + allExpandedTypes.push({ + types, + set: expandedTypes + }); + function validate(node, key, val) { + const valType = val == null ? void 0 : val.type; + if (valType != null) { + if (expandedTypes.has(valType)) { + (0, _validate.validateChild)(node, key, val); + return; + } + if (valType === "Placeholder") { + for (const type of types) { + if ((0, _is.default)(type, val)) { + (0, _validate.validateChild)(node, key, val); + return; + } + } + } + } + throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(valType)}`); + } + validate.oneOfNodeTypes = types; + return validate; +} +function assertNodeOrValueType(...types) { + function validate(node, key, val) { + const primitiveType = getType(val); + for (const type of types) { + if (primitiveType === type || (0, _is.default)(type, val)) { + (0, _validate.validateChild)(node, key, val); + return; + } + } + throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`); + } + validate.oneOfNodeOrValueTypes = types; + return validate; +} +function assertValueType(type) { + function validate(node, key, val) { + if (getType(val) === type) { + return; + } + throw new TypeError(`Property ${key} expected type of ${type} but got ${getType(val)}`); + } + validate.type = type; + return validate; +} +function assertShape(shape) { + const keys = Object.keys(shape); + function validate(node, key, val) { + const errors = []; + for (const property of keys) { + try { + (0, _validate.validateField)(node, property, val[property], shape[property]); + } catch (error) { + if (error instanceof TypeError) { + errors.push(error.message); + continue; + } + throw error; + } + } + if (errors.length) { + throw new TypeError(`Property ${key} of ${node.type} expected to have the following:\n${errors.join("\n")}`); + } + } + validate.shapeOf = shape; + return validate; +} +function assertOptionalChainStart() { + function validate(node) { + var _current; + let current = node; + while (node) { + const { + type + } = current; + if (type === "OptionalCallExpression") { + if (current.optional) return; + current = current.callee; + continue; + } + if (type === "OptionalMemberExpression") { + if (current.optional) return; + current = current.object; + continue; + } + break; + } + throw new TypeError(`Non-optional ${node.type} must chain from an optional OptionalMemberExpression or OptionalCallExpression. Found chain from ${(_current = current) == null ? void 0 : _current.type}`); + } + return validate; +} +function chain(...fns) { + function validate(...args) { + for (const fn of fns) { + fn(...args); + } + } + validate.chainOf = fns; + if (fns.length >= 2 && "type" in fns[0] && fns[0].type === "array" && !("each" in fns[1])) { + throw new Error(`An assertValueType("array") validator can only be followed by an assertEach(...) validator.`); + } + return validate; +} +const validTypeOpts = new Set(["aliases", "builder", "deprecatedAlias", "fields", "inherits", "visitor", "validate", "unionShape"]); +const validFieldKeys = new Set(["default", "optional", "deprecated", "validate"]); +const store = {}; +function defineAliasedType(...aliases) { + return (type, opts = {}) => { + let defined = opts.aliases; + if (!defined) { + var _store$opts$inherits$; + if (opts.inherits) defined = (_store$opts$inherits$ = store[opts.inherits].aliases) == null ? void 0 : _store$opts$inherits$.slice(); + defined != null ? defined : defined = []; + opts.aliases = defined; + } + const additional = aliases.filter(a => !defined.includes(a)); + defined.unshift(...additional); + defineType(type, opts); + }; +} +function defineType(type, opts = {}) { + const inherits = opts.inherits && store[opts.inherits] || {}; + let fields = opts.fields; + if (!fields) { + fields = {}; + if (inherits.fields) { + const keys = Object.getOwnPropertyNames(inherits.fields); + for (const key of keys) { + const field = inherits.fields[key]; + const def = field.default; + if (Array.isArray(def) ? def.length > 0 : def && typeof def === "object") { + throw new Error("field defaults can only be primitives or empty arrays currently"); + } + fields[key] = { + default: Array.isArray(def) ? [] : def, + optional: field.optional, + deprecated: field.deprecated, + validate: field.validate + }; + } + } + } + const visitor = opts.visitor || inherits.visitor || []; + const aliases = opts.aliases || inherits.aliases || []; + const builder = opts.builder || inherits.builder || opts.visitor || []; + for (const k of Object.keys(opts)) { + if (!validTypeOpts.has(k)) { + throw new Error(`Unknown type option "${k}" on ${type}`); + } + } + if (opts.deprecatedAlias) { + DEPRECATED_KEYS[opts.deprecatedAlias] = type; + } + for (const key of visitor.concat(builder)) { + fields[key] = fields[key] || {}; + } + for (const key of Object.keys(fields)) { + const field = fields[key]; + if (field.default !== undefined && !builder.includes(key)) { + field.optional = true; + } + if (field.default === undefined) { + field.default = null; + } else if (!field.validate && field.default != null) { + field.validate = assertValueType(getType(field.default)); + } + for (const k of Object.keys(field)) { + if (!validFieldKeys.has(k)) { + throw new Error(`Unknown field key "${k}" on ${type}.${key}`); + } + } + } + VISITOR_KEYS[type] = opts.visitor = visitor; + BUILDER_KEYS[type] = opts.builder = builder; + NODE_FIELDS[type] = opts.fields = fields; + ALIAS_KEYS[type] = opts.aliases = aliases; + aliases.forEach(alias => { + FLIPPED_ALIAS_KEYS[alias] = FLIPPED_ALIAS_KEYS[alias] || []; + FLIPPED_ALIAS_KEYS[alias].push(type); + }); + if (opts.validate) { + NODE_PARENT_VALIDATIONS[type] = opts.validate; + } + if (opts.unionShape) { + NODE_UNION_SHAPES__PRIVATE[type] = opts.unionShape; + } + store[type] = opts; +} + +//# sourceMappingURL=utils.js.map diff --git a/scripts/node_modules/@babel/types/lib/definitions/utils.js.map b/scripts/node_modules/@babel/types/lib/definitions/utils.js.map new file mode 100644 index 0000000000000000000000000000000000000000..c78a7e5154d432bd8b982e145b0dfc7cbbc42bb4 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/definitions/utils.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_is","require","_validate","VISITOR_KEYS","exports","ALIAS_KEYS","FLIPPED_ALIAS_KEYS","NODE_FIELDS","BUILDER_KEYS","DEPRECATED_KEYS","NODE_PARENT_VALIDATIONS","NODE_UNION_SHAPES__PRIVATE","getType","val","Array","isArray","validate","validateType","typeNames","assertNodeType","validateOptional","optional","validateOptionalType","arrayOf","elementType","chain","assertValueType","assertEach","arrayOfType","validateArrayOfType","callback","childValidator","process","env","BABEL_TYPES_8_BREAKING","validateChild","validator","node","key","i","subKey","toString","length","v","each","assertOneOf","values","includes","TypeError","JSON","stringify","oneOf","allExpandedTypes","types","expandedTypes","Set","push","set","valType","type","has","is","oneOfNodeTypes","assertNodeOrValueType","primitiveType","oneOfNodeOrValueTypes","assertShape","shape","keys","Object","errors","property","validateField","error","message","join","shapeOf","assertOptionalChainStart","_current","current","callee","object","fns","args","fn","chainOf","Error","validTypeOpts","validFieldKeys","store","defineAliasedType","aliases","opts","defined","_store$opts$inherits$","inherits","slice","additional","filter","a","unshift","defineType","fields","getOwnPropertyNames","field","def","default","deprecated","visitor","builder","k","deprecatedAlias","concat","undefined","forEach","alias","unionShape"],"sources":["../../src/definitions/utils.ts"],"sourcesContent":["import is from \"../validators/is.ts\";\nimport { validateField, validateChild } from \"../validators/validate.ts\";\nimport type * as t from \"../index.ts\";\n\nexport const VISITOR_KEYS: Record = {};\nexport const ALIAS_KEYS: Partial> =\n {};\nexport const FLIPPED_ALIAS_KEYS: Record = {};\nexport const NODE_FIELDS: Record = {};\nexport const BUILDER_KEYS: Record = {};\nexport const DEPRECATED_KEYS: Record = {};\nexport const NODE_PARENT_VALIDATIONS: Record = {};\nexport const NODE_UNION_SHAPES__PRIVATE: Record = {};\n\nfunction getType(val: any) {\n if (Array.isArray(val)) {\n return \"array\";\n } else if (val === null) {\n return \"null\";\n } else {\n return typeof val;\n }\n}\n\ntype NodeTypesWithoutComment = t.Node[\"type\"] | keyof t.Aliases;\n\ntype NodeTypes = NodeTypesWithoutComment | t.Comment[\"type\"];\n\ntype PrimitiveTypes = ReturnType;\n\ntype FieldDefinitions = Record;\n\ntype UnionShape = {\n discriminator: string;\n shapes: {\n name: string;\n value: any[];\n properties: Record;\n }[];\n};\n\ntype DefineTypeOpts = {\n fields?: FieldDefinitions;\n visitor?: string[];\n aliases?: string[];\n builder?: string[];\n inherits?: NodeTypes;\n deprecatedAlias?: string;\n validate?: Validator;\n unionShape?: UnionShape;\n};\n\nexport type ValidatorImpl = (\n node?: t.Node,\n key?: string | { toString(): string },\n val?: any,\n) => void;\n\nexport type ValidatorType = { type: PrimitiveTypes } & ValidatorImpl;\nexport type ValidatorEach = { each: Validator } & ValidatorImpl;\nexport type ValidatorChainOf = {\n chainOf: readonly Validator[];\n} & ValidatorImpl;\nexport type ValidatorOneOf = { oneOf: readonly any[] } & ValidatorImpl;\nexport type ValidatorOneOfNodeTypes = {\n oneOfNodeTypes: readonly NodeTypes[];\n} & ValidatorImpl;\nexport type ValidatorOneOfNodeOrValueTypes = {\n oneOfNodeOrValueTypes: readonly (NodeTypes | PrimitiveTypes)[];\n} & ValidatorImpl;\nexport type ValidatorShapeOf = {\n shapeOf: Record;\n} & ValidatorImpl;\n\nexport type Validator =\n | ValidatorType\n | ValidatorEach\n | ValidatorChainOf\n | ValidatorOneOf\n | ValidatorOneOfNodeTypes\n | ValidatorOneOfNodeOrValueTypes\n | ValidatorShapeOf\n | ValidatorImpl;\n\nexport type FieldOptions = {\n default?: string | number | boolean | [];\n optional?: boolean;\n deprecated?: boolean;\n validate?: Validator;\n};\n\nexport function validate(validate: Validator): FieldOptions {\n return { validate };\n}\n\nexport function validateType(...typeNames: NodeTypes[]) {\n return validate(assertNodeType(...typeNames));\n}\n\nexport function validateOptional(validate: Validator): FieldOptions {\n return { validate, optional: true };\n}\n\nexport function validateOptionalType(...typeNames: NodeTypes[]): FieldOptions {\n return { validate: assertNodeType(...typeNames), optional: true };\n}\n\nexport function arrayOf(elementType: Validator): Validator {\n return chain(assertValueType(\"array\"), assertEach(elementType));\n}\n\nexport function arrayOfType(...typeNames: NodeTypes[]) {\n return arrayOf(assertNodeType(...typeNames));\n}\n\nexport function validateArrayOfType(...typeNames: NodeTypes[]) {\n return validate(arrayOfType(...typeNames));\n}\n\nexport function assertEach(callback: Validator): Validator {\n const childValidator =\n process.env.BABEL_8_BREAKING || process.env.BABEL_TYPES_8_BREAKING\n ? validateChild\n : () => {};\n\n function validator(node: t.Node, key: string, val: any) {\n if (!Array.isArray(val)) return;\n\n let i = 0;\n // We lazily concatenate strings here for performance reasons.\n // Concatenating the strings is expensive because we are actually concatenating a string and a number,\n // so V8 cannot just create a \"rope string\" but has to allocate memory for the string resulting from the number\n // This string is very rarely used, only in error paths, so we can skip the concatenation cost in most cases\n const subKey = {\n toString() {\n return `${key}[${i}]`;\n },\n };\n\n for (; i < val.length; i++) {\n const v = val[i];\n callback(node, subKey, v);\n childValidator(node, subKey, v);\n }\n }\n validator.each = callback;\n return validator;\n}\n\nexport function assertOneOf(...values: any[]): Validator {\n function validate(node: any, key: string, val: any) {\n if (!values.includes(val)) {\n throw new TypeError(\n `Property ${key} expected value to be one of ${JSON.stringify(\n values,\n )} but got ${JSON.stringify(val)}`,\n );\n }\n }\n\n validate.oneOf = values;\n\n return validate;\n}\n\nexport const allExpandedTypes: {\n types: NodeTypes[];\n set: Set;\n}[] = [];\n\nexport function assertNodeType(...types: NodeTypes[]): Validator {\n const expandedTypes = new Set();\n\n allExpandedTypes.push({ types, set: expandedTypes });\n\n function validate(node: t.Node, key: string, val: any) {\n const valType = val?.type;\n if (valType != null) {\n if (expandedTypes.has(valType)) {\n validateChild(node, key, val);\n return;\n }\n if (valType === \"Placeholder\") {\n for (const type of types) {\n if (is(type, val)) {\n validateChild(node, key, val);\n return;\n }\n }\n }\n }\n\n throw new TypeError(\n `Property ${key} of ${\n node.type\n } expected node to be of a type ${JSON.stringify(\n types,\n )} but instead got ${JSON.stringify(valType)}`,\n );\n }\n\n validate.oneOfNodeTypes = types;\n\n return validate;\n}\n\nexport function assertNodeOrValueType(\n ...types: (NodeTypes | PrimitiveTypes)[]\n): Validator {\n function validate(node: t.Node, key: string, val: any) {\n const primitiveType = getType(val);\n for (const type of types) {\n if (primitiveType === type || is(type, val)) {\n validateChild(node, key, val);\n return;\n }\n }\n\n throw new TypeError(\n `Property ${key} of ${\n node.type\n } expected node to be of a type ${JSON.stringify(\n types,\n )} but instead got ${JSON.stringify(val?.type)}`,\n );\n }\n\n validate.oneOfNodeOrValueTypes = types;\n\n return validate;\n}\n\nexport function assertValueType(type: PrimitiveTypes): Validator {\n function validate(node: t.Node, key: string, val: any) {\n if (getType(val) === type) {\n return;\n }\n\n throw new TypeError(\n `Property ${key} expected type of ${type} but got ${getType(val)}`,\n );\n }\n\n validate.type = type;\n\n return validate;\n}\n\nexport function assertShape(shape: Record): Validator {\n const keys = Object.keys(shape);\n function validate(node: t.Node, key: string, val: any) {\n const errors = [];\n for (const property of keys) {\n try {\n validateField(node, property, val[property], shape[property]);\n } catch (error) {\n if (error instanceof TypeError) {\n errors.push(error.message);\n continue;\n }\n throw error;\n }\n }\n if (errors.length) {\n throw new TypeError(\n `Property ${key} of ${\n node.type\n } expected to have the following:\\n${errors.join(\"\\n\")}`,\n );\n }\n }\n\n validate.shapeOf = shape;\n\n return validate;\n}\n\nexport function assertOptionalChainStart(): Validator {\n function validate(node: t.Node) {\n let current = node;\n while (node) {\n const { type } = current;\n if (type === \"OptionalCallExpression\") {\n if (current.optional) return;\n current = current.callee;\n continue;\n }\n\n if (type === \"OptionalMemberExpression\") {\n if (current.optional) return;\n current = current.object;\n continue;\n }\n\n break;\n }\n\n throw new TypeError(\n `Non-optional ${node.type} must chain from an optional OptionalMemberExpression or OptionalCallExpression. Found chain from ${current?.type}`,\n );\n }\n\n return validate;\n}\n\nexport function chain(...fns: Validator[]): Validator {\n function validate(...args: Parameters) {\n for (const fn of fns) {\n fn(...args);\n }\n }\n validate.chainOf = fns;\n\n if (\n fns.length >= 2 &&\n \"type\" in fns[0] &&\n fns[0].type === \"array\" &&\n !(\"each\" in fns[1])\n ) {\n throw new Error(\n `An assertValueType(\"array\") validator can only be followed by an assertEach(...) validator.`,\n );\n }\n\n return validate;\n}\n\nconst validTypeOpts = new Set([\n \"aliases\",\n \"builder\",\n \"deprecatedAlias\",\n \"fields\",\n \"inherits\",\n \"visitor\",\n \"validate\",\n \"unionShape\",\n]);\nconst validFieldKeys = new Set([\n \"default\",\n \"optional\",\n \"deprecated\",\n \"validate\",\n]);\n\nconst store = {} as Record;\n\n// Wraps defineType to ensure these aliases are included.\nexport function defineAliasedType(...aliases: string[]) {\n return (type: string, opts: DefineTypeOpts = {}) => {\n let defined = opts.aliases;\n if (!defined) {\n if (opts.inherits) defined = store[opts.inherits].aliases?.slice();\n defined ??= [];\n opts.aliases = defined;\n }\n const additional = aliases.filter(a => !defined.includes(a));\n defined.unshift(...additional);\n defineType(type, opts);\n };\n}\n\nexport default function defineType(type: string, opts: DefineTypeOpts = {}) {\n const inherits = (opts.inherits && store[opts.inherits]) || {};\n\n let fields = opts.fields;\n if (!fields) {\n fields = {};\n if (inherits.fields) {\n const keys = Object.getOwnPropertyNames(inherits.fields);\n for (const key of keys) {\n const field = inherits.fields[key];\n const def = field.default;\n if (\n Array.isArray(def) ? def.length > 0 : def && typeof def === \"object\"\n ) {\n throw new Error(\n \"field defaults can only be primitives or empty arrays currently\",\n );\n }\n fields[key] = {\n default: Array.isArray(def) ? [] : def,\n optional: field.optional,\n deprecated: field.deprecated,\n validate: field.validate,\n };\n }\n }\n }\n\n const visitor: string[] = opts.visitor || inherits.visitor || [];\n const aliases: string[] = opts.aliases || inherits.aliases || [];\n const builder: string[] =\n opts.builder || inherits.builder || opts.visitor || [];\n\n for (const k of Object.keys(opts)) {\n if (!validTypeOpts.has(k)) {\n throw new Error(`Unknown type option \"${k}\" on ${type}`);\n }\n }\n\n if (opts.deprecatedAlias) {\n DEPRECATED_KEYS[opts.deprecatedAlias] = type as NodeTypesWithoutComment;\n }\n\n // ensure all field keys are represented in `fields`\n for (const key of visitor.concat(builder)) {\n fields[key] = fields[key] || {};\n }\n\n for (const key of Object.keys(fields)) {\n const field = fields[key];\n\n if (field.default !== undefined && !builder.includes(key)) {\n field.optional = true;\n }\n if (field.default === undefined) {\n field.default = null;\n } else if (!field.validate && field.default != null) {\n field.validate = assertValueType(getType(field.default));\n }\n\n for (const k of Object.keys(field)) {\n if (!validFieldKeys.has(k)) {\n throw new Error(`Unknown field key \"${k}\" on ${type}.${key}`);\n }\n }\n }\n\n VISITOR_KEYS[type] = opts.visitor = visitor;\n BUILDER_KEYS[type] = opts.builder = builder;\n NODE_FIELDS[type] = opts.fields = fields;\n ALIAS_KEYS[type as NodeTypesWithoutComment] = opts.aliases = aliases;\n aliases.forEach(alias => {\n FLIPPED_ALIAS_KEYS[alias] = FLIPPED_ALIAS_KEYS[alias] || [];\n FLIPPED_ALIAS_KEYS[alias].push(type as NodeTypesWithoutComment);\n });\n\n if (opts.validate) {\n NODE_PARENT_VALIDATIONS[type] = opts.validate;\n }\n if (opts.unionShape) {\n NODE_UNION_SHAPES__PRIVATE[type] = opts.unionShape;\n }\n\n store[type] = opts;\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/index-legacy.d.ts b/scripts/node_modules/@babel/types/lib/index-legacy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..90736c33c609a6e7e9e7b1c50701855e17c77255 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/index-legacy.d.ts @@ -0,0 +1,2797 @@ +// NOTE: This file is autogenerated. Do not modify. +// See packages/babel-types/scripts/generators/typescript-legacy.ts for script used. + +interface BaseComment { + value: string; + start: number; + end: number; + loc: SourceLocation; + type: "CommentBlock" | "CommentLine"; +} + +export interface CommentBlock extends BaseComment { + type: "CommentBlock"; +} + +export interface CommentLine extends BaseComment { + type: "CommentLine"; +} + +export type Comment = CommentBlock | CommentLine; + +export interface SourceLocation { + start: { + line: number; + column: number; + }; + + end: { + line: number; + column: number; + }; +} + +interface BaseNode { + leadingComments: ReadonlyArray | null; + innerComments: ReadonlyArray | null; + trailingComments: ReadonlyArray | null; + start: number | null; + end: number | null; + loc: SourceLocation | null; + type: Node["type"]; + extra?: Record; +} + +export type Node = Accessor | AnyTypeAnnotation | ArgumentPlaceholder | ArrayExpression | ArrayPattern | ArrayTypeAnnotation | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BigIntLiteral | Binary | BinaryExpression | BindExpression | Block | BlockParent | BlockStatement | BooleanLiteral | BooleanLiteralTypeAnnotation | BooleanTypeAnnotation | BreakStatement | CallExpression | CatchClause | Class | ClassAccessorProperty | ClassBody | ClassDeclaration | ClassExpression | ClassImplements | ClassMethod | ClassPrivateMethod | ClassPrivateProperty | ClassProperty | CompletionStatement | Conditional | ConditionalExpression | ContinueStatement | DebuggerStatement | DecimalLiteral | Declaration | DeclareClass | DeclareExportAllDeclaration | DeclareExportDeclaration | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareOpaqueType | DeclareTypeAlias | DeclareVariable | DeclaredPredicate | Decorator | Directive | DirectiveLiteral | DoExpression | DoWhileStatement | EmptyStatement | EmptyTypeAnnotation | EnumBody | EnumBooleanBody | EnumBooleanMember | EnumDeclaration | EnumDefaultedMember | EnumMember | EnumNumberBody | EnumNumberMember | EnumStringBody | EnumStringMember | EnumSymbolBody | ExistsTypeAnnotation | ExportAllDeclaration | ExportDeclaration | ExportDefaultDeclaration | ExportDefaultSpecifier | ExportNamedDeclaration | ExportNamespaceSpecifier | ExportSpecifier | Expression | ExpressionStatement | ExpressionWrapper | File | Flow | FlowBaseAnnotation | FlowDeclaration | FlowPredicate | FlowType | For | ForInStatement | ForOfStatement | ForStatement | ForXStatement | Function | FunctionDeclaration | FunctionExpression | FunctionParameter | FunctionParent | FunctionTypeAnnotation | FunctionTypeParam | GenericTypeAnnotation | Identifier | IfStatement | Immutable | Import | ImportAttribute | ImportDeclaration | ImportDefaultSpecifier | ImportExpression | ImportNamespaceSpecifier | ImportOrExportDeclaration | ImportSpecifier | IndexedAccessType | InferredPredicate | InterfaceDeclaration | InterfaceExtends | InterfaceTypeAnnotation | InterpreterDirective | IntersectionTypeAnnotation | JSX | JSXAttribute | JSXClosingElement | JSXClosingFragment | JSXElement | JSXEmptyExpression | JSXExpressionContainer | JSXFragment | JSXIdentifier | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement | JSXOpeningFragment | JSXSpreadAttribute | JSXSpreadChild | JSXText | LVal | LabeledStatement | Literal | LogicalExpression | Loop | MemberExpression | MetaProperty | Method | Miscellaneous | MixedTypeAnnotation | ModuleDeclaration | ModuleExpression | ModuleSpecifier | NewExpression | Noop | NullLiteral | NullLiteralTypeAnnotation | NullableTypeAnnotation | NumberLiteral | NumberLiteralTypeAnnotation | NumberTypeAnnotation | NumericLiteral | ObjectExpression | ObjectMember | ObjectMethod | ObjectPattern | ObjectProperty | ObjectTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalCallExpression | OptionalIndexedAccessType | OptionalMemberExpression | ParenthesizedExpression | Pattern | PatternLike | PipelineBareFunction | PipelinePrimaryTopicReference | PipelineTopicExpression | Placeholder | Private | PrivateName | Program | Property | Pureish | QualifiedTypeIdentifier | RecordExpression | RegExpLiteral | RegexLiteral | RestElement | RestProperty | ReturnStatement | Scopable | SequenceExpression | SpreadElement | SpreadProperty | Standardized | Statement | StaticBlock | StringLiteral | StringLiteralTypeAnnotation | StringTypeAnnotation | Super | SwitchCase | SwitchStatement | SymbolTypeAnnotation | TSAnyKeyword | TSArrayType | TSAsExpression | TSBaseType | TSBigIntKeyword | TSBooleanKeyword | TSCallSignatureDeclaration | TSConditionalType | TSConstructSignatureDeclaration | TSConstructorType | TSDeclareFunction | TSDeclareMethod | TSEntityName | TSEnumBody | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSExpressionWithTypeArguments | TSExternalModuleReference | TSFunctionType | TSImportEqualsDeclaration | TSImportType | TSIndexSignature | TSIndexedAccessType | TSInferType | TSInstantiationExpression | TSInterfaceBody | TSInterfaceDeclaration | TSIntersectionType | TSIntrinsicKeyword | TSLiteralType | TSMappedType | TSMethodSignature | TSModuleBlock | TSModuleDeclaration | TSNamedTupleMember | TSNamespaceExportDeclaration | TSNeverKeyword | TSNonNullExpression | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSOptionalType | TSParameterProperty | TSParenthesizedType | TSPropertySignature | TSQualifiedName | TSRestType | TSSatisfiesExpression | TSStringKeyword | TSSymbolKeyword | TSTemplateLiteralType | TSThisType | TSTupleType | TSType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeElement | TSTypeLiteral | TSTypeOperator | TSTypeParameter | TSTypeParameterDeclaration | TSTypeParameterInstantiation | TSTypePredicate | TSTypeQuery | TSTypeReference | TSUndefinedKeyword | TSUnionType | TSUnknownKeyword | TSVoidKeyword | TaggedTemplateExpression | TemplateElement | TemplateLiteral | Terminatorless | ThisExpression | ThisTypeAnnotation | ThrowStatement | TopicReference | TryStatement | TupleExpression | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeCastExpression | TypeParameter | TypeParameterDeclaration | TypeParameterInstantiation | TypeScript | TypeofTypeAnnotation | UnaryExpression | UnaryLike | UnionTypeAnnotation | UpdateExpression | UserWhitespacable | V8IntrinsicIdentifier | VariableDeclaration | VariableDeclarator | Variance | VoidPattern | VoidTypeAnnotation | While | WhileStatement | WithStatement | YieldExpression; + +export interface ArrayExpression extends BaseNode { + type: "ArrayExpression"; + elements: (null | Expression | SpreadElement)[]; +} + +export interface AssignmentExpression extends BaseNode { + type: "AssignmentExpression"; + operator: string; + left: LVal | OptionalMemberExpression; + right: Expression; +} + +export interface BinaryExpression extends BaseNode { + type: "BinaryExpression"; + operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=" | "|>"; + left: Expression | PrivateName; + right: Expression; +} + +export interface InterpreterDirective extends BaseNode { + type: "InterpreterDirective"; + value: string; +} + +export interface Directive extends BaseNode { + type: "Directive"; + value: DirectiveLiteral; +} + +export interface DirectiveLiteral extends BaseNode { + type: "DirectiveLiteral"; + value: string; +} + +export interface BlockStatement extends BaseNode { + type: "BlockStatement"; + body: Statement[]; + directives: Directive[]; +} + +export interface BreakStatement extends BaseNode { + type: "BreakStatement"; + label: Identifier | null; +} + +export interface CallExpression extends BaseNode { + type: "CallExpression"; + callee: Expression | Super | V8IntrinsicIdentifier; + arguments: (Expression | SpreadElement | ArgumentPlaceholder)[]; + optional: boolean | null; + typeArguments: TypeParameterInstantiation | null; + typeParameters: TSTypeParameterInstantiation | null; +} + +export interface CatchClause extends BaseNode { + type: "CatchClause"; + param: Identifier | ArrayPattern | ObjectPattern | null; + body: BlockStatement; +} + +export interface ConditionalExpression extends BaseNode { + type: "ConditionalExpression"; + test: Expression; + consequent: Expression; + alternate: Expression; +} + +export interface ContinueStatement extends BaseNode { + type: "ContinueStatement"; + label: Identifier | null; +} + +export interface DebuggerStatement extends BaseNode { + type: "DebuggerStatement"; +} + +export interface DoWhileStatement extends BaseNode { + type: "DoWhileStatement"; + test: Expression; + body: Statement; +} + +export interface EmptyStatement extends BaseNode { + type: "EmptyStatement"; +} + +export interface ExpressionStatement extends BaseNode { + type: "ExpressionStatement"; + expression: Expression; +} + +export interface File extends BaseNode { + type: "File"; + program: Program; + comments: (CommentBlock | CommentLine)[] | null; + tokens: any[] | null; +} + +export interface ForInStatement extends BaseNode { + type: "ForInStatement"; + left: VariableDeclaration | LVal; + right: Expression; + body: Statement; +} + +export interface ForStatement extends BaseNode { + type: "ForStatement"; + init: VariableDeclaration | Expression | null; + test: Expression | null; + update: Expression | null; + body: Statement; +} + +export interface FunctionDeclaration extends BaseNode { + type: "FunctionDeclaration"; + id: Identifier | null; + params: FunctionParameter[]; + body: BlockStatement; + generator: boolean; + async: boolean; + declare: boolean | null; + predicate: DeclaredPredicate | InferredPredicate | null; + returnType: TypeAnnotation | TSTypeAnnotation | Noop | null; + typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null; +} + +export interface FunctionExpression extends BaseNode { + type: "FunctionExpression"; + id: Identifier | null; + params: FunctionParameter[]; + body: BlockStatement; + generator: boolean; + async: boolean; + predicate: DeclaredPredicate | InferredPredicate | null; + returnType: TypeAnnotation | TSTypeAnnotation | Noop | null; + typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null; +} + +export interface Identifier extends BaseNode { + type: "Identifier"; + name: string; + decorators: Decorator[] | null; + optional: boolean | null; + typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null; +} + +export interface IfStatement extends BaseNode { + type: "IfStatement"; + test: Expression; + consequent: Statement; + alternate: Statement | null; +} + +export interface LabeledStatement extends BaseNode { + type: "LabeledStatement"; + label: Identifier; + body: Statement; +} + +export interface StringLiteral extends BaseNode { + type: "StringLiteral"; + value: string; +} + +export interface NumericLiteral extends BaseNode { + type: "NumericLiteral"; + value: number; +} + +export interface NullLiteral extends BaseNode { + type: "NullLiteral"; +} + +export interface BooleanLiteral extends BaseNode { + type: "BooleanLiteral"; + value: boolean; +} + +export interface RegExpLiteral extends BaseNode { + type: "RegExpLiteral"; + pattern: string; + flags: string; +} + +export interface LogicalExpression extends BaseNode { + type: "LogicalExpression"; + operator: "||" | "&&" | "??"; + left: Expression; + right: Expression; +} + +export interface MemberExpression extends BaseNode { + type: "MemberExpression"; + object: Expression | Super; + property: Expression | Identifier | PrivateName; + computed: boolean; + optional: boolean | null; +} + +export interface NewExpression extends BaseNode { + type: "NewExpression"; + callee: Expression | Super | V8IntrinsicIdentifier; + arguments: (Expression | SpreadElement | ArgumentPlaceholder)[]; + optional: boolean | null; + typeArguments: TypeParameterInstantiation | null; + typeParameters: TSTypeParameterInstantiation | null; +} + +export interface Program extends BaseNode { + type: "Program"; + body: Statement[]; + directives: Directive[]; + sourceType: "script" | "module"; + interpreter: InterpreterDirective | null; +} + +export interface ObjectExpression extends BaseNode { + type: "ObjectExpression"; + properties: (ObjectMethod | ObjectProperty | SpreadElement)[]; +} + +export interface ObjectMethod extends BaseNode { + type: "ObjectMethod"; + kind: "method" | "get" | "set"; + key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral; + params: FunctionParameter[]; + body: BlockStatement; + computed: boolean; + generator: boolean; + async: boolean; + decorators: Decorator[] | null; + returnType: TypeAnnotation | TSTypeAnnotation | Noop | null; + typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null; +} + +export interface ObjectProperty extends BaseNode { + type: "ObjectProperty"; + key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral | DecimalLiteral | PrivateName; + value: Expression | PatternLike; + computed: boolean; + shorthand: boolean; + decorators: Decorator[] | null; +} + +export interface RestElement extends BaseNode { + type: "RestElement"; + argument: Identifier | ArrayPattern | ObjectPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression | RestElement | AssignmentPattern; + decorators: Decorator[] | null; + optional: boolean | null; + typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null; +} + +export interface ReturnStatement extends BaseNode { + type: "ReturnStatement"; + argument: Expression | null; +} + +export interface SequenceExpression extends BaseNode { + type: "SequenceExpression"; + expressions: Expression[]; +} + +export interface ParenthesizedExpression extends BaseNode { + type: "ParenthesizedExpression"; + expression: Expression; +} + +export interface SwitchCase extends BaseNode { + type: "SwitchCase"; + test: Expression | null; + consequent: Statement[]; +} + +export interface SwitchStatement extends BaseNode { + type: "SwitchStatement"; + discriminant: Expression; + cases: SwitchCase[]; +} + +export interface ThisExpression extends BaseNode { + type: "ThisExpression"; +} + +export interface ThrowStatement extends BaseNode { + type: "ThrowStatement"; + argument: Expression; +} + +export interface TryStatement extends BaseNode { + type: "TryStatement"; + block: BlockStatement; + handler: CatchClause | null; + finalizer: BlockStatement | null; +} + +export interface UnaryExpression extends BaseNode { + type: "UnaryExpression"; + operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof"; + argument: Expression; + prefix: boolean; +} + +export interface UpdateExpression extends BaseNode { + type: "UpdateExpression"; + operator: "++" | "--"; + argument: Expression; + prefix: boolean; +} + +export interface VariableDeclaration extends BaseNode { + type: "VariableDeclaration"; + kind: "var" | "let" | "const" | "using" | "await using"; + declarations: VariableDeclarator[]; + declare: boolean | null; +} + +export interface VariableDeclarator extends BaseNode { + type: "VariableDeclarator"; + id: LVal | VoidPattern; + init: Expression | null; + definite: boolean | null; +} + +export interface WhileStatement extends BaseNode { + type: "WhileStatement"; + test: Expression; + body: Statement; +} + +export interface WithStatement extends BaseNode { + type: "WithStatement"; + object: Expression; + body: Statement; +} + +export interface AssignmentPattern extends BaseNode { + type: "AssignmentPattern"; + left: Identifier | ObjectPattern | ArrayPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression; + right: Expression; + decorators: Decorator[] | null; + optional: boolean | null; + typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null; +} + +export interface ArrayPattern extends BaseNode { + type: "ArrayPattern"; + elements: (null | PatternLike)[]; + decorators: Decorator[] | null; + optional: boolean | null; + typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null; +} + +export interface ArrowFunctionExpression extends BaseNode { + type: "ArrowFunctionExpression"; + params: FunctionParameter[]; + body: BlockStatement | Expression; + async: boolean; + expression: boolean; + generator: boolean; + predicate: DeclaredPredicate | InferredPredicate | null; + returnType: TypeAnnotation | TSTypeAnnotation | Noop | null; + typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null; +} + +export interface ClassBody extends BaseNode { + type: "ClassBody"; + body: (ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty | ClassAccessorProperty | TSDeclareMethod | TSIndexSignature | StaticBlock)[]; +} + +export interface ClassExpression extends BaseNode { + type: "ClassExpression"; + id: Identifier | null; + superClass: Expression | null; + body: ClassBody; + decorators: Decorator[] | null; + implements: (TSExpressionWithTypeArguments | ClassImplements)[] | null; + mixins: InterfaceExtends | null; + superTypeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation | null; + typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null; +} + +export interface ClassDeclaration extends BaseNode { + type: "ClassDeclaration"; + id: Identifier | null; + superClass: Expression | null; + body: ClassBody; + decorators: Decorator[] | null; + abstract: boolean | null; + declare: boolean | null; + implements: (TSExpressionWithTypeArguments | ClassImplements)[] | null; + mixins: InterfaceExtends | null; + superTypeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation | null; + typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null; +} + +export interface ExportAllDeclaration extends BaseNode { + type: "ExportAllDeclaration"; + source: StringLiteral; + attributes: ImportAttribute[] | null; + assertions: ImportAttribute[] | null; + exportKind: "type" | "value" | null; +} + +export interface ExportDefaultDeclaration extends BaseNode { + type: "ExportDefaultDeclaration"; + declaration: TSDeclareFunction | FunctionDeclaration | ClassDeclaration | Expression; + exportKind: "value" | null; +} + +export interface ExportNamedDeclaration extends BaseNode { + type: "ExportNamedDeclaration"; + declaration: Declaration | null; + specifiers: (ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier)[]; + source: StringLiteral | null; + attributes: ImportAttribute[] | null; + assertions: ImportAttribute[] | null; + exportKind: "type" | "value" | null; +} + +export interface ExportSpecifier extends BaseNode { + type: "ExportSpecifier"; + local: Identifier; + exported: Identifier | StringLiteral; + exportKind: "type" | "value" | null; +} + +export interface ForOfStatement extends BaseNode { + type: "ForOfStatement"; + left: VariableDeclaration | LVal; + right: Expression; + body: Statement; + await: boolean; +} + +export interface ImportDeclaration extends BaseNode { + type: "ImportDeclaration"; + specifiers: (ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier)[]; + source: StringLiteral; + attributes: ImportAttribute[] | null; + assertions: ImportAttribute[] | null; + importKind: "type" | "typeof" | "value" | null; + module: boolean | null; + phase: "source" | "defer" | null; +} + +export interface ImportDefaultSpecifier extends BaseNode { + type: "ImportDefaultSpecifier"; + local: Identifier; +} + +export interface ImportNamespaceSpecifier extends BaseNode { + type: "ImportNamespaceSpecifier"; + local: Identifier; +} + +export interface ImportSpecifier extends BaseNode { + type: "ImportSpecifier"; + local: Identifier; + imported: Identifier | StringLiteral; + importKind: "type" | "typeof" | "value" | null; +} + +export interface ImportExpression extends BaseNode { + type: "ImportExpression"; + source: Expression; + options: Expression | null; + phase: "source" | "defer" | null; +} + +export interface MetaProperty extends BaseNode { + type: "MetaProperty"; + meta: Identifier; + property: Identifier; +} + +export interface ClassMethod extends BaseNode { + type: "ClassMethod"; + kind: "get" | "set" | "method" | "constructor"; + key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression; + params: (FunctionParameter | TSParameterProperty)[]; + body: BlockStatement; + computed: boolean; + static: boolean; + generator: boolean; + async: boolean; + abstract: boolean | null; + access: "public" | "private" | "protected" | null; + accessibility: "public" | "private" | "protected" | null; + decorators: Decorator[] | null; + optional: boolean | null; + override: boolean; + returnType: TypeAnnotation | TSTypeAnnotation | Noop | null; + typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null; +} + +export interface ObjectPattern extends BaseNode { + type: "ObjectPattern"; + properties: (RestElement | ObjectProperty)[]; + decorators: Decorator[] | null; + optional: boolean | null; + typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null; +} + +export interface SpreadElement extends BaseNode { + type: "SpreadElement"; + argument: Expression; +} + +export interface Super extends BaseNode { + type: "Super"; +} + +export interface TaggedTemplateExpression extends BaseNode { + type: "TaggedTemplateExpression"; + tag: Expression; + quasi: TemplateLiteral; + typeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation | null; +} + +export interface TemplateElement extends BaseNode { + type: "TemplateElement"; + value: { raw: string, cooked?: string }; + tail: boolean; +} + +export interface TemplateLiteral extends BaseNode { + type: "TemplateLiteral"; + quasis: TemplateElement[]; + expressions: (Expression | TSType)[]; +} + +export interface YieldExpression extends BaseNode { + type: "YieldExpression"; + argument: Expression | null; + delegate: boolean; +} + +export interface AwaitExpression extends BaseNode { + type: "AwaitExpression"; + argument: Expression; +} + +export interface Import extends BaseNode { + type: "Import"; +} + +export interface BigIntLiteral extends BaseNode { + type: "BigIntLiteral"; + value: string; +} + +export interface ExportNamespaceSpecifier extends BaseNode { + type: "ExportNamespaceSpecifier"; + exported: Identifier; +} + +export interface OptionalMemberExpression extends BaseNode { + type: "OptionalMemberExpression"; + object: Expression; + property: Expression | Identifier; + computed: boolean; + optional: boolean; +} + +export interface OptionalCallExpression extends BaseNode { + type: "OptionalCallExpression"; + callee: Expression; + arguments: (Expression | SpreadElement | ArgumentPlaceholder)[]; + optional: boolean; + typeArguments: TypeParameterInstantiation | null; + typeParameters: TSTypeParameterInstantiation | null; +} + +export interface ClassProperty extends BaseNode { + type: "ClassProperty"; + key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression; + value: Expression | null; + typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null; + decorators: Decorator[] | null; + computed: boolean; + static: boolean; + abstract: boolean | null; + accessibility: "public" | "private" | "protected" | null; + declare: boolean | null; + definite: boolean | null; + optional: boolean | null; + override: boolean; + readonly: boolean | null; + variance: Variance | null; +} + +export interface ClassAccessorProperty extends BaseNode { + type: "ClassAccessorProperty"; + key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression | PrivateName; + value: Expression | null; + typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null; + decorators: Decorator[] | null; + computed: boolean; + static: boolean; + abstract: boolean | null; + accessibility: "public" | "private" | "protected" | null; + declare: boolean | null; + definite: boolean | null; + optional: boolean | null; + override: boolean; + readonly: boolean | null; + variance: Variance | null; +} + +export interface ClassPrivateProperty extends BaseNode { + type: "ClassPrivateProperty"; + key: PrivateName; + value: Expression | null; + decorators: Decorator[] | null; + static: boolean; + definite: boolean | null; + optional: boolean | null; + readonly: boolean | null; + typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null; + variance: Variance | null; +} + +export interface ClassPrivateMethod extends BaseNode { + type: "ClassPrivateMethod"; + kind: "get" | "set" | "method"; + key: PrivateName; + params: (FunctionParameter | TSParameterProperty)[]; + body: BlockStatement; + static: boolean; + abstract: boolean | null; + access: "public" | "private" | "protected" | null; + accessibility: "public" | "private" | "protected" | null; + async: boolean; + computed: boolean; + decorators: Decorator[] | null; + generator: boolean; + optional: boolean | null; + override: boolean; + returnType: TypeAnnotation | TSTypeAnnotation | Noop | null; + typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null; +} + +export interface PrivateName extends BaseNode { + type: "PrivateName"; + id: Identifier; +} + +export interface StaticBlock extends BaseNode { + type: "StaticBlock"; + body: Statement[]; +} + +export interface ImportAttribute extends BaseNode { + type: "ImportAttribute"; + key: Identifier | StringLiteral; + value: StringLiteral; +} + +export interface AnyTypeAnnotation extends BaseNode { + type: "AnyTypeAnnotation"; +} + +export interface ArrayTypeAnnotation extends BaseNode { + type: "ArrayTypeAnnotation"; + elementType: FlowType; +} + +export interface BooleanTypeAnnotation extends BaseNode { + type: "BooleanTypeAnnotation"; +} + +export interface BooleanLiteralTypeAnnotation extends BaseNode { + type: "BooleanLiteralTypeAnnotation"; + value: boolean; +} + +export interface NullLiteralTypeAnnotation extends BaseNode { + type: "NullLiteralTypeAnnotation"; +} + +export interface ClassImplements extends BaseNode { + type: "ClassImplements"; + id: Identifier; + typeParameters: TypeParameterInstantiation | null; +} + +export interface DeclareClass extends BaseNode { + type: "DeclareClass"; + id: Identifier; + typeParameters: TypeParameterDeclaration | null; + extends: InterfaceExtends[] | null; + body: ObjectTypeAnnotation; + implements: ClassImplements[] | null; + mixins: InterfaceExtends[] | null; +} + +export interface DeclareFunction extends BaseNode { + type: "DeclareFunction"; + id: Identifier; + predicate: DeclaredPredicate | null; +} + +export interface DeclareInterface extends BaseNode { + type: "DeclareInterface"; + id: Identifier; + typeParameters: TypeParameterDeclaration | null; + extends: InterfaceExtends[] | null; + body: ObjectTypeAnnotation; +} + +export interface DeclareModule extends BaseNode { + type: "DeclareModule"; + id: Identifier | StringLiteral; + body: BlockStatement; + kind: "CommonJS" | "ES" | null; +} + +export interface DeclareModuleExports extends BaseNode { + type: "DeclareModuleExports"; + typeAnnotation: TypeAnnotation; +} + +export interface DeclareTypeAlias extends BaseNode { + type: "DeclareTypeAlias"; + id: Identifier; + typeParameters: TypeParameterDeclaration | null; + right: FlowType; +} + +export interface DeclareOpaqueType extends BaseNode { + type: "DeclareOpaqueType"; + id: Identifier; + typeParameters: TypeParameterDeclaration | null; + supertype: FlowType | null; + impltype: FlowType | null; +} + +export interface DeclareVariable extends BaseNode { + type: "DeclareVariable"; + id: Identifier; +} + +export interface DeclareExportDeclaration extends BaseNode { + type: "DeclareExportDeclaration"; + declaration: Flow | null; + specifiers: (ExportSpecifier | ExportNamespaceSpecifier)[] | null; + source: StringLiteral | null; + attributes: ImportAttribute[] | null; + assertions: ImportAttribute[] | null; + default: boolean | null; +} + +export interface DeclareExportAllDeclaration extends BaseNode { + type: "DeclareExportAllDeclaration"; + source: StringLiteral; + attributes: ImportAttribute[] | null; + assertions: ImportAttribute[] | null; + exportKind: "type" | "value" | null; +} + +export interface DeclaredPredicate extends BaseNode { + type: "DeclaredPredicate"; + value: Flow; +} + +export interface ExistsTypeAnnotation extends BaseNode { + type: "ExistsTypeAnnotation"; +} + +export interface FunctionTypeAnnotation extends BaseNode { + type: "FunctionTypeAnnotation"; + typeParameters: TypeParameterDeclaration | null; + params: FunctionTypeParam[]; + rest: FunctionTypeParam | null; + returnType: FlowType; + this: FunctionTypeParam | null; +} + +export interface FunctionTypeParam extends BaseNode { + type: "FunctionTypeParam"; + name: Identifier | null; + typeAnnotation: FlowType; + optional: boolean | null; +} + +export interface GenericTypeAnnotation extends BaseNode { + type: "GenericTypeAnnotation"; + id: Identifier | QualifiedTypeIdentifier; + typeParameters: TypeParameterInstantiation | null; +} + +export interface InferredPredicate extends BaseNode { + type: "InferredPredicate"; +} + +export interface InterfaceExtends extends BaseNode { + type: "InterfaceExtends"; + id: Identifier | QualifiedTypeIdentifier; + typeParameters: TypeParameterInstantiation | null; +} + +export interface InterfaceDeclaration extends BaseNode { + type: "InterfaceDeclaration"; + id: Identifier; + typeParameters: TypeParameterDeclaration | null; + extends: InterfaceExtends[] | null; + body: ObjectTypeAnnotation; +} + +export interface InterfaceTypeAnnotation extends BaseNode { + type: "InterfaceTypeAnnotation"; + extends: InterfaceExtends[] | null; + body: ObjectTypeAnnotation; +} + +export interface IntersectionTypeAnnotation extends BaseNode { + type: "IntersectionTypeAnnotation"; + types: FlowType[]; +} + +export interface MixedTypeAnnotation extends BaseNode { + type: "MixedTypeAnnotation"; +} + +export interface EmptyTypeAnnotation extends BaseNode { + type: "EmptyTypeAnnotation"; +} + +export interface NullableTypeAnnotation extends BaseNode { + type: "NullableTypeAnnotation"; + typeAnnotation: FlowType; +} + +export interface NumberLiteralTypeAnnotation extends BaseNode { + type: "NumberLiteralTypeAnnotation"; + value: number; +} + +export interface NumberTypeAnnotation extends BaseNode { + type: "NumberTypeAnnotation"; +} + +export interface ObjectTypeAnnotation extends BaseNode { + type: "ObjectTypeAnnotation"; + properties: (ObjectTypeProperty | ObjectTypeSpreadProperty)[]; + indexers: ObjectTypeIndexer[]; + callProperties: ObjectTypeCallProperty[]; + internalSlots: ObjectTypeInternalSlot[]; + exact: boolean; + inexact: boolean | null; +} + +export interface ObjectTypeInternalSlot extends BaseNode { + type: "ObjectTypeInternalSlot"; + id: Identifier; + value: FlowType; + optional: boolean; + static: boolean; + method: boolean; +} + +export interface ObjectTypeCallProperty extends BaseNode { + type: "ObjectTypeCallProperty"; + value: FlowType; + static: boolean; +} + +export interface ObjectTypeIndexer extends BaseNode { + type: "ObjectTypeIndexer"; + id: Identifier | null; + key: FlowType; + value: FlowType; + variance: Variance | null; + static: boolean; +} + +export interface ObjectTypeProperty extends BaseNode { + type: "ObjectTypeProperty"; + key: Identifier | StringLiteral; + value: FlowType; + variance: Variance | null; + kind: "init" | "get" | "set"; + method: boolean; + optional: boolean; + proto: boolean; + static: boolean; +} + +export interface ObjectTypeSpreadProperty extends BaseNode { + type: "ObjectTypeSpreadProperty"; + argument: FlowType; +} + +export interface OpaqueType extends BaseNode { + type: "OpaqueType"; + id: Identifier; + typeParameters: TypeParameterDeclaration | null; + supertype: FlowType | null; + impltype: FlowType; +} + +export interface QualifiedTypeIdentifier extends BaseNode { + type: "QualifiedTypeIdentifier"; + id: Identifier; + qualification: Identifier | QualifiedTypeIdentifier; +} + +export interface StringLiteralTypeAnnotation extends BaseNode { + type: "StringLiteralTypeAnnotation"; + value: string; +} + +export interface StringTypeAnnotation extends BaseNode { + type: "StringTypeAnnotation"; +} + +export interface SymbolTypeAnnotation extends BaseNode { + type: "SymbolTypeAnnotation"; +} + +export interface ThisTypeAnnotation extends BaseNode { + type: "ThisTypeAnnotation"; +} + +export interface TupleTypeAnnotation extends BaseNode { + type: "TupleTypeAnnotation"; + types: FlowType[]; +} + +export interface TypeofTypeAnnotation extends BaseNode { + type: "TypeofTypeAnnotation"; + argument: FlowType; +} + +export interface TypeAlias extends BaseNode { + type: "TypeAlias"; + id: Identifier; + typeParameters: TypeParameterDeclaration | null; + right: FlowType; +} + +export interface TypeAnnotation extends BaseNode { + type: "TypeAnnotation"; + typeAnnotation: FlowType; +} + +export interface TypeCastExpression extends BaseNode { + type: "TypeCastExpression"; + expression: Expression; + typeAnnotation: TypeAnnotation; +} + +export interface TypeParameter extends BaseNode { + type: "TypeParameter"; + bound: TypeAnnotation | null; + default: FlowType | null; + variance: Variance | null; + name: string; +} + +export interface TypeParameterDeclaration extends BaseNode { + type: "TypeParameterDeclaration"; + params: TypeParameter[]; +} + +export interface TypeParameterInstantiation extends BaseNode { + type: "TypeParameterInstantiation"; + params: FlowType[]; +} + +export interface UnionTypeAnnotation extends BaseNode { + type: "UnionTypeAnnotation"; + types: FlowType[]; +} + +export interface Variance extends BaseNode { + type: "Variance"; + kind: "minus" | "plus"; +} + +export interface VoidTypeAnnotation extends BaseNode { + type: "VoidTypeAnnotation"; +} + +export interface EnumDeclaration extends BaseNode { + type: "EnumDeclaration"; + id: Identifier; + body: EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody; +} + +export interface EnumBooleanBody extends BaseNode { + type: "EnumBooleanBody"; + members: EnumBooleanMember[]; + explicitType: boolean; + hasUnknownMembers: boolean; +} + +export interface EnumNumberBody extends BaseNode { + type: "EnumNumberBody"; + members: EnumNumberMember[]; + explicitType: boolean; + hasUnknownMembers: boolean; +} + +export interface EnumStringBody extends BaseNode { + type: "EnumStringBody"; + members: (EnumStringMember | EnumDefaultedMember)[]; + explicitType: boolean; + hasUnknownMembers: boolean; +} + +export interface EnumSymbolBody extends BaseNode { + type: "EnumSymbolBody"; + members: EnumDefaultedMember[]; + hasUnknownMembers: boolean; +} + +export interface EnumBooleanMember extends BaseNode { + type: "EnumBooleanMember"; + id: Identifier; + init: BooleanLiteral; +} + +export interface EnumNumberMember extends BaseNode { + type: "EnumNumberMember"; + id: Identifier; + init: NumericLiteral; +} + +export interface EnumStringMember extends BaseNode { + type: "EnumStringMember"; + id: Identifier; + init: StringLiteral; +} + +export interface EnumDefaultedMember extends BaseNode { + type: "EnumDefaultedMember"; + id: Identifier; +} + +export interface IndexedAccessType extends BaseNode { + type: "IndexedAccessType"; + objectType: FlowType; + indexType: FlowType; +} + +export interface OptionalIndexedAccessType extends BaseNode { + type: "OptionalIndexedAccessType"; + objectType: FlowType; + indexType: FlowType; + optional: boolean; +} + +export interface JSXAttribute extends BaseNode { + type: "JSXAttribute"; + name: JSXIdentifier | JSXNamespacedName; + value: JSXElement | JSXFragment | StringLiteral | JSXExpressionContainer | null; +} + +export interface JSXClosingElement extends BaseNode { + type: "JSXClosingElement"; + name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName; +} + +export interface JSXElement extends BaseNode { + type: "JSXElement"; + openingElement: JSXOpeningElement; + closingElement: JSXClosingElement | null; + children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[]; + selfClosing: boolean | null; +} + +export interface JSXEmptyExpression extends BaseNode { + type: "JSXEmptyExpression"; +} + +export interface JSXExpressionContainer extends BaseNode { + type: "JSXExpressionContainer"; + expression: Expression | JSXEmptyExpression; +} + +export interface JSXSpreadChild extends BaseNode { + type: "JSXSpreadChild"; + expression: Expression; +} + +export interface JSXIdentifier extends BaseNode { + type: "JSXIdentifier"; + name: string; +} + +export interface JSXMemberExpression extends BaseNode { + type: "JSXMemberExpression"; + object: JSXMemberExpression | JSXIdentifier; + property: JSXIdentifier; +} + +export interface JSXNamespacedName extends BaseNode { + type: "JSXNamespacedName"; + namespace: JSXIdentifier; + name: JSXIdentifier; +} + +export interface JSXOpeningElement extends BaseNode { + type: "JSXOpeningElement"; + name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName; + attributes: (JSXAttribute | JSXSpreadAttribute)[]; + selfClosing: boolean; + typeArguments: TypeParameterInstantiation | null; + typeParameters: TSTypeParameterInstantiation | null; +} + +export interface JSXSpreadAttribute extends BaseNode { + type: "JSXSpreadAttribute"; + argument: Expression; +} + +export interface JSXText extends BaseNode { + type: "JSXText"; + value: string; +} + +export interface JSXFragment extends BaseNode { + type: "JSXFragment"; + openingFragment: JSXOpeningFragment; + closingFragment: JSXClosingFragment; + children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[]; +} + +export interface JSXOpeningFragment extends BaseNode { + type: "JSXOpeningFragment"; +} + +export interface JSXClosingFragment extends BaseNode { + type: "JSXClosingFragment"; +} + +export interface Noop extends BaseNode { + type: "Noop"; +} + +export interface Placeholder extends BaseNode { + type: "Placeholder"; + expectedNode: "Identifier" | "StringLiteral" | "Expression" | "Statement" | "Declaration" | "BlockStatement" | "ClassBody" | "Pattern"; + name: Identifier; + decorators: Decorator[] | null; + optional: boolean | null; + typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null; +} + +export interface V8IntrinsicIdentifier extends BaseNode { + type: "V8IntrinsicIdentifier"; + name: string; +} + +export interface ArgumentPlaceholder extends BaseNode { + type: "ArgumentPlaceholder"; +} + +export interface BindExpression extends BaseNode { + type: "BindExpression"; + object: Expression; + callee: Expression; +} + +export interface Decorator extends BaseNode { + type: "Decorator"; + expression: Expression; +} + +export interface DoExpression extends BaseNode { + type: "DoExpression"; + body: BlockStatement; + async: boolean; +} + +export interface ExportDefaultSpecifier extends BaseNode { + type: "ExportDefaultSpecifier"; + exported: Identifier; +} + +export interface RecordExpression extends BaseNode { + type: "RecordExpression"; + properties: (ObjectProperty | SpreadElement)[]; +} + +export interface TupleExpression extends BaseNode { + type: "TupleExpression"; + elements: (Expression | SpreadElement)[]; +} + +export interface DecimalLiteral extends BaseNode { + type: "DecimalLiteral"; + value: string; +} + +export interface ModuleExpression extends BaseNode { + type: "ModuleExpression"; + body: Program; +} + +export interface TopicReference extends BaseNode { + type: "TopicReference"; +} + +export interface PipelineTopicExpression extends BaseNode { + type: "PipelineTopicExpression"; + expression: Expression; +} + +export interface PipelineBareFunction extends BaseNode { + type: "PipelineBareFunction"; + callee: Expression; +} + +export interface PipelinePrimaryTopicReference extends BaseNode { + type: "PipelinePrimaryTopicReference"; +} + +export interface VoidPattern extends BaseNode { + type: "VoidPattern"; +} + +export interface TSParameterProperty extends BaseNode { + type: "TSParameterProperty"; + parameter: Identifier | AssignmentPattern; + accessibility: "public" | "private" | "protected" | null; + decorators: Decorator[] | null; + override: boolean | null; + readonly: boolean | null; +} + +export interface TSDeclareFunction extends BaseNode { + type: "TSDeclareFunction"; + id: Identifier | null; + typeParameters: TSTypeParameterDeclaration | Noop | null; + params: FunctionParameter[]; + returnType: TSTypeAnnotation | Noop | null; + async: boolean; + declare: boolean | null; + generator: boolean; +} + +export interface TSDeclareMethod extends BaseNode { + type: "TSDeclareMethod"; + decorators: Decorator[] | null; + key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression; + typeParameters: TSTypeParameterDeclaration | Noop | null; + params: (FunctionParameter | TSParameterProperty)[]; + returnType: TSTypeAnnotation | Noop | null; + abstract: boolean | null; + access: "public" | "private" | "protected" | null; + accessibility: "public" | "private" | "protected" | null; + async: boolean; + computed: boolean; + generator: boolean; + kind: "get" | "set" | "method" | "constructor"; + optional: boolean | null; + override: boolean; + static: boolean; +} + +export interface TSQualifiedName extends BaseNode { + type: "TSQualifiedName"; + left: TSEntityName; + right: Identifier; +} + +export interface TSCallSignatureDeclaration extends BaseNode { + type: "TSCallSignatureDeclaration"; + typeParameters: TSTypeParameterDeclaration | null; + parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[]; + typeAnnotation: TSTypeAnnotation | null; +} + +export interface TSConstructSignatureDeclaration extends BaseNode { + type: "TSConstructSignatureDeclaration"; + typeParameters: TSTypeParameterDeclaration | null; + parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[]; + typeAnnotation: TSTypeAnnotation | null; +} + +export interface TSPropertySignature extends BaseNode { + type: "TSPropertySignature"; + key: Expression; + typeAnnotation: TSTypeAnnotation | null; + computed: boolean; + kind: "get" | "set" | null; + optional: boolean | null; + readonly: boolean | null; +} + +export interface TSMethodSignature extends BaseNode { + type: "TSMethodSignature"; + key: Expression; + typeParameters: TSTypeParameterDeclaration | null; + parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[]; + typeAnnotation: TSTypeAnnotation | null; + computed: boolean; + kind: "method" | "get" | "set"; + optional: boolean | null; +} + +export interface TSIndexSignature extends BaseNode { + type: "TSIndexSignature"; + parameters: Identifier[]; + typeAnnotation: TSTypeAnnotation | null; + readonly: boolean | null; + static: boolean | null; +} + +export interface TSAnyKeyword extends BaseNode { + type: "TSAnyKeyword"; +} + +export interface TSBooleanKeyword extends BaseNode { + type: "TSBooleanKeyword"; +} + +export interface TSBigIntKeyword extends BaseNode { + type: "TSBigIntKeyword"; +} + +export interface TSIntrinsicKeyword extends BaseNode { + type: "TSIntrinsicKeyword"; +} + +export interface TSNeverKeyword extends BaseNode { + type: "TSNeverKeyword"; +} + +export interface TSNullKeyword extends BaseNode { + type: "TSNullKeyword"; +} + +export interface TSNumberKeyword extends BaseNode { + type: "TSNumberKeyword"; +} + +export interface TSObjectKeyword extends BaseNode { + type: "TSObjectKeyword"; +} + +export interface TSStringKeyword extends BaseNode { + type: "TSStringKeyword"; +} + +export interface TSSymbolKeyword extends BaseNode { + type: "TSSymbolKeyword"; +} + +export interface TSUndefinedKeyword extends BaseNode { + type: "TSUndefinedKeyword"; +} + +export interface TSUnknownKeyword extends BaseNode { + type: "TSUnknownKeyword"; +} + +export interface TSVoidKeyword extends BaseNode { + type: "TSVoidKeyword"; +} + +export interface TSThisType extends BaseNode { + type: "TSThisType"; +} + +export interface TSFunctionType extends BaseNode { + type: "TSFunctionType"; + typeParameters: TSTypeParameterDeclaration | null; + parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[]; + typeAnnotation: TSTypeAnnotation | null; +} + +export interface TSConstructorType extends BaseNode { + type: "TSConstructorType"; + typeParameters: TSTypeParameterDeclaration | null; + parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[]; + typeAnnotation: TSTypeAnnotation | null; + abstract: boolean | null; +} + +export interface TSTypeReference extends BaseNode { + type: "TSTypeReference"; + typeName: TSEntityName; + typeParameters: TSTypeParameterInstantiation | null; +} + +export interface TSTypePredicate extends BaseNode { + type: "TSTypePredicate"; + parameterName: Identifier | TSThisType; + typeAnnotation: TSTypeAnnotation | null; + asserts: boolean | null; +} + +export interface TSTypeQuery extends BaseNode { + type: "TSTypeQuery"; + exprName: TSEntityName | TSImportType; + typeParameters: TSTypeParameterInstantiation | null; +} + +export interface TSTypeLiteral extends BaseNode { + type: "TSTypeLiteral"; + members: TSTypeElement[]; +} + +export interface TSArrayType extends BaseNode { + type: "TSArrayType"; + elementType: TSType; +} + +export interface TSTupleType extends BaseNode { + type: "TSTupleType"; + elementTypes: (TSType | TSNamedTupleMember)[]; +} + +export interface TSOptionalType extends BaseNode { + type: "TSOptionalType"; + typeAnnotation: TSType; +} + +export interface TSRestType extends BaseNode { + type: "TSRestType"; + typeAnnotation: TSType; +} + +export interface TSNamedTupleMember extends BaseNode { + type: "TSNamedTupleMember"; + label: Identifier; + elementType: TSType; + optional: boolean; +} + +export interface TSUnionType extends BaseNode { + type: "TSUnionType"; + types: TSType[]; +} + +export interface TSIntersectionType extends BaseNode { + type: "TSIntersectionType"; + types: TSType[]; +} + +export interface TSConditionalType extends BaseNode { + type: "TSConditionalType"; + checkType: TSType; + extendsType: TSType; + trueType: TSType; + falseType: TSType; +} + +export interface TSInferType extends BaseNode { + type: "TSInferType"; + typeParameter: TSTypeParameter; +} + +export interface TSParenthesizedType extends BaseNode { + type: "TSParenthesizedType"; + typeAnnotation: TSType; +} + +export interface TSTypeOperator extends BaseNode { + type: "TSTypeOperator"; + typeAnnotation: TSType; + operator: string; +} + +export interface TSIndexedAccessType extends BaseNode { + type: "TSIndexedAccessType"; + objectType: TSType; + indexType: TSType; +} + +export interface TSMappedType extends BaseNode { + type: "TSMappedType"; + typeParameter: TSTypeParameter; + typeAnnotation: TSType | null; + nameType: TSType | null; + optional: true | false | "+" | "-" | null; + readonly: true | false | "+" | "-" | null; +} + +export interface TSTemplateLiteralType extends BaseNode { + type: "TSTemplateLiteralType"; + quasis: TemplateElement[]; + types: TSType[]; +} + +export interface TSLiteralType extends BaseNode { + type: "TSLiteralType"; + literal: NumericLiteral | StringLiteral | BooleanLiteral | BigIntLiteral | TemplateLiteral | UnaryExpression; +} + +export interface TSExpressionWithTypeArguments extends BaseNode { + type: "TSExpressionWithTypeArguments"; + expression: TSEntityName; + typeParameters: TSTypeParameterInstantiation | null; +} + +export interface TSInterfaceDeclaration extends BaseNode { + type: "TSInterfaceDeclaration"; + id: Identifier; + typeParameters: TSTypeParameterDeclaration | null; + extends: TSExpressionWithTypeArguments[] | null; + body: TSInterfaceBody; + declare: boolean | null; +} + +export interface TSInterfaceBody extends BaseNode { + type: "TSInterfaceBody"; + body: TSTypeElement[]; +} + +export interface TSTypeAliasDeclaration extends BaseNode { + type: "TSTypeAliasDeclaration"; + id: Identifier; + typeParameters: TSTypeParameterDeclaration | null; + typeAnnotation: TSType; + declare: boolean | null; +} + +export interface TSInstantiationExpression extends BaseNode { + type: "TSInstantiationExpression"; + expression: Expression; + typeParameters: TSTypeParameterInstantiation | null; +} + +export interface TSAsExpression extends BaseNode { + type: "TSAsExpression"; + expression: Expression; + typeAnnotation: TSType; +} + +export interface TSSatisfiesExpression extends BaseNode { + type: "TSSatisfiesExpression"; + expression: Expression; + typeAnnotation: TSType; +} + +export interface TSTypeAssertion extends BaseNode { + type: "TSTypeAssertion"; + typeAnnotation: TSType; + expression: Expression; +} + +export interface TSEnumBody extends BaseNode { + type: "TSEnumBody"; + members: TSEnumMember[]; +} + +export interface TSEnumDeclaration extends BaseNode { + type: "TSEnumDeclaration"; + id: Identifier; + members: TSEnumMember[]; + body: TSEnumBody | null; + const: boolean | null; + declare: boolean | null; + initializer: Expression | null; +} + +export interface TSEnumMember extends BaseNode { + type: "TSEnumMember"; + id: Identifier | StringLiteral; + initializer: Expression | null; +} + +export interface TSModuleDeclaration extends BaseNode { + type: "TSModuleDeclaration"; + id: Identifier | StringLiteral; + body: TSModuleBlock | TSModuleDeclaration; + declare: boolean | null; + global: boolean | null; + kind: "global" | "module" | "namespace"; +} + +export interface TSModuleBlock extends BaseNode { + type: "TSModuleBlock"; + body: Statement[]; +} + +export interface TSImportType extends BaseNode { + type: "TSImportType"; + argument: StringLiteral; + qualifier: TSEntityName | null; + typeParameters: TSTypeParameterInstantiation | null; + options: ObjectExpression | null; +} + +export interface TSImportEqualsDeclaration extends BaseNode { + type: "TSImportEqualsDeclaration"; + id: Identifier; + moduleReference: TSEntityName | TSExternalModuleReference; + importKind: "type" | "value" | null; + isExport: boolean; +} + +export interface TSExternalModuleReference extends BaseNode { + type: "TSExternalModuleReference"; + expression: StringLiteral; +} + +export interface TSNonNullExpression extends BaseNode { + type: "TSNonNullExpression"; + expression: Expression; +} + +export interface TSExportAssignment extends BaseNode { + type: "TSExportAssignment"; + expression: Expression; +} + +export interface TSNamespaceExportDeclaration extends BaseNode { + type: "TSNamespaceExportDeclaration"; + id: Identifier; +} + +export interface TSTypeAnnotation extends BaseNode { + type: "TSTypeAnnotation"; + typeAnnotation: TSType; +} + +export interface TSTypeParameterInstantiation extends BaseNode { + type: "TSTypeParameterInstantiation"; + params: TSType[]; +} + +export interface TSTypeParameterDeclaration extends BaseNode { + type: "TSTypeParameterDeclaration"; + params: TSTypeParameter[]; +} + +export interface TSTypeParameter extends BaseNode { + type: "TSTypeParameter"; + constraint: TSType | null; + default: TSType | null; + name: string; + const: boolean | null; + in: boolean | null; + out: boolean | null; +} + +/** + * @deprecated Use `NumericLiteral` + */ +export type NumberLiteral = NumericLiteral; + +/** + * @deprecated Use `RegExpLiteral` + */ +export type RegexLiteral = RegExpLiteral; + +/** + * @deprecated Use `RestElement` + */ +export type RestProperty = RestElement; + +/** + * @deprecated Use `SpreadElement` + */ +export type SpreadProperty = SpreadElement; + +export type Standardized = ArrayExpression | AssignmentExpression | BinaryExpression | InterpreterDirective | Directive | DirectiveLiteral | BlockStatement | BreakStatement | CallExpression | CatchClause | ConditionalExpression | ContinueStatement | DebuggerStatement | DoWhileStatement | EmptyStatement | ExpressionStatement | File | ForInStatement | ForStatement | FunctionDeclaration | FunctionExpression | Identifier | IfStatement | LabeledStatement | StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | RegExpLiteral | LogicalExpression | MemberExpression | NewExpression | Program | ObjectExpression | ObjectMethod | ObjectProperty | RestElement | ReturnStatement | SequenceExpression | ParenthesizedExpression | SwitchCase | SwitchStatement | ThisExpression | ThrowStatement | TryStatement | UnaryExpression | UpdateExpression | VariableDeclaration | VariableDeclarator | WhileStatement | WithStatement | AssignmentPattern | ArrayPattern | ArrowFunctionExpression | ClassBody | ClassExpression | ClassDeclaration | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ExportSpecifier | ForOfStatement | ImportDeclaration | ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportSpecifier | ImportExpression | MetaProperty | ClassMethod | ObjectPattern | SpreadElement | Super | TaggedTemplateExpression | TemplateElement | TemplateLiteral | YieldExpression | AwaitExpression | Import | BigIntLiteral | ExportNamespaceSpecifier | OptionalMemberExpression | OptionalCallExpression | ClassProperty | ClassAccessorProperty | ClassPrivateProperty | ClassPrivateMethod | PrivateName | StaticBlock | ImportAttribute; +export type Expression = ArrayExpression | AssignmentExpression | BinaryExpression | CallExpression | ConditionalExpression | FunctionExpression | Identifier | StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | RegExpLiteral | LogicalExpression | MemberExpression | NewExpression | ObjectExpression | SequenceExpression | ParenthesizedExpression | ThisExpression | UnaryExpression | UpdateExpression | ArrowFunctionExpression | ClassExpression | ImportExpression | MetaProperty | Super | TaggedTemplateExpression | TemplateLiteral | YieldExpression | AwaitExpression | Import | BigIntLiteral | OptionalMemberExpression | OptionalCallExpression | TypeCastExpression | JSXElement | JSXFragment | BindExpression | DoExpression | RecordExpression | TupleExpression | DecimalLiteral | ModuleExpression | TopicReference | PipelineTopicExpression | PipelineBareFunction | PipelinePrimaryTopicReference | TSInstantiationExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression; +export type Binary = BinaryExpression | LogicalExpression; +export type Scopable = BlockStatement | CatchClause | DoWhileStatement | ForInStatement | ForStatement | FunctionDeclaration | FunctionExpression | Program | ObjectMethod | SwitchStatement | WhileStatement | ArrowFunctionExpression | ClassExpression | ClassDeclaration | ForOfStatement | ClassMethod | ClassPrivateMethod | StaticBlock | TSModuleBlock; +export type BlockParent = BlockStatement | CatchClause | DoWhileStatement | ForInStatement | ForStatement | FunctionDeclaration | FunctionExpression | Program | ObjectMethod | SwitchStatement | WhileStatement | ArrowFunctionExpression | ForOfStatement | ClassMethod | ClassPrivateMethod | StaticBlock | TSModuleBlock; +export type Block = BlockStatement | Program | TSModuleBlock; +export type Statement = BlockStatement | BreakStatement | ContinueStatement | DebuggerStatement | DoWhileStatement | EmptyStatement | ExpressionStatement | ForInStatement | ForStatement | FunctionDeclaration | IfStatement | LabeledStatement | ReturnStatement | SwitchStatement | ThrowStatement | TryStatement | VariableDeclaration | WhileStatement | WithStatement | ClassDeclaration | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ForOfStatement | ImportDeclaration | DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareTypeAlias | DeclareOpaqueType | DeclareVariable | DeclareExportDeclaration | DeclareExportAllDeclaration | InterfaceDeclaration | OpaqueType | TypeAlias | EnumDeclaration | TSDeclareFunction | TSInterfaceDeclaration | TSTypeAliasDeclaration | TSEnumDeclaration | TSModuleDeclaration | TSImportEqualsDeclaration | TSExportAssignment | TSNamespaceExportDeclaration; +export type Terminatorless = BreakStatement | ContinueStatement | ReturnStatement | ThrowStatement | YieldExpression | AwaitExpression; +export type CompletionStatement = BreakStatement | ContinueStatement | ReturnStatement | ThrowStatement; +export type Conditional = ConditionalExpression | IfStatement; +export type Loop = DoWhileStatement | ForInStatement | ForStatement | WhileStatement | ForOfStatement; +export type While = DoWhileStatement | WhileStatement; +export type ExpressionWrapper = ExpressionStatement | ParenthesizedExpression | TypeCastExpression; +export type For = ForInStatement | ForStatement | ForOfStatement; +export type ForXStatement = ForInStatement | ForOfStatement; +export type Function = FunctionDeclaration | FunctionExpression | ObjectMethod | ArrowFunctionExpression | ClassMethod | ClassPrivateMethod; +export type FunctionParent = FunctionDeclaration | FunctionExpression | ObjectMethod | ArrowFunctionExpression | ClassMethod | ClassPrivateMethod | StaticBlock | TSModuleBlock; +export type Pureish = FunctionDeclaration | FunctionExpression | StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | RegExpLiteral | ArrowFunctionExpression | BigIntLiteral | DecimalLiteral; +export type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ImportDeclaration | DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareTypeAlias | DeclareOpaqueType | DeclareVariable | DeclareExportDeclaration | DeclareExportAllDeclaration | InterfaceDeclaration | OpaqueType | TypeAlias | EnumDeclaration | TSDeclareFunction | TSInterfaceDeclaration | TSTypeAliasDeclaration | TSEnumDeclaration | TSModuleDeclaration | TSImportEqualsDeclaration; +export type FunctionParameter = Identifier | RestElement | AssignmentPattern | ArrayPattern | ObjectPattern | VoidPattern; +export type PatternLike = Identifier | MemberExpression | RestElement | AssignmentPattern | ArrayPattern | ObjectPattern | VoidPattern | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression; +export type LVal = Identifier | MemberExpression | RestElement | AssignmentPattern | ArrayPattern | ObjectPattern | TSParameterProperty | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression; +export type TSEntityName = Identifier | TSQualifiedName; +export type Literal = StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | RegExpLiteral | TemplateLiteral | BigIntLiteral | DecimalLiteral; +export type Immutable = StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | BigIntLiteral | JSXAttribute | JSXClosingElement | JSXElement | JSXExpressionContainer | JSXSpreadChild | JSXOpeningElement | JSXText | JSXFragment | JSXOpeningFragment | JSXClosingFragment | DecimalLiteral; +export type UserWhitespacable = ObjectMethod | ObjectProperty | ObjectTypeInternalSlot | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeProperty | ObjectTypeSpreadProperty; +export type Method = ObjectMethod | ClassMethod | ClassPrivateMethod; +export type ObjectMember = ObjectMethod | ObjectProperty; +export type Property = ObjectProperty | ClassProperty | ClassAccessorProperty | ClassPrivateProperty; +export type UnaryLike = UnaryExpression | SpreadElement; +export type Pattern = AssignmentPattern | ArrayPattern | ObjectPattern | VoidPattern; +export type Class = ClassExpression | ClassDeclaration; +export type ImportOrExportDeclaration = ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ImportDeclaration; +export type ExportDeclaration = ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration; +export type ModuleSpecifier = ExportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportSpecifier | ExportNamespaceSpecifier | ExportDefaultSpecifier; +export type Accessor = ClassAccessorProperty; +export type Private = ClassPrivateProperty | ClassPrivateMethod | PrivateName; +export type Flow = AnyTypeAnnotation | ArrayTypeAnnotation | BooleanTypeAnnotation | BooleanLiteralTypeAnnotation | NullLiteralTypeAnnotation | ClassImplements | DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareTypeAlias | DeclareOpaqueType | DeclareVariable | DeclareExportDeclaration | DeclareExportAllDeclaration | DeclaredPredicate | ExistsTypeAnnotation | FunctionTypeAnnotation | FunctionTypeParam | GenericTypeAnnotation | InferredPredicate | InterfaceExtends | InterfaceDeclaration | InterfaceTypeAnnotation | IntersectionTypeAnnotation | MixedTypeAnnotation | EmptyTypeAnnotation | NullableTypeAnnotation | NumberLiteralTypeAnnotation | NumberTypeAnnotation | ObjectTypeAnnotation | ObjectTypeInternalSlot | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | QualifiedTypeIdentifier | StringLiteralTypeAnnotation | StringTypeAnnotation | SymbolTypeAnnotation | ThisTypeAnnotation | TupleTypeAnnotation | TypeofTypeAnnotation | TypeAlias | TypeAnnotation | TypeCastExpression | TypeParameter | TypeParameterDeclaration | TypeParameterInstantiation | UnionTypeAnnotation | Variance | VoidTypeAnnotation | EnumDeclaration | EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody | EnumBooleanMember | EnumNumberMember | EnumStringMember | EnumDefaultedMember | IndexedAccessType | OptionalIndexedAccessType; +export type FlowType = AnyTypeAnnotation | ArrayTypeAnnotation | BooleanTypeAnnotation | BooleanLiteralTypeAnnotation | NullLiteralTypeAnnotation | ExistsTypeAnnotation | FunctionTypeAnnotation | GenericTypeAnnotation | InterfaceTypeAnnotation | IntersectionTypeAnnotation | MixedTypeAnnotation | EmptyTypeAnnotation | NullableTypeAnnotation | NumberLiteralTypeAnnotation | NumberTypeAnnotation | ObjectTypeAnnotation | StringLiteralTypeAnnotation | StringTypeAnnotation | SymbolTypeAnnotation | ThisTypeAnnotation | TupleTypeAnnotation | TypeofTypeAnnotation | UnionTypeAnnotation | VoidTypeAnnotation | IndexedAccessType | OptionalIndexedAccessType; +export type FlowBaseAnnotation = AnyTypeAnnotation | BooleanTypeAnnotation | NullLiteralTypeAnnotation | MixedTypeAnnotation | EmptyTypeAnnotation | NumberTypeAnnotation | StringTypeAnnotation | SymbolTypeAnnotation | ThisTypeAnnotation | VoidTypeAnnotation; +export type FlowDeclaration = DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareTypeAlias | DeclareOpaqueType | DeclareVariable | DeclareExportDeclaration | DeclareExportAllDeclaration | InterfaceDeclaration | OpaqueType | TypeAlias; +export type FlowPredicate = DeclaredPredicate | InferredPredicate; +export type EnumBody = EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody; +export type EnumMember = EnumBooleanMember | EnumNumberMember | EnumStringMember | EnumDefaultedMember; +export type JSX = JSXAttribute | JSXClosingElement | JSXElement | JSXEmptyExpression | JSXExpressionContainer | JSXSpreadChild | JSXIdentifier | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement | JSXSpreadAttribute | JSXText | JSXFragment | JSXOpeningFragment | JSXClosingFragment; +export type Miscellaneous = Noop | Placeholder | V8IntrinsicIdentifier; +export type TypeScript = TSParameterProperty | TSDeclareFunction | TSDeclareMethod | TSQualifiedName | TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSPropertySignature | TSMethodSignature | TSIndexSignature | TSAnyKeyword | TSBooleanKeyword | TSBigIntKeyword | TSIntrinsicKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSThisType | TSFunctionType | TSConstructorType | TSTypeReference | TSTypePredicate | TSTypeQuery | TSTypeLiteral | TSArrayType | TSTupleType | TSOptionalType | TSRestType | TSNamedTupleMember | TSUnionType | TSIntersectionType | TSConditionalType | TSInferType | TSParenthesizedType | TSTypeOperator | TSIndexedAccessType | TSMappedType | TSTemplateLiteralType | TSLiteralType | TSExpressionWithTypeArguments | TSInterfaceDeclaration | TSInterfaceBody | TSTypeAliasDeclaration | TSInstantiationExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSEnumBody | TSEnumDeclaration | TSEnumMember | TSModuleDeclaration | TSModuleBlock | TSImportType | TSImportEqualsDeclaration | TSExternalModuleReference | TSNonNullExpression | TSExportAssignment | TSNamespaceExportDeclaration | TSTypeAnnotation | TSTypeParameterInstantiation | TSTypeParameterDeclaration | TSTypeParameter; +export type TSTypeElement = TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSPropertySignature | TSMethodSignature | TSIndexSignature; +export type TSType = TSAnyKeyword | TSBooleanKeyword | TSBigIntKeyword | TSIntrinsicKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSThisType | TSFunctionType | TSConstructorType | TSTypeReference | TSTypePredicate | TSTypeQuery | TSTypeLiteral | TSArrayType | TSTupleType | TSOptionalType | TSRestType | TSUnionType | TSIntersectionType | TSConditionalType | TSInferType | TSParenthesizedType | TSTypeOperator | TSIndexedAccessType | TSMappedType | TSTemplateLiteralType | TSLiteralType | TSExpressionWithTypeArguments | TSImportType; +export type TSBaseType = TSAnyKeyword | TSBooleanKeyword | TSBigIntKeyword | TSIntrinsicKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSThisType | TSTemplateLiteralType | TSLiteralType; +export type ModuleDeclaration = ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ImportDeclaration; + +export interface Aliases { + Standardized: Standardized; + Expression: Expression; + Binary: Binary; + Scopable: Scopable; + BlockParent: BlockParent; + Block: Block; + Statement: Statement; + Terminatorless: Terminatorless; + CompletionStatement: CompletionStatement; + Conditional: Conditional; + Loop: Loop; + While: While; + ExpressionWrapper: ExpressionWrapper; + For: For; + ForXStatement: ForXStatement; + Function: Function; + FunctionParent: FunctionParent; + Pureish: Pureish; + Declaration: Declaration; + FunctionParameter: FunctionParameter; + PatternLike: PatternLike; + LVal: LVal; + TSEntityName: TSEntityName; + Literal: Literal; + Immutable: Immutable; + UserWhitespacable: UserWhitespacable; + Method: Method; + ObjectMember: ObjectMember; + Property: Property; + UnaryLike: UnaryLike; + Pattern: Pattern; + Class: Class; + ImportOrExportDeclaration: ImportOrExportDeclaration; + ExportDeclaration: ExportDeclaration; + ModuleSpecifier: ModuleSpecifier; + Accessor: Accessor; + Private: Private; + Flow: Flow; + FlowType: FlowType; + FlowBaseAnnotation: FlowBaseAnnotation; + FlowDeclaration: FlowDeclaration; + FlowPredicate: FlowPredicate; + EnumBody: EnumBody; + EnumMember: EnumMember; + JSX: JSX; + Miscellaneous: Miscellaneous; + TypeScript: TypeScript; + TSTypeElement: TSTypeElement; + TSType: TSType; + TSBaseType: TSBaseType; + ModuleDeclaration: ModuleDeclaration; +} + +export function arrayExpression(elements?: (null | Expression | SpreadElement)[]): ArrayExpression; +export function assignmentExpression(operator: string, left: LVal | OptionalMemberExpression, right: Expression): AssignmentExpression; +export function binaryExpression(operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=" | "|>", left: Expression | PrivateName, right: Expression): BinaryExpression; +export function interpreterDirective(value: string): InterpreterDirective; +export function directive(value: DirectiveLiteral): Directive; +export function directiveLiteral(value: string): DirectiveLiteral; +export function blockStatement(body: Statement[], directives?: Directive[]): BlockStatement; +export function breakStatement(label?: Identifier | null): BreakStatement; +export function callExpression(callee: Expression | Super | V8IntrinsicIdentifier, _arguments: (Expression | SpreadElement | ArgumentPlaceholder)[]): CallExpression; +export function catchClause(param: Identifier | ArrayPattern | ObjectPattern | null | undefined, body: BlockStatement): CatchClause; +export function conditionalExpression(test: Expression, consequent: Expression, alternate: Expression): ConditionalExpression; +export function continueStatement(label?: Identifier | null): ContinueStatement; +export function debuggerStatement(): DebuggerStatement; +export function doWhileStatement(test: Expression, body: Statement): DoWhileStatement; +export function emptyStatement(): EmptyStatement; +export function expressionStatement(expression: Expression): ExpressionStatement; +export function file(program: Program, comments?: (CommentBlock | CommentLine)[] | null, tokens?: any[] | null): File; +export function forInStatement(left: VariableDeclaration | LVal, right: Expression, body: Statement): ForInStatement; +export function forStatement(init: VariableDeclaration | Expression | null | undefined, test: Expression | null | undefined, update: Expression | null | undefined, body: Statement): ForStatement; +export function functionDeclaration(id: Identifier | null | undefined, params: FunctionParameter[], body: BlockStatement, generator?: boolean, async?: boolean): FunctionDeclaration; +export function functionExpression(id: Identifier | null | undefined, params: FunctionParameter[], body: BlockStatement, generator?: boolean, async?: boolean): FunctionExpression; +export function identifier(name: string): Identifier; +export function ifStatement(test: Expression, consequent: Statement, alternate?: Statement | null): IfStatement; +export function labeledStatement(label: Identifier, body: Statement): LabeledStatement; +export function stringLiteral(value: string): StringLiteral; +export function numericLiteral(value: number): NumericLiteral; +export function nullLiteral(): NullLiteral; +export function booleanLiteral(value: boolean): BooleanLiteral; +export function regExpLiteral(pattern: string, flags?: string): RegExpLiteral; +export function logicalExpression(operator: "||" | "&&" | "??", left: Expression, right: Expression): LogicalExpression; +export function memberExpression(object: Expression | Super, property: Expression | Identifier | PrivateName, computed?: boolean, optional?: boolean | null): MemberExpression; +export function newExpression(callee: Expression | Super | V8IntrinsicIdentifier, _arguments: (Expression | SpreadElement | ArgumentPlaceholder)[]): NewExpression; +export function program(body: Statement[], directives?: Directive[], sourceType?: "script" | "module", interpreter?: InterpreterDirective | null): Program; +export function objectExpression(properties: (ObjectMethod | ObjectProperty | SpreadElement)[]): ObjectExpression; +export function objectMethod(kind: "method" | "get" | "set" | undefined, key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral, params: FunctionParameter[], body: BlockStatement, computed?: boolean, generator?: boolean, async?: boolean): ObjectMethod; +export function objectProperty(key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral | DecimalLiteral | PrivateName, value: Expression | PatternLike, computed?: boolean, shorthand?: boolean, decorators?: Decorator[] | null): ObjectProperty; +export function restElement(argument: Identifier | ArrayPattern | ObjectPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression | RestElement | AssignmentPattern): RestElement; +export function returnStatement(argument?: Expression | null): ReturnStatement; +export function sequenceExpression(expressions: Expression[]): SequenceExpression; +export function parenthesizedExpression(expression: Expression): ParenthesizedExpression; +export function switchCase(test: Expression | null | undefined, consequent: Statement[]): SwitchCase; +export function switchStatement(discriminant: Expression, cases: SwitchCase[]): SwitchStatement; +export function thisExpression(): ThisExpression; +export function throwStatement(argument: Expression): ThrowStatement; +export function tryStatement(block: BlockStatement, handler?: CatchClause | null, finalizer?: BlockStatement | null): TryStatement; +export function unaryExpression(operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof", argument: Expression, prefix?: boolean): UnaryExpression; +export function updateExpression(operator: "++" | "--", argument: Expression, prefix?: boolean): UpdateExpression; +export function variableDeclaration(kind: "var" | "let" | "const" | "using" | "await using", declarations: VariableDeclarator[]): VariableDeclaration; +export function variableDeclarator(id: LVal | VoidPattern, init?: Expression | null): VariableDeclarator; +export function whileStatement(test: Expression, body: Statement): WhileStatement; +export function withStatement(object: Expression, body: Statement): WithStatement; +export function assignmentPattern(left: Identifier | ObjectPattern | ArrayPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression, right: Expression): AssignmentPattern; +export function arrayPattern(elements: (null | PatternLike)[]): ArrayPattern; +export function arrowFunctionExpression(params: FunctionParameter[], body: BlockStatement | Expression, async?: boolean): ArrowFunctionExpression; +export function classBody(body: (ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty | ClassAccessorProperty | TSDeclareMethod | TSIndexSignature | StaticBlock)[]): ClassBody; +export function classExpression(id: Identifier | null | undefined, superClass: Expression | null | undefined, body: ClassBody, decorators?: Decorator[] | null): ClassExpression; +export function classDeclaration(id: Identifier | null | undefined, superClass: Expression | null | undefined, body: ClassBody, decorators?: Decorator[] | null): ClassDeclaration; +export function exportAllDeclaration(source: StringLiteral, attributes?: ImportAttribute[] | null): ExportAllDeclaration; +export function exportDefaultDeclaration(declaration: TSDeclareFunction | FunctionDeclaration | ClassDeclaration | Expression): ExportDefaultDeclaration; +export function exportNamedDeclaration(declaration?: Declaration | null, specifiers?: (ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier)[], source?: StringLiteral | null, attributes?: ImportAttribute[] | null): ExportNamedDeclaration; +export function exportSpecifier(local: Identifier, exported: Identifier | StringLiteral): ExportSpecifier; +export function forOfStatement(left: VariableDeclaration | LVal, right: Expression, body: Statement, _await?: boolean): ForOfStatement; +export function importDeclaration(specifiers: (ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier)[], source: StringLiteral, attributes?: ImportAttribute[] | null): ImportDeclaration; +export function importDefaultSpecifier(local: Identifier): ImportDefaultSpecifier; +export function importNamespaceSpecifier(local: Identifier): ImportNamespaceSpecifier; +export function importSpecifier(local: Identifier, imported: Identifier | StringLiteral): ImportSpecifier; +export function importExpression(source: Expression, options?: Expression | null): ImportExpression; +export function metaProperty(meta: Identifier, property: Identifier): MetaProperty; +export function classMethod(kind: "get" | "set" | "method" | "constructor" | undefined, key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, params: (FunctionParameter | TSParameterProperty)[], body: BlockStatement, computed?: boolean, _static?: boolean, generator?: boolean, async?: boolean): ClassMethod; +export function objectPattern(properties: (RestElement | ObjectProperty)[]): ObjectPattern; +export function spreadElement(argument: Expression): SpreadElement; +declare function _super(): Super; +export { _super as super} +export function taggedTemplateExpression(tag: Expression, quasi: TemplateLiteral): TaggedTemplateExpression; +export function templateElement(value: { raw: string, cooked?: string }, tail?: boolean): TemplateElement; +export function templateLiteral(quasis: TemplateElement[], expressions: (Expression | TSType)[]): TemplateLiteral; +export function yieldExpression(argument?: Expression | null, delegate?: boolean): YieldExpression; +export function awaitExpression(argument: Expression): AwaitExpression; +declare function _import(): Import; +export { _import as import} +export function bigIntLiteral(value: string): BigIntLiteral; +export function exportNamespaceSpecifier(exported: Identifier): ExportNamespaceSpecifier; +export function optionalMemberExpression(object: Expression, property: Expression | Identifier, computed: boolean | undefined, optional: boolean): OptionalMemberExpression; +export function optionalCallExpression(callee: Expression, _arguments: (Expression | SpreadElement | ArgumentPlaceholder)[], optional: boolean): OptionalCallExpression; +export function classProperty(key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Decorator[] | null, computed?: boolean, _static?: boolean): ClassProperty; +export function classAccessorProperty(key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression | PrivateName, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Decorator[] | null, computed?: boolean, _static?: boolean): ClassAccessorProperty; +export function classPrivateProperty(key: PrivateName, value?: Expression | null, decorators?: Decorator[] | null, _static?: boolean): ClassPrivateProperty; +export function classPrivateMethod(kind: "get" | "set" | "method" | undefined, key: PrivateName, params: (FunctionParameter | TSParameterProperty)[], body: BlockStatement, _static?: boolean): ClassPrivateMethod; +export function privateName(id: Identifier): PrivateName; +export function staticBlock(body: Statement[]): StaticBlock; +export function importAttribute(key: Identifier | StringLiteral, value: StringLiteral): ImportAttribute; +export function anyTypeAnnotation(): AnyTypeAnnotation; +export function arrayTypeAnnotation(elementType: FlowType): ArrayTypeAnnotation; +export function booleanTypeAnnotation(): BooleanTypeAnnotation; +export function booleanLiteralTypeAnnotation(value: boolean): BooleanLiteralTypeAnnotation; +export function nullLiteralTypeAnnotation(): NullLiteralTypeAnnotation; +export function classImplements(id: Identifier, typeParameters?: TypeParameterInstantiation | null): ClassImplements; +export function declareClass(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: InterfaceExtends[] | null | undefined, body: ObjectTypeAnnotation): DeclareClass; +export function declareFunction(id: Identifier): DeclareFunction; +export function declareInterface(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: InterfaceExtends[] | null | undefined, body: ObjectTypeAnnotation): DeclareInterface; +export function declareModule(id: Identifier | StringLiteral, body: BlockStatement, kind?: "CommonJS" | "ES" | null): DeclareModule; +export function declareModuleExports(typeAnnotation: TypeAnnotation): DeclareModuleExports; +export function declareTypeAlias(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, right: FlowType): DeclareTypeAlias; +export function declareOpaqueType(id: Identifier, typeParameters?: TypeParameterDeclaration | null, supertype?: FlowType | null): DeclareOpaqueType; +export function declareVariable(id: Identifier): DeclareVariable; +export function declareExportDeclaration(declaration?: Flow | null, specifiers?: (ExportSpecifier | ExportNamespaceSpecifier)[] | null, source?: StringLiteral | null, attributes?: ImportAttribute[] | null): DeclareExportDeclaration; +export function declareExportAllDeclaration(source: StringLiteral, attributes?: ImportAttribute[] | null): DeclareExportAllDeclaration; +export function declaredPredicate(value: Flow): DeclaredPredicate; +export function existsTypeAnnotation(): ExistsTypeAnnotation; +export function functionTypeAnnotation(typeParameters: TypeParameterDeclaration | null | undefined, params: FunctionTypeParam[], rest: FunctionTypeParam | null | undefined, returnType: FlowType): FunctionTypeAnnotation; +export function functionTypeParam(name: Identifier | null | undefined, typeAnnotation: FlowType): FunctionTypeParam; +export function genericTypeAnnotation(id: Identifier | QualifiedTypeIdentifier, typeParameters?: TypeParameterInstantiation | null): GenericTypeAnnotation; +export function inferredPredicate(): InferredPredicate; +export function interfaceExtends(id: Identifier | QualifiedTypeIdentifier, typeParameters?: TypeParameterInstantiation | null): InterfaceExtends; +export function interfaceDeclaration(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: InterfaceExtends[] | null | undefined, body: ObjectTypeAnnotation): InterfaceDeclaration; +export function interfaceTypeAnnotation(_extends: InterfaceExtends[] | null | undefined, body: ObjectTypeAnnotation): InterfaceTypeAnnotation; +export function intersectionTypeAnnotation(types: FlowType[]): IntersectionTypeAnnotation; +export function mixedTypeAnnotation(): MixedTypeAnnotation; +export function emptyTypeAnnotation(): EmptyTypeAnnotation; +export function nullableTypeAnnotation(typeAnnotation: FlowType): NullableTypeAnnotation; +export function numberLiteralTypeAnnotation(value: number): NumberLiteralTypeAnnotation; +export function numberTypeAnnotation(): NumberTypeAnnotation; +export function objectTypeAnnotation(properties: (ObjectTypeProperty | ObjectTypeSpreadProperty)[], indexers?: ObjectTypeIndexer[], callProperties?: ObjectTypeCallProperty[], internalSlots?: ObjectTypeInternalSlot[], exact?: boolean): ObjectTypeAnnotation; +export function objectTypeInternalSlot(id: Identifier, value: FlowType, optional: boolean, _static: boolean, method: boolean): ObjectTypeInternalSlot; +export function objectTypeCallProperty(value: FlowType): ObjectTypeCallProperty; +export function objectTypeIndexer(id: Identifier | null | undefined, key: FlowType, value: FlowType, variance?: Variance | null): ObjectTypeIndexer; +export function objectTypeProperty(key: Identifier | StringLiteral, value: FlowType, variance?: Variance | null): ObjectTypeProperty; +export function objectTypeSpreadProperty(argument: FlowType): ObjectTypeSpreadProperty; +export function opaqueType(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, supertype: FlowType | null | undefined, impltype: FlowType): OpaqueType; +export function qualifiedTypeIdentifier(id: Identifier, qualification: Identifier | QualifiedTypeIdentifier): QualifiedTypeIdentifier; +export function stringLiteralTypeAnnotation(value: string): StringLiteralTypeAnnotation; +export function stringTypeAnnotation(): StringTypeAnnotation; +export function symbolTypeAnnotation(): SymbolTypeAnnotation; +export function thisTypeAnnotation(): ThisTypeAnnotation; +export function tupleTypeAnnotation(types: FlowType[]): TupleTypeAnnotation; +export function typeofTypeAnnotation(argument: FlowType): TypeofTypeAnnotation; +export function typeAlias(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, right: FlowType): TypeAlias; +export function typeAnnotation(typeAnnotation: FlowType): TypeAnnotation; +export function typeCastExpression(expression: Expression, typeAnnotation: TypeAnnotation): TypeCastExpression; +export function typeParameter(bound?: TypeAnnotation | null, _default?: FlowType | null, variance?: Variance | null): TypeParameter; +export function typeParameterDeclaration(params: TypeParameter[]): TypeParameterDeclaration; +export function typeParameterInstantiation(params: FlowType[]): TypeParameterInstantiation; +export function unionTypeAnnotation(types: FlowType[]): UnionTypeAnnotation; +export function variance(kind: "minus" | "plus"): Variance; +export function voidTypeAnnotation(): VoidTypeAnnotation; +export function enumDeclaration(id: Identifier, body: EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody): EnumDeclaration; +export function enumBooleanBody(members: EnumBooleanMember[]): EnumBooleanBody; +export function enumNumberBody(members: EnumNumberMember[]): EnumNumberBody; +export function enumStringBody(members: (EnumStringMember | EnumDefaultedMember)[]): EnumStringBody; +export function enumSymbolBody(members: EnumDefaultedMember[]): EnumSymbolBody; +export function enumBooleanMember(id: Identifier): EnumBooleanMember; +export function enumNumberMember(id: Identifier, init: NumericLiteral): EnumNumberMember; +export function enumStringMember(id: Identifier, init: StringLiteral): EnumStringMember; +export function enumDefaultedMember(id: Identifier): EnumDefaultedMember; +export function indexedAccessType(objectType: FlowType, indexType: FlowType): IndexedAccessType; +export function optionalIndexedAccessType(objectType: FlowType, indexType: FlowType): OptionalIndexedAccessType; +export function jsxAttribute(name: JSXIdentifier | JSXNamespacedName, value?: JSXElement | JSXFragment | StringLiteral | JSXExpressionContainer | null): JSXAttribute; +export function jsxClosingElement(name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName): JSXClosingElement; +export function jsxElement(openingElement: JSXOpeningElement, closingElement: JSXClosingElement | null | undefined, children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[], selfClosing?: boolean | null): JSXElement; +export function jsxEmptyExpression(): JSXEmptyExpression; +export function jsxExpressionContainer(expression: Expression | JSXEmptyExpression): JSXExpressionContainer; +export function jsxSpreadChild(expression: Expression): JSXSpreadChild; +export function jsxIdentifier(name: string): JSXIdentifier; +export function jsxMemberExpression(object: JSXMemberExpression | JSXIdentifier, property: JSXIdentifier): JSXMemberExpression; +export function jsxNamespacedName(namespace: JSXIdentifier, name: JSXIdentifier): JSXNamespacedName; +export function jsxOpeningElement(name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName, attributes: (JSXAttribute | JSXSpreadAttribute)[], selfClosing?: boolean): JSXOpeningElement; +export function jsxSpreadAttribute(argument: Expression): JSXSpreadAttribute; +export function jsxText(value: string): JSXText; +export function jsxFragment(openingFragment: JSXOpeningFragment, closingFragment: JSXClosingFragment, children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[]): JSXFragment; +export function jsxOpeningFragment(): JSXOpeningFragment; +export function jsxClosingFragment(): JSXClosingFragment; +export function noop(): Noop; +export function placeholder(expectedNode: "Identifier" | "StringLiteral" | "Expression" | "Statement" | "Declaration" | "BlockStatement" | "ClassBody" | "Pattern", name: Identifier): Placeholder; +export function v8IntrinsicIdentifier(name: string): V8IntrinsicIdentifier; +export function argumentPlaceholder(): ArgumentPlaceholder; +export function bindExpression(object: Expression, callee: Expression): BindExpression; +export function decorator(expression: Expression): Decorator; +export function doExpression(body: BlockStatement, async?: boolean): DoExpression; +export function exportDefaultSpecifier(exported: Identifier): ExportDefaultSpecifier; +export function recordExpression(properties: (ObjectProperty | SpreadElement)[]): RecordExpression; +export function tupleExpression(elements?: (Expression | SpreadElement)[]): TupleExpression; +export function decimalLiteral(value: string): DecimalLiteral; +export function moduleExpression(body: Program): ModuleExpression; +export function topicReference(): TopicReference; +export function pipelineTopicExpression(expression: Expression): PipelineTopicExpression; +export function pipelineBareFunction(callee: Expression): PipelineBareFunction; +export function pipelinePrimaryTopicReference(): PipelinePrimaryTopicReference; +export function voidPattern(): VoidPattern; +export function tsParameterProperty(parameter: Identifier | AssignmentPattern): TSParameterProperty; +export function tsDeclareFunction(id: Identifier | null | undefined, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: FunctionParameter[], returnType?: TSTypeAnnotation | Noop | null): TSDeclareFunction; +export function tsDeclareMethod(decorators: Decorator[] | null | undefined, key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: (FunctionParameter | TSParameterProperty)[], returnType?: TSTypeAnnotation | Noop | null): TSDeclareMethod; +export function tsQualifiedName(left: TSEntityName, right: Identifier): TSQualifiedName; +export function tsCallSignatureDeclaration(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSCallSignatureDeclaration; +export function tsConstructSignatureDeclaration(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSConstructSignatureDeclaration; +export function tsPropertySignature(key: Expression, typeAnnotation?: TSTypeAnnotation | null): TSPropertySignature; +export function tsMethodSignature(key: Expression, typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSMethodSignature; +export function tsIndexSignature(parameters: Identifier[], typeAnnotation?: TSTypeAnnotation | null): TSIndexSignature; +export function tsAnyKeyword(): TSAnyKeyword; +export function tsBooleanKeyword(): TSBooleanKeyword; +export function tsBigIntKeyword(): TSBigIntKeyword; +export function tsIntrinsicKeyword(): TSIntrinsicKeyword; +export function tsNeverKeyword(): TSNeverKeyword; +export function tsNullKeyword(): TSNullKeyword; +export function tsNumberKeyword(): TSNumberKeyword; +export function tsObjectKeyword(): TSObjectKeyword; +export function tsStringKeyword(): TSStringKeyword; +export function tsSymbolKeyword(): TSSymbolKeyword; +export function tsUndefinedKeyword(): TSUndefinedKeyword; +export function tsUnknownKeyword(): TSUnknownKeyword; +export function tsVoidKeyword(): TSVoidKeyword; +export function tsThisType(): TSThisType; +export function tsFunctionType(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSFunctionType; +export function tsConstructorType(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSConstructorType; +export function tsTypeReference(typeName: TSEntityName, typeParameters?: TSTypeParameterInstantiation | null): TSTypeReference; +export function tsTypePredicate(parameterName: Identifier | TSThisType, typeAnnotation?: TSTypeAnnotation | null, asserts?: boolean | null): TSTypePredicate; +export function tsTypeQuery(exprName: TSEntityName | TSImportType, typeParameters?: TSTypeParameterInstantiation | null): TSTypeQuery; +export function tsTypeLiteral(members: TSTypeElement[]): TSTypeLiteral; +export function tsArrayType(elementType: TSType): TSArrayType; +export function tsTupleType(elementTypes: (TSType | TSNamedTupleMember)[]): TSTupleType; +export function tsOptionalType(typeAnnotation: TSType): TSOptionalType; +export function tsRestType(typeAnnotation: TSType): TSRestType; +export function tsNamedTupleMember(label: Identifier, elementType: TSType, optional?: boolean): TSNamedTupleMember; +export function tsUnionType(types: TSType[]): TSUnionType; +export function tsIntersectionType(types: TSType[]): TSIntersectionType; +export function tsConditionalType(checkType: TSType, extendsType: TSType, trueType: TSType, falseType: TSType): TSConditionalType; +export function tsInferType(typeParameter: TSTypeParameter): TSInferType; +export function tsParenthesizedType(typeAnnotation: TSType): TSParenthesizedType; +export function tsTypeOperator(typeAnnotation: TSType, operator?: string): TSTypeOperator; +export function tsIndexedAccessType(objectType: TSType, indexType: TSType): TSIndexedAccessType; +export function tsMappedType(typeParameter: TSTypeParameter, typeAnnotation?: TSType | null, nameType?: TSType | null): TSMappedType; +export function tsTemplateLiteralType(quasis: TemplateElement[], types: TSType[]): TSTemplateLiteralType; +export function tsLiteralType(literal: NumericLiteral | StringLiteral | BooleanLiteral | BigIntLiteral | TemplateLiteral | UnaryExpression): TSLiteralType; +export function tsExpressionWithTypeArguments(expression: TSEntityName, typeParameters?: TSTypeParameterInstantiation | null): TSExpressionWithTypeArguments; +export function tsInterfaceDeclaration(id: Identifier, typeParameters: TSTypeParameterDeclaration | null | undefined, _extends: TSExpressionWithTypeArguments[] | null | undefined, body: TSInterfaceBody): TSInterfaceDeclaration; +export function tsInterfaceBody(body: TSTypeElement[]): TSInterfaceBody; +export function tsTypeAliasDeclaration(id: Identifier, typeParameters: TSTypeParameterDeclaration | null | undefined, typeAnnotation: TSType): TSTypeAliasDeclaration; +export function tsInstantiationExpression(expression: Expression, typeParameters?: TSTypeParameterInstantiation | null): TSInstantiationExpression; +export function tsAsExpression(expression: Expression, typeAnnotation: TSType): TSAsExpression; +export function tsSatisfiesExpression(expression: Expression, typeAnnotation: TSType): TSSatisfiesExpression; +export function tsTypeAssertion(typeAnnotation: TSType, expression: Expression): TSTypeAssertion; +export function tsEnumBody(members: TSEnumMember[]): TSEnumBody; +export function tsEnumDeclaration(id: Identifier, members: TSEnumMember[]): TSEnumDeclaration; +export function tsEnumMember(id: Identifier | StringLiteral, initializer?: Expression | null): TSEnumMember; +export function tsModuleDeclaration(id: Identifier | StringLiteral, body: TSModuleBlock | TSModuleDeclaration): TSModuleDeclaration; +export function tsModuleBlock(body: Statement[]): TSModuleBlock; +export function tsImportType(argument: StringLiteral, qualifier?: TSEntityName | null, typeParameters?: TSTypeParameterInstantiation | null): TSImportType; +export function tsImportEqualsDeclaration(id: Identifier, moduleReference: TSEntityName | TSExternalModuleReference): TSImportEqualsDeclaration; +export function tsExternalModuleReference(expression: StringLiteral): TSExternalModuleReference; +export function tsNonNullExpression(expression: Expression): TSNonNullExpression; +export function tsExportAssignment(expression: Expression): TSExportAssignment; +export function tsNamespaceExportDeclaration(id: Identifier): TSNamespaceExportDeclaration; +export function tsTypeAnnotation(typeAnnotation: TSType): TSTypeAnnotation; +export function tsTypeParameterInstantiation(params: TSType[]): TSTypeParameterInstantiation; +export function tsTypeParameterDeclaration(params: TSTypeParameter[]): TSTypeParameterDeclaration; +export function tsTypeParameter(constraint: TSType | null | undefined, _default: TSType | null | undefined, name: string): TSTypeParameter; +export function isAccessor(node: object | null | undefined, opts?: object | null): node is Accessor; +export function assertAccessor(node: object | null | undefined, opts?: object | null): void; +export function isAnyTypeAnnotation(node: object | null | undefined, opts?: object | null): node is AnyTypeAnnotation; +export function assertAnyTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isArgumentPlaceholder(node: object | null | undefined, opts?: object | null): node is ArgumentPlaceholder; +export function assertArgumentPlaceholder(node: object | null | undefined, opts?: object | null): void; +export function isArrayExpression(node: object | null | undefined, opts?: object | null): node is ArrayExpression; +export function assertArrayExpression(node: object | null | undefined, opts?: object | null): void; +export function isArrayPattern(node: object | null | undefined, opts?: object | null): node is ArrayPattern; +export function assertArrayPattern(node: object | null | undefined, opts?: object | null): void; +export function isArrayTypeAnnotation(node: object | null | undefined, opts?: object | null): node is ArrayTypeAnnotation; +export function assertArrayTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isArrowFunctionExpression(node: object | null | undefined, opts?: object | null): node is ArrowFunctionExpression; +export function assertArrowFunctionExpression(node: object | null | undefined, opts?: object | null): void; +export function isAssignmentExpression(node: object | null | undefined, opts?: object | null): node is AssignmentExpression; +export function assertAssignmentExpression(node: object | null | undefined, opts?: object | null): void; +export function isAssignmentPattern(node: object | null | undefined, opts?: object | null): node is AssignmentPattern; +export function assertAssignmentPattern(node: object | null | undefined, opts?: object | null): void; +export function isAwaitExpression(node: object | null | undefined, opts?: object | null): node is AwaitExpression; +export function assertAwaitExpression(node: object | null | undefined, opts?: object | null): void; +export function isBigIntLiteral(node: object | null | undefined, opts?: object | null): node is BigIntLiteral; +export function assertBigIntLiteral(node: object | null | undefined, opts?: object | null): void; +export function isBinary(node: object | null | undefined, opts?: object | null): node is Binary; +export function assertBinary(node: object | null | undefined, opts?: object | null): void; +export function isBinaryExpression(node: object | null | undefined, opts?: object | null): node is BinaryExpression; +export function assertBinaryExpression(node: object | null | undefined, opts?: object | null): void; +export function isBindExpression(node: object | null | undefined, opts?: object | null): node is BindExpression; +export function assertBindExpression(node: object | null | undefined, opts?: object | null): void; +export function isBlock(node: object | null | undefined, opts?: object | null): node is Block; +export function assertBlock(node: object | null | undefined, opts?: object | null): void; +export function isBlockParent(node: object | null | undefined, opts?: object | null): node is BlockParent; +export function assertBlockParent(node: object | null | undefined, opts?: object | null): void; +export function isBlockStatement(node: object | null | undefined, opts?: object | null): node is BlockStatement; +export function assertBlockStatement(node: object | null | undefined, opts?: object | null): void; +export function isBooleanLiteral(node: object | null | undefined, opts?: object | null): node is BooleanLiteral; +export function assertBooleanLiteral(node: object | null | undefined, opts?: object | null): void; +export function isBooleanLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): node is BooleanLiteralTypeAnnotation; +export function assertBooleanLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isBooleanTypeAnnotation(node: object | null | undefined, opts?: object | null): node is BooleanTypeAnnotation; +export function assertBooleanTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isBreakStatement(node: object | null | undefined, opts?: object | null): node is BreakStatement; +export function assertBreakStatement(node: object | null | undefined, opts?: object | null): void; +export function isCallExpression(node: object | null | undefined, opts?: object | null): node is CallExpression; +export function assertCallExpression(node: object | null | undefined, opts?: object | null): void; +export function isCatchClause(node: object | null | undefined, opts?: object | null): node is CatchClause; +export function assertCatchClause(node: object | null | undefined, opts?: object | null): void; +export function isClass(node: object | null | undefined, opts?: object | null): node is Class; +export function assertClass(node: object | null | undefined, opts?: object | null): void; +export function isClassAccessorProperty(node: object | null | undefined, opts?: object | null): node is ClassAccessorProperty; +export function assertClassAccessorProperty(node: object | null | undefined, opts?: object | null): void; +export function isClassBody(node: object | null | undefined, opts?: object | null): node is ClassBody; +export function assertClassBody(node: object | null | undefined, opts?: object | null): void; +export function isClassDeclaration(node: object | null | undefined, opts?: object | null): node is ClassDeclaration; +export function assertClassDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isClassExpression(node: object | null | undefined, opts?: object | null): node is ClassExpression; +export function assertClassExpression(node: object | null | undefined, opts?: object | null): void; +export function isClassImplements(node: object | null | undefined, opts?: object | null): node is ClassImplements; +export function assertClassImplements(node: object | null | undefined, opts?: object | null): void; +export function isClassMethod(node: object | null | undefined, opts?: object | null): node is ClassMethod; +export function assertClassMethod(node: object | null | undefined, opts?: object | null): void; +export function isClassPrivateMethod(node: object | null | undefined, opts?: object | null): node is ClassPrivateMethod; +export function assertClassPrivateMethod(node: object | null | undefined, opts?: object | null): void; +export function isClassPrivateProperty(node: object | null | undefined, opts?: object | null): node is ClassPrivateProperty; +export function assertClassPrivateProperty(node: object | null | undefined, opts?: object | null): void; +export function isClassProperty(node: object | null | undefined, opts?: object | null): node is ClassProperty; +export function assertClassProperty(node: object | null | undefined, opts?: object | null): void; +export function isCompletionStatement(node: object | null | undefined, opts?: object | null): node is CompletionStatement; +export function assertCompletionStatement(node: object | null | undefined, opts?: object | null): void; +export function isConditional(node: object | null | undefined, opts?: object | null): node is Conditional; +export function assertConditional(node: object | null | undefined, opts?: object | null): void; +export function isConditionalExpression(node: object | null | undefined, opts?: object | null): node is ConditionalExpression; +export function assertConditionalExpression(node: object | null | undefined, opts?: object | null): void; +export function isContinueStatement(node: object | null | undefined, opts?: object | null): node is ContinueStatement; +export function assertContinueStatement(node: object | null | undefined, opts?: object | null): void; +export function isDebuggerStatement(node: object | null | undefined, opts?: object | null): node is DebuggerStatement; +export function assertDebuggerStatement(node: object | null | undefined, opts?: object | null): void; +export function isDecimalLiteral(node: object | null | undefined, opts?: object | null): node is DecimalLiteral; +export function assertDecimalLiteral(node: object | null | undefined, opts?: object | null): void; +export function isDeclaration(node: object | null | undefined, opts?: object | null): node is Declaration; +export function assertDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isDeclareClass(node: object | null | undefined, opts?: object | null): node is DeclareClass; +export function assertDeclareClass(node: object | null | undefined, opts?: object | null): void; +export function isDeclareExportAllDeclaration(node: object | null | undefined, opts?: object | null): node is DeclareExportAllDeclaration; +export function assertDeclareExportAllDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isDeclareExportDeclaration(node: object | null | undefined, opts?: object | null): node is DeclareExportDeclaration; +export function assertDeclareExportDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isDeclareFunction(node: object | null | undefined, opts?: object | null): node is DeclareFunction; +export function assertDeclareFunction(node: object | null | undefined, opts?: object | null): void; +export function isDeclareInterface(node: object | null | undefined, opts?: object | null): node is DeclareInterface; +export function assertDeclareInterface(node: object | null | undefined, opts?: object | null): void; +export function isDeclareModule(node: object | null | undefined, opts?: object | null): node is DeclareModule; +export function assertDeclareModule(node: object | null | undefined, opts?: object | null): void; +export function isDeclareModuleExports(node: object | null | undefined, opts?: object | null): node is DeclareModuleExports; +export function assertDeclareModuleExports(node: object | null | undefined, opts?: object | null): void; +export function isDeclareOpaqueType(node: object | null | undefined, opts?: object | null): node is DeclareOpaqueType; +export function assertDeclareOpaqueType(node: object | null | undefined, opts?: object | null): void; +export function isDeclareTypeAlias(node: object | null | undefined, opts?: object | null): node is DeclareTypeAlias; +export function assertDeclareTypeAlias(node: object | null | undefined, opts?: object | null): void; +export function isDeclareVariable(node: object | null | undefined, opts?: object | null): node is DeclareVariable; +export function assertDeclareVariable(node: object | null | undefined, opts?: object | null): void; +export function isDeclaredPredicate(node: object | null | undefined, opts?: object | null): node is DeclaredPredicate; +export function assertDeclaredPredicate(node: object | null | undefined, opts?: object | null): void; +export function isDecorator(node: object | null | undefined, opts?: object | null): node is Decorator; +export function assertDecorator(node: object | null | undefined, opts?: object | null): void; +export function isDirective(node: object | null | undefined, opts?: object | null): node is Directive; +export function assertDirective(node: object | null | undefined, opts?: object | null): void; +export function isDirectiveLiteral(node: object | null | undefined, opts?: object | null): node is DirectiveLiteral; +export function assertDirectiveLiteral(node: object | null | undefined, opts?: object | null): void; +export function isDoExpression(node: object | null | undefined, opts?: object | null): node is DoExpression; +export function assertDoExpression(node: object | null | undefined, opts?: object | null): void; +export function isDoWhileStatement(node: object | null | undefined, opts?: object | null): node is DoWhileStatement; +export function assertDoWhileStatement(node: object | null | undefined, opts?: object | null): void; +export function isEmptyStatement(node: object | null | undefined, opts?: object | null): node is EmptyStatement; +export function assertEmptyStatement(node: object | null | undefined, opts?: object | null): void; +export function isEmptyTypeAnnotation(node: object | null | undefined, opts?: object | null): node is EmptyTypeAnnotation; +export function assertEmptyTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isEnumBody(node: object | null | undefined, opts?: object | null): node is EnumBody; +export function assertEnumBody(node: object | null | undefined, opts?: object | null): void; +export function isEnumBooleanBody(node: object | null | undefined, opts?: object | null): node is EnumBooleanBody; +export function assertEnumBooleanBody(node: object | null | undefined, opts?: object | null): void; +export function isEnumBooleanMember(node: object | null | undefined, opts?: object | null): node is EnumBooleanMember; +export function assertEnumBooleanMember(node: object | null | undefined, opts?: object | null): void; +export function isEnumDeclaration(node: object | null | undefined, opts?: object | null): node is EnumDeclaration; +export function assertEnumDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isEnumDefaultedMember(node: object | null | undefined, opts?: object | null): node is EnumDefaultedMember; +export function assertEnumDefaultedMember(node: object | null | undefined, opts?: object | null): void; +export function isEnumMember(node: object | null | undefined, opts?: object | null): node is EnumMember; +export function assertEnumMember(node: object | null | undefined, opts?: object | null): void; +export function isEnumNumberBody(node: object | null | undefined, opts?: object | null): node is EnumNumberBody; +export function assertEnumNumberBody(node: object | null | undefined, opts?: object | null): void; +export function isEnumNumberMember(node: object | null | undefined, opts?: object | null): node is EnumNumberMember; +export function assertEnumNumberMember(node: object | null | undefined, opts?: object | null): void; +export function isEnumStringBody(node: object | null | undefined, opts?: object | null): node is EnumStringBody; +export function assertEnumStringBody(node: object | null | undefined, opts?: object | null): void; +export function isEnumStringMember(node: object | null | undefined, opts?: object | null): node is EnumStringMember; +export function assertEnumStringMember(node: object | null | undefined, opts?: object | null): void; +export function isEnumSymbolBody(node: object | null | undefined, opts?: object | null): node is EnumSymbolBody; +export function assertEnumSymbolBody(node: object | null | undefined, opts?: object | null): void; +export function isExistsTypeAnnotation(node: object | null | undefined, opts?: object | null): node is ExistsTypeAnnotation; +export function assertExistsTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isExportAllDeclaration(node: object | null | undefined, opts?: object | null): node is ExportAllDeclaration; +export function assertExportAllDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isExportDeclaration(node: object | null | undefined, opts?: object | null): node is ExportDeclaration; +export function assertExportDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isExportDefaultDeclaration(node: object | null | undefined, opts?: object | null): node is ExportDefaultDeclaration; +export function assertExportDefaultDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isExportDefaultSpecifier(node: object | null | undefined, opts?: object | null): node is ExportDefaultSpecifier; +export function assertExportDefaultSpecifier(node: object | null | undefined, opts?: object | null): void; +export function isExportNamedDeclaration(node: object | null | undefined, opts?: object | null): node is ExportNamedDeclaration; +export function assertExportNamedDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isExportNamespaceSpecifier(node: object | null | undefined, opts?: object | null): node is ExportNamespaceSpecifier; +export function assertExportNamespaceSpecifier(node: object | null | undefined, opts?: object | null): void; +export function isExportSpecifier(node: object | null | undefined, opts?: object | null): node is ExportSpecifier; +export function assertExportSpecifier(node: object | null | undefined, opts?: object | null): void; +export function isExpression(node: object | null | undefined, opts?: object | null): node is Expression; +export function assertExpression(node: object | null | undefined, opts?: object | null): void; +export function isExpressionStatement(node: object | null | undefined, opts?: object | null): node is ExpressionStatement; +export function assertExpressionStatement(node: object | null | undefined, opts?: object | null): void; +export function isExpressionWrapper(node: object | null | undefined, opts?: object | null): node is ExpressionWrapper; +export function assertExpressionWrapper(node: object | null | undefined, opts?: object | null): void; +export function isFile(node: object | null | undefined, opts?: object | null): node is File; +export function assertFile(node: object | null | undefined, opts?: object | null): void; +export function isFlow(node: object | null | undefined, opts?: object | null): node is Flow; +export function assertFlow(node: object | null | undefined, opts?: object | null): void; +export function isFlowBaseAnnotation(node: object | null | undefined, opts?: object | null): node is FlowBaseAnnotation; +export function assertFlowBaseAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isFlowDeclaration(node: object | null | undefined, opts?: object | null): node is FlowDeclaration; +export function assertFlowDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isFlowPredicate(node: object | null | undefined, opts?: object | null): node is FlowPredicate; +export function assertFlowPredicate(node: object | null | undefined, opts?: object | null): void; +export function isFlowType(node: object | null | undefined, opts?: object | null): node is FlowType; +export function assertFlowType(node: object | null | undefined, opts?: object | null): void; +export function isFor(node: object | null | undefined, opts?: object | null): node is For; +export function assertFor(node: object | null | undefined, opts?: object | null): void; +export function isForInStatement(node: object | null | undefined, opts?: object | null): node is ForInStatement; +export function assertForInStatement(node: object | null | undefined, opts?: object | null): void; +export function isForOfStatement(node: object | null | undefined, opts?: object | null): node is ForOfStatement; +export function assertForOfStatement(node: object | null | undefined, opts?: object | null): void; +export function isForStatement(node: object | null | undefined, opts?: object | null): node is ForStatement; +export function assertForStatement(node: object | null | undefined, opts?: object | null): void; +export function isForXStatement(node: object | null | undefined, opts?: object | null): node is ForXStatement; +export function assertForXStatement(node: object | null | undefined, opts?: object | null): void; +export function isFunction(node: object | null | undefined, opts?: object | null): node is Function; +export function assertFunction(node: object | null | undefined, opts?: object | null): void; +export function isFunctionDeclaration(node: object | null | undefined, opts?: object | null): node is FunctionDeclaration; +export function assertFunctionDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isFunctionExpression(node: object | null | undefined, opts?: object | null): node is FunctionExpression; +export function assertFunctionExpression(node: object | null | undefined, opts?: object | null): void; +export function isFunctionParameter(node: object | null | undefined, opts?: object | null): node is FunctionParameter; +export function assertFunctionParameter(node: object | null | undefined, opts?: object | null): void; +export function isFunctionParent(node: object | null | undefined, opts?: object | null): node is FunctionParent; +export function assertFunctionParent(node: object | null | undefined, opts?: object | null): void; +export function isFunctionTypeAnnotation(node: object | null | undefined, opts?: object | null): node is FunctionTypeAnnotation; +export function assertFunctionTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isFunctionTypeParam(node: object | null | undefined, opts?: object | null): node is FunctionTypeParam; +export function assertFunctionTypeParam(node: object | null | undefined, opts?: object | null): void; +export function isGenericTypeAnnotation(node: object | null | undefined, opts?: object | null): node is GenericTypeAnnotation; +export function assertGenericTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isIdentifier(node: object | null | undefined, opts?: object | null): node is Identifier; +export function assertIdentifier(node: object | null | undefined, opts?: object | null): void; +export function isIfStatement(node: object | null | undefined, opts?: object | null): node is IfStatement; +export function assertIfStatement(node: object | null | undefined, opts?: object | null): void; +export function isImmutable(node: object | null | undefined, opts?: object | null): node is Immutable; +export function assertImmutable(node: object | null | undefined, opts?: object | null): void; +export function isImport(node: object | null | undefined, opts?: object | null): node is Import; +export function assertImport(node: object | null | undefined, opts?: object | null): void; +export function isImportAttribute(node: object | null | undefined, opts?: object | null): node is ImportAttribute; +export function assertImportAttribute(node: object | null | undefined, opts?: object | null): void; +export function isImportDeclaration(node: object | null | undefined, opts?: object | null): node is ImportDeclaration; +export function assertImportDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isImportDefaultSpecifier(node: object | null | undefined, opts?: object | null): node is ImportDefaultSpecifier; +export function assertImportDefaultSpecifier(node: object | null | undefined, opts?: object | null): void; +export function isImportExpression(node: object | null | undefined, opts?: object | null): node is ImportExpression; +export function assertImportExpression(node: object | null | undefined, opts?: object | null): void; +export function isImportNamespaceSpecifier(node: object | null | undefined, opts?: object | null): node is ImportNamespaceSpecifier; +export function assertImportNamespaceSpecifier(node: object | null | undefined, opts?: object | null): void; +export function isImportOrExportDeclaration(node: object | null | undefined, opts?: object | null): node is ImportOrExportDeclaration; +export function assertImportOrExportDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isImportSpecifier(node: object | null | undefined, opts?: object | null): node is ImportSpecifier; +export function assertImportSpecifier(node: object | null | undefined, opts?: object | null): void; +export function isIndexedAccessType(node: object | null | undefined, opts?: object | null): node is IndexedAccessType; +export function assertIndexedAccessType(node: object | null | undefined, opts?: object | null): void; +export function isInferredPredicate(node: object | null | undefined, opts?: object | null): node is InferredPredicate; +export function assertInferredPredicate(node: object | null | undefined, opts?: object | null): void; +export function isInterfaceDeclaration(node: object | null | undefined, opts?: object | null): node is InterfaceDeclaration; +export function assertInterfaceDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isInterfaceExtends(node: object | null | undefined, opts?: object | null): node is InterfaceExtends; +export function assertInterfaceExtends(node: object | null | undefined, opts?: object | null): void; +export function isInterfaceTypeAnnotation(node: object | null | undefined, opts?: object | null): node is InterfaceTypeAnnotation; +export function assertInterfaceTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isInterpreterDirective(node: object | null | undefined, opts?: object | null): node is InterpreterDirective; +export function assertInterpreterDirective(node: object | null | undefined, opts?: object | null): void; +export function isIntersectionTypeAnnotation(node: object | null | undefined, opts?: object | null): node is IntersectionTypeAnnotation; +export function assertIntersectionTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isJSX(node: object | null | undefined, opts?: object | null): node is JSX; +export function assertJSX(node: object | null | undefined, opts?: object | null): void; +export function isJSXAttribute(node: object | null | undefined, opts?: object | null): node is JSXAttribute; +export function assertJSXAttribute(node: object | null | undefined, opts?: object | null): void; +export function isJSXClosingElement(node: object | null | undefined, opts?: object | null): node is JSXClosingElement; +export function assertJSXClosingElement(node: object | null | undefined, opts?: object | null): void; +export function isJSXClosingFragment(node: object | null | undefined, opts?: object | null): node is JSXClosingFragment; +export function assertJSXClosingFragment(node: object | null | undefined, opts?: object | null): void; +export function isJSXElement(node: object | null | undefined, opts?: object | null): node is JSXElement; +export function assertJSXElement(node: object | null | undefined, opts?: object | null): void; +export function isJSXEmptyExpression(node: object | null | undefined, opts?: object | null): node is JSXEmptyExpression; +export function assertJSXEmptyExpression(node: object | null | undefined, opts?: object | null): void; +export function isJSXExpressionContainer(node: object | null | undefined, opts?: object | null): node is JSXExpressionContainer; +export function assertJSXExpressionContainer(node: object | null | undefined, opts?: object | null): void; +export function isJSXFragment(node: object | null | undefined, opts?: object | null): node is JSXFragment; +export function assertJSXFragment(node: object | null | undefined, opts?: object | null): void; +export function isJSXIdentifier(node: object | null | undefined, opts?: object | null): node is JSXIdentifier; +export function assertJSXIdentifier(node: object | null | undefined, opts?: object | null): void; +export function isJSXMemberExpression(node: object | null | undefined, opts?: object | null): node is JSXMemberExpression; +export function assertJSXMemberExpression(node: object | null | undefined, opts?: object | null): void; +export function isJSXNamespacedName(node: object | null | undefined, opts?: object | null): node is JSXNamespacedName; +export function assertJSXNamespacedName(node: object | null | undefined, opts?: object | null): void; +export function isJSXOpeningElement(node: object | null | undefined, opts?: object | null): node is JSXOpeningElement; +export function assertJSXOpeningElement(node: object | null | undefined, opts?: object | null): void; +export function isJSXOpeningFragment(node: object | null | undefined, opts?: object | null): node is JSXOpeningFragment; +export function assertJSXOpeningFragment(node: object | null | undefined, opts?: object | null): void; +export function isJSXSpreadAttribute(node: object | null | undefined, opts?: object | null): node is JSXSpreadAttribute; +export function assertJSXSpreadAttribute(node: object | null | undefined, opts?: object | null): void; +export function isJSXSpreadChild(node: object | null | undefined, opts?: object | null): node is JSXSpreadChild; +export function assertJSXSpreadChild(node: object | null | undefined, opts?: object | null): void; +export function isJSXText(node: object | null | undefined, opts?: object | null): node is JSXText; +export function assertJSXText(node: object | null | undefined, opts?: object | null): void; +export function isLVal(node: object | null | undefined, opts?: object | null): node is LVal; +export function assertLVal(node: object | null | undefined, opts?: object | null): void; +export function isLabeledStatement(node: object | null | undefined, opts?: object | null): node is LabeledStatement; +export function assertLabeledStatement(node: object | null | undefined, opts?: object | null): void; +export function isLiteral(node: object | null | undefined, opts?: object | null): node is Literal; +export function assertLiteral(node: object | null | undefined, opts?: object | null): void; +export function isLogicalExpression(node: object | null | undefined, opts?: object | null): node is LogicalExpression; +export function assertLogicalExpression(node: object | null | undefined, opts?: object | null): void; +export function isLoop(node: object | null | undefined, opts?: object | null): node is Loop; +export function assertLoop(node: object | null | undefined, opts?: object | null): void; +export function isMemberExpression(node: object | null | undefined, opts?: object | null): node is MemberExpression; +export function assertMemberExpression(node: object | null | undefined, opts?: object | null): void; +export function isMetaProperty(node: object | null | undefined, opts?: object | null): node is MetaProperty; +export function assertMetaProperty(node: object | null | undefined, opts?: object | null): void; +export function isMethod(node: object | null | undefined, opts?: object | null): node is Method; +export function assertMethod(node: object | null | undefined, opts?: object | null): void; +export function isMiscellaneous(node: object | null | undefined, opts?: object | null): node is Miscellaneous; +export function assertMiscellaneous(node: object | null | undefined, opts?: object | null): void; +export function isMixedTypeAnnotation(node: object | null | undefined, opts?: object | null): node is MixedTypeAnnotation; +export function assertMixedTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isModuleDeclaration(node: object | null | undefined, opts?: object | null): node is ModuleDeclaration; +export function assertModuleDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isModuleExpression(node: object | null | undefined, opts?: object | null): node is ModuleExpression; +export function assertModuleExpression(node: object | null | undefined, opts?: object | null): void; +export function isModuleSpecifier(node: object | null | undefined, opts?: object | null): node is ModuleSpecifier; +export function assertModuleSpecifier(node: object | null | undefined, opts?: object | null): void; +export function isNewExpression(node: object | null | undefined, opts?: object | null): node is NewExpression; +export function assertNewExpression(node: object | null | undefined, opts?: object | null): void; +export function isNoop(node: object | null | undefined, opts?: object | null): node is Noop; +export function assertNoop(node: object | null | undefined, opts?: object | null): void; +export function isNullLiteral(node: object | null | undefined, opts?: object | null): node is NullLiteral; +export function assertNullLiteral(node: object | null | undefined, opts?: object | null): void; +export function isNullLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): node is NullLiteralTypeAnnotation; +export function assertNullLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isNullableTypeAnnotation(node: object | null | undefined, opts?: object | null): node is NullableTypeAnnotation; +export function assertNullableTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +/** @deprecated Use `isNumericLiteral` */ +export function isNumberLiteral(node: object | null | undefined, opts?: object | null): node is NumericLiteral; +/** @deprecated Use `assertNumericLiteral` */ +export function assertNumberLiteral(node: object | null | undefined, opts?: object | null): void; +export function isNumberLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): node is NumberLiteralTypeAnnotation; +export function assertNumberLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isNumberTypeAnnotation(node: object | null | undefined, opts?: object | null): node is NumberTypeAnnotation; +export function assertNumberTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isNumericLiteral(node: object | null | undefined, opts?: object | null): node is NumericLiteral; +export function assertNumericLiteral(node: object | null | undefined, opts?: object | null): void; +export function isObjectExpression(node: object | null | undefined, opts?: object | null): node is ObjectExpression; +export function assertObjectExpression(node: object | null | undefined, opts?: object | null): void; +export function isObjectMember(node: object | null | undefined, opts?: object | null): node is ObjectMember; +export function assertObjectMember(node: object | null | undefined, opts?: object | null): void; +export function isObjectMethod(node: object | null | undefined, opts?: object | null): node is ObjectMethod; +export function assertObjectMethod(node: object | null | undefined, opts?: object | null): void; +export function isObjectPattern(node: object | null | undefined, opts?: object | null): node is ObjectPattern; +export function assertObjectPattern(node: object | null | undefined, opts?: object | null): void; +export function isObjectProperty(node: object | null | undefined, opts?: object | null): node is ObjectProperty; +export function assertObjectProperty(node: object | null | undefined, opts?: object | null): void; +export function isObjectTypeAnnotation(node: object | null | undefined, opts?: object | null): node is ObjectTypeAnnotation; +export function assertObjectTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isObjectTypeCallProperty(node: object | null | undefined, opts?: object | null): node is ObjectTypeCallProperty; +export function assertObjectTypeCallProperty(node: object | null | undefined, opts?: object | null): void; +export function isObjectTypeIndexer(node: object | null | undefined, opts?: object | null): node is ObjectTypeIndexer; +export function assertObjectTypeIndexer(node: object | null | undefined, opts?: object | null): void; +export function isObjectTypeInternalSlot(node: object | null | undefined, opts?: object | null): node is ObjectTypeInternalSlot; +export function assertObjectTypeInternalSlot(node: object | null | undefined, opts?: object | null): void; +export function isObjectTypeProperty(node: object | null | undefined, opts?: object | null): node is ObjectTypeProperty; +export function assertObjectTypeProperty(node: object | null | undefined, opts?: object | null): void; +export function isObjectTypeSpreadProperty(node: object | null | undefined, opts?: object | null): node is ObjectTypeSpreadProperty; +export function assertObjectTypeSpreadProperty(node: object | null | undefined, opts?: object | null): void; +export function isOpaqueType(node: object | null | undefined, opts?: object | null): node is OpaqueType; +export function assertOpaqueType(node: object | null | undefined, opts?: object | null): void; +export function isOptionalCallExpression(node: object | null | undefined, opts?: object | null): node is OptionalCallExpression; +export function assertOptionalCallExpression(node: object | null | undefined, opts?: object | null): void; +export function isOptionalIndexedAccessType(node: object | null | undefined, opts?: object | null): node is OptionalIndexedAccessType; +export function assertOptionalIndexedAccessType(node: object | null | undefined, opts?: object | null): void; +export function isOptionalMemberExpression(node: object | null | undefined, opts?: object | null): node is OptionalMemberExpression; +export function assertOptionalMemberExpression(node: object | null | undefined, opts?: object | null): void; +export function isParenthesizedExpression(node: object | null | undefined, opts?: object | null): node is ParenthesizedExpression; +export function assertParenthesizedExpression(node: object | null | undefined, opts?: object | null): void; +export function isPattern(node: object | null | undefined, opts?: object | null): node is Pattern; +export function assertPattern(node: object | null | undefined, opts?: object | null): void; +export function isPatternLike(node: object | null | undefined, opts?: object | null): node is PatternLike; +export function assertPatternLike(node: object | null | undefined, opts?: object | null): void; +export function isPipelineBareFunction(node: object | null | undefined, opts?: object | null): node is PipelineBareFunction; +export function assertPipelineBareFunction(node: object | null | undefined, opts?: object | null): void; +export function isPipelinePrimaryTopicReference(node: object | null | undefined, opts?: object | null): node is PipelinePrimaryTopicReference; +export function assertPipelinePrimaryTopicReference(node: object | null | undefined, opts?: object | null): void; +export function isPipelineTopicExpression(node: object | null | undefined, opts?: object | null): node is PipelineTopicExpression; +export function assertPipelineTopicExpression(node: object | null | undefined, opts?: object | null): void; +export function isPlaceholder(node: object | null | undefined, opts?: object | null): node is Placeholder; +export function assertPlaceholder(node: object | null | undefined, opts?: object | null): void; +export function isPrivate(node: object | null | undefined, opts?: object | null): node is Private; +export function assertPrivate(node: object | null | undefined, opts?: object | null): void; +export function isPrivateName(node: object | null | undefined, opts?: object | null): node is PrivateName; +export function assertPrivateName(node: object | null | undefined, opts?: object | null): void; +export function isProgram(node: object | null | undefined, opts?: object | null): node is Program; +export function assertProgram(node: object | null | undefined, opts?: object | null): void; +export function isProperty(node: object | null | undefined, opts?: object | null): node is Property; +export function assertProperty(node: object | null | undefined, opts?: object | null): void; +export function isPureish(node: object | null | undefined, opts?: object | null): node is Pureish; +export function assertPureish(node: object | null | undefined, opts?: object | null): void; +export function isQualifiedTypeIdentifier(node: object | null | undefined, opts?: object | null): node is QualifiedTypeIdentifier; +export function assertQualifiedTypeIdentifier(node: object | null | undefined, opts?: object | null): void; +export function isRecordExpression(node: object | null | undefined, opts?: object | null): node is RecordExpression; +export function assertRecordExpression(node: object | null | undefined, opts?: object | null): void; +export function isRegExpLiteral(node: object | null | undefined, opts?: object | null): node is RegExpLiteral; +export function assertRegExpLiteral(node: object | null | undefined, opts?: object | null): void; +/** @deprecated Use `isRegExpLiteral` */ +export function isRegexLiteral(node: object | null | undefined, opts?: object | null): node is RegExpLiteral; +/** @deprecated Use `assertRegExpLiteral` */ +export function assertRegexLiteral(node: object | null | undefined, opts?: object | null): void; +export function isRestElement(node: object | null | undefined, opts?: object | null): node is RestElement; +export function assertRestElement(node: object | null | undefined, opts?: object | null): void; +/** @deprecated Use `isRestElement` */ +export function isRestProperty(node: object | null | undefined, opts?: object | null): node is RestElement; +/** @deprecated Use `assertRestElement` */ +export function assertRestProperty(node: object | null | undefined, opts?: object | null): void; +export function isReturnStatement(node: object | null | undefined, opts?: object | null): node is ReturnStatement; +export function assertReturnStatement(node: object | null | undefined, opts?: object | null): void; +export function isScopable(node: object | null | undefined, opts?: object | null): node is Scopable; +export function assertScopable(node: object | null | undefined, opts?: object | null): void; +export function isSequenceExpression(node: object | null | undefined, opts?: object | null): node is SequenceExpression; +export function assertSequenceExpression(node: object | null | undefined, opts?: object | null): void; +export function isSpreadElement(node: object | null | undefined, opts?: object | null): node is SpreadElement; +export function assertSpreadElement(node: object | null | undefined, opts?: object | null): void; +/** @deprecated Use `isSpreadElement` */ +export function isSpreadProperty(node: object | null | undefined, opts?: object | null): node is SpreadElement; +/** @deprecated Use `assertSpreadElement` */ +export function assertSpreadProperty(node: object | null | undefined, opts?: object | null): void; +export function isStandardized(node: object | null | undefined, opts?: object | null): node is Standardized; +export function assertStandardized(node: object | null | undefined, opts?: object | null): void; +export function isStatement(node: object | null | undefined, opts?: object | null): node is Statement; +export function assertStatement(node: object | null | undefined, opts?: object | null): void; +export function isStaticBlock(node: object | null | undefined, opts?: object | null): node is StaticBlock; +export function assertStaticBlock(node: object | null | undefined, opts?: object | null): void; +export function isStringLiteral(node: object | null | undefined, opts?: object | null): node is StringLiteral; +export function assertStringLiteral(node: object | null | undefined, opts?: object | null): void; +export function isStringLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): node is StringLiteralTypeAnnotation; +export function assertStringLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isStringTypeAnnotation(node: object | null | undefined, opts?: object | null): node is StringTypeAnnotation; +export function assertStringTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isSuper(node: object | null | undefined, opts?: object | null): node is Super; +export function assertSuper(node: object | null | undefined, opts?: object | null): void; +export function isSwitchCase(node: object | null | undefined, opts?: object | null): node is SwitchCase; +export function assertSwitchCase(node: object | null | undefined, opts?: object | null): void; +export function isSwitchStatement(node: object | null | undefined, opts?: object | null): node is SwitchStatement; +export function assertSwitchStatement(node: object | null | undefined, opts?: object | null): void; +export function isSymbolTypeAnnotation(node: object | null | undefined, opts?: object | null): node is SymbolTypeAnnotation; +export function assertSymbolTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isTSAnyKeyword(node: object | null | undefined, opts?: object | null): node is TSAnyKeyword; +export function assertTSAnyKeyword(node: object | null | undefined, opts?: object | null): void; +export function isTSArrayType(node: object | null | undefined, opts?: object | null): node is TSArrayType; +export function assertTSArrayType(node: object | null | undefined, opts?: object | null): void; +export function isTSAsExpression(node: object | null | undefined, opts?: object | null): node is TSAsExpression; +export function assertTSAsExpression(node: object | null | undefined, opts?: object | null): void; +export function isTSBaseType(node: object | null | undefined, opts?: object | null): node is TSBaseType; +export function assertTSBaseType(node: object | null | undefined, opts?: object | null): void; +export function isTSBigIntKeyword(node: object | null | undefined, opts?: object | null): node is TSBigIntKeyword; +export function assertTSBigIntKeyword(node: object | null | undefined, opts?: object | null): void; +export function isTSBooleanKeyword(node: object | null | undefined, opts?: object | null): node is TSBooleanKeyword; +export function assertTSBooleanKeyword(node: object | null | undefined, opts?: object | null): void; +export function isTSCallSignatureDeclaration(node: object | null | undefined, opts?: object | null): node is TSCallSignatureDeclaration; +export function assertTSCallSignatureDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isTSConditionalType(node: object | null | undefined, opts?: object | null): node is TSConditionalType; +export function assertTSConditionalType(node: object | null | undefined, opts?: object | null): void; +export function isTSConstructSignatureDeclaration(node: object | null | undefined, opts?: object | null): node is TSConstructSignatureDeclaration; +export function assertTSConstructSignatureDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isTSConstructorType(node: object | null | undefined, opts?: object | null): node is TSConstructorType; +export function assertTSConstructorType(node: object | null | undefined, opts?: object | null): void; +export function isTSDeclareFunction(node: object | null | undefined, opts?: object | null): node is TSDeclareFunction; +export function assertTSDeclareFunction(node: object | null | undefined, opts?: object | null): void; +export function isTSDeclareMethod(node: object | null | undefined, opts?: object | null): node is TSDeclareMethod; +export function assertTSDeclareMethod(node: object | null | undefined, opts?: object | null): void; +export function isTSEntityName(node: object | null | undefined, opts?: object | null): node is TSEntityName; +export function assertTSEntityName(node: object | null | undefined, opts?: object | null): void; +export function isTSEnumBody(node: object | null | undefined, opts?: object | null): node is TSEnumBody; +export function assertTSEnumBody(node: object | null | undefined, opts?: object | null): void; +export function isTSEnumDeclaration(node: object | null | undefined, opts?: object | null): node is TSEnumDeclaration; +export function assertTSEnumDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isTSEnumMember(node: object | null | undefined, opts?: object | null): node is TSEnumMember; +export function assertTSEnumMember(node: object | null | undefined, opts?: object | null): void; +export function isTSExportAssignment(node: object | null | undefined, opts?: object | null): node is TSExportAssignment; +export function assertTSExportAssignment(node: object | null | undefined, opts?: object | null): void; +export function isTSExpressionWithTypeArguments(node: object | null | undefined, opts?: object | null): node is TSExpressionWithTypeArguments; +export function assertTSExpressionWithTypeArguments(node: object | null | undefined, opts?: object | null): void; +export function isTSExternalModuleReference(node: object | null | undefined, opts?: object | null): node is TSExternalModuleReference; +export function assertTSExternalModuleReference(node: object | null | undefined, opts?: object | null): void; +export function isTSFunctionType(node: object | null | undefined, opts?: object | null): node is TSFunctionType; +export function assertTSFunctionType(node: object | null | undefined, opts?: object | null): void; +export function isTSImportEqualsDeclaration(node: object | null | undefined, opts?: object | null): node is TSImportEqualsDeclaration; +export function assertTSImportEqualsDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isTSImportType(node: object | null | undefined, opts?: object | null): node is TSImportType; +export function assertTSImportType(node: object | null | undefined, opts?: object | null): void; +export function isTSIndexSignature(node: object | null | undefined, opts?: object | null): node is TSIndexSignature; +export function assertTSIndexSignature(node: object | null | undefined, opts?: object | null): void; +export function isTSIndexedAccessType(node: object | null | undefined, opts?: object | null): node is TSIndexedAccessType; +export function assertTSIndexedAccessType(node: object | null | undefined, opts?: object | null): void; +export function isTSInferType(node: object | null | undefined, opts?: object | null): node is TSInferType; +export function assertTSInferType(node: object | null | undefined, opts?: object | null): void; +export function isTSInstantiationExpression(node: object | null | undefined, opts?: object | null): node is TSInstantiationExpression; +export function assertTSInstantiationExpression(node: object | null | undefined, opts?: object | null): void; +export function isTSInterfaceBody(node: object | null | undefined, opts?: object | null): node is TSInterfaceBody; +export function assertTSInterfaceBody(node: object | null | undefined, opts?: object | null): void; +export function isTSInterfaceDeclaration(node: object | null | undefined, opts?: object | null): node is TSInterfaceDeclaration; +export function assertTSInterfaceDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isTSIntersectionType(node: object | null | undefined, opts?: object | null): node is TSIntersectionType; +export function assertTSIntersectionType(node: object | null | undefined, opts?: object | null): void; +export function isTSIntrinsicKeyword(node: object | null | undefined, opts?: object | null): node is TSIntrinsicKeyword; +export function assertTSIntrinsicKeyword(node: object | null | undefined, opts?: object | null): void; +export function isTSLiteralType(node: object | null | undefined, opts?: object | null): node is TSLiteralType; +export function assertTSLiteralType(node: object | null | undefined, opts?: object | null): void; +export function isTSMappedType(node: object | null | undefined, opts?: object | null): node is TSMappedType; +export function assertTSMappedType(node: object | null | undefined, opts?: object | null): void; +export function isTSMethodSignature(node: object | null | undefined, opts?: object | null): node is TSMethodSignature; +export function assertTSMethodSignature(node: object | null | undefined, opts?: object | null): void; +export function isTSModuleBlock(node: object | null | undefined, opts?: object | null): node is TSModuleBlock; +export function assertTSModuleBlock(node: object | null | undefined, opts?: object | null): void; +export function isTSModuleDeclaration(node: object | null | undefined, opts?: object | null): node is TSModuleDeclaration; +export function assertTSModuleDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isTSNamedTupleMember(node: object | null | undefined, opts?: object | null): node is TSNamedTupleMember; +export function assertTSNamedTupleMember(node: object | null | undefined, opts?: object | null): void; +export function isTSNamespaceExportDeclaration(node: object | null | undefined, opts?: object | null): node is TSNamespaceExportDeclaration; +export function assertTSNamespaceExportDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isTSNeverKeyword(node: object | null | undefined, opts?: object | null): node is TSNeverKeyword; +export function assertTSNeverKeyword(node: object | null | undefined, opts?: object | null): void; +export function isTSNonNullExpression(node: object | null | undefined, opts?: object | null): node is TSNonNullExpression; +export function assertTSNonNullExpression(node: object | null | undefined, opts?: object | null): void; +export function isTSNullKeyword(node: object | null | undefined, opts?: object | null): node is TSNullKeyword; +export function assertTSNullKeyword(node: object | null | undefined, opts?: object | null): void; +export function isTSNumberKeyword(node: object | null | undefined, opts?: object | null): node is TSNumberKeyword; +export function assertTSNumberKeyword(node: object | null | undefined, opts?: object | null): void; +export function isTSObjectKeyword(node: object | null | undefined, opts?: object | null): node is TSObjectKeyword; +export function assertTSObjectKeyword(node: object | null | undefined, opts?: object | null): void; +export function isTSOptionalType(node: object | null | undefined, opts?: object | null): node is TSOptionalType; +export function assertTSOptionalType(node: object | null | undefined, opts?: object | null): void; +export function isTSParameterProperty(node: object | null | undefined, opts?: object | null): node is TSParameterProperty; +export function assertTSParameterProperty(node: object | null | undefined, opts?: object | null): void; +export function isTSParenthesizedType(node: object | null | undefined, opts?: object | null): node is TSParenthesizedType; +export function assertTSParenthesizedType(node: object | null | undefined, opts?: object | null): void; +export function isTSPropertySignature(node: object | null | undefined, opts?: object | null): node is TSPropertySignature; +export function assertTSPropertySignature(node: object | null | undefined, opts?: object | null): void; +export function isTSQualifiedName(node: object | null | undefined, opts?: object | null): node is TSQualifiedName; +export function assertTSQualifiedName(node: object | null | undefined, opts?: object | null): void; +export function isTSRestType(node: object | null | undefined, opts?: object | null): node is TSRestType; +export function assertTSRestType(node: object | null | undefined, opts?: object | null): void; +export function isTSSatisfiesExpression(node: object | null | undefined, opts?: object | null): node is TSSatisfiesExpression; +export function assertTSSatisfiesExpression(node: object | null | undefined, opts?: object | null): void; +export function isTSStringKeyword(node: object | null | undefined, opts?: object | null): node is TSStringKeyword; +export function assertTSStringKeyword(node: object | null | undefined, opts?: object | null): void; +export function isTSSymbolKeyword(node: object | null | undefined, opts?: object | null): node is TSSymbolKeyword; +export function assertTSSymbolKeyword(node: object | null | undefined, opts?: object | null): void; +export function isTSTemplateLiteralType(node: object | null | undefined, opts?: object | null): node is TSTemplateLiteralType; +export function assertTSTemplateLiteralType(node: object | null | undefined, opts?: object | null): void; +export function isTSThisType(node: object | null | undefined, opts?: object | null): node is TSThisType; +export function assertTSThisType(node: object | null | undefined, opts?: object | null): void; +export function isTSTupleType(node: object | null | undefined, opts?: object | null): node is TSTupleType; +export function assertTSTupleType(node: object | null | undefined, opts?: object | null): void; +export function isTSType(node: object | null | undefined, opts?: object | null): node is TSType; +export function assertTSType(node: object | null | undefined, opts?: object | null): void; +export function isTSTypeAliasDeclaration(node: object | null | undefined, opts?: object | null): node is TSTypeAliasDeclaration; +export function assertTSTypeAliasDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isTSTypeAnnotation(node: object | null | undefined, opts?: object | null): node is TSTypeAnnotation; +export function assertTSTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isTSTypeAssertion(node: object | null | undefined, opts?: object | null): node is TSTypeAssertion; +export function assertTSTypeAssertion(node: object | null | undefined, opts?: object | null): void; +export function isTSTypeElement(node: object | null | undefined, opts?: object | null): node is TSTypeElement; +export function assertTSTypeElement(node: object | null | undefined, opts?: object | null): void; +export function isTSTypeLiteral(node: object | null | undefined, opts?: object | null): node is TSTypeLiteral; +export function assertTSTypeLiteral(node: object | null | undefined, opts?: object | null): void; +export function isTSTypeOperator(node: object | null | undefined, opts?: object | null): node is TSTypeOperator; +export function assertTSTypeOperator(node: object | null | undefined, opts?: object | null): void; +export function isTSTypeParameter(node: object | null | undefined, opts?: object | null): node is TSTypeParameter; +export function assertTSTypeParameter(node: object | null | undefined, opts?: object | null): void; +export function isTSTypeParameterDeclaration(node: object | null | undefined, opts?: object | null): node is TSTypeParameterDeclaration; +export function assertTSTypeParameterDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isTSTypeParameterInstantiation(node: object | null | undefined, opts?: object | null): node is TSTypeParameterInstantiation; +export function assertTSTypeParameterInstantiation(node: object | null | undefined, opts?: object | null): void; +export function isTSTypePredicate(node: object | null | undefined, opts?: object | null): node is TSTypePredicate; +export function assertTSTypePredicate(node: object | null | undefined, opts?: object | null): void; +export function isTSTypeQuery(node: object | null | undefined, opts?: object | null): node is TSTypeQuery; +export function assertTSTypeQuery(node: object | null | undefined, opts?: object | null): void; +export function isTSTypeReference(node: object | null | undefined, opts?: object | null): node is TSTypeReference; +export function assertTSTypeReference(node: object | null | undefined, opts?: object | null): void; +export function isTSUndefinedKeyword(node: object | null | undefined, opts?: object | null): node is TSUndefinedKeyword; +export function assertTSUndefinedKeyword(node: object | null | undefined, opts?: object | null): void; +export function isTSUnionType(node: object | null | undefined, opts?: object | null): node is TSUnionType; +export function assertTSUnionType(node: object | null | undefined, opts?: object | null): void; +export function isTSUnknownKeyword(node: object | null | undefined, opts?: object | null): node is TSUnknownKeyword; +export function assertTSUnknownKeyword(node: object | null | undefined, opts?: object | null): void; +export function isTSVoidKeyword(node: object | null | undefined, opts?: object | null): node is TSVoidKeyword; +export function assertTSVoidKeyword(node: object | null | undefined, opts?: object | null): void; +export function isTaggedTemplateExpression(node: object | null | undefined, opts?: object | null): node is TaggedTemplateExpression; +export function assertTaggedTemplateExpression(node: object | null | undefined, opts?: object | null): void; +export function isTemplateElement(node: object | null | undefined, opts?: object | null): node is TemplateElement; +export function assertTemplateElement(node: object | null | undefined, opts?: object | null): void; +export function isTemplateLiteral(node: object | null | undefined, opts?: object | null): node is TemplateLiteral; +export function assertTemplateLiteral(node: object | null | undefined, opts?: object | null): void; +export function isTerminatorless(node: object | null | undefined, opts?: object | null): node is Terminatorless; +export function assertTerminatorless(node: object | null | undefined, opts?: object | null): void; +export function isThisExpression(node: object | null | undefined, opts?: object | null): node is ThisExpression; +export function assertThisExpression(node: object | null | undefined, opts?: object | null): void; +export function isThisTypeAnnotation(node: object | null | undefined, opts?: object | null): node is ThisTypeAnnotation; +export function assertThisTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isThrowStatement(node: object | null | undefined, opts?: object | null): node is ThrowStatement; +export function assertThrowStatement(node: object | null | undefined, opts?: object | null): void; +export function isTopicReference(node: object | null | undefined, opts?: object | null): node is TopicReference; +export function assertTopicReference(node: object | null | undefined, opts?: object | null): void; +export function isTryStatement(node: object | null | undefined, opts?: object | null): node is TryStatement; +export function assertTryStatement(node: object | null | undefined, opts?: object | null): void; +export function isTupleExpression(node: object | null | undefined, opts?: object | null): node is TupleExpression; +export function assertTupleExpression(node: object | null | undefined, opts?: object | null): void; +export function isTupleTypeAnnotation(node: object | null | undefined, opts?: object | null): node is TupleTypeAnnotation; +export function assertTupleTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isTypeAlias(node: object | null | undefined, opts?: object | null): node is TypeAlias; +export function assertTypeAlias(node: object | null | undefined, opts?: object | null): void; +export function isTypeAnnotation(node: object | null | undefined, opts?: object | null): node is TypeAnnotation; +export function assertTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isTypeCastExpression(node: object | null | undefined, opts?: object | null): node is TypeCastExpression; +export function assertTypeCastExpression(node: object | null | undefined, opts?: object | null): void; +export function isTypeParameter(node: object | null | undefined, opts?: object | null): node is TypeParameter; +export function assertTypeParameter(node: object | null | undefined, opts?: object | null): void; +export function isTypeParameterDeclaration(node: object | null | undefined, opts?: object | null): node is TypeParameterDeclaration; +export function assertTypeParameterDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isTypeParameterInstantiation(node: object | null | undefined, opts?: object | null): node is TypeParameterInstantiation; +export function assertTypeParameterInstantiation(node: object | null | undefined, opts?: object | null): void; +export function isTypeScript(node: object | null | undefined, opts?: object | null): node is TypeScript; +export function assertTypeScript(node: object | null | undefined, opts?: object | null): void; +export function isTypeofTypeAnnotation(node: object | null | undefined, opts?: object | null): node is TypeofTypeAnnotation; +export function assertTypeofTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isUnaryExpression(node: object | null | undefined, opts?: object | null): node is UnaryExpression; +export function assertUnaryExpression(node: object | null | undefined, opts?: object | null): void; +export function isUnaryLike(node: object | null | undefined, opts?: object | null): node is UnaryLike; +export function assertUnaryLike(node: object | null | undefined, opts?: object | null): void; +export function isUnionTypeAnnotation(node: object | null | undefined, opts?: object | null): node is UnionTypeAnnotation; +export function assertUnionTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isUpdateExpression(node: object | null | undefined, opts?: object | null): node is UpdateExpression; +export function assertUpdateExpression(node: object | null | undefined, opts?: object | null): void; +export function isUserWhitespacable(node: object | null | undefined, opts?: object | null): node is UserWhitespacable; +export function assertUserWhitespacable(node: object | null | undefined, opts?: object | null): void; +export function isV8IntrinsicIdentifier(node: object | null | undefined, opts?: object | null): node is V8IntrinsicIdentifier; +export function assertV8IntrinsicIdentifier(node: object | null | undefined, opts?: object | null): void; +export function isVariableDeclaration(node: object | null | undefined, opts?: object | null): node is VariableDeclaration; +export function assertVariableDeclaration(node: object | null | undefined, opts?: object | null): void; +export function isVariableDeclarator(node: object | null | undefined, opts?: object | null): node is VariableDeclarator; +export function assertVariableDeclarator(node: object | null | undefined, opts?: object | null): void; +export function isVariance(node: object | null | undefined, opts?: object | null): node is Variance; +export function assertVariance(node: object | null | undefined, opts?: object | null): void; +export function isVoidPattern(node: object | null | undefined, opts?: object | null): node is VoidPattern; +export function assertVoidPattern(node: object | null | undefined, opts?: object | null): void; +export function isVoidTypeAnnotation(node: object | null | undefined, opts?: object | null): node is VoidTypeAnnotation; +export function assertVoidTypeAnnotation(node: object | null | undefined, opts?: object | null): void; +export function isWhile(node: object | null | undefined, opts?: object | null): node is While; +export function assertWhile(node: object | null | undefined, opts?: object | null): void; +export function isWhileStatement(node: object | null | undefined, opts?: object | null): node is WhileStatement; +export function assertWhileStatement(node: object | null | undefined, opts?: object | null): void; +export function isWithStatement(node: object | null | undefined, opts?: object | null): node is WithStatement; +export function assertWithStatement(node: object | null | undefined, opts?: object | null): void; +export function isYieldExpression(node: object | null | undefined, opts?: object | null): node is YieldExpression; +export function assertYieldExpression(node: object | null | undefined, opts?: object | null): void; +export function assertNode(obj: any): void +export function createTypeAnnotationBasedOnTypeof(type: 'string' | 'number' | 'undefined' | 'boolean' | 'function' | 'object' | 'symbol'): StringTypeAnnotation | VoidTypeAnnotation | NumberTypeAnnotation | BooleanTypeAnnotation | GenericTypeAnnotation +export function createUnionTypeAnnotation(types: [T]): T +export function createFlowUnionType(types: [T]): T +export function createUnionTypeAnnotation(types: ReadonlyArray): UnionTypeAnnotation +export function createFlowUnionType(types: ReadonlyArray): UnionTypeAnnotation +export function buildChildren(node: { children: ReadonlyArray }): JSXElement['children'] +export function clone(n: T): T; +export function cloneDeep(n: T): T; +export function cloneDeepWithoutLoc(n: T): T; +export function cloneNode(n: T, deep?: boolean, withoutLoc?: boolean): T; +export function cloneWithoutLoc(n: T): T; +export type CommentTypeShorthand = 'leading' | 'inner' | 'trailing' +export function addComment(node: T, type: CommentTypeShorthand, content: string, line?: boolean): T +export function addComments(node: T, type: CommentTypeShorthand, comments: ReadonlyArray): T +export function inheritInnerComments(node: Node, parent: Node): void +export function inheritLeadingComments(node: Node, parent: Node): void +export function inheritsComments(node: T, parent: Node): void +export function inheritTrailingComments(node: Node, parent: Node): void +export function removeComments(node: T): T +export function ensureBlock(node: Extract): BlockStatement +export function ensureBlock = 'body'>(node: Extract>, key: K): BlockStatement +export function toBindingIdentifierName(name: { toString(): string } | null | undefined): string +export function toBlock(node: Statement | Expression, parent?: Function | null): BlockStatement +export function toComputedKey>(node: T, key?: Expression | Identifier): Expression +export function toExpression(node: Function): FunctionExpression +export function toExpression(node: Class): ClassExpression +export function toExpression(node: ExpressionStatement | Expression | Class | Function): Expression +export function toIdentifier(name: { toString(): string } | null | undefined): string +export function toKeyAlias(node: Method | Property, key?: Node): string +export function toSequenceExpression(nodes: ReadonlyArray, scope: { push(value: { id: LVal; kind: 'var'; init?: Expression}): void; buildUndefinedNode(): Node }): SequenceExpression | undefined +export function toStatement(node: AssignmentExpression, ignore?: boolean): ExpressionStatement +export function toStatement(node: Statement | AssignmentExpression, ignore?: boolean): Statement +export function toStatement(node: Class, ignore: true): ClassDeclaration | undefined +export function toStatement(node: Class, ignore?: boolean): ClassDeclaration +export function toStatement(node: Function, ignore: true): FunctionDeclaration | undefined +export function toStatement(node: Function, ignore?: boolean): FunctionDeclaration +export function toStatement(node: Statement | Class | Function | AssignmentExpression, ignore: true): Statement | undefined +export function toStatement(node: Statement | Class | Function | AssignmentExpression, ignore?: boolean): Statement +export function valueToNode(value: undefined): Identifier +export function valueToNode(value: boolean): BooleanLiteral +export function valueToNode(value: null): NullLiteral +export function valueToNode(value: string): StringLiteral +export function valueToNode(value: number): NumericLiteral | BinaryExpression | UnaryExpression +export function valueToNode(value: RegExp): RegExpLiteral +export function valueToNode(value: ReadonlyArray): ArrayExpression +export function valueToNode(value: object): ObjectExpression +export function valueToNode(value: undefined | boolean | null | string | number | RegExp | object): Expression +export function removeTypeDuplicates(types: ReadonlyArray): FlowType[] +export function appendToMemberExpression>(member: T, append: MemberExpression['property'], computed?: boolean): T +export function inherits(child: T, parent: Node | null | undefined): T +export function prependToMemberExpression>(member: T, prepend: MemberExpression['object']): T +export function removeProperties( + n: Node, + opts?: { preserveComments: boolean } | null +): void; +export function removePropertiesDeep( + n: T, + opts?: { preserveComments: boolean } | null +): T; +export function getBindingIdentifiers(node: Node, duplicates: true, outerOnly?: boolean): Record> +export function getBindingIdentifiers(node: Node, duplicates?: false, outerOnly?: boolean): Record +export function getBindingIdentifiers(node: Node, duplicates: boolean, outerOnly?: boolean): Record> +export function getOuterBindingIdentifiers(node: Node, duplicates: true): Record> +export function getOuterBindingIdentifiers(node: Node, duplicates?: false): Record +export function getOuterBindingIdentifiers(node: Node, duplicates: boolean): Record> +export type TraversalAncestors = ReadonlyArray<{ + node: Node, + key: string, + index?: number, +}>; +export type TraversalHandler = ( + this: undefined, node: Node, parent: TraversalAncestors, type: T +) => void; +export type TraversalHandlers = { + enter?: TraversalHandler, + exit?: TraversalHandler, +}; +export function traverse(n: Node, h: TraversalHandler | TraversalHandlers, state?: T): void; +export function traverseFast(n: Node, h: TraversalHandler, state?: T): void; +export function shallowEqual(actual: object, expected: T): actual is T +export function buildMatchMemberExpression(match: string, allowPartial?: boolean): (node: Node | null | undefined) => node is MemberExpression +export function is(type: T, n: Node | null | undefined, required?: undefined): n is Extract +export function is>(type: T, n: Node | null | undefined, required: Partial

): n is P +export function is

(type: string, n: Node | null | undefined, required: Partial

): n is P +export function is(type: string, n: Node | null | undefined, required?: Partial): n is Node +export function isBinding(node: Node, parent: Node, grandparent?: Node): boolean +export function isBlockScoped(node: Node): node is FunctionDeclaration | ClassDeclaration | VariableDeclaration +export function isImmutable(node: Node): node is Immutable +export function isLet(node: Node): node is VariableDeclaration +export function isNode(node: object | null | undefined): node is Node +export function isNodesEquivalent>(a: T, b: any): b is T +export function isNodesEquivalent(a: any, b: any): boolean +export function isPlaceholderType(placeholderType: Node['type'], targetType: Node['type']): boolean +export function isReferenced(node: Node, parent: Node, grandparent?: Node): boolean +export function isScope(node: Node, parent: Node): node is Scopable +export function isSpecifierDefault(specifier: ModuleSpecifier): boolean +export function isType(nodetype: string, targetType: T): nodetype is T +export function isType(nodetype: string | null | undefined, targetType: string): boolean +export function isValidES3Identifier(name: string): boolean +export function isValidIdentifier(name: string): boolean +export function isVar(node: Node): node is VariableDeclaration +export function matchesPattern(node: Node | null | undefined, match: string | ReadonlyArray, allowPartial?: boolean): node is MemberExpression +export function validate(n: Node | null | undefined, key: K, value: T[K]): void; +export function validate(n: Node, key: string, value: any): void; \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/index.d.ts b/scripts/node_modules/@babel/types/lib/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..efa49cb138a8a92dab046aabff7dd13338fe9086 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/index.d.ts @@ -0,0 +1,3617 @@ +declare function isCompatTag(tagName?: string): boolean; + +type ReturnedChild = JSXSpreadChild | JSXElement | JSXFragment | Expression; +declare function buildChildren(node: JSXElement | JSXFragment): ReturnedChild[]; + +declare function assertNode(node?: any): asserts node is Node; + +declare function assertArrayExpression(node: object | null | undefined, opts?: object | null): asserts node is ArrayExpression; +declare function assertAssignmentExpression(node: object | null | undefined, opts?: object | null): asserts node is AssignmentExpression; +declare function assertBinaryExpression(node: object | null | undefined, opts?: object | null): asserts node is BinaryExpression; +declare function assertInterpreterDirective(node: object | null | undefined, opts?: object | null): asserts node is InterpreterDirective; +declare function assertDirective(node: object | null | undefined, opts?: object | null): asserts node is Directive; +declare function assertDirectiveLiteral(node: object | null | undefined, opts?: object | null): asserts node is DirectiveLiteral; +declare function assertBlockStatement(node: object | null | undefined, opts?: object | null): asserts node is BlockStatement; +declare function assertBreakStatement(node: object | null | undefined, opts?: object | null): asserts node is BreakStatement; +declare function assertCallExpression(node: object | null | undefined, opts?: object | null): asserts node is CallExpression; +declare function assertCatchClause(node: object | null | undefined, opts?: object | null): asserts node is CatchClause; +declare function assertConditionalExpression(node: object | null | undefined, opts?: object | null): asserts node is ConditionalExpression; +declare function assertContinueStatement(node: object | null | undefined, opts?: object | null): asserts node is ContinueStatement; +declare function assertDebuggerStatement(node: object | null | undefined, opts?: object | null): asserts node is DebuggerStatement; +declare function assertDoWhileStatement(node: object | null | undefined, opts?: object | null): asserts node is DoWhileStatement; +declare function assertEmptyStatement(node: object | null | undefined, opts?: object | null): asserts node is EmptyStatement; +declare function assertExpressionStatement(node: object | null | undefined, opts?: object | null): asserts node is ExpressionStatement; +declare function assertFile(node: object | null | undefined, opts?: object | null): asserts node is File; +declare function assertForInStatement(node: object | null | undefined, opts?: object | null): asserts node is ForInStatement; +declare function assertForStatement(node: object | null | undefined, opts?: object | null): asserts node is ForStatement; +declare function assertFunctionDeclaration(node: object | null | undefined, opts?: object | null): asserts node is FunctionDeclaration; +declare function assertFunctionExpression(node: object | null | undefined, opts?: object | null): asserts node is FunctionExpression; +declare function assertIdentifier(node: object | null | undefined, opts?: object | null): asserts node is Identifier; +declare function assertIfStatement(node: object | null | undefined, opts?: object | null): asserts node is IfStatement; +declare function assertLabeledStatement(node: object | null | undefined, opts?: object | null): asserts node is LabeledStatement; +declare function assertStringLiteral(node: object | null | undefined, opts?: object | null): asserts node is StringLiteral; +declare function assertNumericLiteral(node: object | null | undefined, opts?: object | null): asserts node is NumericLiteral; +declare function assertNullLiteral(node: object | null | undefined, opts?: object | null): asserts node is NullLiteral; +declare function assertBooleanLiteral(node: object | null | undefined, opts?: object | null): asserts node is BooleanLiteral; +declare function assertRegExpLiteral(node: object | null | undefined, opts?: object | null): asserts node is RegExpLiteral; +declare function assertLogicalExpression(node: object | null | undefined, opts?: object | null): asserts node is LogicalExpression; +declare function assertMemberExpression(node: object | null | undefined, opts?: object | null): asserts node is MemberExpression; +declare function assertNewExpression(node: object | null | undefined, opts?: object | null): asserts node is NewExpression; +declare function assertProgram(node: object | null | undefined, opts?: object | null): asserts node is Program; +declare function assertObjectExpression(node: object | null | undefined, opts?: object | null): asserts node is ObjectExpression; +declare function assertObjectMethod(node: object | null | undefined, opts?: object | null): asserts node is ObjectMethod; +declare function assertObjectProperty(node: object | null | undefined, opts?: object | null): asserts node is ObjectProperty; +declare function assertRestElement(node: object | null | undefined, opts?: object | null): asserts node is RestElement; +declare function assertReturnStatement(node: object | null | undefined, opts?: object | null): asserts node is ReturnStatement; +declare function assertSequenceExpression(node: object | null | undefined, opts?: object | null): asserts node is SequenceExpression; +declare function assertParenthesizedExpression(node: object | null | undefined, opts?: object | null): asserts node is ParenthesizedExpression; +declare function assertSwitchCase(node: object | null | undefined, opts?: object | null): asserts node is SwitchCase; +declare function assertSwitchStatement(node: object | null | undefined, opts?: object | null): asserts node is SwitchStatement; +declare function assertThisExpression(node: object | null | undefined, opts?: object | null): asserts node is ThisExpression; +declare function assertThrowStatement(node: object | null | undefined, opts?: object | null): asserts node is ThrowStatement; +declare function assertTryStatement(node: object | null | undefined, opts?: object | null): asserts node is TryStatement; +declare function assertUnaryExpression(node: object | null | undefined, opts?: object | null): asserts node is UnaryExpression; +declare function assertUpdateExpression(node: object | null | undefined, opts?: object | null): asserts node is UpdateExpression; +declare function assertVariableDeclaration(node: object | null | undefined, opts?: object | null): asserts node is VariableDeclaration; +declare function assertVariableDeclarator(node: object | null | undefined, opts?: object | null): asserts node is VariableDeclarator; +declare function assertWhileStatement(node: object | null | undefined, opts?: object | null): asserts node is WhileStatement; +declare function assertWithStatement(node: object | null | undefined, opts?: object | null): asserts node is WithStatement; +declare function assertAssignmentPattern(node: object | null | undefined, opts?: object | null): asserts node is AssignmentPattern; +declare function assertArrayPattern(node: object | null | undefined, opts?: object | null): asserts node is ArrayPattern; +declare function assertArrowFunctionExpression(node: object | null | undefined, opts?: object | null): asserts node is ArrowFunctionExpression; +declare function assertClassBody(node: object | null | undefined, opts?: object | null): asserts node is ClassBody; +declare function assertClassExpression(node: object | null | undefined, opts?: object | null): asserts node is ClassExpression; +declare function assertClassDeclaration(node: object | null | undefined, opts?: object | null): asserts node is ClassDeclaration; +declare function assertExportAllDeclaration(node: object | null | undefined, opts?: object | null): asserts node is ExportAllDeclaration; +declare function assertExportDefaultDeclaration(node: object | null | undefined, opts?: object | null): asserts node is ExportDefaultDeclaration; +declare function assertExportNamedDeclaration(node: object | null | undefined, opts?: object | null): asserts node is ExportNamedDeclaration; +declare function assertExportSpecifier(node: object | null | undefined, opts?: object | null): asserts node is ExportSpecifier; +declare function assertForOfStatement(node: object | null | undefined, opts?: object | null): asserts node is ForOfStatement; +declare function assertImportDeclaration(node: object | null | undefined, opts?: object | null): asserts node is ImportDeclaration; +declare function assertImportDefaultSpecifier(node: object | null | undefined, opts?: object | null): asserts node is ImportDefaultSpecifier; +declare function assertImportNamespaceSpecifier(node: object | null | undefined, opts?: object | null): asserts node is ImportNamespaceSpecifier; +declare function assertImportSpecifier(node: object | null | undefined, opts?: object | null): asserts node is ImportSpecifier; +declare function assertImportExpression(node: object | null | undefined, opts?: object | null): asserts node is ImportExpression; +declare function assertMetaProperty(node: object | null | undefined, opts?: object | null): asserts node is MetaProperty; +declare function assertClassMethod(node: object | null | undefined, opts?: object | null): asserts node is ClassMethod; +declare function assertObjectPattern(node: object | null | undefined, opts?: object | null): asserts node is ObjectPattern; +declare function assertSpreadElement(node: object | null | undefined, opts?: object | null): asserts node is SpreadElement; +declare function assertSuper(node: object | null | undefined, opts?: object | null): asserts node is Super; +declare function assertTaggedTemplateExpression(node: object | null | undefined, opts?: object | null): asserts node is TaggedTemplateExpression; +declare function assertTemplateElement(node: object | null | undefined, opts?: object | null): asserts node is TemplateElement; +declare function assertTemplateLiteral(node: object | null | undefined, opts?: object | null): asserts node is TemplateLiteral; +declare function assertYieldExpression(node: object | null | undefined, opts?: object | null): asserts node is YieldExpression; +declare function assertAwaitExpression(node: object | null | undefined, opts?: object | null): asserts node is AwaitExpression; +declare function assertImport(node: object | null | undefined, opts?: object | null): asserts node is Import; +declare function assertBigIntLiteral(node: object | null | undefined, opts?: object | null): asserts node is BigIntLiteral; +declare function assertExportNamespaceSpecifier(node: object | null | undefined, opts?: object | null): asserts node is ExportNamespaceSpecifier; +declare function assertOptionalMemberExpression(node: object | null | undefined, opts?: object | null): asserts node is OptionalMemberExpression; +declare function assertOptionalCallExpression(node: object | null | undefined, opts?: object | null): asserts node is OptionalCallExpression; +declare function assertClassProperty(node: object | null | undefined, opts?: object | null): asserts node is ClassProperty; +declare function assertClassAccessorProperty(node: object | null | undefined, opts?: object | null): asserts node is ClassAccessorProperty; +declare function assertClassPrivateProperty(node: object | null | undefined, opts?: object | null): asserts node is ClassPrivateProperty; +declare function assertClassPrivateMethod(node: object | null | undefined, opts?: object | null): asserts node is ClassPrivateMethod; +declare function assertPrivateName(node: object | null | undefined, opts?: object | null): asserts node is PrivateName; +declare function assertStaticBlock(node: object | null | undefined, opts?: object | null): asserts node is StaticBlock; +declare function assertImportAttribute(node: object | null | undefined, opts?: object | null): asserts node is ImportAttribute; +declare function assertAnyTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is AnyTypeAnnotation; +declare function assertArrayTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is ArrayTypeAnnotation; +declare function assertBooleanTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is BooleanTypeAnnotation; +declare function assertBooleanLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is BooleanLiteralTypeAnnotation; +declare function assertNullLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is NullLiteralTypeAnnotation; +declare function assertClassImplements(node: object | null | undefined, opts?: object | null): asserts node is ClassImplements; +declare function assertDeclareClass(node: object | null | undefined, opts?: object | null): asserts node is DeclareClass; +declare function assertDeclareFunction(node: object | null | undefined, opts?: object | null): asserts node is DeclareFunction; +declare function assertDeclareInterface(node: object | null | undefined, opts?: object | null): asserts node is DeclareInterface; +declare function assertDeclareModule(node: object | null | undefined, opts?: object | null): asserts node is DeclareModule; +declare function assertDeclareModuleExports(node: object | null | undefined, opts?: object | null): asserts node is DeclareModuleExports; +declare function assertDeclareTypeAlias(node: object | null | undefined, opts?: object | null): asserts node is DeclareTypeAlias; +declare function assertDeclareOpaqueType(node: object | null | undefined, opts?: object | null): asserts node is DeclareOpaqueType; +declare function assertDeclareVariable(node: object | null | undefined, opts?: object | null): asserts node is DeclareVariable; +declare function assertDeclareExportDeclaration(node: object | null | undefined, opts?: object | null): asserts node is DeclareExportDeclaration; +declare function assertDeclareExportAllDeclaration(node: object | null | undefined, opts?: object | null): asserts node is DeclareExportAllDeclaration; +declare function assertDeclaredPredicate(node: object | null | undefined, opts?: object | null): asserts node is DeclaredPredicate; +declare function assertExistsTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is ExistsTypeAnnotation; +declare function assertFunctionTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is FunctionTypeAnnotation; +declare function assertFunctionTypeParam(node: object | null | undefined, opts?: object | null): asserts node is FunctionTypeParam; +declare function assertGenericTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is GenericTypeAnnotation; +declare function assertInferredPredicate(node: object | null | undefined, opts?: object | null): asserts node is InferredPredicate; +declare function assertInterfaceExtends(node: object | null | undefined, opts?: object | null): asserts node is InterfaceExtends; +declare function assertInterfaceDeclaration(node: object | null | undefined, opts?: object | null): asserts node is InterfaceDeclaration; +declare function assertInterfaceTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is InterfaceTypeAnnotation; +declare function assertIntersectionTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is IntersectionTypeAnnotation; +declare function assertMixedTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is MixedTypeAnnotation; +declare function assertEmptyTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is EmptyTypeAnnotation; +declare function assertNullableTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is NullableTypeAnnotation; +declare function assertNumberLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is NumberLiteralTypeAnnotation; +declare function assertNumberTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is NumberTypeAnnotation; +declare function assertObjectTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is ObjectTypeAnnotation; +declare function assertObjectTypeInternalSlot(node: object | null | undefined, opts?: object | null): asserts node is ObjectTypeInternalSlot; +declare function assertObjectTypeCallProperty(node: object | null | undefined, opts?: object | null): asserts node is ObjectTypeCallProperty; +declare function assertObjectTypeIndexer(node: object | null | undefined, opts?: object | null): asserts node is ObjectTypeIndexer; +declare function assertObjectTypeProperty(node: object | null | undefined, opts?: object | null): asserts node is ObjectTypeProperty; +declare function assertObjectTypeSpreadProperty(node: object | null | undefined, opts?: object | null): asserts node is ObjectTypeSpreadProperty; +declare function assertOpaqueType(node: object | null | undefined, opts?: object | null): asserts node is OpaqueType; +declare function assertQualifiedTypeIdentifier(node: object | null | undefined, opts?: object | null): asserts node is QualifiedTypeIdentifier; +declare function assertStringLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is StringLiteralTypeAnnotation; +declare function assertStringTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is StringTypeAnnotation; +declare function assertSymbolTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is SymbolTypeAnnotation; +declare function assertThisTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is ThisTypeAnnotation; +declare function assertTupleTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is TupleTypeAnnotation; +declare function assertTypeofTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is TypeofTypeAnnotation; +declare function assertTypeAlias(node: object | null | undefined, opts?: object | null): asserts node is TypeAlias; +declare function assertTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is TypeAnnotation; +declare function assertTypeCastExpression(node: object | null | undefined, opts?: object | null): asserts node is TypeCastExpression; +declare function assertTypeParameter(node: object | null | undefined, opts?: object | null): asserts node is TypeParameter; +declare function assertTypeParameterDeclaration(node: object | null | undefined, opts?: object | null): asserts node is TypeParameterDeclaration; +declare function assertTypeParameterInstantiation(node: object | null | undefined, opts?: object | null): asserts node is TypeParameterInstantiation; +declare function assertUnionTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is UnionTypeAnnotation; +declare function assertVariance(node: object | null | undefined, opts?: object | null): asserts node is Variance; +declare function assertVoidTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is VoidTypeAnnotation; +declare function assertEnumDeclaration(node: object | null | undefined, opts?: object | null): asserts node is EnumDeclaration; +declare function assertEnumBooleanBody(node: object | null | undefined, opts?: object | null): asserts node is EnumBooleanBody; +declare function assertEnumNumberBody(node: object | null | undefined, opts?: object | null): asserts node is EnumNumberBody; +declare function assertEnumStringBody(node: object | null | undefined, opts?: object | null): asserts node is EnumStringBody; +declare function assertEnumSymbolBody(node: object | null | undefined, opts?: object | null): asserts node is EnumSymbolBody; +declare function assertEnumBooleanMember(node: object | null | undefined, opts?: object | null): asserts node is EnumBooleanMember; +declare function assertEnumNumberMember(node: object | null | undefined, opts?: object | null): asserts node is EnumNumberMember; +declare function assertEnumStringMember(node: object | null | undefined, opts?: object | null): asserts node is EnumStringMember; +declare function assertEnumDefaultedMember(node: object | null | undefined, opts?: object | null): asserts node is EnumDefaultedMember; +declare function assertIndexedAccessType(node: object | null | undefined, opts?: object | null): asserts node is IndexedAccessType; +declare function assertOptionalIndexedAccessType(node: object | null | undefined, opts?: object | null): asserts node is OptionalIndexedAccessType; +declare function assertJSXAttribute(node: object | null | undefined, opts?: object | null): asserts node is JSXAttribute; +declare function assertJSXClosingElement(node: object | null | undefined, opts?: object | null): asserts node is JSXClosingElement; +declare function assertJSXElement(node: object | null | undefined, opts?: object | null): asserts node is JSXElement; +declare function assertJSXEmptyExpression(node: object | null | undefined, opts?: object | null): asserts node is JSXEmptyExpression; +declare function assertJSXExpressionContainer(node: object | null | undefined, opts?: object | null): asserts node is JSXExpressionContainer; +declare function assertJSXSpreadChild(node: object | null | undefined, opts?: object | null): asserts node is JSXSpreadChild; +declare function assertJSXIdentifier(node: object | null | undefined, opts?: object | null): asserts node is JSXIdentifier; +declare function assertJSXMemberExpression(node: object | null | undefined, opts?: object | null): asserts node is JSXMemberExpression; +declare function assertJSXNamespacedName(node: object | null | undefined, opts?: object | null): asserts node is JSXNamespacedName; +declare function assertJSXOpeningElement(node: object | null | undefined, opts?: object | null): asserts node is JSXOpeningElement; +declare function assertJSXSpreadAttribute(node: object | null | undefined, opts?: object | null): asserts node is JSXSpreadAttribute; +declare function assertJSXText(node: object | null | undefined, opts?: object | null): asserts node is JSXText; +declare function assertJSXFragment(node: object | null | undefined, opts?: object | null): asserts node is JSXFragment; +declare function assertJSXOpeningFragment(node: object | null | undefined, opts?: object | null): asserts node is JSXOpeningFragment; +declare function assertJSXClosingFragment(node: object | null | undefined, opts?: object | null): asserts node is JSXClosingFragment; +declare function assertNoop(node: object | null | undefined, opts?: object | null): asserts node is Noop; +declare function assertPlaceholder(node: object | null | undefined, opts?: object | null): asserts node is Placeholder; +declare function assertV8IntrinsicIdentifier(node: object | null | undefined, opts?: object | null): asserts node is V8IntrinsicIdentifier; +declare function assertArgumentPlaceholder(node: object | null | undefined, opts?: object | null): asserts node is ArgumentPlaceholder; +declare function assertBindExpression(node: object | null | undefined, opts?: object | null): asserts node is BindExpression; +declare function assertDecorator(node: object | null | undefined, opts?: object | null): asserts node is Decorator; +declare function assertDoExpression(node: object | null | undefined, opts?: object | null): asserts node is DoExpression; +declare function assertExportDefaultSpecifier(node: object | null | undefined, opts?: object | null): asserts node is ExportDefaultSpecifier; +declare function assertRecordExpression(node: object | null | undefined, opts?: object | null): asserts node is RecordExpression; +declare function assertTupleExpression(node: object | null | undefined, opts?: object | null): asserts node is TupleExpression; +declare function assertDecimalLiteral(node: object | null | undefined, opts?: object | null): asserts node is DecimalLiteral; +declare function assertModuleExpression(node: object | null | undefined, opts?: object | null): asserts node is ModuleExpression; +declare function assertTopicReference(node: object | null | undefined, opts?: object | null): asserts node is TopicReference; +declare function assertPipelineTopicExpression(node: object | null | undefined, opts?: object | null): asserts node is PipelineTopicExpression; +declare function assertPipelineBareFunction(node: object | null | undefined, opts?: object | null): asserts node is PipelineBareFunction; +declare function assertPipelinePrimaryTopicReference(node: object | null | undefined, opts?: object | null): asserts node is PipelinePrimaryTopicReference; +declare function assertVoidPattern(node: object | null | undefined, opts?: object | null): asserts node is VoidPattern; +declare function assertTSParameterProperty(node: object | null | undefined, opts?: object | null): asserts node is TSParameterProperty; +declare function assertTSDeclareFunction(node: object | null | undefined, opts?: object | null): asserts node is TSDeclareFunction; +declare function assertTSDeclareMethod(node: object | null | undefined, opts?: object | null): asserts node is TSDeclareMethod; +declare function assertTSQualifiedName(node: object | null | undefined, opts?: object | null): asserts node is TSQualifiedName; +declare function assertTSCallSignatureDeclaration(node: object | null | undefined, opts?: object | null): asserts node is TSCallSignatureDeclaration; +declare function assertTSConstructSignatureDeclaration(node: object | null | undefined, opts?: object | null): asserts node is TSConstructSignatureDeclaration; +declare function assertTSPropertySignature(node: object | null | undefined, opts?: object | null): asserts node is TSPropertySignature; +declare function assertTSMethodSignature(node: object | null | undefined, opts?: object | null): asserts node is TSMethodSignature; +declare function assertTSIndexSignature(node: object | null | undefined, opts?: object | null): asserts node is TSIndexSignature; +declare function assertTSAnyKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSAnyKeyword; +declare function assertTSBooleanKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSBooleanKeyword; +declare function assertTSBigIntKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSBigIntKeyword; +declare function assertTSIntrinsicKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSIntrinsicKeyword; +declare function assertTSNeverKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSNeverKeyword; +declare function assertTSNullKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSNullKeyword; +declare function assertTSNumberKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSNumberKeyword; +declare function assertTSObjectKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSObjectKeyword; +declare function assertTSStringKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSStringKeyword; +declare function assertTSSymbolKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSSymbolKeyword; +declare function assertTSUndefinedKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSUndefinedKeyword; +declare function assertTSUnknownKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSUnknownKeyword; +declare function assertTSVoidKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSVoidKeyword; +declare function assertTSThisType(node: object | null | undefined, opts?: object | null): asserts node is TSThisType; +declare function assertTSFunctionType(node: object | null | undefined, opts?: object | null): asserts node is TSFunctionType; +declare function assertTSConstructorType(node: object | null | undefined, opts?: object | null): asserts node is TSConstructorType; +declare function assertTSTypeReference(node: object | null | undefined, opts?: object | null): asserts node is TSTypeReference; +declare function assertTSTypePredicate(node: object | null | undefined, opts?: object | null): asserts node is TSTypePredicate; +declare function assertTSTypeQuery(node: object | null | undefined, opts?: object | null): asserts node is TSTypeQuery; +declare function assertTSTypeLiteral(node: object | null | undefined, opts?: object | null): asserts node is TSTypeLiteral; +declare function assertTSArrayType(node: object | null | undefined, opts?: object | null): asserts node is TSArrayType; +declare function assertTSTupleType(node: object | null | undefined, opts?: object | null): asserts node is TSTupleType; +declare function assertTSOptionalType(node: object | null | undefined, opts?: object | null): asserts node is TSOptionalType; +declare function assertTSRestType(node: object | null | undefined, opts?: object | null): asserts node is TSRestType; +declare function assertTSNamedTupleMember(node: object | null | undefined, opts?: object | null): asserts node is TSNamedTupleMember; +declare function assertTSUnionType(node: object | null | undefined, opts?: object | null): asserts node is TSUnionType; +declare function assertTSIntersectionType(node: object | null | undefined, opts?: object | null): asserts node is TSIntersectionType; +declare function assertTSConditionalType(node: object | null | undefined, opts?: object | null): asserts node is TSConditionalType; +declare function assertTSInferType(node: object | null | undefined, opts?: object | null): asserts node is TSInferType; +declare function assertTSParenthesizedType(node: object | null | undefined, opts?: object | null): asserts node is TSParenthesizedType; +declare function assertTSTypeOperator(node: object | null | undefined, opts?: object | null): asserts node is TSTypeOperator; +declare function assertTSIndexedAccessType(node: object | null | undefined, opts?: object | null): asserts node is TSIndexedAccessType; +declare function assertTSMappedType(node: object | null | undefined, opts?: object | null): asserts node is TSMappedType; +declare function assertTSTemplateLiteralType(node: object | null | undefined, opts?: object | null): asserts node is TSTemplateLiteralType; +declare function assertTSLiteralType(node: object | null | undefined, opts?: object | null): asserts node is TSLiteralType; +declare function assertTSExpressionWithTypeArguments(node: object | null | undefined, opts?: object | null): asserts node is TSExpressionWithTypeArguments; +declare function assertTSInterfaceDeclaration(node: object | null | undefined, opts?: object | null): asserts node is TSInterfaceDeclaration; +declare function assertTSInterfaceBody(node: object | null | undefined, opts?: object | null): asserts node is TSInterfaceBody; +declare function assertTSTypeAliasDeclaration(node: object | null | undefined, opts?: object | null): asserts node is TSTypeAliasDeclaration; +declare function assertTSInstantiationExpression(node: object | null | undefined, opts?: object | null): asserts node is TSInstantiationExpression; +declare function assertTSAsExpression(node: object | null | undefined, opts?: object | null): asserts node is TSAsExpression; +declare function assertTSSatisfiesExpression(node: object | null | undefined, opts?: object | null): asserts node is TSSatisfiesExpression; +declare function assertTSTypeAssertion(node: object | null | undefined, opts?: object | null): asserts node is TSTypeAssertion; +declare function assertTSEnumBody(node: object | null | undefined, opts?: object | null): asserts node is TSEnumBody; +declare function assertTSEnumDeclaration(node: object | null | undefined, opts?: object | null): asserts node is TSEnumDeclaration; +declare function assertTSEnumMember(node: object | null | undefined, opts?: object | null): asserts node is TSEnumMember; +declare function assertTSModuleDeclaration(node: object | null | undefined, opts?: object | null): asserts node is TSModuleDeclaration; +declare function assertTSModuleBlock(node: object | null | undefined, opts?: object | null): asserts node is TSModuleBlock; +declare function assertTSImportType(node: object | null | undefined, opts?: object | null): asserts node is TSImportType; +declare function assertTSImportEqualsDeclaration(node: object | null | undefined, opts?: object | null): asserts node is TSImportEqualsDeclaration; +declare function assertTSExternalModuleReference(node: object | null | undefined, opts?: object | null): asserts node is TSExternalModuleReference; +declare function assertTSNonNullExpression(node: object | null | undefined, opts?: object | null): asserts node is TSNonNullExpression; +declare function assertTSExportAssignment(node: object | null | undefined, opts?: object | null): asserts node is TSExportAssignment; +declare function assertTSNamespaceExportDeclaration(node: object | null | undefined, opts?: object | null): asserts node is TSNamespaceExportDeclaration; +declare function assertTSTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is TSTypeAnnotation; +declare function assertTSTypeParameterInstantiation(node: object | null | undefined, opts?: object | null): asserts node is TSTypeParameterInstantiation; +declare function assertTSTypeParameterDeclaration(node: object | null | undefined, opts?: object | null): asserts node is TSTypeParameterDeclaration; +declare function assertTSTypeParameter(node: object | null | undefined, opts?: object | null): asserts node is TSTypeParameter; +declare function assertStandardized(node: object | null | undefined, opts?: object | null): asserts node is Standardized; +declare function assertExpression(node: object | null | undefined, opts?: object | null): asserts node is Expression; +declare function assertBinary(node: object | null | undefined, opts?: object | null): asserts node is Binary; +declare function assertScopable(node: object | null | undefined, opts?: object | null): asserts node is Scopable; +declare function assertBlockParent(node: object | null | undefined, opts?: object | null): asserts node is BlockParent; +declare function assertBlock(node: object | null | undefined, opts?: object | null): asserts node is Block; +declare function assertStatement(node: object | null | undefined, opts?: object | null): asserts node is Statement; +declare function assertTerminatorless(node: object | null | undefined, opts?: object | null): asserts node is Terminatorless; +declare function assertCompletionStatement(node: object | null | undefined, opts?: object | null): asserts node is CompletionStatement; +declare function assertConditional(node: object | null | undefined, opts?: object | null): asserts node is Conditional; +declare function assertLoop(node: object | null | undefined, opts?: object | null): asserts node is Loop; +declare function assertWhile(node: object | null | undefined, opts?: object | null): asserts node is While; +declare function assertExpressionWrapper(node: object | null | undefined, opts?: object | null): asserts node is ExpressionWrapper; +declare function assertFor(node: object | null | undefined, opts?: object | null): asserts node is For; +declare function assertForXStatement(node: object | null | undefined, opts?: object | null): asserts node is ForXStatement; +declare function assertFunction(node: object | null | undefined, opts?: object | null): asserts node is Function; +declare function assertFunctionParent(node: object | null | undefined, opts?: object | null): asserts node is FunctionParent; +declare function assertPureish(node: object | null | undefined, opts?: object | null): asserts node is Pureish; +declare function assertDeclaration(node: object | null | undefined, opts?: object | null): asserts node is Declaration; +declare function assertFunctionParameter(node: object | null | undefined, opts?: object | null): asserts node is FunctionParameter; +declare function assertPatternLike(node: object | null | undefined, opts?: object | null): asserts node is PatternLike; +declare function assertLVal(node: object | null | undefined, opts?: object | null): asserts node is LVal; +declare function assertTSEntityName(node: object | null | undefined, opts?: object | null): asserts node is TSEntityName; +declare function assertLiteral(node: object | null | undefined, opts?: object | null): asserts node is Literal; +declare function assertImmutable(node: object | null | undefined, opts?: object | null): asserts node is Immutable; +declare function assertUserWhitespacable(node: object | null | undefined, opts?: object | null): asserts node is UserWhitespacable; +declare function assertMethod(node: object | null | undefined, opts?: object | null): asserts node is Method; +declare function assertObjectMember(node: object | null | undefined, opts?: object | null): asserts node is ObjectMember; +declare function assertProperty(node: object | null | undefined, opts?: object | null): asserts node is Property; +declare function assertUnaryLike(node: object | null | undefined, opts?: object | null): asserts node is UnaryLike; +declare function assertPattern(node: object | null | undefined, opts?: object | null): asserts node is Pattern; +declare function assertClass(node: object | null | undefined, opts?: object | null): asserts node is Class; +declare function assertImportOrExportDeclaration(node: object | null | undefined, opts?: object | null): asserts node is ImportOrExportDeclaration; +declare function assertExportDeclaration(node: object | null | undefined, opts?: object | null): asserts node is ExportDeclaration; +declare function assertModuleSpecifier(node: object | null | undefined, opts?: object | null): asserts node is ModuleSpecifier; +declare function assertAccessor(node: object | null | undefined, opts?: object | null): asserts node is Accessor; +declare function assertPrivate(node: object | null | undefined, opts?: object | null): asserts node is Private; +declare function assertFlow(node: object | null | undefined, opts?: object | null): asserts node is Flow; +declare function assertFlowType(node: object | null | undefined, opts?: object | null): asserts node is FlowType; +declare function assertFlowBaseAnnotation(node: object | null | undefined, opts?: object | null): asserts node is FlowBaseAnnotation; +declare function assertFlowDeclaration(node: object | null | undefined, opts?: object | null): asserts node is FlowDeclaration; +declare function assertFlowPredicate(node: object | null | undefined, opts?: object | null): asserts node is FlowPredicate; +declare function assertEnumBody(node: object | null | undefined, opts?: object | null): asserts node is EnumBody; +declare function assertEnumMember(node: object | null | undefined, opts?: object | null): asserts node is EnumMember; +declare function assertJSX(node: object | null | undefined, opts?: object | null): asserts node is JSX; +declare function assertMiscellaneous(node: object | null | undefined, opts?: object | null): asserts node is Miscellaneous; +declare function assertTypeScript(node: object | null | undefined, opts?: object | null): asserts node is TypeScript; +declare function assertTSTypeElement(node: object | null | undefined, opts?: object | null): asserts node is TSTypeElement; +declare function assertTSType(node: object | null | undefined, opts?: object | null): asserts node is TSType; +declare function assertTSBaseType(node: object | null | undefined, opts?: object | null): asserts node is TSBaseType; +declare function assertNumberLiteral(node: any, opts: any): void; +declare function assertRegexLiteral(node: any, opts: any): void; +declare function assertRestProperty(node: any, opts: any): void; +declare function assertSpreadProperty(node: any, opts: any): void; +declare function assertModuleDeclaration(node: any, opts: any): void; + +declare const _default$4: { + (type: "string"): StringTypeAnnotation; + (type: "number"): NumberTypeAnnotation; + (type: "undefined"): VoidTypeAnnotation; + (type: "boolean"): BooleanTypeAnnotation; + (type: "function"): GenericTypeAnnotation; + (type: "object"): GenericTypeAnnotation; + (type: "symbol"): GenericTypeAnnotation; + (type: "bigint"): AnyTypeAnnotation; +}; +//# sourceMappingURL=createTypeAnnotationBasedOnTypeof.d.ts.map + +/** + * Takes an array of `types` and flattens them, removing duplicates and + * returns a `UnionTypeAnnotation` node containing them. + */ +declare function createFlowUnionType(types: [T] | T[]): T | UnionTypeAnnotation; + +/** + * Takes an array of `types` and flattens them, removing duplicates and + * returns a `UnionTypeAnnotation` node containing them. + */ +declare function createTSUnionType(typeAnnotations: (TSTypeAnnotation | TSType)[]): TSType; + +interface BaseComment { + value: string; + start?: number; + end?: number; + loc?: SourceLocation; + ignore?: boolean; + type: "CommentBlock" | "CommentLine"; +} +interface Position { + line: number; + column: number; + index: number; +} +interface CommentBlock extends BaseComment { + type: "CommentBlock"; +} +interface CommentLine extends BaseComment { + type: "CommentLine"; +} +type Comment = CommentBlock | CommentLine; +interface SourceLocation { + start: Position; + end: Position; + filename: string; + identifierName: string | undefined | null; +} +interface BaseNode { + leadingComments?: Comment[] | null; + innerComments?: Comment[] | null; + trailingComments?: Comment[] | null; + start?: number | null; + end?: number | null; + loc?: SourceLocation | null; + range?: [number, number]; + extra?: Record; +} +type CommentTypeShorthand = "leading" | "inner" | "trailing"; +type Node = AnyTypeAnnotation | ArgumentPlaceholder | ArrayExpression | ArrayPattern | ArrayTypeAnnotation | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BigIntLiteral | BinaryExpression | BindExpression | BlockStatement | BooleanLiteral | BooleanLiteralTypeAnnotation | BooleanTypeAnnotation | BreakStatement | CallExpression | CatchClause | ClassAccessorProperty | ClassBody | ClassDeclaration | ClassExpression | ClassImplements | ClassMethod | ClassPrivateMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | ContinueStatement | DebuggerStatement | DecimalLiteral | DeclareClass | DeclareExportAllDeclaration | DeclareExportDeclaration | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareOpaqueType | DeclareTypeAlias | DeclareVariable | DeclaredPredicate | Decorator | Directive | DirectiveLiteral | DoExpression | DoWhileStatement | EmptyStatement | EmptyTypeAnnotation | EnumBooleanBody | EnumBooleanMember | EnumDeclaration | EnumDefaultedMember | EnumNumberBody | EnumNumberMember | EnumStringBody | EnumStringMember | EnumSymbolBody | ExistsTypeAnnotation | ExportAllDeclaration | ExportDefaultDeclaration | ExportDefaultSpecifier | ExportNamedDeclaration | ExportNamespaceSpecifier | ExportSpecifier | ExpressionStatement | File | ForInStatement | ForOfStatement | ForStatement | FunctionDeclaration | FunctionExpression | FunctionTypeAnnotation | FunctionTypeParam | GenericTypeAnnotation | Identifier | IfStatement | Import | ImportAttribute | ImportDeclaration | ImportDefaultSpecifier | ImportExpression | ImportNamespaceSpecifier | ImportSpecifier | IndexedAccessType | InferredPredicate | InterfaceDeclaration | InterfaceExtends | InterfaceTypeAnnotation | InterpreterDirective | IntersectionTypeAnnotation | JSXAttribute | JSXClosingElement | JSXClosingFragment | JSXElement | JSXEmptyExpression | JSXExpressionContainer | JSXFragment | JSXIdentifier | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement | JSXOpeningFragment | JSXSpreadAttribute | JSXSpreadChild | JSXText | LabeledStatement | LogicalExpression | MemberExpression | MetaProperty | MixedTypeAnnotation | ModuleExpression | NewExpression | Noop | NullLiteral | NullLiteralTypeAnnotation | NullableTypeAnnotation | NumberLiteral$1 | NumberLiteralTypeAnnotation | NumberTypeAnnotation | NumericLiteral | ObjectExpression | ObjectMethod | ObjectPattern | ObjectProperty | ObjectTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalCallExpression | OptionalIndexedAccessType | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelinePrimaryTopicReference | PipelineTopicExpression | Placeholder | PrivateName | Program | QualifiedTypeIdentifier | RecordExpression | RegExpLiteral | RegexLiteral$1 | RestElement | RestProperty$1 | ReturnStatement | SequenceExpression | SpreadElement | SpreadProperty$1 | StaticBlock | StringLiteral | StringLiteralTypeAnnotation | StringTypeAnnotation | Super | SwitchCase | SwitchStatement | SymbolTypeAnnotation | TSAnyKeyword | TSArrayType | TSAsExpression | TSBigIntKeyword | TSBooleanKeyword | TSCallSignatureDeclaration | TSConditionalType | TSConstructSignatureDeclaration | TSConstructorType | TSDeclareFunction | TSDeclareMethod | TSEnumBody | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSExpressionWithTypeArguments | TSExternalModuleReference | TSFunctionType | TSImportEqualsDeclaration | TSImportType | TSIndexSignature | TSIndexedAccessType | TSInferType | TSInstantiationExpression | TSInterfaceBody | TSInterfaceDeclaration | TSIntersectionType | TSIntrinsicKeyword | TSLiteralType | TSMappedType | TSMethodSignature | TSModuleBlock | TSModuleDeclaration | TSNamedTupleMember | TSNamespaceExportDeclaration | TSNeverKeyword | TSNonNullExpression | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSOptionalType | TSParameterProperty | TSParenthesizedType | TSPropertySignature | TSQualifiedName | TSRestType | TSSatisfiesExpression | TSStringKeyword | TSSymbolKeyword | TSTemplateLiteralType | TSThisType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeLiteral | TSTypeOperator | TSTypeParameter | TSTypeParameterDeclaration | TSTypeParameterInstantiation | TSTypePredicate | TSTypeQuery | TSTypeReference | TSUndefinedKeyword | TSUnionType | TSUnknownKeyword | TSVoidKeyword | TaggedTemplateExpression | TemplateElement | TemplateLiteral | ThisExpression | ThisTypeAnnotation | ThrowStatement | TopicReference | TryStatement | TupleExpression | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeCastExpression | TypeParameter | TypeParameterDeclaration | TypeParameterInstantiation | TypeofTypeAnnotation | UnaryExpression | UnionTypeAnnotation | UpdateExpression | V8IntrinsicIdentifier | VariableDeclaration | VariableDeclarator | Variance | VoidPattern | VoidTypeAnnotation | WhileStatement | WithStatement | YieldExpression; +interface ArrayExpression extends BaseNode { + type: "ArrayExpression"; + elements: (null | Expression | SpreadElement)[]; +} +interface AssignmentExpression extends BaseNode { + type: "AssignmentExpression"; + operator: string; + left: LVal | OptionalMemberExpression; + right: Expression; +} +interface BinaryExpression extends BaseNode { + type: "BinaryExpression"; + operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=" | "|>"; + left: Expression | PrivateName; + right: Expression; +} +interface InterpreterDirective extends BaseNode { + type: "InterpreterDirective"; + value: string; +} +interface Directive extends BaseNode { + type: "Directive"; + value: DirectiveLiteral; +} +interface DirectiveLiteral extends BaseNode { + type: "DirectiveLiteral"; + value: string; +} +interface BlockStatement extends BaseNode { + type: "BlockStatement"; + body: Statement[]; + directives: Directive[]; +} +interface BreakStatement extends BaseNode { + type: "BreakStatement"; + label?: Identifier | null; +} +interface CallExpression extends BaseNode { + type: "CallExpression"; + callee: Expression | Super | V8IntrinsicIdentifier; + arguments: (Expression | SpreadElement | ArgumentPlaceholder)[]; + optional?: boolean | null; + typeArguments?: TypeParameterInstantiation | null; + typeParameters?: TSTypeParameterInstantiation | null; +} +interface CatchClause extends BaseNode { + type: "CatchClause"; + param?: Identifier | ArrayPattern | ObjectPattern | null; + body: BlockStatement; +} +interface ConditionalExpression extends BaseNode { + type: "ConditionalExpression"; + test: Expression; + consequent: Expression; + alternate: Expression; +} +interface ContinueStatement extends BaseNode { + type: "ContinueStatement"; + label?: Identifier | null; +} +interface DebuggerStatement extends BaseNode { + type: "DebuggerStatement"; +} +interface DoWhileStatement extends BaseNode { + type: "DoWhileStatement"; + test: Expression; + body: Statement; +} +interface EmptyStatement extends BaseNode { + type: "EmptyStatement"; +} +interface ExpressionStatement extends BaseNode { + type: "ExpressionStatement"; + expression: Expression; +} +interface File extends BaseNode { + type: "File"; + program: Program; + comments?: (CommentBlock | CommentLine)[] | null; + tokens?: any[] | null; +} +interface ForInStatement extends BaseNode { + type: "ForInStatement"; + left: VariableDeclaration | LVal; + right: Expression; + body: Statement; +} +interface ForStatement extends BaseNode { + type: "ForStatement"; + init?: VariableDeclaration | Expression | null; + test?: Expression | null; + update?: Expression | null; + body: Statement; +} +interface FunctionDeclaration extends BaseNode { + type: "FunctionDeclaration"; + id?: Identifier | null; + params: FunctionParameter[]; + body: BlockStatement; + generator: boolean; + async: boolean; + declare?: boolean | null; + predicate?: DeclaredPredicate | InferredPredicate | null; + returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null; + typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null; +} +interface FunctionExpression extends BaseNode { + type: "FunctionExpression"; + id?: Identifier | null; + params: FunctionParameter[]; + body: BlockStatement; + generator: boolean; + async: boolean; + predicate?: DeclaredPredicate | InferredPredicate | null; + returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null; + typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null; +} +interface Identifier extends BaseNode { + type: "Identifier"; + name: string; + decorators?: Decorator[] | null; + optional?: boolean | null; + typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null; +} +interface IfStatement extends BaseNode { + type: "IfStatement"; + test: Expression; + consequent: Statement; + alternate?: Statement | null; +} +interface LabeledStatement extends BaseNode { + type: "LabeledStatement"; + label: Identifier; + body: Statement; +} +interface StringLiteral extends BaseNode { + type: "StringLiteral"; + value: string; +} +interface NumericLiteral extends BaseNode { + type: "NumericLiteral"; + value: number; +} +/** + * @deprecated Use `NumericLiteral` + */ +interface NumberLiteral$1 extends BaseNode { + type: "NumberLiteral"; + value: number; +} +interface NullLiteral extends BaseNode { + type: "NullLiteral"; +} +interface BooleanLiteral extends BaseNode { + type: "BooleanLiteral"; + value: boolean; +} +interface RegExpLiteral extends BaseNode { + type: "RegExpLiteral"; + pattern: string; + flags: string; +} +/** + * @deprecated Use `RegExpLiteral` + */ +interface RegexLiteral$1 extends BaseNode { + type: "RegexLiteral"; + pattern: string; + flags: string; +} +interface LogicalExpression extends BaseNode { + type: "LogicalExpression"; + operator: "||" | "&&" | "??"; + left: Expression; + right: Expression; +} +interface MemberExpression extends BaseNode { + type: "MemberExpression"; + object: Expression | Super; + property: Expression | Identifier | PrivateName; + computed: boolean; + optional?: boolean | null; +} +interface NewExpression extends BaseNode { + type: "NewExpression"; + callee: Expression | Super | V8IntrinsicIdentifier; + arguments: (Expression | SpreadElement | ArgumentPlaceholder)[]; + optional?: boolean | null; + typeArguments?: TypeParameterInstantiation | null; + typeParameters?: TSTypeParameterInstantiation | null; +} +interface Program extends BaseNode { + type: "Program"; + body: Statement[]; + directives: Directive[]; + sourceType: "script" | "module"; + interpreter?: InterpreterDirective | null; +} +interface ObjectExpression extends BaseNode { + type: "ObjectExpression"; + properties: (ObjectMethod | ObjectProperty | SpreadElement)[]; +} +interface ObjectMethod extends BaseNode { + type: "ObjectMethod"; + kind: "method" | "get" | "set"; + key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral; + params: FunctionParameter[]; + body: BlockStatement; + computed: boolean; + generator: boolean; + async: boolean; + decorators?: Decorator[] | null; + returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null; + typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null; +} +interface ObjectProperty extends BaseNode { + type: "ObjectProperty"; + key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral | DecimalLiteral | PrivateName; + value: Expression | PatternLike; + computed: boolean; + shorthand: boolean; + decorators?: Decorator[] | null; +} +interface RestElement extends BaseNode { + type: "RestElement"; + argument: Identifier | ArrayPattern | ObjectPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression | RestElement | AssignmentPattern; + decorators?: Decorator[] | null; + optional?: boolean | null; + typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null; +} +/** + * @deprecated Use `RestElement` + */ +interface RestProperty$1 extends BaseNode { + type: "RestProperty"; + argument: Identifier | ArrayPattern | ObjectPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression | RestElement | AssignmentPattern; + decorators?: Decorator[] | null; + optional?: boolean | null; + typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null; +} +interface ReturnStatement extends BaseNode { + type: "ReturnStatement"; + argument?: Expression | null; +} +interface SequenceExpression extends BaseNode { + type: "SequenceExpression"; + expressions: Expression[]; +} +interface ParenthesizedExpression extends BaseNode { + type: "ParenthesizedExpression"; + expression: Expression; +} +interface SwitchCase extends BaseNode { + type: "SwitchCase"; + test?: Expression | null; + consequent: Statement[]; +} +interface SwitchStatement extends BaseNode { + type: "SwitchStatement"; + discriminant: Expression; + cases: SwitchCase[]; +} +interface ThisExpression extends BaseNode { + type: "ThisExpression"; +} +interface ThrowStatement extends BaseNode { + type: "ThrowStatement"; + argument: Expression; +} +interface TryStatement extends BaseNode { + type: "TryStatement"; + block: BlockStatement; + handler?: CatchClause | null; + finalizer?: BlockStatement | null; +} +interface UnaryExpression extends BaseNode { + type: "UnaryExpression"; + operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof"; + argument: Expression; + prefix: boolean; +} +interface UpdateExpression extends BaseNode { + type: "UpdateExpression"; + operator: "++" | "--"; + argument: Expression; + prefix: boolean; +} +interface VariableDeclaration extends BaseNode { + type: "VariableDeclaration"; + kind: "var" | "let" | "const" | "using" | "await using"; + declarations: VariableDeclarator[]; + declare?: boolean | null; +} +interface VariableDeclarator extends BaseNode { + type: "VariableDeclarator"; + id: LVal | VoidPattern; + init?: Expression | null; + definite?: boolean | null; +} +interface WhileStatement extends BaseNode { + type: "WhileStatement"; + test: Expression; + body: Statement; +} +interface WithStatement extends BaseNode { + type: "WithStatement"; + object: Expression; + body: Statement; +} +interface AssignmentPattern extends BaseNode { + type: "AssignmentPattern"; + left: Identifier | ObjectPattern | ArrayPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression; + right: Expression; + decorators?: Decorator[] | null; + optional?: boolean | null; + typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null; +} +interface ArrayPattern extends BaseNode { + type: "ArrayPattern"; + elements: (null | PatternLike)[]; + decorators?: Decorator[] | null; + optional?: boolean | null; + typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null; +} +interface ArrowFunctionExpression extends BaseNode { + type: "ArrowFunctionExpression"; + params: FunctionParameter[]; + body: BlockStatement | Expression; + async: boolean; + expression: boolean; + generator?: boolean; + predicate?: DeclaredPredicate | InferredPredicate | null; + returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null; + typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null; +} +interface ClassBody extends BaseNode { + type: "ClassBody"; + body: (ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty | ClassAccessorProperty | TSDeclareMethod | TSIndexSignature | StaticBlock)[]; +} +interface ClassExpression extends BaseNode { + type: "ClassExpression"; + id?: Identifier | null; + superClass?: Expression | null; + body: ClassBody; + decorators?: Decorator[] | null; + implements?: (TSExpressionWithTypeArguments | ClassImplements)[] | null; + mixins?: InterfaceExtends | null; + superTypeParameters?: TypeParameterInstantiation | TSTypeParameterInstantiation | null; + typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null; +} +interface ClassDeclaration extends BaseNode { + type: "ClassDeclaration"; + id?: Identifier | null; + superClass?: Expression | null; + body: ClassBody; + decorators?: Decorator[] | null; + abstract?: boolean | null; + declare?: boolean | null; + implements?: (TSExpressionWithTypeArguments | ClassImplements)[] | null; + mixins?: InterfaceExtends | null; + superTypeParameters?: TypeParameterInstantiation | TSTypeParameterInstantiation | null; + typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null; +} +interface ExportAllDeclaration extends BaseNode { + type: "ExportAllDeclaration"; + source: StringLiteral; + attributes?: ImportAttribute[] | null; + /** @deprecated */ + assertions?: ImportAttribute[] | null; + exportKind?: "type" | "value" | null; +} +interface ExportDefaultDeclaration extends BaseNode { + type: "ExportDefaultDeclaration"; + declaration: TSDeclareFunction | FunctionDeclaration | ClassDeclaration | Expression; + exportKind?: "value" | null; +} +interface ExportNamedDeclaration extends BaseNode { + type: "ExportNamedDeclaration"; + declaration?: Declaration | null; + specifiers: (ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier)[]; + source?: StringLiteral | null; + attributes?: ImportAttribute[] | null; + /** @deprecated */ + assertions?: ImportAttribute[] | null; + exportKind?: "type" | "value" | null; +} +interface ExportSpecifier extends BaseNode { + type: "ExportSpecifier"; + local: Identifier; + exported: Identifier | StringLiteral; + exportKind?: "type" | "value" | null; +} +interface ForOfStatement extends BaseNode { + type: "ForOfStatement"; + left: VariableDeclaration | LVal; + right: Expression; + body: Statement; + await: boolean; +} +interface ImportDeclaration extends BaseNode { + type: "ImportDeclaration"; + specifiers: (ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier)[]; + source: StringLiteral; + attributes?: ImportAttribute[] | null; + /** @deprecated */ + assertions?: ImportAttribute[] | null; + importKind?: "type" | "typeof" | "value" | null; + module?: boolean | null; + phase?: "source" | "defer" | null; +} +interface ImportDefaultSpecifier extends BaseNode { + type: "ImportDefaultSpecifier"; + local: Identifier; +} +interface ImportNamespaceSpecifier extends BaseNode { + type: "ImportNamespaceSpecifier"; + local: Identifier; +} +interface ImportSpecifier extends BaseNode { + type: "ImportSpecifier"; + local: Identifier; + imported: Identifier | StringLiteral; + importKind?: "type" | "typeof" | "value" | null; +} +interface ImportExpression extends BaseNode { + type: "ImportExpression"; + source: Expression; + options?: Expression | null; + phase?: "source" | "defer" | null; +} +interface MetaProperty extends BaseNode { + type: "MetaProperty"; + meta: Identifier; + property: Identifier; +} +interface ClassMethod extends BaseNode { + type: "ClassMethod"; + kind: "get" | "set" | "method" | "constructor"; + key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression; + params: (FunctionParameter | TSParameterProperty)[]; + body: BlockStatement; + computed: boolean; + static: boolean; + generator: boolean; + async: boolean; + abstract?: boolean | null; + access?: "public" | "private" | "protected" | null; + accessibility?: "public" | "private" | "protected" | null; + decorators?: Decorator[] | null; + optional?: boolean | null; + override?: boolean; + returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null; + typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null; +} +interface ObjectPattern extends BaseNode { + type: "ObjectPattern"; + properties: (RestElement | ObjectProperty)[]; + decorators?: Decorator[] | null; + optional?: boolean | null; + typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null; +} +interface SpreadElement extends BaseNode { + type: "SpreadElement"; + argument: Expression; +} +/** + * @deprecated Use `SpreadElement` + */ +interface SpreadProperty$1 extends BaseNode { + type: "SpreadProperty"; + argument: Expression; +} +interface Super extends BaseNode { + type: "Super"; +} +interface TaggedTemplateExpression extends BaseNode { + type: "TaggedTemplateExpression"; + tag: Expression; + quasi: TemplateLiteral; + typeParameters?: TypeParameterInstantiation | TSTypeParameterInstantiation | null; +} +interface TemplateElement extends BaseNode { + type: "TemplateElement"; + value: { + raw: string; + cooked?: string; + }; + tail: boolean; +} +interface TemplateLiteral extends BaseNode { + type: "TemplateLiteral"; + quasis: TemplateElement[]; + expressions: (Expression | TSType)[]; +} +interface YieldExpression extends BaseNode { + type: "YieldExpression"; + argument?: Expression | null; + delegate: boolean; +} +interface AwaitExpression extends BaseNode { + type: "AwaitExpression"; + argument: Expression; +} +interface Import extends BaseNode { + type: "Import"; +} +interface BigIntLiteral extends BaseNode { + type: "BigIntLiteral"; + value: string; +} +interface ExportNamespaceSpecifier extends BaseNode { + type: "ExportNamespaceSpecifier"; + exported: Identifier; +} +interface OptionalMemberExpression extends BaseNode { + type: "OptionalMemberExpression"; + object: Expression; + property: Expression | Identifier; + computed: boolean; + optional: boolean; +} +interface OptionalCallExpression extends BaseNode { + type: "OptionalCallExpression"; + callee: Expression; + arguments: (Expression | SpreadElement | ArgumentPlaceholder)[]; + optional: boolean; + typeArguments?: TypeParameterInstantiation | null; + typeParameters?: TSTypeParameterInstantiation | null; +} +interface ClassProperty extends BaseNode { + type: "ClassProperty"; + key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression; + value?: Expression | null; + typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null; + decorators?: Decorator[] | null; + computed: boolean; + static: boolean; + abstract?: boolean | null; + accessibility?: "public" | "private" | "protected" | null; + declare?: boolean | null; + definite?: boolean | null; + optional?: boolean | null; + override?: boolean; + readonly?: boolean | null; + variance?: Variance | null; +} +interface ClassAccessorProperty extends BaseNode { + type: "ClassAccessorProperty"; + key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression | PrivateName; + value?: Expression | null; + typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null; + decorators?: Decorator[] | null; + computed: boolean; + static: boolean; + abstract?: boolean | null; + accessibility?: "public" | "private" | "protected" | null; + declare?: boolean | null; + definite?: boolean | null; + optional?: boolean | null; + override?: boolean; + readonly?: boolean | null; + variance?: Variance | null; +} +interface ClassPrivateProperty extends BaseNode { + type: "ClassPrivateProperty"; + key: PrivateName; + value?: Expression | null; + decorators?: Decorator[] | null; + static: boolean; + definite?: boolean | null; + optional?: boolean | null; + readonly?: boolean | null; + typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null; + variance?: Variance | null; +} +interface ClassPrivateMethod extends BaseNode { + type: "ClassPrivateMethod"; + kind: "get" | "set" | "method"; + key: PrivateName; + params: (FunctionParameter | TSParameterProperty)[]; + body: BlockStatement; + static: boolean; + abstract?: boolean | null; + access?: "public" | "private" | "protected" | null; + accessibility?: "public" | "private" | "protected" | null; + async?: boolean; + computed?: boolean; + decorators?: Decorator[] | null; + generator?: boolean; + optional?: boolean | null; + override?: boolean; + returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null; + typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null; +} +interface PrivateName extends BaseNode { + type: "PrivateName"; + id: Identifier; +} +interface StaticBlock extends BaseNode { + type: "StaticBlock"; + body: Statement[]; +} +interface ImportAttribute extends BaseNode { + type: "ImportAttribute"; + key: Identifier | StringLiteral; + value: StringLiteral; +} +interface AnyTypeAnnotation extends BaseNode { + type: "AnyTypeAnnotation"; +} +interface ArrayTypeAnnotation extends BaseNode { + type: "ArrayTypeAnnotation"; + elementType: FlowType; +} +interface BooleanTypeAnnotation extends BaseNode { + type: "BooleanTypeAnnotation"; +} +interface BooleanLiteralTypeAnnotation extends BaseNode { + type: "BooleanLiteralTypeAnnotation"; + value: boolean; +} +interface NullLiteralTypeAnnotation extends BaseNode { + type: "NullLiteralTypeAnnotation"; +} +interface ClassImplements extends BaseNode { + type: "ClassImplements"; + id: Identifier; + typeParameters?: TypeParameterInstantiation | null; +} +interface DeclareClass extends BaseNode { + type: "DeclareClass"; + id: Identifier; + typeParameters?: TypeParameterDeclaration | null; + extends?: InterfaceExtends[] | null; + body: ObjectTypeAnnotation; + implements?: ClassImplements[] | null; + mixins?: InterfaceExtends[] | null; +} +interface DeclareFunction extends BaseNode { + type: "DeclareFunction"; + id: Identifier; + predicate?: DeclaredPredicate | null; +} +interface DeclareInterface extends BaseNode { + type: "DeclareInterface"; + id: Identifier; + typeParameters?: TypeParameterDeclaration | null; + extends?: InterfaceExtends[] | null; + body: ObjectTypeAnnotation; +} +interface DeclareModule extends BaseNode { + type: "DeclareModule"; + id: Identifier | StringLiteral; + body: BlockStatement; + kind?: "CommonJS" | "ES" | null; +} +interface DeclareModuleExports extends BaseNode { + type: "DeclareModuleExports"; + typeAnnotation: TypeAnnotation; +} +interface DeclareTypeAlias extends BaseNode { + type: "DeclareTypeAlias"; + id: Identifier; + typeParameters?: TypeParameterDeclaration | null; + right: FlowType; +} +interface DeclareOpaqueType extends BaseNode { + type: "DeclareOpaqueType"; + id: Identifier; + typeParameters?: TypeParameterDeclaration | null; + supertype?: FlowType | null; + impltype?: FlowType | null; +} +interface DeclareVariable extends BaseNode { + type: "DeclareVariable"; + id: Identifier; +} +interface DeclareExportDeclaration extends BaseNode { + type: "DeclareExportDeclaration"; + declaration?: Flow | null; + specifiers?: (ExportSpecifier | ExportNamespaceSpecifier)[] | null; + source?: StringLiteral | null; + attributes?: ImportAttribute[] | null; + /** @deprecated */ + assertions?: ImportAttribute[] | null; + default?: boolean | null; +} +interface DeclareExportAllDeclaration extends BaseNode { + type: "DeclareExportAllDeclaration"; + source: StringLiteral; + attributes?: ImportAttribute[] | null; + /** @deprecated */ + assertions?: ImportAttribute[] | null; + exportKind?: "type" | "value" | null; +} +interface DeclaredPredicate extends BaseNode { + type: "DeclaredPredicate"; + value: Flow; +} +interface ExistsTypeAnnotation extends BaseNode { + type: "ExistsTypeAnnotation"; +} +interface FunctionTypeAnnotation extends BaseNode { + type: "FunctionTypeAnnotation"; + typeParameters?: TypeParameterDeclaration | null; + params: FunctionTypeParam[]; + rest?: FunctionTypeParam | null; + returnType: FlowType; + this?: FunctionTypeParam | null; +} +interface FunctionTypeParam extends BaseNode { + type: "FunctionTypeParam"; + name?: Identifier | null; + typeAnnotation: FlowType; + optional?: boolean | null; +} +interface GenericTypeAnnotation extends BaseNode { + type: "GenericTypeAnnotation"; + id: Identifier | QualifiedTypeIdentifier; + typeParameters?: TypeParameterInstantiation | null; +} +interface InferredPredicate extends BaseNode { + type: "InferredPredicate"; +} +interface InterfaceExtends extends BaseNode { + type: "InterfaceExtends"; + id: Identifier | QualifiedTypeIdentifier; + typeParameters?: TypeParameterInstantiation | null; +} +interface InterfaceDeclaration extends BaseNode { + type: "InterfaceDeclaration"; + id: Identifier; + typeParameters?: TypeParameterDeclaration | null; + extends?: InterfaceExtends[] | null; + body: ObjectTypeAnnotation; +} +interface InterfaceTypeAnnotation extends BaseNode { + type: "InterfaceTypeAnnotation"; + extends?: InterfaceExtends[] | null; + body: ObjectTypeAnnotation; +} +interface IntersectionTypeAnnotation extends BaseNode { + type: "IntersectionTypeAnnotation"; + types: FlowType[]; +} +interface MixedTypeAnnotation extends BaseNode { + type: "MixedTypeAnnotation"; +} +interface EmptyTypeAnnotation extends BaseNode { + type: "EmptyTypeAnnotation"; +} +interface NullableTypeAnnotation extends BaseNode { + type: "NullableTypeAnnotation"; + typeAnnotation: FlowType; +} +interface NumberLiteralTypeAnnotation extends BaseNode { + type: "NumberLiteralTypeAnnotation"; + value: number; +} +interface NumberTypeAnnotation extends BaseNode { + type: "NumberTypeAnnotation"; +} +interface ObjectTypeAnnotation extends BaseNode { + type: "ObjectTypeAnnotation"; + properties: (ObjectTypeProperty | ObjectTypeSpreadProperty)[]; + indexers?: ObjectTypeIndexer[]; + callProperties?: ObjectTypeCallProperty[]; + internalSlots?: ObjectTypeInternalSlot[]; + exact: boolean; + inexact?: boolean | null; +} +interface ObjectTypeInternalSlot extends BaseNode { + type: "ObjectTypeInternalSlot"; + id: Identifier; + value: FlowType; + optional: boolean; + static: boolean; + method: boolean; +} +interface ObjectTypeCallProperty extends BaseNode { + type: "ObjectTypeCallProperty"; + value: FlowType; + static: boolean; +} +interface ObjectTypeIndexer extends BaseNode { + type: "ObjectTypeIndexer"; + id?: Identifier | null; + key: FlowType; + value: FlowType; + variance?: Variance | null; + static: boolean; +} +interface ObjectTypeProperty extends BaseNode { + type: "ObjectTypeProperty"; + key: Identifier | StringLiteral; + value: FlowType; + variance?: Variance | null; + kind: "init" | "get" | "set"; + method: boolean; + optional: boolean; + proto: boolean; + static: boolean; +} +interface ObjectTypeSpreadProperty extends BaseNode { + type: "ObjectTypeSpreadProperty"; + argument: FlowType; +} +interface OpaqueType extends BaseNode { + type: "OpaqueType"; + id: Identifier; + typeParameters?: TypeParameterDeclaration | null; + supertype?: FlowType | null; + impltype: FlowType; +} +interface QualifiedTypeIdentifier extends BaseNode { + type: "QualifiedTypeIdentifier"; + id: Identifier; + qualification: Identifier | QualifiedTypeIdentifier; +} +interface StringLiteralTypeAnnotation extends BaseNode { + type: "StringLiteralTypeAnnotation"; + value: string; +} +interface StringTypeAnnotation extends BaseNode { + type: "StringTypeAnnotation"; +} +interface SymbolTypeAnnotation extends BaseNode { + type: "SymbolTypeAnnotation"; +} +interface ThisTypeAnnotation extends BaseNode { + type: "ThisTypeAnnotation"; +} +interface TupleTypeAnnotation extends BaseNode { + type: "TupleTypeAnnotation"; + types: FlowType[]; +} +interface TypeofTypeAnnotation extends BaseNode { + type: "TypeofTypeAnnotation"; + argument: FlowType; +} +interface TypeAlias extends BaseNode { + type: "TypeAlias"; + id: Identifier; + typeParameters?: TypeParameterDeclaration | null; + right: FlowType; +} +interface TypeAnnotation extends BaseNode { + type: "TypeAnnotation"; + typeAnnotation: FlowType; +} +interface TypeCastExpression extends BaseNode { + type: "TypeCastExpression"; + expression: Expression; + typeAnnotation: TypeAnnotation; +} +interface TypeParameter extends BaseNode { + type: "TypeParameter"; + bound?: TypeAnnotation | null; + default?: FlowType | null; + variance?: Variance | null; + name: string; +} +interface TypeParameterDeclaration extends BaseNode { + type: "TypeParameterDeclaration"; + params: TypeParameter[]; +} +interface TypeParameterInstantiation extends BaseNode { + type: "TypeParameterInstantiation"; + params: FlowType[]; +} +interface UnionTypeAnnotation extends BaseNode { + type: "UnionTypeAnnotation"; + types: FlowType[]; +} +interface Variance extends BaseNode { + type: "Variance"; + kind: "minus" | "plus"; +} +interface VoidTypeAnnotation extends BaseNode { + type: "VoidTypeAnnotation"; +} +interface EnumDeclaration extends BaseNode { + type: "EnumDeclaration"; + id: Identifier; + body: EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody; +} +interface EnumBooleanBody extends BaseNode { + type: "EnumBooleanBody"; + members: EnumBooleanMember[]; + explicitType: boolean; + hasUnknownMembers: boolean; +} +interface EnumNumberBody extends BaseNode { + type: "EnumNumberBody"; + members: EnumNumberMember[]; + explicitType: boolean; + hasUnknownMembers: boolean; +} +interface EnumStringBody extends BaseNode { + type: "EnumStringBody"; + members: (EnumStringMember | EnumDefaultedMember)[]; + explicitType: boolean; + hasUnknownMembers: boolean; +} +interface EnumSymbolBody extends BaseNode { + type: "EnumSymbolBody"; + members: EnumDefaultedMember[]; + hasUnknownMembers: boolean; +} +interface EnumBooleanMember extends BaseNode { + type: "EnumBooleanMember"; + id: Identifier; + init: BooleanLiteral; +} +interface EnumNumberMember extends BaseNode { + type: "EnumNumberMember"; + id: Identifier; + init: NumericLiteral; +} +interface EnumStringMember extends BaseNode { + type: "EnumStringMember"; + id: Identifier; + init: StringLiteral; +} +interface EnumDefaultedMember extends BaseNode { + type: "EnumDefaultedMember"; + id: Identifier; +} +interface IndexedAccessType extends BaseNode { + type: "IndexedAccessType"; + objectType: FlowType; + indexType: FlowType; +} +interface OptionalIndexedAccessType extends BaseNode { + type: "OptionalIndexedAccessType"; + objectType: FlowType; + indexType: FlowType; + optional: boolean; +} +interface JSXAttribute extends BaseNode { + type: "JSXAttribute"; + name: JSXIdentifier | JSXNamespacedName; + value?: JSXElement | JSXFragment | StringLiteral | JSXExpressionContainer | null; +} +interface JSXClosingElement extends BaseNode { + type: "JSXClosingElement"; + name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName; +} +interface JSXElement extends BaseNode { + type: "JSXElement"; + openingElement: JSXOpeningElement; + closingElement?: JSXClosingElement | null; + children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[]; + selfClosing?: boolean | null; +} +interface JSXEmptyExpression extends BaseNode { + type: "JSXEmptyExpression"; +} +interface JSXExpressionContainer extends BaseNode { + type: "JSXExpressionContainer"; + expression: Expression | JSXEmptyExpression; +} +interface JSXSpreadChild extends BaseNode { + type: "JSXSpreadChild"; + expression: Expression; +} +interface JSXIdentifier extends BaseNode { + type: "JSXIdentifier"; + name: string; +} +interface JSXMemberExpression extends BaseNode { + type: "JSXMemberExpression"; + object: JSXMemberExpression | JSXIdentifier; + property: JSXIdentifier; +} +interface JSXNamespacedName extends BaseNode { + type: "JSXNamespacedName"; + namespace: JSXIdentifier; + name: JSXIdentifier; +} +interface JSXOpeningElement extends BaseNode { + type: "JSXOpeningElement"; + name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName; + attributes: (JSXAttribute | JSXSpreadAttribute)[]; + selfClosing: boolean; + typeArguments?: TypeParameterInstantiation | null; + typeParameters?: TSTypeParameterInstantiation | null; +} +interface JSXSpreadAttribute extends BaseNode { + type: "JSXSpreadAttribute"; + argument: Expression; +} +interface JSXText extends BaseNode { + type: "JSXText"; + value: string; +} +interface JSXFragment extends BaseNode { + type: "JSXFragment"; + openingFragment: JSXOpeningFragment; + closingFragment: JSXClosingFragment; + children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[]; +} +interface JSXOpeningFragment extends BaseNode { + type: "JSXOpeningFragment"; +} +interface JSXClosingFragment extends BaseNode { + type: "JSXClosingFragment"; +} +interface Noop extends BaseNode { + type: "Noop"; +} +interface Placeholder extends BaseNode { + type: "Placeholder"; + expectedNode: "Identifier" | "StringLiteral" | "Expression" | "Statement" | "Declaration" | "BlockStatement" | "ClassBody" | "Pattern"; + name: Identifier; + decorators?: Decorator[] | null; + optional?: boolean | null; + typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null; +} +interface V8IntrinsicIdentifier extends BaseNode { + type: "V8IntrinsicIdentifier"; + name: string; +} +interface ArgumentPlaceholder extends BaseNode { + type: "ArgumentPlaceholder"; +} +interface BindExpression extends BaseNode { + type: "BindExpression"; + object: Expression; + callee: Expression; +} +interface Decorator extends BaseNode { + type: "Decorator"; + expression: Expression; +} +interface DoExpression extends BaseNode { + type: "DoExpression"; + body: BlockStatement; + async: boolean; +} +interface ExportDefaultSpecifier extends BaseNode { + type: "ExportDefaultSpecifier"; + exported: Identifier; +} +interface RecordExpression extends BaseNode { + type: "RecordExpression"; + properties: (ObjectProperty | SpreadElement)[]; +} +interface TupleExpression extends BaseNode { + type: "TupleExpression"; + elements: (Expression | SpreadElement)[]; +} +interface DecimalLiteral extends BaseNode { + type: "DecimalLiteral"; + value: string; +} +interface ModuleExpression extends BaseNode { + type: "ModuleExpression"; + body: Program; +} +interface TopicReference extends BaseNode { + type: "TopicReference"; +} +interface PipelineTopicExpression extends BaseNode { + type: "PipelineTopicExpression"; + expression: Expression; +} +interface PipelineBareFunction extends BaseNode { + type: "PipelineBareFunction"; + callee: Expression; +} +interface PipelinePrimaryTopicReference extends BaseNode { + type: "PipelinePrimaryTopicReference"; +} +interface VoidPattern extends BaseNode { + type: "VoidPattern"; +} +interface TSParameterProperty extends BaseNode { + type: "TSParameterProperty"; + parameter: Identifier | AssignmentPattern; + accessibility?: "public" | "private" | "protected" | null; + decorators?: Decorator[] | null; + override?: boolean | null; + readonly?: boolean | null; +} +interface TSDeclareFunction extends BaseNode { + type: "TSDeclareFunction"; + id?: Identifier | null; + typeParameters?: TSTypeParameterDeclaration | Noop | null; + params: FunctionParameter[]; + returnType?: TSTypeAnnotation | Noop | null; + async?: boolean; + declare?: boolean | null; + generator?: boolean; +} +interface TSDeclareMethod extends BaseNode { + type: "TSDeclareMethod"; + decorators?: Decorator[] | null; + key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression; + typeParameters?: TSTypeParameterDeclaration | Noop | null; + params: (FunctionParameter | TSParameterProperty)[]; + returnType?: TSTypeAnnotation | Noop | null; + abstract?: boolean | null; + access?: "public" | "private" | "protected" | null; + accessibility?: "public" | "private" | "protected" | null; + async?: boolean; + computed?: boolean; + generator?: boolean; + kind?: "get" | "set" | "method" | "constructor"; + optional?: boolean | null; + override?: boolean; + static?: boolean; +} +interface TSQualifiedName extends BaseNode { + type: "TSQualifiedName"; + left: TSEntityName; + right: Identifier; +} +interface TSCallSignatureDeclaration extends BaseNode { + type: "TSCallSignatureDeclaration"; + typeParameters?: TSTypeParameterDeclaration | null; + parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[]; + typeAnnotation?: TSTypeAnnotation | null; +} +interface TSConstructSignatureDeclaration extends BaseNode { + type: "TSConstructSignatureDeclaration"; + typeParameters?: TSTypeParameterDeclaration | null; + parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[]; + typeAnnotation?: TSTypeAnnotation | null; +} +interface TSPropertySignature extends BaseNode { + type: "TSPropertySignature"; + key: Expression; + typeAnnotation?: TSTypeAnnotation | null; + computed?: boolean; + kind?: "get" | "set" | null; + optional?: boolean | null; + readonly?: boolean | null; +} +interface TSMethodSignature extends BaseNode { + type: "TSMethodSignature"; + key: Expression; + typeParameters?: TSTypeParameterDeclaration | null; + parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[]; + typeAnnotation?: TSTypeAnnotation | null; + computed?: boolean; + kind: "method" | "get" | "set"; + optional?: boolean | null; +} +interface TSIndexSignature extends BaseNode { + type: "TSIndexSignature"; + parameters: Identifier[]; + typeAnnotation?: TSTypeAnnotation | null; + readonly?: boolean | null; + static?: boolean | null; +} +interface TSAnyKeyword extends BaseNode { + type: "TSAnyKeyword"; +} +interface TSBooleanKeyword extends BaseNode { + type: "TSBooleanKeyword"; +} +interface TSBigIntKeyword extends BaseNode { + type: "TSBigIntKeyword"; +} +interface TSIntrinsicKeyword extends BaseNode { + type: "TSIntrinsicKeyword"; +} +interface TSNeverKeyword extends BaseNode { + type: "TSNeverKeyword"; +} +interface TSNullKeyword extends BaseNode { + type: "TSNullKeyword"; +} +interface TSNumberKeyword extends BaseNode { + type: "TSNumberKeyword"; +} +interface TSObjectKeyword extends BaseNode { + type: "TSObjectKeyword"; +} +interface TSStringKeyword extends BaseNode { + type: "TSStringKeyword"; +} +interface TSSymbolKeyword extends BaseNode { + type: "TSSymbolKeyword"; +} +interface TSUndefinedKeyword extends BaseNode { + type: "TSUndefinedKeyword"; +} +interface TSUnknownKeyword extends BaseNode { + type: "TSUnknownKeyword"; +} +interface TSVoidKeyword extends BaseNode { + type: "TSVoidKeyword"; +} +interface TSThisType extends BaseNode { + type: "TSThisType"; +} +interface TSFunctionType extends BaseNode { + type: "TSFunctionType"; + typeParameters?: TSTypeParameterDeclaration | null; + parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[]; + typeAnnotation?: TSTypeAnnotation | null; +} +interface TSConstructorType extends BaseNode { + type: "TSConstructorType"; + typeParameters?: TSTypeParameterDeclaration | null; + parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[]; + typeAnnotation?: TSTypeAnnotation | null; + abstract?: boolean | null; +} +interface TSTypeReference extends BaseNode { + type: "TSTypeReference"; + typeName: TSEntityName; + typeParameters?: TSTypeParameterInstantiation | null; +} +interface TSTypePredicate extends BaseNode { + type: "TSTypePredicate"; + parameterName: Identifier | TSThisType; + typeAnnotation?: TSTypeAnnotation | null; + asserts?: boolean | null; +} +interface TSTypeQuery extends BaseNode { + type: "TSTypeQuery"; + exprName: TSEntityName | TSImportType; + typeParameters?: TSTypeParameterInstantiation | null; +} +interface TSTypeLiteral extends BaseNode { + type: "TSTypeLiteral"; + members: TSTypeElement[]; +} +interface TSArrayType extends BaseNode { + type: "TSArrayType"; + elementType: TSType; +} +interface TSTupleType extends BaseNode { + type: "TSTupleType"; + elementTypes: (TSType | TSNamedTupleMember)[]; +} +interface TSOptionalType extends BaseNode { + type: "TSOptionalType"; + typeAnnotation: TSType; +} +interface TSRestType extends BaseNode { + type: "TSRestType"; + typeAnnotation: TSType; +} +interface TSNamedTupleMember extends BaseNode { + type: "TSNamedTupleMember"; + label: Identifier; + elementType: TSType; + optional: boolean; +} +interface TSUnionType extends BaseNode { + type: "TSUnionType"; + types: TSType[]; +} +interface TSIntersectionType extends BaseNode { + type: "TSIntersectionType"; + types: TSType[]; +} +interface TSConditionalType extends BaseNode { + type: "TSConditionalType"; + checkType: TSType; + extendsType: TSType; + trueType: TSType; + falseType: TSType; +} +interface TSInferType extends BaseNode { + type: "TSInferType"; + typeParameter: TSTypeParameter; +} +interface TSParenthesizedType extends BaseNode { + type: "TSParenthesizedType"; + typeAnnotation: TSType; +} +interface TSTypeOperator extends BaseNode { + type: "TSTypeOperator"; + typeAnnotation: TSType; + operator: string; +} +interface TSIndexedAccessType extends BaseNode { + type: "TSIndexedAccessType"; + objectType: TSType; + indexType: TSType; +} +interface TSMappedType extends BaseNode { + type: "TSMappedType"; + typeParameter: TSTypeParameter; + typeAnnotation?: TSType | null; + nameType?: TSType | null; + optional?: true | false | "+" | "-" | null; + readonly?: true | false | "+" | "-" | null; +} +interface TSTemplateLiteralType extends BaseNode { + type: "TSTemplateLiteralType"; + quasis: TemplateElement[]; + types: TSType[]; +} +interface TSLiteralType extends BaseNode { + type: "TSLiteralType"; + literal: NumericLiteral | StringLiteral | BooleanLiteral | BigIntLiteral | TemplateLiteral | UnaryExpression; +} +interface TSExpressionWithTypeArguments extends BaseNode { + type: "TSExpressionWithTypeArguments"; + expression: TSEntityName; + typeParameters?: TSTypeParameterInstantiation | null; +} +interface TSInterfaceDeclaration extends BaseNode { + type: "TSInterfaceDeclaration"; + id: Identifier; + typeParameters?: TSTypeParameterDeclaration | null; + extends?: TSExpressionWithTypeArguments[] | null; + body: TSInterfaceBody; + declare?: boolean | null; +} +interface TSInterfaceBody extends BaseNode { + type: "TSInterfaceBody"; + body: TSTypeElement[]; +} +interface TSTypeAliasDeclaration extends BaseNode { + type: "TSTypeAliasDeclaration"; + id: Identifier; + typeParameters?: TSTypeParameterDeclaration | null; + typeAnnotation: TSType; + declare?: boolean | null; +} +interface TSInstantiationExpression extends BaseNode { + type: "TSInstantiationExpression"; + expression: Expression; + typeParameters?: TSTypeParameterInstantiation | null; +} +interface TSAsExpression extends BaseNode { + type: "TSAsExpression"; + expression: Expression; + typeAnnotation: TSType; +} +interface TSSatisfiesExpression extends BaseNode { + type: "TSSatisfiesExpression"; + expression: Expression; + typeAnnotation: TSType; +} +interface TSTypeAssertion extends BaseNode { + type: "TSTypeAssertion"; + typeAnnotation: TSType; + expression: Expression; +} +interface TSEnumBody extends BaseNode { + type: "TSEnumBody"; + members: TSEnumMember[]; +} +interface TSEnumDeclaration extends BaseNode { + type: "TSEnumDeclaration"; + id: Identifier; + members: TSEnumMember[]; + body?: TSEnumBody | null; + const?: boolean | null; + declare?: boolean | null; + initializer?: Expression | null; +} +interface TSEnumMember extends BaseNode { + type: "TSEnumMember"; + id: Identifier | StringLiteral; + initializer?: Expression | null; +} +interface TSModuleDeclaration extends BaseNode { + type: "TSModuleDeclaration"; + id: Identifier | StringLiteral; + body: TSModuleBlock | TSModuleDeclaration; + declare?: boolean | null; + global?: boolean | null; + kind: "global" | "module" | "namespace"; +} +interface TSModuleBlock extends BaseNode { + type: "TSModuleBlock"; + body: Statement[]; +} +interface TSImportType extends BaseNode { + type: "TSImportType"; + argument: StringLiteral; + qualifier?: TSEntityName | null; + typeParameters?: TSTypeParameterInstantiation | null; + options?: ObjectExpression | null; +} +interface TSImportEqualsDeclaration extends BaseNode { + type: "TSImportEqualsDeclaration"; + id: Identifier; + moduleReference: TSEntityName | TSExternalModuleReference; + importKind?: "type" | "value" | null; + isExport: boolean; +} +interface TSExternalModuleReference extends BaseNode { + type: "TSExternalModuleReference"; + expression: StringLiteral; +} +interface TSNonNullExpression extends BaseNode { + type: "TSNonNullExpression"; + expression: Expression; +} +interface TSExportAssignment extends BaseNode { + type: "TSExportAssignment"; + expression: Expression; +} +interface TSNamespaceExportDeclaration extends BaseNode { + type: "TSNamespaceExportDeclaration"; + id: Identifier; +} +interface TSTypeAnnotation extends BaseNode { + type: "TSTypeAnnotation"; + typeAnnotation: TSType; +} +interface TSTypeParameterInstantiation extends BaseNode { + type: "TSTypeParameterInstantiation"; + params: TSType[]; +} +interface TSTypeParameterDeclaration extends BaseNode { + type: "TSTypeParameterDeclaration"; + params: TSTypeParameter[]; +} +interface TSTypeParameter extends BaseNode { + type: "TSTypeParameter"; + constraint?: TSType | null; + default?: TSType | null; + name: string; + const?: boolean | null; + in?: boolean | null; + out?: boolean | null; +} +type Standardized = ArrayExpression | AssignmentExpression | BinaryExpression | InterpreterDirective | Directive | DirectiveLiteral | BlockStatement | BreakStatement | CallExpression | CatchClause | ConditionalExpression | ContinueStatement | DebuggerStatement | DoWhileStatement | EmptyStatement | ExpressionStatement | File | ForInStatement | ForStatement | FunctionDeclaration | FunctionExpression | Identifier | IfStatement | LabeledStatement | StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | RegExpLiteral | LogicalExpression | MemberExpression | NewExpression | Program | ObjectExpression | ObjectMethod | ObjectProperty | RestElement | ReturnStatement | SequenceExpression | ParenthesizedExpression | SwitchCase | SwitchStatement | ThisExpression | ThrowStatement | TryStatement | UnaryExpression | UpdateExpression | VariableDeclaration | VariableDeclarator | WhileStatement | WithStatement | AssignmentPattern | ArrayPattern | ArrowFunctionExpression | ClassBody | ClassExpression | ClassDeclaration | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ExportSpecifier | ForOfStatement | ImportDeclaration | ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportSpecifier | ImportExpression | MetaProperty | ClassMethod | ObjectPattern | SpreadElement | Super | TaggedTemplateExpression | TemplateElement | TemplateLiteral | YieldExpression | AwaitExpression | Import | BigIntLiteral | ExportNamespaceSpecifier | OptionalMemberExpression | OptionalCallExpression | ClassProperty | ClassAccessorProperty | ClassPrivateProperty | ClassPrivateMethod | PrivateName | StaticBlock | ImportAttribute; +type Expression = ArrayExpression | AssignmentExpression | BinaryExpression | CallExpression | ConditionalExpression | FunctionExpression | Identifier | StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | RegExpLiteral | LogicalExpression | MemberExpression | NewExpression | ObjectExpression | SequenceExpression | ParenthesizedExpression | ThisExpression | UnaryExpression | UpdateExpression | ArrowFunctionExpression | ClassExpression | ImportExpression | MetaProperty | Super | TaggedTemplateExpression | TemplateLiteral | YieldExpression | AwaitExpression | Import | BigIntLiteral | OptionalMemberExpression | OptionalCallExpression | TypeCastExpression | JSXElement | JSXFragment | BindExpression | DoExpression | RecordExpression | TupleExpression | DecimalLiteral | ModuleExpression | TopicReference | PipelineTopicExpression | PipelineBareFunction | PipelinePrimaryTopicReference | TSInstantiationExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression; +type Binary = BinaryExpression | LogicalExpression; +type Scopable = BlockStatement | CatchClause | DoWhileStatement | ForInStatement | ForStatement | FunctionDeclaration | FunctionExpression | Program | ObjectMethod | SwitchStatement | WhileStatement | ArrowFunctionExpression | ClassExpression | ClassDeclaration | ForOfStatement | ClassMethod | ClassPrivateMethod | StaticBlock | TSModuleBlock; +type BlockParent = BlockStatement | CatchClause | DoWhileStatement | ForInStatement | ForStatement | FunctionDeclaration | FunctionExpression | Program | ObjectMethod | SwitchStatement | WhileStatement | ArrowFunctionExpression | ForOfStatement | ClassMethod | ClassPrivateMethod | StaticBlock | TSModuleBlock; +type Block = BlockStatement | Program | TSModuleBlock; +type Statement = BlockStatement | BreakStatement | ContinueStatement | DebuggerStatement | DoWhileStatement | EmptyStatement | ExpressionStatement | ForInStatement | ForStatement | FunctionDeclaration | IfStatement | LabeledStatement | ReturnStatement | SwitchStatement | ThrowStatement | TryStatement | VariableDeclaration | WhileStatement | WithStatement | ClassDeclaration | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ForOfStatement | ImportDeclaration | DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareTypeAlias | DeclareOpaqueType | DeclareVariable | DeclareExportDeclaration | DeclareExportAllDeclaration | InterfaceDeclaration | OpaqueType | TypeAlias | EnumDeclaration | TSDeclareFunction | TSInterfaceDeclaration | TSTypeAliasDeclaration | TSEnumDeclaration | TSModuleDeclaration | TSImportEqualsDeclaration | TSExportAssignment | TSNamespaceExportDeclaration; +type Terminatorless = BreakStatement | ContinueStatement | ReturnStatement | ThrowStatement | YieldExpression | AwaitExpression; +type CompletionStatement = BreakStatement | ContinueStatement | ReturnStatement | ThrowStatement; +type Conditional = ConditionalExpression | IfStatement; +type Loop = DoWhileStatement | ForInStatement | ForStatement | WhileStatement | ForOfStatement; +type While = DoWhileStatement | WhileStatement; +type ExpressionWrapper = ExpressionStatement | ParenthesizedExpression | TypeCastExpression; +type For = ForInStatement | ForStatement | ForOfStatement; +type ForXStatement = ForInStatement | ForOfStatement; +type Function = FunctionDeclaration | FunctionExpression | ObjectMethod | ArrowFunctionExpression | ClassMethod | ClassPrivateMethod; +type FunctionParent = FunctionDeclaration | FunctionExpression | ObjectMethod | ArrowFunctionExpression | ClassMethod | ClassPrivateMethod | StaticBlock | TSModuleBlock; +type Pureish = FunctionDeclaration | FunctionExpression | StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | RegExpLiteral | ArrowFunctionExpression | BigIntLiteral | DecimalLiteral; +type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ImportDeclaration | DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareTypeAlias | DeclareOpaqueType | DeclareVariable | DeclareExportDeclaration | DeclareExportAllDeclaration | InterfaceDeclaration | OpaqueType | TypeAlias | EnumDeclaration | TSDeclareFunction | TSInterfaceDeclaration | TSTypeAliasDeclaration | TSEnumDeclaration | TSModuleDeclaration | TSImportEqualsDeclaration; +type FunctionParameter = Identifier | RestElement | AssignmentPattern | ArrayPattern | ObjectPattern | VoidPattern; +type PatternLike = Identifier | MemberExpression | RestElement | AssignmentPattern | ArrayPattern | ObjectPattern | VoidPattern | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression; +type LVal = Identifier | MemberExpression | RestElement | AssignmentPattern | ArrayPattern | ObjectPattern | TSParameterProperty | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression; +type TSEntityName = Identifier | TSQualifiedName; +type Literal = StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | RegExpLiteral | TemplateLiteral | BigIntLiteral | DecimalLiteral; +type Immutable = StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | BigIntLiteral | JSXAttribute | JSXClosingElement | JSXElement | JSXExpressionContainer | JSXSpreadChild | JSXOpeningElement | JSXText | JSXFragment | JSXOpeningFragment | JSXClosingFragment | DecimalLiteral; +type UserWhitespacable = ObjectMethod | ObjectProperty | ObjectTypeInternalSlot | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeProperty | ObjectTypeSpreadProperty; +type Method = ObjectMethod | ClassMethod | ClassPrivateMethod; +type ObjectMember = ObjectMethod | ObjectProperty; +type Property = ObjectProperty | ClassProperty | ClassAccessorProperty | ClassPrivateProperty; +type UnaryLike = UnaryExpression | SpreadElement; +type Pattern = AssignmentPattern | ArrayPattern | ObjectPattern | VoidPattern; +type Class = ClassExpression | ClassDeclaration; +type ImportOrExportDeclaration = ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ImportDeclaration; +type ExportDeclaration = ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration; +type ModuleSpecifier = ExportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportSpecifier | ExportNamespaceSpecifier | ExportDefaultSpecifier; +type Accessor = ClassAccessorProperty; +type Private = ClassPrivateProperty | ClassPrivateMethod | PrivateName; +type Flow = AnyTypeAnnotation | ArrayTypeAnnotation | BooleanTypeAnnotation | BooleanLiteralTypeAnnotation | NullLiteralTypeAnnotation | ClassImplements | DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareTypeAlias | DeclareOpaqueType | DeclareVariable | DeclareExportDeclaration | DeclareExportAllDeclaration | DeclaredPredicate | ExistsTypeAnnotation | FunctionTypeAnnotation | FunctionTypeParam | GenericTypeAnnotation | InferredPredicate | InterfaceExtends | InterfaceDeclaration | InterfaceTypeAnnotation | IntersectionTypeAnnotation | MixedTypeAnnotation | EmptyTypeAnnotation | NullableTypeAnnotation | NumberLiteralTypeAnnotation | NumberTypeAnnotation | ObjectTypeAnnotation | ObjectTypeInternalSlot | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | QualifiedTypeIdentifier | StringLiteralTypeAnnotation | StringTypeAnnotation | SymbolTypeAnnotation | ThisTypeAnnotation | TupleTypeAnnotation | TypeofTypeAnnotation | TypeAlias | TypeAnnotation | TypeCastExpression | TypeParameter | TypeParameterDeclaration | TypeParameterInstantiation | UnionTypeAnnotation | Variance | VoidTypeAnnotation | EnumDeclaration | EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody | EnumBooleanMember | EnumNumberMember | EnumStringMember | EnumDefaultedMember | IndexedAccessType | OptionalIndexedAccessType; +type FlowType = AnyTypeAnnotation | ArrayTypeAnnotation | BooleanTypeAnnotation | BooleanLiteralTypeAnnotation | NullLiteralTypeAnnotation | ExistsTypeAnnotation | FunctionTypeAnnotation | GenericTypeAnnotation | InterfaceTypeAnnotation | IntersectionTypeAnnotation | MixedTypeAnnotation | EmptyTypeAnnotation | NullableTypeAnnotation | NumberLiteralTypeAnnotation | NumberTypeAnnotation | ObjectTypeAnnotation | StringLiteralTypeAnnotation | StringTypeAnnotation | SymbolTypeAnnotation | ThisTypeAnnotation | TupleTypeAnnotation | TypeofTypeAnnotation | UnionTypeAnnotation | VoidTypeAnnotation | IndexedAccessType | OptionalIndexedAccessType; +type FlowBaseAnnotation = AnyTypeAnnotation | BooleanTypeAnnotation | NullLiteralTypeAnnotation | MixedTypeAnnotation | EmptyTypeAnnotation | NumberTypeAnnotation | StringTypeAnnotation | SymbolTypeAnnotation | ThisTypeAnnotation | VoidTypeAnnotation; +type FlowDeclaration = DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareTypeAlias | DeclareOpaqueType | DeclareVariable | DeclareExportDeclaration | DeclareExportAllDeclaration | InterfaceDeclaration | OpaqueType | TypeAlias; +type FlowPredicate = DeclaredPredicate | InferredPredicate; +type EnumBody = EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody; +type EnumMember = EnumBooleanMember | EnumNumberMember | EnumStringMember | EnumDefaultedMember; +type JSX = JSXAttribute | JSXClosingElement | JSXElement | JSXEmptyExpression | JSXExpressionContainer | JSXSpreadChild | JSXIdentifier | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement | JSXSpreadAttribute | JSXText | JSXFragment | JSXOpeningFragment | JSXClosingFragment; +type Miscellaneous = Noop | Placeholder | V8IntrinsicIdentifier; +type TypeScript = TSParameterProperty | TSDeclareFunction | TSDeclareMethod | TSQualifiedName | TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSPropertySignature | TSMethodSignature | TSIndexSignature | TSAnyKeyword | TSBooleanKeyword | TSBigIntKeyword | TSIntrinsicKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSThisType | TSFunctionType | TSConstructorType | TSTypeReference | TSTypePredicate | TSTypeQuery | TSTypeLiteral | TSArrayType | TSTupleType | TSOptionalType | TSRestType | TSNamedTupleMember | TSUnionType | TSIntersectionType | TSConditionalType | TSInferType | TSParenthesizedType | TSTypeOperator | TSIndexedAccessType | TSMappedType | TSTemplateLiteralType | TSLiteralType | TSExpressionWithTypeArguments | TSInterfaceDeclaration | TSInterfaceBody | TSTypeAliasDeclaration | TSInstantiationExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSEnumBody | TSEnumDeclaration | TSEnumMember | TSModuleDeclaration | TSModuleBlock | TSImportType | TSImportEqualsDeclaration | TSExternalModuleReference | TSNonNullExpression | TSExportAssignment | TSNamespaceExportDeclaration | TSTypeAnnotation | TSTypeParameterInstantiation | TSTypeParameterDeclaration | TSTypeParameter; +type TSTypeElement = TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSPropertySignature | TSMethodSignature | TSIndexSignature; +type TSType = TSAnyKeyword | TSBooleanKeyword | TSBigIntKeyword | TSIntrinsicKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSThisType | TSFunctionType | TSConstructorType | TSTypeReference | TSTypePredicate | TSTypeQuery | TSTypeLiteral | TSArrayType | TSTupleType | TSOptionalType | TSRestType | TSUnionType | TSIntersectionType | TSConditionalType | TSInferType | TSParenthesizedType | TSTypeOperator | TSIndexedAccessType | TSMappedType | TSTemplateLiteralType | TSLiteralType | TSExpressionWithTypeArguments | TSImportType; +type TSBaseType = TSAnyKeyword | TSBooleanKeyword | TSBigIntKeyword | TSIntrinsicKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSThisType | TSTemplateLiteralType | TSLiteralType; +type ModuleDeclaration = ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ImportDeclaration; +interface Aliases { + Standardized: Standardized; + Expression: Expression; + Binary: Binary; + Scopable: Scopable; + BlockParent: BlockParent; + Block: Block; + Statement: Statement; + Terminatorless: Terminatorless; + CompletionStatement: CompletionStatement; + Conditional: Conditional; + Loop: Loop; + While: While; + ExpressionWrapper: ExpressionWrapper; + For: For; + ForXStatement: ForXStatement; + Function: Function; + FunctionParent: FunctionParent; + Pureish: Pureish; + Declaration: Declaration; + FunctionParameter: FunctionParameter; + PatternLike: PatternLike; + LVal: LVal; + TSEntityName: TSEntityName; + Literal: Literal; + Immutable: Immutable; + UserWhitespacable: UserWhitespacable; + Method: Method; + ObjectMember: ObjectMember; + Property: Property; + UnaryLike: UnaryLike; + Pattern: Pattern; + Class: Class; + ImportOrExportDeclaration: ImportOrExportDeclaration; + ExportDeclaration: ExportDeclaration; + ModuleSpecifier: ModuleSpecifier; + Accessor: Accessor; + Private: Private; + Flow: Flow; + FlowType: FlowType; + FlowBaseAnnotation: FlowBaseAnnotation; + FlowDeclaration: FlowDeclaration; + FlowPredicate: FlowPredicate; + EnumBody: EnumBody; + EnumMember: EnumMember; + JSX: JSX; + Miscellaneous: Miscellaneous; + TypeScript: TypeScript; + TSTypeElement: TSTypeElement; + TSType: TSType; + TSBaseType: TSBaseType; + ModuleDeclaration: ModuleDeclaration; +} +type DeprecatedAliases = NumberLiteral$1 | RegexLiteral$1 | RestProperty$1 | SpreadProperty$1; +interface ParentMaps { + AnyTypeAnnotation: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + ArgumentPlaceholder: CallExpression | NewExpression | OptionalCallExpression; + ArrayExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + ArrayPattern: ArrayPattern | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | CatchClause | ClassMethod | ClassPrivateMethod | ForInStatement | ForOfStatement | FunctionDeclaration | FunctionExpression | ObjectMethod | ObjectProperty | RestElement | TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSConstructorType | TSDeclareFunction | TSDeclareMethod | TSFunctionType | TSMethodSignature | VariableDeclarator; + ArrayTypeAnnotation: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + ArrowFunctionExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + AssignmentExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + AssignmentPattern: ArrayPattern | ArrowFunctionExpression | AssignmentExpression | ClassMethod | ClassPrivateMethod | ForInStatement | ForOfStatement | FunctionDeclaration | FunctionExpression | ObjectMethod | ObjectProperty | RestElement | TSDeclareFunction | TSDeclareMethod | TSParameterProperty | VariableDeclarator; + AwaitExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + BigIntLiteral: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSLiteralType | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + BinaryExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + BindExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + BlockStatement: ArrowFunctionExpression | BlockStatement | CatchClause | ClassMethod | ClassPrivateMethod | DeclareModule | DoExpression | DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | FunctionDeclaration | FunctionExpression | IfStatement | LabeledStatement | ObjectMethod | Program | StaticBlock | SwitchCase | TSModuleBlock | TryStatement | WhileStatement | WithStatement; + BooleanLiteral: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | EnumBooleanMember | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSLiteralType | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + BooleanLiteralTypeAnnotation: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + BooleanTypeAnnotation: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + BreakStatement: BlockStatement | DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + CallExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + CatchClause: TryStatement; + ClassAccessorProperty: ClassBody; + ClassBody: ClassDeclaration | ClassExpression; + ClassDeclaration: BlockStatement | DoWhileStatement | ExportDefaultDeclaration | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + ClassExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + ClassImplements: ClassDeclaration | ClassExpression | DeclareClass | DeclareExportDeclaration | DeclaredPredicate; + ClassMethod: ClassBody; + ClassPrivateMethod: ClassBody; + ClassPrivateProperty: ClassBody; + ClassProperty: ClassBody; + CommentBlock: File; + CommentLine: File; + ConditionalExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + ContinueStatement: BlockStatement | DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + DebuggerStatement: BlockStatement | DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + DecimalLiteral: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + DeclareClass: BlockStatement | DeclareExportDeclaration | DeclaredPredicate | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + DeclareExportAllDeclaration: BlockStatement | DeclareExportDeclaration | DeclaredPredicate | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + DeclareExportDeclaration: BlockStatement | DeclareExportDeclaration | DeclaredPredicate | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + DeclareFunction: BlockStatement | DeclareExportDeclaration | DeclaredPredicate | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + DeclareInterface: BlockStatement | DeclareExportDeclaration | DeclaredPredicate | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + DeclareModule: BlockStatement | DeclareExportDeclaration | DeclaredPredicate | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + DeclareModuleExports: BlockStatement | DeclareExportDeclaration | DeclaredPredicate | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + DeclareOpaqueType: BlockStatement | DeclareExportDeclaration | DeclaredPredicate | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + DeclareTypeAlias: BlockStatement | DeclareExportDeclaration | DeclaredPredicate | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + DeclareVariable: BlockStatement | DeclareExportDeclaration | DeclaredPredicate | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + DeclaredPredicate: ArrowFunctionExpression | DeclareExportDeclaration | DeclareFunction | DeclaredPredicate | FunctionDeclaration | FunctionExpression; + Decorator: ArrayPattern | AssignmentPattern | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateMethod | ClassPrivateProperty | ClassProperty | Identifier | ObjectMethod | ObjectPattern | ObjectProperty | Placeholder | RestElement | TSDeclareMethod | TSParameterProperty; + Directive: BlockStatement | Program; + DirectiveLiteral: Directive; + DoExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + DoWhileStatement: BlockStatement | DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + EmptyStatement: BlockStatement | DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + EmptyTypeAnnotation: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + EnumBooleanBody: DeclareExportDeclaration | DeclaredPredicate | EnumDeclaration; + EnumBooleanMember: DeclareExportDeclaration | DeclaredPredicate | EnumBooleanBody; + EnumDeclaration: BlockStatement | DeclareExportDeclaration | DeclaredPredicate | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + EnumDefaultedMember: DeclareExportDeclaration | DeclaredPredicate | EnumStringBody | EnumSymbolBody; + EnumNumberBody: DeclareExportDeclaration | DeclaredPredicate | EnumDeclaration; + EnumNumberMember: DeclareExportDeclaration | DeclaredPredicate | EnumNumberBody; + EnumStringBody: DeclareExportDeclaration | DeclaredPredicate | EnumDeclaration; + EnumStringMember: DeclareExportDeclaration | DeclaredPredicate | EnumStringBody; + EnumSymbolBody: DeclareExportDeclaration | DeclaredPredicate | EnumDeclaration; + ExistsTypeAnnotation: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + ExportAllDeclaration: BlockStatement | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + ExportDefaultDeclaration: BlockStatement | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + ExportDefaultSpecifier: ExportNamedDeclaration; + ExportNamedDeclaration: BlockStatement | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + ExportNamespaceSpecifier: DeclareExportDeclaration | ExportNamedDeclaration; + ExportSpecifier: DeclareExportDeclaration | ExportNamedDeclaration; + ExpressionStatement: BlockStatement | DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + File: null; + ForInStatement: BlockStatement | DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + ForOfStatement: BlockStatement | DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + ForStatement: BlockStatement | DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + FunctionDeclaration: BlockStatement | DoWhileStatement | ExportDefaultDeclaration | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + FunctionExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + FunctionTypeAnnotation: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + FunctionTypeParam: DeclareExportDeclaration | DeclaredPredicate | FunctionTypeAnnotation; + GenericTypeAnnotation: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + Identifier: ArrayExpression | ArrayPattern | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | BreakStatement | CallExpression | CatchClause | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassImplements | ClassMethod | ClassPrivateMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | ContinueStatement | DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareOpaqueType | DeclareTypeAlias | DeclareVariable | Decorator | DoWhileStatement | EnumBooleanMember | EnumDeclaration | EnumDefaultedMember | EnumNumberMember | EnumStringMember | ExportDefaultDeclaration | ExportDefaultSpecifier | ExportNamespaceSpecifier | ExportSpecifier | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | FunctionDeclaration | FunctionExpression | FunctionTypeParam | GenericTypeAnnotation | IfStatement | ImportAttribute | ImportDefaultSpecifier | ImportExpression | ImportNamespaceSpecifier | ImportSpecifier | InterfaceDeclaration | InterfaceExtends | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LabeledStatement | LogicalExpression | MemberExpression | MetaProperty | NewExpression | ObjectMethod | ObjectProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | OpaqueType | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | Placeholder | PrivateName | QualifiedTypeIdentifier | RestElement | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSConstructorType | TSDeclareFunction | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSExpressionWithTypeArguments | TSFunctionType | TSImportEqualsDeclaration | TSImportType | TSIndexSignature | TSInstantiationExpression | TSInterfaceDeclaration | TSMethodSignature | TSModuleDeclaration | TSNamedTupleMember | TSNamespaceExportDeclaration | TSNonNullExpression | TSParameterProperty | TSPropertySignature | TSQualifiedName | TSSatisfiesExpression | TSTypeAliasDeclaration | TSTypeAssertion | TSTypePredicate | TSTypeQuery | TSTypeReference | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeAlias | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + IfStatement: BlockStatement | DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + Import: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + ImportAttribute: DeclareExportAllDeclaration | DeclareExportDeclaration | ExportAllDeclaration | ExportNamedDeclaration | ImportDeclaration; + ImportDeclaration: BlockStatement | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + ImportDefaultSpecifier: ImportDeclaration; + ImportExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + ImportNamespaceSpecifier: ImportDeclaration; + ImportSpecifier: ImportDeclaration; + IndexedAccessType: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + InferredPredicate: ArrowFunctionExpression | DeclareExportDeclaration | DeclaredPredicate | FunctionDeclaration | FunctionExpression; + InterfaceDeclaration: BlockStatement | DeclareExportDeclaration | DeclaredPredicate | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + InterfaceExtends: ClassDeclaration | ClassExpression | DeclareClass | DeclareExportDeclaration | DeclareInterface | DeclaredPredicate | InterfaceDeclaration | InterfaceTypeAnnotation; + InterfaceTypeAnnotation: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + InterpreterDirective: Program; + IntersectionTypeAnnotation: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + JSXAttribute: JSXOpeningElement; + JSXClosingElement: JSXElement; + JSXClosingFragment: JSXFragment; + JSXElement: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXAttribute | JSXElement | JSXExpressionContainer | JSXFragment | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + JSXEmptyExpression: JSXExpressionContainer; + JSXExpressionContainer: JSXAttribute | JSXElement | JSXFragment; + JSXFragment: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXAttribute | JSXElement | JSXExpressionContainer | JSXFragment | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + JSXIdentifier: JSXAttribute | JSXClosingElement | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement; + JSXMemberExpression: JSXClosingElement | JSXMemberExpression | JSXOpeningElement; + JSXNamespacedName: JSXAttribute | JSXClosingElement | JSXOpeningElement; + JSXOpeningElement: JSXElement; + JSXOpeningFragment: JSXFragment; + JSXSpreadAttribute: JSXOpeningElement; + JSXSpreadChild: JSXElement | JSXFragment; + JSXText: JSXElement | JSXFragment; + LabeledStatement: BlockStatement | DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + LogicalExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + MemberExpression: ArrayExpression | ArrayPattern | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | RestElement | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + MetaProperty: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + MixedTypeAnnotation: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + ModuleExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + NewExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + Noop: ArrayPattern | ArrowFunctionExpression | AssignmentPattern | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateMethod | ClassPrivateProperty | ClassProperty | FunctionDeclaration | FunctionExpression | Identifier | ObjectMethod | ObjectPattern | Placeholder | RestElement | TSDeclareFunction | TSDeclareMethod; + NullLiteral: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + NullLiteralTypeAnnotation: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + NullableTypeAnnotation: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + NumberLiteral: null; + NumberLiteralTypeAnnotation: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + NumberTypeAnnotation: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + NumericLiteral: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | EnumNumberMember | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSLiteralType | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + ObjectExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSImportType | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + ObjectMethod: ObjectExpression; + ObjectPattern: ArrayPattern | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | CatchClause | ClassMethod | ClassPrivateMethod | ForInStatement | ForOfStatement | FunctionDeclaration | FunctionExpression | ObjectMethod | ObjectProperty | RestElement | TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSConstructorType | TSDeclareFunction | TSDeclareMethod | TSFunctionType | TSMethodSignature | VariableDeclarator; + ObjectProperty: ObjectExpression | ObjectPattern | RecordExpression; + ObjectTypeAnnotation: ArrayTypeAnnotation | DeclareClass | DeclareExportDeclaration | DeclareInterface | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | InterfaceDeclaration | InterfaceTypeAnnotation | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + ObjectTypeCallProperty: DeclareExportDeclaration | DeclaredPredicate | ObjectTypeAnnotation; + ObjectTypeIndexer: DeclareExportDeclaration | DeclaredPredicate | ObjectTypeAnnotation; + ObjectTypeInternalSlot: DeclareExportDeclaration | DeclaredPredicate | ObjectTypeAnnotation; + ObjectTypeProperty: DeclareExportDeclaration | DeclaredPredicate | ObjectTypeAnnotation; + ObjectTypeSpreadProperty: DeclareExportDeclaration | DeclaredPredicate | ObjectTypeAnnotation; + OpaqueType: BlockStatement | DeclareExportDeclaration | DeclaredPredicate | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + OptionalCallExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + OptionalIndexedAccessType: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + OptionalMemberExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + ParenthesizedExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + PipelineBareFunction: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + PipelinePrimaryTopicReference: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + PipelineTopicExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + Placeholder: Node; + PrivateName: BinaryExpression | ClassAccessorProperty | ClassPrivateMethod | ClassPrivateProperty | MemberExpression | ObjectProperty; + Program: File | ModuleExpression; + QualifiedTypeIdentifier: DeclareExportDeclaration | DeclaredPredicate | GenericTypeAnnotation | InterfaceExtends | QualifiedTypeIdentifier; + RecordExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + RegExpLiteral: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + RegexLiteral: null; + RestElement: ArrayPattern | ArrowFunctionExpression | AssignmentExpression | ClassMethod | ClassPrivateMethod | ForInStatement | ForOfStatement | FunctionDeclaration | FunctionExpression | ObjectMethod | ObjectPattern | ObjectProperty | RestElement | TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSConstructorType | TSDeclareFunction | TSDeclareMethod | TSFunctionType | TSMethodSignature | VariableDeclarator; + RestProperty: null; + ReturnStatement: BlockStatement | DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + SequenceExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + SpreadElement: ArrayExpression | CallExpression | NewExpression | ObjectExpression | OptionalCallExpression | RecordExpression | TupleExpression; + SpreadProperty: null; + StaticBlock: ClassBody; + StringLiteral: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | DeclareExportAllDeclaration | DeclareExportDeclaration | DeclareModule | Decorator | DoWhileStatement | EnumStringMember | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ExportSpecifier | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportAttribute | ImportDeclaration | ImportExpression | ImportSpecifier | JSXAttribute | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | ObjectTypeProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSExternalModuleReference | TSImportType | TSInstantiationExpression | TSLiteralType | TSMethodSignature | TSModuleDeclaration | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + StringLiteralTypeAnnotation: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + StringTypeAnnotation: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + Super: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + SwitchCase: SwitchStatement; + SwitchStatement: BlockStatement | DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + SymbolTypeAnnotation: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + TSAnyKeyword: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSArrayType: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSAsExpression: ArrayExpression | ArrayPattern | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | RestElement | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + TSBigIntKeyword: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSBooleanKeyword: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSCallSignatureDeclaration: TSInterfaceBody | TSTypeLiteral; + TSConditionalType: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSConstructSignatureDeclaration: TSInterfaceBody | TSTypeLiteral; + TSConstructorType: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSDeclareFunction: BlockStatement | DoWhileStatement | ExportDefaultDeclaration | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + TSDeclareMethod: ClassBody; + TSEnumBody: TSEnumDeclaration; + TSEnumDeclaration: BlockStatement | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + TSEnumMember: TSEnumBody | TSEnumDeclaration; + TSExportAssignment: BlockStatement | DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + TSExpressionWithTypeArguments: ClassDeclaration | ClassExpression | TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSInterfaceDeclaration | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSExternalModuleReference: TSImportEqualsDeclaration; + TSFunctionType: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSImportEqualsDeclaration: BlockStatement | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + TSImportType: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSTypeQuery | TSUnionType | TemplateLiteral; + TSIndexSignature: ClassBody | TSInterfaceBody | TSTypeLiteral; + TSIndexedAccessType: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSInferType: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSInstantiationExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + TSInterfaceBody: TSInterfaceDeclaration; + TSInterfaceDeclaration: BlockStatement | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + TSIntersectionType: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSIntrinsicKeyword: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSLiteralType: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSMappedType: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSMethodSignature: TSInterfaceBody | TSTypeLiteral; + TSModuleBlock: TSModuleDeclaration; + TSModuleDeclaration: BlockStatement | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | TSModuleDeclaration | WhileStatement | WithStatement; + TSNamedTupleMember: TSTupleType; + TSNamespaceExportDeclaration: BlockStatement | DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + TSNeverKeyword: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSNonNullExpression: ArrayExpression | ArrayPattern | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | RestElement | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + TSNullKeyword: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSNumberKeyword: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSObjectKeyword: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSOptionalType: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSParameterProperty: AssignmentExpression | ClassMethod | ClassPrivateMethod | ForInStatement | ForOfStatement | TSDeclareMethod | VariableDeclarator; + TSParenthesizedType: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSPropertySignature: TSInterfaceBody | TSTypeLiteral; + TSQualifiedName: TSExpressionWithTypeArguments | TSImportEqualsDeclaration | TSImportType | TSQualifiedName | TSTypeQuery | TSTypeReference; + TSRestType: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSSatisfiesExpression: ArrayExpression | ArrayPattern | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | RestElement | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + TSStringKeyword: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSSymbolKeyword: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSTemplateLiteralType: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSThisType: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSTypePredicate | TSUnionType | TemplateLiteral; + TSTupleType: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSTypeAliasDeclaration: BlockStatement | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + TSTypeAnnotation: ArrayPattern | ArrowFunctionExpression | AssignmentPattern | ClassAccessorProperty | ClassMethod | ClassPrivateMethod | ClassPrivateProperty | ClassProperty | FunctionDeclaration | FunctionExpression | Identifier | ObjectMethod | ObjectPattern | Placeholder | RestElement | TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSConstructorType | TSDeclareFunction | TSDeclareMethod | TSFunctionType | TSIndexSignature | TSMethodSignature | TSPropertySignature | TSTypePredicate; + TSTypeAssertion: ArrayExpression | ArrayPattern | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | RestElement | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + TSTypeLiteral: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSTypeOperator: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSTypeParameter: TSInferType | TSMappedType | TSTypeParameterDeclaration; + TSTypeParameterDeclaration: ArrowFunctionExpression | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateMethod | FunctionDeclaration | FunctionExpression | ObjectMethod | TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSConstructorType | TSDeclareFunction | TSDeclareMethod | TSFunctionType | TSInterfaceDeclaration | TSMethodSignature | TSTypeAliasDeclaration; + TSTypeParameterInstantiation: CallExpression | ClassDeclaration | ClassExpression | JSXOpeningElement | NewExpression | OptionalCallExpression | TSExpressionWithTypeArguments | TSImportType | TSInstantiationExpression | TSTypeQuery | TSTypeReference | TaggedTemplateExpression; + TSTypePredicate: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSTypeQuery: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSTypeReference: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSUndefinedKeyword: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSUnionType: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSUnknownKeyword: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TSVoidKeyword: TSArrayType | TSAsExpression | TSConditionalType | TSIndexedAccessType | TSIntersectionType | TSMappedType | TSNamedTupleMember | TSOptionalType | TSParenthesizedType | TSRestType | TSSatisfiesExpression | TSTemplateLiteralType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeOperator | TSTypeParameter | TSTypeParameterInstantiation | TSUnionType | TemplateLiteral; + TaggedTemplateExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + TemplateElement: TSTemplateLiteralType | TemplateLiteral; + TemplateLiteral: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSLiteralType | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + ThisExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + ThisTypeAnnotation: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + ThrowStatement: BlockStatement | DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + TopicReference: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + TryStatement: BlockStatement | DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + TupleExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + TupleTypeAnnotation: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + TypeAlias: BlockStatement | DeclareExportDeclaration | DeclaredPredicate | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + TypeAnnotation: ArrayPattern | ArrowFunctionExpression | AssignmentPattern | ClassAccessorProperty | ClassMethod | ClassPrivateMethod | ClassPrivateProperty | ClassProperty | DeclareExportDeclaration | DeclareModuleExports | DeclaredPredicate | FunctionDeclaration | FunctionExpression | Identifier | ObjectMethod | ObjectPattern | Placeholder | RestElement | TypeCastExpression | TypeParameter; + TypeCastExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | DeclareExportDeclaration | DeclaredPredicate | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + TypeParameter: DeclareExportDeclaration | DeclaredPredicate | TypeParameterDeclaration; + TypeParameterDeclaration: ArrowFunctionExpression | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateMethod | DeclareClass | DeclareExportDeclaration | DeclareInterface | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionDeclaration | FunctionExpression | FunctionTypeAnnotation | InterfaceDeclaration | ObjectMethod | OpaqueType | TypeAlias; + TypeParameterInstantiation: CallExpression | ClassDeclaration | ClassExpression | ClassImplements | DeclareExportDeclaration | DeclaredPredicate | GenericTypeAnnotation | InterfaceExtends | JSXOpeningElement | NewExpression | OptionalCallExpression | TaggedTemplateExpression; + TypeofTypeAnnotation: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + UnaryExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSLiteralType | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + UnionTypeAnnotation: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + UpdateExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; + V8IntrinsicIdentifier: CallExpression | NewExpression; + VariableDeclaration: BlockStatement | DoWhileStatement | ExportNamedDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + VariableDeclarator: VariableDeclaration; + Variance: ClassAccessorProperty | ClassPrivateProperty | ClassProperty | DeclareExportDeclaration | DeclaredPredicate | ObjectTypeIndexer | ObjectTypeProperty | TypeParameter; + VoidPattern: ArrayPattern | ArrowFunctionExpression | ClassMethod | ClassPrivateMethod | FunctionDeclaration | FunctionExpression | ObjectMethod | ObjectProperty | TSDeclareFunction | TSDeclareMethod | VariableDeclarator; + VoidTypeAnnotation: ArrayTypeAnnotation | DeclareExportDeclaration | DeclareOpaqueType | DeclareTypeAlias | DeclaredPredicate | FunctionTypeAnnotation | FunctionTypeParam | IndexedAccessType | IntersectionTypeAnnotation | NullableTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalIndexedAccessType | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeParameter | TypeParameterInstantiation | TypeofTypeAnnotation | UnionTypeAnnotation; + WhileStatement: BlockStatement | DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + WithStatement: BlockStatement | DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | LabeledStatement | Program | StaticBlock | SwitchCase | TSModuleBlock | WhileStatement | WithStatement; + YieldExpression: ArrayExpression | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BindExpression | CallExpression | ClassAccessorProperty | ClassDeclaration | ClassExpression | ClassMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | Decorator | DoWhileStatement | ExportDefaultDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ImportExpression | JSXExpressionContainer | JSXSpreadAttribute | JSXSpreadChild | LogicalExpression | MemberExpression | NewExpression | ObjectMethod | ObjectProperty | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelineTopicExpression | ReturnStatement | SequenceExpression | SpreadElement | SwitchCase | SwitchStatement | TSAsExpression | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSInstantiationExpression | TSMethodSignature | TSNonNullExpression | TSPropertySignature | TSSatisfiesExpression | TSTypeAssertion | TaggedTemplateExpression | TemplateLiteral | ThrowStatement | TupleExpression | TypeCastExpression | UnaryExpression | UpdateExpression | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; +} + +/** @deprecated */ declare function bigIntLiteral(value: string): BigIntLiteral; +declare function bigIntLiteral(value: bigint): BigIntLiteral; +declare function arrayExpression(elements?: (null | Expression | SpreadElement)[]): ArrayExpression; +declare function assignmentExpression(operator: string, left: LVal | OptionalMemberExpression, right: Expression): AssignmentExpression; +declare function binaryExpression(operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=" | "|>", left: Expression | PrivateName, right: Expression): BinaryExpression; +declare function interpreterDirective(value: string): InterpreterDirective; +declare function directive(value: DirectiveLiteral): Directive; +declare function directiveLiteral(value: string): DirectiveLiteral; +declare function blockStatement(body: Statement[], directives?: Directive[]): BlockStatement; +declare function breakStatement(label?: Identifier | null): BreakStatement; +declare function callExpression(callee: Expression | Super | V8IntrinsicIdentifier, _arguments: (Expression | SpreadElement | ArgumentPlaceholder)[]): CallExpression; +declare function catchClause(param: Identifier | ArrayPattern | ObjectPattern | null | undefined, body: BlockStatement): CatchClause; +declare function conditionalExpression(test: Expression, consequent: Expression, alternate: Expression): ConditionalExpression; +declare function continueStatement(label?: Identifier | null): ContinueStatement; +declare function debuggerStatement(): DebuggerStatement; +declare function doWhileStatement(test: Expression, body: Statement): DoWhileStatement; +declare function emptyStatement(): EmptyStatement; +declare function expressionStatement(expression: Expression): ExpressionStatement; +declare function file(program: Program, comments?: (CommentBlock | CommentLine)[] | null, tokens?: any[] | null): File; +declare function forInStatement(left: VariableDeclaration | LVal, right: Expression, body: Statement): ForInStatement; +declare function forStatement(init: VariableDeclaration | Expression | null | undefined, test: Expression | null | undefined, update: Expression | null | undefined, body: Statement): ForStatement; +declare function functionDeclaration(id: Identifier | null | undefined, params: FunctionParameter[], body: BlockStatement, generator?: boolean, async?: boolean): FunctionDeclaration; +declare function functionExpression(id: Identifier | null | undefined, params: FunctionParameter[], body: BlockStatement, generator?: boolean, async?: boolean): FunctionExpression; +declare function identifier(name: string): Identifier; +declare function ifStatement(test: Expression, consequent: Statement, alternate?: Statement | null): IfStatement; +declare function labeledStatement(label: Identifier, body: Statement): LabeledStatement; +declare function stringLiteral(value: string): StringLiteral; +declare function numericLiteral(value: number): NumericLiteral; +declare function nullLiteral(): NullLiteral; +declare function booleanLiteral(value: boolean): BooleanLiteral; +declare function regExpLiteral(pattern: string, flags?: string): RegExpLiteral; +declare function logicalExpression(operator: "||" | "&&" | "??", left: Expression, right: Expression): LogicalExpression; +declare function memberExpression(object: Expression | Super, property: Expression | Identifier | PrivateName, computed?: boolean, optional?: boolean | null): MemberExpression; +declare function newExpression(callee: Expression | Super | V8IntrinsicIdentifier, _arguments: (Expression | SpreadElement | ArgumentPlaceholder)[]): NewExpression; +declare function program(body: Statement[], directives?: Directive[], sourceType?: "script" | "module", interpreter?: InterpreterDirective | null): Program; +declare function objectExpression(properties: (ObjectMethod | ObjectProperty | SpreadElement)[]): ObjectExpression; +declare function objectMethod(kind: "method" | "get" | "set" | undefined, key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral, params: FunctionParameter[], body: BlockStatement, computed?: boolean, generator?: boolean, async?: boolean): ObjectMethod; +declare function objectProperty(key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral | DecimalLiteral | PrivateName, value: Expression | PatternLike, computed?: boolean, shorthand?: boolean, decorators?: Decorator[] | null): ObjectProperty; +declare function restElement(argument: Identifier | ArrayPattern | ObjectPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression | RestElement | AssignmentPattern): RestElement; +declare function returnStatement(argument?: Expression | null): ReturnStatement; +declare function sequenceExpression(expressions: Expression[]): SequenceExpression; +declare function parenthesizedExpression(expression: Expression): ParenthesizedExpression; +declare function switchCase(test: Expression | null | undefined, consequent: Statement[]): SwitchCase; +declare function switchStatement(discriminant: Expression, cases: SwitchCase[]): SwitchStatement; +declare function thisExpression(): ThisExpression; +declare function throwStatement(argument: Expression): ThrowStatement; +declare function tryStatement(block: BlockStatement, handler?: CatchClause | null, finalizer?: BlockStatement | null): TryStatement; +declare function unaryExpression(operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof", argument: Expression, prefix?: boolean): UnaryExpression; +declare function updateExpression(operator: "++" | "--", argument: Expression, prefix?: boolean): UpdateExpression; +declare function variableDeclaration(kind: "var" | "let" | "const" | "using" | "await using", declarations: VariableDeclarator[]): VariableDeclaration; +declare function variableDeclarator(id: LVal | VoidPattern, init?: Expression | null): VariableDeclarator; +declare function whileStatement(test: Expression, body: Statement): WhileStatement; +declare function withStatement(object: Expression, body: Statement): WithStatement; +declare function assignmentPattern(left: Identifier | ObjectPattern | ArrayPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression, right: Expression): AssignmentPattern; +declare function arrayPattern(elements: (null | PatternLike)[]): ArrayPattern; +declare function arrowFunctionExpression(params: FunctionParameter[], body: BlockStatement | Expression, async?: boolean): ArrowFunctionExpression; +declare function classBody(body: (ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty | ClassAccessorProperty | TSDeclareMethod | TSIndexSignature | StaticBlock)[]): ClassBody; +declare function classExpression(id: Identifier | null | undefined, superClass: Expression | null | undefined, body: ClassBody, decorators?: Decorator[] | null): ClassExpression; +declare function classDeclaration(id: Identifier | null | undefined, superClass: Expression | null | undefined, body: ClassBody, decorators?: Decorator[] | null): ClassDeclaration; +declare function exportAllDeclaration(source: StringLiteral, attributes?: ImportAttribute[] | null): ExportAllDeclaration; +declare function exportDefaultDeclaration(declaration: TSDeclareFunction | FunctionDeclaration | ClassDeclaration | Expression): ExportDefaultDeclaration; +declare function exportNamedDeclaration(declaration?: Declaration | null, specifiers?: (ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier)[], source?: StringLiteral | null, attributes?: ImportAttribute[] | null): ExportNamedDeclaration; +declare function exportSpecifier(local: Identifier, exported: Identifier | StringLiteral): ExportSpecifier; +declare function forOfStatement(left: VariableDeclaration | LVal, right: Expression, body: Statement, _await?: boolean): ForOfStatement; +declare function importDeclaration(specifiers: (ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier)[], source: StringLiteral, attributes?: ImportAttribute[] | null): ImportDeclaration; +declare function importDefaultSpecifier(local: Identifier): ImportDefaultSpecifier; +declare function importNamespaceSpecifier(local: Identifier): ImportNamespaceSpecifier; +declare function importSpecifier(local: Identifier, imported: Identifier | StringLiteral): ImportSpecifier; +declare function importExpression(source: Expression, options?: Expression | null): ImportExpression; +declare function metaProperty(meta: Identifier, property: Identifier): MetaProperty; +declare function classMethod(kind: "get" | "set" | "method" | "constructor" | undefined, key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, params: (FunctionParameter | TSParameterProperty)[], body: BlockStatement, computed?: boolean, _static?: boolean, generator?: boolean, async?: boolean): ClassMethod; +declare function objectPattern(properties: (RestElement | ObjectProperty)[]): ObjectPattern; +declare function spreadElement(argument: Expression): SpreadElement; +declare function _super(): Super; + +declare function taggedTemplateExpression(tag: Expression, quasi: TemplateLiteral): TaggedTemplateExpression; +declare function templateElement(value: { + raw: string; + cooked?: string; +}, tail?: boolean): TemplateElement; +declare function templateLiteral(quasis: TemplateElement[], expressions: (Expression | TSType)[]): TemplateLiteral; +declare function yieldExpression(argument?: Expression | null, delegate?: boolean): YieldExpression; +declare function awaitExpression(argument: Expression): AwaitExpression; +declare function _import(): Import; + +declare function exportNamespaceSpecifier(exported: Identifier): ExportNamespaceSpecifier; +declare function optionalMemberExpression(object: Expression, property: Expression | Identifier, computed: boolean | undefined, optional: boolean): OptionalMemberExpression; +declare function optionalCallExpression(callee: Expression, _arguments: (Expression | SpreadElement | ArgumentPlaceholder)[], optional: boolean): OptionalCallExpression; +declare function classProperty(key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Decorator[] | null, computed?: boolean, _static?: boolean): ClassProperty; +declare function classAccessorProperty(key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression | PrivateName, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Decorator[] | null, computed?: boolean, _static?: boolean): ClassAccessorProperty; +declare function classPrivateProperty(key: PrivateName, value?: Expression | null, decorators?: Decorator[] | null, _static?: boolean): ClassPrivateProperty; +declare function classPrivateMethod(kind: "get" | "set" | "method" | undefined, key: PrivateName, params: (FunctionParameter | TSParameterProperty)[], body: BlockStatement, _static?: boolean): ClassPrivateMethod; +declare function privateName(id: Identifier): PrivateName; +declare function staticBlock(body: Statement[]): StaticBlock; +declare function importAttribute(key: Identifier | StringLiteral, value: StringLiteral): ImportAttribute; +declare function anyTypeAnnotation(): AnyTypeAnnotation; +declare function arrayTypeAnnotation(elementType: FlowType): ArrayTypeAnnotation; +declare function booleanTypeAnnotation(): BooleanTypeAnnotation; +declare function booleanLiteralTypeAnnotation(value: boolean): BooleanLiteralTypeAnnotation; +declare function nullLiteralTypeAnnotation(): NullLiteralTypeAnnotation; +declare function classImplements(id: Identifier, typeParameters?: TypeParameterInstantiation | null): ClassImplements; +declare function declareClass(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: InterfaceExtends[] | null | undefined, body: ObjectTypeAnnotation): DeclareClass; +declare function declareFunction(id: Identifier): DeclareFunction; +declare function declareInterface(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: InterfaceExtends[] | null | undefined, body: ObjectTypeAnnotation): DeclareInterface; +declare function declareModule(id: Identifier | StringLiteral, body: BlockStatement, kind?: "CommonJS" | "ES" | null): DeclareModule; +declare function declareModuleExports(typeAnnotation: TypeAnnotation): DeclareModuleExports; +declare function declareTypeAlias(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, right: FlowType): DeclareTypeAlias; +declare function declareOpaqueType(id: Identifier, typeParameters?: TypeParameterDeclaration | null, supertype?: FlowType | null): DeclareOpaqueType; +declare function declareVariable(id: Identifier): DeclareVariable; +declare function declareExportDeclaration(declaration?: Flow | null, specifiers?: (ExportSpecifier | ExportNamespaceSpecifier)[] | null, source?: StringLiteral | null, attributes?: ImportAttribute[] | null): DeclareExportDeclaration; +declare function declareExportAllDeclaration(source: StringLiteral, attributes?: ImportAttribute[] | null): DeclareExportAllDeclaration; +declare function declaredPredicate(value: Flow): DeclaredPredicate; +declare function existsTypeAnnotation(): ExistsTypeAnnotation; +declare function functionTypeAnnotation(typeParameters: TypeParameterDeclaration | null | undefined, params: FunctionTypeParam[], rest: FunctionTypeParam | null | undefined, returnType: FlowType): FunctionTypeAnnotation; +declare function functionTypeParam(name: Identifier | null | undefined, typeAnnotation: FlowType): FunctionTypeParam; +declare function genericTypeAnnotation(id: Identifier | QualifiedTypeIdentifier, typeParameters?: TypeParameterInstantiation | null): GenericTypeAnnotation; +declare function inferredPredicate(): InferredPredicate; +declare function interfaceExtends(id: Identifier | QualifiedTypeIdentifier, typeParameters?: TypeParameterInstantiation | null): InterfaceExtends; +declare function interfaceDeclaration(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: InterfaceExtends[] | null | undefined, body: ObjectTypeAnnotation): InterfaceDeclaration; +declare function interfaceTypeAnnotation(_extends: InterfaceExtends[] | null | undefined, body: ObjectTypeAnnotation): InterfaceTypeAnnotation; +declare function intersectionTypeAnnotation(types: FlowType[]): IntersectionTypeAnnotation; +declare function mixedTypeAnnotation(): MixedTypeAnnotation; +declare function emptyTypeAnnotation(): EmptyTypeAnnotation; +declare function nullableTypeAnnotation(typeAnnotation: FlowType): NullableTypeAnnotation; +declare function numberLiteralTypeAnnotation(value: number): NumberLiteralTypeAnnotation; +declare function numberTypeAnnotation(): NumberTypeAnnotation; +declare function objectTypeAnnotation(properties: (ObjectTypeProperty | ObjectTypeSpreadProperty)[], indexers?: ObjectTypeIndexer[], callProperties?: ObjectTypeCallProperty[], internalSlots?: ObjectTypeInternalSlot[], exact?: boolean): ObjectTypeAnnotation; +declare function objectTypeInternalSlot(id: Identifier, value: FlowType, optional: boolean, _static: boolean, method: boolean): ObjectTypeInternalSlot; +declare function objectTypeCallProperty(value: FlowType): ObjectTypeCallProperty; +declare function objectTypeIndexer(id: Identifier | null | undefined, key: FlowType, value: FlowType, variance?: Variance | null): ObjectTypeIndexer; +declare function objectTypeProperty(key: Identifier | StringLiteral, value: FlowType, variance?: Variance | null): ObjectTypeProperty; +declare function objectTypeSpreadProperty(argument: FlowType): ObjectTypeSpreadProperty; +declare function opaqueType(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, supertype: FlowType | null | undefined, impltype: FlowType): OpaqueType; +declare function qualifiedTypeIdentifier(id: Identifier, qualification: Identifier | QualifiedTypeIdentifier): QualifiedTypeIdentifier; +declare function stringLiteralTypeAnnotation(value: string): StringLiteralTypeAnnotation; +declare function stringTypeAnnotation(): StringTypeAnnotation; +declare function symbolTypeAnnotation(): SymbolTypeAnnotation; +declare function thisTypeAnnotation(): ThisTypeAnnotation; +declare function tupleTypeAnnotation(types: FlowType[]): TupleTypeAnnotation; +declare function typeofTypeAnnotation(argument: FlowType): TypeofTypeAnnotation; +declare function typeAlias(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, right: FlowType): TypeAlias; +declare function typeAnnotation(typeAnnotation: FlowType): TypeAnnotation; +declare function typeCastExpression(expression: Expression, typeAnnotation: TypeAnnotation): TypeCastExpression; +declare function typeParameter(bound?: TypeAnnotation | null, _default?: FlowType | null, variance?: Variance | null): TypeParameter; +declare function typeParameterDeclaration(params: TypeParameter[]): TypeParameterDeclaration; +declare function typeParameterInstantiation(params: FlowType[]): TypeParameterInstantiation; +declare function unionTypeAnnotation(types: FlowType[]): UnionTypeAnnotation; +declare function variance(kind: "minus" | "plus"): Variance; +declare function voidTypeAnnotation(): VoidTypeAnnotation; +declare function enumDeclaration(id: Identifier, body: EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody): EnumDeclaration; +declare function enumBooleanBody(members: EnumBooleanMember[]): EnumBooleanBody; +declare function enumNumberBody(members: EnumNumberMember[]): EnumNumberBody; +declare function enumStringBody(members: (EnumStringMember | EnumDefaultedMember)[]): EnumStringBody; +declare function enumSymbolBody(members: EnumDefaultedMember[]): EnumSymbolBody; +declare function enumBooleanMember(id: Identifier): EnumBooleanMember; +declare function enumNumberMember(id: Identifier, init: NumericLiteral): EnumNumberMember; +declare function enumStringMember(id: Identifier, init: StringLiteral): EnumStringMember; +declare function enumDefaultedMember(id: Identifier): EnumDefaultedMember; +declare function indexedAccessType(objectType: FlowType, indexType: FlowType): IndexedAccessType; +declare function optionalIndexedAccessType(objectType: FlowType, indexType: FlowType): OptionalIndexedAccessType; +declare function jsxAttribute(name: JSXIdentifier | JSXNamespacedName, value?: JSXElement | JSXFragment | StringLiteral | JSXExpressionContainer | null): JSXAttribute; + +declare function jsxClosingElement(name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName): JSXClosingElement; + +declare function jsxElement(openingElement: JSXOpeningElement, closingElement: JSXClosingElement | null | undefined, children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[], selfClosing?: boolean | null): JSXElement; + +declare function jsxEmptyExpression(): JSXEmptyExpression; + +declare function jsxExpressionContainer(expression: Expression | JSXEmptyExpression): JSXExpressionContainer; + +declare function jsxSpreadChild(expression: Expression): JSXSpreadChild; + +declare function jsxIdentifier(name: string): JSXIdentifier; + +declare function jsxMemberExpression(object: JSXMemberExpression | JSXIdentifier, property: JSXIdentifier): JSXMemberExpression; + +declare function jsxNamespacedName(namespace: JSXIdentifier, name: JSXIdentifier): JSXNamespacedName; + +declare function jsxOpeningElement(name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName, attributes: (JSXAttribute | JSXSpreadAttribute)[], selfClosing?: boolean): JSXOpeningElement; + +declare function jsxSpreadAttribute(argument: Expression): JSXSpreadAttribute; + +declare function jsxText(value: string): JSXText; + +declare function jsxFragment(openingFragment: JSXOpeningFragment, closingFragment: JSXClosingFragment, children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[]): JSXFragment; + +declare function jsxOpeningFragment(): JSXOpeningFragment; + +declare function jsxClosingFragment(): JSXClosingFragment; + +declare function noop(): Noop; +declare function placeholder(expectedNode: "Identifier" | "StringLiteral" | "Expression" | "Statement" | "Declaration" | "BlockStatement" | "ClassBody" | "Pattern", name: Identifier): Placeholder; +declare function v8IntrinsicIdentifier(name: string): V8IntrinsicIdentifier; +declare function argumentPlaceholder(): ArgumentPlaceholder; +declare function bindExpression(object: Expression, callee: Expression): BindExpression; +declare function decorator(expression: Expression): Decorator; +declare function doExpression(body: BlockStatement, async?: boolean): DoExpression; +declare function exportDefaultSpecifier(exported: Identifier): ExportDefaultSpecifier; +declare function recordExpression(properties: (ObjectProperty | SpreadElement)[]): RecordExpression; +declare function tupleExpression(elements?: (Expression | SpreadElement)[]): TupleExpression; +declare function decimalLiteral(value: string): DecimalLiteral; +declare function moduleExpression(body: Program): ModuleExpression; +declare function topicReference(): TopicReference; +declare function pipelineTopicExpression(expression: Expression): PipelineTopicExpression; +declare function pipelineBareFunction(callee: Expression): PipelineBareFunction; +declare function pipelinePrimaryTopicReference(): PipelinePrimaryTopicReference; +declare function voidPattern(): VoidPattern; +declare function tsParameterProperty(parameter: Identifier | AssignmentPattern): TSParameterProperty; + +declare function tsDeclareFunction(id: Identifier | null | undefined, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: FunctionParameter[], returnType?: TSTypeAnnotation | Noop | null): TSDeclareFunction; + +declare function tsDeclareMethod(decorators: Decorator[] | null | undefined, key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: (FunctionParameter | TSParameterProperty)[], returnType?: TSTypeAnnotation | Noop | null): TSDeclareMethod; + +declare function tsQualifiedName(left: TSEntityName, right: Identifier): TSQualifiedName; + +declare function tsCallSignatureDeclaration(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSCallSignatureDeclaration; + +declare function tsConstructSignatureDeclaration(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSConstructSignatureDeclaration; + +declare function tsPropertySignature(key: Expression, typeAnnotation?: TSTypeAnnotation | null): TSPropertySignature; + +declare function tsMethodSignature(key: Expression, typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSMethodSignature; + +declare function tsIndexSignature(parameters: Identifier[], typeAnnotation?: TSTypeAnnotation | null): TSIndexSignature; + +declare function tsAnyKeyword(): TSAnyKeyword; + +declare function tsBooleanKeyword(): TSBooleanKeyword; + +declare function tsBigIntKeyword(): TSBigIntKeyword; + +declare function tsIntrinsicKeyword(): TSIntrinsicKeyword; + +declare function tsNeverKeyword(): TSNeverKeyword; + +declare function tsNullKeyword(): TSNullKeyword; + +declare function tsNumberKeyword(): TSNumberKeyword; + +declare function tsObjectKeyword(): TSObjectKeyword; + +declare function tsStringKeyword(): TSStringKeyword; + +declare function tsSymbolKeyword(): TSSymbolKeyword; + +declare function tsUndefinedKeyword(): TSUndefinedKeyword; + +declare function tsUnknownKeyword(): TSUnknownKeyword; + +declare function tsVoidKeyword(): TSVoidKeyword; + +declare function tsThisType(): TSThisType; + +declare function tsFunctionType(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSFunctionType; + +declare function tsConstructorType(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSConstructorType; + +declare function tsTypeReference(typeName: TSEntityName, typeParameters?: TSTypeParameterInstantiation | null): TSTypeReference; + +declare function tsTypePredicate(parameterName: Identifier | TSThisType, typeAnnotation?: TSTypeAnnotation | null, asserts?: boolean | null): TSTypePredicate; + +declare function tsTypeQuery(exprName: TSEntityName | TSImportType, typeParameters?: TSTypeParameterInstantiation | null): TSTypeQuery; + +declare function tsTypeLiteral(members: TSTypeElement[]): TSTypeLiteral; + +declare function tsArrayType(elementType: TSType): TSArrayType; + +declare function tsTupleType(elementTypes: (TSType | TSNamedTupleMember)[]): TSTupleType; + +declare function tsOptionalType(typeAnnotation: TSType): TSOptionalType; + +declare function tsRestType(typeAnnotation: TSType): TSRestType; + +declare function tsNamedTupleMember(label: Identifier, elementType: TSType, optional?: boolean): TSNamedTupleMember; + +declare function tsUnionType(types: TSType[]): TSUnionType; + +declare function tsIntersectionType(types: TSType[]): TSIntersectionType; + +declare function tsConditionalType(checkType: TSType, extendsType: TSType, trueType: TSType, falseType: TSType): TSConditionalType; + +declare function tsInferType(typeParameter: TSTypeParameter): TSInferType; + +declare function tsParenthesizedType(typeAnnotation: TSType): TSParenthesizedType; + +declare function tsTypeOperator(typeAnnotation: TSType, operator?: string): TSTypeOperator; + +declare function tsIndexedAccessType(objectType: TSType, indexType: TSType): TSIndexedAccessType; + +declare function tsMappedType(typeParameter: TSTypeParameter, typeAnnotation?: TSType | null, nameType?: TSType | null): TSMappedType; + +declare function tsTemplateLiteralType(quasis: TemplateElement[], types: TSType[]): TSTemplateLiteralType; + +declare function tsLiteralType(literal: NumericLiteral | StringLiteral | BooleanLiteral | BigIntLiteral | TemplateLiteral | UnaryExpression): TSLiteralType; + +declare function tsExpressionWithTypeArguments(expression: TSEntityName, typeParameters?: TSTypeParameterInstantiation | null): TSExpressionWithTypeArguments; + +declare function tsInterfaceDeclaration(id: Identifier, typeParameters: TSTypeParameterDeclaration | null | undefined, _extends: TSExpressionWithTypeArguments[] | null | undefined, body: TSInterfaceBody): TSInterfaceDeclaration; + +declare function tsInterfaceBody(body: TSTypeElement[]): TSInterfaceBody; + +declare function tsTypeAliasDeclaration(id: Identifier, typeParameters: TSTypeParameterDeclaration | null | undefined, typeAnnotation: TSType): TSTypeAliasDeclaration; + +declare function tsInstantiationExpression(expression: Expression, typeParameters?: TSTypeParameterInstantiation | null): TSInstantiationExpression; + +declare function tsAsExpression(expression: Expression, typeAnnotation: TSType): TSAsExpression; + +declare function tsSatisfiesExpression(expression: Expression, typeAnnotation: TSType): TSSatisfiesExpression; + +declare function tsTypeAssertion(typeAnnotation: TSType, expression: Expression): TSTypeAssertion; + +declare function tsEnumBody(members: TSEnumMember[]): TSEnumBody; + +declare function tsEnumDeclaration(id: Identifier, members: TSEnumMember[]): TSEnumDeclaration; + +declare function tsEnumMember(id: Identifier | StringLiteral, initializer?: Expression | null): TSEnumMember; + +declare function tsModuleDeclaration(id: Identifier | StringLiteral, body: TSModuleBlock | TSModuleDeclaration): TSModuleDeclaration; + +declare function tsModuleBlock(body: Statement[]): TSModuleBlock; + +declare function tsImportType(argument: StringLiteral, qualifier?: TSEntityName | null, typeParameters?: TSTypeParameterInstantiation | null): TSImportType; + +declare function tsImportEqualsDeclaration(id: Identifier, moduleReference: TSEntityName | TSExternalModuleReference): TSImportEqualsDeclaration; + +declare function tsExternalModuleReference(expression: StringLiteral): TSExternalModuleReference; + +declare function tsNonNullExpression(expression: Expression): TSNonNullExpression; + +declare function tsExportAssignment(expression: Expression): TSExportAssignment; + +declare function tsNamespaceExportDeclaration(id: Identifier): TSNamespaceExportDeclaration; + +declare function tsTypeAnnotation(typeAnnotation: TSType): TSTypeAnnotation; + +declare function tsTypeParameterInstantiation(params: TSType[]): TSTypeParameterInstantiation; + +declare function tsTypeParameterDeclaration(params: TSTypeParameter[]): TSTypeParameterDeclaration; + +declare function tsTypeParameter(constraint: TSType | null | undefined, _default: TSType | null | undefined, name: string): TSTypeParameter; + +/** @deprecated */ +declare function NumberLiteral(value: number): NumericLiteral; + +/** @deprecated */ +declare function RegexLiteral(pattern: string, flags?: string): RegExpLiteral; + +/** @deprecated */ +declare function RestProperty(argument: Identifier | ArrayPattern | ObjectPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression | RestElement | AssignmentPattern): RestElement; + +/** @deprecated */ +declare function SpreadProperty(argument: Expression): SpreadElement; + +declare function buildUndefinedNode(): UnaryExpression; + +/** + * Create a clone of a `node` including only properties belonging to the node. + * If the second parameter is `false`, cloneNode performs a shallow clone. + * If the third parameter is true, the cloned nodes exclude location properties. + */ +declare function cloneNode(node: T, deep?: boolean, withoutLoc?: boolean): T; + +/** + * Create a shallow clone of a `node`, including only + * properties belonging to the node. + * @deprecated Use t.cloneNode instead. + */ +declare function clone(node: T): T; + +/** + * Create a deep clone of a `node` and all of it's child nodes + * including only properties belonging to the node. + * @deprecated Use t.cloneNode instead. + */ +declare function cloneDeep(node: T): T; + +/** + * Create a deep clone of a `node` and all of it's child nodes + * including only properties belonging to the node. + * excluding `_private` and location properties. + */ +declare function cloneDeepWithoutLoc(node: T): T; + +/** + * Create a shallow clone of a `node` excluding `_private` and location properties. + */ +declare function cloneWithoutLoc(node: T): T; + +/** + * Add comment of certain type to a node. + */ +declare function addComment(node: T, type: CommentTypeShorthand, content: string, line?: boolean): T; + +/** + * Add comments of certain type to a node. + */ +declare function addComments(node: T, type: CommentTypeShorthand, comments: Comment[]): T; + +declare function inheritInnerComments(child: Node, parent: Node): void; + +declare function inheritLeadingComments(child: Node, parent: Node): void; + +/** + * Inherit all unique comments from `parent` node to `child` node. + */ +declare function inheritsComments(child: T, parent: Node): T; + +declare function inheritTrailingComments(child: Node, parent: Node): void; + +/** + * Remove comment properties from a node. + */ +declare function removeComments(node: T): T; + +declare const STANDARDIZED_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const EXPRESSION_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const BINARY_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const SCOPABLE_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const BLOCKPARENT_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const BLOCK_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const STATEMENT_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const TERMINATORLESS_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const COMPLETIONSTATEMENT_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const CONDITIONAL_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const LOOP_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const WHILE_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const EXPRESSIONWRAPPER_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const FOR_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const FORXSTATEMENT_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const FUNCTION_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const FUNCTIONPARENT_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const PUREISH_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const DECLARATION_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const FUNCTIONPARAMETER_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const PATTERNLIKE_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const LVAL_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const TSENTITYNAME_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const LITERAL_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const IMMUTABLE_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const USERWHITESPACABLE_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const METHOD_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const OBJECTMEMBER_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const PROPERTY_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const UNARYLIKE_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const PATTERN_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const CLASS_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const IMPORTOREXPORTDECLARATION_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const EXPORTDECLARATION_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const MODULESPECIFIER_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const ACCESSOR_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const PRIVATE_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const FLOW_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const FLOWTYPE_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const FLOWBASEANNOTATION_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const FLOWDECLARATION_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const FLOWPREDICATE_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const ENUMBODY_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const ENUMMEMBER_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const JSX_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const MISCELLANEOUS_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const TYPESCRIPT_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const TSTYPEELEMENT_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const TSTYPE_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +declare const TSBASETYPE_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; +/** + * @deprecated migrate to IMPORTOREXPORTDECLARATION_TYPES. + */ +declare const MODULEDECLARATION_TYPES: ("AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumBody" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSTemplateLiteralType" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidPattern" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression" | keyof Aliases)[]; + +declare const STATEMENT_OR_BLOCK_KEYS: string[]; +declare const FLATTENABLE_KEYS: string[]; +declare const FOR_INIT_KEYS: string[]; +declare const COMMENT_KEYS: readonly ["leadingComments", "trailingComments", "innerComments"]; +declare const LOGICAL_OPERATORS: string[]; +declare const UPDATE_OPERATORS: string[]; +declare const BOOLEAN_NUMBER_BINARY_OPERATORS: string[]; +declare const EQUALITY_BINARY_OPERATORS: string[]; +declare const COMPARISON_BINARY_OPERATORS: string[]; +declare const BOOLEAN_BINARY_OPERATORS: string[]; +declare const NUMBER_BINARY_OPERATORS: string[]; +declare const BINARY_OPERATORS: string[]; +declare const ASSIGNMENT_OPERATORS: string[]; +declare const BOOLEAN_UNARY_OPERATORS: string[]; +declare const NUMBER_UNARY_OPERATORS: string[]; +declare const STRING_UNARY_OPERATORS: string[]; +declare const UNARY_OPERATORS: string[]; +declare const INHERIT_KEYS: { + readonly optional: readonly ["typeAnnotation", "typeParameters", "returnType"]; + readonly force: readonly ["start", "loc", "end"]; +}; + +/** + * Ensure the `key` (defaults to "body") of a `node` is a block. + * Casting it to a block if it is not. + * + * Returns the BlockStatement + */ +declare function ensureBlock(node: Node, key?: string): BlockStatement; + +declare function toBindingIdentifierName(name: string): string; + +declare function toBlock(node: Statement | Expression, parent?: Node): BlockStatement; + +declare function toComputedKey(node: ObjectMember | ObjectProperty | ClassMethod | ClassProperty | ClassAccessorProperty | MemberExpression | OptionalMemberExpression, key?: Expression | PrivateName): PrivateName | Expression; + +declare const _default$3: { + (node: Function): FunctionExpression; + (node: Class): ClassExpression; + (node: ExpressionStatement | Expression | Class | Function): Expression; +}; +//# sourceMappingURL=toExpression.d.ts.map + +declare function toIdentifier(input: string): string; + +declare function toKeyAlias(node: Method | Property, key?: Node): string; +declare namespace toKeyAlias { + var uid: number; + var increment: () => number; +} +//# sourceMappingURL=toKeyAlias.d.ts.map + +declare const _default$2: { + (node: AssignmentExpression, ignore?: boolean): ExpressionStatement; + (node: T, ignore: false): T; + (node: T, ignore?: boolean): T | false; + (node: Class, ignore: false): ClassDeclaration; + (node: Class, ignore?: boolean): ClassDeclaration | false; + (node: Function, ignore: false): FunctionDeclaration; + (node: Function, ignore?: boolean): FunctionDeclaration | false; + (node: Node, ignore: false): Statement; + (node: Node, ignore?: boolean): Statement | false; +}; +//# sourceMappingURL=toStatement.d.ts.map + +declare const _default$1: { + (value: undefined): Identifier; + (value: boolean): BooleanLiteral; + (value: null): NullLiteral; + (value: string): StringLiteral; + (value: number): NumericLiteral | BinaryExpression | UnaryExpression; + (value: bigint): BigIntLiteral; + (value: RegExp): RegExpLiteral; + (value: readonly unknown[]): ArrayExpression; + (value: object): ObjectExpression; + (value: unknown): Expression; +}; +//# sourceMappingURL=valueToNode.d.ts.map + +declare const VISITOR_KEYS: Record; +declare const ALIAS_KEYS: Partial>; +declare const FLIPPED_ALIAS_KEYS: Record; +declare const NODE_FIELDS: Record; +declare const BUILDER_KEYS: Record; +declare const DEPRECATED_KEYS: Record; +declare const NODE_PARENT_VALIDATIONS: Record; +declare function getType(val: any): "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "array" | "null"; +type NodeTypesWithoutComment = Node["type"] | keyof Aliases; +type NodeTypes = NodeTypesWithoutComment | Comment["type"]; +type PrimitiveTypes = ReturnType; +type FieldDefinitions = Record; +type ValidatorImpl = (node?: Node, key?: string | { + toString(): string; +}, val?: any) => void; +type ValidatorType = { + type: PrimitiveTypes; +} & ValidatorImpl; +type ValidatorEach = { + each: Validator; +} & ValidatorImpl; +type ValidatorChainOf = { + chainOf: readonly Validator[]; +} & ValidatorImpl; +type ValidatorOneOf = { + oneOf: readonly any[]; +} & ValidatorImpl; +type ValidatorOneOfNodeTypes = { + oneOfNodeTypes: readonly NodeTypes[]; +} & ValidatorImpl; +type ValidatorOneOfNodeOrValueTypes = { + oneOfNodeOrValueTypes: readonly (NodeTypes | PrimitiveTypes)[]; +} & ValidatorImpl; +type ValidatorShapeOf = { + shapeOf: Record; +} & ValidatorImpl; +type Validator = ValidatorType | ValidatorEach | ValidatorChainOf | ValidatorOneOf | ValidatorOneOfNodeTypes | ValidatorOneOfNodeOrValueTypes | ValidatorShapeOf | ValidatorImpl; +type FieldOptions = { + default?: string | number | boolean | []; + optional?: boolean; + deprecated?: boolean; + validate?: Validator; +}; + +declare const PLACEHOLDERS: readonly ["Identifier", "StringLiteral", "Expression", "Statement", "Declaration", "BlockStatement", "ClassBody", "Pattern"]; +declare const PLACEHOLDERS_ALIAS: Record; +declare const PLACEHOLDERS_FLIPPED_ALIAS: Record; + +declare const DEPRECATED_ALIASES: { + ModuleDeclaration: string; +}; + +declare const TYPES: string[]; +//# sourceMappingURL=index.d.ts.map + +/** + * Append a node to a member expression. + */ +declare function appendToMemberExpression(member: MemberExpression, append: MemberExpression["property"], computed?: boolean): MemberExpression; + +/** + * Inherit all contextual properties from `parent` node to `child` node. + */ +declare function inherits(child: T, parent: Node | null | undefined): T; + +/** + * Prepend a node to a member expression. + */ +declare function prependToMemberExpression>(member: T, prepend: MemberExpression["object"]): T; + +type Options$1 = { + preserveComments?: boolean; +}; +/** + * Remove all of the _* properties from a node along with the additional metadata + * properties like location data and raw token data. + */ +declare function removeProperties(node: Node, opts?: Options$1): void; + +declare function removePropertiesDeep(tree: T, opts?: { + preserveComments: boolean; +} | null): T; + +/** + * Dedupe type annotations. + */ +declare function removeTypeDuplicates(nodesIn: readonly (FlowType | false | null | undefined)[]): FlowType[]; + +/** + * For the given node, generate a map from assignment id names to the identifier node. + * Unlike getBindingIdentifiers, this function does not handle declarations and imports. + * @param node the assignment expression or forXstatement + * @returns an object map + * @see getBindingIdentifiers + */ +declare function getAssignmentIdentifiers(node: Node | Node[]): Record; + +declare function getBindingIdentifiers(node: Node, duplicates: true, outerOnly?: boolean, newBindingsOnly?: boolean): Record; +declare function getBindingIdentifiers(node: Node, duplicates?: false, outerOnly?: boolean, newBindingsOnly?: boolean): Record; +declare function getBindingIdentifiers(node: Node, duplicates?: boolean, outerOnly?: boolean, newBindingsOnly?: boolean): Record | Record; +declare namespace getBindingIdentifiers { + var keys: KeysMap; +} +/** + * Mapping of types to their identifier keys. + */ +type KeysMap = { + [N in Node as N["type"]]?: (keyof N)[]; +}; +//# sourceMappingURL=getBindingIdentifiers.d.ts.map + +declare const _default: { + (node: Node, duplicates: true): Record; + (node: Node, duplicates?: false): Record; + (node: Node, duplicates?: boolean): Record | Record; +}; +//# sourceMappingURL=getOuterBindingIdentifiers.d.ts.map + +type GetFunctionNameResult = { + name: string; + originalNode: Node; +} | null; +declare function getFunctionName(node: ObjectMethod | ClassMethod): GetFunctionNameResult; +declare function getFunctionName(node: Function | Class, parent: Node): GetFunctionNameResult; + +type TraversalAncestors = { + node: Node; + key: string; + index?: number; +}[]; +type TraversalHandler = (this: undefined, node: Node, parent: TraversalAncestors, state: T) => void; +type TraversalHandlers = { + enter?: TraversalHandler; + exit?: TraversalHandler; +}; +/** + * A general AST traversal with both prefix and postfix handlers, and a + * state object. Exposes ancestry data to each handler so that more complex + * AST data can be taken into account. + */ +declare function traverse(node: Node, handlers: TraversalHandler | TraversalHandlers, state?: T): void; + +declare const _skip: unique symbol; +declare const _stop: unique symbol; +/** + * A prefix AST traversal implementation meant for simple searching and processing. + * @param enter The callback can return `traverseFast.skip` to skip the subtree of the current node, or `traverseFast.stop` to stop the traversal. + * @returns `true` if the traversal was stopped by callback, `false` otherwise. + */ +declare function traverseFast(node: Node | null | undefined, enter: (node: Node, opts?: Options) => void | typeof traverseFast.skip | typeof traverseFast.stop, opts?: Options): boolean; +declare namespace traverseFast { + var skip: typeof _skip; + var stop: typeof _stop; +} +//# sourceMappingURL=traverseFast.d.ts.map + +declare function shallowEqual(actual: object, expected: T): actual is T; + +declare function is(type: T, node: Node | null | undefined, opts?: undefined): node is Extract; +declare function is>(type: T, n: Node | null | undefined, required: Partial

): n is P; +declare function is

(type: string, node: Node | null | undefined, opts: Partial

): node is P; +declare function is(type: string, node: Node | null | undefined, opts?: Partial): node is Node; + +/** + * Check if the input `node` is a binding identifier. + */ +declare function isBinding(node: Node, parent: Node, grandparent?: Node): boolean; + +/** + * Check if the input `node` is block scoped. + */ +declare function isBlockScoped(node: Node | null | undefined): boolean; + +/** + * Check if the input `node` is definitely immutable. + */ +declare function isImmutable(node: Node): boolean; + +/** + * Check if the input `node` is a `let` variable declaration. + */ +declare function isLet(node: Node): boolean; + +declare function isNode(node: any): node is Node; + +/** + * Check if two nodes are equivalent + */ +declare function isNodesEquivalent>(a: T, b: any): b is T; + +/** + * Test if a `placeholderType` is a `targetType` or if `targetType` is an alias of `placeholderType`. + */ +declare function isPlaceholderType(placeholderType: string, targetType: string): boolean; + +/** + * Check if the input `node` is a reference to a bound variable. + */ +declare function isReferenced(node: Node | null | undefined, parent: Node, grandparent?: Node): boolean; + +/** + * Check if the input `node` is a scope. + */ +declare function isScope(node: Node | null | undefined, parent: Node): boolean; + +/** + * Check if the input `specifier` is a `default` import or export. + */ +declare function isSpecifierDefault(specifier: ModuleSpecifier): boolean; + +declare function isType(nodeType: string, targetType: T): nodeType is T; +declare function isType(nodeType: string | null | undefined, targetType: string): boolean; + +/** + * Check if the input `name` is a valid identifier name according to the ES3 specification. + * + * Additional ES3 reserved words are + */ +declare function isValidES3Identifier(name: string): boolean; + +/** + * Check if the input `name` is a valid identifier name + * and isn't a reserved word. + */ +declare function isValidIdentifier(name: string, reserved?: boolean): boolean; + +/** + * Check if the input `node` is a variable declaration. + */ +declare function isVar(node: Node | null | undefined): boolean; + +/** + * Determines whether or not the input node `member` matches the + * input `match`. + * + * For example, given the match `React.createClass` it would match the + * parsed nodes of `React.createClass` and `React["createClass"]`. + */ +declare function matchesPattern(member: Node | null | undefined, match: string | string[], allowPartial?: boolean): boolean; + +declare function validate(node: Node | undefined | null, key: string, val: unknown): void; + +/** + * Build a function that when called will return whether or not the + * input `node` `MemberExpression` matches the input `match`. + * + * For example, given the match `React.createClass` it would match the + * parsed nodes of `React.createClass` and `React["createClass"]`. + */ +declare function buildMatchMemberExpression(match: string, allowPartial?: boolean): (member: Node) => boolean; + +type Options = Partial<{ + [Prop in Exclude]: Obj[Prop] extends Node ? Node : Obj[Prop] extends Node[] ? Node[] : Obj[Prop]; +}>; +declare function isArrayExpression(node: Node | null | undefined): node is ArrayExpression; +declare function isArrayExpression>(node: Node | null | undefined, opts?: Opts | null): node is ArrayExpression & Opts; +declare function isAssignmentExpression(node: Node | null | undefined): node is AssignmentExpression; +declare function isAssignmentExpression>(node: Node | null | undefined, opts?: Opts | null): node is AssignmentExpression & Opts; +declare function isBinaryExpression(node: Node | null | undefined): node is BinaryExpression; +declare function isBinaryExpression>(node: Node | null | undefined, opts?: Opts | null): node is BinaryExpression & Opts; +declare function isInterpreterDirective(node: Node | null | undefined): node is InterpreterDirective; +declare function isInterpreterDirective>(node: Node | null | undefined, opts?: Opts | null): node is InterpreterDirective & Opts; +declare function isDirective(node: Node | null | undefined): node is Directive; +declare function isDirective>(node: Node | null | undefined, opts?: Opts | null): node is Directive & Opts; +declare function isDirectiveLiteral(node: Node | null | undefined): node is DirectiveLiteral; +declare function isDirectiveLiteral>(node: Node | null | undefined, opts?: Opts | null): node is DirectiveLiteral & Opts; +declare function isBlockStatement(node: Node | null | undefined): node is BlockStatement; +declare function isBlockStatement>(node: Node | null | undefined, opts?: Opts | null): node is BlockStatement & Opts; +declare function isBreakStatement(node: Node | null | undefined): node is BreakStatement; +declare function isBreakStatement>(node: Node | null | undefined, opts?: Opts | null): node is BreakStatement & Opts; +declare function isCallExpression(node: Node | null | undefined): node is CallExpression; +declare function isCallExpression>(node: Node | null | undefined, opts?: Opts | null): node is CallExpression & Opts; +declare function isCatchClause(node: Node | null | undefined): node is CatchClause; +declare function isCatchClause>(node: Node | null | undefined, opts?: Opts | null): node is CatchClause & Opts; +declare function isConditionalExpression(node: Node | null | undefined): node is ConditionalExpression; +declare function isConditionalExpression>(node: Node | null | undefined, opts?: Opts | null): node is ConditionalExpression & Opts; +declare function isContinueStatement(node: Node | null | undefined): node is ContinueStatement; +declare function isContinueStatement>(node: Node | null | undefined, opts?: Opts | null): node is ContinueStatement & Opts; +declare function isDebuggerStatement(node: Node | null | undefined): node is DebuggerStatement; +declare function isDebuggerStatement>(node: Node | null | undefined, opts?: Opts | null): node is DebuggerStatement & Opts; +declare function isDoWhileStatement(node: Node | null | undefined): node is DoWhileStatement; +declare function isDoWhileStatement>(node: Node | null | undefined, opts?: Opts | null): node is DoWhileStatement & Opts; +declare function isEmptyStatement(node: Node | null | undefined): node is EmptyStatement; +declare function isEmptyStatement>(node: Node | null | undefined, opts?: Opts | null): node is EmptyStatement & Opts; +declare function isExpressionStatement(node: Node | null | undefined): node is ExpressionStatement; +declare function isExpressionStatement>(node: Node | null | undefined, opts?: Opts | null): node is ExpressionStatement & Opts; +declare function isFile(node: Node | null | undefined): node is File; +declare function isFile>(node: Node | null | undefined, opts?: Opts | null): node is File & Opts; +declare function isForInStatement(node: Node | null | undefined): node is ForInStatement; +declare function isForInStatement>(node: Node | null | undefined, opts?: Opts | null): node is ForInStatement & Opts; +declare function isForStatement(node: Node | null | undefined): node is ForStatement; +declare function isForStatement>(node: Node | null | undefined, opts?: Opts | null): node is ForStatement & Opts; +declare function isFunctionDeclaration(node: Node | null | undefined): node is FunctionDeclaration; +declare function isFunctionDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is FunctionDeclaration & Opts; +declare function isFunctionExpression(node: Node | null | undefined): node is FunctionExpression; +declare function isFunctionExpression>(node: Node | null | undefined, opts?: Opts | null): node is FunctionExpression & Opts; +declare function isIdentifier(node: Node | null | undefined): node is Identifier; +declare function isIdentifier>(node: Node | null | undefined, opts?: Opts | null): node is Identifier & Opts; +declare function isIfStatement(node: Node | null | undefined): node is IfStatement; +declare function isIfStatement>(node: Node | null | undefined, opts?: Opts | null): node is IfStatement & Opts; +declare function isLabeledStatement(node: Node | null | undefined): node is LabeledStatement; +declare function isLabeledStatement>(node: Node | null | undefined, opts?: Opts | null): node is LabeledStatement & Opts; +declare function isStringLiteral(node: Node | null | undefined): node is StringLiteral; +declare function isStringLiteral>(node: Node | null | undefined, opts?: Opts | null): node is StringLiteral & Opts; +declare function isNumericLiteral(node: Node | null | undefined): node is NumericLiteral; +declare function isNumericLiteral>(node: Node | null | undefined, opts?: Opts | null): node is NumericLiteral & Opts; +declare function isNullLiteral(node: Node | null | undefined): node is NullLiteral; +declare function isNullLiteral>(node: Node | null | undefined, opts?: Opts | null): node is NullLiteral & Opts; +declare function isBooleanLiteral(node: Node | null | undefined): node is BooleanLiteral; +declare function isBooleanLiteral>(node: Node | null | undefined, opts?: Opts | null): node is BooleanLiteral & Opts; +declare function isRegExpLiteral(node: Node | null | undefined): node is RegExpLiteral; +declare function isRegExpLiteral>(node: Node | null | undefined, opts?: Opts | null): node is RegExpLiteral & Opts; +declare function isLogicalExpression(node: Node | null | undefined): node is LogicalExpression; +declare function isLogicalExpression>(node: Node | null | undefined, opts?: Opts | null): node is LogicalExpression & Opts; +declare function isMemberExpression(node: Node | null | undefined): node is MemberExpression; +declare function isMemberExpression>(node: Node | null | undefined, opts?: Opts | null): node is MemberExpression & Opts; +declare function isNewExpression(node: Node | null | undefined): node is NewExpression; +declare function isNewExpression>(node: Node | null | undefined, opts?: Opts | null): node is NewExpression & Opts; +declare function isProgram(node: Node | null | undefined): node is Program; +declare function isProgram>(node: Node | null | undefined, opts?: Opts | null): node is Program & Opts; +declare function isObjectExpression(node: Node | null | undefined): node is ObjectExpression; +declare function isObjectExpression>(node: Node | null | undefined, opts?: Opts | null): node is ObjectExpression & Opts; +declare function isObjectMethod(node: Node | null | undefined): node is ObjectMethod; +declare function isObjectMethod>(node: Node | null | undefined, opts?: Opts | null): node is ObjectMethod & Opts; +declare function isObjectProperty(node: Node | null | undefined): node is ObjectProperty; +declare function isObjectProperty>(node: Node | null | undefined, opts?: Opts | null): node is ObjectProperty & Opts; +declare function isRestElement(node: Node | null | undefined): node is RestElement; +declare function isRestElement>(node: Node | null | undefined, opts?: Opts | null): node is RestElement & Opts; +declare function isReturnStatement(node: Node | null | undefined): node is ReturnStatement; +declare function isReturnStatement>(node: Node | null | undefined, opts?: Opts | null): node is ReturnStatement & Opts; +declare function isSequenceExpression(node: Node | null | undefined): node is SequenceExpression; +declare function isSequenceExpression>(node: Node | null | undefined, opts?: Opts | null): node is SequenceExpression & Opts; +declare function isParenthesizedExpression(node: Node | null | undefined): node is ParenthesizedExpression; +declare function isParenthesizedExpression>(node: Node | null | undefined, opts?: Opts | null): node is ParenthesizedExpression & Opts; +declare function isSwitchCase(node: Node | null | undefined): node is SwitchCase; +declare function isSwitchCase>(node: Node | null | undefined, opts?: Opts | null): node is SwitchCase & Opts; +declare function isSwitchStatement(node: Node | null | undefined): node is SwitchStatement; +declare function isSwitchStatement>(node: Node | null | undefined, opts?: Opts | null): node is SwitchStatement & Opts; +declare function isThisExpression(node: Node | null | undefined): node is ThisExpression; +declare function isThisExpression>(node: Node | null | undefined, opts?: Opts | null): node is ThisExpression & Opts; +declare function isThrowStatement(node: Node | null | undefined): node is ThrowStatement; +declare function isThrowStatement>(node: Node | null | undefined, opts?: Opts | null): node is ThrowStatement & Opts; +declare function isTryStatement(node: Node | null | undefined): node is TryStatement; +declare function isTryStatement>(node: Node | null | undefined, opts?: Opts | null): node is TryStatement & Opts; +declare function isUnaryExpression(node: Node | null | undefined): node is UnaryExpression; +declare function isUnaryExpression>(node: Node | null | undefined, opts?: Opts | null): node is UnaryExpression & Opts; +declare function isUpdateExpression(node: Node | null | undefined): node is UpdateExpression; +declare function isUpdateExpression>(node: Node | null | undefined, opts?: Opts | null): node is UpdateExpression & Opts; +declare function isVariableDeclaration(node: Node | null | undefined): node is VariableDeclaration; +declare function isVariableDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is VariableDeclaration & Opts; +declare function isVariableDeclarator(node: Node | null | undefined): node is VariableDeclarator; +declare function isVariableDeclarator>(node: Node | null | undefined, opts?: Opts | null): node is VariableDeclarator & Opts; +declare function isWhileStatement(node: Node | null | undefined): node is WhileStatement; +declare function isWhileStatement>(node: Node | null | undefined, opts?: Opts | null): node is WhileStatement & Opts; +declare function isWithStatement(node: Node | null | undefined): node is WithStatement; +declare function isWithStatement>(node: Node | null | undefined, opts?: Opts | null): node is WithStatement & Opts; +declare function isAssignmentPattern(node: Node | null | undefined): node is AssignmentPattern; +declare function isAssignmentPattern>(node: Node | null | undefined, opts?: Opts | null): node is AssignmentPattern & Opts; +declare function isArrayPattern(node: Node | null | undefined): node is ArrayPattern; +declare function isArrayPattern>(node: Node | null | undefined, opts?: Opts | null): node is ArrayPattern & Opts; +declare function isArrowFunctionExpression(node: Node | null | undefined): node is ArrowFunctionExpression; +declare function isArrowFunctionExpression>(node: Node | null | undefined, opts?: Opts | null): node is ArrowFunctionExpression & Opts; +declare function isClassBody(node: Node | null | undefined): node is ClassBody; +declare function isClassBody>(node: Node | null | undefined, opts?: Opts | null): node is ClassBody & Opts; +declare function isClassExpression(node: Node | null | undefined): node is ClassExpression; +declare function isClassExpression>(node: Node | null | undefined, opts?: Opts | null): node is ClassExpression & Opts; +declare function isClassDeclaration(node: Node | null | undefined): node is ClassDeclaration; +declare function isClassDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is ClassDeclaration & Opts; +declare function isExportAllDeclaration(node: Node | null | undefined): node is ExportAllDeclaration; +declare function isExportAllDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is ExportAllDeclaration & Opts; +declare function isExportDefaultDeclaration(node: Node | null | undefined): node is ExportDefaultDeclaration; +declare function isExportDefaultDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is ExportDefaultDeclaration & Opts; +declare function isExportNamedDeclaration(node: Node | null | undefined): node is ExportNamedDeclaration; +declare function isExportNamedDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is ExportNamedDeclaration & Opts; +declare function isExportSpecifier(node: Node | null | undefined): node is ExportSpecifier; +declare function isExportSpecifier>(node: Node | null | undefined, opts?: Opts | null): node is ExportSpecifier & Opts; +declare function isForOfStatement(node: Node | null | undefined): node is ForOfStatement; +declare function isForOfStatement>(node: Node | null | undefined, opts?: Opts | null): node is ForOfStatement & Opts; +declare function isImportDeclaration(node: Node | null | undefined): node is ImportDeclaration; +declare function isImportDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is ImportDeclaration & Opts; +declare function isImportDefaultSpecifier(node: Node | null | undefined): node is ImportDefaultSpecifier; +declare function isImportDefaultSpecifier>(node: Node | null | undefined, opts?: Opts | null): node is ImportDefaultSpecifier & Opts; +declare function isImportNamespaceSpecifier(node: Node | null | undefined): node is ImportNamespaceSpecifier; +declare function isImportNamespaceSpecifier>(node: Node | null | undefined, opts?: Opts | null): node is ImportNamespaceSpecifier & Opts; +declare function isImportSpecifier(node: Node | null | undefined): node is ImportSpecifier; +declare function isImportSpecifier>(node: Node | null | undefined, opts?: Opts | null): node is ImportSpecifier & Opts; +declare function isImportExpression(node: Node | null | undefined): node is ImportExpression; +declare function isImportExpression>(node: Node | null | undefined, opts?: Opts | null): node is ImportExpression & Opts; +declare function isMetaProperty(node: Node | null | undefined): node is MetaProperty; +declare function isMetaProperty>(node: Node | null | undefined, opts?: Opts | null): node is MetaProperty & Opts; +declare function isClassMethod(node: Node | null | undefined): node is ClassMethod; +declare function isClassMethod>(node: Node | null | undefined, opts?: Opts | null): node is ClassMethod & Opts; +declare function isObjectPattern(node: Node | null | undefined): node is ObjectPattern; +declare function isObjectPattern>(node: Node | null | undefined, opts?: Opts | null): node is ObjectPattern & Opts; +declare function isSpreadElement(node: Node | null | undefined): node is SpreadElement; +declare function isSpreadElement>(node: Node | null | undefined, opts?: Opts | null): node is SpreadElement & Opts; +declare function isSuper(node: Node | null | undefined): node is Super; +declare function isSuper>(node: Node | null | undefined, opts?: Opts | null): node is Super & Opts; +declare function isTaggedTemplateExpression(node: Node | null | undefined): node is TaggedTemplateExpression; +declare function isTaggedTemplateExpression>(node: Node | null | undefined, opts?: Opts | null): node is TaggedTemplateExpression & Opts; +declare function isTemplateElement(node: Node | null | undefined): node is TemplateElement; +declare function isTemplateElement>(node: Node | null | undefined, opts?: Opts | null): node is TemplateElement & Opts; +declare function isTemplateLiteral(node: Node | null | undefined): node is TemplateLiteral; +declare function isTemplateLiteral>(node: Node | null | undefined, opts?: Opts | null): node is TemplateLiteral & Opts; +declare function isYieldExpression(node: Node | null | undefined): node is YieldExpression; +declare function isYieldExpression>(node: Node | null | undefined, opts?: Opts | null): node is YieldExpression & Opts; +declare function isAwaitExpression(node: Node | null | undefined): node is AwaitExpression; +declare function isAwaitExpression>(node: Node | null | undefined, opts?: Opts | null): node is AwaitExpression & Opts; +declare function isImport(node: Node | null | undefined): node is Import; +declare function isImport>(node: Node | null | undefined, opts?: Opts | null): node is Import & Opts; +declare function isBigIntLiteral(node: Node | null | undefined): node is BigIntLiteral; +declare function isBigIntLiteral>(node: Node | null | undefined, opts?: Opts | null): node is BigIntLiteral & Opts; +declare function isExportNamespaceSpecifier(node: Node | null | undefined): node is ExportNamespaceSpecifier; +declare function isExportNamespaceSpecifier>(node: Node | null | undefined, opts?: Opts | null): node is ExportNamespaceSpecifier & Opts; +declare function isOptionalMemberExpression(node: Node | null | undefined): node is OptionalMemberExpression; +declare function isOptionalMemberExpression>(node: Node | null | undefined, opts?: Opts | null): node is OptionalMemberExpression & Opts; +declare function isOptionalCallExpression(node: Node | null | undefined): node is OptionalCallExpression; +declare function isOptionalCallExpression>(node: Node | null | undefined, opts?: Opts | null): node is OptionalCallExpression & Opts; +declare function isClassProperty(node: Node | null | undefined): node is ClassProperty; +declare function isClassProperty>(node: Node | null | undefined, opts?: Opts | null): node is ClassProperty & Opts; +declare function isClassAccessorProperty(node: Node | null | undefined): node is ClassAccessorProperty; +declare function isClassAccessorProperty>(node: Node | null | undefined, opts?: Opts | null): node is ClassAccessorProperty & Opts; +declare function isClassPrivateProperty(node: Node | null | undefined): node is ClassPrivateProperty; +declare function isClassPrivateProperty>(node: Node | null | undefined, opts?: Opts | null): node is ClassPrivateProperty & Opts; +declare function isClassPrivateMethod(node: Node | null | undefined): node is ClassPrivateMethod; +declare function isClassPrivateMethod>(node: Node | null | undefined, opts?: Opts | null): node is ClassPrivateMethod & Opts; +declare function isPrivateName(node: Node | null | undefined): node is PrivateName; +declare function isPrivateName>(node: Node | null | undefined, opts?: Opts | null): node is PrivateName & Opts; +declare function isStaticBlock(node: Node | null | undefined): node is StaticBlock; +declare function isStaticBlock>(node: Node | null | undefined, opts?: Opts | null): node is StaticBlock & Opts; +declare function isImportAttribute(node: Node | null | undefined): node is ImportAttribute; +declare function isImportAttribute>(node: Node | null | undefined, opts?: Opts | null): node is ImportAttribute & Opts; +declare function isAnyTypeAnnotation(node: Node | null | undefined): node is AnyTypeAnnotation; +declare function isAnyTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is AnyTypeAnnotation & Opts; +declare function isArrayTypeAnnotation(node: Node | null | undefined): node is ArrayTypeAnnotation; +declare function isArrayTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is ArrayTypeAnnotation & Opts; +declare function isBooleanTypeAnnotation(node: Node | null | undefined): node is BooleanTypeAnnotation; +declare function isBooleanTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is BooleanTypeAnnotation & Opts; +declare function isBooleanLiteralTypeAnnotation(node: Node | null | undefined): node is BooleanLiteralTypeAnnotation; +declare function isBooleanLiteralTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is BooleanLiteralTypeAnnotation & Opts; +declare function isNullLiteralTypeAnnotation(node: Node | null | undefined): node is NullLiteralTypeAnnotation; +declare function isNullLiteralTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is NullLiteralTypeAnnotation & Opts; +declare function isClassImplements(node: Node | null | undefined): node is ClassImplements; +declare function isClassImplements>(node: Node | null | undefined, opts?: Opts | null): node is ClassImplements & Opts; +declare function isDeclareClass(node: Node | null | undefined): node is DeclareClass; +declare function isDeclareClass>(node: Node | null | undefined, opts?: Opts | null): node is DeclareClass & Opts; +declare function isDeclareFunction(node: Node | null | undefined): node is DeclareFunction; +declare function isDeclareFunction>(node: Node | null | undefined, opts?: Opts | null): node is DeclareFunction & Opts; +declare function isDeclareInterface(node: Node | null | undefined): node is DeclareInterface; +declare function isDeclareInterface>(node: Node | null | undefined, opts?: Opts | null): node is DeclareInterface & Opts; +declare function isDeclareModule(node: Node | null | undefined): node is DeclareModule; +declare function isDeclareModule>(node: Node | null | undefined, opts?: Opts | null): node is DeclareModule & Opts; +declare function isDeclareModuleExports(node: Node | null | undefined): node is DeclareModuleExports; +declare function isDeclareModuleExports>(node: Node | null | undefined, opts?: Opts | null): node is DeclareModuleExports & Opts; +declare function isDeclareTypeAlias(node: Node | null | undefined): node is DeclareTypeAlias; +declare function isDeclareTypeAlias>(node: Node | null | undefined, opts?: Opts | null): node is DeclareTypeAlias & Opts; +declare function isDeclareOpaqueType(node: Node | null | undefined): node is DeclareOpaqueType; +declare function isDeclareOpaqueType>(node: Node | null | undefined, opts?: Opts | null): node is DeclareOpaqueType & Opts; +declare function isDeclareVariable(node: Node | null | undefined): node is DeclareVariable; +declare function isDeclareVariable>(node: Node | null | undefined, opts?: Opts | null): node is DeclareVariable & Opts; +declare function isDeclareExportDeclaration(node: Node | null | undefined): node is DeclareExportDeclaration; +declare function isDeclareExportDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is DeclareExportDeclaration & Opts; +declare function isDeclareExportAllDeclaration(node: Node | null | undefined): node is DeclareExportAllDeclaration; +declare function isDeclareExportAllDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is DeclareExportAllDeclaration & Opts; +declare function isDeclaredPredicate(node: Node | null | undefined): node is DeclaredPredicate; +declare function isDeclaredPredicate>(node: Node | null | undefined, opts?: Opts | null): node is DeclaredPredicate & Opts; +declare function isExistsTypeAnnotation(node: Node | null | undefined): node is ExistsTypeAnnotation; +declare function isExistsTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is ExistsTypeAnnotation & Opts; +declare function isFunctionTypeAnnotation(node: Node | null | undefined): node is FunctionTypeAnnotation; +declare function isFunctionTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is FunctionTypeAnnotation & Opts; +declare function isFunctionTypeParam(node: Node | null | undefined): node is FunctionTypeParam; +declare function isFunctionTypeParam>(node: Node | null | undefined, opts?: Opts | null): node is FunctionTypeParam & Opts; +declare function isGenericTypeAnnotation(node: Node | null | undefined): node is GenericTypeAnnotation; +declare function isGenericTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is GenericTypeAnnotation & Opts; +declare function isInferredPredicate(node: Node | null | undefined): node is InferredPredicate; +declare function isInferredPredicate>(node: Node | null | undefined, opts?: Opts | null): node is InferredPredicate & Opts; +declare function isInterfaceExtends(node: Node | null | undefined): node is InterfaceExtends; +declare function isInterfaceExtends>(node: Node | null | undefined, opts?: Opts | null): node is InterfaceExtends & Opts; +declare function isInterfaceDeclaration(node: Node | null | undefined): node is InterfaceDeclaration; +declare function isInterfaceDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is InterfaceDeclaration & Opts; +declare function isInterfaceTypeAnnotation(node: Node | null | undefined): node is InterfaceTypeAnnotation; +declare function isInterfaceTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is InterfaceTypeAnnotation & Opts; +declare function isIntersectionTypeAnnotation(node: Node | null | undefined): node is IntersectionTypeAnnotation; +declare function isIntersectionTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is IntersectionTypeAnnotation & Opts; +declare function isMixedTypeAnnotation(node: Node | null | undefined): node is MixedTypeAnnotation; +declare function isMixedTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is MixedTypeAnnotation & Opts; +declare function isEmptyTypeAnnotation(node: Node | null | undefined): node is EmptyTypeAnnotation; +declare function isEmptyTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is EmptyTypeAnnotation & Opts; +declare function isNullableTypeAnnotation(node: Node | null | undefined): node is NullableTypeAnnotation; +declare function isNullableTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is NullableTypeAnnotation & Opts; +declare function isNumberLiteralTypeAnnotation(node: Node | null | undefined): node is NumberLiteralTypeAnnotation; +declare function isNumberLiteralTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is NumberLiteralTypeAnnotation & Opts; +declare function isNumberTypeAnnotation(node: Node | null | undefined): node is NumberTypeAnnotation; +declare function isNumberTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is NumberTypeAnnotation & Opts; +declare function isObjectTypeAnnotation(node: Node | null | undefined): node is ObjectTypeAnnotation; +declare function isObjectTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is ObjectTypeAnnotation & Opts; +declare function isObjectTypeInternalSlot(node: Node | null | undefined): node is ObjectTypeInternalSlot; +declare function isObjectTypeInternalSlot>(node: Node | null | undefined, opts?: Opts | null): node is ObjectTypeInternalSlot & Opts; +declare function isObjectTypeCallProperty(node: Node | null | undefined): node is ObjectTypeCallProperty; +declare function isObjectTypeCallProperty>(node: Node | null | undefined, opts?: Opts | null): node is ObjectTypeCallProperty & Opts; +declare function isObjectTypeIndexer(node: Node | null | undefined): node is ObjectTypeIndexer; +declare function isObjectTypeIndexer>(node: Node | null | undefined, opts?: Opts | null): node is ObjectTypeIndexer & Opts; +declare function isObjectTypeProperty(node: Node | null | undefined): node is ObjectTypeProperty; +declare function isObjectTypeProperty>(node: Node | null | undefined, opts?: Opts | null): node is ObjectTypeProperty & Opts; +declare function isObjectTypeSpreadProperty(node: Node | null | undefined): node is ObjectTypeSpreadProperty; +declare function isObjectTypeSpreadProperty>(node: Node | null | undefined, opts?: Opts | null): node is ObjectTypeSpreadProperty & Opts; +declare function isOpaqueType(node: Node | null | undefined): node is OpaqueType; +declare function isOpaqueType>(node: Node | null | undefined, opts?: Opts | null): node is OpaqueType & Opts; +declare function isQualifiedTypeIdentifier(node: Node | null | undefined): node is QualifiedTypeIdentifier; +declare function isQualifiedTypeIdentifier>(node: Node | null | undefined, opts?: Opts | null): node is QualifiedTypeIdentifier & Opts; +declare function isStringLiteralTypeAnnotation(node: Node | null | undefined): node is StringLiteralTypeAnnotation; +declare function isStringLiteralTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is StringLiteralTypeAnnotation & Opts; +declare function isStringTypeAnnotation(node: Node | null | undefined): node is StringTypeAnnotation; +declare function isStringTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is StringTypeAnnotation & Opts; +declare function isSymbolTypeAnnotation(node: Node | null | undefined): node is SymbolTypeAnnotation; +declare function isSymbolTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is SymbolTypeAnnotation & Opts; +declare function isThisTypeAnnotation(node: Node | null | undefined): node is ThisTypeAnnotation; +declare function isThisTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is ThisTypeAnnotation & Opts; +declare function isTupleTypeAnnotation(node: Node | null | undefined): node is TupleTypeAnnotation; +declare function isTupleTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is TupleTypeAnnotation & Opts; +declare function isTypeofTypeAnnotation(node: Node | null | undefined): node is TypeofTypeAnnotation; +declare function isTypeofTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is TypeofTypeAnnotation & Opts; +declare function isTypeAlias(node: Node | null | undefined): node is TypeAlias; +declare function isTypeAlias>(node: Node | null | undefined, opts?: Opts | null): node is TypeAlias & Opts; +declare function isTypeAnnotation(node: Node | null | undefined): node is TypeAnnotation; +declare function isTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is TypeAnnotation & Opts; +declare function isTypeCastExpression(node: Node | null | undefined): node is TypeCastExpression; +declare function isTypeCastExpression>(node: Node | null | undefined, opts?: Opts | null): node is TypeCastExpression & Opts; +declare function isTypeParameter(node: Node | null | undefined): node is TypeParameter; +declare function isTypeParameter>(node: Node | null | undefined, opts?: Opts | null): node is TypeParameter & Opts; +declare function isTypeParameterDeclaration(node: Node | null | undefined): node is TypeParameterDeclaration; +declare function isTypeParameterDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is TypeParameterDeclaration & Opts; +declare function isTypeParameterInstantiation(node: Node | null | undefined): node is TypeParameterInstantiation; +declare function isTypeParameterInstantiation>(node: Node | null | undefined, opts?: Opts | null): node is TypeParameterInstantiation & Opts; +declare function isUnionTypeAnnotation(node: Node | null | undefined): node is UnionTypeAnnotation; +declare function isUnionTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is UnionTypeAnnotation & Opts; +declare function isVariance(node: Node | null | undefined): node is Variance; +declare function isVariance>(node: Node | null | undefined, opts?: Opts | null): node is Variance & Opts; +declare function isVoidTypeAnnotation(node: Node | null | undefined): node is VoidTypeAnnotation; +declare function isVoidTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is VoidTypeAnnotation & Opts; +declare function isEnumDeclaration(node: Node | null | undefined): node is EnumDeclaration; +declare function isEnumDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is EnumDeclaration & Opts; +declare function isEnumBooleanBody(node: Node | null | undefined): node is EnumBooleanBody; +declare function isEnumBooleanBody>(node: Node | null | undefined, opts?: Opts | null): node is EnumBooleanBody & Opts; +declare function isEnumNumberBody(node: Node | null | undefined): node is EnumNumberBody; +declare function isEnumNumberBody>(node: Node | null | undefined, opts?: Opts | null): node is EnumNumberBody & Opts; +declare function isEnumStringBody(node: Node | null | undefined): node is EnumStringBody; +declare function isEnumStringBody>(node: Node | null | undefined, opts?: Opts | null): node is EnumStringBody & Opts; +declare function isEnumSymbolBody(node: Node | null | undefined): node is EnumSymbolBody; +declare function isEnumSymbolBody>(node: Node | null | undefined, opts?: Opts | null): node is EnumSymbolBody & Opts; +declare function isEnumBooleanMember(node: Node | null | undefined): node is EnumBooleanMember; +declare function isEnumBooleanMember>(node: Node | null | undefined, opts?: Opts | null): node is EnumBooleanMember & Opts; +declare function isEnumNumberMember(node: Node | null | undefined): node is EnumNumberMember; +declare function isEnumNumberMember>(node: Node | null | undefined, opts?: Opts | null): node is EnumNumberMember & Opts; +declare function isEnumStringMember(node: Node | null | undefined): node is EnumStringMember; +declare function isEnumStringMember>(node: Node | null | undefined, opts?: Opts | null): node is EnumStringMember & Opts; +declare function isEnumDefaultedMember(node: Node | null | undefined): node is EnumDefaultedMember; +declare function isEnumDefaultedMember>(node: Node | null | undefined, opts?: Opts | null): node is EnumDefaultedMember & Opts; +declare function isIndexedAccessType(node: Node | null | undefined): node is IndexedAccessType; +declare function isIndexedAccessType>(node: Node | null | undefined, opts?: Opts | null): node is IndexedAccessType & Opts; +declare function isOptionalIndexedAccessType(node: Node | null | undefined): node is OptionalIndexedAccessType; +declare function isOptionalIndexedAccessType>(node: Node | null | undefined, opts?: Opts | null): node is OptionalIndexedAccessType & Opts; +declare function isJSXAttribute(node: Node | null | undefined): node is JSXAttribute; +declare function isJSXAttribute>(node: Node | null | undefined, opts?: Opts | null): node is JSXAttribute & Opts; +declare function isJSXClosingElement(node: Node | null | undefined): node is JSXClosingElement; +declare function isJSXClosingElement>(node: Node | null | undefined, opts?: Opts | null): node is JSXClosingElement & Opts; +declare function isJSXElement(node: Node | null | undefined): node is JSXElement; +declare function isJSXElement>(node: Node | null | undefined, opts?: Opts | null): node is JSXElement & Opts; +declare function isJSXEmptyExpression(node: Node | null | undefined): node is JSXEmptyExpression; +declare function isJSXEmptyExpression>(node: Node | null | undefined, opts?: Opts | null): node is JSXEmptyExpression & Opts; +declare function isJSXExpressionContainer(node: Node | null | undefined): node is JSXExpressionContainer; +declare function isJSXExpressionContainer>(node: Node | null | undefined, opts?: Opts | null): node is JSXExpressionContainer & Opts; +declare function isJSXSpreadChild(node: Node | null | undefined): node is JSXSpreadChild; +declare function isJSXSpreadChild>(node: Node | null | undefined, opts?: Opts | null): node is JSXSpreadChild & Opts; +declare function isJSXIdentifier(node: Node | null | undefined): node is JSXIdentifier; +declare function isJSXIdentifier>(node: Node | null | undefined, opts?: Opts | null): node is JSXIdentifier & Opts; +declare function isJSXMemberExpression(node: Node | null | undefined): node is JSXMemberExpression; +declare function isJSXMemberExpression>(node: Node | null | undefined, opts?: Opts | null): node is JSXMemberExpression & Opts; +declare function isJSXNamespacedName(node: Node | null | undefined): node is JSXNamespacedName; +declare function isJSXNamespacedName>(node: Node | null | undefined, opts?: Opts | null): node is JSXNamespacedName & Opts; +declare function isJSXOpeningElement(node: Node | null | undefined): node is JSXOpeningElement; +declare function isJSXOpeningElement>(node: Node | null | undefined, opts?: Opts | null): node is JSXOpeningElement & Opts; +declare function isJSXSpreadAttribute(node: Node | null | undefined): node is JSXSpreadAttribute; +declare function isJSXSpreadAttribute>(node: Node | null | undefined, opts?: Opts | null): node is JSXSpreadAttribute & Opts; +declare function isJSXText(node: Node | null | undefined): node is JSXText; +declare function isJSXText>(node: Node | null | undefined, opts?: Opts | null): node is JSXText & Opts; +declare function isJSXFragment(node: Node | null | undefined): node is JSXFragment; +declare function isJSXFragment>(node: Node | null | undefined, opts?: Opts | null): node is JSXFragment & Opts; +declare function isJSXOpeningFragment(node: Node | null | undefined): node is JSXOpeningFragment; +declare function isJSXOpeningFragment>(node: Node | null | undefined, opts?: Opts | null): node is JSXOpeningFragment & Opts; +declare function isJSXClosingFragment(node: Node | null | undefined): node is JSXClosingFragment; +declare function isJSXClosingFragment>(node: Node | null | undefined, opts?: Opts | null): node is JSXClosingFragment & Opts; +declare function isNoop(node: Node | null | undefined): node is Noop; +declare function isNoop>(node: Node | null | undefined, opts?: Opts | null): node is Noop & Opts; +declare function isPlaceholder(node: Node | null | undefined): node is Placeholder; +declare function isPlaceholder>(node: Node | null | undefined, opts?: Opts | null): node is Placeholder & Opts; +declare function isV8IntrinsicIdentifier(node: Node | null | undefined): node is V8IntrinsicIdentifier; +declare function isV8IntrinsicIdentifier>(node: Node | null | undefined, opts?: Opts | null): node is V8IntrinsicIdentifier & Opts; +declare function isArgumentPlaceholder(node: Node | null | undefined): node is ArgumentPlaceholder; +declare function isArgumentPlaceholder>(node: Node | null | undefined, opts?: Opts | null): node is ArgumentPlaceholder & Opts; +declare function isBindExpression(node: Node | null | undefined): node is BindExpression; +declare function isBindExpression>(node: Node | null | undefined, opts?: Opts | null): node is BindExpression & Opts; +declare function isDecorator(node: Node | null | undefined): node is Decorator; +declare function isDecorator>(node: Node | null | undefined, opts?: Opts | null): node is Decorator & Opts; +declare function isDoExpression(node: Node | null | undefined): node is DoExpression; +declare function isDoExpression>(node: Node | null | undefined, opts?: Opts | null): node is DoExpression & Opts; +declare function isExportDefaultSpecifier(node: Node | null | undefined): node is ExportDefaultSpecifier; +declare function isExportDefaultSpecifier>(node: Node | null | undefined, opts?: Opts | null): node is ExportDefaultSpecifier & Opts; +declare function isRecordExpression(node: Node | null | undefined): node is RecordExpression; +declare function isRecordExpression>(node: Node | null | undefined, opts?: Opts | null): node is RecordExpression & Opts; +declare function isTupleExpression(node: Node | null | undefined): node is TupleExpression; +declare function isTupleExpression>(node: Node | null | undefined, opts?: Opts | null): node is TupleExpression & Opts; +declare function isDecimalLiteral(node: Node | null | undefined): node is DecimalLiteral; +declare function isDecimalLiteral>(node: Node | null | undefined, opts?: Opts | null): node is DecimalLiteral & Opts; +declare function isModuleExpression(node: Node | null | undefined): node is ModuleExpression; +declare function isModuleExpression>(node: Node | null | undefined, opts?: Opts | null): node is ModuleExpression & Opts; +declare function isTopicReference(node: Node | null | undefined): node is TopicReference; +declare function isTopicReference>(node: Node | null | undefined, opts?: Opts | null): node is TopicReference & Opts; +declare function isPipelineTopicExpression(node: Node | null | undefined): node is PipelineTopicExpression; +declare function isPipelineTopicExpression>(node: Node | null | undefined, opts?: Opts | null): node is PipelineTopicExpression & Opts; +declare function isPipelineBareFunction(node: Node | null | undefined): node is PipelineBareFunction; +declare function isPipelineBareFunction>(node: Node | null | undefined, opts?: Opts | null): node is PipelineBareFunction & Opts; +declare function isPipelinePrimaryTopicReference(node: Node | null | undefined): node is PipelinePrimaryTopicReference; +declare function isPipelinePrimaryTopicReference>(node: Node | null | undefined, opts?: Opts | null): node is PipelinePrimaryTopicReference & Opts; +declare function isVoidPattern(node: Node | null | undefined): node is VoidPattern; +declare function isVoidPattern>(node: Node | null | undefined, opts?: Opts | null): node is VoidPattern & Opts; +declare function isTSParameterProperty(node: Node | null | undefined): node is TSParameterProperty; +declare function isTSParameterProperty>(node: Node | null | undefined, opts?: Opts | null): node is TSParameterProperty & Opts; +declare function isTSDeclareFunction(node: Node | null | undefined): node is TSDeclareFunction; +declare function isTSDeclareFunction>(node: Node | null | undefined, opts?: Opts | null): node is TSDeclareFunction & Opts; +declare function isTSDeclareMethod(node: Node | null | undefined): node is TSDeclareMethod; +declare function isTSDeclareMethod>(node: Node | null | undefined, opts?: Opts | null): node is TSDeclareMethod & Opts; +declare function isTSQualifiedName(node: Node | null | undefined): node is TSQualifiedName; +declare function isTSQualifiedName>(node: Node | null | undefined, opts?: Opts | null): node is TSQualifiedName & Opts; +declare function isTSCallSignatureDeclaration(node: Node | null | undefined): node is TSCallSignatureDeclaration; +declare function isTSCallSignatureDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is TSCallSignatureDeclaration & Opts; +declare function isTSConstructSignatureDeclaration(node: Node | null | undefined): node is TSConstructSignatureDeclaration; +declare function isTSConstructSignatureDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is TSConstructSignatureDeclaration & Opts; +declare function isTSPropertySignature(node: Node | null | undefined): node is TSPropertySignature; +declare function isTSPropertySignature>(node: Node | null | undefined, opts?: Opts | null): node is TSPropertySignature & Opts; +declare function isTSMethodSignature(node: Node | null | undefined): node is TSMethodSignature; +declare function isTSMethodSignature>(node: Node | null | undefined, opts?: Opts | null): node is TSMethodSignature & Opts; +declare function isTSIndexSignature(node: Node | null | undefined): node is TSIndexSignature; +declare function isTSIndexSignature>(node: Node | null | undefined, opts?: Opts | null): node is TSIndexSignature & Opts; +declare function isTSAnyKeyword(node: Node | null | undefined): node is TSAnyKeyword; +declare function isTSAnyKeyword>(node: Node | null | undefined, opts?: Opts | null): node is TSAnyKeyword & Opts; +declare function isTSBooleanKeyword(node: Node | null | undefined): node is TSBooleanKeyword; +declare function isTSBooleanKeyword>(node: Node | null | undefined, opts?: Opts | null): node is TSBooleanKeyword & Opts; +declare function isTSBigIntKeyword(node: Node | null | undefined): node is TSBigIntKeyword; +declare function isTSBigIntKeyword>(node: Node | null | undefined, opts?: Opts | null): node is TSBigIntKeyword & Opts; +declare function isTSIntrinsicKeyword(node: Node | null | undefined): node is TSIntrinsicKeyword; +declare function isTSIntrinsicKeyword>(node: Node | null | undefined, opts?: Opts | null): node is TSIntrinsicKeyword & Opts; +declare function isTSNeverKeyword(node: Node | null | undefined): node is TSNeverKeyword; +declare function isTSNeverKeyword>(node: Node | null | undefined, opts?: Opts | null): node is TSNeverKeyword & Opts; +declare function isTSNullKeyword(node: Node | null | undefined): node is TSNullKeyword; +declare function isTSNullKeyword>(node: Node | null | undefined, opts?: Opts | null): node is TSNullKeyword & Opts; +declare function isTSNumberKeyword(node: Node | null | undefined): node is TSNumberKeyword; +declare function isTSNumberKeyword>(node: Node | null | undefined, opts?: Opts | null): node is TSNumberKeyword & Opts; +declare function isTSObjectKeyword(node: Node | null | undefined): node is TSObjectKeyword; +declare function isTSObjectKeyword>(node: Node | null | undefined, opts?: Opts | null): node is TSObjectKeyword & Opts; +declare function isTSStringKeyword(node: Node | null | undefined): node is TSStringKeyword; +declare function isTSStringKeyword>(node: Node | null | undefined, opts?: Opts | null): node is TSStringKeyword & Opts; +declare function isTSSymbolKeyword(node: Node | null | undefined): node is TSSymbolKeyword; +declare function isTSSymbolKeyword>(node: Node | null | undefined, opts?: Opts | null): node is TSSymbolKeyword & Opts; +declare function isTSUndefinedKeyword(node: Node | null | undefined): node is TSUndefinedKeyword; +declare function isTSUndefinedKeyword>(node: Node | null | undefined, opts?: Opts | null): node is TSUndefinedKeyword & Opts; +declare function isTSUnknownKeyword(node: Node | null | undefined): node is TSUnknownKeyword; +declare function isTSUnknownKeyword>(node: Node | null | undefined, opts?: Opts | null): node is TSUnknownKeyword & Opts; +declare function isTSVoidKeyword(node: Node | null | undefined): node is TSVoidKeyword; +declare function isTSVoidKeyword>(node: Node | null | undefined, opts?: Opts | null): node is TSVoidKeyword & Opts; +declare function isTSThisType(node: Node | null | undefined): node is TSThisType; +declare function isTSThisType>(node: Node | null | undefined, opts?: Opts | null): node is TSThisType & Opts; +declare function isTSFunctionType(node: Node | null | undefined): node is TSFunctionType; +declare function isTSFunctionType>(node: Node | null | undefined, opts?: Opts | null): node is TSFunctionType & Opts; +declare function isTSConstructorType(node: Node | null | undefined): node is TSConstructorType; +declare function isTSConstructorType>(node: Node | null | undefined, opts?: Opts | null): node is TSConstructorType & Opts; +declare function isTSTypeReference(node: Node | null | undefined): node is TSTypeReference; +declare function isTSTypeReference>(node: Node | null | undefined, opts?: Opts | null): node is TSTypeReference & Opts; +declare function isTSTypePredicate(node: Node | null | undefined): node is TSTypePredicate; +declare function isTSTypePredicate>(node: Node | null | undefined, opts?: Opts | null): node is TSTypePredicate & Opts; +declare function isTSTypeQuery(node: Node | null | undefined): node is TSTypeQuery; +declare function isTSTypeQuery>(node: Node | null | undefined, opts?: Opts | null): node is TSTypeQuery & Opts; +declare function isTSTypeLiteral(node: Node | null | undefined): node is TSTypeLiteral; +declare function isTSTypeLiteral>(node: Node | null | undefined, opts?: Opts | null): node is TSTypeLiteral & Opts; +declare function isTSArrayType(node: Node | null | undefined): node is TSArrayType; +declare function isTSArrayType>(node: Node | null | undefined, opts?: Opts | null): node is TSArrayType & Opts; +declare function isTSTupleType(node: Node | null | undefined): node is TSTupleType; +declare function isTSTupleType>(node: Node | null | undefined, opts?: Opts | null): node is TSTupleType & Opts; +declare function isTSOptionalType(node: Node | null | undefined): node is TSOptionalType; +declare function isTSOptionalType>(node: Node | null | undefined, opts?: Opts | null): node is TSOptionalType & Opts; +declare function isTSRestType(node: Node | null | undefined): node is TSRestType; +declare function isTSRestType>(node: Node | null | undefined, opts?: Opts | null): node is TSRestType & Opts; +declare function isTSNamedTupleMember(node: Node | null | undefined): node is TSNamedTupleMember; +declare function isTSNamedTupleMember>(node: Node | null | undefined, opts?: Opts | null): node is TSNamedTupleMember & Opts; +declare function isTSUnionType(node: Node | null | undefined): node is TSUnionType; +declare function isTSUnionType>(node: Node | null | undefined, opts?: Opts | null): node is TSUnionType & Opts; +declare function isTSIntersectionType(node: Node | null | undefined): node is TSIntersectionType; +declare function isTSIntersectionType>(node: Node | null | undefined, opts?: Opts | null): node is TSIntersectionType & Opts; +declare function isTSConditionalType(node: Node | null | undefined): node is TSConditionalType; +declare function isTSConditionalType>(node: Node | null | undefined, opts?: Opts | null): node is TSConditionalType & Opts; +declare function isTSInferType(node: Node | null | undefined): node is TSInferType; +declare function isTSInferType>(node: Node | null | undefined, opts?: Opts | null): node is TSInferType & Opts; +declare function isTSParenthesizedType(node: Node | null | undefined): node is TSParenthesizedType; +declare function isTSParenthesizedType>(node: Node | null | undefined, opts?: Opts | null): node is TSParenthesizedType & Opts; +declare function isTSTypeOperator(node: Node | null | undefined): node is TSTypeOperator; +declare function isTSTypeOperator>(node: Node | null | undefined, opts?: Opts | null): node is TSTypeOperator & Opts; +declare function isTSIndexedAccessType(node: Node | null | undefined): node is TSIndexedAccessType; +declare function isTSIndexedAccessType>(node: Node | null | undefined, opts?: Opts | null): node is TSIndexedAccessType & Opts; +declare function isTSMappedType(node: Node | null | undefined): node is TSMappedType; +declare function isTSMappedType>(node: Node | null | undefined, opts?: Opts | null): node is TSMappedType & Opts; +declare function isTSTemplateLiteralType(node: Node | null | undefined): node is TSTemplateLiteralType; +declare function isTSTemplateLiteralType>(node: Node | null | undefined, opts?: Opts | null): node is TSTemplateLiteralType & Opts; +declare function isTSLiteralType(node: Node | null | undefined): node is TSLiteralType; +declare function isTSLiteralType>(node: Node | null | undefined, opts?: Opts | null): node is TSLiteralType & Opts; +declare function isTSExpressionWithTypeArguments(node: Node | null | undefined): node is TSExpressionWithTypeArguments; +declare function isTSExpressionWithTypeArguments>(node: Node | null | undefined, opts?: Opts | null): node is TSExpressionWithTypeArguments & Opts; +declare function isTSInterfaceDeclaration(node: Node | null | undefined): node is TSInterfaceDeclaration; +declare function isTSInterfaceDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is TSInterfaceDeclaration & Opts; +declare function isTSInterfaceBody(node: Node | null | undefined): node is TSInterfaceBody; +declare function isTSInterfaceBody>(node: Node | null | undefined, opts?: Opts | null): node is TSInterfaceBody & Opts; +declare function isTSTypeAliasDeclaration(node: Node | null | undefined): node is TSTypeAliasDeclaration; +declare function isTSTypeAliasDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is TSTypeAliasDeclaration & Opts; +declare function isTSInstantiationExpression(node: Node | null | undefined): node is TSInstantiationExpression; +declare function isTSInstantiationExpression>(node: Node | null | undefined, opts?: Opts | null): node is TSInstantiationExpression & Opts; +declare function isTSAsExpression(node: Node | null | undefined): node is TSAsExpression; +declare function isTSAsExpression>(node: Node | null | undefined, opts?: Opts | null): node is TSAsExpression & Opts; +declare function isTSSatisfiesExpression(node: Node | null | undefined): node is TSSatisfiesExpression; +declare function isTSSatisfiesExpression>(node: Node | null | undefined, opts?: Opts | null): node is TSSatisfiesExpression & Opts; +declare function isTSTypeAssertion(node: Node | null | undefined): node is TSTypeAssertion; +declare function isTSTypeAssertion>(node: Node | null | undefined, opts?: Opts | null): node is TSTypeAssertion & Opts; +declare function isTSEnumBody(node: Node | null | undefined): node is TSEnumBody; +declare function isTSEnumBody>(node: Node | null | undefined, opts?: Opts | null): node is TSEnumBody & Opts; +declare function isTSEnumDeclaration(node: Node | null | undefined): node is TSEnumDeclaration; +declare function isTSEnumDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is TSEnumDeclaration & Opts; +declare function isTSEnumMember(node: Node | null | undefined): node is TSEnumMember; +declare function isTSEnumMember>(node: Node | null | undefined, opts?: Opts | null): node is TSEnumMember & Opts; +declare function isTSModuleDeclaration(node: Node | null | undefined): node is TSModuleDeclaration; +declare function isTSModuleDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is TSModuleDeclaration & Opts; +declare function isTSModuleBlock(node: Node | null | undefined): node is TSModuleBlock; +declare function isTSModuleBlock>(node: Node | null | undefined, opts?: Opts | null): node is TSModuleBlock & Opts; +declare function isTSImportType(node: Node | null | undefined): node is TSImportType; +declare function isTSImportType>(node: Node | null | undefined, opts?: Opts | null): node is TSImportType & Opts; +declare function isTSImportEqualsDeclaration(node: Node | null | undefined): node is TSImportEqualsDeclaration; +declare function isTSImportEqualsDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is TSImportEqualsDeclaration & Opts; +declare function isTSExternalModuleReference(node: Node | null | undefined): node is TSExternalModuleReference; +declare function isTSExternalModuleReference>(node: Node | null | undefined, opts?: Opts | null): node is TSExternalModuleReference & Opts; +declare function isTSNonNullExpression(node: Node | null | undefined): node is TSNonNullExpression; +declare function isTSNonNullExpression>(node: Node | null | undefined, opts?: Opts | null): node is TSNonNullExpression & Opts; +declare function isTSExportAssignment(node: Node | null | undefined): node is TSExportAssignment; +declare function isTSExportAssignment>(node: Node | null | undefined, opts?: Opts | null): node is TSExportAssignment & Opts; +declare function isTSNamespaceExportDeclaration(node: Node | null | undefined): node is TSNamespaceExportDeclaration; +declare function isTSNamespaceExportDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is TSNamespaceExportDeclaration & Opts; +declare function isTSTypeAnnotation(node: Node | null | undefined): node is TSTypeAnnotation; +declare function isTSTypeAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is TSTypeAnnotation & Opts; +declare function isTSTypeParameterInstantiation(node: Node | null | undefined): node is TSTypeParameterInstantiation; +declare function isTSTypeParameterInstantiation>(node: Node | null | undefined, opts?: Opts | null): node is TSTypeParameterInstantiation & Opts; +declare function isTSTypeParameterDeclaration(node: Node | null | undefined): node is TSTypeParameterDeclaration; +declare function isTSTypeParameterDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is TSTypeParameterDeclaration & Opts; +declare function isTSTypeParameter(node: Node | null | undefined): node is TSTypeParameter; +declare function isTSTypeParameter>(node: Node | null | undefined, opts?: Opts | null): node is TSTypeParameter & Opts; +declare function isStandardized(node: Node | null | undefined): node is Standardized; +declare function isStandardized>(node: Node | null | undefined, opts?: Opts | null): node is Standardized & Opts; +declare function isExpression(node: Node | null | undefined): node is Expression; +declare function isExpression>(node: Node | null | undefined, opts?: Opts | null): node is Expression & Opts; +declare function isBinary(node: Node | null | undefined): node is Binary; +declare function isBinary>(node: Node | null | undefined, opts?: Opts | null): node is Binary & Opts; +declare function isScopable(node: Node | null | undefined): node is Scopable; +declare function isScopable>(node: Node | null | undefined, opts?: Opts | null): node is Scopable & Opts; +declare function isBlockParent(node: Node | null | undefined): node is BlockParent; +declare function isBlockParent>(node: Node | null | undefined, opts?: Opts | null): node is BlockParent & Opts; +declare function isBlock(node: Node | null | undefined): node is Block; +declare function isBlock>(node: Node | null | undefined, opts?: Opts | null): node is Block & Opts; +declare function isStatement(node: Node | null | undefined): node is Statement; +declare function isStatement>(node: Node | null | undefined, opts?: Opts | null): node is Statement & Opts; +declare function isTerminatorless(node: Node | null | undefined): node is Terminatorless; +declare function isTerminatorless>(node: Node | null | undefined, opts?: Opts | null): node is Terminatorless & Opts; +declare function isCompletionStatement(node: Node | null | undefined): node is CompletionStatement; +declare function isCompletionStatement>(node: Node | null | undefined, opts?: Opts | null): node is CompletionStatement & Opts; +declare function isConditional(node: Node | null | undefined): node is Conditional; +declare function isConditional>(node: Node | null | undefined, opts?: Opts | null): node is Conditional & Opts; +declare function isLoop(node: Node | null | undefined): node is Loop; +declare function isLoop>(node: Node | null | undefined, opts?: Opts | null): node is Loop & Opts; +declare function isWhile(node: Node | null | undefined): node is While; +declare function isWhile>(node: Node | null | undefined, opts?: Opts | null): node is While & Opts; +declare function isExpressionWrapper(node: Node | null | undefined): node is ExpressionWrapper; +declare function isExpressionWrapper>(node: Node | null | undefined, opts?: Opts | null): node is ExpressionWrapper & Opts; +declare function isFor(node: Node | null | undefined): node is For; +declare function isFor>(node: Node | null | undefined, opts?: Opts | null): node is For & Opts; +declare function isForXStatement(node: Node | null | undefined): node is ForXStatement; +declare function isForXStatement>(node: Node | null | undefined, opts?: Opts | null): node is ForXStatement & Opts; +declare function isFunction(node: Node | null | undefined): node is Function; +declare function isFunction>(node: Node | null | undefined, opts?: Opts | null): node is Function & Opts; +declare function isFunctionParent(node: Node | null | undefined): node is FunctionParent; +declare function isFunctionParent>(node: Node | null | undefined, opts?: Opts | null): node is FunctionParent & Opts; +declare function isPureish(node: Node | null | undefined): node is Pureish; +declare function isPureish>(node: Node | null | undefined, opts?: Opts | null): node is Pureish & Opts; +declare function isDeclaration(node: Node | null | undefined): node is Declaration; +declare function isDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is Declaration & Opts; +declare function isFunctionParameter(node: Node | null | undefined): node is FunctionParameter; +declare function isFunctionParameter>(node: Node | null | undefined, opts?: Opts | null): node is FunctionParameter & Opts; +declare function isPatternLike(node: Node | null | undefined): node is PatternLike; +declare function isPatternLike>(node: Node | null | undefined, opts?: Opts | null): node is PatternLike & Opts; +declare function isLVal(node: Node | null | undefined): node is LVal; +declare function isLVal>(node: Node | null | undefined, opts?: Opts | null): node is LVal & Opts; +declare function isTSEntityName(node: Node | null | undefined): node is TSEntityName; +declare function isTSEntityName>(node: Node | null | undefined, opts?: Opts | null): node is TSEntityName & Opts; +declare function isLiteral(node: Node | null | undefined): node is Literal; +declare function isLiteral>(node: Node | null | undefined, opts?: Opts | null): node is Literal & Opts; +declare function isUserWhitespacable(node: Node | null | undefined): node is UserWhitespacable; +declare function isUserWhitespacable>(node: Node | null | undefined, opts?: Opts | null): node is UserWhitespacable & Opts; +declare function isMethod(node: Node | null | undefined): node is Method; +declare function isMethod>(node: Node | null | undefined, opts?: Opts | null): node is Method & Opts; +declare function isObjectMember(node: Node | null | undefined): node is ObjectMember; +declare function isObjectMember>(node: Node | null | undefined, opts?: Opts | null): node is ObjectMember & Opts; +declare function isProperty(node: Node | null | undefined): node is Property; +declare function isProperty>(node: Node | null | undefined, opts?: Opts | null): node is Property & Opts; +declare function isUnaryLike(node: Node | null | undefined): node is UnaryLike; +declare function isUnaryLike>(node: Node | null | undefined, opts?: Opts | null): node is UnaryLike & Opts; +declare function isPattern(node: Node | null | undefined): node is Pattern; +declare function isPattern>(node: Node | null | undefined, opts?: Opts | null): node is Pattern & Opts; +declare function isClass(node: Node | null | undefined): node is Class; +declare function isClass>(node: Node | null | undefined, opts?: Opts | null): node is Class & Opts; +declare function isImportOrExportDeclaration(node: Node | null | undefined): node is ImportOrExportDeclaration; +declare function isImportOrExportDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is ImportOrExportDeclaration & Opts; +declare function isExportDeclaration(node: Node | null | undefined): node is ExportDeclaration; +declare function isExportDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is ExportDeclaration & Opts; +declare function isModuleSpecifier(node: Node | null | undefined): node is ModuleSpecifier; +declare function isModuleSpecifier>(node: Node | null | undefined, opts?: Opts | null): node is ModuleSpecifier & Opts; +declare function isAccessor(node: Node | null | undefined): node is Accessor; +declare function isAccessor>(node: Node | null | undefined, opts?: Opts | null): node is Accessor & Opts; +declare function isPrivate(node: Node | null | undefined): node is Private; +declare function isPrivate>(node: Node | null | undefined, opts?: Opts | null): node is Private & Opts; +declare function isFlow(node: Node | null | undefined): node is Flow; +declare function isFlow>(node: Node | null | undefined, opts?: Opts | null): node is Flow & Opts; +declare function isFlowType(node: Node | null | undefined): node is FlowType; +declare function isFlowType>(node: Node | null | undefined, opts?: Opts | null): node is FlowType & Opts; +declare function isFlowBaseAnnotation(node: Node | null | undefined): node is FlowBaseAnnotation; +declare function isFlowBaseAnnotation>(node: Node | null | undefined, opts?: Opts | null): node is FlowBaseAnnotation & Opts; +declare function isFlowDeclaration(node: Node | null | undefined): node is FlowDeclaration; +declare function isFlowDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is FlowDeclaration & Opts; +declare function isFlowPredicate(node: Node | null | undefined): node is FlowPredicate; +declare function isFlowPredicate>(node: Node | null | undefined, opts?: Opts | null): node is FlowPredicate & Opts; +declare function isEnumBody(node: Node | null | undefined): node is EnumBody; +declare function isEnumBody>(node: Node | null | undefined, opts?: Opts | null): node is EnumBody & Opts; +declare function isEnumMember(node: Node | null | undefined): node is EnumMember; +declare function isEnumMember>(node: Node | null | undefined, opts?: Opts | null): node is EnumMember & Opts; +declare function isJSX(node: Node | null | undefined): node is JSX; +declare function isJSX>(node: Node | null | undefined, opts?: Opts | null): node is JSX & Opts; +declare function isMiscellaneous(node: Node | null | undefined): node is Miscellaneous; +declare function isMiscellaneous>(node: Node | null | undefined, opts?: Opts | null): node is Miscellaneous & Opts; +declare function isTypeScript(node: Node | null | undefined): node is TypeScript; +declare function isTypeScript>(node: Node | null | undefined, opts?: Opts | null): node is TypeScript & Opts; +declare function isTSTypeElement(node: Node | null | undefined): node is TSTypeElement; +declare function isTSTypeElement>(node: Node | null | undefined, opts?: Opts | null): node is TSTypeElement & Opts; +declare function isTSType(node: Node | null | undefined): node is TSType; +declare function isTSType>(node: Node | null | undefined, opts?: Opts | null): node is TSType & Opts; +declare function isTSBaseType(node: Node | null | undefined): node is TSBaseType; +declare function isTSBaseType>(node: Node | null | undefined, opts?: Opts | null): node is TSBaseType & Opts; +/** + * @deprecated Use `isNumericLiteral` + */ +declare function isNumberLiteral(node: Node | null | undefined): boolean; +declare function isNumberLiteral>(node: Node | null | undefined, opts?: Opts | null): boolean; +/** + * @deprecated Use `isRegExpLiteral` + */ +declare function isRegexLiteral(node: Node | null | undefined): boolean; +declare function isRegexLiteral>(node: Node | null | undefined, opts?: Opts | null): boolean; +/** + * @deprecated Use `isRestElement` + */ +declare function isRestProperty(node: Node | null | undefined): boolean; +declare function isRestProperty>(node: Node | null | undefined, opts?: Opts | null): boolean; +/** + * @deprecated Use `isSpreadElement` + */ +declare function isSpreadProperty(node: Node | null | undefined): boolean; +declare function isSpreadProperty>(node: Node | null | undefined, opts?: Opts | null): boolean; +/** + * @deprecated Use `isImportOrExportDeclaration` + */ +declare function isModuleDeclaration>(node: Node | null | undefined, opts?: Opts | null): node is ImportOrExportDeclaration & Opts; + +declare function deprecationWarning(oldName: string, newName: string, prefix?: string, cacheKey?: string): void; + +declare const react: { + isReactComponent: (member: Node) => boolean; + isCompatTag: typeof isCompatTag; + buildChildren: typeof buildChildren; +}; + +export { ACCESSOR_TYPES, ALIAS_KEYS, ASSIGNMENT_OPERATORS, Accessor, Aliases, AnyTypeAnnotation, ArgumentPlaceholder, ArrayExpression, ArrayPattern, ArrayTypeAnnotation, ArrowFunctionExpression, AssignmentExpression, AssignmentPattern, AwaitExpression, BINARY_OPERATORS, BINARY_TYPES, BLOCKPARENT_TYPES, BLOCK_TYPES, BOOLEAN_BINARY_OPERATORS, BOOLEAN_NUMBER_BINARY_OPERATORS, BOOLEAN_UNARY_OPERATORS, BUILDER_KEYS, BigIntLiteral, Binary, BinaryExpression, BindExpression, Block, BlockParent, BlockStatement, BooleanLiteral, BooleanLiteralTypeAnnotation, BooleanTypeAnnotation, BreakStatement, CLASS_TYPES, COMMENT_KEYS, COMPARISON_BINARY_OPERATORS, COMPLETIONSTATEMENT_TYPES, CONDITIONAL_TYPES, CallExpression, CatchClause, Class, ClassAccessorProperty, ClassBody, ClassDeclaration, ClassExpression, ClassImplements, ClassMethod, ClassPrivateMethod, ClassPrivateProperty, ClassProperty, Comment, CommentBlock, CommentLine, CommentTypeShorthand, CompletionStatement, Conditional, ConditionalExpression, ContinueStatement, DECLARATION_TYPES, DEPRECATED_ALIASES, DEPRECATED_KEYS, DebuggerStatement, DecimalLiteral, Declaration, DeclareClass, DeclareExportAllDeclaration, DeclareExportDeclaration, DeclareFunction, DeclareInterface, DeclareModule, DeclareModuleExports, DeclareOpaqueType, DeclareTypeAlias, DeclareVariable, DeclaredPredicate, Decorator, DeprecatedAliases, Directive, DirectiveLiteral, DoExpression, DoWhileStatement, ENUMBODY_TYPES, ENUMMEMBER_TYPES, EQUALITY_BINARY_OPERATORS, EXPORTDECLARATION_TYPES, EXPRESSIONWRAPPER_TYPES, EXPRESSION_TYPES, EmptyStatement, EmptyTypeAnnotation, EnumBody, EnumBooleanBody, EnumBooleanMember, EnumDeclaration, EnumDefaultedMember, EnumMember, EnumNumberBody, EnumNumberMember, EnumStringBody, EnumStringMember, EnumSymbolBody, ExistsTypeAnnotation, ExportAllDeclaration, ExportDeclaration, ExportDefaultDeclaration, ExportDefaultSpecifier, ExportNamedDeclaration, ExportNamespaceSpecifier, ExportSpecifier, Expression, ExpressionStatement, ExpressionWrapper, FLATTENABLE_KEYS, FLIPPED_ALIAS_KEYS, FLOWBASEANNOTATION_TYPES, FLOWDECLARATION_TYPES, FLOWPREDICATE_TYPES, FLOWTYPE_TYPES, FLOW_TYPES, FORXSTATEMENT_TYPES, FOR_INIT_KEYS, FOR_TYPES, FUNCTIONPARAMETER_TYPES, FUNCTIONPARENT_TYPES, FUNCTION_TYPES, FieldOptions, File, Flow, FlowBaseAnnotation, FlowDeclaration, FlowPredicate, FlowType, For, ForInStatement, ForOfStatement, ForStatement, ForXStatement, Function, FunctionDeclaration, FunctionExpression, FunctionParameter, FunctionParent, FunctionTypeAnnotation, FunctionTypeParam, GenericTypeAnnotation, IMMUTABLE_TYPES, IMPORTOREXPORTDECLARATION_TYPES, INHERIT_KEYS, Identifier, IfStatement, Immutable, Import, ImportAttribute, ImportDeclaration, ImportDefaultSpecifier, ImportExpression, ImportNamespaceSpecifier, ImportOrExportDeclaration, ImportSpecifier, IndexedAccessType, InferredPredicate, InterfaceDeclaration, InterfaceExtends, InterfaceTypeAnnotation, InterpreterDirective, IntersectionTypeAnnotation, JSX, JSXAttribute, JSXClosingElement, JSXClosingFragment, JSXElement, JSXEmptyExpression, JSXExpressionContainer, JSXFragment, JSXIdentifier, JSXMemberExpression, JSXNamespacedName, JSXOpeningElement, JSXOpeningFragment, JSXSpreadAttribute, JSXSpreadChild, JSXText, JSX_TYPES, LITERAL_TYPES, LOGICAL_OPERATORS, LOOP_TYPES, LVAL_TYPES, LVal, LabeledStatement, Literal, LogicalExpression, Loop, METHOD_TYPES, MISCELLANEOUS_TYPES, MODULEDECLARATION_TYPES, MODULESPECIFIER_TYPES, MemberExpression, MetaProperty, Method, Miscellaneous, MixedTypeAnnotation, ModuleDeclaration, ModuleExpression, ModuleSpecifier, NODE_FIELDS, NODE_PARENT_VALIDATIONS, NUMBER_BINARY_OPERATORS, NUMBER_UNARY_OPERATORS, NewExpression, Node, Noop, NullLiteral, NullLiteralTypeAnnotation, NullableTypeAnnotation, NumberLiteral$1 as NumberLiteral, NumberLiteralTypeAnnotation, NumberTypeAnnotation, NumericLiteral, OBJECTMEMBER_TYPES, ObjectExpression, ObjectMember, ObjectMethod, ObjectPattern, ObjectProperty, ObjectTypeAnnotation, ObjectTypeCallProperty, ObjectTypeIndexer, ObjectTypeInternalSlot, ObjectTypeProperty, ObjectTypeSpreadProperty, OpaqueType, OptionalCallExpression, OptionalIndexedAccessType, OptionalMemberExpression, PATTERNLIKE_TYPES, PATTERN_TYPES, PLACEHOLDERS, PLACEHOLDERS_ALIAS, PLACEHOLDERS_FLIPPED_ALIAS, PRIVATE_TYPES, PROPERTY_TYPES, PUREISH_TYPES, ParentMaps, ParenthesizedExpression, Pattern, PatternLike, PipelineBareFunction, PipelinePrimaryTopicReference, PipelineTopicExpression, Placeholder, Private, PrivateName, Program, Property, Pureish, QualifiedTypeIdentifier, RecordExpression, RegExpLiteral, RegexLiteral$1 as RegexLiteral, Options$1 as RemovePropertiesOptions, RestElement, RestProperty$1 as RestProperty, ReturnStatement, SCOPABLE_TYPES, STANDARDIZED_TYPES, STATEMENT_OR_BLOCK_KEYS, STATEMENT_TYPES, STRING_UNARY_OPERATORS, Scopable, SequenceExpression, SourceLocation, SpreadElement, SpreadProperty$1 as SpreadProperty, Standardized, Statement, StaticBlock, StringLiteral, StringLiteralTypeAnnotation, StringTypeAnnotation, Super, SwitchCase, SwitchStatement, SymbolTypeAnnotation, TERMINATORLESS_TYPES, TSAnyKeyword, TSArrayType, TSAsExpression, TSBASETYPE_TYPES, TSBaseType, TSBigIntKeyword, TSBooleanKeyword, TSCallSignatureDeclaration, TSConditionalType, TSConstructSignatureDeclaration, TSConstructorType, TSDeclareFunction, TSDeclareMethod, TSENTITYNAME_TYPES, TSEntityName, TSEnumBody, TSEnumDeclaration, TSEnumMember, TSExportAssignment, TSExpressionWithTypeArguments, TSExternalModuleReference, TSFunctionType, TSImportEqualsDeclaration, TSImportType, TSIndexSignature, TSIndexedAccessType, TSInferType, TSInstantiationExpression, TSInterfaceBody, TSInterfaceDeclaration, TSIntersectionType, TSIntrinsicKeyword, TSLiteralType, TSMappedType, TSMethodSignature, TSModuleBlock, TSModuleDeclaration, TSNamedTupleMember, TSNamespaceExportDeclaration, TSNeverKeyword, TSNonNullExpression, TSNullKeyword, TSNumberKeyword, TSObjectKeyword, TSOptionalType, TSParameterProperty, TSParenthesizedType, TSPropertySignature, TSQualifiedName, TSRestType, TSSatisfiesExpression, TSStringKeyword, TSSymbolKeyword, TSTYPEELEMENT_TYPES, TSTYPE_TYPES, TSTemplateLiteralType, TSThisType, TSTupleType, TSType, TSTypeAliasDeclaration, TSTypeAnnotation, TSTypeAssertion, TSTypeElement, TSTypeLiteral, TSTypeOperator, TSTypeParameter, TSTypeParameterDeclaration, TSTypeParameterInstantiation, TSTypePredicate, TSTypeQuery, TSTypeReference, TSUndefinedKeyword, TSUnionType, TSUnknownKeyword, TSVoidKeyword, TYPES, TYPESCRIPT_TYPES, TaggedTemplateExpression, TemplateElement, TemplateLiteral, Terminatorless, ThisExpression, ThisTypeAnnotation, ThrowStatement, TopicReference, TraversalAncestors, TraversalHandler, TraversalHandlers, TryStatement, TupleExpression, TupleTypeAnnotation, TypeAlias, TypeAnnotation, TypeCastExpression, TypeParameter, TypeParameterDeclaration, TypeParameterInstantiation, TypeScript, TypeofTypeAnnotation, UNARYLIKE_TYPES, UNARY_OPERATORS, UPDATE_OPERATORS, USERWHITESPACABLE_TYPES, UnaryExpression, UnaryLike, UnionTypeAnnotation, UpdateExpression, UserWhitespacable, V8IntrinsicIdentifier, VISITOR_KEYS, VariableDeclaration, VariableDeclarator, Variance, VoidPattern, VoidTypeAnnotation, WHILE_TYPES, While, WhileStatement, WithStatement, YieldExpression, deprecationWarning as __internal__deprecationWarning, addComment, addComments, anyTypeAnnotation, appendToMemberExpression, argumentPlaceholder, arrayExpression, arrayPattern, arrayTypeAnnotation, arrowFunctionExpression, assertAccessor, assertAnyTypeAnnotation, assertArgumentPlaceholder, assertArrayExpression, assertArrayPattern, assertArrayTypeAnnotation, assertArrowFunctionExpression, assertAssignmentExpression, assertAssignmentPattern, assertAwaitExpression, assertBigIntLiteral, assertBinary, assertBinaryExpression, assertBindExpression, assertBlock, assertBlockParent, assertBlockStatement, assertBooleanLiteral, assertBooleanLiteralTypeAnnotation, assertBooleanTypeAnnotation, assertBreakStatement, assertCallExpression, assertCatchClause, assertClass, assertClassAccessorProperty, assertClassBody, assertClassDeclaration, assertClassExpression, assertClassImplements, assertClassMethod, assertClassPrivateMethod, assertClassPrivateProperty, assertClassProperty, assertCompletionStatement, assertConditional, assertConditionalExpression, assertContinueStatement, assertDebuggerStatement, assertDecimalLiteral, assertDeclaration, assertDeclareClass, assertDeclareExportAllDeclaration, assertDeclareExportDeclaration, assertDeclareFunction, assertDeclareInterface, assertDeclareModule, assertDeclareModuleExports, assertDeclareOpaqueType, assertDeclareTypeAlias, assertDeclareVariable, assertDeclaredPredicate, assertDecorator, assertDirective, assertDirectiveLiteral, assertDoExpression, assertDoWhileStatement, assertEmptyStatement, assertEmptyTypeAnnotation, assertEnumBody, assertEnumBooleanBody, assertEnumBooleanMember, assertEnumDeclaration, assertEnumDefaultedMember, assertEnumMember, assertEnumNumberBody, assertEnumNumberMember, assertEnumStringBody, assertEnumStringMember, assertEnumSymbolBody, assertExistsTypeAnnotation, assertExportAllDeclaration, assertExportDeclaration, assertExportDefaultDeclaration, assertExportDefaultSpecifier, assertExportNamedDeclaration, assertExportNamespaceSpecifier, assertExportSpecifier, assertExpression, assertExpressionStatement, assertExpressionWrapper, assertFile, assertFlow, assertFlowBaseAnnotation, assertFlowDeclaration, assertFlowPredicate, assertFlowType, assertFor, assertForInStatement, assertForOfStatement, assertForStatement, assertForXStatement, assertFunction, assertFunctionDeclaration, assertFunctionExpression, assertFunctionParameter, assertFunctionParent, assertFunctionTypeAnnotation, assertFunctionTypeParam, assertGenericTypeAnnotation, assertIdentifier, assertIfStatement, assertImmutable, assertImport, assertImportAttribute, assertImportDeclaration, assertImportDefaultSpecifier, assertImportExpression, assertImportNamespaceSpecifier, assertImportOrExportDeclaration, assertImportSpecifier, assertIndexedAccessType, assertInferredPredicate, assertInterfaceDeclaration, assertInterfaceExtends, assertInterfaceTypeAnnotation, assertInterpreterDirective, assertIntersectionTypeAnnotation, assertJSX, assertJSXAttribute, assertJSXClosingElement, assertJSXClosingFragment, assertJSXElement, assertJSXEmptyExpression, assertJSXExpressionContainer, assertJSXFragment, assertJSXIdentifier, assertJSXMemberExpression, assertJSXNamespacedName, assertJSXOpeningElement, assertJSXOpeningFragment, assertJSXSpreadAttribute, assertJSXSpreadChild, assertJSXText, assertLVal, assertLabeledStatement, assertLiteral, assertLogicalExpression, assertLoop, assertMemberExpression, assertMetaProperty, assertMethod, assertMiscellaneous, assertMixedTypeAnnotation, assertModuleDeclaration, assertModuleExpression, assertModuleSpecifier, assertNewExpression, assertNode, assertNoop, assertNullLiteral, assertNullLiteralTypeAnnotation, assertNullableTypeAnnotation, assertNumberLiteral, assertNumberLiteralTypeAnnotation, assertNumberTypeAnnotation, assertNumericLiteral, assertObjectExpression, assertObjectMember, assertObjectMethod, assertObjectPattern, assertObjectProperty, assertObjectTypeAnnotation, assertObjectTypeCallProperty, assertObjectTypeIndexer, assertObjectTypeInternalSlot, assertObjectTypeProperty, assertObjectTypeSpreadProperty, assertOpaqueType, assertOptionalCallExpression, assertOptionalIndexedAccessType, assertOptionalMemberExpression, assertParenthesizedExpression, assertPattern, assertPatternLike, assertPipelineBareFunction, assertPipelinePrimaryTopicReference, assertPipelineTopicExpression, assertPlaceholder, assertPrivate, assertPrivateName, assertProgram, assertProperty, assertPureish, assertQualifiedTypeIdentifier, assertRecordExpression, assertRegExpLiteral, assertRegexLiteral, assertRestElement, assertRestProperty, assertReturnStatement, assertScopable, assertSequenceExpression, assertSpreadElement, assertSpreadProperty, assertStandardized, assertStatement, assertStaticBlock, assertStringLiteral, assertStringLiteralTypeAnnotation, assertStringTypeAnnotation, assertSuper, assertSwitchCase, assertSwitchStatement, assertSymbolTypeAnnotation, assertTSAnyKeyword, assertTSArrayType, assertTSAsExpression, assertTSBaseType, assertTSBigIntKeyword, assertTSBooleanKeyword, assertTSCallSignatureDeclaration, assertTSConditionalType, assertTSConstructSignatureDeclaration, assertTSConstructorType, assertTSDeclareFunction, assertTSDeclareMethod, assertTSEntityName, assertTSEnumBody, assertTSEnumDeclaration, assertTSEnumMember, assertTSExportAssignment, assertTSExpressionWithTypeArguments, assertTSExternalModuleReference, assertTSFunctionType, assertTSImportEqualsDeclaration, assertTSImportType, assertTSIndexSignature, assertTSIndexedAccessType, assertTSInferType, assertTSInstantiationExpression, assertTSInterfaceBody, assertTSInterfaceDeclaration, assertTSIntersectionType, assertTSIntrinsicKeyword, assertTSLiteralType, assertTSMappedType, assertTSMethodSignature, assertTSModuleBlock, assertTSModuleDeclaration, assertTSNamedTupleMember, assertTSNamespaceExportDeclaration, assertTSNeverKeyword, assertTSNonNullExpression, assertTSNullKeyword, assertTSNumberKeyword, assertTSObjectKeyword, assertTSOptionalType, assertTSParameterProperty, assertTSParenthesizedType, assertTSPropertySignature, assertTSQualifiedName, assertTSRestType, assertTSSatisfiesExpression, assertTSStringKeyword, assertTSSymbolKeyword, assertTSTemplateLiteralType, assertTSThisType, assertTSTupleType, assertTSType, assertTSTypeAliasDeclaration, assertTSTypeAnnotation, assertTSTypeAssertion, assertTSTypeElement, assertTSTypeLiteral, assertTSTypeOperator, assertTSTypeParameter, assertTSTypeParameterDeclaration, assertTSTypeParameterInstantiation, assertTSTypePredicate, assertTSTypeQuery, assertTSTypeReference, assertTSUndefinedKeyword, assertTSUnionType, assertTSUnknownKeyword, assertTSVoidKeyword, assertTaggedTemplateExpression, assertTemplateElement, assertTemplateLiteral, assertTerminatorless, assertThisExpression, assertThisTypeAnnotation, assertThrowStatement, assertTopicReference, assertTryStatement, assertTupleExpression, assertTupleTypeAnnotation, assertTypeAlias, assertTypeAnnotation, assertTypeCastExpression, assertTypeParameter, assertTypeParameterDeclaration, assertTypeParameterInstantiation, assertTypeScript, assertTypeofTypeAnnotation, assertUnaryExpression, assertUnaryLike, assertUnionTypeAnnotation, assertUpdateExpression, assertUserWhitespacable, assertV8IntrinsicIdentifier, assertVariableDeclaration, assertVariableDeclarator, assertVariance, assertVoidPattern, assertVoidTypeAnnotation, assertWhile, assertWhileStatement, assertWithStatement, assertYieldExpression, assignmentExpression, assignmentPattern, awaitExpression, bigIntLiteral, binaryExpression, bindExpression, blockStatement, booleanLiteral, booleanLiteralTypeAnnotation, booleanTypeAnnotation, breakStatement, buildMatchMemberExpression, buildUndefinedNode, callExpression, catchClause, classAccessorProperty, classBody, classDeclaration, classExpression, classImplements, classMethod, classPrivateMethod, classPrivateProperty, classProperty, clone, cloneDeep, cloneDeepWithoutLoc, cloneNode, cloneWithoutLoc, conditionalExpression, continueStatement, createFlowUnionType, createTSUnionType, _default$4 as createTypeAnnotationBasedOnTypeof, createFlowUnionType as createUnionTypeAnnotation, debuggerStatement, decimalLiteral, declareClass, declareExportAllDeclaration, declareExportDeclaration, declareFunction, declareInterface, declareModule, declareModuleExports, declareOpaqueType, declareTypeAlias, declareVariable, declaredPredicate, decorator, directive, directiveLiteral, doExpression, doWhileStatement, emptyStatement, emptyTypeAnnotation, ensureBlock, enumBooleanBody, enumBooleanMember, enumDeclaration, enumDefaultedMember, enumNumberBody, enumNumberMember, enumStringBody, enumStringMember, enumSymbolBody, existsTypeAnnotation, exportAllDeclaration, exportDefaultDeclaration, exportDefaultSpecifier, exportNamedDeclaration, exportNamespaceSpecifier, exportSpecifier, expressionStatement, file, forInStatement, forOfStatement, forStatement, functionDeclaration, functionExpression, functionTypeAnnotation, functionTypeParam, genericTypeAnnotation, getAssignmentIdentifiers, getBindingIdentifiers, getFunctionName, _default as getOuterBindingIdentifiers, identifier, ifStatement, _import as import, importAttribute, importDeclaration, importDefaultSpecifier, importExpression, importNamespaceSpecifier, importSpecifier, indexedAccessType, inferredPredicate, inheritInnerComments, inheritLeadingComments, inheritTrailingComments, inherits, inheritsComments, interfaceDeclaration, interfaceExtends, interfaceTypeAnnotation, interpreterDirective, intersectionTypeAnnotation, is, isAccessor, isAnyTypeAnnotation, isArgumentPlaceholder, isArrayExpression, isArrayPattern, isArrayTypeAnnotation, isArrowFunctionExpression, isAssignmentExpression, isAssignmentPattern, isAwaitExpression, isBigIntLiteral, isBinary, isBinaryExpression, isBindExpression, isBinding, isBlock, isBlockParent, isBlockScoped, isBlockStatement, isBooleanLiteral, isBooleanLiteralTypeAnnotation, isBooleanTypeAnnotation, isBreakStatement, isCallExpression, isCatchClause, isClass, isClassAccessorProperty, isClassBody, isClassDeclaration, isClassExpression, isClassImplements, isClassMethod, isClassPrivateMethod, isClassPrivateProperty, isClassProperty, isCompletionStatement, isConditional, isConditionalExpression, isContinueStatement, isDebuggerStatement, isDecimalLiteral, isDeclaration, isDeclareClass, isDeclareExportAllDeclaration, isDeclareExportDeclaration, isDeclareFunction, isDeclareInterface, isDeclareModule, isDeclareModuleExports, isDeclareOpaqueType, isDeclareTypeAlias, isDeclareVariable, isDeclaredPredicate, isDecorator, isDirective, isDirectiveLiteral, isDoExpression, isDoWhileStatement, isEmptyStatement, isEmptyTypeAnnotation, isEnumBody, isEnumBooleanBody, isEnumBooleanMember, isEnumDeclaration, isEnumDefaultedMember, isEnumMember, isEnumNumberBody, isEnumNumberMember, isEnumStringBody, isEnumStringMember, isEnumSymbolBody, isExistsTypeAnnotation, isExportAllDeclaration, isExportDeclaration, isExportDefaultDeclaration, isExportDefaultSpecifier, isExportNamedDeclaration, isExportNamespaceSpecifier, isExportSpecifier, isExpression, isExpressionStatement, isExpressionWrapper, isFile, isFlow, isFlowBaseAnnotation, isFlowDeclaration, isFlowPredicate, isFlowType, isFor, isForInStatement, isForOfStatement, isForStatement, isForXStatement, isFunction, isFunctionDeclaration, isFunctionExpression, isFunctionParameter, isFunctionParent, isFunctionTypeAnnotation, isFunctionTypeParam, isGenericTypeAnnotation, isIdentifier, isIfStatement, isImmutable, isImport, isImportAttribute, isImportDeclaration, isImportDefaultSpecifier, isImportExpression, isImportNamespaceSpecifier, isImportOrExportDeclaration, isImportSpecifier, isIndexedAccessType, isInferredPredicate, isInterfaceDeclaration, isInterfaceExtends, isInterfaceTypeAnnotation, isInterpreterDirective, isIntersectionTypeAnnotation, isJSX, isJSXAttribute, isJSXClosingElement, isJSXClosingFragment, isJSXElement, isJSXEmptyExpression, isJSXExpressionContainer, isJSXFragment, isJSXIdentifier, isJSXMemberExpression, isJSXNamespacedName, isJSXOpeningElement, isJSXOpeningFragment, isJSXSpreadAttribute, isJSXSpreadChild, isJSXText, isLVal, isLabeledStatement, isLet, isLiteral, isLogicalExpression, isLoop, isMemberExpression, isMetaProperty, isMethod, isMiscellaneous, isMixedTypeAnnotation, isModuleDeclaration, isModuleExpression, isModuleSpecifier, isNewExpression, isNode, isNodesEquivalent, isNoop, isNullLiteral, isNullLiteralTypeAnnotation, isNullableTypeAnnotation, isNumberLiteral, isNumberLiteralTypeAnnotation, isNumberTypeAnnotation, isNumericLiteral, isObjectExpression, isObjectMember, isObjectMethod, isObjectPattern, isObjectProperty, isObjectTypeAnnotation, isObjectTypeCallProperty, isObjectTypeIndexer, isObjectTypeInternalSlot, isObjectTypeProperty, isObjectTypeSpreadProperty, isOpaqueType, isOptionalCallExpression, isOptionalIndexedAccessType, isOptionalMemberExpression, isParenthesizedExpression, isPattern, isPatternLike, isPipelineBareFunction, isPipelinePrimaryTopicReference, isPipelineTopicExpression, isPlaceholder, isPlaceholderType, isPrivate, isPrivateName, isProgram, isProperty, isPureish, isQualifiedTypeIdentifier, isRecordExpression, isReferenced, isRegExpLiteral, isRegexLiteral, isRestElement, isRestProperty, isReturnStatement, isScopable, isScope, isSequenceExpression, isSpecifierDefault, isSpreadElement, isSpreadProperty, isStandardized, isStatement, isStaticBlock, isStringLiteral, isStringLiteralTypeAnnotation, isStringTypeAnnotation, isSuper, isSwitchCase, isSwitchStatement, isSymbolTypeAnnotation, isTSAnyKeyword, isTSArrayType, isTSAsExpression, isTSBaseType, isTSBigIntKeyword, isTSBooleanKeyword, isTSCallSignatureDeclaration, isTSConditionalType, isTSConstructSignatureDeclaration, isTSConstructorType, isTSDeclareFunction, isTSDeclareMethod, isTSEntityName, isTSEnumBody, isTSEnumDeclaration, isTSEnumMember, isTSExportAssignment, isTSExpressionWithTypeArguments, isTSExternalModuleReference, isTSFunctionType, isTSImportEqualsDeclaration, isTSImportType, isTSIndexSignature, isTSIndexedAccessType, isTSInferType, isTSInstantiationExpression, isTSInterfaceBody, isTSInterfaceDeclaration, isTSIntersectionType, isTSIntrinsicKeyword, isTSLiteralType, isTSMappedType, isTSMethodSignature, isTSModuleBlock, isTSModuleDeclaration, isTSNamedTupleMember, isTSNamespaceExportDeclaration, isTSNeverKeyword, isTSNonNullExpression, isTSNullKeyword, isTSNumberKeyword, isTSObjectKeyword, isTSOptionalType, isTSParameterProperty, isTSParenthesizedType, isTSPropertySignature, isTSQualifiedName, isTSRestType, isTSSatisfiesExpression, isTSStringKeyword, isTSSymbolKeyword, isTSTemplateLiteralType, isTSThisType, isTSTupleType, isTSType, isTSTypeAliasDeclaration, isTSTypeAnnotation, isTSTypeAssertion, isTSTypeElement, isTSTypeLiteral, isTSTypeOperator, isTSTypeParameter, isTSTypeParameterDeclaration, isTSTypeParameterInstantiation, isTSTypePredicate, isTSTypeQuery, isTSTypeReference, isTSUndefinedKeyword, isTSUnionType, isTSUnknownKeyword, isTSVoidKeyword, isTaggedTemplateExpression, isTemplateElement, isTemplateLiteral, isTerminatorless, isThisExpression, isThisTypeAnnotation, isThrowStatement, isTopicReference, isTryStatement, isTupleExpression, isTupleTypeAnnotation, isType, isTypeAlias, isTypeAnnotation, isTypeCastExpression, isTypeParameter, isTypeParameterDeclaration, isTypeParameterInstantiation, isTypeScript, isTypeofTypeAnnotation, isUnaryExpression, isUnaryLike, isUnionTypeAnnotation, isUpdateExpression, isUserWhitespacable, isV8IntrinsicIdentifier, isValidES3Identifier, isValidIdentifier, isVar, isVariableDeclaration, isVariableDeclarator, isVariance, isVoidPattern, isVoidTypeAnnotation, isWhile, isWhileStatement, isWithStatement, isYieldExpression, jsxAttribute as jSXAttribute, jsxClosingElement as jSXClosingElement, jsxClosingFragment as jSXClosingFragment, jsxElement as jSXElement, jsxEmptyExpression as jSXEmptyExpression, jsxExpressionContainer as jSXExpressionContainer, jsxFragment as jSXFragment, jsxIdentifier as jSXIdentifier, jsxMemberExpression as jSXMemberExpression, jsxNamespacedName as jSXNamespacedName, jsxOpeningElement as jSXOpeningElement, jsxOpeningFragment as jSXOpeningFragment, jsxSpreadAttribute as jSXSpreadAttribute, jsxSpreadChild as jSXSpreadChild, jsxText as jSXText, jsxAttribute, jsxClosingElement, jsxClosingFragment, jsxElement, jsxEmptyExpression, jsxExpressionContainer, jsxFragment, jsxIdentifier, jsxMemberExpression, jsxNamespacedName, jsxOpeningElement, jsxOpeningFragment, jsxSpreadAttribute, jsxSpreadChild, jsxText, labeledStatement, logicalExpression, matchesPattern, memberExpression, metaProperty, mixedTypeAnnotation, moduleExpression, newExpression, noop, nullLiteral, nullLiteralTypeAnnotation, nullableTypeAnnotation, NumberLiteral as numberLiteral, numberLiteralTypeAnnotation, numberTypeAnnotation, numericLiteral, objectExpression, objectMethod, objectPattern, objectProperty, objectTypeAnnotation, objectTypeCallProperty, objectTypeIndexer, objectTypeInternalSlot, objectTypeProperty, objectTypeSpreadProperty, opaqueType, optionalCallExpression, optionalIndexedAccessType, optionalMemberExpression, parenthesizedExpression, pipelineBareFunction, pipelinePrimaryTopicReference, pipelineTopicExpression, placeholder, prependToMemberExpression, privateName, program, qualifiedTypeIdentifier, react, recordExpression, regExpLiteral, RegexLiteral as regexLiteral, removeComments, removeProperties, removePropertiesDeep, removeTypeDuplicates, restElement, RestProperty as restProperty, returnStatement, sequenceExpression, shallowEqual, spreadElement, SpreadProperty as spreadProperty, staticBlock, stringLiteral, stringLiteralTypeAnnotation, stringTypeAnnotation, _super as super, switchCase, switchStatement, symbolTypeAnnotation, tsAnyKeyword as tSAnyKeyword, tsArrayType as tSArrayType, tsAsExpression as tSAsExpression, tsBigIntKeyword as tSBigIntKeyword, tsBooleanKeyword as tSBooleanKeyword, tsCallSignatureDeclaration as tSCallSignatureDeclaration, tsConditionalType as tSConditionalType, tsConstructSignatureDeclaration as tSConstructSignatureDeclaration, tsConstructorType as tSConstructorType, tsDeclareFunction as tSDeclareFunction, tsDeclareMethod as tSDeclareMethod, tsEnumBody as tSEnumBody, tsEnumDeclaration as tSEnumDeclaration, tsEnumMember as tSEnumMember, tsExportAssignment as tSExportAssignment, tsExpressionWithTypeArguments as tSExpressionWithTypeArguments, tsExternalModuleReference as tSExternalModuleReference, tsFunctionType as tSFunctionType, tsImportEqualsDeclaration as tSImportEqualsDeclaration, tsImportType as tSImportType, tsIndexSignature as tSIndexSignature, tsIndexedAccessType as tSIndexedAccessType, tsInferType as tSInferType, tsInstantiationExpression as tSInstantiationExpression, tsInterfaceBody as tSInterfaceBody, tsInterfaceDeclaration as tSInterfaceDeclaration, tsIntersectionType as tSIntersectionType, tsIntrinsicKeyword as tSIntrinsicKeyword, tsLiteralType as tSLiteralType, tsMappedType as tSMappedType, tsMethodSignature as tSMethodSignature, tsModuleBlock as tSModuleBlock, tsModuleDeclaration as tSModuleDeclaration, tsNamedTupleMember as tSNamedTupleMember, tsNamespaceExportDeclaration as tSNamespaceExportDeclaration, tsNeverKeyword as tSNeverKeyword, tsNonNullExpression as tSNonNullExpression, tsNullKeyword as tSNullKeyword, tsNumberKeyword as tSNumberKeyword, tsObjectKeyword as tSObjectKeyword, tsOptionalType as tSOptionalType, tsParameterProperty as tSParameterProperty, tsParenthesizedType as tSParenthesizedType, tsPropertySignature as tSPropertySignature, tsQualifiedName as tSQualifiedName, tsRestType as tSRestType, tsSatisfiesExpression as tSSatisfiesExpression, tsStringKeyword as tSStringKeyword, tsSymbolKeyword as tSSymbolKeyword, tsTemplateLiteralType as tSTemplateLiteralType, tsThisType as tSThisType, tsTupleType as tSTupleType, tsTypeAliasDeclaration as tSTypeAliasDeclaration, tsTypeAnnotation as tSTypeAnnotation, tsTypeAssertion as tSTypeAssertion, tsTypeLiteral as tSTypeLiteral, tsTypeOperator as tSTypeOperator, tsTypeParameter as tSTypeParameter, tsTypeParameterDeclaration as tSTypeParameterDeclaration, tsTypeParameterInstantiation as tSTypeParameterInstantiation, tsTypePredicate as tSTypePredicate, tsTypeQuery as tSTypeQuery, tsTypeReference as tSTypeReference, tsUndefinedKeyword as tSUndefinedKeyword, tsUnionType as tSUnionType, tsUnknownKeyword as tSUnknownKeyword, tsVoidKeyword as tSVoidKeyword, taggedTemplateExpression, templateElement, templateLiteral, thisExpression, thisTypeAnnotation, throwStatement, toBindingIdentifierName, toBlock, toComputedKey, _default$3 as toExpression, toIdentifier, toKeyAlias, _default$2 as toStatement, topicReference, traverse, traverseFast, tryStatement, tsAnyKeyword, tsArrayType, tsAsExpression, tsBigIntKeyword, tsBooleanKeyword, tsCallSignatureDeclaration, tsConditionalType, tsConstructSignatureDeclaration, tsConstructorType, tsDeclareFunction, tsDeclareMethod, tsEnumBody, tsEnumDeclaration, tsEnumMember, tsExportAssignment, tsExpressionWithTypeArguments, tsExternalModuleReference, tsFunctionType, tsImportEqualsDeclaration, tsImportType, tsIndexSignature, tsIndexedAccessType, tsInferType, tsInstantiationExpression, tsInterfaceBody, tsInterfaceDeclaration, tsIntersectionType, tsIntrinsicKeyword, tsLiteralType, tsMappedType, tsMethodSignature, tsModuleBlock, tsModuleDeclaration, tsNamedTupleMember, tsNamespaceExportDeclaration, tsNeverKeyword, tsNonNullExpression, tsNullKeyword, tsNumberKeyword, tsObjectKeyword, tsOptionalType, tsParameterProperty, tsParenthesizedType, tsPropertySignature, tsQualifiedName, tsRestType, tsSatisfiesExpression, tsStringKeyword, tsSymbolKeyword, tsTemplateLiteralType, tsThisType, tsTupleType, tsTypeAliasDeclaration, tsTypeAnnotation, tsTypeAssertion, tsTypeLiteral, tsTypeOperator, tsTypeParameter, tsTypeParameterDeclaration, tsTypeParameterInstantiation, tsTypePredicate, tsTypeQuery, tsTypeReference, tsUndefinedKeyword, tsUnionType, tsUnknownKeyword, tsVoidKeyword, tupleExpression, tupleTypeAnnotation, typeAlias, typeAnnotation, typeCastExpression, typeParameter, typeParameterDeclaration, typeParameterInstantiation, typeofTypeAnnotation, unaryExpression, unionTypeAnnotation, updateExpression, v8IntrinsicIdentifier, validate, _default$1 as valueToNode, variableDeclaration, variableDeclarator, variance, voidPattern, voidTypeAnnotation, whileStatement, withStatement, yieldExpression }; diff --git a/scripts/node_modules/@babel/types/lib/index.js b/scripts/node_modules/@babel/types/lib/index.js new file mode 100644 index 0000000000000000000000000000000000000000..3d1c1878134eceef90a1b56d907f4e01cfa0916a --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/index.js @@ -0,0 +1,582 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +var _exportNames = { + react: true, + assertNode: true, + createTypeAnnotationBasedOnTypeof: true, + createUnionTypeAnnotation: true, + createFlowUnionType: true, + createTSUnionType: true, + cloneNode: true, + clone: true, + cloneDeep: true, + cloneDeepWithoutLoc: true, + cloneWithoutLoc: true, + addComment: true, + addComments: true, + inheritInnerComments: true, + inheritLeadingComments: true, + inheritsComments: true, + inheritTrailingComments: true, + removeComments: true, + ensureBlock: true, + toBindingIdentifierName: true, + toBlock: true, + toComputedKey: true, + toExpression: true, + toIdentifier: true, + toKeyAlias: true, + toStatement: true, + valueToNode: true, + appendToMemberExpression: true, + inherits: true, + prependToMemberExpression: true, + removeProperties: true, + removePropertiesDeep: true, + removeTypeDuplicates: true, + getAssignmentIdentifiers: true, + getBindingIdentifiers: true, + getOuterBindingIdentifiers: true, + getFunctionName: true, + traverse: true, + traverseFast: true, + shallowEqual: true, + is: true, + isBinding: true, + isBlockScoped: true, + isImmutable: true, + isLet: true, + isNode: true, + isNodesEquivalent: true, + isPlaceholderType: true, + isReferenced: true, + isScope: true, + isSpecifierDefault: true, + isType: true, + isValidES3Identifier: true, + isValidIdentifier: true, + isVar: true, + matchesPattern: true, + validate: true, + buildMatchMemberExpression: true, + __internal__deprecationWarning: true +}; +Object.defineProperty(exports, "__internal__deprecationWarning", { + enumerable: true, + get: function () { + return _deprecationWarning.default; + } +}); +Object.defineProperty(exports, "addComment", { + enumerable: true, + get: function () { + return _addComment.default; + } +}); +Object.defineProperty(exports, "addComments", { + enumerable: true, + get: function () { + return _addComments.default; + } +}); +Object.defineProperty(exports, "appendToMemberExpression", { + enumerable: true, + get: function () { + return _appendToMemberExpression.default; + } +}); +Object.defineProperty(exports, "assertNode", { + enumerable: true, + get: function () { + return _assertNode.default; + } +}); +Object.defineProperty(exports, "buildMatchMemberExpression", { + enumerable: true, + get: function () { + return _buildMatchMemberExpression.default; + } +}); +Object.defineProperty(exports, "clone", { + enumerable: true, + get: function () { + return _clone.default; + } +}); +Object.defineProperty(exports, "cloneDeep", { + enumerable: true, + get: function () { + return _cloneDeep.default; + } +}); +Object.defineProperty(exports, "cloneDeepWithoutLoc", { + enumerable: true, + get: function () { + return _cloneDeepWithoutLoc.default; + } +}); +Object.defineProperty(exports, "cloneNode", { + enumerable: true, + get: function () { + return _cloneNode.default; + } +}); +Object.defineProperty(exports, "cloneWithoutLoc", { + enumerable: true, + get: function () { + return _cloneWithoutLoc.default; + } +}); +Object.defineProperty(exports, "createFlowUnionType", { + enumerable: true, + get: function () { + return _createFlowUnionType.default; + } +}); +Object.defineProperty(exports, "createTSUnionType", { + enumerable: true, + get: function () { + return _createTSUnionType.default; + } +}); +Object.defineProperty(exports, "createTypeAnnotationBasedOnTypeof", { + enumerable: true, + get: function () { + return _createTypeAnnotationBasedOnTypeof.default; + } +}); +Object.defineProperty(exports, "createUnionTypeAnnotation", { + enumerable: true, + get: function () { + return _createFlowUnionType.default; + } +}); +Object.defineProperty(exports, "ensureBlock", { + enumerable: true, + get: function () { + return _ensureBlock.default; + } +}); +Object.defineProperty(exports, "getAssignmentIdentifiers", { + enumerable: true, + get: function () { + return _getAssignmentIdentifiers.default; + } +}); +Object.defineProperty(exports, "getBindingIdentifiers", { + enumerable: true, + get: function () { + return _getBindingIdentifiers.default; + } +}); +Object.defineProperty(exports, "getFunctionName", { + enumerable: true, + get: function () { + return _getFunctionName.default; + } +}); +Object.defineProperty(exports, "getOuterBindingIdentifiers", { + enumerable: true, + get: function () { + return _getOuterBindingIdentifiers.default; + } +}); +Object.defineProperty(exports, "inheritInnerComments", { + enumerable: true, + get: function () { + return _inheritInnerComments.default; + } +}); +Object.defineProperty(exports, "inheritLeadingComments", { + enumerable: true, + get: function () { + return _inheritLeadingComments.default; + } +}); +Object.defineProperty(exports, "inheritTrailingComments", { + enumerable: true, + get: function () { + return _inheritTrailingComments.default; + } +}); +Object.defineProperty(exports, "inherits", { + enumerable: true, + get: function () { + return _inherits.default; + } +}); +Object.defineProperty(exports, "inheritsComments", { + enumerable: true, + get: function () { + return _inheritsComments.default; + } +}); +Object.defineProperty(exports, "is", { + enumerable: true, + get: function () { + return _is.default; + } +}); +Object.defineProperty(exports, "isBinding", { + enumerable: true, + get: function () { + return _isBinding.default; + } +}); +Object.defineProperty(exports, "isBlockScoped", { + enumerable: true, + get: function () { + return _isBlockScoped.default; + } +}); +Object.defineProperty(exports, "isImmutable", { + enumerable: true, + get: function () { + return _isImmutable.default; + } +}); +Object.defineProperty(exports, "isLet", { + enumerable: true, + get: function () { + return _isLet.default; + } +}); +Object.defineProperty(exports, "isNode", { + enumerable: true, + get: function () { + return _isNode.default; + } +}); +Object.defineProperty(exports, "isNodesEquivalent", { + enumerable: true, + get: function () { + return _isNodesEquivalent.default; + } +}); +Object.defineProperty(exports, "isPlaceholderType", { + enumerable: true, + get: function () { + return _isPlaceholderType.default; + } +}); +Object.defineProperty(exports, "isReferenced", { + enumerable: true, + get: function () { + return _isReferenced.default; + } +}); +Object.defineProperty(exports, "isScope", { + enumerable: true, + get: function () { + return _isScope.default; + } +}); +Object.defineProperty(exports, "isSpecifierDefault", { + enumerable: true, + get: function () { + return _isSpecifierDefault.default; + } +}); +Object.defineProperty(exports, "isType", { + enumerable: true, + get: function () { + return _isType.default; + } +}); +Object.defineProperty(exports, "isValidES3Identifier", { + enumerable: true, + get: function () { + return _isValidES3Identifier.default; + } +}); +Object.defineProperty(exports, "isValidIdentifier", { + enumerable: true, + get: function () { + return _isValidIdentifier.default; + } +}); +Object.defineProperty(exports, "isVar", { + enumerable: true, + get: function () { + return _isVar.default; + } +}); +Object.defineProperty(exports, "matchesPattern", { + enumerable: true, + get: function () { + return _matchesPattern.default; + } +}); +Object.defineProperty(exports, "prependToMemberExpression", { + enumerable: true, + get: function () { + return _prependToMemberExpression.default; + } +}); +exports.react = void 0; +Object.defineProperty(exports, "removeComments", { + enumerable: true, + get: function () { + return _removeComments.default; + } +}); +Object.defineProperty(exports, "removeProperties", { + enumerable: true, + get: function () { + return _removeProperties.default; + } +}); +Object.defineProperty(exports, "removePropertiesDeep", { + enumerable: true, + get: function () { + return _removePropertiesDeep.default; + } +}); +Object.defineProperty(exports, "removeTypeDuplicates", { + enumerable: true, + get: function () { + return _removeTypeDuplicates.default; + } +}); +Object.defineProperty(exports, "shallowEqual", { + enumerable: true, + get: function () { + return _shallowEqual.default; + } +}); +Object.defineProperty(exports, "toBindingIdentifierName", { + enumerable: true, + get: function () { + return _toBindingIdentifierName.default; + } +}); +Object.defineProperty(exports, "toBlock", { + enumerable: true, + get: function () { + return _toBlock.default; + } +}); +Object.defineProperty(exports, "toComputedKey", { + enumerable: true, + get: function () { + return _toComputedKey.default; + } +}); +Object.defineProperty(exports, "toExpression", { + enumerable: true, + get: function () { + return _toExpression.default; + } +}); +Object.defineProperty(exports, "toIdentifier", { + enumerable: true, + get: function () { + return _toIdentifier.default; + } +}); +Object.defineProperty(exports, "toKeyAlias", { + enumerable: true, + get: function () { + return _toKeyAlias.default; + } +}); +Object.defineProperty(exports, "toStatement", { + enumerable: true, + get: function () { + return _toStatement.default; + } +}); +Object.defineProperty(exports, "traverse", { + enumerable: true, + get: function () { + return _traverse.default; + } +}); +Object.defineProperty(exports, "traverseFast", { + enumerable: true, + get: function () { + return _traverseFast.default; + } +}); +Object.defineProperty(exports, "validate", { + enumerable: true, + get: function () { + return _validate.default; + } +}); +Object.defineProperty(exports, "valueToNode", { + enumerable: true, + get: function () { + return _valueToNode.default; + } +}); +var _isReactComponent = require("./validators/react/isReactComponent.js"); +var _isCompatTag = require("./validators/react/isCompatTag.js"); +var _buildChildren = require("./builders/react/buildChildren.js"); +var _assertNode = require("./asserts/assertNode.js"); +var _index = require("./asserts/generated/index.js"); +Object.keys(_index).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; + if (key in exports && exports[key] === _index[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _index[key]; + } + }); +}); +var _createTypeAnnotationBasedOnTypeof = require("./builders/flow/createTypeAnnotationBasedOnTypeof.js"); +var _createFlowUnionType = require("./builders/flow/createFlowUnionType.js"); +var _createTSUnionType = require("./builders/typescript/createTSUnionType.js"); +var _productions = require("./builders/productions.js"); +Object.keys(_productions).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; + if (key in exports && exports[key] === _productions[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _productions[key]; + } + }); +}); +var _index2 = require("./builders/generated/index.js"); +Object.keys(_index2).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; + if (key in exports && exports[key] === _index2[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _index2[key]; + } + }); +}); +var _cloneNode = require("./clone/cloneNode.js"); +var _clone = require("./clone/clone.js"); +var _cloneDeep = require("./clone/cloneDeep.js"); +var _cloneDeepWithoutLoc = require("./clone/cloneDeepWithoutLoc.js"); +var _cloneWithoutLoc = require("./clone/cloneWithoutLoc.js"); +var _addComment = require("./comments/addComment.js"); +var _addComments = require("./comments/addComments.js"); +var _inheritInnerComments = require("./comments/inheritInnerComments.js"); +var _inheritLeadingComments = require("./comments/inheritLeadingComments.js"); +var _inheritsComments = require("./comments/inheritsComments.js"); +var _inheritTrailingComments = require("./comments/inheritTrailingComments.js"); +var _removeComments = require("./comments/removeComments.js"); +var _index3 = require("./constants/generated/index.js"); +Object.keys(_index3).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; + if (key in exports && exports[key] === _index3[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _index3[key]; + } + }); +}); +var _index4 = require("./constants/index.js"); +Object.keys(_index4).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; + if (key in exports && exports[key] === _index4[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _index4[key]; + } + }); +}); +var _ensureBlock = require("./converters/ensureBlock.js"); +var _toBindingIdentifierName = require("./converters/toBindingIdentifierName.js"); +var _toBlock = require("./converters/toBlock.js"); +var _toComputedKey = require("./converters/toComputedKey.js"); +var _toExpression = require("./converters/toExpression.js"); +var _toIdentifier = require("./converters/toIdentifier.js"); +var _toKeyAlias = require("./converters/toKeyAlias.js"); +var _toStatement = require("./converters/toStatement.js"); +var _valueToNode = require("./converters/valueToNode.js"); +var _index5 = require("./definitions/index.js"); +Object.keys(_index5).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; + if (key in exports && exports[key] === _index5[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _index5[key]; + } + }); +}); +var _appendToMemberExpression = require("./modifications/appendToMemberExpression.js"); +var _inherits = require("./modifications/inherits.js"); +var _prependToMemberExpression = require("./modifications/prependToMemberExpression.js"); +var _removeProperties = require("./modifications/removeProperties.js"); +var _removePropertiesDeep = require("./modifications/removePropertiesDeep.js"); +var _removeTypeDuplicates = require("./modifications/flow/removeTypeDuplicates.js"); +var _getAssignmentIdentifiers = require("./retrievers/getAssignmentIdentifiers.js"); +var _getBindingIdentifiers = require("./retrievers/getBindingIdentifiers.js"); +var _getOuterBindingIdentifiers = require("./retrievers/getOuterBindingIdentifiers.js"); +var _getFunctionName = require("./retrievers/getFunctionName.js"); +var _traverse = require("./traverse/traverse.js"); +Object.keys(_traverse).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; + if (key in exports && exports[key] === _traverse[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _traverse[key]; + } + }); +}); +var _traverseFast = require("./traverse/traverseFast.js"); +var _shallowEqual = require("./utils/shallowEqual.js"); +var _is = require("./validators/is.js"); +var _isBinding = require("./validators/isBinding.js"); +var _isBlockScoped = require("./validators/isBlockScoped.js"); +var _isImmutable = require("./validators/isImmutable.js"); +var _isLet = require("./validators/isLet.js"); +var _isNode = require("./validators/isNode.js"); +var _isNodesEquivalent = require("./validators/isNodesEquivalent.js"); +var _isPlaceholderType = require("./validators/isPlaceholderType.js"); +var _isReferenced = require("./validators/isReferenced.js"); +var _isScope = require("./validators/isScope.js"); +var _isSpecifierDefault = require("./validators/isSpecifierDefault.js"); +var _isType = require("./validators/isType.js"); +var _isValidES3Identifier = require("./validators/isValidES3Identifier.js"); +var _isValidIdentifier = require("./validators/isValidIdentifier.js"); +var _isVar = require("./validators/isVar.js"); +var _matchesPattern = require("./validators/matchesPattern.js"); +var _validate = require("./validators/validate.js"); +var _buildMatchMemberExpression = require("./validators/buildMatchMemberExpression.js"); +var _index6 = require("./validators/generated/index.js"); +Object.keys(_index6).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; + if (key in exports && exports[key] === _index6[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _index6[key]; + } + }); +}); +var _deprecationWarning = require("./utils/deprecationWarning.js"); +var _toSequenceExpression = require("./converters/toSequenceExpression.js"); +const react = exports.react = { + isReactComponent: _isReactComponent.default, + isCompatTag: _isCompatTag.default, + buildChildren: _buildChildren.default +}; +exports.toSequenceExpression = _toSequenceExpression.default; +if (process.env.BABEL_TYPES_8_BREAKING) { + console.warn("BABEL_TYPES_8_BREAKING is not supported anymore. Use the latest Babel 8.0.0 pre-release instead!"); +} + +//# sourceMappingURL=index.js.map diff --git a/scripts/node_modules/@babel/types/lib/index.js.flow b/scripts/node_modules/@babel/types/lib/index.js.flow new file mode 100644 index 0000000000000000000000000000000000000000..772d5acc3a390321ce80b9cafc74c3630b77a1ff --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/index.js.flow @@ -0,0 +1,2650 @@ +// NOTE: This file is autogenerated. Do not modify. +// See packages/babel-types/scripts/generators/flow.ts for script used. + +declare class BabelNodeComment { + value: string; + start: number; + end: number; + loc: BabelNodeSourceLocation; +} + +declare class BabelNodeCommentBlock extends BabelNodeComment { + type: "CommentBlock"; +} + +declare class BabelNodeCommentLine extends BabelNodeComment { + type: "CommentLine"; +} + +declare class BabelNodeSourceLocation { + start: { + line: number; + column: number; + }; + + end: { + line: number; + column: number; + }; +} + +declare class BabelNode { + leadingComments?: Array; + innerComments?: Array; + trailingComments?: Array; + start: ?number; + end: ?number; + loc: ?BabelNodeSourceLocation; + extra?: { [string]: mixed }; +} + +declare class BabelNodeArrayExpression extends BabelNode { + type: "ArrayExpression"; + elements?: (null | BabelNodeExpression | BabelNodeSpreadElement)[]; +} + +declare class BabelNodeAssignmentExpression extends BabelNode { + type: "AssignmentExpression"; + operator: string; + left: BabelNodeLVal | BabelNodeOptionalMemberExpression; + right: BabelNodeExpression; +} + +declare class BabelNodeBinaryExpression extends BabelNode { + type: "BinaryExpression"; + operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=" | "|>"; + left: BabelNodeExpression | BabelNodePrivateName; + right: BabelNodeExpression; +} + +declare class BabelNodeInterpreterDirective extends BabelNode { + type: "InterpreterDirective"; + value: string; +} + +declare class BabelNodeDirective extends BabelNode { + type: "Directive"; + value: BabelNodeDirectiveLiteral; +} + +declare class BabelNodeDirectiveLiteral extends BabelNode { + type: "DirectiveLiteral"; + value: string; +} + +declare class BabelNodeBlockStatement extends BabelNode { + type: "BlockStatement"; + body: BabelNodeStatement[]; + directives?: BabelNodeDirective[]; +} + +declare class BabelNodeBreakStatement extends BabelNode { + type: "BreakStatement"; + label?: BabelNodeIdentifier; +} + +declare class BabelNodeCallExpression extends BabelNode { + type: "CallExpression"; + callee: BabelNodeExpression | BabelNodeSuper | BabelNodeV8IntrinsicIdentifier; + arguments: (BabelNodeExpression | BabelNodeSpreadElement | BabelNodeArgumentPlaceholder)[]; + optional?: boolean; + typeArguments?: BabelNodeTypeParameterInstantiation; + typeParameters?: BabelNodeTSTypeParameterInstantiation; +} + +declare class BabelNodeCatchClause extends BabelNode { + type: "CatchClause"; + param?: BabelNodeIdentifier | BabelNodeArrayPattern | BabelNodeObjectPattern; + body: BabelNodeBlockStatement; +} + +declare class BabelNodeConditionalExpression extends BabelNode { + type: "ConditionalExpression"; + test: BabelNodeExpression; + consequent: BabelNodeExpression; + alternate: BabelNodeExpression; +} + +declare class BabelNodeContinueStatement extends BabelNode { + type: "ContinueStatement"; + label?: BabelNodeIdentifier; +} + +declare class BabelNodeDebuggerStatement extends BabelNode { + type: "DebuggerStatement"; +} + +declare class BabelNodeDoWhileStatement extends BabelNode { + type: "DoWhileStatement"; + test: BabelNodeExpression; + body: BabelNodeStatement; +} + +declare class BabelNodeEmptyStatement extends BabelNode { + type: "EmptyStatement"; +} + +declare class BabelNodeExpressionStatement extends BabelNode { + type: "ExpressionStatement"; + expression: BabelNodeExpression; +} + +declare class BabelNodeFile extends BabelNode { + type: "File"; + program: BabelNodeProgram; + comments?: (BabelNodeCommentBlock | BabelNodeCommentLine)[]; + tokens?: any[]; +} + +declare class BabelNodeForInStatement extends BabelNode { + type: "ForInStatement"; + left: BabelNodeVariableDeclaration | BabelNodeLVal; + right: BabelNodeExpression; + body: BabelNodeStatement; +} + +declare class BabelNodeForStatement extends BabelNode { + type: "ForStatement"; + init?: BabelNodeVariableDeclaration | BabelNodeExpression; + test?: BabelNodeExpression; + update?: BabelNodeExpression; + body: BabelNodeStatement; +} + +declare class BabelNodeFunctionDeclaration extends BabelNode { + type: "FunctionDeclaration"; + id?: BabelNodeIdentifier; + params: BabelNodeFunctionParameter[]; + body: BabelNodeBlockStatement; + generator?: boolean; + async?: boolean; + declare?: boolean; + predicate?: BabelNodeDeclaredPredicate | BabelNodeInferredPredicate; + returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop; + typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop; +} + +declare class BabelNodeFunctionExpression extends BabelNode { + type: "FunctionExpression"; + id?: BabelNodeIdentifier; + params: BabelNodeFunctionParameter[]; + body: BabelNodeBlockStatement; + generator?: boolean; + async?: boolean; + predicate?: BabelNodeDeclaredPredicate | BabelNodeInferredPredicate; + returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop; + typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop; +} + +declare class BabelNodeIdentifier extends BabelNode { + type: "Identifier"; + name: string; + decorators?: BabelNodeDecorator[]; + optional?: boolean; + typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop; +} + +declare class BabelNodeIfStatement extends BabelNode { + type: "IfStatement"; + test: BabelNodeExpression; + consequent: BabelNodeStatement; + alternate?: BabelNodeStatement; +} + +declare class BabelNodeLabeledStatement extends BabelNode { + type: "LabeledStatement"; + label: BabelNodeIdentifier; + body: BabelNodeStatement; +} + +declare class BabelNodeStringLiteral extends BabelNode { + type: "StringLiteral"; + value: string; +} + +declare class BabelNodeNumericLiteral extends BabelNode { + type: "NumericLiteral"; + value: number; +} + +declare class BabelNodeNullLiteral extends BabelNode { + type: "NullLiteral"; +} + +declare class BabelNodeBooleanLiteral extends BabelNode { + type: "BooleanLiteral"; + value: boolean; +} + +declare class BabelNodeRegExpLiteral extends BabelNode { + type: "RegExpLiteral"; + pattern: string; + flags?: string; +} + +declare class BabelNodeLogicalExpression extends BabelNode { + type: "LogicalExpression"; + operator: "||" | "&&" | "??"; + left: BabelNodeExpression; + right: BabelNodeExpression; +} + +declare class BabelNodeMemberExpression extends BabelNode { + type: "MemberExpression"; + object: BabelNodeExpression | BabelNodeSuper; + property: BabelNodeExpression | BabelNodeIdentifier | BabelNodePrivateName; + computed?: boolean; + optional?: boolean; +} + +declare class BabelNodeNewExpression extends BabelNode { + type: "NewExpression"; + callee: BabelNodeExpression | BabelNodeSuper | BabelNodeV8IntrinsicIdentifier; + arguments: (BabelNodeExpression | BabelNodeSpreadElement | BabelNodeArgumentPlaceholder)[]; + optional?: boolean; + typeArguments?: BabelNodeTypeParameterInstantiation; + typeParameters?: BabelNodeTSTypeParameterInstantiation; +} + +declare class BabelNodeProgram extends BabelNode { + type: "Program"; + body: BabelNodeStatement[]; + directives?: BabelNodeDirective[]; + sourceType?: "script" | "module"; + interpreter?: BabelNodeInterpreterDirective; +} + +declare class BabelNodeObjectExpression extends BabelNode { + type: "ObjectExpression"; + properties: (BabelNodeObjectMethod | BabelNodeObjectProperty | BabelNodeSpreadElement)[]; +} + +declare class BabelNodeObjectMethod extends BabelNode { + type: "ObjectMethod"; + kind?: "method" | "get" | "set"; + key: BabelNodeExpression | BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral; + params: BabelNodeFunctionParameter[]; + body: BabelNodeBlockStatement; + computed?: boolean; + generator?: boolean; + async?: boolean; + decorators?: BabelNodeDecorator[]; + returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop; + typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop; +} + +declare class BabelNodeObjectProperty extends BabelNode { + type: "ObjectProperty"; + key: BabelNodeExpression | BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeDecimalLiteral | BabelNodePrivateName; + value: BabelNodeExpression | BabelNodePatternLike; + computed?: boolean; + shorthand?: boolean; + decorators?: BabelNodeDecorator[]; +} + +declare class BabelNodeRestElement extends BabelNode { + type: "RestElement"; + argument: BabelNodeIdentifier | BabelNodeArrayPattern | BabelNodeObjectPattern | BabelNodeMemberExpression | BabelNodeTSAsExpression | BabelNodeTSSatisfiesExpression | BabelNodeTSTypeAssertion | BabelNodeTSNonNullExpression | BabelNodeRestElement | BabelNodeAssignmentPattern; + decorators?: BabelNodeDecorator[]; + optional?: boolean; + typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop; +} + +declare class BabelNodeReturnStatement extends BabelNode { + type: "ReturnStatement"; + argument?: BabelNodeExpression; +} + +declare class BabelNodeSequenceExpression extends BabelNode { + type: "SequenceExpression"; + expressions: BabelNodeExpression[]; +} + +declare class BabelNodeParenthesizedExpression extends BabelNode { + type: "ParenthesizedExpression"; + expression: BabelNodeExpression; +} + +declare class BabelNodeSwitchCase extends BabelNode { + type: "SwitchCase"; + test?: BabelNodeExpression; + consequent: BabelNodeStatement[]; +} + +declare class BabelNodeSwitchStatement extends BabelNode { + type: "SwitchStatement"; + discriminant: BabelNodeExpression; + cases: BabelNodeSwitchCase[]; +} + +declare class BabelNodeThisExpression extends BabelNode { + type: "ThisExpression"; +} + +declare class BabelNodeThrowStatement extends BabelNode { + type: "ThrowStatement"; + argument: BabelNodeExpression; +} + +declare class BabelNodeTryStatement extends BabelNode { + type: "TryStatement"; + block: BabelNodeBlockStatement; + handler?: BabelNodeCatchClause; + finalizer?: BabelNodeBlockStatement; +} + +declare class BabelNodeUnaryExpression extends BabelNode { + type: "UnaryExpression"; + operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof"; + argument: BabelNodeExpression; + prefix?: boolean; +} + +declare class BabelNodeUpdateExpression extends BabelNode { + type: "UpdateExpression"; + operator: "++" | "--"; + argument: BabelNodeExpression; + prefix?: boolean; +} + +declare class BabelNodeVariableDeclaration extends BabelNode { + type: "VariableDeclaration"; + kind: "var" | "let" | "const" | "using" | "await using"; + declarations: BabelNodeVariableDeclarator[]; + declare?: boolean; +} + +declare class BabelNodeVariableDeclarator extends BabelNode { + type: "VariableDeclarator"; + id: BabelNodeLVal | BabelNodeVoidPattern; + init?: BabelNodeExpression; + definite?: boolean; +} + +declare class BabelNodeWhileStatement extends BabelNode { + type: "WhileStatement"; + test: BabelNodeExpression; + body: BabelNodeStatement; +} + +declare class BabelNodeWithStatement extends BabelNode { + type: "WithStatement"; + object: BabelNodeExpression; + body: BabelNodeStatement; +} + +declare class BabelNodeAssignmentPattern extends BabelNode { + type: "AssignmentPattern"; + left: BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeArrayPattern | BabelNodeMemberExpression | BabelNodeTSAsExpression | BabelNodeTSSatisfiesExpression | BabelNodeTSTypeAssertion | BabelNodeTSNonNullExpression; + right: BabelNodeExpression; + decorators?: BabelNodeDecorator[]; + optional?: boolean; + typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop; +} + +declare class BabelNodeArrayPattern extends BabelNode { + type: "ArrayPattern"; + elements: (null | BabelNodePatternLike)[]; + decorators?: BabelNodeDecorator[]; + optional?: boolean; + typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop; +} + +declare class BabelNodeArrowFunctionExpression extends BabelNode { + type: "ArrowFunctionExpression"; + params: BabelNodeFunctionParameter[]; + body: BabelNodeBlockStatement | BabelNodeExpression; + async?: boolean; + expression: boolean; + generator?: boolean; + predicate?: BabelNodeDeclaredPredicate | BabelNodeInferredPredicate; + returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop; + typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop; +} + +declare class BabelNodeClassBody extends BabelNode { + type: "ClassBody"; + body: (BabelNodeClassMethod | BabelNodeClassPrivateMethod | BabelNodeClassProperty | BabelNodeClassPrivateProperty | BabelNodeClassAccessorProperty | BabelNodeTSDeclareMethod | BabelNodeTSIndexSignature | BabelNodeStaticBlock)[]; +} + +declare class BabelNodeClassExpression extends BabelNode { + type: "ClassExpression"; + id?: BabelNodeIdentifier; + superClass?: BabelNodeExpression; + body: BabelNodeClassBody; + decorators?: BabelNodeDecorator[]; + mixins?: BabelNodeInterfaceExtends; + superTypeParameters?: BabelNodeTypeParameterInstantiation | BabelNodeTSTypeParameterInstantiation; + typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop; +} + +declare class BabelNodeClassDeclaration extends BabelNode { + type: "ClassDeclaration"; + id?: BabelNodeIdentifier; + superClass?: BabelNodeExpression; + body: BabelNodeClassBody; + decorators?: BabelNodeDecorator[]; + abstract?: boolean; + declare?: boolean; + mixins?: BabelNodeInterfaceExtends; + superTypeParameters?: BabelNodeTypeParameterInstantiation | BabelNodeTSTypeParameterInstantiation; + typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop; +} + +declare class BabelNodeExportAllDeclaration extends BabelNode { + type: "ExportAllDeclaration"; + source: BabelNodeStringLiteral; + attributes?: BabelNodeImportAttribute[]; + assertions?: BabelNodeImportAttribute[]; + exportKind?: "type" | "value"; +} + +declare class BabelNodeExportDefaultDeclaration extends BabelNode { + type: "ExportDefaultDeclaration"; + declaration: BabelNodeTSDeclareFunction | BabelNodeFunctionDeclaration | BabelNodeClassDeclaration | BabelNodeExpression; + exportKind?: "value"; +} + +declare class BabelNodeExportNamedDeclaration extends BabelNode { + type: "ExportNamedDeclaration"; + declaration?: BabelNodeDeclaration; + specifiers?: (BabelNodeExportSpecifier | BabelNodeExportDefaultSpecifier | BabelNodeExportNamespaceSpecifier)[]; + source?: BabelNodeStringLiteral; + attributes?: BabelNodeImportAttribute[]; + assertions?: BabelNodeImportAttribute[]; + exportKind?: "type" | "value"; +} + +declare class BabelNodeExportSpecifier extends BabelNode { + type: "ExportSpecifier"; + local: BabelNodeIdentifier; + exported: BabelNodeIdentifier | BabelNodeStringLiteral; + exportKind?: "type" | "value"; +} + +declare class BabelNodeForOfStatement extends BabelNode { + type: "ForOfStatement"; + left: BabelNodeVariableDeclaration | BabelNodeLVal; + right: BabelNodeExpression; + body: BabelNodeStatement; +} + +declare class BabelNodeImportDeclaration extends BabelNode { + type: "ImportDeclaration"; + specifiers: (BabelNodeImportSpecifier | BabelNodeImportDefaultSpecifier | BabelNodeImportNamespaceSpecifier)[]; + source: BabelNodeStringLiteral; + attributes?: BabelNodeImportAttribute[]; + assertions?: BabelNodeImportAttribute[]; + importKind?: "type" | "typeof" | "value"; + module?: boolean; + phase?: "source" | "defer"; +} + +declare class BabelNodeImportDefaultSpecifier extends BabelNode { + type: "ImportDefaultSpecifier"; + local: BabelNodeIdentifier; +} + +declare class BabelNodeImportNamespaceSpecifier extends BabelNode { + type: "ImportNamespaceSpecifier"; + local: BabelNodeIdentifier; +} + +declare class BabelNodeImportSpecifier extends BabelNode { + type: "ImportSpecifier"; + local: BabelNodeIdentifier; + imported: BabelNodeIdentifier | BabelNodeStringLiteral; + importKind?: "type" | "typeof" | "value"; +} + +declare class BabelNodeImportExpression extends BabelNode { + type: "ImportExpression"; + source: BabelNodeExpression; + options?: BabelNodeExpression; + phase?: "source" | "defer"; +} + +declare class BabelNodeMetaProperty extends BabelNode { + type: "MetaProperty"; + meta: BabelNodeIdentifier; + property: BabelNodeIdentifier; +} + +declare class BabelNodeClassMethod extends BabelNode { + type: "ClassMethod"; + kind?: "get" | "set" | "method" | "constructor"; + key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression; + params: (BabelNodeFunctionParameter | BabelNodeTSParameterProperty)[]; + body: BabelNodeBlockStatement; + computed?: boolean; + generator?: boolean; + async?: boolean; + abstract?: boolean; + access?: "public" | "private" | "protected"; + accessibility?: "public" | "private" | "protected"; + decorators?: BabelNodeDecorator[]; + optional?: boolean; + override?: boolean; + returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop; + typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop; +} + +declare class BabelNodeObjectPattern extends BabelNode { + type: "ObjectPattern"; + properties: (BabelNodeRestElement | BabelNodeObjectProperty)[]; + decorators?: BabelNodeDecorator[]; + optional?: boolean; + typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop; +} + +declare class BabelNodeSpreadElement extends BabelNode { + type: "SpreadElement"; + argument: BabelNodeExpression; +} + +declare class BabelNodeSuper extends BabelNode { + type: "Super"; +} + +declare class BabelNodeTaggedTemplateExpression extends BabelNode { + type: "TaggedTemplateExpression"; + tag: BabelNodeExpression; + quasi: BabelNodeTemplateLiteral; + typeParameters?: BabelNodeTypeParameterInstantiation | BabelNodeTSTypeParameterInstantiation; +} + +declare class BabelNodeTemplateElement extends BabelNode { + type: "TemplateElement"; + value: { raw: string, cooked?: string }; + tail?: boolean; +} + +declare class BabelNodeTemplateLiteral extends BabelNode { + type: "TemplateLiteral"; + quasis: BabelNodeTemplateElement[]; + expressions: (BabelNodeExpression | BabelNodeTSType)[]; +} + +declare class BabelNodeYieldExpression extends BabelNode { + type: "YieldExpression"; + argument?: BabelNodeExpression; + delegate?: boolean; +} + +declare class BabelNodeAwaitExpression extends BabelNode { + type: "AwaitExpression"; + argument: BabelNodeExpression; +} + +declare class BabelNodeImport extends BabelNode { + type: "Import"; +} + +declare class BabelNodeBigIntLiteral extends BabelNode { + type: "BigIntLiteral"; + value: string; +} + +declare class BabelNodeExportNamespaceSpecifier extends BabelNode { + type: "ExportNamespaceSpecifier"; + exported: BabelNodeIdentifier; +} + +declare class BabelNodeOptionalMemberExpression extends BabelNode { + type: "OptionalMemberExpression"; + object: BabelNodeExpression; + property: BabelNodeExpression | BabelNodeIdentifier; + computed?: boolean; + optional: boolean; +} + +declare class BabelNodeOptionalCallExpression extends BabelNode { + type: "OptionalCallExpression"; + callee: BabelNodeExpression; + arguments: (BabelNodeExpression | BabelNodeSpreadElement | BabelNodeArgumentPlaceholder)[]; + optional: boolean; + typeArguments?: BabelNodeTypeParameterInstantiation; + typeParameters?: BabelNodeTSTypeParameterInstantiation; +} + +declare class BabelNodeClassProperty extends BabelNode { + type: "ClassProperty"; + key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression; + value?: BabelNodeExpression; + typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop; + decorators?: BabelNodeDecorator[]; + computed?: boolean; + abstract?: boolean; + accessibility?: "public" | "private" | "protected"; + declare?: boolean; + definite?: boolean; + optional?: boolean; + override?: boolean; + readonly?: boolean; + variance?: BabelNodeVariance; +} + +declare class BabelNodeClassAccessorProperty extends BabelNode { + type: "ClassAccessorProperty"; + key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression | BabelNodePrivateName; + value?: BabelNodeExpression; + typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop; + decorators?: BabelNodeDecorator[]; + computed?: boolean; + abstract?: boolean; + accessibility?: "public" | "private" | "protected"; + declare?: boolean; + definite?: boolean; + optional?: boolean; + override?: boolean; + readonly?: boolean; + variance?: BabelNodeVariance; +} + +declare class BabelNodeClassPrivateProperty extends BabelNode { + type: "ClassPrivateProperty"; + key: BabelNodePrivateName; + value?: BabelNodeExpression; + decorators?: BabelNodeDecorator[]; + definite?: boolean; + optional?: boolean; + readonly?: boolean; + typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop; + variance?: BabelNodeVariance; +} + +declare class BabelNodeClassPrivateMethod extends BabelNode { + type: "ClassPrivateMethod"; + kind?: "get" | "set" | "method"; + key: BabelNodePrivateName; + params: (BabelNodeFunctionParameter | BabelNodeTSParameterProperty)[]; + body: BabelNodeBlockStatement; + abstract?: boolean; + access?: "public" | "private" | "protected"; + accessibility?: "public" | "private" | "protected"; + async?: boolean; + computed?: boolean; + decorators?: BabelNodeDecorator[]; + generator?: boolean; + optional?: boolean; + override?: boolean; + returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop; + typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop; +} + +declare class BabelNodePrivateName extends BabelNode { + type: "PrivateName"; + id: BabelNodeIdentifier; +} + +declare class BabelNodeStaticBlock extends BabelNode { + type: "StaticBlock"; + body: BabelNodeStatement[]; +} + +declare class BabelNodeImportAttribute extends BabelNode { + type: "ImportAttribute"; + key: BabelNodeIdentifier | BabelNodeStringLiteral; + value: BabelNodeStringLiteral; +} + +declare class BabelNodeAnyTypeAnnotation extends BabelNode { + type: "AnyTypeAnnotation"; +} + +declare class BabelNodeArrayTypeAnnotation extends BabelNode { + type: "ArrayTypeAnnotation"; + elementType: BabelNodeFlowType; +} + +declare class BabelNodeBooleanTypeAnnotation extends BabelNode { + type: "BooleanTypeAnnotation"; +} + +declare class BabelNodeBooleanLiteralTypeAnnotation extends BabelNode { + type: "BooleanLiteralTypeAnnotation"; + value: boolean; +} + +declare class BabelNodeNullLiteralTypeAnnotation extends BabelNode { + type: "NullLiteralTypeAnnotation"; +} + +declare class BabelNodeClassImplements extends BabelNode { + type: "ClassImplements"; + id: BabelNodeIdentifier; + typeParameters?: BabelNodeTypeParameterInstantiation; +} + +declare class BabelNodeDeclareClass extends BabelNode { + type: "DeclareClass"; + id: BabelNodeIdentifier; + typeParameters?: BabelNodeTypeParameterDeclaration; + body: BabelNodeObjectTypeAnnotation; + mixins?: BabelNodeInterfaceExtends[]; +} + +declare class BabelNodeDeclareFunction extends BabelNode { + type: "DeclareFunction"; + id: BabelNodeIdentifier; + predicate?: BabelNodeDeclaredPredicate; +} + +declare class BabelNodeDeclareInterface extends BabelNode { + type: "DeclareInterface"; + id: BabelNodeIdentifier; + typeParameters?: BabelNodeTypeParameterDeclaration; + body: BabelNodeObjectTypeAnnotation; +} + +declare class BabelNodeDeclareModule extends BabelNode { + type: "DeclareModule"; + id: BabelNodeIdentifier | BabelNodeStringLiteral; + body: BabelNodeBlockStatement; + kind?: "CommonJS" | "ES"; +} + +declare class BabelNodeDeclareModuleExports extends BabelNode { + type: "DeclareModuleExports"; + typeAnnotation: BabelNodeTypeAnnotation; +} + +declare class BabelNodeDeclareTypeAlias extends BabelNode { + type: "DeclareTypeAlias"; + id: BabelNodeIdentifier; + typeParameters?: BabelNodeTypeParameterDeclaration; + right: BabelNodeFlowType; +} + +declare class BabelNodeDeclareOpaqueType extends BabelNode { + type: "DeclareOpaqueType"; + id: BabelNodeIdentifier; + typeParameters?: BabelNodeTypeParameterDeclaration; + supertype?: BabelNodeFlowType; + impltype?: BabelNodeFlowType; +} + +declare class BabelNodeDeclareVariable extends BabelNode { + type: "DeclareVariable"; + id: BabelNodeIdentifier; +} + +declare class BabelNodeDeclareExportDeclaration extends BabelNode { + type: "DeclareExportDeclaration"; + declaration?: BabelNodeFlow; + specifiers?: (BabelNodeExportSpecifier | BabelNodeExportNamespaceSpecifier)[]; + source?: BabelNodeStringLiteral; + attributes?: BabelNodeImportAttribute[]; + assertions?: BabelNodeImportAttribute[]; +} + +declare class BabelNodeDeclareExportAllDeclaration extends BabelNode { + type: "DeclareExportAllDeclaration"; + source: BabelNodeStringLiteral; + attributes?: BabelNodeImportAttribute[]; + assertions?: BabelNodeImportAttribute[]; + exportKind?: "type" | "value"; +} + +declare class BabelNodeDeclaredPredicate extends BabelNode { + type: "DeclaredPredicate"; + value: BabelNodeFlow; +} + +declare class BabelNodeExistsTypeAnnotation extends BabelNode { + type: "ExistsTypeAnnotation"; +} + +declare class BabelNodeFunctionTypeAnnotation extends BabelNode { + type: "FunctionTypeAnnotation"; + typeParameters?: BabelNodeTypeParameterDeclaration; + params: BabelNodeFunctionTypeParam[]; + rest?: BabelNodeFunctionTypeParam; + returnType: BabelNodeFlowType; +} + +declare class BabelNodeFunctionTypeParam extends BabelNode { + type: "FunctionTypeParam"; + name?: BabelNodeIdentifier; + typeAnnotation: BabelNodeFlowType; + optional?: boolean; +} + +declare class BabelNodeGenericTypeAnnotation extends BabelNode { + type: "GenericTypeAnnotation"; + id: BabelNodeIdentifier | BabelNodeQualifiedTypeIdentifier; + typeParameters?: BabelNodeTypeParameterInstantiation; +} + +declare class BabelNodeInferredPredicate extends BabelNode { + type: "InferredPredicate"; +} + +declare class BabelNodeInterfaceExtends extends BabelNode { + type: "InterfaceExtends"; + id: BabelNodeIdentifier | BabelNodeQualifiedTypeIdentifier; + typeParameters?: BabelNodeTypeParameterInstantiation; +} + +declare class BabelNodeInterfaceDeclaration extends BabelNode { + type: "InterfaceDeclaration"; + id: BabelNodeIdentifier; + typeParameters?: BabelNodeTypeParameterDeclaration; + body: BabelNodeObjectTypeAnnotation; +} + +declare class BabelNodeInterfaceTypeAnnotation extends BabelNode { + type: "InterfaceTypeAnnotation"; + body: BabelNodeObjectTypeAnnotation; +} + +declare class BabelNodeIntersectionTypeAnnotation extends BabelNode { + type: "IntersectionTypeAnnotation"; + types: BabelNodeFlowType[]; +} + +declare class BabelNodeMixedTypeAnnotation extends BabelNode { + type: "MixedTypeAnnotation"; +} + +declare class BabelNodeEmptyTypeAnnotation extends BabelNode { + type: "EmptyTypeAnnotation"; +} + +declare class BabelNodeNullableTypeAnnotation extends BabelNode { + type: "NullableTypeAnnotation"; + typeAnnotation: BabelNodeFlowType; +} + +declare class BabelNodeNumberLiteralTypeAnnotation extends BabelNode { + type: "NumberLiteralTypeAnnotation"; + value: number; +} + +declare class BabelNodeNumberTypeAnnotation extends BabelNode { + type: "NumberTypeAnnotation"; +} + +declare class BabelNodeObjectTypeAnnotation extends BabelNode { + type: "ObjectTypeAnnotation"; + properties: (BabelNodeObjectTypeProperty | BabelNodeObjectTypeSpreadProperty)[]; + indexers?: BabelNodeObjectTypeIndexer[]; + callProperties?: BabelNodeObjectTypeCallProperty[]; + internalSlots?: BabelNodeObjectTypeInternalSlot[]; + exact?: boolean; + inexact?: boolean; +} + +declare class BabelNodeObjectTypeInternalSlot extends BabelNode { + type: "ObjectTypeInternalSlot"; + id: BabelNodeIdentifier; + value: BabelNodeFlowType; + optional: boolean; + method: boolean; +} + +declare class BabelNodeObjectTypeCallProperty extends BabelNode { + type: "ObjectTypeCallProperty"; + value: BabelNodeFlowType; +} + +declare class BabelNodeObjectTypeIndexer extends BabelNode { + type: "ObjectTypeIndexer"; + id?: BabelNodeIdentifier; + key: BabelNodeFlowType; + value: BabelNodeFlowType; + variance?: BabelNodeVariance; +} + +declare class BabelNodeObjectTypeProperty extends BabelNode { + type: "ObjectTypeProperty"; + key: BabelNodeIdentifier | BabelNodeStringLiteral; + value: BabelNodeFlowType; + variance?: BabelNodeVariance; + kind: "init" | "get" | "set"; + method: boolean; + optional: boolean; + proto: boolean; +} + +declare class BabelNodeObjectTypeSpreadProperty extends BabelNode { + type: "ObjectTypeSpreadProperty"; + argument: BabelNodeFlowType; +} + +declare class BabelNodeOpaqueType extends BabelNode { + type: "OpaqueType"; + id: BabelNodeIdentifier; + typeParameters?: BabelNodeTypeParameterDeclaration; + supertype?: BabelNodeFlowType; + impltype: BabelNodeFlowType; +} + +declare class BabelNodeQualifiedTypeIdentifier extends BabelNode { + type: "QualifiedTypeIdentifier"; + id: BabelNodeIdentifier; + qualification: BabelNodeIdentifier | BabelNodeQualifiedTypeIdentifier; +} + +declare class BabelNodeStringLiteralTypeAnnotation extends BabelNode { + type: "StringLiteralTypeAnnotation"; + value: string; +} + +declare class BabelNodeStringTypeAnnotation extends BabelNode { + type: "StringTypeAnnotation"; +} + +declare class BabelNodeSymbolTypeAnnotation extends BabelNode { + type: "SymbolTypeAnnotation"; +} + +declare class BabelNodeThisTypeAnnotation extends BabelNode { + type: "ThisTypeAnnotation"; +} + +declare class BabelNodeTupleTypeAnnotation extends BabelNode { + type: "TupleTypeAnnotation"; + types: BabelNodeFlowType[]; +} + +declare class BabelNodeTypeofTypeAnnotation extends BabelNode { + type: "TypeofTypeAnnotation"; + argument: BabelNodeFlowType; +} + +declare class BabelNodeTypeAlias extends BabelNode { + type: "TypeAlias"; + id: BabelNodeIdentifier; + typeParameters?: BabelNodeTypeParameterDeclaration; + right: BabelNodeFlowType; +} + +declare class BabelNodeTypeAnnotation extends BabelNode { + type: "TypeAnnotation"; + typeAnnotation: BabelNodeFlowType; +} + +declare class BabelNodeTypeCastExpression extends BabelNode { + type: "TypeCastExpression"; + expression: BabelNodeExpression; + typeAnnotation: BabelNodeTypeAnnotation; +} + +declare class BabelNodeTypeParameter extends BabelNode { + type: "TypeParameter"; + bound?: BabelNodeTypeAnnotation; + variance?: BabelNodeVariance; + name: string; +} + +declare class BabelNodeTypeParameterDeclaration extends BabelNode { + type: "TypeParameterDeclaration"; + params: BabelNodeTypeParameter[]; +} + +declare class BabelNodeTypeParameterInstantiation extends BabelNode { + type: "TypeParameterInstantiation"; + params: BabelNodeFlowType[]; +} + +declare class BabelNodeUnionTypeAnnotation extends BabelNode { + type: "UnionTypeAnnotation"; + types: BabelNodeFlowType[]; +} + +declare class BabelNodeVariance extends BabelNode { + type: "Variance"; + kind: "minus" | "plus"; +} + +declare class BabelNodeVoidTypeAnnotation extends BabelNode { + type: "VoidTypeAnnotation"; +} + +declare class BabelNodeEnumDeclaration extends BabelNode { + type: "EnumDeclaration"; + id: BabelNodeIdentifier; + body: BabelNodeEnumBooleanBody | BabelNodeEnumNumberBody | BabelNodeEnumStringBody | BabelNodeEnumSymbolBody; +} + +declare class BabelNodeEnumBooleanBody extends BabelNode { + type: "EnumBooleanBody"; + members: BabelNodeEnumBooleanMember[]; + explicitType: boolean; + hasUnknownMembers: boolean; +} + +declare class BabelNodeEnumNumberBody extends BabelNode { + type: "EnumNumberBody"; + members: BabelNodeEnumNumberMember[]; + explicitType: boolean; + hasUnknownMembers: boolean; +} + +declare class BabelNodeEnumStringBody extends BabelNode { + type: "EnumStringBody"; + members: (BabelNodeEnumStringMember | BabelNodeEnumDefaultedMember)[]; + explicitType: boolean; + hasUnknownMembers: boolean; +} + +declare class BabelNodeEnumSymbolBody extends BabelNode { + type: "EnumSymbolBody"; + members: BabelNodeEnumDefaultedMember[]; + hasUnknownMembers: boolean; +} + +declare class BabelNodeEnumBooleanMember extends BabelNode { + type: "EnumBooleanMember"; + id: BabelNodeIdentifier; + init: BabelNodeBooleanLiteral; +} + +declare class BabelNodeEnumNumberMember extends BabelNode { + type: "EnumNumberMember"; + id: BabelNodeIdentifier; + init: BabelNodeNumericLiteral; +} + +declare class BabelNodeEnumStringMember extends BabelNode { + type: "EnumStringMember"; + id: BabelNodeIdentifier; + init: BabelNodeStringLiteral; +} + +declare class BabelNodeEnumDefaultedMember extends BabelNode { + type: "EnumDefaultedMember"; + id: BabelNodeIdentifier; +} + +declare class BabelNodeIndexedAccessType extends BabelNode { + type: "IndexedAccessType"; + objectType: BabelNodeFlowType; + indexType: BabelNodeFlowType; +} + +declare class BabelNodeOptionalIndexedAccessType extends BabelNode { + type: "OptionalIndexedAccessType"; + objectType: BabelNodeFlowType; + indexType: BabelNodeFlowType; + optional: boolean; +} + +declare class BabelNodeJSXAttribute extends BabelNode { + type: "JSXAttribute"; + name: BabelNodeJSXIdentifier | BabelNodeJSXNamespacedName; + value?: BabelNodeJSXElement | BabelNodeJSXFragment | BabelNodeStringLiteral | BabelNodeJSXExpressionContainer; +} + +declare class BabelNodeJSXClosingElement extends BabelNode { + type: "JSXClosingElement"; + name: BabelNodeJSXIdentifier | BabelNodeJSXMemberExpression | BabelNodeJSXNamespacedName; +} + +declare class BabelNodeJSXElement extends BabelNode { + type: "JSXElement"; + openingElement: BabelNodeJSXOpeningElement; + closingElement?: BabelNodeJSXClosingElement; + children: (BabelNodeJSXText | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXElement | BabelNodeJSXFragment)[]; + selfClosing?: boolean; +} + +declare class BabelNodeJSXEmptyExpression extends BabelNode { + type: "JSXEmptyExpression"; +} + +declare class BabelNodeJSXExpressionContainer extends BabelNode { + type: "JSXExpressionContainer"; + expression: BabelNodeExpression | BabelNodeJSXEmptyExpression; +} + +declare class BabelNodeJSXSpreadChild extends BabelNode { + type: "JSXSpreadChild"; + expression: BabelNodeExpression; +} + +declare class BabelNodeJSXIdentifier extends BabelNode { + type: "JSXIdentifier"; + name: string; +} + +declare class BabelNodeJSXMemberExpression extends BabelNode { + type: "JSXMemberExpression"; + object: BabelNodeJSXMemberExpression | BabelNodeJSXIdentifier; + property: BabelNodeJSXIdentifier; +} + +declare class BabelNodeJSXNamespacedName extends BabelNode { + type: "JSXNamespacedName"; + namespace: BabelNodeJSXIdentifier; + name: BabelNodeJSXIdentifier; +} + +declare class BabelNodeJSXOpeningElement extends BabelNode { + type: "JSXOpeningElement"; + name: BabelNodeJSXIdentifier | BabelNodeJSXMemberExpression | BabelNodeJSXNamespacedName; + attributes: (BabelNodeJSXAttribute | BabelNodeJSXSpreadAttribute)[]; + selfClosing?: boolean; + typeArguments?: BabelNodeTypeParameterInstantiation; + typeParameters?: BabelNodeTSTypeParameterInstantiation; +} + +declare class BabelNodeJSXSpreadAttribute extends BabelNode { + type: "JSXSpreadAttribute"; + argument: BabelNodeExpression; +} + +declare class BabelNodeJSXText extends BabelNode { + type: "JSXText"; + value: string; +} + +declare class BabelNodeJSXFragment extends BabelNode { + type: "JSXFragment"; + openingFragment: BabelNodeJSXOpeningFragment; + closingFragment: BabelNodeJSXClosingFragment; + children: (BabelNodeJSXText | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXElement | BabelNodeJSXFragment)[]; +} + +declare class BabelNodeJSXOpeningFragment extends BabelNode { + type: "JSXOpeningFragment"; +} + +declare class BabelNodeJSXClosingFragment extends BabelNode { + type: "JSXClosingFragment"; +} + +declare class BabelNodeNoop extends BabelNode { + type: "Noop"; +} + +declare class BabelNodePlaceholder extends BabelNode { + type: "Placeholder"; + expectedNode: "Identifier" | "StringLiteral" | "Expression" | "Statement" | "Declaration" | "BlockStatement" | "ClassBody" | "Pattern"; + name: BabelNodeIdentifier; + decorators?: BabelNodeDecorator[]; + optional?: boolean; + typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop; +} + +declare class BabelNodeV8IntrinsicIdentifier extends BabelNode { + type: "V8IntrinsicIdentifier"; + name: string; +} + +declare class BabelNodeArgumentPlaceholder extends BabelNode { + type: "ArgumentPlaceholder"; +} + +declare class BabelNodeBindExpression extends BabelNode { + type: "BindExpression"; + object: BabelNodeExpression; + callee: BabelNodeExpression; +} + +declare class BabelNodeDecorator extends BabelNode { + type: "Decorator"; + expression: BabelNodeExpression; +} + +declare class BabelNodeDoExpression extends BabelNode { + type: "DoExpression"; + body: BabelNodeBlockStatement; + async?: boolean; +} + +declare class BabelNodeExportDefaultSpecifier extends BabelNode { + type: "ExportDefaultSpecifier"; + exported: BabelNodeIdentifier; +} + +declare class BabelNodeRecordExpression extends BabelNode { + type: "RecordExpression"; + properties: (BabelNodeObjectProperty | BabelNodeSpreadElement)[]; +} + +declare class BabelNodeTupleExpression extends BabelNode { + type: "TupleExpression"; + elements?: (BabelNodeExpression | BabelNodeSpreadElement)[]; +} + +declare class BabelNodeDecimalLiteral extends BabelNode { + type: "DecimalLiteral"; + value: string; +} + +declare class BabelNodeModuleExpression extends BabelNode { + type: "ModuleExpression"; + body: BabelNodeProgram; +} + +declare class BabelNodeTopicReference extends BabelNode { + type: "TopicReference"; +} + +declare class BabelNodePipelineTopicExpression extends BabelNode { + type: "PipelineTopicExpression"; + expression: BabelNodeExpression; +} + +declare class BabelNodePipelineBareFunction extends BabelNode { + type: "PipelineBareFunction"; + callee: BabelNodeExpression; +} + +declare class BabelNodePipelinePrimaryTopicReference extends BabelNode { + type: "PipelinePrimaryTopicReference"; +} + +declare class BabelNodeVoidPattern extends BabelNode { + type: "VoidPattern"; +} + +declare class BabelNodeTSParameterProperty extends BabelNode { + type: "TSParameterProperty"; + parameter: BabelNodeIdentifier | BabelNodeAssignmentPattern; + accessibility?: "public" | "private" | "protected"; + decorators?: BabelNodeDecorator[]; + override?: boolean; + readonly?: boolean; +} + +declare class BabelNodeTSDeclareFunction extends BabelNode { + type: "TSDeclareFunction"; + id?: BabelNodeIdentifier; + typeParameters?: BabelNodeTSTypeParameterDeclaration | BabelNodeNoop; + params: BabelNodeFunctionParameter[]; + returnType?: BabelNodeTSTypeAnnotation | BabelNodeNoop; + async?: boolean; + declare?: boolean; + generator?: boolean; +} + +declare class BabelNodeTSDeclareMethod extends BabelNode { + type: "TSDeclareMethod"; + decorators?: BabelNodeDecorator[]; + key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression; + typeParameters?: BabelNodeTSTypeParameterDeclaration | BabelNodeNoop; + params: (BabelNodeFunctionParameter | BabelNodeTSParameterProperty)[]; + returnType?: BabelNodeTSTypeAnnotation | BabelNodeNoop; + abstract?: boolean; + access?: "public" | "private" | "protected"; + accessibility?: "public" | "private" | "protected"; + async?: boolean; + computed?: boolean; + generator?: boolean; + kind?: "get" | "set" | "method" | "constructor"; + optional?: boolean; + override?: boolean; +} + +declare class BabelNodeTSQualifiedName extends BabelNode { + type: "TSQualifiedName"; + left: BabelNodeTSEntityName; + right: BabelNodeIdentifier; +} + +declare class BabelNodeTSCallSignatureDeclaration extends BabelNode { + type: "TSCallSignatureDeclaration"; + typeParameters?: BabelNodeTSTypeParameterDeclaration; + parameters: (BabelNodeArrayPattern | BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeRestElement)[]; + typeAnnotation?: BabelNodeTSTypeAnnotation; +} + +declare class BabelNodeTSConstructSignatureDeclaration extends BabelNode { + type: "TSConstructSignatureDeclaration"; + typeParameters?: BabelNodeTSTypeParameterDeclaration; + parameters: (BabelNodeArrayPattern | BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeRestElement)[]; + typeAnnotation?: BabelNodeTSTypeAnnotation; +} + +declare class BabelNodeTSPropertySignature extends BabelNode { + type: "TSPropertySignature"; + key: BabelNodeExpression; + typeAnnotation?: BabelNodeTSTypeAnnotation; + computed?: boolean; + kind?: "get" | "set"; + optional?: boolean; + readonly?: boolean; +} + +declare class BabelNodeTSMethodSignature extends BabelNode { + type: "TSMethodSignature"; + key: BabelNodeExpression; + typeParameters?: BabelNodeTSTypeParameterDeclaration; + parameters: (BabelNodeArrayPattern | BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeRestElement)[]; + typeAnnotation?: BabelNodeTSTypeAnnotation; + computed?: boolean; + kind: "method" | "get" | "set"; + optional?: boolean; +} + +declare class BabelNodeTSIndexSignature extends BabelNode { + type: "TSIndexSignature"; + parameters: BabelNodeIdentifier[]; + typeAnnotation?: BabelNodeTSTypeAnnotation; + readonly?: boolean; +} + +declare class BabelNodeTSAnyKeyword extends BabelNode { + type: "TSAnyKeyword"; +} + +declare class BabelNodeTSBooleanKeyword extends BabelNode { + type: "TSBooleanKeyword"; +} + +declare class BabelNodeTSBigIntKeyword extends BabelNode { + type: "TSBigIntKeyword"; +} + +declare class BabelNodeTSIntrinsicKeyword extends BabelNode { + type: "TSIntrinsicKeyword"; +} + +declare class BabelNodeTSNeverKeyword extends BabelNode { + type: "TSNeverKeyword"; +} + +declare class BabelNodeTSNullKeyword extends BabelNode { + type: "TSNullKeyword"; +} + +declare class BabelNodeTSNumberKeyword extends BabelNode { + type: "TSNumberKeyword"; +} + +declare class BabelNodeTSObjectKeyword extends BabelNode { + type: "TSObjectKeyword"; +} + +declare class BabelNodeTSStringKeyword extends BabelNode { + type: "TSStringKeyword"; +} + +declare class BabelNodeTSSymbolKeyword extends BabelNode { + type: "TSSymbolKeyword"; +} + +declare class BabelNodeTSUndefinedKeyword extends BabelNode { + type: "TSUndefinedKeyword"; +} + +declare class BabelNodeTSUnknownKeyword extends BabelNode { + type: "TSUnknownKeyword"; +} + +declare class BabelNodeTSVoidKeyword extends BabelNode { + type: "TSVoidKeyword"; +} + +declare class BabelNodeTSThisType extends BabelNode { + type: "TSThisType"; +} + +declare class BabelNodeTSFunctionType extends BabelNode { + type: "TSFunctionType"; + typeParameters?: BabelNodeTSTypeParameterDeclaration; + parameters: (BabelNodeArrayPattern | BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeRestElement)[]; + typeAnnotation?: BabelNodeTSTypeAnnotation; +} + +declare class BabelNodeTSConstructorType extends BabelNode { + type: "TSConstructorType"; + typeParameters?: BabelNodeTSTypeParameterDeclaration; + parameters: (BabelNodeArrayPattern | BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeRestElement)[]; + typeAnnotation?: BabelNodeTSTypeAnnotation; + abstract?: boolean; +} + +declare class BabelNodeTSTypeReference extends BabelNode { + type: "TSTypeReference"; + typeName: BabelNodeTSEntityName; + typeParameters?: BabelNodeTSTypeParameterInstantiation; +} + +declare class BabelNodeTSTypePredicate extends BabelNode { + type: "TSTypePredicate"; + parameterName: BabelNodeIdentifier | BabelNodeTSThisType; + typeAnnotation?: BabelNodeTSTypeAnnotation; + asserts?: boolean; +} + +declare class BabelNodeTSTypeQuery extends BabelNode { + type: "TSTypeQuery"; + exprName: BabelNodeTSEntityName | BabelNodeTSImportType; + typeParameters?: BabelNodeTSTypeParameterInstantiation; +} + +declare class BabelNodeTSTypeLiteral extends BabelNode { + type: "TSTypeLiteral"; + members: BabelNodeTSTypeElement[]; +} + +declare class BabelNodeTSArrayType extends BabelNode { + type: "TSArrayType"; + elementType: BabelNodeTSType; +} + +declare class BabelNodeTSTupleType extends BabelNode { + type: "TSTupleType"; + elementTypes: (BabelNodeTSType | BabelNodeTSNamedTupleMember)[]; +} + +declare class BabelNodeTSOptionalType extends BabelNode { + type: "TSOptionalType"; + typeAnnotation: BabelNodeTSType; +} + +declare class BabelNodeTSRestType extends BabelNode { + type: "TSRestType"; + typeAnnotation: BabelNodeTSType; +} + +declare class BabelNodeTSNamedTupleMember extends BabelNode { + type: "TSNamedTupleMember"; + label: BabelNodeIdentifier; + elementType: BabelNodeTSType; + optional?: boolean; +} + +declare class BabelNodeTSUnionType extends BabelNode { + type: "TSUnionType"; + types: BabelNodeTSType[]; +} + +declare class BabelNodeTSIntersectionType extends BabelNode { + type: "TSIntersectionType"; + types: BabelNodeTSType[]; +} + +declare class BabelNodeTSConditionalType extends BabelNode { + type: "TSConditionalType"; + checkType: BabelNodeTSType; + extendsType: BabelNodeTSType; + trueType: BabelNodeTSType; + falseType: BabelNodeTSType; +} + +declare class BabelNodeTSInferType extends BabelNode { + type: "TSInferType"; + typeParameter: BabelNodeTSTypeParameter; +} + +declare class BabelNodeTSParenthesizedType extends BabelNode { + type: "TSParenthesizedType"; + typeAnnotation: BabelNodeTSType; +} + +declare class BabelNodeTSTypeOperator extends BabelNode { + type: "TSTypeOperator"; + typeAnnotation: BabelNodeTSType; + operator?: string; +} + +declare class BabelNodeTSIndexedAccessType extends BabelNode { + type: "TSIndexedAccessType"; + objectType: BabelNodeTSType; + indexType: BabelNodeTSType; +} + +declare class BabelNodeTSMappedType extends BabelNode { + type: "TSMappedType"; + typeParameter: BabelNodeTSTypeParameter; + typeAnnotation?: BabelNodeTSType; + nameType?: BabelNodeTSType; + optional?: true | false | "+" | "-"; + readonly?: true | false | "+" | "-"; +} + +declare class BabelNodeTSTemplateLiteralType extends BabelNode { + type: "TSTemplateLiteralType"; + quasis: BabelNodeTemplateElement[]; + types: BabelNodeTSType[]; +} + +declare class BabelNodeTSLiteralType extends BabelNode { + type: "TSLiteralType"; + literal: BabelNodeNumericLiteral | BabelNodeStringLiteral | BabelNodeBooleanLiteral | BabelNodeBigIntLiteral | BabelNodeTemplateLiteral | BabelNodeUnaryExpression; +} + +declare class BabelNodeTSExpressionWithTypeArguments extends BabelNode { + type: "TSExpressionWithTypeArguments"; + expression: BabelNodeTSEntityName; + typeParameters?: BabelNodeTSTypeParameterInstantiation; +} + +declare class BabelNodeTSInterfaceDeclaration extends BabelNode { + type: "TSInterfaceDeclaration"; + id: BabelNodeIdentifier; + typeParameters?: BabelNodeTSTypeParameterDeclaration; + body: BabelNodeTSInterfaceBody; + declare?: boolean; +} + +declare class BabelNodeTSInterfaceBody extends BabelNode { + type: "TSInterfaceBody"; + body: BabelNodeTSTypeElement[]; +} + +declare class BabelNodeTSTypeAliasDeclaration extends BabelNode { + type: "TSTypeAliasDeclaration"; + id: BabelNodeIdentifier; + typeParameters?: BabelNodeTSTypeParameterDeclaration; + typeAnnotation: BabelNodeTSType; + declare?: boolean; +} + +declare class BabelNodeTSInstantiationExpression extends BabelNode { + type: "TSInstantiationExpression"; + expression: BabelNodeExpression; + typeParameters?: BabelNodeTSTypeParameterInstantiation; +} + +declare class BabelNodeTSAsExpression extends BabelNode { + type: "TSAsExpression"; + expression: BabelNodeExpression; + typeAnnotation: BabelNodeTSType; +} + +declare class BabelNodeTSSatisfiesExpression extends BabelNode { + type: "TSSatisfiesExpression"; + expression: BabelNodeExpression; + typeAnnotation: BabelNodeTSType; +} + +declare class BabelNodeTSTypeAssertion extends BabelNode { + type: "TSTypeAssertion"; + typeAnnotation: BabelNodeTSType; + expression: BabelNodeExpression; +} + +declare class BabelNodeTSEnumBody extends BabelNode { + type: "TSEnumBody"; + members: BabelNodeTSEnumMember[]; +} + +declare class BabelNodeTSEnumDeclaration extends BabelNode { + type: "TSEnumDeclaration"; + id: BabelNodeIdentifier; + members: BabelNodeTSEnumMember[]; + body?: BabelNodeTSEnumBody; + declare?: boolean; + initializer?: BabelNodeExpression; +} + +declare class BabelNodeTSEnumMember extends BabelNode { + type: "TSEnumMember"; + id: BabelNodeIdentifier | BabelNodeStringLiteral; + initializer?: BabelNodeExpression; +} + +declare class BabelNodeTSModuleDeclaration extends BabelNode { + type: "TSModuleDeclaration"; + id: BabelNodeIdentifier | BabelNodeStringLiteral; + body: BabelNodeTSModuleBlock | BabelNodeTSModuleDeclaration; + declare?: boolean; + global?: boolean; + kind: "global" | "module" | "namespace"; +} + +declare class BabelNodeTSModuleBlock extends BabelNode { + type: "TSModuleBlock"; + body: BabelNodeStatement[]; +} + +declare class BabelNodeTSImportType extends BabelNode { + type: "TSImportType"; + argument: BabelNodeStringLiteral; + qualifier?: BabelNodeTSEntityName; + typeParameters?: BabelNodeTSTypeParameterInstantiation; + options?: BabelNodeObjectExpression; +} + +declare class BabelNodeTSImportEqualsDeclaration extends BabelNode { + type: "TSImportEqualsDeclaration"; + id: BabelNodeIdentifier; + moduleReference: BabelNodeTSEntityName | BabelNodeTSExternalModuleReference; + importKind?: "type" | "value"; + isExport: boolean; +} + +declare class BabelNodeTSExternalModuleReference extends BabelNode { + type: "TSExternalModuleReference"; + expression: BabelNodeStringLiteral; +} + +declare class BabelNodeTSNonNullExpression extends BabelNode { + type: "TSNonNullExpression"; + expression: BabelNodeExpression; +} + +declare class BabelNodeTSExportAssignment extends BabelNode { + type: "TSExportAssignment"; + expression: BabelNodeExpression; +} + +declare class BabelNodeTSNamespaceExportDeclaration extends BabelNode { + type: "TSNamespaceExportDeclaration"; + id: BabelNodeIdentifier; +} + +declare class BabelNodeTSTypeAnnotation extends BabelNode { + type: "TSTypeAnnotation"; + typeAnnotation: BabelNodeTSType; +} + +declare class BabelNodeTSTypeParameterInstantiation extends BabelNode { + type: "TSTypeParameterInstantiation"; + params: BabelNodeTSType[]; +} + +declare class BabelNodeTSTypeParameterDeclaration extends BabelNode { + type: "TSTypeParameterDeclaration"; + params: BabelNodeTSTypeParameter[]; +} + +declare class BabelNodeTSTypeParameter extends BabelNode { + type: "TSTypeParameter"; + constraint?: BabelNodeTSType; + name: string; + out?: boolean; +} + +type BabelNodeStandardized = BabelNodeArrayExpression | BabelNodeAssignmentExpression | BabelNodeBinaryExpression | BabelNodeInterpreterDirective | BabelNodeDirective | BabelNodeDirectiveLiteral | BabelNodeBlockStatement | BabelNodeBreakStatement | BabelNodeCallExpression | BabelNodeCatchClause | BabelNodeConditionalExpression | BabelNodeContinueStatement | BabelNodeDebuggerStatement | BabelNodeDoWhileStatement | BabelNodeEmptyStatement | BabelNodeExpressionStatement | BabelNodeFile | BabelNodeForInStatement | BabelNodeForStatement | BabelNodeFunctionDeclaration | BabelNodeFunctionExpression | BabelNodeIdentifier | BabelNodeIfStatement | BabelNodeLabeledStatement | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeNullLiteral | BabelNodeBooleanLiteral | BabelNodeRegExpLiteral | BabelNodeLogicalExpression | BabelNodeMemberExpression | BabelNodeNewExpression | BabelNodeProgram | BabelNodeObjectExpression | BabelNodeObjectMethod | BabelNodeObjectProperty | BabelNodeRestElement | BabelNodeReturnStatement | BabelNodeSequenceExpression | BabelNodeParenthesizedExpression | BabelNodeSwitchCase | BabelNodeSwitchStatement | BabelNodeThisExpression | BabelNodeThrowStatement | BabelNodeTryStatement | BabelNodeUnaryExpression | BabelNodeUpdateExpression | BabelNodeVariableDeclaration | BabelNodeVariableDeclarator | BabelNodeWhileStatement | BabelNodeWithStatement | BabelNodeAssignmentPattern | BabelNodeArrayPattern | BabelNodeArrowFunctionExpression | BabelNodeClassBody | BabelNodeClassExpression | BabelNodeClassDeclaration | BabelNodeExportAllDeclaration | BabelNodeExportDefaultDeclaration | BabelNodeExportNamedDeclaration | BabelNodeExportSpecifier | BabelNodeForOfStatement | BabelNodeImportDeclaration | BabelNodeImportDefaultSpecifier | BabelNodeImportNamespaceSpecifier | BabelNodeImportSpecifier | BabelNodeImportExpression | BabelNodeMetaProperty | BabelNodeClassMethod | BabelNodeObjectPattern | BabelNodeSpreadElement | BabelNodeSuper | BabelNodeTaggedTemplateExpression | BabelNodeTemplateElement | BabelNodeTemplateLiteral | BabelNodeYieldExpression | BabelNodeAwaitExpression | BabelNodeImport | BabelNodeBigIntLiteral | BabelNodeExportNamespaceSpecifier | BabelNodeOptionalMemberExpression | BabelNodeOptionalCallExpression | BabelNodeClassProperty | BabelNodeClassAccessorProperty | BabelNodeClassPrivateProperty | BabelNodeClassPrivateMethod | BabelNodePrivateName | BabelNodeStaticBlock | BabelNodeImportAttribute; +type BabelNodeExpression = BabelNodeArrayExpression | BabelNodeAssignmentExpression | BabelNodeBinaryExpression | BabelNodeCallExpression | BabelNodeConditionalExpression | BabelNodeFunctionExpression | BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeNullLiteral | BabelNodeBooleanLiteral | BabelNodeRegExpLiteral | BabelNodeLogicalExpression | BabelNodeMemberExpression | BabelNodeNewExpression | BabelNodeObjectExpression | BabelNodeSequenceExpression | BabelNodeParenthesizedExpression | BabelNodeThisExpression | BabelNodeUnaryExpression | BabelNodeUpdateExpression | BabelNodeArrowFunctionExpression | BabelNodeClassExpression | BabelNodeImportExpression | BabelNodeMetaProperty | BabelNodeSuper | BabelNodeTaggedTemplateExpression | BabelNodeTemplateLiteral | BabelNodeYieldExpression | BabelNodeAwaitExpression | BabelNodeImport | BabelNodeBigIntLiteral | BabelNodeOptionalMemberExpression | BabelNodeOptionalCallExpression | BabelNodeTypeCastExpression | BabelNodeJSXElement | BabelNodeJSXFragment | BabelNodeBindExpression | BabelNodeDoExpression | BabelNodeRecordExpression | BabelNodeTupleExpression | BabelNodeDecimalLiteral | BabelNodeModuleExpression | BabelNodeTopicReference | BabelNodePipelineTopicExpression | BabelNodePipelineBareFunction | BabelNodePipelinePrimaryTopicReference | BabelNodeTSInstantiationExpression | BabelNodeTSAsExpression | BabelNodeTSSatisfiesExpression | BabelNodeTSTypeAssertion | BabelNodeTSNonNullExpression; +type BabelNodeBinary = BabelNodeBinaryExpression | BabelNodeLogicalExpression; +type BabelNodeScopable = BabelNodeBlockStatement | BabelNodeCatchClause | BabelNodeDoWhileStatement | BabelNodeForInStatement | BabelNodeForStatement | BabelNodeFunctionDeclaration | BabelNodeFunctionExpression | BabelNodeProgram | BabelNodeObjectMethod | BabelNodeSwitchStatement | BabelNodeWhileStatement | BabelNodeArrowFunctionExpression | BabelNodeClassExpression | BabelNodeClassDeclaration | BabelNodeForOfStatement | BabelNodeClassMethod | BabelNodeClassPrivateMethod | BabelNodeStaticBlock | BabelNodeTSModuleBlock; +type BabelNodeBlockParent = BabelNodeBlockStatement | BabelNodeCatchClause | BabelNodeDoWhileStatement | BabelNodeForInStatement | BabelNodeForStatement | BabelNodeFunctionDeclaration | BabelNodeFunctionExpression | BabelNodeProgram | BabelNodeObjectMethod | BabelNodeSwitchStatement | BabelNodeWhileStatement | BabelNodeArrowFunctionExpression | BabelNodeForOfStatement | BabelNodeClassMethod | BabelNodeClassPrivateMethod | BabelNodeStaticBlock | BabelNodeTSModuleBlock; +type BabelNodeBlock = BabelNodeBlockStatement | BabelNodeProgram | BabelNodeTSModuleBlock; +type BabelNodeStatement = BabelNodeBlockStatement | BabelNodeBreakStatement | BabelNodeContinueStatement | BabelNodeDebuggerStatement | BabelNodeDoWhileStatement | BabelNodeEmptyStatement | BabelNodeExpressionStatement | BabelNodeForInStatement | BabelNodeForStatement | BabelNodeFunctionDeclaration | BabelNodeIfStatement | BabelNodeLabeledStatement | BabelNodeReturnStatement | BabelNodeSwitchStatement | BabelNodeThrowStatement | BabelNodeTryStatement | BabelNodeVariableDeclaration | BabelNodeWhileStatement | BabelNodeWithStatement | BabelNodeClassDeclaration | BabelNodeExportAllDeclaration | BabelNodeExportDefaultDeclaration | BabelNodeExportNamedDeclaration | BabelNodeForOfStatement | BabelNodeImportDeclaration | BabelNodeDeclareClass | BabelNodeDeclareFunction | BabelNodeDeclareInterface | BabelNodeDeclareModule | BabelNodeDeclareModuleExports | BabelNodeDeclareTypeAlias | BabelNodeDeclareOpaqueType | BabelNodeDeclareVariable | BabelNodeDeclareExportDeclaration | BabelNodeDeclareExportAllDeclaration | BabelNodeInterfaceDeclaration | BabelNodeOpaqueType | BabelNodeTypeAlias | BabelNodeEnumDeclaration | BabelNodeTSDeclareFunction | BabelNodeTSInterfaceDeclaration | BabelNodeTSTypeAliasDeclaration | BabelNodeTSEnumDeclaration | BabelNodeTSModuleDeclaration | BabelNodeTSImportEqualsDeclaration | BabelNodeTSExportAssignment | BabelNodeTSNamespaceExportDeclaration; +type BabelNodeTerminatorless = BabelNodeBreakStatement | BabelNodeContinueStatement | BabelNodeReturnStatement | BabelNodeThrowStatement | BabelNodeYieldExpression | BabelNodeAwaitExpression; +type BabelNodeCompletionStatement = BabelNodeBreakStatement | BabelNodeContinueStatement | BabelNodeReturnStatement | BabelNodeThrowStatement; +type BabelNodeConditional = BabelNodeConditionalExpression | BabelNodeIfStatement; +type BabelNodeLoop = BabelNodeDoWhileStatement | BabelNodeForInStatement | BabelNodeForStatement | BabelNodeWhileStatement | BabelNodeForOfStatement; +type BabelNodeWhile = BabelNodeDoWhileStatement | BabelNodeWhileStatement; +type BabelNodeExpressionWrapper = BabelNodeExpressionStatement | BabelNodeParenthesizedExpression | BabelNodeTypeCastExpression; +type BabelNodeFor = BabelNodeForInStatement | BabelNodeForStatement | BabelNodeForOfStatement; +type BabelNodeForXStatement = BabelNodeForInStatement | BabelNodeForOfStatement; +type BabelNodeFunction = BabelNodeFunctionDeclaration | BabelNodeFunctionExpression | BabelNodeObjectMethod | BabelNodeArrowFunctionExpression | BabelNodeClassMethod | BabelNodeClassPrivateMethod; +type BabelNodeFunctionParent = BabelNodeFunctionDeclaration | BabelNodeFunctionExpression | BabelNodeObjectMethod | BabelNodeArrowFunctionExpression | BabelNodeClassMethod | BabelNodeClassPrivateMethod | BabelNodeStaticBlock | BabelNodeTSModuleBlock; +type BabelNodePureish = BabelNodeFunctionDeclaration | BabelNodeFunctionExpression | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeNullLiteral | BabelNodeBooleanLiteral | BabelNodeRegExpLiteral | BabelNodeArrowFunctionExpression | BabelNodeBigIntLiteral | BabelNodeDecimalLiteral; +type BabelNodeDeclaration = BabelNodeFunctionDeclaration | BabelNodeVariableDeclaration | BabelNodeClassDeclaration | BabelNodeExportAllDeclaration | BabelNodeExportDefaultDeclaration | BabelNodeExportNamedDeclaration | BabelNodeImportDeclaration | BabelNodeDeclareClass | BabelNodeDeclareFunction | BabelNodeDeclareInterface | BabelNodeDeclareModule | BabelNodeDeclareModuleExports | BabelNodeDeclareTypeAlias | BabelNodeDeclareOpaqueType | BabelNodeDeclareVariable | BabelNodeDeclareExportDeclaration | BabelNodeDeclareExportAllDeclaration | BabelNodeInterfaceDeclaration | BabelNodeOpaqueType | BabelNodeTypeAlias | BabelNodeEnumDeclaration | BabelNodeTSDeclareFunction | BabelNodeTSInterfaceDeclaration | BabelNodeTSTypeAliasDeclaration | BabelNodeTSEnumDeclaration | BabelNodeTSModuleDeclaration | BabelNodeTSImportEqualsDeclaration; +type BabelNodeFunctionParameter = BabelNodeIdentifier | BabelNodeRestElement | BabelNodeAssignmentPattern | BabelNodeArrayPattern | BabelNodeObjectPattern | BabelNodeVoidPattern; +type BabelNodePatternLike = BabelNodeIdentifier | BabelNodeMemberExpression | BabelNodeRestElement | BabelNodeAssignmentPattern | BabelNodeArrayPattern | BabelNodeObjectPattern | BabelNodeVoidPattern | BabelNodeTSAsExpression | BabelNodeTSSatisfiesExpression | BabelNodeTSTypeAssertion | BabelNodeTSNonNullExpression; +type BabelNodeLVal = BabelNodeIdentifier | BabelNodeMemberExpression | BabelNodeRestElement | BabelNodeAssignmentPattern | BabelNodeArrayPattern | BabelNodeObjectPattern | BabelNodeTSParameterProperty | BabelNodeTSAsExpression | BabelNodeTSSatisfiesExpression | BabelNodeTSTypeAssertion | BabelNodeTSNonNullExpression; +type BabelNodeTSEntityName = BabelNodeIdentifier | BabelNodeTSQualifiedName; +type BabelNodeLiteral = BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeNullLiteral | BabelNodeBooleanLiteral | BabelNodeRegExpLiteral | BabelNodeTemplateLiteral | BabelNodeBigIntLiteral | BabelNodeDecimalLiteral; +type BabelNodeImmutable = BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeNullLiteral | BabelNodeBooleanLiteral | BabelNodeBigIntLiteral | BabelNodeJSXAttribute | BabelNodeJSXClosingElement | BabelNodeJSXElement | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXOpeningElement | BabelNodeJSXText | BabelNodeJSXFragment | BabelNodeJSXOpeningFragment | BabelNodeJSXClosingFragment | BabelNodeDecimalLiteral; +type BabelNodeUserWhitespacable = BabelNodeObjectMethod | BabelNodeObjectProperty | BabelNodeObjectTypeInternalSlot | BabelNodeObjectTypeCallProperty | BabelNodeObjectTypeIndexer | BabelNodeObjectTypeProperty | BabelNodeObjectTypeSpreadProperty; +type BabelNodeMethod = BabelNodeObjectMethod | BabelNodeClassMethod | BabelNodeClassPrivateMethod; +type BabelNodeObjectMember = BabelNodeObjectMethod | BabelNodeObjectProperty; +type BabelNodeProperty = BabelNodeObjectProperty | BabelNodeClassProperty | BabelNodeClassAccessorProperty | BabelNodeClassPrivateProperty; +type BabelNodeUnaryLike = BabelNodeUnaryExpression | BabelNodeSpreadElement; +type BabelNodePattern = BabelNodeAssignmentPattern | BabelNodeArrayPattern | BabelNodeObjectPattern | BabelNodeVoidPattern; +type BabelNodeClass = BabelNodeClassExpression | BabelNodeClassDeclaration; +type BabelNodeImportOrExportDeclaration = BabelNodeExportAllDeclaration | BabelNodeExportDefaultDeclaration | BabelNodeExportNamedDeclaration | BabelNodeImportDeclaration; +type BabelNodeExportDeclaration = BabelNodeExportAllDeclaration | BabelNodeExportDefaultDeclaration | BabelNodeExportNamedDeclaration; +type BabelNodeModuleSpecifier = BabelNodeExportSpecifier | BabelNodeImportDefaultSpecifier | BabelNodeImportNamespaceSpecifier | BabelNodeImportSpecifier | BabelNodeExportNamespaceSpecifier | BabelNodeExportDefaultSpecifier; +type BabelNodeAccessor = BabelNodeClassAccessorProperty; +type BabelNodePrivate = BabelNodeClassPrivateProperty | BabelNodeClassPrivateMethod | BabelNodePrivateName; +type BabelNodeFlow = BabelNodeAnyTypeAnnotation | BabelNodeArrayTypeAnnotation | BabelNodeBooleanTypeAnnotation | BabelNodeBooleanLiteralTypeAnnotation | BabelNodeNullLiteralTypeAnnotation | BabelNodeClassImplements | BabelNodeDeclareClass | BabelNodeDeclareFunction | BabelNodeDeclareInterface | BabelNodeDeclareModule | BabelNodeDeclareModuleExports | BabelNodeDeclareTypeAlias | BabelNodeDeclareOpaqueType | BabelNodeDeclareVariable | BabelNodeDeclareExportDeclaration | BabelNodeDeclareExportAllDeclaration | BabelNodeDeclaredPredicate | BabelNodeExistsTypeAnnotation | BabelNodeFunctionTypeAnnotation | BabelNodeFunctionTypeParam | BabelNodeGenericTypeAnnotation | BabelNodeInferredPredicate | BabelNodeInterfaceExtends | BabelNodeInterfaceDeclaration | BabelNodeInterfaceTypeAnnotation | BabelNodeIntersectionTypeAnnotation | BabelNodeMixedTypeAnnotation | BabelNodeEmptyTypeAnnotation | BabelNodeNullableTypeAnnotation | BabelNodeNumberLiteralTypeAnnotation | BabelNodeNumberTypeAnnotation | BabelNodeObjectTypeAnnotation | BabelNodeObjectTypeInternalSlot | BabelNodeObjectTypeCallProperty | BabelNodeObjectTypeIndexer | BabelNodeObjectTypeProperty | BabelNodeObjectTypeSpreadProperty | BabelNodeOpaqueType | BabelNodeQualifiedTypeIdentifier | BabelNodeStringLiteralTypeAnnotation | BabelNodeStringTypeAnnotation | BabelNodeSymbolTypeAnnotation | BabelNodeThisTypeAnnotation | BabelNodeTupleTypeAnnotation | BabelNodeTypeofTypeAnnotation | BabelNodeTypeAlias | BabelNodeTypeAnnotation | BabelNodeTypeCastExpression | BabelNodeTypeParameter | BabelNodeTypeParameterDeclaration | BabelNodeTypeParameterInstantiation | BabelNodeUnionTypeAnnotation | BabelNodeVariance | BabelNodeVoidTypeAnnotation | BabelNodeEnumDeclaration | BabelNodeEnumBooleanBody | BabelNodeEnumNumberBody | BabelNodeEnumStringBody | BabelNodeEnumSymbolBody | BabelNodeEnumBooleanMember | BabelNodeEnumNumberMember | BabelNodeEnumStringMember | BabelNodeEnumDefaultedMember | BabelNodeIndexedAccessType | BabelNodeOptionalIndexedAccessType; +type BabelNodeFlowType = BabelNodeAnyTypeAnnotation | BabelNodeArrayTypeAnnotation | BabelNodeBooleanTypeAnnotation | BabelNodeBooleanLiteralTypeAnnotation | BabelNodeNullLiteralTypeAnnotation | BabelNodeExistsTypeAnnotation | BabelNodeFunctionTypeAnnotation | BabelNodeGenericTypeAnnotation | BabelNodeInterfaceTypeAnnotation | BabelNodeIntersectionTypeAnnotation | BabelNodeMixedTypeAnnotation | BabelNodeEmptyTypeAnnotation | BabelNodeNullableTypeAnnotation | BabelNodeNumberLiteralTypeAnnotation | BabelNodeNumberTypeAnnotation | BabelNodeObjectTypeAnnotation | BabelNodeStringLiteralTypeAnnotation | BabelNodeStringTypeAnnotation | BabelNodeSymbolTypeAnnotation | BabelNodeThisTypeAnnotation | BabelNodeTupleTypeAnnotation | BabelNodeTypeofTypeAnnotation | BabelNodeUnionTypeAnnotation | BabelNodeVoidTypeAnnotation | BabelNodeIndexedAccessType | BabelNodeOptionalIndexedAccessType; +type BabelNodeFlowBaseAnnotation = BabelNodeAnyTypeAnnotation | BabelNodeBooleanTypeAnnotation | BabelNodeNullLiteralTypeAnnotation | BabelNodeMixedTypeAnnotation | BabelNodeEmptyTypeAnnotation | BabelNodeNumberTypeAnnotation | BabelNodeStringTypeAnnotation | BabelNodeSymbolTypeAnnotation | BabelNodeThisTypeAnnotation | BabelNodeVoidTypeAnnotation; +type BabelNodeFlowDeclaration = BabelNodeDeclareClass | BabelNodeDeclareFunction | BabelNodeDeclareInterface | BabelNodeDeclareModule | BabelNodeDeclareModuleExports | BabelNodeDeclareTypeAlias | BabelNodeDeclareOpaqueType | BabelNodeDeclareVariable | BabelNodeDeclareExportDeclaration | BabelNodeDeclareExportAllDeclaration | BabelNodeInterfaceDeclaration | BabelNodeOpaqueType | BabelNodeTypeAlias; +type BabelNodeFlowPredicate = BabelNodeDeclaredPredicate | BabelNodeInferredPredicate; +type BabelNodeEnumBody = BabelNodeEnumBooleanBody | BabelNodeEnumNumberBody | BabelNodeEnumStringBody | BabelNodeEnumSymbolBody; +type BabelNodeEnumMember = BabelNodeEnumBooleanMember | BabelNodeEnumNumberMember | BabelNodeEnumStringMember | BabelNodeEnumDefaultedMember; +type BabelNodeJSX = BabelNodeJSXAttribute | BabelNodeJSXClosingElement | BabelNodeJSXElement | BabelNodeJSXEmptyExpression | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXIdentifier | BabelNodeJSXMemberExpression | BabelNodeJSXNamespacedName | BabelNodeJSXOpeningElement | BabelNodeJSXSpreadAttribute | BabelNodeJSXText | BabelNodeJSXFragment | BabelNodeJSXOpeningFragment | BabelNodeJSXClosingFragment; +type BabelNodeMiscellaneous = BabelNodeNoop | BabelNodePlaceholder | BabelNodeV8IntrinsicIdentifier; +type BabelNodeTypeScript = BabelNodeTSParameterProperty | BabelNodeTSDeclareFunction | BabelNodeTSDeclareMethod | BabelNodeTSQualifiedName | BabelNodeTSCallSignatureDeclaration | BabelNodeTSConstructSignatureDeclaration | BabelNodeTSPropertySignature | BabelNodeTSMethodSignature | BabelNodeTSIndexSignature | BabelNodeTSAnyKeyword | BabelNodeTSBooleanKeyword | BabelNodeTSBigIntKeyword | BabelNodeTSIntrinsicKeyword | BabelNodeTSNeverKeyword | BabelNodeTSNullKeyword | BabelNodeTSNumberKeyword | BabelNodeTSObjectKeyword | BabelNodeTSStringKeyword | BabelNodeTSSymbolKeyword | BabelNodeTSUndefinedKeyword | BabelNodeTSUnknownKeyword | BabelNodeTSVoidKeyword | BabelNodeTSThisType | BabelNodeTSFunctionType | BabelNodeTSConstructorType | BabelNodeTSTypeReference | BabelNodeTSTypePredicate | BabelNodeTSTypeQuery | BabelNodeTSTypeLiteral | BabelNodeTSArrayType | BabelNodeTSTupleType | BabelNodeTSOptionalType | BabelNodeTSRestType | BabelNodeTSNamedTupleMember | BabelNodeTSUnionType | BabelNodeTSIntersectionType | BabelNodeTSConditionalType | BabelNodeTSInferType | BabelNodeTSParenthesizedType | BabelNodeTSTypeOperator | BabelNodeTSIndexedAccessType | BabelNodeTSMappedType | BabelNodeTSTemplateLiteralType | BabelNodeTSLiteralType | BabelNodeTSExpressionWithTypeArguments | BabelNodeTSInterfaceDeclaration | BabelNodeTSInterfaceBody | BabelNodeTSTypeAliasDeclaration | BabelNodeTSInstantiationExpression | BabelNodeTSAsExpression | BabelNodeTSSatisfiesExpression | BabelNodeTSTypeAssertion | BabelNodeTSEnumBody | BabelNodeTSEnumDeclaration | BabelNodeTSEnumMember | BabelNodeTSModuleDeclaration | BabelNodeTSModuleBlock | BabelNodeTSImportType | BabelNodeTSImportEqualsDeclaration | BabelNodeTSExternalModuleReference | BabelNodeTSNonNullExpression | BabelNodeTSExportAssignment | BabelNodeTSNamespaceExportDeclaration | BabelNodeTSTypeAnnotation | BabelNodeTSTypeParameterInstantiation | BabelNodeTSTypeParameterDeclaration | BabelNodeTSTypeParameter; +type BabelNodeTSTypeElement = BabelNodeTSCallSignatureDeclaration | BabelNodeTSConstructSignatureDeclaration | BabelNodeTSPropertySignature | BabelNodeTSMethodSignature | BabelNodeTSIndexSignature; +type BabelNodeTSType = BabelNodeTSAnyKeyword | BabelNodeTSBooleanKeyword | BabelNodeTSBigIntKeyword | BabelNodeTSIntrinsicKeyword | BabelNodeTSNeverKeyword | BabelNodeTSNullKeyword | BabelNodeTSNumberKeyword | BabelNodeTSObjectKeyword | BabelNodeTSStringKeyword | BabelNodeTSSymbolKeyword | BabelNodeTSUndefinedKeyword | BabelNodeTSUnknownKeyword | BabelNodeTSVoidKeyword | BabelNodeTSThisType | BabelNodeTSFunctionType | BabelNodeTSConstructorType | BabelNodeTSTypeReference | BabelNodeTSTypePredicate | BabelNodeTSTypeQuery | BabelNodeTSTypeLiteral | BabelNodeTSArrayType | BabelNodeTSTupleType | BabelNodeTSOptionalType | BabelNodeTSRestType | BabelNodeTSUnionType | BabelNodeTSIntersectionType | BabelNodeTSConditionalType | BabelNodeTSInferType | BabelNodeTSParenthesizedType | BabelNodeTSTypeOperator | BabelNodeTSIndexedAccessType | BabelNodeTSMappedType | BabelNodeTSTemplateLiteralType | BabelNodeTSLiteralType | BabelNodeTSExpressionWithTypeArguments | BabelNodeTSImportType; +type BabelNodeTSBaseType = BabelNodeTSAnyKeyword | BabelNodeTSBooleanKeyword | BabelNodeTSBigIntKeyword | BabelNodeTSIntrinsicKeyword | BabelNodeTSNeverKeyword | BabelNodeTSNullKeyword | BabelNodeTSNumberKeyword | BabelNodeTSObjectKeyword | BabelNodeTSStringKeyword | BabelNodeTSSymbolKeyword | BabelNodeTSUndefinedKeyword | BabelNodeTSUnknownKeyword | BabelNodeTSVoidKeyword | BabelNodeTSThisType | BabelNodeTSTemplateLiteralType | BabelNodeTSLiteralType; +type BabelNodeModuleDeclaration = BabelNodeExportAllDeclaration | BabelNodeExportDefaultDeclaration | BabelNodeExportNamedDeclaration | BabelNodeImportDeclaration; + +declare module "@babel/types" { + declare export function arrayExpression(elements?: (null | BabelNodeExpression | BabelNodeSpreadElement)[]): BabelNodeArrayExpression; + declare export function assignmentExpression(operator: string, left: BabelNodeLVal | BabelNodeOptionalMemberExpression, right: BabelNodeExpression): BabelNodeAssignmentExpression; + declare export function binaryExpression(operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=" | "|>", left: BabelNodeExpression | BabelNodePrivateName, right: BabelNodeExpression): BabelNodeBinaryExpression; + declare export function interpreterDirective(value: string): BabelNodeInterpreterDirective; + declare export function directive(value: BabelNodeDirectiveLiteral): BabelNodeDirective; + declare export function directiveLiteral(value: string): BabelNodeDirectiveLiteral; + declare export function blockStatement(body: BabelNodeStatement[], directives?: BabelNodeDirective[]): BabelNodeBlockStatement; + declare export function breakStatement(label?: BabelNodeIdentifier): BabelNodeBreakStatement; + declare export function callExpression(callee: BabelNodeExpression | BabelNodeSuper | BabelNodeV8IntrinsicIdentifier, _arguments: (BabelNodeExpression | BabelNodeSpreadElement | BabelNodeArgumentPlaceholder)[]): BabelNodeCallExpression; + declare export function catchClause(param?: BabelNodeIdentifier | BabelNodeArrayPattern | BabelNodeObjectPattern, body: BabelNodeBlockStatement): BabelNodeCatchClause; + declare export function conditionalExpression(test: BabelNodeExpression, consequent: BabelNodeExpression, alternate: BabelNodeExpression): BabelNodeConditionalExpression; + declare export function continueStatement(label?: BabelNodeIdentifier): BabelNodeContinueStatement; + declare export function debuggerStatement(): BabelNodeDebuggerStatement; + declare export function doWhileStatement(test: BabelNodeExpression, body: BabelNodeStatement): BabelNodeDoWhileStatement; + declare export function emptyStatement(): BabelNodeEmptyStatement; + declare export function expressionStatement(expression: BabelNodeExpression): BabelNodeExpressionStatement; + declare export function file(program: BabelNodeProgram, comments?: (BabelNodeCommentBlock | BabelNodeCommentLine)[], tokens?: any[]): BabelNodeFile; + declare export function forInStatement(left: BabelNodeVariableDeclaration | BabelNodeLVal, right: BabelNodeExpression, body: BabelNodeStatement): BabelNodeForInStatement; + declare export function forStatement(init?: BabelNodeVariableDeclaration | BabelNodeExpression, test?: BabelNodeExpression, update?: BabelNodeExpression, body: BabelNodeStatement): BabelNodeForStatement; + declare export function functionDeclaration(id?: BabelNodeIdentifier, params: BabelNodeFunctionParameter[], body: BabelNodeBlockStatement, generator?: boolean, async?: boolean): BabelNodeFunctionDeclaration; + declare export function functionExpression(id?: BabelNodeIdentifier, params: BabelNodeFunctionParameter[], body: BabelNodeBlockStatement, generator?: boolean, async?: boolean): BabelNodeFunctionExpression; + declare export function identifier(name: string): BabelNodeIdentifier; + declare export function ifStatement(test: BabelNodeExpression, consequent: BabelNodeStatement, alternate?: BabelNodeStatement): BabelNodeIfStatement; + declare export function labeledStatement(label: BabelNodeIdentifier, body: BabelNodeStatement): BabelNodeLabeledStatement; + declare export function stringLiteral(value: string): BabelNodeStringLiteral; + declare export function numericLiteral(value: number): BabelNodeNumericLiteral; + declare export function nullLiteral(): BabelNodeNullLiteral; + declare export function booleanLiteral(value: boolean): BabelNodeBooleanLiteral; + declare export function regExpLiteral(pattern: string, flags?: string): BabelNodeRegExpLiteral; + declare export function logicalExpression(operator: "||" | "&&" | "??", left: BabelNodeExpression, right: BabelNodeExpression): BabelNodeLogicalExpression; + declare export function memberExpression(object: BabelNodeExpression | BabelNodeSuper, property: BabelNodeExpression | BabelNodeIdentifier | BabelNodePrivateName, computed?: boolean, optional?: boolean): BabelNodeMemberExpression; + declare export function newExpression(callee: BabelNodeExpression | BabelNodeSuper | BabelNodeV8IntrinsicIdentifier, _arguments: (BabelNodeExpression | BabelNodeSpreadElement | BabelNodeArgumentPlaceholder)[]): BabelNodeNewExpression; + declare export function program(body: BabelNodeStatement[], directives?: BabelNodeDirective[], sourceType?: "script" | "module", interpreter?: BabelNodeInterpreterDirective): BabelNodeProgram; + declare export function objectExpression(properties: (BabelNodeObjectMethod | BabelNodeObjectProperty | BabelNodeSpreadElement)[]): BabelNodeObjectExpression; + declare export function objectMethod(kind?: "method" | "get" | "set", key: BabelNodeExpression | BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral, params: BabelNodeFunctionParameter[], body: BabelNodeBlockStatement, computed?: boolean, generator?: boolean, async?: boolean): BabelNodeObjectMethod; + declare export function objectProperty(key: BabelNodeExpression | BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeDecimalLiteral | BabelNodePrivateName, value: BabelNodeExpression | BabelNodePatternLike, computed?: boolean, shorthand?: boolean, decorators?: BabelNodeDecorator[]): BabelNodeObjectProperty; + declare export function restElement(argument: BabelNodeIdentifier | BabelNodeArrayPattern | BabelNodeObjectPattern | BabelNodeMemberExpression | BabelNodeTSAsExpression | BabelNodeTSSatisfiesExpression | BabelNodeTSTypeAssertion | BabelNodeTSNonNullExpression | BabelNodeRestElement | BabelNodeAssignmentPattern): BabelNodeRestElement; + declare export function returnStatement(argument?: BabelNodeExpression): BabelNodeReturnStatement; + declare export function sequenceExpression(expressions: BabelNodeExpression[]): BabelNodeSequenceExpression; + declare export function parenthesizedExpression(expression: BabelNodeExpression): BabelNodeParenthesizedExpression; + declare export function switchCase(test?: BabelNodeExpression, consequent: BabelNodeStatement[]): BabelNodeSwitchCase; + declare export function switchStatement(discriminant: BabelNodeExpression, cases: BabelNodeSwitchCase[]): BabelNodeSwitchStatement; + declare export function thisExpression(): BabelNodeThisExpression; + declare export function throwStatement(argument: BabelNodeExpression): BabelNodeThrowStatement; + declare export function tryStatement(block: BabelNodeBlockStatement, handler?: BabelNodeCatchClause, finalizer?: BabelNodeBlockStatement): BabelNodeTryStatement; + declare export function unaryExpression(operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof", argument: BabelNodeExpression, prefix?: boolean): BabelNodeUnaryExpression; + declare export function updateExpression(operator: "++" | "--", argument: BabelNodeExpression, prefix?: boolean): BabelNodeUpdateExpression; + declare export function variableDeclaration(kind: "var" | "let" | "const" | "using" | "await using", declarations: BabelNodeVariableDeclarator[]): BabelNodeVariableDeclaration; + declare export function variableDeclarator(id: BabelNodeLVal | BabelNodeVoidPattern, init?: BabelNodeExpression): BabelNodeVariableDeclarator; + declare export function whileStatement(test: BabelNodeExpression, body: BabelNodeStatement): BabelNodeWhileStatement; + declare export function withStatement(object: BabelNodeExpression, body: BabelNodeStatement): BabelNodeWithStatement; + declare export function assignmentPattern(left: BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeArrayPattern | BabelNodeMemberExpression | BabelNodeTSAsExpression | BabelNodeTSSatisfiesExpression | BabelNodeTSTypeAssertion | BabelNodeTSNonNullExpression, right: BabelNodeExpression): BabelNodeAssignmentPattern; + declare export function arrayPattern(elements: (null | BabelNodePatternLike)[]): BabelNodeArrayPattern; + declare export function arrowFunctionExpression(params: BabelNodeFunctionParameter[], body: BabelNodeBlockStatement | BabelNodeExpression, async?: boolean): BabelNodeArrowFunctionExpression; + declare export function classBody(body: (BabelNodeClassMethod | BabelNodeClassPrivateMethod | BabelNodeClassProperty | BabelNodeClassPrivateProperty | BabelNodeClassAccessorProperty | BabelNodeTSDeclareMethod | BabelNodeTSIndexSignature | BabelNodeStaticBlock)[]): BabelNodeClassBody; + declare export function classExpression(id?: BabelNodeIdentifier, superClass?: BabelNodeExpression, body: BabelNodeClassBody, decorators?: BabelNodeDecorator[]): BabelNodeClassExpression; + declare export function classDeclaration(id?: BabelNodeIdentifier, superClass?: BabelNodeExpression, body: BabelNodeClassBody, decorators?: BabelNodeDecorator[]): BabelNodeClassDeclaration; + declare export function exportAllDeclaration(source: BabelNodeStringLiteral, attributes?: BabelNodeImportAttribute[]): BabelNodeExportAllDeclaration; + declare export function exportDefaultDeclaration(declaration: BabelNodeTSDeclareFunction | BabelNodeFunctionDeclaration | BabelNodeClassDeclaration | BabelNodeExpression): BabelNodeExportDefaultDeclaration; + declare export function exportNamedDeclaration(declaration?: BabelNodeDeclaration, specifiers?: (BabelNodeExportSpecifier | BabelNodeExportDefaultSpecifier | BabelNodeExportNamespaceSpecifier)[], source?: BabelNodeStringLiteral, attributes?: BabelNodeImportAttribute[]): BabelNodeExportNamedDeclaration; + declare export function exportSpecifier(local: BabelNodeIdentifier, exported: BabelNodeIdentifier | BabelNodeStringLiteral): BabelNodeExportSpecifier; + declare export function forOfStatement(left: BabelNodeVariableDeclaration | BabelNodeLVal, right: BabelNodeExpression, body: BabelNodeStatement, _await?: boolean): BabelNodeForOfStatement; + declare export function importDeclaration(specifiers: (BabelNodeImportSpecifier | BabelNodeImportDefaultSpecifier | BabelNodeImportNamespaceSpecifier)[], source: BabelNodeStringLiteral, attributes?: BabelNodeImportAttribute[]): BabelNodeImportDeclaration; + declare export function importDefaultSpecifier(local: BabelNodeIdentifier): BabelNodeImportDefaultSpecifier; + declare export function importNamespaceSpecifier(local: BabelNodeIdentifier): BabelNodeImportNamespaceSpecifier; + declare export function importSpecifier(local: BabelNodeIdentifier, imported: BabelNodeIdentifier | BabelNodeStringLiteral): BabelNodeImportSpecifier; + declare export function importExpression(source: BabelNodeExpression, options?: BabelNodeExpression): BabelNodeImportExpression; + declare export function metaProperty(meta: BabelNodeIdentifier, property: BabelNodeIdentifier): BabelNodeMetaProperty; + declare export function classMethod(kind?: "get" | "set" | "method" | "constructor", key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression, params: (BabelNodeFunctionParameter | BabelNodeTSParameterProperty)[], body: BabelNodeBlockStatement, computed?: boolean, _static?: boolean, generator?: boolean, async?: boolean): BabelNodeClassMethod; + declare export function objectPattern(properties: (BabelNodeRestElement | BabelNodeObjectProperty)[]): BabelNodeObjectPattern; + declare export function spreadElement(argument: BabelNodeExpression): BabelNodeSpreadElement; + declare function _super(): BabelNodeSuper; + declare export { _super as super } + declare export function taggedTemplateExpression(tag: BabelNodeExpression, quasi: BabelNodeTemplateLiteral): BabelNodeTaggedTemplateExpression; + declare export function templateElement(value: { raw: string, cooked?: string }, tail?: boolean): BabelNodeTemplateElement; + declare export function templateLiteral(quasis: BabelNodeTemplateElement[], expressions: (BabelNodeExpression | BabelNodeTSType)[]): BabelNodeTemplateLiteral; + declare export function yieldExpression(argument?: BabelNodeExpression, delegate?: boolean): BabelNodeYieldExpression; + declare export function awaitExpression(argument: BabelNodeExpression): BabelNodeAwaitExpression; + declare function _import(): BabelNodeImport; + declare export { _import as import } + declare export function bigIntLiteral(value: string): BabelNodeBigIntLiteral; + declare export function exportNamespaceSpecifier(exported: BabelNodeIdentifier): BabelNodeExportNamespaceSpecifier; + declare export function optionalMemberExpression(object: BabelNodeExpression, property: BabelNodeExpression | BabelNodeIdentifier, computed?: boolean, optional: boolean): BabelNodeOptionalMemberExpression; + declare export function optionalCallExpression(callee: BabelNodeExpression, _arguments: (BabelNodeExpression | BabelNodeSpreadElement | BabelNodeArgumentPlaceholder)[], optional: boolean): BabelNodeOptionalCallExpression; + declare export function classProperty(key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression, value?: BabelNodeExpression, typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop, decorators?: BabelNodeDecorator[], computed?: boolean, _static?: boolean): BabelNodeClassProperty; + declare export function classAccessorProperty(key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression | BabelNodePrivateName, value?: BabelNodeExpression, typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop, decorators?: BabelNodeDecorator[], computed?: boolean, _static?: boolean): BabelNodeClassAccessorProperty; + declare export function classPrivateProperty(key: BabelNodePrivateName, value?: BabelNodeExpression, decorators?: BabelNodeDecorator[], _static?: boolean): BabelNodeClassPrivateProperty; + declare export function classPrivateMethod(kind?: "get" | "set" | "method", key: BabelNodePrivateName, params: (BabelNodeFunctionParameter | BabelNodeTSParameterProperty)[], body: BabelNodeBlockStatement, _static?: boolean): BabelNodeClassPrivateMethod; + declare export function privateName(id: BabelNodeIdentifier): BabelNodePrivateName; + declare export function staticBlock(body: BabelNodeStatement[]): BabelNodeStaticBlock; + declare export function importAttribute(key: BabelNodeIdentifier | BabelNodeStringLiteral, value: BabelNodeStringLiteral): BabelNodeImportAttribute; + declare export function anyTypeAnnotation(): BabelNodeAnyTypeAnnotation; + declare export function arrayTypeAnnotation(elementType: BabelNodeFlowType): BabelNodeArrayTypeAnnotation; + declare export function booleanTypeAnnotation(): BabelNodeBooleanTypeAnnotation; + declare export function booleanLiteralTypeAnnotation(value: boolean): BabelNodeBooleanLiteralTypeAnnotation; + declare export function nullLiteralTypeAnnotation(): BabelNodeNullLiteralTypeAnnotation; + declare export function classImplements(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterInstantiation): BabelNodeClassImplements; + declare export function declareClass(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, _extends?: BabelNodeInterfaceExtends[], body: BabelNodeObjectTypeAnnotation): BabelNodeDeclareClass; + declare export function declareFunction(id: BabelNodeIdentifier): BabelNodeDeclareFunction; + declare export function declareInterface(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, _extends?: BabelNodeInterfaceExtends[], body: BabelNodeObjectTypeAnnotation): BabelNodeDeclareInterface; + declare export function declareModule(id: BabelNodeIdentifier | BabelNodeStringLiteral, body: BabelNodeBlockStatement, kind?: "CommonJS" | "ES"): BabelNodeDeclareModule; + declare export function declareModuleExports(typeAnnotation: BabelNodeTypeAnnotation): BabelNodeDeclareModuleExports; + declare export function declareTypeAlias(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, right: BabelNodeFlowType): BabelNodeDeclareTypeAlias; + declare export function declareOpaqueType(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, supertype?: BabelNodeFlowType): BabelNodeDeclareOpaqueType; + declare export function declareVariable(id: BabelNodeIdentifier): BabelNodeDeclareVariable; + declare export function declareExportDeclaration(declaration?: BabelNodeFlow, specifiers?: (BabelNodeExportSpecifier | BabelNodeExportNamespaceSpecifier)[], source?: BabelNodeStringLiteral, attributes?: BabelNodeImportAttribute[]): BabelNodeDeclareExportDeclaration; + declare export function declareExportAllDeclaration(source: BabelNodeStringLiteral, attributes?: BabelNodeImportAttribute[]): BabelNodeDeclareExportAllDeclaration; + declare export function declaredPredicate(value: BabelNodeFlow): BabelNodeDeclaredPredicate; + declare export function existsTypeAnnotation(): BabelNodeExistsTypeAnnotation; + declare export function functionTypeAnnotation(typeParameters?: BabelNodeTypeParameterDeclaration, params: BabelNodeFunctionTypeParam[], rest?: BabelNodeFunctionTypeParam, returnType: BabelNodeFlowType): BabelNodeFunctionTypeAnnotation; + declare export function functionTypeParam(name?: BabelNodeIdentifier, typeAnnotation: BabelNodeFlowType): BabelNodeFunctionTypeParam; + declare export function genericTypeAnnotation(id: BabelNodeIdentifier | BabelNodeQualifiedTypeIdentifier, typeParameters?: BabelNodeTypeParameterInstantiation): BabelNodeGenericTypeAnnotation; + declare export function inferredPredicate(): BabelNodeInferredPredicate; + declare export function interfaceExtends(id: BabelNodeIdentifier | BabelNodeQualifiedTypeIdentifier, typeParameters?: BabelNodeTypeParameterInstantiation): BabelNodeInterfaceExtends; + declare export function interfaceDeclaration(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, _extends?: BabelNodeInterfaceExtends[], body: BabelNodeObjectTypeAnnotation): BabelNodeInterfaceDeclaration; + declare export function interfaceTypeAnnotation(_extends?: BabelNodeInterfaceExtends[], body: BabelNodeObjectTypeAnnotation): BabelNodeInterfaceTypeAnnotation; + declare export function intersectionTypeAnnotation(types: BabelNodeFlowType[]): BabelNodeIntersectionTypeAnnotation; + declare export function mixedTypeAnnotation(): BabelNodeMixedTypeAnnotation; + declare export function emptyTypeAnnotation(): BabelNodeEmptyTypeAnnotation; + declare export function nullableTypeAnnotation(typeAnnotation: BabelNodeFlowType): BabelNodeNullableTypeAnnotation; + declare export function numberLiteralTypeAnnotation(value: number): BabelNodeNumberLiteralTypeAnnotation; + declare export function numberTypeAnnotation(): BabelNodeNumberTypeAnnotation; + declare export function objectTypeAnnotation(properties: (BabelNodeObjectTypeProperty | BabelNodeObjectTypeSpreadProperty)[], indexers?: BabelNodeObjectTypeIndexer[], callProperties?: BabelNodeObjectTypeCallProperty[], internalSlots?: BabelNodeObjectTypeInternalSlot[], exact?: boolean): BabelNodeObjectTypeAnnotation; + declare export function objectTypeInternalSlot(id: BabelNodeIdentifier, value: BabelNodeFlowType, optional: boolean, _static: boolean, method: boolean): BabelNodeObjectTypeInternalSlot; + declare export function objectTypeCallProperty(value: BabelNodeFlowType): BabelNodeObjectTypeCallProperty; + declare export function objectTypeIndexer(id?: BabelNodeIdentifier, key: BabelNodeFlowType, value: BabelNodeFlowType, variance?: BabelNodeVariance): BabelNodeObjectTypeIndexer; + declare export function objectTypeProperty(key: BabelNodeIdentifier | BabelNodeStringLiteral, value: BabelNodeFlowType, variance?: BabelNodeVariance): BabelNodeObjectTypeProperty; + declare export function objectTypeSpreadProperty(argument: BabelNodeFlowType): BabelNodeObjectTypeSpreadProperty; + declare export function opaqueType(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, supertype?: BabelNodeFlowType, impltype: BabelNodeFlowType): BabelNodeOpaqueType; + declare export function qualifiedTypeIdentifier(id: BabelNodeIdentifier, qualification: BabelNodeIdentifier | BabelNodeQualifiedTypeIdentifier): BabelNodeQualifiedTypeIdentifier; + declare export function stringLiteralTypeAnnotation(value: string): BabelNodeStringLiteralTypeAnnotation; + declare export function stringTypeAnnotation(): BabelNodeStringTypeAnnotation; + declare export function symbolTypeAnnotation(): BabelNodeSymbolTypeAnnotation; + declare export function thisTypeAnnotation(): BabelNodeThisTypeAnnotation; + declare export function tupleTypeAnnotation(types: BabelNodeFlowType[]): BabelNodeTupleTypeAnnotation; + declare export function typeofTypeAnnotation(argument: BabelNodeFlowType): BabelNodeTypeofTypeAnnotation; + declare export function typeAlias(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, right: BabelNodeFlowType): BabelNodeTypeAlias; + declare export function typeAnnotation(typeAnnotation: BabelNodeFlowType): BabelNodeTypeAnnotation; + declare export function typeCastExpression(expression: BabelNodeExpression, typeAnnotation: BabelNodeTypeAnnotation): BabelNodeTypeCastExpression; + declare export function typeParameter(bound?: BabelNodeTypeAnnotation, _default?: BabelNodeFlowType, variance?: BabelNodeVariance): BabelNodeTypeParameter; + declare export function typeParameterDeclaration(params: BabelNodeTypeParameter[]): BabelNodeTypeParameterDeclaration; + declare export function typeParameterInstantiation(params: BabelNodeFlowType[]): BabelNodeTypeParameterInstantiation; + declare export function unionTypeAnnotation(types: BabelNodeFlowType[]): BabelNodeUnionTypeAnnotation; + declare export function variance(kind: "minus" | "plus"): BabelNodeVariance; + declare export function voidTypeAnnotation(): BabelNodeVoidTypeAnnotation; + declare export function enumDeclaration(id: BabelNodeIdentifier, body: BabelNodeEnumBooleanBody | BabelNodeEnumNumberBody | BabelNodeEnumStringBody | BabelNodeEnumSymbolBody): BabelNodeEnumDeclaration; + declare export function enumBooleanBody(members: BabelNodeEnumBooleanMember[]): BabelNodeEnumBooleanBody; + declare export function enumNumberBody(members: BabelNodeEnumNumberMember[]): BabelNodeEnumNumberBody; + declare export function enumStringBody(members: (BabelNodeEnumStringMember | BabelNodeEnumDefaultedMember)[]): BabelNodeEnumStringBody; + declare export function enumSymbolBody(members: BabelNodeEnumDefaultedMember[]): BabelNodeEnumSymbolBody; + declare export function enumBooleanMember(id: BabelNodeIdentifier): BabelNodeEnumBooleanMember; + declare export function enumNumberMember(id: BabelNodeIdentifier, init: BabelNodeNumericLiteral): BabelNodeEnumNumberMember; + declare export function enumStringMember(id: BabelNodeIdentifier, init: BabelNodeStringLiteral): BabelNodeEnumStringMember; + declare export function enumDefaultedMember(id: BabelNodeIdentifier): BabelNodeEnumDefaultedMember; + declare export function indexedAccessType(objectType: BabelNodeFlowType, indexType: BabelNodeFlowType): BabelNodeIndexedAccessType; + declare export function optionalIndexedAccessType(objectType: BabelNodeFlowType, indexType: BabelNodeFlowType): BabelNodeOptionalIndexedAccessType; + declare export function jsxAttribute(name: BabelNodeJSXIdentifier | BabelNodeJSXNamespacedName, value?: BabelNodeJSXElement | BabelNodeJSXFragment | BabelNodeStringLiteral | BabelNodeJSXExpressionContainer): BabelNodeJSXAttribute; + declare export function jsxClosingElement(name: BabelNodeJSXIdentifier | BabelNodeJSXMemberExpression | BabelNodeJSXNamespacedName): BabelNodeJSXClosingElement; + declare export function jsxElement(openingElement: BabelNodeJSXOpeningElement, closingElement?: BabelNodeJSXClosingElement, children: (BabelNodeJSXText | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXElement | BabelNodeJSXFragment)[], selfClosing?: boolean): BabelNodeJSXElement; + declare export function jsxEmptyExpression(): BabelNodeJSXEmptyExpression; + declare export function jsxExpressionContainer(expression: BabelNodeExpression | BabelNodeJSXEmptyExpression): BabelNodeJSXExpressionContainer; + declare export function jsxSpreadChild(expression: BabelNodeExpression): BabelNodeJSXSpreadChild; + declare export function jsxIdentifier(name: string): BabelNodeJSXIdentifier; + declare export function jsxMemberExpression(object: BabelNodeJSXMemberExpression | BabelNodeJSXIdentifier, property: BabelNodeJSXIdentifier): BabelNodeJSXMemberExpression; + declare export function jsxNamespacedName(namespace: BabelNodeJSXIdentifier, name: BabelNodeJSXIdentifier): BabelNodeJSXNamespacedName; + declare export function jsxOpeningElement(name: BabelNodeJSXIdentifier | BabelNodeJSXMemberExpression | BabelNodeJSXNamespacedName, attributes: (BabelNodeJSXAttribute | BabelNodeJSXSpreadAttribute)[], selfClosing?: boolean): BabelNodeJSXOpeningElement; + declare export function jsxSpreadAttribute(argument: BabelNodeExpression): BabelNodeJSXSpreadAttribute; + declare export function jsxText(value: string): BabelNodeJSXText; + declare export function jsxFragment(openingFragment: BabelNodeJSXOpeningFragment, closingFragment: BabelNodeJSXClosingFragment, children: (BabelNodeJSXText | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXElement | BabelNodeJSXFragment)[]): BabelNodeJSXFragment; + declare export function jsxOpeningFragment(): BabelNodeJSXOpeningFragment; + declare export function jsxClosingFragment(): BabelNodeJSXClosingFragment; + declare export function noop(): BabelNodeNoop; + declare export function placeholder(expectedNode: "Identifier" | "StringLiteral" | "Expression" | "Statement" | "Declaration" | "BlockStatement" | "ClassBody" | "Pattern", name: BabelNodeIdentifier): BabelNodePlaceholder; + declare export function v8IntrinsicIdentifier(name: string): BabelNodeV8IntrinsicIdentifier; + declare export function argumentPlaceholder(): BabelNodeArgumentPlaceholder; + declare export function bindExpression(object: BabelNodeExpression, callee: BabelNodeExpression): BabelNodeBindExpression; + declare export function decorator(expression: BabelNodeExpression): BabelNodeDecorator; + declare export function doExpression(body: BabelNodeBlockStatement, async?: boolean): BabelNodeDoExpression; + declare export function exportDefaultSpecifier(exported: BabelNodeIdentifier): BabelNodeExportDefaultSpecifier; + declare export function recordExpression(properties: (BabelNodeObjectProperty | BabelNodeSpreadElement)[]): BabelNodeRecordExpression; + declare export function tupleExpression(elements?: (BabelNodeExpression | BabelNodeSpreadElement)[]): BabelNodeTupleExpression; + declare export function decimalLiteral(value: string): BabelNodeDecimalLiteral; + declare export function moduleExpression(body: BabelNodeProgram): BabelNodeModuleExpression; + declare export function topicReference(): BabelNodeTopicReference; + declare export function pipelineTopicExpression(expression: BabelNodeExpression): BabelNodePipelineTopicExpression; + declare export function pipelineBareFunction(callee: BabelNodeExpression): BabelNodePipelineBareFunction; + declare export function pipelinePrimaryTopicReference(): BabelNodePipelinePrimaryTopicReference; + declare export function voidPattern(): BabelNodeVoidPattern; + declare export function tsParameterProperty(parameter: BabelNodeIdentifier | BabelNodeAssignmentPattern): BabelNodeTSParameterProperty; + declare export function tsDeclareFunction(id?: BabelNodeIdentifier, typeParameters?: BabelNodeTSTypeParameterDeclaration | BabelNodeNoop, params: BabelNodeFunctionParameter[], returnType?: BabelNodeTSTypeAnnotation | BabelNodeNoop): BabelNodeTSDeclareFunction; + declare export function tsDeclareMethod(decorators?: BabelNodeDecorator[], key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression, typeParameters?: BabelNodeTSTypeParameterDeclaration | BabelNodeNoop, params: (BabelNodeFunctionParameter | BabelNodeTSParameterProperty)[], returnType?: BabelNodeTSTypeAnnotation | BabelNodeNoop): BabelNodeTSDeclareMethod; + declare export function tsQualifiedName(left: BabelNodeTSEntityName, right: BabelNodeIdentifier): BabelNodeTSQualifiedName; + declare export function tsCallSignatureDeclaration(typeParameters?: BabelNodeTSTypeParameterDeclaration, parameters: (BabelNodeArrayPattern | BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeRestElement)[], typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSCallSignatureDeclaration; + declare export function tsConstructSignatureDeclaration(typeParameters?: BabelNodeTSTypeParameterDeclaration, parameters: (BabelNodeArrayPattern | BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeRestElement)[], typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSConstructSignatureDeclaration; + declare export function tsPropertySignature(key: BabelNodeExpression, typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSPropertySignature; + declare export function tsMethodSignature(key: BabelNodeExpression, typeParameters?: BabelNodeTSTypeParameterDeclaration, parameters: (BabelNodeArrayPattern | BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeRestElement)[], typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSMethodSignature; + declare export function tsIndexSignature(parameters: BabelNodeIdentifier[], typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSIndexSignature; + declare export function tsAnyKeyword(): BabelNodeTSAnyKeyword; + declare export function tsBooleanKeyword(): BabelNodeTSBooleanKeyword; + declare export function tsBigIntKeyword(): BabelNodeTSBigIntKeyword; + declare export function tsIntrinsicKeyword(): BabelNodeTSIntrinsicKeyword; + declare export function tsNeverKeyword(): BabelNodeTSNeverKeyword; + declare export function tsNullKeyword(): BabelNodeTSNullKeyword; + declare export function tsNumberKeyword(): BabelNodeTSNumberKeyword; + declare export function tsObjectKeyword(): BabelNodeTSObjectKeyword; + declare export function tsStringKeyword(): BabelNodeTSStringKeyword; + declare export function tsSymbolKeyword(): BabelNodeTSSymbolKeyword; + declare export function tsUndefinedKeyword(): BabelNodeTSUndefinedKeyword; + declare export function tsUnknownKeyword(): BabelNodeTSUnknownKeyword; + declare export function tsVoidKeyword(): BabelNodeTSVoidKeyword; + declare export function tsThisType(): BabelNodeTSThisType; + declare export function tsFunctionType(typeParameters?: BabelNodeTSTypeParameterDeclaration, parameters: (BabelNodeArrayPattern | BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeRestElement)[], typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSFunctionType; + declare export function tsConstructorType(typeParameters?: BabelNodeTSTypeParameterDeclaration, parameters: (BabelNodeArrayPattern | BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeRestElement)[], typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSConstructorType; + declare export function tsTypeReference(typeName: BabelNodeTSEntityName, typeParameters?: BabelNodeTSTypeParameterInstantiation): BabelNodeTSTypeReference; + declare export function tsTypePredicate(parameterName: BabelNodeIdentifier | BabelNodeTSThisType, typeAnnotation?: BabelNodeTSTypeAnnotation, asserts?: boolean): BabelNodeTSTypePredicate; + declare export function tsTypeQuery(exprName: BabelNodeTSEntityName | BabelNodeTSImportType, typeParameters?: BabelNodeTSTypeParameterInstantiation): BabelNodeTSTypeQuery; + declare export function tsTypeLiteral(members: BabelNodeTSTypeElement[]): BabelNodeTSTypeLiteral; + declare export function tsArrayType(elementType: BabelNodeTSType): BabelNodeTSArrayType; + declare export function tsTupleType(elementTypes: (BabelNodeTSType | BabelNodeTSNamedTupleMember)[]): BabelNodeTSTupleType; + declare export function tsOptionalType(typeAnnotation: BabelNodeTSType): BabelNodeTSOptionalType; + declare export function tsRestType(typeAnnotation: BabelNodeTSType): BabelNodeTSRestType; + declare export function tsNamedTupleMember(label: BabelNodeIdentifier, elementType: BabelNodeTSType, optional?: boolean): BabelNodeTSNamedTupleMember; + declare export function tsUnionType(types: BabelNodeTSType[]): BabelNodeTSUnionType; + declare export function tsIntersectionType(types: BabelNodeTSType[]): BabelNodeTSIntersectionType; + declare export function tsConditionalType(checkType: BabelNodeTSType, extendsType: BabelNodeTSType, trueType: BabelNodeTSType, falseType: BabelNodeTSType): BabelNodeTSConditionalType; + declare export function tsInferType(typeParameter: BabelNodeTSTypeParameter): BabelNodeTSInferType; + declare export function tsParenthesizedType(typeAnnotation: BabelNodeTSType): BabelNodeTSParenthesizedType; + declare export function tsTypeOperator(typeAnnotation: BabelNodeTSType, operator?: string): BabelNodeTSTypeOperator; + declare export function tsIndexedAccessType(objectType: BabelNodeTSType, indexType: BabelNodeTSType): BabelNodeTSIndexedAccessType; + declare export function tsMappedType(typeParameter: BabelNodeTSTypeParameter, typeAnnotation?: BabelNodeTSType, nameType?: BabelNodeTSType): BabelNodeTSMappedType; + declare export function tsTemplateLiteralType(quasis: BabelNodeTemplateElement[], types: BabelNodeTSType[]): BabelNodeTSTemplateLiteralType; + declare export function tsLiteralType(literal: BabelNodeNumericLiteral | BabelNodeStringLiteral | BabelNodeBooleanLiteral | BabelNodeBigIntLiteral | BabelNodeTemplateLiteral | BabelNodeUnaryExpression): BabelNodeTSLiteralType; + declare export function tsExpressionWithTypeArguments(expression: BabelNodeTSEntityName, typeParameters?: BabelNodeTSTypeParameterInstantiation): BabelNodeTSExpressionWithTypeArguments; + declare export function tsInterfaceDeclaration(id: BabelNodeIdentifier, typeParameters?: BabelNodeTSTypeParameterDeclaration, _extends?: BabelNodeTSExpressionWithTypeArguments[], body: BabelNodeTSInterfaceBody): BabelNodeTSInterfaceDeclaration; + declare export function tsInterfaceBody(body: BabelNodeTSTypeElement[]): BabelNodeTSInterfaceBody; + declare export function tsTypeAliasDeclaration(id: BabelNodeIdentifier, typeParameters?: BabelNodeTSTypeParameterDeclaration, typeAnnotation: BabelNodeTSType): BabelNodeTSTypeAliasDeclaration; + declare export function tsInstantiationExpression(expression: BabelNodeExpression, typeParameters?: BabelNodeTSTypeParameterInstantiation): BabelNodeTSInstantiationExpression; + declare export function tsAsExpression(expression: BabelNodeExpression, typeAnnotation: BabelNodeTSType): BabelNodeTSAsExpression; + declare export function tsSatisfiesExpression(expression: BabelNodeExpression, typeAnnotation: BabelNodeTSType): BabelNodeTSSatisfiesExpression; + declare export function tsTypeAssertion(typeAnnotation: BabelNodeTSType, expression: BabelNodeExpression): BabelNodeTSTypeAssertion; + declare export function tsEnumBody(members: BabelNodeTSEnumMember[]): BabelNodeTSEnumBody; + declare export function tsEnumDeclaration(id: BabelNodeIdentifier, members: BabelNodeTSEnumMember[]): BabelNodeTSEnumDeclaration; + declare export function tsEnumMember(id: BabelNodeIdentifier | BabelNodeStringLiteral, initializer?: BabelNodeExpression): BabelNodeTSEnumMember; + declare export function tsModuleDeclaration(id: BabelNodeIdentifier | BabelNodeStringLiteral, body: BabelNodeTSModuleBlock | BabelNodeTSModuleDeclaration): BabelNodeTSModuleDeclaration; + declare export function tsModuleBlock(body: BabelNodeStatement[]): BabelNodeTSModuleBlock; + declare export function tsImportType(argument: BabelNodeStringLiteral, qualifier?: BabelNodeTSEntityName, typeParameters?: BabelNodeTSTypeParameterInstantiation): BabelNodeTSImportType; + declare export function tsImportEqualsDeclaration(id: BabelNodeIdentifier, moduleReference: BabelNodeTSEntityName | BabelNodeTSExternalModuleReference): BabelNodeTSImportEqualsDeclaration; + declare export function tsExternalModuleReference(expression: BabelNodeStringLiteral): BabelNodeTSExternalModuleReference; + declare export function tsNonNullExpression(expression: BabelNodeExpression): BabelNodeTSNonNullExpression; + declare export function tsExportAssignment(expression: BabelNodeExpression): BabelNodeTSExportAssignment; + declare export function tsNamespaceExportDeclaration(id: BabelNodeIdentifier): BabelNodeTSNamespaceExportDeclaration; + declare export function tsTypeAnnotation(typeAnnotation: BabelNodeTSType): BabelNodeTSTypeAnnotation; + declare export function tsTypeParameterInstantiation(params: BabelNodeTSType[]): BabelNodeTSTypeParameterInstantiation; + declare export function tsTypeParameterDeclaration(params: BabelNodeTSTypeParameter[]): BabelNodeTSTypeParameterDeclaration; + declare export function tsTypeParameter(constraint?: BabelNodeTSType, _default?: BabelNodeTSType, name: string): BabelNodeTSTypeParameter; + declare export function isArrayExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeArrayExpression) + declare export function assertArrayExpression(node: ?Object, opts?: ?Object): void + declare export function isAssignmentExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeAssignmentExpression) + declare export function assertAssignmentExpression(node: ?Object, opts?: ?Object): void + declare export function isBinaryExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBinaryExpression) + declare export function assertBinaryExpression(node: ?Object, opts?: ?Object): void + declare export function isInterpreterDirective(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeInterpreterDirective) + declare export function assertInterpreterDirective(node: ?Object, opts?: ?Object): void + declare export function isDirective(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDirective) + declare export function assertDirective(node: ?Object, opts?: ?Object): void + declare export function isDirectiveLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDirectiveLiteral) + declare export function assertDirectiveLiteral(node: ?Object, opts?: ?Object): void + declare export function isBlockStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBlockStatement) + declare export function assertBlockStatement(node: ?Object, opts?: ?Object): void + declare export function isBreakStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBreakStatement) + declare export function assertBreakStatement(node: ?Object, opts?: ?Object): void + declare export function isCallExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeCallExpression) + declare export function assertCallExpression(node: ?Object, opts?: ?Object): void + declare export function isCatchClause(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeCatchClause) + declare export function assertCatchClause(node: ?Object, opts?: ?Object): void + declare export function isConditionalExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeConditionalExpression) + declare export function assertConditionalExpression(node: ?Object, opts?: ?Object): void + declare export function isContinueStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeContinueStatement) + declare export function assertContinueStatement(node: ?Object, opts?: ?Object): void + declare export function isDebuggerStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDebuggerStatement) + declare export function assertDebuggerStatement(node: ?Object, opts?: ?Object): void + declare export function isDoWhileStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDoWhileStatement) + declare export function assertDoWhileStatement(node: ?Object, opts?: ?Object): void + declare export function isEmptyStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEmptyStatement) + declare export function assertEmptyStatement(node: ?Object, opts?: ?Object): void + declare export function isExpressionStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExpressionStatement) + declare export function assertExpressionStatement(node: ?Object, opts?: ?Object): void + declare export function isFile(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeFile) + declare export function assertFile(node: ?Object, opts?: ?Object): void + declare export function isForInStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeForInStatement) + declare export function assertForInStatement(node: ?Object, opts?: ?Object): void + declare export function isForStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeForStatement) + declare export function assertForStatement(node: ?Object, opts?: ?Object): void + declare export function isFunctionDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeFunctionDeclaration) + declare export function assertFunctionDeclaration(node: ?Object, opts?: ?Object): void + declare export function isFunctionExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeFunctionExpression) + declare export function assertFunctionExpression(node: ?Object, opts?: ?Object): void + declare export function isIdentifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeIdentifier) + declare export function assertIdentifier(node: ?Object, opts?: ?Object): void + declare export function isIfStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeIfStatement) + declare export function assertIfStatement(node: ?Object, opts?: ?Object): void + declare export function isLabeledStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeLabeledStatement) + declare export function assertLabeledStatement(node: ?Object, opts?: ?Object): void + declare export function isStringLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeStringLiteral) + declare export function assertStringLiteral(node: ?Object, opts?: ?Object): void + declare export function isNumericLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNumericLiteral) + declare export function assertNumericLiteral(node: ?Object, opts?: ?Object): void + declare export function isNullLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNullLiteral) + declare export function assertNullLiteral(node: ?Object, opts?: ?Object): void + declare export function isBooleanLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBooleanLiteral) + declare export function assertBooleanLiteral(node: ?Object, opts?: ?Object): void + declare export function isRegExpLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeRegExpLiteral) + declare export function assertRegExpLiteral(node: ?Object, opts?: ?Object): void + declare export function isLogicalExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeLogicalExpression) + declare export function assertLogicalExpression(node: ?Object, opts?: ?Object): void + declare export function isMemberExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeMemberExpression) + declare export function assertMemberExpression(node: ?Object, opts?: ?Object): void + declare export function isNewExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNewExpression) + declare export function assertNewExpression(node: ?Object, opts?: ?Object): void + declare export function isProgram(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeProgram) + declare export function assertProgram(node: ?Object, opts?: ?Object): void + declare export function isObjectExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectExpression) + declare export function assertObjectExpression(node: ?Object, opts?: ?Object): void + declare export function isObjectMethod(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectMethod) + declare export function assertObjectMethod(node: ?Object, opts?: ?Object): void + declare export function isObjectProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectProperty) + declare export function assertObjectProperty(node: ?Object, opts?: ?Object): void + declare export function isRestElement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeRestElement) + declare export function assertRestElement(node: ?Object, opts?: ?Object): void + declare export function isReturnStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeReturnStatement) + declare export function assertReturnStatement(node: ?Object, opts?: ?Object): void + declare export function isSequenceExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSequenceExpression) + declare export function assertSequenceExpression(node: ?Object, opts?: ?Object): void + declare export function isParenthesizedExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeParenthesizedExpression) + declare export function assertParenthesizedExpression(node: ?Object, opts?: ?Object): void + declare export function isSwitchCase(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSwitchCase) + declare export function assertSwitchCase(node: ?Object, opts?: ?Object): void + declare export function isSwitchStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSwitchStatement) + declare export function assertSwitchStatement(node: ?Object, opts?: ?Object): void + declare export function isThisExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeThisExpression) + declare export function assertThisExpression(node: ?Object, opts?: ?Object): void + declare export function isThrowStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeThrowStatement) + declare export function assertThrowStatement(node: ?Object, opts?: ?Object): void + declare export function isTryStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTryStatement) + declare export function assertTryStatement(node: ?Object, opts?: ?Object): void + declare export function isUnaryExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeUnaryExpression) + declare export function assertUnaryExpression(node: ?Object, opts?: ?Object): void + declare export function isUpdateExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeUpdateExpression) + declare export function assertUpdateExpression(node: ?Object, opts?: ?Object): void + declare export function isVariableDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeVariableDeclaration) + declare export function assertVariableDeclaration(node: ?Object, opts?: ?Object): void + declare export function isVariableDeclarator(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeVariableDeclarator) + declare export function assertVariableDeclarator(node: ?Object, opts?: ?Object): void + declare export function isWhileStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeWhileStatement) + declare export function assertWhileStatement(node: ?Object, opts?: ?Object): void + declare export function isWithStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeWithStatement) + declare export function assertWithStatement(node: ?Object, opts?: ?Object): void + declare export function isAssignmentPattern(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeAssignmentPattern) + declare export function assertAssignmentPattern(node: ?Object, opts?: ?Object): void + declare export function isArrayPattern(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeArrayPattern) + declare export function assertArrayPattern(node: ?Object, opts?: ?Object): void + declare export function isArrowFunctionExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeArrowFunctionExpression) + declare export function assertArrowFunctionExpression(node: ?Object, opts?: ?Object): void + declare export function isClassBody(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassBody) + declare export function assertClassBody(node: ?Object, opts?: ?Object): void + declare export function isClassExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassExpression) + declare export function assertClassExpression(node: ?Object, opts?: ?Object): void + declare export function isClassDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassDeclaration) + declare export function assertClassDeclaration(node: ?Object, opts?: ?Object): void + declare export function isExportAllDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportAllDeclaration) + declare export function assertExportAllDeclaration(node: ?Object, opts?: ?Object): void + declare export function isExportDefaultDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportDefaultDeclaration) + declare export function assertExportDefaultDeclaration(node: ?Object, opts?: ?Object): void + declare export function isExportNamedDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportNamedDeclaration) + declare export function assertExportNamedDeclaration(node: ?Object, opts?: ?Object): void + declare export function isExportSpecifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportSpecifier) + declare export function assertExportSpecifier(node: ?Object, opts?: ?Object): void + declare export function isForOfStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeForOfStatement) + declare export function assertForOfStatement(node: ?Object, opts?: ?Object): void + declare export function isImportDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImportDeclaration) + declare export function assertImportDeclaration(node: ?Object, opts?: ?Object): void + declare export function isImportDefaultSpecifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImportDefaultSpecifier) + declare export function assertImportDefaultSpecifier(node: ?Object, opts?: ?Object): void + declare export function isImportNamespaceSpecifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImportNamespaceSpecifier) + declare export function assertImportNamespaceSpecifier(node: ?Object, opts?: ?Object): void + declare export function isImportSpecifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImportSpecifier) + declare export function assertImportSpecifier(node: ?Object, opts?: ?Object): void + declare export function isImportExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImportExpression) + declare export function assertImportExpression(node: ?Object, opts?: ?Object): void + declare export function isMetaProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeMetaProperty) + declare export function assertMetaProperty(node: ?Object, opts?: ?Object): void + declare export function isClassMethod(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassMethod) + declare export function assertClassMethod(node: ?Object, opts?: ?Object): void + declare export function isObjectPattern(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectPattern) + declare export function assertObjectPattern(node: ?Object, opts?: ?Object): void + declare export function isSpreadElement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSpreadElement) + declare export function assertSpreadElement(node: ?Object, opts?: ?Object): void + declare export function isSuper(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSuper) + declare export function assertSuper(node: ?Object, opts?: ?Object): void + declare export function isTaggedTemplateExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTaggedTemplateExpression) + declare export function assertTaggedTemplateExpression(node: ?Object, opts?: ?Object): void + declare export function isTemplateElement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTemplateElement) + declare export function assertTemplateElement(node: ?Object, opts?: ?Object): void + declare export function isTemplateLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTemplateLiteral) + declare export function assertTemplateLiteral(node: ?Object, opts?: ?Object): void + declare export function isYieldExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeYieldExpression) + declare export function assertYieldExpression(node: ?Object, opts?: ?Object): void + declare export function isAwaitExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeAwaitExpression) + declare export function assertAwaitExpression(node: ?Object, opts?: ?Object): void + declare export function isImport(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImport) + declare export function assertImport(node: ?Object, opts?: ?Object): void + declare export function isBigIntLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBigIntLiteral) + declare export function assertBigIntLiteral(node: ?Object, opts?: ?Object): void + declare export function isExportNamespaceSpecifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportNamespaceSpecifier) + declare export function assertExportNamespaceSpecifier(node: ?Object, opts?: ?Object): void + declare export function isOptionalMemberExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeOptionalMemberExpression) + declare export function assertOptionalMemberExpression(node: ?Object, opts?: ?Object): void + declare export function isOptionalCallExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeOptionalCallExpression) + declare export function assertOptionalCallExpression(node: ?Object, opts?: ?Object): void + declare export function isClassProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassProperty) + declare export function assertClassProperty(node: ?Object, opts?: ?Object): void + declare export function isClassAccessorProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassAccessorProperty) + declare export function assertClassAccessorProperty(node: ?Object, opts?: ?Object): void + declare export function isClassPrivateProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassPrivateProperty) + declare export function assertClassPrivateProperty(node: ?Object, opts?: ?Object): void + declare export function isClassPrivateMethod(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassPrivateMethod) + declare export function assertClassPrivateMethod(node: ?Object, opts?: ?Object): void + declare export function isPrivateName(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodePrivateName) + declare export function assertPrivateName(node: ?Object, opts?: ?Object): void + declare export function isStaticBlock(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeStaticBlock) + declare export function assertStaticBlock(node: ?Object, opts?: ?Object): void + declare export function isImportAttribute(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImportAttribute) + declare export function assertImportAttribute(node: ?Object, opts?: ?Object): void + declare export function isAnyTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeAnyTypeAnnotation) + declare export function assertAnyTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isArrayTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeArrayTypeAnnotation) + declare export function assertArrayTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isBooleanTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBooleanTypeAnnotation) + declare export function assertBooleanTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isBooleanLiteralTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBooleanLiteralTypeAnnotation) + declare export function assertBooleanLiteralTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isNullLiteralTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNullLiteralTypeAnnotation) + declare export function assertNullLiteralTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isClassImplements(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassImplements) + declare export function assertClassImplements(node: ?Object, opts?: ?Object): void + declare export function isDeclareClass(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareClass) + declare export function assertDeclareClass(node: ?Object, opts?: ?Object): void + declare export function isDeclareFunction(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareFunction) + declare export function assertDeclareFunction(node: ?Object, opts?: ?Object): void + declare export function isDeclareInterface(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareInterface) + declare export function assertDeclareInterface(node: ?Object, opts?: ?Object): void + declare export function isDeclareModule(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareModule) + declare export function assertDeclareModule(node: ?Object, opts?: ?Object): void + declare export function isDeclareModuleExports(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareModuleExports) + declare export function assertDeclareModuleExports(node: ?Object, opts?: ?Object): void + declare export function isDeclareTypeAlias(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareTypeAlias) + declare export function assertDeclareTypeAlias(node: ?Object, opts?: ?Object): void + declare export function isDeclareOpaqueType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareOpaqueType) + declare export function assertDeclareOpaqueType(node: ?Object, opts?: ?Object): void + declare export function isDeclareVariable(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareVariable) + declare export function assertDeclareVariable(node: ?Object, opts?: ?Object): void + declare export function isDeclareExportDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareExportDeclaration) + declare export function assertDeclareExportDeclaration(node: ?Object, opts?: ?Object): void + declare export function isDeclareExportAllDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareExportAllDeclaration) + declare export function assertDeclareExportAllDeclaration(node: ?Object, opts?: ?Object): void + declare export function isDeclaredPredicate(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclaredPredicate) + declare export function assertDeclaredPredicate(node: ?Object, opts?: ?Object): void + declare export function isExistsTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExistsTypeAnnotation) + declare export function assertExistsTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isFunctionTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeFunctionTypeAnnotation) + declare export function assertFunctionTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isFunctionTypeParam(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeFunctionTypeParam) + declare export function assertFunctionTypeParam(node: ?Object, opts?: ?Object): void + declare export function isGenericTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeGenericTypeAnnotation) + declare export function assertGenericTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isInferredPredicate(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeInferredPredicate) + declare export function assertInferredPredicate(node: ?Object, opts?: ?Object): void + declare export function isInterfaceExtends(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeInterfaceExtends) + declare export function assertInterfaceExtends(node: ?Object, opts?: ?Object): void + declare export function isInterfaceDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeInterfaceDeclaration) + declare export function assertInterfaceDeclaration(node: ?Object, opts?: ?Object): void + declare export function isInterfaceTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeInterfaceTypeAnnotation) + declare export function assertInterfaceTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isIntersectionTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeIntersectionTypeAnnotation) + declare export function assertIntersectionTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isMixedTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeMixedTypeAnnotation) + declare export function assertMixedTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isEmptyTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEmptyTypeAnnotation) + declare export function assertEmptyTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isNullableTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNullableTypeAnnotation) + declare export function assertNullableTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isNumberLiteralTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNumberLiteralTypeAnnotation) + declare export function assertNumberLiteralTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isNumberTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNumberTypeAnnotation) + declare export function assertNumberTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isObjectTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectTypeAnnotation) + declare export function assertObjectTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isObjectTypeInternalSlot(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectTypeInternalSlot) + declare export function assertObjectTypeInternalSlot(node: ?Object, opts?: ?Object): void + declare export function isObjectTypeCallProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectTypeCallProperty) + declare export function assertObjectTypeCallProperty(node: ?Object, opts?: ?Object): void + declare export function isObjectTypeIndexer(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectTypeIndexer) + declare export function assertObjectTypeIndexer(node: ?Object, opts?: ?Object): void + declare export function isObjectTypeProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectTypeProperty) + declare export function assertObjectTypeProperty(node: ?Object, opts?: ?Object): void + declare export function isObjectTypeSpreadProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectTypeSpreadProperty) + declare export function assertObjectTypeSpreadProperty(node: ?Object, opts?: ?Object): void + declare export function isOpaqueType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeOpaqueType) + declare export function assertOpaqueType(node: ?Object, opts?: ?Object): void + declare export function isQualifiedTypeIdentifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeQualifiedTypeIdentifier) + declare export function assertQualifiedTypeIdentifier(node: ?Object, opts?: ?Object): void + declare export function isStringLiteralTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeStringLiteralTypeAnnotation) + declare export function assertStringLiteralTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isStringTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeStringTypeAnnotation) + declare export function assertStringTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isSymbolTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSymbolTypeAnnotation) + declare export function assertSymbolTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isThisTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeThisTypeAnnotation) + declare export function assertThisTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isTupleTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTupleTypeAnnotation) + declare export function assertTupleTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isTypeofTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeofTypeAnnotation) + declare export function assertTypeofTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isTypeAlias(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeAlias) + declare export function assertTypeAlias(node: ?Object, opts?: ?Object): void + declare export function isTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeAnnotation) + declare export function assertTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isTypeCastExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeCastExpression) + declare export function assertTypeCastExpression(node: ?Object, opts?: ?Object): void + declare export function isTypeParameter(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeParameter) + declare export function assertTypeParameter(node: ?Object, opts?: ?Object): void + declare export function isTypeParameterDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeParameterDeclaration) + declare export function assertTypeParameterDeclaration(node: ?Object, opts?: ?Object): void + declare export function isTypeParameterInstantiation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeParameterInstantiation) + declare export function assertTypeParameterInstantiation(node: ?Object, opts?: ?Object): void + declare export function isUnionTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeUnionTypeAnnotation) + declare export function assertUnionTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isVariance(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeVariance) + declare export function assertVariance(node: ?Object, opts?: ?Object): void + declare export function isVoidTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeVoidTypeAnnotation) + declare export function assertVoidTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isEnumDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumDeclaration) + declare export function assertEnumDeclaration(node: ?Object, opts?: ?Object): void + declare export function isEnumBooleanBody(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumBooleanBody) + declare export function assertEnumBooleanBody(node: ?Object, opts?: ?Object): void + declare export function isEnumNumberBody(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumNumberBody) + declare export function assertEnumNumberBody(node: ?Object, opts?: ?Object): void + declare export function isEnumStringBody(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumStringBody) + declare export function assertEnumStringBody(node: ?Object, opts?: ?Object): void + declare export function isEnumSymbolBody(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumSymbolBody) + declare export function assertEnumSymbolBody(node: ?Object, opts?: ?Object): void + declare export function isEnumBooleanMember(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumBooleanMember) + declare export function assertEnumBooleanMember(node: ?Object, opts?: ?Object): void + declare export function isEnumNumberMember(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumNumberMember) + declare export function assertEnumNumberMember(node: ?Object, opts?: ?Object): void + declare export function isEnumStringMember(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumStringMember) + declare export function assertEnumStringMember(node: ?Object, opts?: ?Object): void + declare export function isEnumDefaultedMember(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumDefaultedMember) + declare export function assertEnumDefaultedMember(node: ?Object, opts?: ?Object): void + declare export function isIndexedAccessType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeIndexedAccessType) + declare export function assertIndexedAccessType(node: ?Object, opts?: ?Object): void + declare export function isOptionalIndexedAccessType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeOptionalIndexedAccessType) + declare export function assertOptionalIndexedAccessType(node: ?Object, opts?: ?Object): void + declare export function isJSXAttribute(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXAttribute) + declare export function assertJSXAttribute(node: ?Object, opts?: ?Object): void + declare export function isJSXClosingElement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXClosingElement) + declare export function assertJSXClosingElement(node: ?Object, opts?: ?Object): void + declare export function isJSXElement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXElement) + declare export function assertJSXElement(node: ?Object, opts?: ?Object): void + declare export function isJSXEmptyExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXEmptyExpression) + declare export function assertJSXEmptyExpression(node: ?Object, opts?: ?Object): void + declare export function isJSXExpressionContainer(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXExpressionContainer) + declare export function assertJSXExpressionContainer(node: ?Object, opts?: ?Object): void + declare export function isJSXSpreadChild(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXSpreadChild) + declare export function assertJSXSpreadChild(node: ?Object, opts?: ?Object): void + declare export function isJSXIdentifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXIdentifier) + declare export function assertJSXIdentifier(node: ?Object, opts?: ?Object): void + declare export function isJSXMemberExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXMemberExpression) + declare export function assertJSXMemberExpression(node: ?Object, opts?: ?Object): void + declare export function isJSXNamespacedName(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXNamespacedName) + declare export function assertJSXNamespacedName(node: ?Object, opts?: ?Object): void + declare export function isJSXOpeningElement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXOpeningElement) + declare export function assertJSXOpeningElement(node: ?Object, opts?: ?Object): void + declare export function isJSXSpreadAttribute(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXSpreadAttribute) + declare export function assertJSXSpreadAttribute(node: ?Object, opts?: ?Object): void + declare export function isJSXText(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXText) + declare export function assertJSXText(node: ?Object, opts?: ?Object): void + declare export function isJSXFragment(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXFragment) + declare export function assertJSXFragment(node: ?Object, opts?: ?Object): void + declare export function isJSXOpeningFragment(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXOpeningFragment) + declare export function assertJSXOpeningFragment(node: ?Object, opts?: ?Object): void + declare export function isJSXClosingFragment(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXClosingFragment) + declare export function assertJSXClosingFragment(node: ?Object, opts?: ?Object): void + declare export function isNoop(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNoop) + declare export function assertNoop(node: ?Object, opts?: ?Object): void + declare export function isPlaceholder(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodePlaceholder) + declare export function assertPlaceholder(node: ?Object, opts?: ?Object): void + declare export function isV8IntrinsicIdentifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeV8IntrinsicIdentifier) + declare export function assertV8IntrinsicIdentifier(node: ?Object, opts?: ?Object): void + declare export function isArgumentPlaceholder(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeArgumentPlaceholder) + declare export function assertArgumentPlaceholder(node: ?Object, opts?: ?Object): void + declare export function isBindExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBindExpression) + declare export function assertBindExpression(node: ?Object, opts?: ?Object): void + declare export function isDecorator(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDecorator) + declare export function assertDecorator(node: ?Object, opts?: ?Object): void + declare export function isDoExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDoExpression) + declare export function assertDoExpression(node: ?Object, opts?: ?Object): void + declare export function isExportDefaultSpecifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportDefaultSpecifier) + declare export function assertExportDefaultSpecifier(node: ?Object, opts?: ?Object): void + declare export function isRecordExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeRecordExpression) + declare export function assertRecordExpression(node: ?Object, opts?: ?Object): void + declare export function isTupleExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTupleExpression) + declare export function assertTupleExpression(node: ?Object, opts?: ?Object): void + declare export function isDecimalLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDecimalLiteral) + declare export function assertDecimalLiteral(node: ?Object, opts?: ?Object): void + declare export function isModuleExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeModuleExpression) + declare export function assertModuleExpression(node: ?Object, opts?: ?Object): void + declare export function isTopicReference(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTopicReference) + declare export function assertTopicReference(node: ?Object, opts?: ?Object): void + declare export function isPipelineTopicExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodePipelineTopicExpression) + declare export function assertPipelineTopicExpression(node: ?Object, opts?: ?Object): void + declare export function isPipelineBareFunction(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodePipelineBareFunction) + declare export function assertPipelineBareFunction(node: ?Object, opts?: ?Object): void + declare export function isPipelinePrimaryTopicReference(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodePipelinePrimaryTopicReference) + declare export function assertPipelinePrimaryTopicReference(node: ?Object, opts?: ?Object): void + declare export function isVoidPattern(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeVoidPattern) + declare export function assertVoidPattern(node: ?Object, opts?: ?Object): void + declare export function isTSParameterProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSParameterProperty) + declare export function assertTSParameterProperty(node: ?Object, opts?: ?Object): void + declare export function isTSDeclareFunction(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSDeclareFunction) + declare export function assertTSDeclareFunction(node: ?Object, opts?: ?Object): void + declare export function isTSDeclareMethod(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSDeclareMethod) + declare export function assertTSDeclareMethod(node: ?Object, opts?: ?Object): void + declare export function isTSQualifiedName(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSQualifiedName) + declare export function assertTSQualifiedName(node: ?Object, opts?: ?Object): void + declare export function isTSCallSignatureDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSCallSignatureDeclaration) + declare export function assertTSCallSignatureDeclaration(node: ?Object, opts?: ?Object): void + declare export function isTSConstructSignatureDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSConstructSignatureDeclaration) + declare export function assertTSConstructSignatureDeclaration(node: ?Object, opts?: ?Object): void + declare export function isTSPropertySignature(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSPropertySignature) + declare export function assertTSPropertySignature(node: ?Object, opts?: ?Object): void + declare export function isTSMethodSignature(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSMethodSignature) + declare export function assertTSMethodSignature(node: ?Object, opts?: ?Object): void + declare export function isTSIndexSignature(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSIndexSignature) + declare export function assertTSIndexSignature(node: ?Object, opts?: ?Object): void + declare export function isTSAnyKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSAnyKeyword) + declare export function assertTSAnyKeyword(node: ?Object, opts?: ?Object): void + declare export function isTSBooleanKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSBooleanKeyword) + declare export function assertTSBooleanKeyword(node: ?Object, opts?: ?Object): void + declare export function isTSBigIntKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSBigIntKeyword) + declare export function assertTSBigIntKeyword(node: ?Object, opts?: ?Object): void + declare export function isTSIntrinsicKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSIntrinsicKeyword) + declare export function assertTSIntrinsicKeyword(node: ?Object, opts?: ?Object): void + declare export function isTSNeverKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSNeverKeyword) + declare export function assertTSNeverKeyword(node: ?Object, opts?: ?Object): void + declare export function isTSNullKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSNullKeyword) + declare export function assertTSNullKeyword(node: ?Object, opts?: ?Object): void + declare export function isTSNumberKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSNumberKeyword) + declare export function assertTSNumberKeyword(node: ?Object, opts?: ?Object): void + declare export function isTSObjectKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSObjectKeyword) + declare export function assertTSObjectKeyword(node: ?Object, opts?: ?Object): void + declare export function isTSStringKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSStringKeyword) + declare export function assertTSStringKeyword(node: ?Object, opts?: ?Object): void + declare export function isTSSymbolKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSSymbolKeyword) + declare export function assertTSSymbolKeyword(node: ?Object, opts?: ?Object): void + declare export function isTSUndefinedKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSUndefinedKeyword) + declare export function assertTSUndefinedKeyword(node: ?Object, opts?: ?Object): void + declare export function isTSUnknownKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSUnknownKeyword) + declare export function assertTSUnknownKeyword(node: ?Object, opts?: ?Object): void + declare export function isTSVoidKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSVoidKeyword) + declare export function assertTSVoidKeyword(node: ?Object, opts?: ?Object): void + declare export function isTSThisType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSThisType) + declare export function assertTSThisType(node: ?Object, opts?: ?Object): void + declare export function isTSFunctionType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSFunctionType) + declare export function assertTSFunctionType(node: ?Object, opts?: ?Object): void + declare export function isTSConstructorType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSConstructorType) + declare export function assertTSConstructorType(node: ?Object, opts?: ?Object): void + declare export function isTSTypeReference(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeReference) + declare export function assertTSTypeReference(node: ?Object, opts?: ?Object): void + declare export function isTSTypePredicate(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypePredicate) + declare export function assertTSTypePredicate(node: ?Object, opts?: ?Object): void + declare export function isTSTypeQuery(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeQuery) + declare export function assertTSTypeQuery(node: ?Object, opts?: ?Object): void + declare export function isTSTypeLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeLiteral) + declare export function assertTSTypeLiteral(node: ?Object, opts?: ?Object): void + declare export function isTSArrayType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSArrayType) + declare export function assertTSArrayType(node: ?Object, opts?: ?Object): void + declare export function isTSTupleType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTupleType) + declare export function assertTSTupleType(node: ?Object, opts?: ?Object): void + declare export function isTSOptionalType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSOptionalType) + declare export function assertTSOptionalType(node: ?Object, opts?: ?Object): void + declare export function isTSRestType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSRestType) + declare export function assertTSRestType(node: ?Object, opts?: ?Object): void + declare export function isTSNamedTupleMember(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSNamedTupleMember) + declare export function assertTSNamedTupleMember(node: ?Object, opts?: ?Object): void + declare export function isTSUnionType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSUnionType) + declare export function assertTSUnionType(node: ?Object, opts?: ?Object): void + declare export function isTSIntersectionType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSIntersectionType) + declare export function assertTSIntersectionType(node: ?Object, opts?: ?Object): void + declare export function isTSConditionalType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSConditionalType) + declare export function assertTSConditionalType(node: ?Object, opts?: ?Object): void + declare export function isTSInferType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSInferType) + declare export function assertTSInferType(node: ?Object, opts?: ?Object): void + declare export function isTSParenthesizedType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSParenthesizedType) + declare export function assertTSParenthesizedType(node: ?Object, opts?: ?Object): void + declare export function isTSTypeOperator(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeOperator) + declare export function assertTSTypeOperator(node: ?Object, opts?: ?Object): void + declare export function isTSIndexedAccessType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSIndexedAccessType) + declare export function assertTSIndexedAccessType(node: ?Object, opts?: ?Object): void + declare export function isTSMappedType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSMappedType) + declare export function assertTSMappedType(node: ?Object, opts?: ?Object): void + declare export function isTSTemplateLiteralType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTemplateLiteralType) + declare export function assertTSTemplateLiteralType(node: ?Object, opts?: ?Object): void + declare export function isTSLiteralType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSLiteralType) + declare export function assertTSLiteralType(node: ?Object, opts?: ?Object): void + declare export function isTSExpressionWithTypeArguments(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSExpressionWithTypeArguments) + declare export function assertTSExpressionWithTypeArguments(node: ?Object, opts?: ?Object): void + declare export function isTSInterfaceDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSInterfaceDeclaration) + declare export function assertTSInterfaceDeclaration(node: ?Object, opts?: ?Object): void + declare export function isTSInterfaceBody(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSInterfaceBody) + declare export function assertTSInterfaceBody(node: ?Object, opts?: ?Object): void + declare export function isTSTypeAliasDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeAliasDeclaration) + declare export function assertTSTypeAliasDeclaration(node: ?Object, opts?: ?Object): void + declare export function isTSInstantiationExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSInstantiationExpression) + declare export function assertTSInstantiationExpression(node: ?Object, opts?: ?Object): void + declare export function isTSAsExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSAsExpression) + declare export function assertTSAsExpression(node: ?Object, opts?: ?Object): void + declare export function isTSSatisfiesExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSSatisfiesExpression) + declare export function assertTSSatisfiesExpression(node: ?Object, opts?: ?Object): void + declare export function isTSTypeAssertion(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeAssertion) + declare export function assertTSTypeAssertion(node: ?Object, opts?: ?Object): void + declare export function isTSEnumBody(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSEnumBody) + declare export function assertTSEnumBody(node: ?Object, opts?: ?Object): void + declare export function isTSEnumDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSEnumDeclaration) + declare export function assertTSEnumDeclaration(node: ?Object, opts?: ?Object): void + declare export function isTSEnumMember(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSEnumMember) + declare export function assertTSEnumMember(node: ?Object, opts?: ?Object): void + declare export function isTSModuleDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSModuleDeclaration) + declare export function assertTSModuleDeclaration(node: ?Object, opts?: ?Object): void + declare export function isTSModuleBlock(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSModuleBlock) + declare export function assertTSModuleBlock(node: ?Object, opts?: ?Object): void + declare export function isTSImportType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSImportType) + declare export function assertTSImportType(node: ?Object, opts?: ?Object): void + declare export function isTSImportEqualsDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSImportEqualsDeclaration) + declare export function assertTSImportEqualsDeclaration(node: ?Object, opts?: ?Object): void + declare export function isTSExternalModuleReference(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSExternalModuleReference) + declare export function assertTSExternalModuleReference(node: ?Object, opts?: ?Object): void + declare export function isTSNonNullExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSNonNullExpression) + declare export function assertTSNonNullExpression(node: ?Object, opts?: ?Object): void + declare export function isTSExportAssignment(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSExportAssignment) + declare export function assertTSExportAssignment(node: ?Object, opts?: ?Object): void + declare export function isTSNamespaceExportDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSNamespaceExportDeclaration) + declare export function assertTSNamespaceExportDeclaration(node: ?Object, opts?: ?Object): void + declare export function isTSTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeAnnotation) + declare export function assertTSTypeAnnotation(node: ?Object, opts?: ?Object): void + declare export function isTSTypeParameterInstantiation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeParameterInstantiation) + declare export function assertTSTypeParameterInstantiation(node: ?Object, opts?: ?Object): void + declare export function isTSTypeParameterDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeParameterDeclaration) + declare export function assertTSTypeParameterDeclaration(node: ?Object, opts?: ?Object): void + declare export function isTSTypeParameter(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeParameter) + declare export function assertTSTypeParameter(node: ?Object, opts?: ?Object): void + declare export function isStandardized(node: ?Object, opts?: ?Object): boolean + declare export function assertStandardized(node: ?Object, opts?: ?Object): void + declare export function isExpression(node: ?Object, opts?: ?Object): boolean + declare export function assertExpression(node: ?Object, opts?: ?Object): void + declare export function isBinary(node: ?Object, opts?: ?Object): boolean + declare export function assertBinary(node: ?Object, opts?: ?Object): void + declare export function isScopable(node: ?Object, opts?: ?Object): boolean + declare export function assertScopable(node: ?Object, opts?: ?Object): void + declare export function isBlockParent(node: ?Object, opts?: ?Object): boolean + declare export function assertBlockParent(node: ?Object, opts?: ?Object): void + declare export function isBlock(node: ?Object, opts?: ?Object): boolean + declare export function assertBlock(node: ?Object, opts?: ?Object): void + declare export function isStatement(node: ?Object, opts?: ?Object): boolean + declare export function assertStatement(node: ?Object, opts?: ?Object): void + declare export function isTerminatorless(node: ?Object, opts?: ?Object): boolean + declare export function assertTerminatorless(node: ?Object, opts?: ?Object): void + declare export function isCompletionStatement(node: ?Object, opts?: ?Object): boolean + declare export function assertCompletionStatement(node: ?Object, opts?: ?Object): void + declare export function isConditional(node: ?Object, opts?: ?Object): boolean + declare export function assertConditional(node: ?Object, opts?: ?Object): void + declare export function isLoop(node: ?Object, opts?: ?Object): boolean + declare export function assertLoop(node: ?Object, opts?: ?Object): void + declare export function isWhile(node: ?Object, opts?: ?Object): boolean + declare export function assertWhile(node: ?Object, opts?: ?Object): void + declare export function isExpressionWrapper(node: ?Object, opts?: ?Object): boolean + declare export function assertExpressionWrapper(node: ?Object, opts?: ?Object): void + declare export function isFor(node: ?Object, opts?: ?Object): boolean + declare export function assertFor(node: ?Object, opts?: ?Object): void + declare export function isForXStatement(node: ?Object, opts?: ?Object): boolean + declare export function assertForXStatement(node: ?Object, opts?: ?Object): void + declare export function isFunction(node: ?Object, opts?: ?Object): boolean + declare export function assertFunction(node: ?Object, opts?: ?Object): void + declare export function isFunctionParent(node: ?Object, opts?: ?Object): boolean + declare export function assertFunctionParent(node: ?Object, opts?: ?Object): void + declare export function isPureish(node: ?Object, opts?: ?Object): boolean + declare export function assertPureish(node: ?Object, opts?: ?Object): void + declare export function isDeclaration(node: ?Object, opts?: ?Object): boolean + declare export function assertDeclaration(node: ?Object, opts?: ?Object): void + declare export function isFunctionParameter(node: ?Object, opts?: ?Object): boolean + declare export function assertFunctionParameter(node: ?Object, opts?: ?Object): void + declare export function isPatternLike(node: ?Object, opts?: ?Object): boolean + declare export function assertPatternLike(node: ?Object, opts?: ?Object): void + declare export function isLVal(node: ?Object, opts?: ?Object): boolean + declare export function assertLVal(node: ?Object, opts?: ?Object): void + declare export function isTSEntityName(node: ?Object, opts?: ?Object): boolean + declare export function assertTSEntityName(node: ?Object, opts?: ?Object): void + declare export function isLiteral(node: ?Object, opts?: ?Object): boolean + declare export function assertLiteral(node: ?Object, opts?: ?Object): void + declare export function isImmutable(node: ?Object, opts?: ?Object): boolean + declare export function assertImmutable(node: ?Object, opts?: ?Object): void + declare export function isUserWhitespacable(node: ?Object, opts?: ?Object): boolean + declare export function assertUserWhitespacable(node: ?Object, opts?: ?Object): void + declare export function isMethod(node: ?Object, opts?: ?Object): boolean + declare export function assertMethod(node: ?Object, opts?: ?Object): void + declare export function isObjectMember(node: ?Object, opts?: ?Object): boolean + declare export function assertObjectMember(node: ?Object, opts?: ?Object): void + declare export function isProperty(node: ?Object, opts?: ?Object): boolean + declare export function assertProperty(node: ?Object, opts?: ?Object): void + declare export function isUnaryLike(node: ?Object, opts?: ?Object): boolean + declare export function assertUnaryLike(node: ?Object, opts?: ?Object): void + declare export function isPattern(node: ?Object, opts?: ?Object): boolean + declare export function assertPattern(node: ?Object, opts?: ?Object): void + declare export function isClass(node: ?Object, opts?: ?Object): boolean + declare export function assertClass(node: ?Object, opts?: ?Object): void + declare export function isImportOrExportDeclaration(node: ?Object, opts?: ?Object): boolean + declare export function assertImportOrExportDeclaration(node: ?Object, opts?: ?Object): void + declare export function isExportDeclaration(node: ?Object, opts?: ?Object): boolean + declare export function assertExportDeclaration(node: ?Object, opts?: ?Object): void + declare export function isModuleSpecifier(node: ?Object, opts?: ?Object): boolean + declare export function assertModuleSpecifier(node: ?Object, opts?: ?Object): void + declare export function isAccessor(node: ?Object, opts?: ?Object): boolean + declare export function assertAccessor(node: ?Object, opts?: ?Object): void + declare export function isPrivate(node: ?Object, opts?: ?Object): boolean + declare export function assertPrivate(node: ?Object, opts?: ?Object): void + declare export function isFlow(node: ?Object, opts?: ?Object): boolean + declare export function assertFlow(node: ?Object, opts?: ?Object): void + declare export function isFlowType(node: ?Object, opts?: ?Object): boolean + declare export function assertFlowType(node: ?Object, opts?: ?Object): void + declare export function isFlowBaseAnnotation(node: ?Object, opts?: ?Object): boolean + declare export function assertFlowBaseAnnotation(node: ?Object, opts?: ?Object): void + declare export function isFlowDeclaration(node: ?Object, opts?: ?Object): boolean + declare export function assertFlowDeclaration(node: ?Object, opts?: ?Object): void + declare export function isFlowPredicate(node: ?Object, opts?: ?Object): boolean + declare export function assertFlowPredicate(node: ?Object, opts?: ?Object): void + declare export function isEnumBody(node: ?Object, opts?: ?Object): boolean + declare export function assertEnumBody(node: ?Object, opts?: ?Object): void + declare export function isEnumMember(node: ?Object, opts?: ?Object): boolean + declare export function assertEnumMember(node: ?Object, opts?: ?Object): void + declare export function isJSX(node: ?Object, opts?: ?Object): boolean + declare export function assertJSX(node: ?Object, opts?: ?Object): void + declare export function isMiscellaneous(node: ?Object, opts?: ?Object): boolean + declare export function assertMiscellaneous(node: ?Object, opts?: ?Object): void + declare export function isTypeScript(node: ?Object, opts?: ?Object): boolean + declare export function assertTypeScript(node: ?Object, opts?: ?Object): void + declare export function isTSTypeElement(node: ?Object, opts?: ?Object): boolean + declare export function assertTSTypeElement(node: ?Object, opts?: ?Object): void + declare export function isTSType(node: ?Object, opts?: ?Object): boolean + declare export function assertTSType(node: ?Object, opts?: ?Object): void + declare export function isTSBaseType(node: ?Object, opts?: ?Object): boolean + declare export function assertTSBaseType(node: ?Object, opts?: ?Object): void + declare export function isModuleDeclaration(node: ?Object, opts?: ?Object): boolean + declare export function assertModuleDeclaration(node: ?Object, opts?: ?Object): void + declare export function isNumberLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNumericLiteral) + declare export function assertNumberLiteral(node: ?Object, opts?: ?Object): void + declare export function isRegexLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeRegExpLiteral) + declare export function assertRegexLiteral(node: ?Object, opts?: ?Object): void + declare export function isRestProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeRestElement) + declare export function assertRestProperty(node: ?Object, opts?: ?Object): void + declare export function isSpreadProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSpreadElement) + declare export function assertSpreadProperty(node: ?Object, opts?: ?Object): void + declare export var VISITOR_KEYS: { [type: string]: string[] } + declare export function assertNode(obj: any): void + declare export function createTypeAnnotationBasedOnTypeof(type: 'string' | 'number' | 'undefined' | 'boolean' | 'function' | 'object' | 'symbol'): BabelNodeTypeAnnotation + declare export function createUnionTypeAnnotation(types: Array): BabelNodeUnionTypeAnnotation + declare export function createFlowUnionType(types: Array): BabelNodeUnionTypeAnnotation + declare export function buildChildren(node: { children: Array }): Array + declare export function clone(n: T): T; + declare export function cloneDeep(n: T): T; + declare export function cloneDeepWithoutLoc(n: T): T; + declare export function cloneNode(n: T, deep?: boolean, withoutLoc?: boolean): T; + declare export function cloneWithoutLoc(n: T): T; + declare type CommentTypeShorthand = 'leading' | 'inner' | 'trailing' + declare export function addComment(node: T, type: CommentTypeShorthand, content: string, line?: boolean): T + declare export function addComments(node: T, type: CommentTypeShorthand, comments: Array): T + declare export function inheritInnerComments(node: BabelNode, parent: BabelNode): void + declare export function inheritLeadingComments(node: BabelNode, parent: BabelNode): void + declare export function inheritsComments(node: T, parent: BabelNode): void + declare export function inheritTrailingComments(node: BabelNode, parent: BabelNode): void + declare export function removeComments(node: T): T + declare export function ensureBlock(node: BabelNode, key: string): BabelNodeBlockStatement + declare export function toBindingIdentifierName(name?: ?string): string + declare export function toBlock(node: BabelNodeStatement | BabelNodeExpression, parent?: BabelNodeFunction | null): BabelNodeBlockStatement + declare export function toComputedKey(node: BabelNodeMethod | BabelNodeProperty, key?: BabelNodeExpression | BabelNodeIdentifier): BabelNodeExpression + declare export function toExpression(node: BabelNodeExpressionStatement | BabelNodeExpression | BabelNodeClass | BabelNodeFunction): BabelNodeExpression + declare export function toIdentifier(name?: ?string): string + declare export function toKeyAlias(node: BabelNodeMethod | BabelNodeProperty, key?: BabelNode): string + declare export function toStatement(node: BabelNodeStatement | BabelNodeClass | BabelNodeFunction | BabelNodeAssignmentExpression, ignore?: boolean): BabelNodeStatement | void + declare export function valueToNode(value: any): BabelNodeExpression + declare export function removeTypeDuplicates(types: Array): Array + declare export function appendToMemberExpression(member: BabelNodeMemberExpression, append: BabelNode, computed?: boolean): BabelNodeMemberExpression + declare export function inherits(child: T, parent: BabelNode | null | void): T + declare export function prependToMemberExpression(member: BabelNodeMemberExpression, prepend: BabelNodeExpression): BabelNodeMemberExpression + declare export function removeProperties(n: T, opts: ?{}): void; + declare export function removePropertiesDeep(n: T, opts: ?{}): T; + declare export var getBindingIdentifiers: { + (node: BabelNode, duplicates?: boolean, outerOnly?: boolean): { [key: string]: BabelNodeIdentifier | Array }, + keys: { [type: string]: string[] } + } + declare export function getOuterBindingIdentifiers(node: BabelNode, duplicates?: boolean): { [key: string]: BabelNodeIdentifier | Array } + declare type TraversalAncestors = Array<{ + node: BabelNode, + key: string, + index?: number, + }>; + declare type TraversalHandler = (BabelNode, TraversalAncestors, T) => void; + declare type TraversalHandlers = { + enter?: TraversalHandler, + exit?: TraversalHandler, + }; + declare export function traverse(n: BabelNode, TraversalHandler | TraversalHandlers, state?: T): void; + declare export function traverseFast(n: BabelNode, h: TraversalHandler, state?: T): void; + declare export function shallowEqual(actual: Object, expected: Object): boolean + declare export function buildMatchMemberExpression(match: string, allowPartial?: boolean): (?BabelNode) => boolean + declare export function is(type: string, n: BabelNode, opts: Object): boolean; + declare export function isBinding(node: BabelNode, parent: BabelNode, grandparent?: BabelNode): boolean + declare export function isBlockScoped(node: BabelNode): boolean + declare export function isImmutable(node: BabelNode): boolean + declare export function isLet(node: BabelNode): boolean + declare export function isNode(node: ?Object): boolean + declare export function isNodesEquivalent(a: any, b: any): boolean + declare export function isPlaceholderType(placeholderType: string, targetType: string): boolean + declare export function isReferenced(node: BabelNode, parent: BabelNode, grandparent?: BabelNode): boolean + declare export function isScope(node: BabelNode, parent: BabelNode): boolean + declare export function isSpecifierDefault(specifier: BabelNodeModuleSpecifier): boolean + declare export function isType(nodetype: ?string, targetType: string): boolean + declare export function isValidES3Identifier(name: string): boolean + declare export function isValidES3Identifier(name: string): boolean + declare export function isValidIdentifier(name: string): boolean + declare export function isVar(node: BabelNode): boolean + declare export function matchesPattern(node: ?BabelNode, match: string | Array, allowPartial?: boolean): boolean + declare export function validate(n: BabelNode, key: string, value: mixed): void; +} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/index.js.map b/scripts/node_modules/@babel/types/lib/index.js.map new file mode 100644 index 0000000000000000000000000000000000000000..8ce007b68e4a1ccc43cda051d4d56e1537bf2f32 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/index.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_isReactComponent","require","_isCompatTag","_buildChildren","_assertNode","_index","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_createTypeAnnotationBasedOnTypeof","_createFlowUnionType","_createTSUnionType","_productions","_index2","_cloneNode","_clone","_cloneDeep","_cloneDeepWithoutLoc","_cloneWithoutLoc","_addComment","_addComments","_inheritInnerComments","_inheritLeadingComments","_inheritsComments","_inheritTrailingComments","_removeComments","_index3","_index4","_ensureBlock","_toBindingIdentifierName","_toBlock","_toComputedKey","_toExpression","_toIdentifier","_toKeyAlias","_toStatement","_valueToNode","_index5","_appendToMemberExpression","_inherits","_prependToMemberExpression","_removeProperties","_removePropertiesDeep","_removeTypeDuplicates","_getAssignmentIdentifiers","_getBindingIdentifiers","_getOuterBindingIdentifiers","_getFunctionName","_traverse","_traverseFast","_shallowEqual","_is","_isBinding","_isBlockScoped","_isImmutable","_isLet","_isNode","_isNodesEquivalent","_isPlaceholderType","_isReferenced","_isScope","_isSpecifierDefault","_isType","_isValidES3Identifier","_isValidIdentifier","_isVar","_matchesPattern","_validate","_buildMatchMemberExpression","_index6","_deprecationWarning","_toSequenceExpression","react","isReactComponent","isCompatTag","buildChildren","toSequenceExpression","process","env","BABEL_TYPES_8_BREAKING","console","warn"],"sources":["../src/index.ts"],"sourcesContent":["import isReactComponent from \"./validators/react/isReactComponent.ts\";\nimport isCompatTag from \"./validators/react/isCompatTag.ts\";\nimport buildChildren from \"./builders/react/buildChildren.ts\";\n\n// asserts\nexport { default as assertNode } from \"./asserts/assertNode.ts\";\nexport * from \"./asserts/generated/index.ts\";\n\n// builders\nexport { default as createTypeAnnotationBasedOnTypeof } from \"./builders/flow/createTypeAnnotationBasedOnTypeof.ts\";\n/** @deprecated use createFlowUnionType instead */\nexport { default as createUnionTypeAnnotation } from \"./builders/flow/createFlowUnionType.ts\";\nexport { default as createFlowUnionType } from \"./builders/flow/createFlowUnionType.ts\";\nexport { default as createTSUnionType } from \"./builders/typescript/createTSUnionType.ts\";\nexport * from \"./builders/productions.ts\";\nexport * from \"./builders/generated/index.ts\"; // includes AST types\n\n// clone\nexport { default as cloneNode } from \"./clone/cloneNode.ts\";\nexport { default as clone } from \"./clone/clone.ts\";\nexport { default as cloneDeep } from \"./clone/cloneDeep.ts\";\nexport { default as cloneDeepWithoutLoc } from \"./clone/cloneDeepWithoutLoc.ts\";\nexport { default as cloneWithoutLoc } from \"./clone/cloneWithoutLoc.ts\";\n\n// comments\nexport { default as addComment } from \"./comments/addComment.ts\";\nexport { default as addComments } from \"./comments/addComments.ts\";\nexport { default as inheritInnerComments } from \"./comments/inheritInnerComments.ts\";\nexport { default as inheritLeadingComments } from \"./comments/inheritLeadingComments.ts\";\nexport { default as inheritsComments } from \"./comments/inheritsComments.ts\";\nexport { default as inheritTrailingComments } from \"./comments/inheritTrailingComments.ts\";\nexport { default as removeComments } from \"./comments/removeComments.ts\";\n\n// constants\nexport * from \"./constants/generated/index.ts\";\nexport * from \"./constants/index.ts\";\n\n// converters\nexport { default as ensureBlock } from \"./converters/ensureBlock.ts\";\nexport { default as toBindingIdentifierName } from \"./converters/toBindingIdentifierName.ts\";\nexport { default as toBlock } from \"./converters/toBlock.ts\";\nexport { default as toComputedKey } from \"./converters/toComputedKey.ts\";\nexport { default as toExpression } from \"./converters/toExpression.ts\";\nexport { default as toIdentifier } from \"./converters/toIdentifier.ts\";\nexport { default as toKeyAlias } from \"./converters/toKeyAlias.ts\";\nexport { default as toStatement } from \"./converters/toStatement.ts\";\nexport { default as valueToNode } from \"./converters/valueToNode.ts\";\n\n// definitions\nexport * from \"./definitions/index.ts\";\n\n// modifications\nexport { default as appendToMemberExpression } from \"./modifications/appendToMemberExpression.ts\";\nexport { default as inherits } from \"./modifications/inherits.ts\";\nexport { default as prependToMemberExpression } from \"./modifications/prependToMemberExpression.ts\";\nexport {\n default as removeProperties,\n type Options as RemovePropertiesOptions,\n} from \"./modifications/removeProperties.ts\";\nexport { default as removePropertiesDeep } from \"./modifications/removePropertiesDeep.ts\";\nexport { default as removeTypeDuplicates } from \"./modifications/flow/removeTypeDuplicates.ts\";\n\n// retrievers\nexport { default as getAssignmentIdentifiers } from \"./retrievers/getAssignmentIdentifiers.ts\";\nexport { default as getBindingIdentifiers } from \"./retrievers/getBindingIdentifiers.ts\";\nexport { default as getOuterBindingIdentifiers } from \"./retrievers/getOuterBindingIdentifiers.ts\";\nexport { default as getFunctionName } from \"./retrievers/getFunctionName.ts\";\n\n// traverse\nexport { default as traverse } from \"./traverse/traverse.ts\";\nexport * from \"./traverse/traverse.ts\";\nexport { default as traverseFast } from \"./traverse/traverseFast.ts\";\n\n// utils\nexport { default as shallowEqual } from \"./utils/shallowEqual.ts\";\n\n// validators\nexport { default as is } from \"./validators/is.ts\";\nexport { default as isBinding } from \"./validators/isBinding.ts\";\nexport { default as isBlockScoped } from \"./validators/isBlockScoped.ts\";\nexport { default as isImmutable } from \"./validators/isImmutable.ts\";\nexport { default as isLet } from \"./validators/isLet.ts\";\nexport { default as isNode } from \"./validators/isNode.ts\";\nexport { default as isNodesEquivalent } from \"./validators/isNodesEquivalent.ts\";\nexport { default as isPlaceholderType } from \"./validators/isPlaceholderType.ts\";\nexport { default as isReferenced } from \"./validators/isReferenced.ts\";\nexport { default as isScope } from \"./validators/isScope.ts\";\nexport { default as isSpecifierDefault } from \"./validators/isSpecifierDefault.ts\";\nexport { default as isType } from \"./validators/isType.ts\";\nexport { default as isValidES3Identifier } from \"./validators/isValidES3Identifier.ts\";\nexport { default as isValidIdentifier } from \"./validators/isValidIdentifier.ts\";\nexport { default as isVar } from \"./validators/isVar.ts\";\nexport { default as matchesPattern } from \"./validators/matchesPattern.ts\";\nexport { default as validate } from \"./validators/validate.ts\";\nexport { default as buildMatchMemberExpression } from \"./validators/buildMatchMemberExpression.ts\";\nexport * from \"./validators/generated/index.ts\";\n\n// react\nexport const react = {\n isReactComponent,\n isCompatTag,\n buildChildren,\n};\n\n// this is used by @babel/traverse to warn about deprecated visitors\nexport { default as __internal__deprecationWarning } from \"./utils/deprecationWarning.ts\";\n\nimport toSequenceExpression from \"./converters/toSequenceExpression.ts\" with { if: \"!process.env.BABEL_8_BREAKING && !USE_ESM && !IS_STANDALONE\" };\nif (!process.env.BABEL_8_BREAKING && !USE_ESM && !IS_STANDALONE) {\n // eslint-disable-next-line no-restricted-globals\n exports.toSequenceExpression = toSequenceExpression;\n}\n\nif (!process.env.BABEL_8_BREAKING && process.env.BABEL_TYPES_8_BREAKING) {\n console.warn(\n \"BABEL_TYPES_8_BREAKING is not supported anymore. Use the latest Babel 8.0.0 pre-release instead!\",\n );\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/modifications/appendToMemberExpression.js b/scripts/node_modules/@babel/types/lib/modifications/appendToMemberExpression.js new file mode 100644 index 0000000000000000000000000000000000000000..48ff2a2aeb0753539fd5aa7793c11093af14bbf0 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/modifications/appendToMemberExpression.js @@ -0,0 +1,15 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = appendToMemberExpression; +var _index = require("../builders/generated/index.js"); +function appendToMemberExpression(member, append, computed = false) { + member.object = (0, _index.memberExpression)(member.object, member.property, member.computed); + member.property = append; + member.computed = !!computed; + return member; +} + +//# sourceMappingURL=appendToMemberExpression.js.map diff --git a/scripts/node_modules/@babel/types/lib/modifications/appendToMemberExpression.js.map b/scripts/node_modules/@babel/types/lib/modifications/appendToMemberExpression.js.map new file mode 100644 index 0000000000000000000000000000000000000000..33236a9ca86d38edcdd11343b5b1ec1be0222350 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/modifications/appendToMemberExpression.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_index","require","appendToMemberExpression","member","append","computed","object","memberExpression","property"],"sources":["../../src/modifications/appendToMemberExpression.ts"],"sourcesContent":["import { memberExpression } from \"../builders/generated/index.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Append a node to a member expression.\n */\nexport default function appendToMemberExpression(\n member: t.MemberExpression,\n append: t.MemberExpression[\"property\"],\n computed: boolean = false,\n): t.MemberExpression {\n member.object = memberExpression(\n member.object,\n member.property,\n member.computed,\n );\n member.property = append;\n member.computed = !!computed;\n\n return member;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAMe,SAASC,wBAAwBA,CAC9CC,MAA0B,EAC1BC,MAAsC,EACtCC,QAAiB,GAAG,KAAK,EACL;EACpBF,MAAM,CAACG,MAAM,GAAG,IAAAC,uBAAgB,EAC9BJ,MAAM,CAACG,MAAM,EACbH,MAAM,CAACK,QAAQ,EACfL,MAAM,CAACE,QACT,CAAC;EACDF,MAAM,CAACK,QAAQ,GAAGJ,MAAM;EACxBD,MAAM,CAACE,QAAQ,GAAG,CAAC,CAACA,QAAQ;EAE5B,OAAOF,MAAM;AACf","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js b/scripts/node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js new file mode 100644 index 0000000000000000000000000000000000000000..edbdd8bacd312f7450ce98ac616c219151dfa65a --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js @@ -0,0 +1,65 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = removeTypeDuplicates; +var _index = require("../../validators/generated/index.js"); +function getQualifiedName(node) { + return (0, _index.isIdentifier)(node) ? node.name : `${node.id.name}.${getQualifiedName(node.qualification)}`; +} +function removeTypeDuplicates(nodesIn) { + const nodes = Array.from(nodesIn); + const generics = new Map(); + const bases = new Map(); + const typeGroups = new Set(); + const types = []; + for (let i = 0; i < nodes.length; i++) { + const node = nodes[i]; + if (!node) continue; + if (types.includes(node)) { + continue; + } + if ((0, _index.isAnyTypeAnnotation)(node)) { + return [node]; + } + if ((0, _index.isFlowBaseAnnotation)(node)) { + bases.set(node.type, node); + continue; + } + if ((0, _index.isUnionTypeAnnotation)(node)) { + if (!typeGroups.has(node.types)) { + nodes.push(...node.types); + typeGroups.add(node.types); + } + continue; + } + if ((0, _index.isGenericTypeAnnotation)(node)) { + const name = getQualifiedName(node.id); + if (generics.has(name)) { + let existing = generics.get(name); + if (existing.typeParameters) { + if (node.typeParameters) { + existing.typeParameters.params.push(...node.typeParameters.params); + existing.typeParameters.params = removeTypeDuplicates(existing.typeParameters.params); + } + } else { + existing = node.typeParameters; + } + } else { + generics.set(name, node); + } + continue; + } + types.push(node); + } + for (const [, baseType] of bases) { + types.push(baseType); + } + for (const [, genericName] of generics) { + types.push(genericName); + } + return types; +} + +//# sourceMappingURL=removeTypeDuplicates.js.map diff --git a/scripts/node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js.map b/scripts/node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js.map new file mode 100644 index 0000000000000000000000000000000000000000..09468cac7d17a2cd87dbe5f9ecaf17c878e8321d --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_index","require","getQualifiedName","node","isIdentifier","name","id","qualification","removeTypeDuplicates","nodesIn","nodes","Array","from","generics","Map","bases","typeGroups","Set","types","i","length","includes","isAnyTypeAnnotation","isFlowBaseAnnotation","set","type","isUnionTypeAnnotation","has","push","add","isGenericTypeAnnotation","existing","get","typeParameters","params","baseType","genericName"],"sources":["../../../src/modifications/flow/removeTypeDuplicates.ts"],"sourcesContent":["import {\n isAnyTypeAnnotation,\n isGenericTypeAnnotation,\n isUnionTypeAnnotation,\n isFlowBaseAnnotation,\n isIdentifier,\n} from \"../../validators/generated/index.ts\";\nimport type * as t from \"../../index.ts\";\n\nfunction getQualifiedName(node: t.GenericTypeAnnotation[\"id\"]): string {\n return isIdentifier(node)\n ? node.name\n : `${node.id.name}.${getQualifiedName(node.qualification)}`;\n}\n\n/**\n * Dedupe type annotations.\n */\nexport default function removeTypeDuplicates(\n nodesIn: readonly (t.FlowType | false | null | undefined)[],\n): t.FlowType[] {\n const nodes = Array.from(nodesIn);\n\n const generics = new Map();\n const bases = new Map();\n\n // store union type groups to circular references\n const typeGroups = new Set();\n\n const types: t.FlowType[] = [];\n\n for (let i = 0; i < nodes.length; i++) {\n const node = nodes[i];\n if (!node) continue;\n\n // detect duplicates\n if (types.includes(node)) {\n continue;\n }\n\n // this type matches anything\n if (isAnyTypeAnnotation(node)) {\n return [node];\n }\n\n if (isFlowBaseAnnotation(node)) {\n bases.set(node.type, node);\n continue;\n }\n\n if (isUnionTypeAnnotation(node)) {\n if (!typeGroups.has(node.types)) {\n nodes.push(...node.types);\n typeGroups.add(node.types);\n }\n continue;\n }\n\n // find a matching generic type and merge and deduplicate the type parameters\n if (isGenericTypeAnnotation(node)) {\n const name = getQualifiedName(node.id);\n\n if (generics.has(name)) {\n let existing: t.Flow = generics.get(name);\n if (existing.typeParameters) {\n if (node.typeParameters) {\n existing.typeParameters.params.push(...node.typeParameters.params);\n existing.typeParameters.params = removeTypeDuplicates(\n existing.typeParameters.params,\n );\n }\n } else {\n existing = node.typeParameters;\n }\n } else {\n generics.set(name, node);\n }\n\n continue;\n }\n\n types.push(node);\n }\n\n // add back in bases\n for (const [, baseType] of bases) {\n types.push(baseType);\n }\n\n // add back in generics\n for (const [, genericName] of generics) {\n types.push(genericName);\n }\n\n return types;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AASA,SAASC,gBAAgBA,CAACC,IAAmC,EAAU;EACrE,OAAO,IAAAC,mBAAY,EAACD,IAAI,CAAC,GACrBA,IAAI,CAACE,IAAI,GACT,GAAGF,IAAI,CAACG,EAAE,CAACD,IAAI,IAAIH,gBAAgB,CAACC,IAAI,CAACI,aAAa,CAAC,EAAE;AAC/D;AAKe,SAASC,oBAAoBA,CAC1CC,OAA2D,EAC7C;EACd,MAAMC,KAAK,GAAGC,KAAK,CAACC,IAAI,CAACH,OAAO,CAAC;EAEjC,MAAMI,QAAQ,GAAG,IAAIC,GAAG,CAAkC,CAAC;EAC3D,MAAMC,KAAK,GAAG,IAAID,GAAG,CAAqD,CAAC;EAG3E,MAAME,UAAU,GAAG,IAAIC,GAAG,CAAe,CAAC;EAE1C,MAAMC,KAAmB,GAAG,EAAE;EAE9B,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGT,KAAK,CAACU,MAAM,EAAED,CAAC,EAAE,EAAE;IACrC,MAAMhB,IAAI,GAAGO,KAAK,CAACS,CAAC,CAAC;IACrB,IAAI,CAAChB,IAAI,EAAE;IAGX,IAAIe,KAAK,CAACG,QAAQ,CAAClB,IAAI,CAAC,EAAE;MACxB;IACF;IAGA,IAAI,IAAAmB,0BAAmB,EAACnB,IAAI,CAAC,EAAE;MAC7B,OAAO,CAACA,IAAI,CAAC;IACf;IAEA,IAAI,IAAAoB,2BAAoB,EAACpB,IAAI,CAAC,EAAE;MAC9BY,KAAK,CAACS,GAAG,CAACrB,IAAI,CAACsB,IAAI,EAAEtB,IAAI,CAAC;MAC1B;IACF;IAEA,IAAI,IAAAuB,4BAAqB,EAACvB,IAAI,CAAC,EAAE;MAC/B,IAAI,CAACa,UAAU,CAACW,GAAG,CAACxB,IAAI,CAACe,KAAK,CAAC,EAAE;QAC/BR,KAAK,CAACkB,IAAI,CAAC,GAAGzB,IAAI,CAACe,KAAK,CAAC;QACzBF,UAAU,CAACa,GAAG,CAAC1B,IAAI,CAACe,KAAK,CAAC;MAC5B;MACA;IACF;IAGA,IAAI,IAAAY,8BAAuB,EAAC3B,IAAI,CAAC,EAAE;MACjC,MAAME,IAAI,GAAGH,gBAAgB,CAACC,IAAI,CAACG,EAAE,CAAC;MAEtC,IAAIO,QAAQ,CAACc,GAAG,CAACtB,IAAI,CAAC,EAAE;QACtB,IAAI0B,QAAgB,GAAGlB,QAAQ,CAACmB,GAAG,CAAC3B,IAAI,CAAC;QACzC,IAAI0B,QAAQ,CAACE,cAAc,EAAE;UAC3B,IAAI9B,IAAI,CAAC8B,cAAc,EAAE;YACvBF,QAAQ,CAACE,cAAc,CAACC,MAAM,CAACN,IAAI,CAAC,GAAGzB,IAAI,CAAC8B,cAAc,CAACC,MAAM,CAAC;YAClEH,QAAQ,CAACE,cAAc,CAACC,MAAM,GAAG1B,oBAAoB,CACnDuB,QAAQ,CAACE,cAAc,CAACC,MAC1B,CAAC;UACH;QACF,CAAC,MAAM;UACLH,QAAQ,GAAG5B,IAAI,CAAC8B,cAAc;QAChC;MACF,CAAC,MAAM;QACLpB,QAAQ,CAACW,GAAG,CAACnB,IAAI,EAAEF,IAAI,CAAC;MAC1B;MAEA;IACF;IAEAe,KAAK,CAACU,IAAI,CAACzB,IAAI,CAAC;EAClB;EAGA,KAAK,MAAM,GAAGgC,QAAQ,CAAC,IAAIpB,KAAK,EAAE;IAChCG,KAAK,CAACU,IAAI,CAACO,QAAQ,CAAC;EACtB;EAGA,KAAK,MAAM,GAAGC,WAAW,CAAC,IAAIvB,QAAQ,EAAE;IACtCK,KAAK,CAACU,IAAI,CAACQ,WAAW,CAAC;EACzB;EAEA,OAAOlB,KAAK;AACd","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/modifications/inherits.js b/scripts/node_modules/@babel/types/lib/modifications/inherits.js new file mode 100644 index 0000000000000000000000000000000000000000..7667d9ea63750934c46da5c4124de4d130b4ca2e --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/modifications/inherits.js @@ -0,0 +1,28 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = inherits; +var _index = require("../constants/index.js"); +var _inheritsComments = require("../comments/inheritsComments.js"); +function inherits(child, parent) { + if (!child || !parent) return child; + for (const key of _index.INHERIT_KEYS.optional) { + if (child[key] == null) { + child[key] = parent[key]; + } + } + for (const key of Object.keys(parent)) { + if (key.startsWith("_") && key !== "__clone") { + child[key] = parent[key]; + } + } + for (const key of _index.INHERIT_KEYS.force) { + child[key] = parent[key]; + } + (0, _inheritsComments.default)(child, parent); + return child; +} + +//# sourceMappingURL=inherits.js.map diff --git a/scripts/node_modules/@babel/types/lib/modifications/inherits.js.map b/scripts/node_modules/@babel/types/lib/modifications/inherits.js.map new file mode 100644 index 0000000000000000000000000000000000000000..188e94f003b43e9db2851e672a394b22231e4758 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/modifications/inherits.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_index","require","_inheritsComments","inherits","child","parent","key","INHERIT_KEYS","optional","Object","keys","startsWith","force","inheritsComments"],"sources":["../../src/modifications/inherits.ts"],"sourcesContent":["import { INHERIT_KEYS } from \"../constants/index.ts\";\nimport inheritsComments from \"../comments/inheritsComments.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Inherit all contextual properties from `parent` node to `child` node.\n */\nexport default function inherits(\n child: T,\n parent: t.Node | null | undefined,\n): T {\n if (!child || !parent) return child;\n\n // optionally inherit specific properties if not null\n for (const key of INHERIT_KEYS.optional) {\n // @ts-expect-error Fixme: refine parent types\n if (child[key] == null) {\n // @ts-expect-error Fixme: refine parent types\n child[key] = parent[key];\n }\n }\n\n // force inherit \"private\" properties\n for (const key of Object.keys(parent)) {\n if (key.startsWith(\"_\") && key !== \"__clone\") {\n // @ts-expect-error Fixme: refine parent types\n child[key] = parent[key];\n }\n }\n\n // force inherit select properties\n for (const key of INHERIT_KEYS.force) {\n // @ts-expect-error Fixme: refine parent types\n child[key] = parent[key];\n }\n\n inheritsComments(child, parent);\n\n return child;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,iBAAA,GAAAD,OAAA;AAMe,SAASE,QAAQA,CAC9BC,KAAQ,EACRC,MAAiC,EAC9B;EACH,IAAI,CAACD,KAAK,IAAI,CAACC,MAAM,EAAE,OAAOD,KAAK;EAGnC,KAAK,MAAME,GAAG,IAAIC,mBAAY,CAACC,QAAQ,EAAE;IAEvC,IAAIJ,KAAK,CAACE,GAAG,CAAC,IAAI,IAAI,EAAE;MAEtBF,KAAK,CAACE,GAAG,CAAC,GAAGD,MAAM,CAACC,GAAG,CAAC;IAC1B;EACF;EAGA,KAAK,MAAMA,GAAG,IAAIG,MAAM,CAACC,IAAI,CAACL,MAAM,CAAC,EAAE;IACrC,IAAIC,GAAG,CAACK,UAAU,CAAC,GAAG,CAAC,IAAIL,GAAG,KAAK,SAAS,EAAE;MAE5CF,KAAK,CAACE,GAAG,CAAC,GAAGD,MAAM,CAACC,GAAG,CAAC;IAC1B;EACF;EAGA,KAAK,MAAMA,GAAG,IAAIC,mBAAY,CAACK,KAAK,EAAE;IAEpCR,KAAK,CAACE,GAAG,CAAC,GAAGD,MAAM,CAACC,GAAG,CAAC;EAC1B;EAEA,IAAAO,yBAAgB,EAACT,KAAK,EAAEC,MAAM,CAAC;EAE/B,OAAOD,KAAK;AACd","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/modifications/prependToMemberExpression.js b/scripts/node_modules/@babel/types/lib/modifications/prependToMemberExpression.js new file mode 100644 index 0000000000000000000000000000000000000000..d86e70add32e118530a25013590dacb54ba96947 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/modifications/prependToMemberExpression.js @@ -0,0 +1,17 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = prependToMemberExpression; +var _index = require("../builders/generated/index.js"); +var _index2 = require("../index.js"); +function prependToMemberExpression(member, prepend) { + if ((0, _index2.isSuper)(member.object)) { + throw new Error("Cannot prepend node to super property access (`super.foo`)."); + } + member.object = (0, _index.memberExpression)(prepend, member.object); + return member; +} + +//# sourceMappingURL=prependToMemberExpression.js.map diff --git a/scripts/node_modules/@babel/types/lib/modifications/prependToMemberExpression.js.map b/scripts/node_modules/@babel/types/lib/modifications/prependToMemberExpression.js.map new file mode 100644 index 0000000000000000000000000000000000000000..5da2b40596926afaeca81470007e0b38856251aa --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/modifications/prependToMemberExpression.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_index","require","_index2","prependToMemberExpression","member","prepend","isSuper","object","Error","memberExpression"],"sources":["../../src/modifications/prependToMemberExpression.ts"],"sourcesContent":["import { memberExpression } from \"../builders/generated/index.ts\";\nimport { isSuper } from \"../index.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Prepend a node to a member expression.\n */\nexport default function prependToMemberExpression<\n T extends Pick,\n>(member: T, prepend: t.MemberExpression[\"object\"]): T {\n if (isSuper(member.object)) {\n throw new Error(\n \"Cannot prepend node to super property access (`super.foo`).\",\n );\n }\n member.object = memberExpression(prepend, member.object);\n\n return member;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AAMe,SAASE,yBAAyBA,CAE/CC,MAAS,EAAEC,OAAqC,EAAK;EACrD,IAAI,IAAAC,eAAO,EAACF,MAAM,CAACG,MAAM,CAAC,EAAE;IAC1B,MAAM,IAAIC,KAAK,CACb,6DACF,CAAC;EACH;EACAJ,MAAM,CAACG,MAAM,GAAG,IAAAE,uBAAgB,EAACJ,OAAO,EAAED,MAAM,CAACG,MAAM,CAAC;EAExD,OAAOH,MAAM;AACf","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/modifications/removeProperties.js b/scripts/node_modules/@babel/types/lib/modifications/removeProperties.js new file mode 100644 index 0000000000000000000000000000000000000000..c8e1e16173547217b5c2cd76c13fc82c820905fe --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/modifications/removeProperties.js @@ -0,0 +1,24 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = removeProperties; +var _index = require("../constants/index.js"); +const CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"]; +const CLEAR_KEYS_PLUS_COMMENTS = [..._index.COMMENT_KEYS, "comments", ...CLEAR_KEYS]; +function removeProperties(node, opts = {}) { + const map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS; + for (const key of map) { + if (node[key] != null) node[key] = undefined; + } + for (const key of Object.keys(node)) { + if (key.startsWith("_") && node[key] != null) node[key] = undefined; + } + const symbols = Object.getOwnPropertySymbols(node); + for (const sym of symbols) { + node[sym] = null; + } +} + +//# sourceMappingURL=removeProperties.js.map diff --git a/scripts/node_modules/@babel/types/lib/modifications/removeProperties.js.map b/scripts/node_modules/@babel/types/lib/modifications/removeProperties.js.map new file mode 100644 index 0000000000000000000000000000000000000000..38c78ea66ce4e95afb277f89b630f3faed01c114 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/modifications/removeProperties.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_index","require","CLEAR_KEYS","CLEAR_KEYS_PLUS_COMMENTS","COMMENT_KEYS","removeProperties","node","opts","map","preserveComments","key","undefined","Object","keys","startsWith","symbols","getOwnPropertySymbols","sym"],"sources":["../../src/modifications/removeProperties.ts"],"sourcesContent":["import { COMMENT_KEYS } from \"../constants/index.ts\";\nimport type * as t from \"../index.ts\";\n\nconst CLEAR_KEYS = [\n \"tokens\", // only exist in t.File\n \"start\",\n \"end\",\n \"loc\",\n // Fixme: should be extra.raw / extra.rawValue?\n \"raw\",\n \"rawValue\",\n] as const;\n\nconst CLEAR_KEYS_PLUS_COMMENTS = [\n ...COMMENT_KEYS,\n \"comments\",\n ...CLEAR_KEYS,\n] as const;\n\nexport type Options = { preserveComments?: boolean };\n/**\n * Remove all of the _* properties from a node along with the additional metadata\n * properties like location data and raw token data.\n */\nexport default function removeProperties(\n node: t.Node,\n opts: Options = {},\n): void {\n const map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS;\n for (const key of map) {\n // @ts-expect-error tokens only exist in t.File\n if (node[key] != null) node[key] = undefined;\n }\n\n for (const key of Object.keys(node)) {\n // @ts-expect-error string can not index node\n if (key.startsWith(\"_\") && node[key] != null) node[key] = undefined;\n }\n\n const symbols: symbol[] = Object.getOwnPropertySymbols(node);\n for (const sym of symbols) {\n // @ts-expect-error Fixme: document symbol properties\n node[sym] = null;\n }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAGA,MAAMC,UAAU,GAAG,CACjB,QAAQ,EACR,OAAO,EACP,KAAK,EACL,KAAK,EAEL,KAAK,EACL,UAAU,CACF;AAEV,MAAMC,wBAAwB,GAAG,CAC/B,GAAGC,mBAAY,EACf,UAAU,EACV,GAAGF,UAAU,CACL;AAOK,SAASG,gBAAgBA,CACtCC,IAAY,EACZC,IAAa,GAAG,CAAC,CAAC,EACZ;EACN,MAAMC,GAAG,GAAGD,IAAI,CAACE,gBAAgB,GAAGP,UAAU,GAAGC,wBAAwB;EACzE,KAAK,MAAMO,GAAG,IAAIF,GAAG,EAAE;IAErB,IAAIF,IAAI,CAACI,GAAG,CAAC,IAAI,IAAI,EAAEJ,IAAI,CAACI,GAAG,CAAC,GAAGC,SAAS;EAC9C;EAEA,KAAK,MAAMD,GAAG,IAAIE,MAAM,CAACC,IAAI,CAACP,IAAI,CAAC,EAAE;IAEnC,IAAII,GAAG,CAACI,UAAU,CAAC,GAAG,CAAC,IAAIR,IAAI,CAACI,GAAG,CAAC,IAAI,IAAI,EAAEJ,IAAI,CAACI,GAAG,CAAC,GAAGC,SAAS;EACrE;EAEA,MAAMI,OAAiB,GAAGH,MAAM,CAACI,qBAAqB,CAACV,IAAI,CAAC;EAC5D,KAAK,MAAMW,GAAG,IAAIF,OAAO,EAAE;IAEzBT,IAAI,CAACW,GAAG,CAAC,GAAG,IAAI;EAClB;AACF","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/modifications/removePropertiesDeep.js b/scripts/node_modules/@babel/types/lib/modifications/removePropertiesDeep.js new file mode 100644 index 0000000000000000000000000000000000000000..58a9a0074f76eb1674ccc8be386aa0b4c6ecb117 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/modifications/removePropertiesDeep.js @@ -0,0 +1,14 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = removePropertiesDeep; +var _traverseFast = require("../traverse/traverseFast.js"); +var _removeProperties = require("./removeProperties.js"); +function removePropertiesDeep(tree, opts) { + (0, _traverseFast.default)(tree, _removeProperties.default, opts); + return tree; +} + +//# sourceMappingURL=removePropertiesDeep.js.map diff --git a/scripts/node_modules/@babel/types/lib/modifications/removePropertiesDeep.js.map b/scripts/node_modules/@babel/types/lib/modifications/removePropertiesDeep.js.map new file mode 100644 index 0000000000000000000000000000000000000000..938d040c629a03f8f9ceac45b157625156858442 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/modifications/removePropertiesDeep.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_traverseFast","require","_removeProperties","removePropertiesDeep","tree","opts","traverseFast","removeProperties"],"sources":["../../src/modifications/removePropertiesDeep.ts"],"sourcesContent":["import traverseFast from \"../traverse/traverseFast.ts\";\nimport removeProperties from \"./removeProperties.ts\";\nimport type * as t from \"../index.ts\";\n\nexport default function removePropertiesDeep(\n tree: T,\n opts?: { preserveComments: boolean } | null,\n): T {\n traverseFast(tree, removeProperties, opts);\n\n return tree;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,aAAA,GAAAC,OAAA;AACA,IAAAC,iBAAA,GAAAD,OAAA;AAGe,SAASE,oBAAoBA,CAC1CC,IAAO,EACPC,IAA2C,EACxC;EACH,IAAAC,qBAAY,EAACF,IAAI,EAAEG,yBAAgB,EAAEF,IAAI,CAAC;EAE1C,OAAOD,IAAI;AACb","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/modifications/typescript/removeTypeDuplicates.js b/scripts/node_modules/@babel/types/lib/modifications/typescript/removeTypeDuplicates.js new file mode 100644 index 0000000000000000000000000000000000000000..eada697caecd2cb53ecae768501f6274d69731ce --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/modifications/typescript/removeTypeDuplicates.js @@ -0,0 +1,66 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = removeTypeDuplicates; +var _index = require("../../validators/generated/index.js"); +function getQualifiedName(node) { + return (0, _index.isIdentifier)(node) ? node.name : (0, _index.isThisExpression)(node) ? "this" : `${node.right.name}.${getQualifiedName(node.left)}`; +} +function removeTypeDuplicates(nodesIn) { + const nodes = Array.from(nodesIn); + const generics = new Map(); + const bases = new Map(); + const typeGroups = new Set(); + const types = []; + for (let i = 0; i < nodes.length; i++) { + const node = nodes[i]; + if (!node) continue; + if (types.includes(node)) { + continue; + } + if ((0, _index.isTSAnyKeyword)(node)) { + return [node]; + } + if ((0, _index.isTSBaseType)(node)) { + bases.set(node.type, node); + continue; + } + if ((0, _index.isTSUnionType)(node)) { + if (!typeGroups.has(node.types)) { + nodes.push(...node.types); + typeGroups.add(node.types); + } + continue; + } + const typeArgumentsKey = "typeParameters"; + if ((0, _index.isTSTypeReference)(node) && node[typeArgumentsKey]) { + const typeArguments = node[typeArgumentsKey]; + const name = getQualifiedName(node.typeName); + if (generics.has(name)) { + let existing = generics.get(name); + const existingTypeArguments = existing[typeArgumentsKey]; + if (existingTypeArguments) { + existingTypeArguments.params.push(...typeArguments.params); + existingTypeArguments.params = removeTypeDuplicates(existingTypeArguments.params); + } else { + existing = typeArguments; + } + } else { + generics.set(name, node); + } + continue; + } + types.push(node); + } + for (const [, baseType] of bases) { + types.push(baseType); + } + for (const [, genericName] of generics) { + types.push(genericName); + } + return types; +} + +//# sourceMappingURL=removeTypeDuplicates.js.map diff --git a/scripts/node_modules/@babel/types/lib/modifications/typescript/removeTypeDuplicates.js.map b/scripts/node_modules/@babel/types/lib/modifications/typescript/removeTypeDuplicates.js.map new file mode 100644 index 0000000000000000000000000000000000000000..a8718e4e503e858e4402c5b9c72417370e8826c4 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/modifications/typescript/removeTypeDuplicates.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_index","require","getQualifiedName","node","isIdentifier","name","isThisExpression","right","left","removeTypeDuplicates","nodesIn","nodes","Array","from","generics","Map","bases","typeGroups","Set","types","i","length","includes","isTSAnyKeyword","isTSBaseType","set","type","isTSUnionType","has","push","add","typeArgumentsKey","isTSTypeReference","typeArguments","typeName","existing","get","existingTypeArguments","params","baseType","genericName"],"sources":["../../../src/modifications/typescript/removeTypeDuplicates.ts"],"sourcesContent":["import {\n isIdentifier,\n isThisExpression,\n isTSAnyKeyword,\n isTSTypeReference,\n isTSUnionType,\n isTSBaseType,\n} from \"../../validators/generated/index.ts\";\nimport type * as t from \"../../index.ts\";\n\nfunction getQualifiedName(node: t.TSTypeReference[\"typeName\"]): string {\n return isIdentifier(node)\n ? node.name\n : isThisExpression(node)\n ? \"this\"\n : `${node.right.name}.${getQualifiedName(node.left)}`;\n}\n\n/**\n * Dedupe type annotations.\n */\nexport default function removeTypeDuplicates(\n nodesIn: readonly t.TSType[],\n): t.TSType[] {\n const nodes = Array.from(nodesIn);\n\n const generics = new Map();\n const bases = new Map();\n\n // store union type groups to circular references\n const typeGroups = new Set();\n\n const types: t.TSType[] = [];\n\n for (let i = 0; i < nodes.length; i++) {\n const node = nodes[i];\n if (!node) continue;\n\n // detect duplicates\n if (types.includes(node)) {\n continue;\n }\n\n // this type matches anything\n if (isTSAnyKeyword(node)) {\n return [node];\n }\n\n // Analogue of FlowBaseAnnotation\n if (isTSBaseType(node)) {\n bases.set(node.type, node);\n continue;\n }\n\n if (isTSUnionType(node)) {\n if (!typeGroups.has(node.types)) {\n nodes.push(...node.types);\n typeGroups.add(node.types);\n }\n continue;\n }\n\n // todo: support merging tuples: number[]\n const typeArgumentsKey = process.env.BABEL_8_BREAKING\n ? \"typeArguments\"\n : \"typeParameters\";\n // @ts-ignore(Babel 7 vs Babel 8) Babel 8 AST\n if (isTSTypeReference(node) && node[typeArgumentsKey]) {\n // @ts-ignore(Babel 7 vs Babel 8) Babel 8 AST\n const typeArguments = node[typeArgumentsKey];\n const name = getQualifiedName(node.typeName);\n\n if (generics.has(name)) {\n let existing: t.TypeScript = generics.get(name);\n // @ts-ignore(Babel 7 vs Babel 8) Babel 8 AST\n const existingTypeArguments = existing[typeArgumentsKey];\n if (existingTypeArguments) {\n existingTypeArguments.params.push(...typeArguments.params);\n existingTypeArguments.params = removeTypeDuplicates(\n existingTypeArguments.params,\n );\n } else {\n existing = typeArguments;\n }\n } else {\n generics.set(name, node);\n }\n\n continue;\n }\n\n types.push(node);\n }\n\n // add back in bases\n for (const [, baseType] of bases) {\n types.push(baseType);\n }\n\n // add back in generics\n for (const [, genericName] of generics) {\n types.push(genericName);\n }\n\n return types;\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/retrievers/getAssignmentIdentifiers.js b/scripts/node_modules/@babel/types/lib/retrievers/getAssignmentIdentifiers.js new file mode 100644 index 0000000000000000000000000000000000000000..fb8db3157e112e675ad819cc2c4f687f972f63b5 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/retrievers/getAssignmentIdentifiers.js @@ -0,0 +1,48 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = getAssignmentIdentifiers; +function getAssignmentIdentifiers(node) { + const search = [].concat(node); + const ids = Object.create(null); + while (search.length) { + const id = search.pop(); + if (!id) continue; + switch (id.type) { + case "ArrayPattern": + search.push(...id.elements); + break; + case "AssignmentExpression": + case "AssignmentPattern": + case "ForInStatement": + case "ForOfStatement": + search.push(id.left); + break; + case "ObjectPattern": + search.push(...id.properties); + break; + case "ObjectProperty": + search.push(id.value); + break; + case "RestElement": + case "UpdateExpression": + search.push(id.argument); + break; + case "UnaryExpression": + if (id.operator === "delete") { + search.push(id.argument); + } + break; + case "Identifier": + ids[id.name] = id; + break; + default: + break; + } + } + return ids; +} + +//# sourceMappingURL=getAssignmentIdentifiers.js.map diff --git a/scripts/node_modules/@babel/types/lib/retrievers/getAssignmentIdentifiers.js.map b/scripts/node_modules/@babel/types/lib/retrievers/getAssignmentIdentifiers.js.map new file mode 100644 index 0000000000000000000000000000000000000000..78d2ebd84c15d5cc237fcd0f03a4a6a5cbbb29a0 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/retrievers/getAssignmentIdentifiers.js.map @@ -0,0 +1 @@ +{"version":3,"names":["getAssignmentIdentifiers","node","search","concat","ids","Object","create","length","id","pop","type","push","elements","left","properties","value","argument","operator","name"],"sources":["../../src/retrievers/getAssignmentIdentifiers.ts"],"sourcesContent":["import type * as t from \"../index.ts\";\n\n/**\n * For the given node, generate a map from assignment id names to the identifier node.\n * Unlike getBindingIdentifiers, this function does not handle declarations and imports.\n * @param node the assignment expression or forXstatement\n * @returns an object map\n * @see getBindingIdentifiers\n */\nexport default function getAssignmentIdentifiers(\n node: t.Node | t.Node[],\n): Record {\n // null represents holes in an array pattern\n const search: (t.Node | null)[] = [].concat(node);\n const ids = Object.create(null);\n\n while (search.length) {\n const id = search.pop();\n if (!id) continue;\n\n switch (id.type) {\n case \"ArrayPattern\":\n search.push(...id.elements);\n break;\n\n case \"AssignmentExpression\":\n case \"AssignmentPattern\":\n case \"ForInStatement\":\n case \"ForOfStatement\":\n search.push(id.left);\n break;\n\n case \"ObjectPattern\":\n search.push(...id.properties);\n break;\n\n case \"ObjectProperty\":\n search.push(id.value);\n break;\n\n case \"RestElement\":\n case \"UpdateExpression\":\n search.push(id.argument);\n break;\n\n case \"UnaryExpression\":\n if (id.operator === \"delete\") {\n search.push(id.argument);\n }\n break;\n\n case \"Identifier\":\n ids[id.name] = id;\n break;\n\n default:\n break;\n }\n }\n\n return ids;\n}\n"],"mappings":";;;;;;AASe,SAASA,wBAAwBA,CAC9CC,IAAuB,EACO;EAE9B,MAAMC,MAAyB,GAAG,EAAE,CAACC,MAAM,CAACF,IAAI,CAAC;EACjD,MAAMG,GAAG,GAAGC,MAAM,CAACC,MAAM,CAAC,IAAI,CAAC;EAE/B,OAAOJ,MAAM,CAACK,MAAM,EAAE;IACpB,MAAMC,EAAE,GAAGN,MAAM,CAACO,GAAG,CAAC,CAAC;IACvB,IAAI,CAACD,EAAE,EAAE;IAET,QAAQA,EAAE,CAACE,IAAI;MACb,KAAK,cAAc;QACjBR,MAAM,CAACS,IAAI,CAAC,GAAGH,EAAE,CAACI,QAAQ,CAAC;QAC3B;MAEF,KAAK,sBAAsB;MAC3B,KAAK,mBAAmB;MACxB,KAAK,gBAAgB;MACrB,KAAK,gBAAgB;QACnBV,MAAM,CAACS,IAAI,CAACH,EAAE,CAACK,IAAI,CAAC;QACpB;MAEF,KAAK,eAAe;QAClBX,MAAM,CAACS,IAAI,CAAC,GAAGH,EAAE,CAACM,UAAU,CAAC;QAC7B;MAEF,KAAK,gBAAgB;QACnBZ,MAAM,CAACS,IAAI,CAACH,EAAE,CAACO,KAAK,CAAC;QACrB;MAEF,KAAK,aAAa;MAClB,KAAK,kBAAkB;QACrBb,MAAM,CAACS,IAAI,CAACH,EAAE,CAACQ,QAAQ,CAAC;QACxB;MAEF,KAAK,iBAAiB;QACpB,IAAIR,EAAE,CAACS,QAAQ,KAAK,QAAQ,EAAE;UAC5Bf,MAAM,CAACS,IAAI,CAACH,EAAE,CAACQ,QAAQ,CAAC;QAC1B;QACA;MAEF,KAAK,YAAY;QACfZ,GAAG,CAACI,EAAE,CAACU,IAAI,CAAC,GAAGV,EAAE;QACjB;MAEF;QACE;IACJ;EACF;EAEA,OAAOJ,GAAG;AACZ","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js b/scripts/node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js new file mode 100644 index 0000000000000000000000000000000000000000..e4fb8a072ee3d0b4bb33e86c22e1ebdeba2cf466 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js @@ -0,0 +1,102 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = getBindingIdentifiers; +var _index = require("../validators/generated/index.js"); +function getBindingIdentifiers(node, duplicates, outerOnly, newBindingsOnly) { + const search = [].concat(node); + const ids = Object.create(null); + while (search.length) { + const id = search.shift(); + if (!id) continue; + if (newBindingsOnly && ((0, _index.isAssignmentExpression)(id) || (0, _index.isUnaryExpression)(id) || (0, _index.isUpdateExpression)(id))) { + continue; + } + if ((0, _index.isIdentifier)(id)) { + if (duplicates) { + const _ids = ids[id.name] = ids[id.name] || []; + _ids.push(id); + } else { + ids[id.name] = id; + } + continue; + } + if ((0, _index.isExportDeclaration)(id) && !(0, _index.isExportAllDeclaration)(id)) { + if ((0, _index.isDeclaration)(id.declaration)) { + search.push(id.declaration); + } + continue; + } + if (outerOnly) { + if ((0, _index.isFunctionDeclaration)(id)) { + search.push(id.id); + continue; + } + if ((0, _index.isFunctionExpression)(id)) { + continue; + } + } + const keys = getBindingIdentifiers.keys[id.type]; + if (keys) { + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const nodes = id[key]; + if (nodes) { + if (Array.isArray(nodes)) { + search.push(...nodes); + } else { + search.push(nodes); + } + } + } + } + } + return ids; +} +const keys = { + DeclareClass: ["id"], + DeclareFunction: ["id"], + DeclareModule: ["id"], + DeclareVariable: ["id"], + DeclareInterface: ["id"], + DeclareTypeAlias: ["id"], + DeclareOpaqueType: ["id"], + InterfaceDeclaration: ["id"], + TypeAlias: ["id"], + OpaqueType: ["id"], + CatchClause: ["param"], + LabeledStatement: ["label"], + UnaryExpression: ["argument"], + AssignmentExpression: ["left"], + ImportSpecifier: ["local"], + ImportNamespaceSpecifier: ["local"], + ImportDefaultSpecifier: ["local"], + ImportDeclaration: ["specifiers"], + TSImportEqualsDeclaration: ["id"], + ExportSpecifier: ["exported"], + ExportNamespaceSpecifier: ["exported"], + ExportDefaultSpecifier: ["exported"], + FunctionDeclaration: ["id", "params"], + FunctionExpression: ["id", "params"], + ArrowFunctionExpression: ["params"], + ObjectMethod: ["params"], + ClassMethod: ["params"], + ClassPrivateMethod: ["params"], + ForInStatement: ["left"], + ForOfStatement: ["left"], + ClassDeclaration: ["id"], + ClassExpression: ["id"], + RestElement: ["argument"], + UpdateExpression: ["argument"], + ObjectProperty: ["value"], + AssignmentPattern: ["left"], + ArrayPattern: ["elements"], + ObjectPattern: ["properties"], + VariableDeclaration: ["declarations"], + VariableDeclarator: ["id"] +}; +getBindingIdentifiers.keys = keys; + +//# sourceMappingURL=getBindingIdentifiers.js.map diff --git a/scripts/node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js.map b/scripts/node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js.map new file mode 100644 index 0000000000000000000000000000000000000000..74494d36fa92341729e785ebde45cfbc3ddd31c6 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_index","require","getBindingIdentifiers","node","duplicates","outerOnly","newBindingsOnly","search","concat","ids","Object","create","length","id","shift","isAssignmentExpression","isUnaryExpression","isUpdateExpression","isIdentifier","_ids","name","push","isExportDeclaration","isExportAllDeclaration","isDeclaration","declaration","isFunctionDeclaration","isFunctionExpression","keys","type","i","key","nodes","Array","isArray","DeclareClass","DeclareFunction","DeclareModule","DeclareVariable","DeclareInterface","DeclareTypeAlias","DeclareOpaqueType","InterfaceDeclaration","TypeAlias","OpaqueType","CatchClause","LabeledStatement","UnaryExpression","AssignmentExpression","ImportSpecifier","ImportNamespaceSpecifier","ImportDefaultSpecifier","ImportDeclaration","TSImportEqualsDeclaration","ExportSpecifier","ExportNamespaceSpecifier","ExportDefaultSpecifier","FunctionDeclaration","FunctionExpression","ArrowFunctionExpression","ObjectMethod","ClassMethod","ClassPrivateMethod","ForInStatement","ForOfStatement","ClassDeclaration","ClassExpression","RestElement","UpdateExpression","ObjectProperty","AssignmentPattern","ArrayPattern","ObjectPattern","VariableDeclaration","VariableDeclarator"],"sources":["../../src/retrievers/getBindingIdentifiers.ts"],"sourcesContent":["import {\n isExportDeclaration,\n isIdentifier,\n isClassExpression,\n isDeclaration,\n isFunctionDeclaration,\n isFunctionExpression,\n isExportAllDeclaration,\n isAssignmentExpression,\n isUnaryExpression,\n isUpdateExpression,\n} from \"../validators/generated/index.ts\";\nimport type * as t from \"../index.ts\";\n\nexport { getBindingIdentifiers as default };\n\nfunction getBindingIdentifiers(\n node: t.Node,\n duplicates: true,\n outerOnly?: boolean,\n newBindingsOnly?: boolean,\n): Record;\n\nfunction getBindingIdentifiers(\n node: t.Node,\n duplicates?: false,\n outerOnly?: boolean,\n newBindingsOnly?: boolean,\n): Record;\n\nfunction getBindingIdentifiers(\n node: t.Node,\n duplicates?: boolean,\n outerOnly?: boolean,\n newBindingsOnly?: boolean,\n): Record | Record;\n\n/**\n * Return a list of binding identifiers associated with the input `node`.\n */\nfunction getBindingIdentifiers(\n node: t.Node,\n duplicates?: boolean,\n outerOnly?: boolean,\n newBindingsOnly?: boolean,\n): Record | Record {\n const search: t.Node[] = [].concat(node);\n const ids = Object.create(null);\n\n while (search.length) {\n const id = search.shift();\n if (!id) continue;\n\n if (\n newBindingsOnly &&\n // These nodes do not introduce _new_ bindings, but they are included\n // in getBindingIdentifiers.keys for backwards compatibility.\n // TODO(@nicolo-ribaudo): Check if we can remove them from .keys in a\n // backward-compatible way, and if not what we need to do to remove them\n // in Babel 8.\n (isAssignmentExpression(id) ||\n isUnaryExpression(id) ||\n isUpdateExpression(id))\n ) {\n continue;\n }\n\n if (isIdentifier(id)) {\n if (duplicates) {\n const _ids = (ids[id.name] = ids[id.name] || []);\n _ids.push(id);\n } else {\n ids[id.name] = id;\n }\n continue;\n }\n\n if (isExportDeclaration(id) && !isExportAllDeclaration(id)) {\n if (isDeclaration(id.declaration)) {\n search.push(id.declaration);\n }\n continue;\n }\n\n if (outerOnly) {\n if (isFunctionDeclaration(id)) {\n search.push(id.id);\n continue;\n }\n\n if (\n isFunctionExpression(id) ||\n (process.env.BABEL_8_BREAKING && isClassExpression(id))\n ) {\n continue;\n }\n }\n\n const keys = getBindingIdentifiers.keys[id.type];\n\n if (keys) {\n for (let i = 0; i < keys.length; i++) {\n const key = keys[i];\n const nodes =\n // @ts-expect-error key must present in id\n id[key] as t.Node[] | t.Node | undefined | null;\n if (nodes) {\n if (Array.isArray(nodes)) {\n search.push(...nodes);\n } else {\n search.push(nodes);\n }\n }\n }\n }\n }\n return ids;\n}\n\n/**\n * Mapping of types to their identifier keys.\n */\ntype KeysMap = {\n [N in t.Node as N[\"type\"]]?: (keyof N)[];\n};\n\nconst keys: KeysMap = {\n DeclareClass: [\"id\"],\n DeclareFunction: [\"id\"],\n DeclareModule: [\"id\"],\n DeclareVariable: [\"id\"],\n DeclareInterface: [\"id\"],\n DeclareTypeAlias: [\"id\"],\n DeclareOpaqueType: [\"id\"],\n InterfaceDeclaration: [\"id\"],\n TypeAlias: [\"id\"],\n OpaqueType: [\"id\"],\n\n CatchClause: [\"param\"],\n LabeledStatement: [\"label\"],\n UnaryExpression: [\"argument\"],\n AssignmentExpression: [\"left\"],\n\n ImportSpecifier: [\"local\"],\n ImportNamespaceSpecifier: [\"local\"],\n ImportDefaultSpecifier: [\"local\"],\n ImportDeclaration: [\"specifiers\"],\n TSImportEqualsDeclaration: [\"id\"],\n\n ExportSpecifier: [\"exported\"],\n ExportNamespaceSpecifier: [\"exported\"],\n ExportDefaultSpecifier: [\"exported\"],\n\n FunctionDeclaration: [\"id\", \"params\"],\n FunctionExpression: [\"id\", \"params\"],\n ArrowFunctionExpression: [\"params\"],\n ObjectMethod: [\"params\"],\n ClassMethod: [\"params\"],\n ClassPrivateMethod: [\"params\"],\n\n ForInStatement: [\"left\"],\n ForOfStatement: [\"left\"],\n\n ClassDeclaration: [\"id\"],\n ClassExpression: [\"id\"],\n\n RestElement: [\"argument\"],\n UpdateExpression: [\"argument\"],\n\n ObjectProperty: [\"value\"],\n\n AssignmentPattern: [\"left\"],\n ArrayPattern: [\"elements\"],\n ObjectPattern: [\"properties\"],\n\n VariableDeclaration: [\"declarations\"],\n VariableDeclarator: [\"id\"],\n};\n\ngetBindingIdentifiers.keys = keys;\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/retrievers/getFunctionName.js b/scripts/node_modules/@babel/types/lib/retrievers/getFunctionName.js new file mode 100644 index 0000000000000000000000000000000000000000..43d33d78fdb0a868f489b2348d5be0a4196af59f --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/retrievers/getFunctionName.js @@ -0,0 +1,63 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = getFunctionName; +var _index = require("../validators/generated/index.js"); +function getNameFromLiteralId(id) { + if ((0, _index.isNullLiteral)(id)) { + return "null"; + } + if ((0, _index.isRegExpLiteral)(id)) { + return `/${id.pattern}/${id.flags}`; + } + if ((0, _index.isTemplateLiteral)(id)) { + return id.quasis.map(quasi => quasi.value.raw).join(""); + } + if (id.value !== undefined) { + return String(id.value); + } + return null; +} +function getObjectMemberKey(node) { + if (!node.computed || (0, _index.isLiteral)(node.key)) { + return node.key; + } +} +function getFunctionName(node, parent) { + if ("id" in node && node.id) { + return { + name: node.id.name, + originalNode: node.id + }; + } + let prefix = ""; + let id; + if ((0, _index.isObjectProperty)(parent, { + value: node + })) { + id = getObjectMemberKey(parent); + } else if ((0, _index.isObjectMethod)(node) || (0, _index.isClassMethod)(node)) { + id = getObjectMemberKey(node); + if (node.kind === "get") prefix = "get ";else if (node.kind === "set") prefix = "set "; + } else if ((0, _index.isVariableDeclarator)(parent, { + init: node + })) { + id = parent.id; + } else if ((0, _index.isAssignmentExpression)(parent, { + operator: "=", + right: node + })) { + id = parent.left; + } + if (!id) return null; + const name = (0, _index.isLiteral)(id) ? getNameFromLiteralId(id) : (0, _index.isIdentifier)(id) ? id.name : (0, _index.isPrivateName)(id) ? id.id.name : null; + if (name == null) return null; + return { + name: prefix + name, + originalNode: id + }; +} + +//# sourceMappingURL=getFunctionName.js.map diff --git a/scripts/node_modules/@babel/types/lib/retrievers/getFunctionName.js.map b/scripts/node_modules/@babel/types/lib/retrievers/getFunctionName.js.map new file mode 100644 index 0000000000000000000000000000000000000000..be68ebd777e8df0d07e375a177ede1f1cf0a1c43 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/retrievers/getFunctionName.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_index","require","getNameFromLiteralId","id","isNullLiteral","isRegExpLiteral","pattern","flags","isTemplateLiteral","quasis","map","quasi","value","raw","join","undefined","String","getObjectMemberKey","node","computed","isLiteral","key","getFunctionName","parent","name","originalNode","prefix","isObjectProperty","isObjectMethod","isClassMethod","kind","isVariableDeclarator","init","isAssignmentExpression","operator","right","left","isIdentifier","isPrivateName"],"sources":["../../src/retrievers/getFunctionName.ts"],"sourcesContent":["import type * as t from \"../index.ts\";\n\nimport {\n isAssignmentExpression,\n isClassMethod,\n isIdentifier,\n isLiteral,\n isNullLiteral,\n isObjectMethod,\n isObjectProperty,\n isPrivateName,\n isRegExpLiteral,\n isTemplateLiteral,\n isVariableDeclarator,\n} from \"../validators/generated/index.ts\";\n\nfunction getNameFromLiteralId(id: t.Literal): string {\n if (isNullLiteral(id)) {\n return \"null\";\n }\n\n if (isRegExpLiteral(id)) {\n return `/${id.pattern}/${id.flags}`;\n }\n\n if (isTemplateLiteral(id)) {\n return id.quasis.map(quasi => quasi.value.raw).join(\"\");\n }\n\n if (id.value !== undefined) {\n return String(id.value);\n }\n\n return null;\n}\n\nfunction getObjectMemberKey(\n node: t.ObjectProperty | t.ObjectMethod | t.ClassProperty | t.ClassMethod,\n): t.Expression | t.PrivateName {\n if (!node.computed || isLiteral(node.key)) {\n return node.key;\n }\n}\n\ntype GetFunctionNameResult = {\n name: string;\n originalNode: t.Node;\n} | null;\n\nexport default function getFunctionName(\n node: t.ObjectMethod | t.ClassMethod,\n): GetFunctionNameResult;\nexport default function getFunctionName(\n node: t.Function | t.Class,\n parent: t.Node,\n): GetFunctionNameResult;\nexport default function getFunctionName(\n node: t.Function | t.Class,\n parent?: t.Node,\n): GetFunctionNameResult {\n if (\"id\" in node && node.id) {\n return {\n name: node.id.name,\n originalNode: node.id,\n };\n }\n\n let prefix = \"\";\n\n let id;\n if (isObjectProperty(parent, { value: node })) {\n // { foo: () => {} };\n id = getObjectMemberKey(parent);\n } else if (isObjectMethod(node) || isClassMethod(node)) {\n // { foo() {} };\n id = getObjectMemberKey(node);\n if (node.kind === \"get\") prefix = \"get \";\n else if (node.kind === \"set\") prefix = \"set \";\n } else if (isVariableDeclarator(parent, { init: node })) {\n // let foo = function () {};\n id = parent.id;\n } else if (isAssignmentExpression(parent, { operator: \"=\", right: node })) {\n // foo = function () {};\n id = parent.left;\n }\n\n if (!id) return null;\n\n const name = isLiteral(id)\n ? getNameFromLiteralId(id)\n : isIdentifier(id)\n ? id.name\n : isPrivateName(id)\n ? id.id.name\n : null;\n if (name == null) return null;\n\n return { name: prefix + name, originalNode: id };\n}\n"],"mappings":";;;;;;AAEA,IAAAA,MAAA,GAAAC,OAAA;AAcA,SAASC,oBAAoBA,CAACC,EAAa,EAAU;EACnD,IAAI,IAAAC,oBAAa,EAACD,EAAE,CAAC,EAAE;IACrB,OAAO,MAAM;EACf;EAEA,IAAI,IAAAE,sBAAe,EAACF,EAAE,CAAC,EAAE;IACvB,OAAO,IAAIA,EAAE,CAACG,OAAO,IAAIH,EAAE,CAACI,KAAK,EAAE;EACrC;EAEA,IAAI,IAAAC,wBAAiB,EAACL,EAAE,CAAC,EAAE;IACzB,OAAOA,EAAE,CAACM,MAAM,CAACC,GAAG,CAACC,KAAK,IAAIA,KAAK,CAACC,KAAK,CAACC,GAAG,CAAC,CAACC,IAAI,CAAC,EAAE,CAAC;EACzD;EAEA,IAAIX,EAAE,CAACS,KAAK,KAAKG,SAAS,EAAE;IAC1B,OAAOC,MAAM,CAACb,EAAE,CAACS,KAAK,CAAC;EACzB;EAEA,OAAO,IAAI;AACb;AAEA,SAASK,kBAAkBA,CACzBC,IAAyE,EAC3C;EAC9B,IAAI,CAACA,IAAI,CAACC,QAAQ,IAAI,IAAAC,gBAAS,EAACF,IAAI,CAACG,GAAG,CAAC,EAAE;IACzC,OAAOH,IAAI,CAACG,GAAG;EACjB;AACF;AAce,SAASC,eAAeA,CACrCJ,IAA0B,EAC1BK,MAAe,EACQ;EACvB,IAAI,IAAI,IAAIL,IAAI,IAAIA,IAAI,CAACf,EAAE,EAAE;IAC3B,OAAO;MACLqB,IAAI,EAAEN,IAAI,CAACf,EAAE,CAACqB,IAAI;MAClBC,YAAY,EAAEP,IAAI,CAACf;IACrB,CAAC;EACH;EAEA,IAAIuB,MAAM,GAAG,EAAE;EAEf,IAAIvB,EAAE;EACN,IAAI,IAAAwB,uBAAgB,EAACJ,MAAM,EAAE;IAAEX,KAAK,EAAEM;EAAK,CAAC,CAAC,EAAE;IAE7Cf,EAAE,GAAGc,kBAAkB,CAACM,MAAM,CAAC;EACjC,CAAC,MAAM,IAAI,IAAAK,qBAAc,EAACV,IAAI,CAAC,IAAI,IAAAW,oBAAa,EAACX,IAAI,CAAC,EAAE;IAEtDf,EAAE,GAAGc,kBAAkB,CAACC,IAAI,CAAC;IAC7B,IAAIA,IAAI,CAACY,IAAI,KAAK,KAAK,EAAEJ,MAAM,GAAG,MAAM,CAAC,KACpC,IAAIR,IAAI,CAACY,IAAI,KAAK,KAAK,EAAEJ,MAAM,GAAG,MAAM;EAC/C,CAAC,MAAM,IAAI,IAAAK,2BAAoB,EAACR,MAAM,EAAE;IAAES,IAAI,EAAEd;EAAK,CAAC,CAAC,EAAE;IAEvDf,EAAE,GAAGoB,MAAM,CAACpB,EAAE;EAChB,CAAC,MAAM,IAAI,IAAA8B,6BAAsB,EAACV,MAAM,EAAE;IAAEW,QAAQ,EAAE,GAAG;IAAEC,KAAK,EAAEjB;EAAK,CAAC,CAAC,EAAE;IAEzEf,EAAE,GAAGoB,MAAM,CAACa,IAAI;EAClB;EAEA,IAAI,CAACjC,EAAE,EAAE,OAAO,IAAI;EAEpB,MAAMqB,IAAI,GAAG,IAAAJ,gBAAS,EAACjB,EAAE,CAAC,GACtBD,oBAAoB,CAACC,EAAE,CAAC,GACxB,IAAAkC,mBAAY,EAAClC,EAAE,CAAC,GACdA,EAAE,CAACqB,IAAI,GACP,IAAAc,oBAAa,EAACnC,EAAE,CAAC,GACfA,EAAE,CAACA,EAAE,CAACqB,IAAI,GACV,IAAI;EACZ,IAAIA,IAAI,IAAI,IAAI,EAAE,OAAO,IAAI;EAE7B,OAAO;IAAEA,IAAI,EAAEE,MAAM,GAAGF,IAAI;IAAEC,YAAY,EAAEtB;EAAG,CAAC;AAClD","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/retrievers/getOuterBindingIdentifiers.js b/scripts/node_modules/@babel/types/lib/retrievers/getOuterBindingIdentifiers.js new file mode 100644 index 0000000000000000000000000000000000000000..f51c47b5f89fea07e7a05568c4bb811c13c57bd0 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/retrievers/getOuterBindingIdentifiers.js @@ -0,0 +1,13 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; +var _getBindingIdentifiers = require("./getBindingIdentifiers.js"); +var _default = exports.default = getOuterBindingIdentifiers; +function getOuterBindingIdentifiers(node, duplicates) { + return (0, _getBindingIdentifiers.default)(node, duplicates, true); +} + +//# sourceMappingURL=getOuterBindingIdentifiers.js.map diff --git a/scripts/node_modules/@babel/types/lib/retrievers/getOuterBindingIdentifiers.js.map b/scripts/node_modules/@babel/types/lib/retrievers/getOuterBindingIdentifiers.js.map new file mode 100644 index 0000000000000000000000000000000000000000..55cadd5797f7c9ac6b5d91a067bfc38fd7494637 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/retrievers/getOuterBindingIdentifiers.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_getBindingIdentifiers","require","_default","exports","default","getOuterBindingIdentifiers","node","duplicates","getBindingIdentifiers"],"sources":["../../src/retrievers/getOuterBindingIdentifiers.ts"],"sourcesContent":["import getBindingIdentifiers from \"./getBindingIdentifiers.ts\";\nimport type * as t from \"../index.ts\";\n\nexport default getOuterBindingIdentifiers as {\n (node: t.Node, duplicates: true): Record;\n (node: t.Node, duplicates?: false): Record;\n (\n node: t.Node,\n duplicates?: boolean,\n ): Record | Record;\n};\n\nfunction getOuterBindingIdentifiers(\n node: t.Node,\n duplicates: boolean,\n): Record | Record {\n return getBindingIdentifiers(node, duplicates, true);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,sBAAA,GAAAC,OAAA;AAA+D,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAGhDC,0BAA0B;AASzC,SAASA,0BAA0BA,CACjCC,IAAY,EACZC,UAAmB,EAC4C;EAC/D,OAAO,IAAAC,8BAAqB,EAACF,IAAI,EAAEC,UAAU,EAAE,IAAI,CAAC;AACtD","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/traverse/traverse.js b/scripts/node_modules/@babel/types/lib/traverse/traverse.js new file mode 100644 index 0000000000000000000000000000000000000000..77b0c3736f94a67328d532be672d3ec9a928f1ed --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/traverse/traverse.js @@ -0,0 +1,50 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = traverse; +var _index = require("../definitions/index.js"); +function traverse(node, handlers, state) { + if (typeof handlers === "function") { + handlers = { + enter: handlers + }; + } + const { + enter, + exit + } = handlers; + traverseSimpleImpl(node, enter, exit, state, []); +} +function traverseSimpleImpl(node, enter, exit, state, ancestors) { + const keys = _index.VISITOR_KEYS[node.type]; + if (!keys) return; + if (enter) enter(node, ancestors, state); + for (const key of keys) { + const subNode = node[key]; + if (Array.isArray(subNode)) { + for (let i = 0; i < subNode.length; i++) { + const child = subNode[i]; + if (!child) continue; + ancestors.push({ + node, + key, + index: i + }); + traverseSimpleImpl(child, enter, exit, state, ancestors); + ancestors.pop(); + } + } else if (subNode) { + ancestors.push({ + node, + key + }); + traverseSimpleImpl(subNode, enter, exit, state, ancestors); + ancestors.pop(); + } + } + if (exit) exit(node, ancestors, state); +} + +//# sourceMappingURL=traverse.js.map diff --git a/scripts/node_modules/@babel/types/lib/traverse/traverse.js.map b/scripts/node_modules/@babel/types/lib/traverse/traverse.js.map new file mode 100644 index 0000000000000000000000000000000000000000..9359c676c57b2d9d43b111363dccf4cc5a82faf2 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/traverse/traverse.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_index","require","traverse","node","handlers","state","enter","exit","traverseSimpleImpl","ancestors","keys","VISITOR_KEYS","type","key","subNode","Array","isArray","i","length","child","push","index","pop"],"sources":["../../src/traverse/traverse.ts"],"sourcesContent":["import { VISITOR_KEYS } from \"../definitions/index.ts\";\nimport type * as t from \"../index.ts\";\n\nexport type TraversalAncestors = {\n node: t.Node;\n key: string;\n index?: number;\n}[];\n\nexport type TraversalHandler = (\n this: undefined,\n node: t.Node,\n parent: TraversalAncestors,\n state: T,\n) => void;\n\nexport type TraversalHandlers = {\n enter?: TraversalHandler;\n exit?: TraversalHandler;\n};\n\n/**\n * A general AST traversal with both prefix and postfix handlers, and a\n * state object. Exposes ancestry data to each handler so that more complex\n * AST data can be taken into account.\n */\nexport default function traverse(\n node: t.Node,\n handlers: TraversalHandler | TraversalHandlers,\n state?: T,\n): void {\n if (typeof handlers === \"function\") {\n handlers = { enter: handlers };\n }\n\n const { enter, exit } = handlers;\n\n traverseSimpleImpl(node, enter, exit, state, []);\n}\n\nfunction traverseSimpleImpl(\n node: any,\n enter: Function | undefined,\n exit: Function | undefined,\n state: T | undefined,\n ancestors: TraversalAncestors,\n) {\n const keys = VISITOR_KEYS[node.type];\n if (!keys) return;\n\n if (enter) enter(node, ancestors, state);\n\n for (const key of keys) {\n const subNode = node[key];\n\n if (Array.isArray(subNode)) {\n for (let i = 0; i < subNode.length; i++) {\n const child = subNode[i];\n if (!child) continue;\n\n ancestors.push({\n node,\n key,\n index: i,\n });\n\n traverseSimpleImpl(child, enter, exit, state, ancestors);\n\n ancestors.pop();\n }\n } else if (subNode) {\n ancestors.push({\n node,\n key,\n });\n\n traverseSimpleImpl(subNode, enter, exit, state, ancestors);\n\n ancestors.pop();\n }\n }\n\n if (exit) exit(node, ancestors, state);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AA0Be,SAASC,QAAQA,CAC9BC,IAAY,EACZC,QAAoD,EACpDC,KAAS,EACH;EACN,IAAI,OAAOD,QAAQ,KAAK,UAAU,EAAE;IAClCA,QAAQ,GAAG;MAAEE,KAAK,EAAEF;IAAS,CAAC;EAChC;EAEA,MAAM;IAAEE,KAAK;IAAEC;EAAK,CAAC,GAAGH,QAAQ;EAEhCI,kBAAkB,CAACL,IAAI,EAAEG,KAAK,EAAEC,IAAI,EAAEF,KAAK,EAAE,EAAE,CAAC;AAClD;AAEA,SAASG,kBAAkBA,CACzBL,IAAS,EACTG,KAA2B,EAC3BC,IAA0B,EAC1BF,KAAoB,EACpBI,SAA6B,EAC7B;EACA,MAAMC,IAAI,GAAGC,mBAAY,CAACR,IAAI,CAACS,IAAI,CAAC;EACpC,IAAI,CAACF,IAAI,EAAE;EAEX,IAAIJ,KAAK,EAAEA,KAAK,CAACH,IAAI,EAAEM,SAAS,EAAEJ,KAAK,CAAC;EAExC,KAAK,MAAMQ,GAAG,IAAIH,IAAI,EAAE;IACtB,MAAMI,OAAO,GAAGX,IAAI,CAACU,GAAG,CAAC;IAEzB,IAAIE,KAAK,CAACC,OAAO,CAACF,OAAO,CAAC,EAAE;MAC1B,KAAK,IAAIG,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGH,OAAO,CAACI,MAAM,EAAED,CAAC,EAAE,EAAE;QACvC,MAAME,KAAK,GAAGL,OAAO,CAACG,CAAC,CAAC;QACxB,IAAI,CAACE,KAAK,EAAE;QAEZV,SAAS,CAACW,IAAI,CAAC;UACbjB,IAAI;UACJU,GAAG;UACHQ,KAAK,EAAEJ;QACT,CAAC,CAAC;QAEFT,kBAAkB,CAACW,KAAK,EAAEb,KAAK,EAAEC,IAAI,EAAEF,KAAK,EAAEI,SAAS,CAAC;QAExDA,SAAS,CAACa,GAAG,CAAC,CAAC;MACjB;IACF,CAAC,MAAM,IAAIR,OAAO,EAAE;MAClBL,SAAS,CAACW,IAAI,CAAC;QACbjB,IAAI;QACJU;MACF,CAAC,CAAC;MAEFL,kBAAkB,CAACM,OAAO,EAAER,KAAK,EAAEC,IAAI,EAAEF,KAAK,EAAEI,SAAS,CAAC;MAE1DA,SAAS,CAACa,GAAG,CAAC,CAAC;IACjB;EACF;EAEA,IAAIf,IAAI,EAAEA,IAAI,CAACJ,IAAI,EAAEM,SAAS,EAAEJ,KAAK,CAAC;AACxC","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/traverse/traverseFast.js b/scripts/node_modules/@babel/types/lib/traverse/traverseFast.js new file mode 100644 index 0000000000000000000000000000000000000000..2b1d84e0d8acb47a0c0d0c9675278fd49b03ebb4 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/traverse/traverseFast.js @@ -0,0 +1,40 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = traverseFast; +var _index = require("../definitions/index.js"); +const _skip = Symbol(); +const _stop = Symbol(); +function traverseFast(node, enter, opts) { + if (!node) return false; + const keys = _index.VISITOR_KEYS[node.type]; + if (!keys) return false; + opts = opts || {}; + const ret = enter(node, opts); + if (ret !== undefined) { + switch (ret) { + case _skip: + return false; + case _stop: + return true; + } + } + for (const key of keys) { + const subNode = node[key]; + if (!subNode) continue; + if (Array.isArray(subNode)) { + for (const node of subNode) { + if (traverseFast(node, enter, opts)) return true; + } + } else { + if (traverseFast(subNode, enter, opts)) return true; + } + } + return false; +} +traverseFast.skip = _skip; +traverseFast.stop = _stop; + +//# sourceMappingURL=traverseFast.js.map diff --git a/scripts/node_modules/@babel/types/lib/traverse/traverseFast.js.map b/scripts/node_modules/@babel/types/lib/traverse/traverseFast.js.map new file mode 100644 index 0000000000000000000000000000000000000000..11e1524dae338009e9c6bec3c48760fc585bca96 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/traverse/traverseFast.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_index","require","_skip","Symbol","_stop","traverseFast","node","enter","opts","keys","VISITOR_KEYS","type","ret","undefined","key","subNode","Array","isArray","skip","stop"],"sources":["../../src/traverse/traverseFast.ts"],"sourcesContent":["import { VISITOR_KEYS } from \"../definitions/index.ts\";\nimport type * as t from \"../index.ts\";\n\nconst _skip = Symbol();\nconst _stop = Symbol();\n\n/**\n * A prefix AST traversal implementation meant for simple searching and processing.\n * @param enter The callback can return `traverseFast.skip` to skip the subtree of the current node, or `traverseFast.stop` to stop the traversal.\n * @returns `true` if the traversal was stopped by callback, `false` otherwise.\n */\nexport default function traverseFast(\n node: t.Node | null | undefined,\n enter: (\n node: t.Node,\n opts?: Options,\n ) => void | typeof traverseFast.skip | typeof traverseFast.stop,\n opts?: Options,\n): boolean {\n if (!node) return false;\n\n const keys = VISITOR_KEYS[node.type];\n if (!keys) return false;\n\n opts = opts || ({} as Options);\n const ret = enter(node, opts);\n if (ret !== undefined) {\n switch (ret) {\n case _skip:\n return false;\n case _stop:\n return true;\n }\n }\n\n for (const key of keys) {\n const subNode: t.Node | undefined | null =\n // @ts-expect-error key must present in node\n node[key];\n\n if (!subNode) continue;\n\n if (Array.isArray(subNode)) {\n for (const node of subNode) {\n if (traverseFast(node, enter, opts)) return true;\n }\n } else {\n if (traverseFast(subNode, enter, opts)) return true;\n }\n }\n return false;\n}\n\ntraverseFast.skip = _skip;\ntraverseFast.stop = _stop;\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAGA,MAAMC,KAAK,GAAGC,MAAM,CAAC,CAAC;AACtB,MAAMC,KAAK,GAAGD,MAAM,CAAC,CAAC;AAOP,SAASE,YAAYA,CAClCC,IAA+B,EAC/BC,KAG+D,EAC/DC,IAAc,EACL;EACT,IAAI,CAACF,IAAI,EAAE,OAAO,KAAK;EAEvB,MAAMG,IAAI,GAAGC,mBAAY,CAACJ,IAAI,CAACK,IAAI,CAAC;EACpC,IAAI,CAACF,IAAI,EAAE,OAAO,KAAK;EAEvBD,IAAI,GAAGA,IAAI,IAAK,CAAC,CAAa;EAC9B,MAAMI,GAAG,GAAGL,KAAK,CAACD,IAAI,EAAEE,IAAI,CAAC;EAC7B,IAAII,GAAG,KAAKC,SAAS,EAAE;IACrB,QAAQD,GAAG;MACT,KAAKV,KAAK;QACR,OAAO,KAAK;MACd,KAAKE,KAAK;QACR,OAAO,IAAI;IACf;EACF;EAEA,KAAK,MAAMU,GAAG,IAAIL,IAAI,EAAE;IACtB,MAAMM,OAAkC,GAEtCT,IAAI,CAACQ,GAAG,CAAC;IAEX,IAAI,CAACC,OAAO,EAAE;IAEd,IAAIC,KAAK,CAACC,OAAO,CAACF,OAAO,CAAC,EAAE;MAC1B,KAAK,MAAMT,IAAI,IAAIS,OAAO,EAAE;QAC1B,IAAIV,YAAY,CAACC,IAAI,EAAEC,KAAK,EAAEC,IAAI,CAAC,EAAE,OAAO,IAAI;MAClD;IACF,CAAC,MAAM;MACL,IAAIH,YAAY,CAACU,OAAO,EAAER,KAAK,EAAEC,IAAI,CAAC,EAAE,OAAO,IAAI;IACrD;EACF;EACA,OAAO,KAAK;AACd;AAEAH,YAAY,CAACa,IAAI,GAAGhB,KAAK;AACzBG,YAAY,CAACc,IAAI,GAAGf,KAAK","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/utils/deprecationWarning.js b/scripts/node_modules/@babel/types/lib/utils/deprecationWarning.js new file mode 100644 index 0000000000000000000000000000000000000000..6c3693826b881f42a5a09724af29ba80bd286c17 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/utils/deprecationWarning.js @@ -0,0 +1,44 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = deprecationWarning; +const warnings = new Set(); +function deprecationWarning(oldName, newName, prefix = "", cacheKey = oldName) { + if (warnings.has(cacheKey)) return; + warnings.add(cacheKey); + const { + internal, + trace + } = captureShortStackTrace(1, 2); + if (internal) { + return; + } + console.warn(`${prefix}\`${oldName}\` has been deprecated, please migrate to \`${newName}\`\n${trace}`); +} +function captureShortStackTrace(skip, length) { + const { + stackTraceLimit, + prepareStackTrace + } = Error; + let stackTrace; + Error.stackTraceLimit = 1 + skip + length; + Error.prepareStackTrace = function (err, stack) { + stackTrace = stack; + }; + new Error().stack; + Error.stackTraceLimit = stackTraceLimit; + Error.prepareStackTrace = prepareStackTrace; + if (!stackTrace) return { + internal: false, + trace: "" + }; + const shortStackTrace = stackTrace.slice(1 + skip, 1 + skip + length); + return { + internal: /[\\/]@babel[\\/]/.test(shortStackTrace[1].getFileName()), + trace: shortStackTrace.map(frame => ` at ${frame}`).join("\n") + }; +} + +//# sourceMappingURL=deprecationWarning.js.map diff --git a/scripts/node_modules/@babel/types/lib/utils/deprecationWarning.js.map b/scripts/node_modules/@babel/types/lib/utils/deprecationWarning.js.map new file mode 100644 index 0000000000000000000000000000000000000000..1d96e3ee95964d1c38594ebc20878bcdd03d85b7 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/utils/deprecationWarning.js.map @@ -0,0 +1 @@ +{"version":3,"names":["warnings","Set","deprecationWarning","oldName","newName","prefix","cacheKey","has","add","internal","trace","captureShortStackTrace","console","warn","skip","length","stackTraceLimit","prepareStackTrace","Error","stackTrace","err","stack","shortStackTrace","slice","test","getFileName","map","frame","join"],"sources":["../../src/utils/deprecationWarning.ts"],"sourcesContent":["const warnings = new Set();\n\nexport default function deprecationWarning(\n oldName: string,\n newName: string,\n prefix: string = \"\",\n cacheKey: string = oldName,\n) {\n if (warnings.has(cacheKey)) return;\n warnings.add(cacheKey);\n\n const { internal, trace } = captureShortStackTrace(1, 2);\n if (internal) {\n // If usage comes from an internal package, there is no point in warning because\n // 1. The new version of the package will already use the new API\n // 2. When the deprecation will become an error (in a future major version), users\n // will have to update every package anyway.\n return;\n }\n console.warn(\n `${prefix}\\`${oldName}\\` has been deprecated, please migrate to \\`${newName}\\`\\n${trace}`,\n );\n}\n\nfunction captureShortStackTrace(skip: number, length: number) {\n const { stackTraceLimit, prepareStackTrace } = Error;\n let stackTrace: NodeJS.CallSite[];\n // We add 1 to also take into account this function.\n Error.stackTraceLimit = 1 + skip + length;\n Error.prepareStackTrace = function (err, stack) {\n stackTrace = stack;\n };\n // eslint-disable-next-line @typescript-eslint/no-unused-expressions\n new Error().stack;\n Error.stackTraceLimit = stackTraceLimit;\n Error.prepareStackTrace = prepareStackTrace;\n\n if (!stackTrace) return { internal: false, trace: \"\" };\n\n const shortStackTrace = stackTrace.slice(1 + skip, 1 + skip + length);\n return {\n internal: /[\\\\/]@babel[\\\\/]/.test(shortStackTrace[1].getFileName()),\n trace: shortStackTrace.map(frame => ` at ${frame}`).join(\"\\n\"),\n };\n}\n"],"mappings":";;;;;;AAAA,MAAMA,QAAQ,GAAG,IAAIC,GAAG,CAAC,CAAC;AAEX,SAASC,kBAAkBA,CACxCC,OAAe,EACfC,OAAe,EACfC,MAAc,GAAG,EAAE,EACnBC,QAAgB,GAAGH,OAAO,EAC1B;EACA,IAAIH,QAAQ,CAACO,GAAG,CAACD,QAAQ,CAAC,EAAE;EAC5BN,QAAQ,CAACQ,GAAG,CAACF,QAAQ,CAAC;EAEtB,MAAM;IAAEG,QAAQ;IAAEC;EAAM,CAAC,GAAGC,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC;EACxD,IAAIF,QAAQ,EAAE;IAKZ;EACF;EACAG,OAAO,CAACC,IAAI,CACV,GAAGR,MAAM,KAAKF,OAAO,+CAA+CC,OAAO,OAAOM,KAAK,EACzF,CAAC;AACH;AAEA,SAASC,sBAAsBA,CAACG,IAAY,EAAEC,MAAc,EAAE;EAC5D,MAAM;IAAEC,eAAe;IAAEC;EAAkB,CAAC,GAAGC,KAAK;EACpD,IAAIC,UAA6B;EAEjCD,KAAK,CAACF,eAAe,GAAG,CAAC,GAAGF,IAAI,GAAGC,MAAM;EACzCG,KAAK,CAACD,iBAAiB,GAAG,UAAUG,GAAG,EAAEC,KAAK,EAAE;IAC9CF,UAAU,GAAGE,KAAK;EACpB,CAAC;EAED,IAAIH,KAAK,CAAC,CAAC,CAACG,KAAK;EACjBH,KAAK,CAACF,eAAe,GAAGA,eAAe;EACvCE,KAAK,CAACD,iBAAiB,GAAGA,iBAAiB;EAE3C,IAAI,CAACE,UAAU,EAAE,OAAO;IAAEV,QAAQ,EAAE,KAAK;IAAEC,KAAK,EAAE;EAAG,CAAC;EAEtD,MAAMY,eAAe,GAAGH,UAAU,CAACI,KAAK,CAAC,CAAC,GAAGT,IAAI,EAAE,CAAC,GAAGA,IAAI,GAAGC,MAAM,CAAC;EACrE,OAAO;IACLN,QAAQ,EAAE,kBAAkB,CAACe,IAAI,CAACF,eAAe,CAAC,CAAC,CAAC,CAACG,WAAW,CAAC,CAAC,CAAC;IACnEf,KAAK,EAAEY,eAAe,CAACI,GAAG,CAACC,KAAK,IAAI,UAAUA,KAAK,EAAE,CAAC,CAACC,IAAI,CAAC,IAAI;EAClE,CAAC;AACH","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/utils/inherit.js b/scripts/node_modules/@babel/types/lib/utils/inherit.js new file mode 100644 index 0000000000000000000000000000000000000000..9023d2c4d9519a0ebac51aaada09e0e7e790d4da --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/utils/inherit.js @@ -0,0 +1,13 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = inherit; +function inherit(key, child, parent) { + if (child && parent) { + child[key] = Array.from(new Set([].concat(child[key], parent[key]).filter(Boolean))); + } +} + +//# sourceMappingURL=inherit.js.map diff --git a/scripts/node_modules/@babel/types/lib/utils/inherit.js.map b/scripts/node_modules/@babel/types/lib/utils/inherit.js.map new file mode 100644 index 0000000000000000000000000000000000000000..8cfeaa14bc8ee861064b4ee1334e80fd2df7db16 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/utils/inherit.js.map @@ -0,0 +1 @@ +{"version":3,"names":["inherit","key","child","parent","Array","from","Set","concat","filter","Boolean"],"sources":["../../src/utils/inherit.ts"],"sourcesContent":["import type * as t from \"../index.ts\";\n\nexport default function inherit<\n C extends t.Node | undefined,\n P extends t.Node | undefined,\n>(key: keyof C & keyof P, child: C, parent: P): void {\n if (child && parent) {\n // @ts-expect-error Could further refine key definitions\n child[key] = Array.from(\n new Set([].concat(child[key], parent[key]).filter(Boolean)),\n );\n }\n}\n"],"mappings":";;;;;;AAEe,SAASA,OAAOA,CAG7BC,GAAsB,EAAEC,KAAQ,EAAEC,MAAS,EAAQ;EACnD,IAAID,KAAK,IAAIC,MAAM,EAAE;IAEnBD,KAAK,CAACD,GAAG,CAAC,GAAGG,KAAK,CAACC,IAAI,CACrB,IAAIC,GAAG,CAAC,EAAE,CAACC,MAAM,CAACL,KAAK,CAACD,GAAG,CAAC,EAAEE,MAAM,CAACF,GAAG,CAAC,CAAC,CAACO,MAAM,CAACC,OAAO,CAAC,CAC5D,CAAC;EACH;AACF","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/utils/react/cleanJSXElementLiteralChild.js b/scripts/node_modules/@babel/types/lib/utils/react/cleanJSXElementLiteralChild.js new file mode 100644 index 0000000000000000000000000000000000000000..276f2dd982a55cd13fafce53d938a15f3b11baca --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/utils/react/cleanJSXElementLiteralChild.js @@ -0,0 +1,40 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = cleanJSXElementLiteralChild; +var _index = require("../../builders/generated/index.js"); +var _index2 = require("../../index.js"); +function cleanJSXElementLiteralChild(child, args) { + const lines = child.value.split(/\r\n|\n|\r/); + let lastNonEmptyLine = 0; + for (let i = 0; i < lines.length; i++) { + if (/[^ \t]/.exec(lines[i])) { + lastNonEmptyLine = i; + } + } + let str = ""; + for (let i = 0; i < lines.length; i++) { + const line = lines[i]; + const isFirstLine = i === 0; + const isLastLine = i === lines.length - 1; + const isLastNonEmptyLine = i === lastNonEmptyLine; + let trimmedLine = line.replace(/\t/g, " "); + if (!isFirstLine) { + trimmedLine = trimmedLine.replace(/^ +/, ""); + } + if (!isLastLine) { + trimmedLine = trimmedLine.replace(/ +$/, ""); + } + if (trimmedLine) { + if (!isLastNonEmptyLine) { + trimmedLine += " "; + } + str += trimmedLine; + } + } + if (str) args.push((0, _index2.inherits)((0, _index.stringLiteral)(str), child)); +} + +//# sourceMappingURL=cleanJSXElementLiteralChild.js.map diff --git a/scripts/node_modules/@babel/types/lib/utils/react/cleanJSXElementLiteralChild.js.map b/scripts/node_modules/@babel/types/lib/utils/react/cleanJSXElementLiteralChild.js.map new file mode 100644 index 0000000000000000000000000000000000000000..84d02a3f75ad241d1f37d6b05cbcf33bf7f3f318 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/utils/react/cleanJSXElementLiteralChild.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_index","require","_index2","cleanJSXElementLiteralChild","child","args","lines","value","split","lastNonEmptyLine","i","length","exec","str","line","isFirstLine","isLastLine","isLastNonEmptyLine","trimmedLine","replace","push","inherits","stringLiteral"],"sources":["../../../src/utils/react/cleanJSXElementLiteralChild.ts"],"sourcesContent":["import { stringLiteral } from \"../../builders/generated/index.ts\";\nimport type * as t from \"../../index.ts\";\nimport { inherits } from \"../../index.ts\";\n\nexport default function cleanJSXElementLiteralChild(\n child: t.JSXText,\n args: t.Node[],\n) {\n const lines = child.value.split(/\\r\\n|\\n|\\r/);\n\n let lastNonEmptyLine = 0;\n\n for (let i = 0; i < lines.length; i++) {\n if (/[^ \\t]/.exec(lines[i])) {\n lastNonEmptyLine = i;\n }\n }\n\n let str = \"\";\n\n for (let i = 0; i < lines.length; i++) {\n const line = lines[i];\n\n const isFirstLine = i === 0;\n const isLastLine = i === lines.length - 1;\n const isLastNonEmptyLine = i === lastNonEmptyLine;\n\n // replace rendered whitespace tabs with spaces\n let trimmedLine = line.replace(/\\t/g, \" \");\n\n // trim whitespace touching a newline\n if (!isFirstLine) {\n trimmedLine = trimmedLine.replace(/^ +/, \"\");\n }\n\n // trim whitespace touching an endline\n if (!isLastLine) {\n trimmedLine = trimmedLine.replace(/ +$/, \"\");\n }\n\n if (trimmedLine) {\n if (!isLastNonEmptyLine) {\n trimmedLine += \" \";\n }\n\n str += trimmedLine;\n }\n }\n\n if (str) args.push(inherits(stringLiteral(str), child));\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,OAAA,GAAAD,OAAA;AAEe,SAASE,2BAA2BA,CACjDC,KAAgB,EAChBC,IAAc,EACd;EACA,MAAMC,KAAK,GAAGF,KAAK,CAACG,KAAK,CAACC,KAAK,CAAC,YAAY,CAAC;EAE7C,IAAIC,gBAAgB,GAAG,CAAC;EAExB,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGJ,KAAK,CAACK,MAAM,EAAED,CAAC,EAAE,EAAE;IACrC,IAAI,QAAQ,CAACE,IAAI,CAACN,KAAK,CAACI,CAAC,CAAC,CAAC,EAAE;MAC3BD,gBAAgB,GAAGC,CAAC;IACtB;EACF;EAEA,IAAIG,GAAG,GAAG,EAAE;EAEZ,KAAK,IAAIH,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGJ,KAAK,CAACK,MAAM,EAAED,CAAC,EAAE,EAAE;IACrC,MAAMI,IAAI,GAAGR,KAAK,CAACI,CAAC,CAAC;IAErB,MAAMK,WAAW,GAAGL,CAAC,KAAK,CAAC;IAC3B,MAAMM,UAAU,GAAGN,CAAC,KAAKJ,KAAK,CAACK,MAAM,GAAG,CAAC;IACzC,MAAMM,kBAAkB,GAAGP,CAAC,KAAKD,gBAAgB;IAGjD,IAAIS,WAAW,GAAGJ,IAAI,CAACK,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;IAG1C,IAAI,CAACJ,WAAW,EAAE;MAChBG,WAAW,GAAGA,WAAW,CAACC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC;IAC9C;IAGA,IAAI,CAACH,UAAU,EAAE;MACfE,WAAW,GAAGA,WAAW,CAACC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC;IAC9C;IAEA,IAAID,WAAW,EAAE;MACf,IAAI,CAACD,kBAAkB,EAAE;QACvBC,WAAW,IAAI,GAAG;MACpB;MAEAL,GAAG,IAAIK,WAAW;IACpB;EACF;EAEA,IAAIL,GAAG,EAAER,IAAI,CAACe,IAAI,CAAC,IAAAC,gBAAQ,EAAC,IAAAC,oBAAa,EAACT,GAAG,CAAC,EAAET,KAAK,CAAC,CAAC;AACzD","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/utils/shallowEqual.js b/scripts/node_modules/@babel/types/lib/utils/shallowEqual.js new file mode 100644 index 0000000000000000000000000000000000000000..9a1d6c71754b3d889cdd7cdb50c9c424a578bf78 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/utils/shallowEqual.js @@ -0,0 +1,17 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = shallowEqual; +function shallowEqual(actual, expected) { + const keys = Object.keys(expected); + for (const key of keys) { + if (actual[key] !== expected[key]) { + return false; + } + } + return true; +} + +//# sourceMappingURL=shallowEqual.js.map diff --git a/scripts/node_modules/@babel/types/lib/utils/shallowEqual.js.map b/scripts/node_modules/@babel/types/lib/utils/shallowEqual.js.map new file mode 100644 index 0000000000000000000000000000000000000000..11bc65aa6afc1093c35b9517779ccd89b491cf65 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/utils/shallowEqual.js.map @@ -0,0 +1 @@ +{"version":3,"names":["shallowEqual","actual","expected","keys","Object","key"],"sources":["../../src/utils/shallowEqual.ts"],"sourcesContent":["export default function shallowEqual(\n actual: object,\n expected: T,\n): actual is T {\n const keys = Object.keys(expected) as (keyof T)[];\n\n for (const key of keys) {\n if (\n // @ts-expect-error maybe we should check whether key exists first\n actual[key] !== expected[key]\n ) {\n return false;\n }\n }\n\n return true;\n}\n"],"mappings":";;;;;;AAAe,SAASA,YAAYA,CAClCC,MAAc,EACdC,QAAW,EACE;EACb,MAAMC,IAAI,GAAGC,MAAM,CAACD,IAAI,CAACD,QAAQ,CAAgB;EAEjD,KAAK,MAAMG,GAAG,IAAIF,IAAI,EAAE;IACtB,IAEEF,MAAM,CAACI,GAAG,CAAC,KAAKH,QAAQ,CAACG,GAAG,CAAC,EAC7B;MACA,OAAO,KAAK;IACd;EACF;EAEA,OAAO,IAAI;AACb","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/validators/buildMatchMemberExpression.js b/scripts/node_modules/@babel/types/lib/validators/buildMatchMemberExpression.js new file mode 100644 index 0000000000000000000000000000000000000000..dcde1dbf8c93963be254d6a887bba712126fd392 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/buildMatchMemberExpression.js @@ -0,0 +1,13 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = buildMatchMemberExpression; +var _matchesPattern = require("./matchesPattern.js"); +function buildMatchMemberExpression(match, allowPartial) { + const parts = match.split("."); + return member => (0, _matchesPattern.default)(member, parts, allowPartial); +} + +//# sourceMappingURL=buildMatchMemberExpression.js.map diff --git a/scripts/node_modules/@babel/types/lib/validators/buildMatchMemberExpression.js.map b/scripts/node_modules/@babel/types/lib/validators/buildMatchMemberExpression.js.map new file mode 100644 index 0000000000000000000000000000000000000000..ef90b57ac9359c726d2a1d996c1511d1480153dc --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/buildMatchMemberExpression.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_matchesPattern","require","buildMatchMemberExpression","match","allowPartial","parts","split","member","matchesPattern"],"sources":["../../src/validators/buildMatchMemberExpression.ts"],"sourcesContent":["import matchesPattern from \"./matchesPattern.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Build a function that when called will return whether or not the\n * input `node` `MemberExpression` matches the input `match`.\n *\n * For example, given the match `React.createClass` it would match the\n * parsed nodes of `React.createClass` and `React[\"createClass\"]`.\n */\nexport default function buildMatchMemberExpression(\n match: string,\n allowPartial?: boolean,\n) {\n const parts = match.split(\".\");\n\n return (member: t.Node) => matchesPattern(member, parts, allowPartial);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,eAAA,GAAAC,OAAA;AAUe,SAASC,0BAA0BA,CAChDC,KAAa,EACbC,YAAsB,EACtB;EACA,MAAMC,KAAK,GAAGF,KAAK,CAACG,KAAK,CAAC,GAAG,CAAC;EAE9B,OAAQC,MAAc,IAAK,IAAAC,uBAAc,EAACD,MAAM,EAAEF,KAAK,EAAED,YAAY,CAAC;AACxE","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/validators/generated/index.js b/scripts/node_modules/@babel/types/lib/validators/generated/index.js new file mode 100644 index 0000000000000000000000000000000000000000..a26bea27d32e52fdf54f0a4ab098511c3da7fc31 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/generated/index.js @@ -0,0 +1,2797 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.isAccessor = isAccessor; +exports.isAnyTypeAnnotation = isAnyTypeAnnotation; +exports.isArgumentPlaceholder = isArgumentPlaceholder; +exports.isArrayExpression = isArrayExpression; +exports.isArrayPattern = isArrayPattern; +exports.isArrayTypeAnnotation = isArrayTypeAnnotation; +exports.isArrowFunctionExpression = isArrowFunctionExpression; +exports.isAssignmentExpression = isAssignmentExpression; +exports.isAssignmentPattern = isAssignmentPattern; +exports.isAwaitExpression = isAwaitExpression; +exports.isBigIntLiteral = isBigIntLiteral; +exports.isBinary = isBinary; +exports.isBinaryExpression = isBinaryExpression; +exports.isBindExpression = isBindExpression; +exports.isBlock = isBlock; +exports.isBlockParent = isBlockParent; +exports.isBlockStatement = isBlockStatement; +exports.isBooleanLiteral = isBooleanLiteral; +exports.isBooleanLiteralTypeAnnotation = isBooleanLiteralTypeAnnotation; +exports.isBooleanTypeAnnotation = isBooleanTypeAnnotation; +exports.isBreakStatement = isBreakStatement; +exports.isCallExpression = isCallExpression; +exports.isCatchClause = isCatchClause; +exports.isClass = isClass; +exports.isClassAccessorProperty = isClassAccessorProperty; +exports.isClassBody = isClassBody; +exports.isClassDeclaration = isClassDeclaration; +exports.isClassExpression = isClassExpression; +exports.isClassImplements = isClassImplements; +exports.isClassMethod = isClassMethod; +exports.isClassPrivateMethod = isClassPrivateMethod; +exports.isClassPrivateProperty = isClassPrivateProperty; +exports.isClassProperty = isClassProperty; +exports.isCompletionStatement = isCompletionStatement; +exports.isConditional = isConditional; +exports.isConditionalExpression = isConditionalExpression; +exports.isContinueStatement = isContinueStatement; +exports.isDebuggerStatement = isDebuggerStatement; +exports.isDecimalLiteral = isDecimalLiteral; +exports.isDeclaration = isDeclaration; +exports.isDeclareClass = isDeclareClass; +exports.isDeclareExportAllDeclaration = isDeclareExportAllDeclaration; +exports.isDeclareExportDeclaration = isDeclareExportDeclaration; +exports.isDeclareFunction = isDeclareFunction; +exports.isDeclareInterface = isDeclareInterface; +exports.isDeclareModule = isDeclareModule; +exports.isDeclareModuleExports = isDeclareModuleExports; +exports.isDeclareOpaqueType = isDeclareOpaqueType; +exports.isDeclareTypeAlias = isDeclareTypeAlias; +exports.isDeclareVariable = isDeclareVariable; +exports.isDeclaredPredicate = isDeclaredPredicate; +exports.isDecorator = isDecorator; +exports.isDirective = isDirective; +exports.isDirectiveLiteral = isDirectiveLiteral; +exports.isDoExpression = isDoExpression; +exports.isDoWhileStatement = isDoWhileStatement; +exports.isEmptyStatement = isEmptyStatement; +exports.isEmptyTypeAnnotation = isEmptyTypeAnnotation; +exports.isEnumBody = isEnumBody; +exports.isEnumBooleanBody = isEnumBooleanBody; +exports.isEnumBooleanMember = isEnumBooleanMember; +exports.isEnumDeclaration = isEnumDeclaration; +exports.isEnumDefaultedMember = isEnumDefaultedMember; +exports.isEnumMember = isEnumMember; +exports.isEnumNumberBody = isEnumNumberBody; +exports.isEnumNumberMember = isEnumNumberMember; +exports.isEnumStringBody = isEnumStringBody; +exports.isEnumStringMember = isEnumStringMember; +exports.isEnumSymbolBody = isEnumSymbolBody; +exports.isExistsTypeAnnotation = isExistsTypeAnnotation; +exports.isExportAllDeclaration = isExportAllDeclaration; +exports.isExportDeclaration = isExportDeclaration; +exports.isExportDefaultDeclaration = isExportDefaultDeclaration; +exports.isExportDefaultSpecifier = isExportDefaultSpecifier; +exports.isExportNamedDeclaration = isExportNamedDeclaration; +exports.isExportNamespaceSpecifier = isExportNamespaceSpecifier; +exports.isExportSpecifier = isExportSpecifier; +exports.isExpression = isExpression; +exports.isExpressionStatement = isExpressionStatement; +exports.isExpressionWrapper = isExpressionWrapper; +exports.isFile = isFile; +exports.isFlow = isFlow; +exports.isFlowBaseAnnotation = isFlowBaseAnnotation; +exports.isFlowDeclaration = isFlowDeclaration; +exports.isFlowPredicate = isFlowPredicate; +exports.isFlowType = isFlowType; +exports.isFor = isFor; +exports.isForInStatement = isForInStatement; +exports.isForOfStatement = isForOfStatement; +exports.isForStatement = isForStatement; +exports.isForXStatement = isForXStatement; +exports.isFunction = isFunction; +exports.isFunctionDeclaration = isFunctionDeclaration; +exports.isFunctionExpression = isFunctionExpression; +exports.isFunctionParameter = isFunctionParameter; +exports.isFunctionParent = isFunctionParent; +exports.isFunctionTypeAnnotation = isFunctionTypeAnnotation; +exports.isFunctionTypeParam = isFunctionTypeParam; +exports.isGenericTypeAnnotation = isGenericTypeAnnotation; +exports.isIdentifier = isIdentifier; +exports.isIfStatement = isIfStatement; +exports.isImmutable = isImmutable; +exports.isImport = isImport; +exports.isImportAttribute = isImportAttribute; +exports.isImportDeclaration = isImportDeclaration; +exports.isImportDefaultSpecifier = isImportDefaultSpecifier; +exports.isImportExpression = isImportExpression; +exports.isImportNamespaceSpecifier = isImportNamespaceSpecifier; +exports.isImportOrExportDeclaration = isImportOrExportDeclaration; +exports.isImportSpecifier = isImportSpecifier; +exports.isIndexedAccessType = isIndexedAccessType; +exports.isInferredPredicate = isInferredPredicate; +exports.isInterfaceDeclaration = isInterfaceDeclaration; +exports.isInterfaceExtends = isInterfaceExtends; +exports.isInterfaceTypeAnnotation = isInterfaceTypeAnnotation; +exports.isInterpreterDirective = isInterpreterDirective; +exports.isIntersectionTypeAnnotation = isIntersectionTypeAnnotation; +exports.isJSX = isJSX; +exports.isJSXAttribute = isJSXAttribute; +exports.isJSXClosingElement = isJSXClosingElement; +exports.isJSXClosingFragment = isJSXClosingFragment; +exports.isJSXElement = isJSXElement; +exports.isJSXEmptyExpression = isJSXEmptyExpression; +exports.isJSXExpressionContainer = isJSXExpressionContainer; +exports.isJSXFragment = isJSXFragment; +exports.isJSXIdentifier = isJSXIdentifier; +exports.isJSXMemberExpression = isJSXMemberExpression; +exports.isJSXNamespacedName = isJSXNamespacedName; +exports.isJSXOpeningElement = isJSXOpeningElement; +exports.isJSXOpeningFragment = isJSXOpeningFragment; +exports.isJSXSpreadAttribute = isJSXSpreadAttribute; +exports.isJSXSpreadChild = isJSXSpreadChild; +exports.isJSXText = isJSXText; +exports.isLVal = isLVal; +exports.isLabeledStatement = isLabeledStatement; +exports.isLiteral = isLiteral; +exports.isLogicalExpression = isLogicalExpression; +exports.isLoop = isLoop; +exports.isMemberExpression = isMemberExpression; +exports.isMetaProperty = isMetaProperty; +exports.isMethod = isMethod; +exports.isMiscellaneous = isMiscellaneous; +exports.isMixedTypeAnnotation = isMixedTypeAnnotation; +exports.isModuleDeclaration = isModuleDeclaration; +exports.isModuleExpression = isModuleExpression; +exports.isModuleSpecifier = isModuleSpecifier; +exports.isNewExpression = isNewExpression; +exports.isNoop = isNoop; +exports.isNullLiteral = isNullLiteral; +exports.isNullLiteralTypeAnnotation = isNullLiteralTypeAnnotation; +exports.isNullableTypeAnnotation = isNullableTypeAnnotation; +exports.isNumberLiteral = isNumberLiteral; +exports.isNumberLiteralTypeAnnotation = isNumberLiteralTypeAnnotation; +exports.isNumberTypeAnnotation = isNumberTypeAnnotation; +exports.isNumericLiteral = isNumericLiteral; +exports.isObjectExpression = isObjectExpression; +exports.isObjectMember = isObjectMember; +exports.isObjectMethod = isObjectMethod; +exports.isObjectPattern = isObjectPattern; +exports.isObjectProperty = isObjectProperty; +exports.isObjectTypeAnnotation = isObjectTypeAnnotation; +exports.isObjectTypeCallProperty = isObjectTypeCallProperty; +exports.isObjectTypeIndexer = isObjectTypeIndexer; +exports.isObjectTypeInternalSlot = isObjectTypeInternalSlot; +exports.isObjectTypeProperty = isObjectTypeProperty; +exports.isObjectTypeSpreadProperty = isObjectTypeSpreadProperty; +exports.isOpaqueType = isOpaqueType; +exports.isOptionalCallExpression = isOptionalCallExpression; +exports.isOptionalIndexedAccessType = isOptionalIndexedAccessType; +exports.isOptionalMemberExpression = isOptionalMemberExpression; +exports.isParenthesizedExpression = isParenthesizedExpression; +exports.isPattern = isPattern; +exports.isPatternLike = isPatternLike; +exports.isPipelineBareFunction = isPipelineBareFunction; +exports.isPipelinePrimaryTopicReference = isPipelinePrimaryTopicReference; +exports.isPipelineTopicExpression = isPipelineTopicExpression; +exports.isPlaceholder = isPlaceholder; +exports.isPrivate = isPrivate; +exports.isPrivateName = isPrivateName; +exports.isProgram = isProgram; +exports.isProperty = isProperty; +exports.isPureish = isPureish; +exports.isQualifiedTypeIdentifier = isQualifiedTypeIdentifier; +exports.isRecordExpression = isRecordExpression; +exports.isRegExpLiteral = isRegExpLiteral; +exports.isRegexLiteral = isRegexLiteral; +exports.isRestElement = isRestElement; +exports.isRestProperty = isRestProperty; +exports.isReturnStatement = isReturnStatement; +exports.isScopable = isScopable; +exports.isSequenceExpression = isSequenceExpression; +exports.isSpreadElement = isSpreadElement; +exports.isSpreadProperty = isSpreadProperty; +exports.isStandardized = isStandardized; +exports.isStatement = isStatement; +exports.isStaticBlock = isStaticBlock; +exports.isStringLiteral = isStringLiteral; +exports.isStringLiteralTypeAnnotation = isStringLiteralTypeAnnotation; +exports.isStringTypeAnnotation = isStringTypeAnnotation; +exports.isSuper = isSuper; +exports.isSwitchCase = isSwitchCase; +exports.isSwitchStatement = isSwitchStatement; +exports.isSymbolTypeAnnotation = isSymbolTypeAnnotation; +exports.isTSAnyKeyword = isTSAnyKeyword; +exports.isTSArrayType = isTSArrayType; +exports.isTSAsExpression = isTSAsExpression; +exports.isTSBaseType = isTSBaseType; +exports.isTSBigIntKeyword = isTSBigIntKeyword; +exports.isTSBooleanKeyword = isTSBooleanKeyword; +exports.isTSCallSignatureDeclaration = isTSCallSignatureDeclaration; +exports.isTSConditionalType = isTSConditionalType; +exports.isTSConstructSignatureDeclaration = isTSConstructSignatureDeclaration; +exports.isTSConstructorType = isTSConstructorType; +exports.isTSDeclareFunction = isTSDeclareFunction; +exports.isTSDeclareMethod = isTSDeclareMethod; +exports.isTSEntityName = isTSEntityName; +exports.isTSEnumBody = isTSEnumBody; +exports.isTSEnumDeclaration = isTSEnumDeclaration; +exports.isTSEnumMember = isTSEnumMember; +exports.isTSExportAssignment = isTSExportAssignment; +exports.isTSExpressionWithTypeArguments = isTSExpressionWithTypeArguments; +exports.isTSExternalModuleReference = isTSExternalModuleReference; +exports.isTSFunctionType = isTSFunctionType; +exports.isTSImportEqualsDeclaration = isTSImportEqualsDeclaration; +exports.isTSImportType = isTSImportType; +exports.isTSIndexSignature = isTSIndexSignature; +exports.isTSIndexedAccessType = isTSIndexedAccessType; +exports.isTSInferType = isTSInferType; +exports.isTSInstantiationExpression = isTSInstantiationExpression; +exports.isTSInterfaceBody = isTSInterfaceBody; +exports.isTSInterfaceDeclaration = isTSInterfaceDeclaration; +exports.isTSIntersectionType = isTSIntersectionType; +exports.isTSIntrinsicKeyword = isTSIntrinsicKeyword; +exports.isTSLiteralType = isTSLiteralType; +exports.isTSMappedType = isTSMappedType; +exports.isTSMethodSignature = isTSMethodSignature; +exports.isTSModuleBlock = isTSModuleBlock; +exports.isTSModuleDeclaration = isTSModuleDeclaration; +exports.isTSNamedTupleMember = isTSNamedTupleMember; +exports.isTSNamespaceExportDeclaration = isTSNamespaceExportDeclaration; +exports.isTSNeverKeyword = isTSNeverKeyword; +exports.isTSNonNullExpression = isTSNonNullExpression; +exports.isTSNullKeyword = isTSNullKeyword; +exports.isTSNumberKeyword = isTSNumberKeyword; +exports.isTSObjectKeyword = isTSObjectKeyword; +exports.isTSOptionalType = isTSOptionalType; +exports.isTSParameterProperty = isTSParameterProperty; +exports.isTSParenthesizedType = isTSParenthesizedType; +exports.isTSPropertySignature = isTSPropertySignature; +exports.isTSQualifiedName = isTSQualifiedName; +exports.isTSRestType = isTSRestType; +exports.isTSSatisfiesExpression = isTSSatisfiesExpression; +exports.isTSStringKeyword = isTSStringKeyword; +exports.isTSSymbolKeyword = isTSSymbolKeyword; +exports.isTSTemplateLiteralType = isTSTemplateLiteralType; +exports.isTSThisType = isTSThisType; +exports.isTSTupleType = isTSTupleType; +exports.isTSType = isTSType; +exports.isTSTypeAliasDeclaration = isTSTypeAliasDeclaration; +exports.isTSTypeAnnotation = isTSTypeAnnotation; +exports.isTSTypeAssertion = isTSTypeAssertion; +exports.isTSTypeElement = isTSTypeElement; +exports.isTSTypeLiteral = isTSTypeLiteral; +exports.isTSTypeOperator = isTSTypeOperator; +exports.isTSTypeParameter = isTSTypeParameter; +exports.isTSTypeParameterDeclaration = isTSTypeParameterDeclaration; +exports.isTSTypeParameterInstantiation = isTSTypeParameterInstantiation; +exports.isTSTypePredicate = isTSTypePredicate; +exports.isTSTypeQuery = isTSTypeQuery; +exports.isTSTypeReference = isTSTypeReference; +exports.isTSUndefinedKeyword = isTSUndefinedKeyword; +exports.isTSUnionType = isTSUnionType; +exports.isTSUnknownKeyword = isTSUnknownKeyword; +exports.isTSVoidKeyword = isTSVoidKeyword; +exports.isTaggedTemplateExpression = isTaggedTemplateExpression; +exports.isTemplateElement = isTemplateElement; +exports.isTemplateLiteral = isTemplateLiteral; +exports.isTerminatorless = isTerminatorless; +exports.isThisExpression = isThisExpression; +exports.isThisTypeAnnotation = isThisTypeAnnotation; +exports.isThrowStatement = isThrowStatement; +exports.isTopicReference = isTopicReference; +exports.isTryStatement = isTryStatement; +exports.isTupleExpression = isTupleExpression; +exports.isTupleTypeAnnotation = isTupleTypeAnnotation; +exports.isTypeAlias = isTypeAlias; +exports.isTypeAnnotation = isTypeAnnotation; +exports.isTypeCastExpression = isTypeCastExpression; +exports.isTypeParameter = isTypeParameter; +exports.isTypeParameterDeclaration = isTypeParameterDeclaration; +exports.isTypeParameterInstantiation = isTypeParameterInstantiation; +exports.isTypeScript = isTypeScript; +exports.isTypeofTypeAnnotation = isTypeofTypeAnnotation; +exports.isUnaryExpression = isUnaryExpression; +exports.isUnaryLike = isUnaryLike; +exports.isUnionTypeAnnotation = isUnionTypeAnnotation; +exports.isUpdateExpression = isUpdateExpression; +exports.isUserWhitespacable = isUserWhitespacable; +exports.isV8IntrinsicIdentifier = isV8IntrinsicIdentifier; +exports.isVariableDeclaration = isVariableDeclaration; +exports.isVariableDeclarator = isVariableDeclarator; +exports.isVariance = isVariance; +exports.isVoidPattern = isVoidPattern; +exports.isVoidTypeAnnotation = isVoidTypeAnnotation; +exports.isWhile = isWhile; +exports.isWhileStatement = isWhileStatement; +exports.isWithStatement = isWithStatement; +exports.isYieldExpression = isYieldExpression; +var _shallowEqual = require("../../utils/shallowEqual.js"); +var _deprecationWarning = require("../../utils/deprecationWarning.js"); +function isArrayExpression(node, opts) { + if (!node) return false; + if (node.type !== "ArrayExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isAssignmentExpression(node, opts) { + if (!node) return false; + if (node.type !== "AssignmentExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isBinaryExpression(node, opts) { + if (!node) return false; + if (node.type !== "BinaryExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isInterpreterDirective(node, opts) { + if (!node) return false; + if (node.type !== "InterpreterDirective") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDirective(node, opts) { + if (!node) return false; + if (node.type !== "Directive") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDirectiveLiteral(node, opts) { + if (!node) return false; + if (node.type !== "DirectiveLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isBlockStatement(node, opts) { + if (!node) return false; + if (node.type !== "BlockStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isBreakStatement(node, opts) { + if (!node) return false; + if (node.type !== "BreakStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isCallExpression(node, opts) { + if (!node) return false; + if (node.type !== "CallExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isCatchClause(node, opts) { + if (!node) return false; + if (node.type !== "CatchClause") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isConditionalExpression(node, opts) { + if (!node) return false; + if (node.type !== "ConditionalExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isContinueStatement(node, opts) { + if (!node) return false; + if (node.type !== "ContinueStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDebuggerStatement(node, opts) { + if (!node) return false; + if (node.type !== "DebuggerStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDoWhileStatement(node, opts) { + if (!node) return false; + if (node.type !== "DoWhileStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEmptyStatement(node, opts) { + if (!node) return false; + if (node.type !== "EmptyStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isExpressionStatement(node, opts) { + if (!node) return false; + if (node.type !== "ExpressionStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFile(node, opts) { + if (!node) return false; + if (node.type !== "File") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isForInStatement(node, opts) { + if (!node) return false; + if (node.type !== "ForInStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isForStatement(node, opts) { + if (!node) return false; + if (node.type !== "ForStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFunctionDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "FunctionDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFunctionExpression(node, opts) { + if (!node) return false; + if (node.type !== "FunctionExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isIdentifier(node, opts) { + if (!node) return false; + if (node.type !== "Identifier") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isIfStatement(node, opts) { + if (!node) return false; + if (node.type !== "IfStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isLabeledStatement(node, opts) { + if (!node) return false; + if (node.type !== "LabeledStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isStringLiteral(node, opts) { + if (!node) return false; + if (node.type !== "StringLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isNumericLiteral(node, opts) { + if (!node) return false; + if (node.type !== "NumericLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isNullLiteral(node, opts) { + if (!node) return false; + if (node.type !== "NullLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isBooleanLiteral(node, opts) { + if (!node) return false; + if (node.type !== "BooleanLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isRegExpLiteral(node, opts) { + if (!node) return false; + if (node.type !== "RegExpLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isLogicalExpression(node, opts) { + if (!node) return false; + if (node.type !== "LogicalExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isMemberExpression(node, opts) { + if (!node) return false; + if (node.type !== "MemberExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isNewExpression(node, opts) { + if (!node) return false; + if (node.type !== "NewExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isProgram(node, opts) { + if (!node) return false; + if (node.type !== "Program") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isObjectExpression(node, opts) { + if (!node) return false; + if (node.type !== "ObjectExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isObjectMethod(node, opts) { + if (!node) return false; + if (node.type !== "ObjectMethod") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isObjectProperty(node, opts) { + if (!node) return false; + if (node.type !== "ObjectProperty") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isRestElement(node, opts) { + if (!node) return false; + if (node.type !== "RestElement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isReturnStatement(node, opts) { + if (!node) return false; + if (node.type !== "ReturnStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isSequenceExpression(node, opts) { + if (!node) return false; + if (node.type !== "SequenceExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isParenthesizedExpression(node, opts) { + if (!node) return false; + if (node.type !== "ParenthesizedExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isSwitchCase(node, opts) { + if (!node) return false; + if (node.type !== "SwitchCase") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isSwitchStatement(node, opts) { + if (!node) return false; + if (node.type !== "SwitchStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isThisExpression(node, opts) { + if (!node) return false; + if (node.type !== "ThisExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isThrowStatement(node, opts) { + if (!node) return false; + if (node.type !== "ThrowStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTryStatement(node, opts) { + if (!node) return false; + if (node.type !== "TryStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isUnaryExpression(node, opts) { + if (!node) return false; + if (node.type !== "UnaryExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isUpdateExpression(node, opts) { + if (!node) return false; + if (node.type !== "UpdateExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isVariableDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "VariableDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isVariableDeclarator(node, opts) { + if (!node) return false; + if (node.type !== "VariableDeclarator") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isWhileStatement(node, opts) { + if (!node) return false; + if (node.type !== "WhileStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isWithStatement(node, opts) { + if (!node) return false; + if (node.type !== "WithStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isAssignmentPattern(node, opts) { + if (!node) return false; + if (node.type !== "AssignmentPattern") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isArrayPattern(node, opts) { + if (!node) return false; + if (node.type !== "ArrayPattern") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isArrowFunctionExpression(node, opts) { + if (!node) return false; + if (node.type !== "ArrowFunctionExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isClassBody(node, opts) { + if (!node) return false; + if (node.type !== "ClassBody") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isClassExpression(node, opts) { + if (!node) return false; + if (node.type !== "ClassExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isClassDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "ClassDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isExportAllDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "ExportAllDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isExportDefaultDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "ExportDefaultDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isExportNamedDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "ExportNamedDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isExportSpecifier(node, opts) { + if (!node) return false; + if (node.type !== "ExportSpecifier") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isForOfStatement(node, opts) { + if (!node) return false; + if (node.type !== "ForOfStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isImportDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "ImportDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isImportDefaultSpecifier(node, opts) { + if (!node) return false; + if (node.type !== "ImportDefaultSpecifier") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isImportNamespaceSpecifier(node, opts) { + if (!node) return false; + if (node.type !== "ImportNamespaceSpecifier") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isImportSpecifier(node, opts) { + if (!node) return false; + if (node.type !== "ImportSpecifier") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isImportExpression(node, opts) { + if (!node) return false; + if (node.type !== "ImportExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isMetaProperty(node, opts) { + if (!node) return false; + if (node.type !== "MetaProperty") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isClassMethod(node, opts) { + if (!node) return false; + if (node.type !== "ClassMethod") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isObjectPattern(node, opts) { + if (!node) return false; + if (node.type !== "ObjectPattern") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isSpreadElement(node, opts) { + if (!node) return false; + if (node.type !== "SpreadElement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isSuper(node, opts) { + if (!node) return false; + if (node.type !== "Super") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTaggedTemplateExpression(node, opts) { + if (!node) return false; + if (node.type !== "TaggedTemplateExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTemplateElement(node, opts) { + if (!node) return false; + if (node.type !== "TemplateElement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTemplateLiteral(node, opts) { + if (!node) return false; + if (node.type !== "TemplateLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isYieldExpression(node, opts) { + if (!node) return false; + if (node.type !== "YieldExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isAwaitExpression(node, opts) { + if (!node) return false; + if (node.type !== "AwaitExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isImport(node, opts) { + if (!node) return false; + if (node.type !== "Import") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isBigIntLiteral(node, opts) { + if (!node) return false; + if (node.type !== "BigIntLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isExportNamespaceSpecifier(node, opts) { + if (!node) return false; + if (node.type !== "ExportNamespaceSpecifier") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isOptionalMemberExpression(node, opts) { + if (!node) return false; + if (node.type !== "OptionalMemberExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isOptionalCallExpression(node, opts) { + if (!node) return false; + if (node.type !== "OptionalCallExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isClassProperty(node, opts) { + if (!node) return false; + if (node.type !== "ClassProperty") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isClassAccessorProperty(node, opts) { + if (!node) return false; + if (node.type !== "ClassAccessorProperty") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isClassPrivateProperty(node, opts) { + if (!node) return false; + if (node.type !== "ClassPrivateProperty") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isClassPrivateMethod(node, opts) { + if (!node) return false; + if (node.type !== "ClassPrivateMethod") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isPrivateName(node, opts) { + if (!node) return false; + if (node.type !== "PrivateName") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isStaticBlock(node, opts) { + if (!node) return false; + if (node.type !== "StaticBlock") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isImportAttribute(node, opts) { + if (!node) return false; + if (node.type !== "ImportAttribute") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isAnyTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "AnyTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isArrayTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "ArrayTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isBooleanTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "BooleanTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isBooleanLiteralTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "BooleanLiteralTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isNullLiteralTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "NullLiteralTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isClassImplements(node, opts) { + if (!node) return false; + if (node.type !== "ClassImplements") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclareClass(node, opts) { + if (!node) return false; + if (node.type !== "DeclareClass") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclareFunction(node, opts) { + if (!node) return false; + if (node.type !== "DeclareFunction") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclareInterface(node, opts) { + if (!node) return false; + if (node.type !== "DeclareInterface") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclareModule(node, opts) { + if (!node) return false; + if (node.type !== "DeclareModule") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclareModuleExports(node, opts) { + if (!node) return false; + if (node.type !== "DeclareModuleExports") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclareTypeAlias(node, opts) { + if (!node) return false; + if (node.type !== "DeclareTypeAlias") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclareOpaqueType(node, opts) { + if (!node) return false; + if (node.type !== "DeclareOpaqueType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclareVariable(node, opts) { + if (!node) return false; + if (node.type !== "DeclareVariable") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclareExportDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "DeclareExportDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclareExportAllDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "DeclareExportAllDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclaredPredicate(node, opts) { + if (!node) return false; + if (node.type !== "DeclaredPredicate") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isExistsTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "ExistsTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFunctionTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "FunctionTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFunctionTypeParam(node, opts) { + if (!node) return false; + if (node.type !== "FunctionTypeParam") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isGenericTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "GenericTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isInferredPredicate(node, opts) { + if (!node) return false; + if (node.type !== "InferredPredicate") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isInterfaceExtends(node, opts) { + if (!node) return false; + if (node.type !== "InterfaceExtends") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isInterfaceDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "InterfaceDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isInterfaceTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "InterfaceTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isIntersectionTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "IntersectionTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isMixedTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "MixedTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEmptyTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "EmptyTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isNullableTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "NullableTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isNumberLiteralTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "NumberLiteralTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isNumberTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "NumberTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isObjectTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "ObjectTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isObjectTypeInternalSlot(node, opts) { + if (!node) return false; + if (node.type !== "ObjectTypeInternalSlot") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isObjectTypeCallProperty(node, opts) { + if (!node) return false; + if (node.type !== "ObjectTypeCallProperty") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isObjectTypeIndexer(node, opts) { + if (!node) return false; + if (node.type !== "ObjectTypeIndexer") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isObjectTypeProperty(node, opts) { + if (!node) return false; + if (node.type !== "ObjectTypeProperty") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isObjectTypeSpreadProperty(node, opts) { + if (!node) return false; + if (node.type !== "ObjectTypeSpreadProperty") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isOpaqueType(node, opts) { + if (!node) return false; + if (node.type !== "OpaqueType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isQualifiedTypeIdentifier(node, opts) { + if (!node) return false; + if (node.type !== "QualifiedTypeIdentifier") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isStringLiteralTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "StringLiteralTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isStringTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "StringTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isSymbolTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "SymbolTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isThisTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "ThisTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTupleTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "TupleTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTypeofTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "TypeofTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTypeAlias(node, opts) { + if (!node) return false; + if (node.type !== "TypeAlias") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "TypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTypeCastExpression(node, opts) { + if (!node) return false; + if (node.type !== "TypeCastExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTypeParameter(node, opts) { + if (!node) return false; + if (node.type !== "TypeParameter") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTypeParameterDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "TypeParameterDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTypeParameterInstantiation(node, opts) { + if (!node) return false; + if (node.type !== "TypeParameterInstantiation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isUnionTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "UnionTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isVariance(node, opts) { + if (!node) return false; + if (node.type !== "Variance") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isVoidTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "VoidTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEnumDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "EnumDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEnumBooleanBody(node, opts) { + if (!node) return false; + if (node.type !== "EnumBooleanBody") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEnumNumberBody(node, opts) { + if (!node) return false; + if (node.type !== "EnumNumberBody") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEnumStringBody(node, opts) { + if (!node) return false; + if (node.type !== "EnumStringBody") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEnumSymbolBody(node, opts) { + if (!node) return false; + if (node.type !== "EnumSymbolBody") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEnumBooleanMember(node, opts) { + if (!node) return false; + if (node.type !== "EnumBooleanMember") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEnumNumberMember(node, opts) { + if (!node) return false; + if (node.type !== "EnumNumberMember") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEnumStringMember(node, opts) { + if (!node) return false; + if (node.type !== "EnumStringMember") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEnumDefaultedMember(node, opts) { + if (!node) return false; + if (node.type !== "EnumDefaultedMember") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isIndexedAccessType(node, opts) { + if (!node) return false; + if (node.type !== "IndexedAccessType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isOptionalIndexedAccessType(node, opts) { + if (!node) return false; + if (node.type !== "OptionalIndexedAccessType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXAttribute(node, opts) { + if (!node) return false; + if (node.type !== "JSXAttribute") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXClosingElement(node, opts) { + if (!node) return false; + if (node.type !== "JSXClosingElement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXElement(node, opts) { + if (!node) return false; + if (node.type !== "JSXElement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXEmptyExpression(node, opts) { + if (!node) return false; + if (node.type !== "JSXEmptyExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXExpressionContainer(node, opts) { + if (!node) return false; + if (node.type !== "JSXExpressionContainer") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXSpreadChild(node, opts) { + if (!node) return false; + if (node.type !== "JSXSpreadChild") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXIdentifier(node, opts) { + if (!node) return false; + if (node.type !== "JSXIdentifier") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXMemberExpression(node, opts) { + if (!node) return false; + if (node.type !== "JSXMemberExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXNamespacedName(node, opts) { + if (!node) return false; + if (node.type !== "JSXNamespacedName") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXOpeningElement(node, opts) { + if (!node) return false; + if (node.type !== "JSXOpeningElement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXSpreadAttribute(node, opts) { + if (!node) return false; + if (node.type !== "JSXSpreadAttribute") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXText(node, opts) { + if (!node) return false; + if (node.type !== "JSXText") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXFragment(node, opts) { + if (!node) return false; + if (node.type !== "JSXFragment") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXOpeningFragment(node, opts) { + if (!node) return false; + if (node.type !== "JSXOpeningFragment") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXClosingFragment(node, opts) { + if (!node) return false; + if (node.type !== "JSXClosingFragment") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isNoop(node, opts) { + if (!node) return false; + if (node.type !== "Noop") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isPlaceholder(node, opts) { + if (!node) return false; + if (node.type !== "Placeholder") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isV8IntrinsicIdentifier(node, opts) { + if (!node) return false; + if (node.type !== "V8IntrinsicIdentifier") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isArgumentPlaceholder(node, opts) { + if (!node) return false; + if (node.type !== "ArgumentPlaceholder") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isBindExpression(node, opts) { + if (!node) return false; + if (node.type !== "BindExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDecorator(node, opts) { + if (!node) return false; + if (node.type !== "Decorator") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDoExpression(node, opts) { + if (!node) return false; + if (node.type !== "DoExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isExportDefaultSpecifier(node, opts) { + if (!node) return false; + if (node.type !== "ExportDefaultSpecifier") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isRecordExpression(node, opts) { + if (!node) return false; + if (node.type !== "RecordExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTupleExpression(node, opts) { + if (!node) return false; + if (node.type !== "TupleExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDecimalLiteral(node, opts) { + if (!node) return false; + if (node.type !== "DecimalLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isModuleExpression(node, opts) { + if (!node) return false; + if (node.type !== "ModuleExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTopicReference(node, opts) { + if (!node) return false; + if (node.type !== "TopicReference") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isPipelineTopicExpression(node, opts) { + if (!node) return false; + if (node.type !== "PipelineTopicExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isPipelineBareFunction(node, opts) { + if (!node) return false; + if (node.type !== "PipelineBareFunction") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isPipelinePrimaryTopicReference(node, opts) { + if (!node) return false; + if (node.type !== "PipelinePrimaryTopicReference") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isVoidPattern(node, opts) { + if (!node) return false; + if (node.type !== "VoidPattern") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSParameterProperty(node, opts) { + if (!node) return false; + if (node.type !== "TSParameterProperty") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSDeclareFunction(node, opts) { + if (!node) return false; + if (node.type !== "TSDeclareFunction") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSDeclareMethod(node, opts) { + if (!node) return false; + if (node.type !== "TSDeclareMethod") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSQualifiedName(node, opts) { + if (!node) return false; + if (node.type !== "TSQualifiedName") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSCallSignatureDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "TSCallSignatureDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSConstructSignatureDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "TSConstructSignatureDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSPropertySignature(node, opts) { + if (!node) return false; + if (node.type !== "TSPropertySignature") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSMethodSignature(node, opts) { + if (!node) return false; + if (node.type !== "TSMethodSignature") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSIndexSignature(node, opts) { + if (!node) return false; + if (node.type !== "TSIndexSignature") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSAnyKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSAnyKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSBooleanKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSBooleanKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSBigIntKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSBigIntKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSIntrinsicKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSIntrinsicKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSNeverKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSNeverKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSNullKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSNullKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSNumberKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSNumberKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSObjectKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSObjectKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSStringKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSStringKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSSymbolKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSSymbolKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSUndefinedKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSUndefinedKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSUnknownKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSUnknownKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSVoidKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSVoidKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSThisType(node, opts) { + if (!node) return false; + if (node.type !== "TSThisType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSFunctionType(node, opts) { + if (!node) return false; + if (node.type !== "TSFunctionType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSConstructorType(node, opts) { + if (!node) return false; + if (node.type !== "TSConstructorType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypeReference(node, opts) { + if (!node) return false; + if (node.type !== "TSTypeReference") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypePredicate(node, opts) { + if (!node) return false; + if (node.type !== "TSTypePredicate") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypeQuery(node, opts) { + if (!node) return false; + if (node.type !== "TSTypeQuery") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypeLiteral(node, opts) { + if (!node) return false; + if (node.type !== "TSTypeLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSArrayType(node, opts) { + if (!node) return false; + if (node.type !== "TSArrayType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTupleType(node, opts) { + if (!node) return false; + if (node.type !== "TSTupleType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSOptionalType(node, opts) { + if (!node) return false; + if (node.type !== "TSOptionalType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSRestType(node, opts) { + if (!node) return false; + if (node.type !== "TSRestType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSNamedTupleMember(node, opts) { + if (!node) return false; + if (node.type !== "TSNamedTupleMember") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSUnionType(node, opts) { + if (!node) return false; + if (node.type !== "TSUnionType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSIntersectionType(node, opts) { + if (!node) return false; + if (node.type !== "TSIntersectionType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSConditionalType(node, opts) { + if (!node) return false; + if (node.type !== "TSConditionalType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSInferType(node, opts) { + if (!node) return false; + if (node.type !== "TSInferType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSParenthesizedType(node, opts) { + if (!node) return false; + if (node.type !== "TSParenthesizedType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypeOperator(node, opts) { + if (!node) return false; + if (node.type !== "TSTypeOperator") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSIndexedAccessType(node, opts) { + if (!node) return false; + if (node.type !== "TSIndexedAccessType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSMappedType(node, opts) { + if (!node) return false; + if (node.type !== "TSMappedType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTemplateLiteralType(node, opts) { + if (!node) return false; + if (node.type !== "TSTemplateLiteralType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSLiteralType(node, opts) { + if (!node) return false; + if (node.type !== "TSLiteralType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSExpressionWithTypeArguments(node, opts) { + if (!node) return false; + if (node.type !== "TSExpressionWithTypeArguments") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSInterfaceDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "TSInterfaceDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSInterfaceBody(node, opts) { + if (!node) return false; + if (node.type !== "TSInterfaceBody") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypeAliasDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "TSTypeAliasDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSInstantiationExpression(node, opts) { + if (!node) return false; + if (node.type !== "TSInstantiationExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSAsExpression(node, opts) { + if (!node) return false; + if (node.type !== "TSAsExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSSatisfiesExpression(node, opts) { + if (!node) return false; + if (node.type !== "TSSatisfiesExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypeAssertion(node, opts) { + if (!node) return false; + if (node.type !== "TSTypeAssertion") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSEnumBody(node, opts) { + if (!node) return false; + if (node.type !== "TSEnumBody") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSEnumDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "TSEnumDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSEnumMember(node, opts) { + if (!node) return false; + if (node.type !== "TSEnumMember") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSModuleDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "TSModuleDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSModuleBlock(node, opts) { + if (!node) return false; + if (node.type !== "TSModuleBlock") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSImportType(node, opts) { + if (!node) return false; + if (node.type !== "TSImportType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSImportEqualsDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "TSImportEqualsDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSExternalModuleReference(node, opts) { + if (!node) return false; + if (node.type !== "TSExternalModuleReference") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSNonNullExpression(node, opts) { + if (!node) return false; + if (node.type !== "TSNonNullExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSExportAssignment(node, opts) { + if (!node) return false; + if (node.type !== "TSExportAssignment") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSNamespaceExportDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "TSNamespaceExportDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "TSTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypeParameterInstantiation(node, opts) { + if (!node) return false; + if (node.type !== "TSTypeParameterInstantiation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypeParameterDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "TSTypeParameterDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypeParameter(node, opts) { + if (!node) return false; + if (node.type !== "TSTypeParameter") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isStandardized(node, opts) { + if (!node) return false; + switch (node.type) { + case "ArrayExpression": + case "AssignmentExpression": + case "BinaryExpression": + case "InterpreterDirective": + case "Directive": + case "DirectiveLiteral": + case "BlockStatement": + case "BreakStatement": + case "CallExpression": + case "CatchClause": + case "ConditionalExpression": + case "ContinueStatement": + case "DebuggerStatement": + case "DoWhileStatement": + case "EmptyStatement": + case "ExpressionStatement": + case "File": + case "ForInStatement": + case "ForStatement": + case "FunctionDeclaration": + case "FunctionExpression": + case "Identifier": + case "IfStatement": + case "LabeledStatement": + case "StringLiteral": + case "NumericLiteral": + case "NullLiteral": + case "BooleanLiteral": + case "RegExpLiteral": + case "LogicalExpression": + case "MemberExpression": + case "NewExpression": + case "Program": + case "ObjectExpression": + case "ObjectMethod": + case "ObjectProperty": + case "RestElement": + case "ReturnStatement": + case "SequenceExpression": + case "ParenthesizedExpression": + case "SwitchCase": + case "SwitchStatement": + case "ThisExpression": + case "ThrowStatement": + case "TryStatement": + case "UnaryExpression": + case "UpdateExpression": + case "VariableDeclaration": + case "VariableDeclarator": + case "WhileStatement": + case "WithStatement": + case "AssignmentPattern": + case "ArrayPattern": + case "ArrowFunctionExpression": + case "ClassBody": + case "ClassExpression": + case "ClassDeclaration": + case "ExportAllDeclaration": + case "ExportDefaultDeclaration": + case "ExportNamedDeclaration": + case "ExportSpecifier": + case "ForOfStatement": + case "ImportDeclaration": + case "ImportDefaultSpecifier": + case "ImportNamespaceSpecifier": + case "ImportSpecifier": + case "ImportExpression": + case "MetaProperty": + case "ClassMethod": + case "ObjectPattern": + case "SpreadElement": + case "Super": + case "TaggedTemplateExpression": + case "TemplateElement": + case "TemplateLiteral": + case "YieldExpression": + case "AwaitExpression": + case "Import": + case "BigIntLiteral": + case "ExportNamespaceSpecifier": + case "OptionalMemberExpression": + case "OptionalCallExpression": + case "ClassProperty": + case "ClassAccessorProperty": + case "ClassPrivateProperty": + case "ClassPrivateMethod": + case "PrivateName": + case "StaticBlock": + case "ImportAttribute": + break; + case "Placeholder": + switch (node.expectedNode) { + case "Identifier": + case "StringLiteral": + case "BlockStatement": + case "ClassBody": + break; + default: + return false; + } + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isExpression(node, opts) { + if (!node) return false; + switch (node.type) { + case "ArrayExpression": + case "AssignmentExpression": + case "BinaryExpression": + case "CallExpression": + case "ConditionalExpression": + case "FunctionExpression": + case "Identifier": + case "StringLiteral": + case "NumericLiteral": + case "NullLiteral": + case "BooleanLiteral": + case "RegExpLiteral": + case "LogicalExpression": + case "MemberExpression": + case "NewExpression": + case "ObjectExpression": + case "SequenceExpression": + case "ParenthesizedExpression": + case "ThisExpression": + case "UnaryExpression": + case "UpdateExpression": + case "ArrowFunctionExpression": + case "ClassExpression": + case "ImportExpression": + case "MetaProperty": + case "Super": + case "TaggedTemplateExpression": + case "TemplateLiteral": + case "YieldExpression": + case "AwaitExpression": + case "Import": + case "BigIntLiteral": + case "OptionalMemberExpression": + case "OptionalCallExpression": + case "TypeCastExpression": + case "JSXElement": + case "JSXFragment": + case "BindExpression": + case "DoExpression": + case "RecordExpression": + case "TupleExpression": + case "DecimalLiteral": + case "ModuleExpression": + case "TopicReference": + case "PipelineTopicExpression": + case "PipelineBareFunction": + case "PipelinePrimaryTopicReference": + case "TSInstantiationExpression": + case "TSAsExpression": + case "TSSatisfiesExpression": + case "TSTypeAssertion": + case "TSNonNullExpression": + break; + case "Placeholder": + switch (node.expectedNode) { + case "Expression": + case "Identifier": + case "StringLiteral": + break; + default: + return false; + } + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isBinary(node, opts) { + if (!node) return false; + switch (node.type) { + case "BinaryExpression": + case "LogicalExpression": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isScopable(node, opts) { + if (!node) return false; + switch (node.type) { + case "BlockStatement": + case "CatchClause": + case "DoWhileStatement": + case "ForInStatement": + case "ForStatement": + case "FunctionDeclaration": + case "FunctionExpression": + case "Program": + case "ObjectMethod": + case "SwitchStatement": + case "WhileStatement": + case "ArrowFunctionExpression": + case "ClassExpression": + case "ClassDeclaration": + case "ForOfStatement": + case "ClassMethod": + case "ClassPrivateMethod": + case "StaticBlock": + case "TSModuleBlock": + break; + case "Placeholder": + if (node.expectedNode === "BlockStatement") break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isBlockParent(node, opts) { + if (!node) return false; + switch (node.type) { + case "BlockStatement": + case "CatchClause": + case "DoWhileStatement": + case "ForInStatement": + case "ForStatement": + case "FunctionDeclaration": + case "FunctionExpression": + case "Program": + case "ObjectMethod": + case "SwitchStatement": + case "WhileStatement": + case "ArrowFunctionExpression": + case "ForOfStatement": + case "ClassMethod": + case "ClassPrivateMethod": + case "StaticBlock": + case "TSModuleBlock": + break; + case "Placeholder": + if (node.expectedNode === "BlockStatement") break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isBlock(node, opts) { + if (!node) return false; + switch (node.type) { + case "BlockStatement": + case "Program": + case "TSModuleBlock": + break; + case "Placeholder": + if (node.expectedNode === "BlockStatement") break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isStatement(node, opts) { + if (!node) return false; + switch (node.type) { + case "BlockStatement": + case "BreakStatement": + case "ContinueStatement": + case "DebuggerStatement": + case "DoWhileStatement": + case "EmptyStatement": + case "ExpressionStatement": + case "ForInStatement": + case "ForStatement": + case "FunctionDeclaration": + case "IfStatement": + case "LabeledStatement": + case "ReturnStatement": + case "SwitchStatement": + case "ThrowStatement": + case "TryStatement": + case "VariableDeclaration": + case "WhileStatement": + case "WithStatement": + case "ClassDeclaration": + case "ExportAllDeclaration": + case "ExportDefaultDeclaration": + case "ExportNamedDeclaration": + case "ForOfStatement": + case "ImportDeclaration": + case "DeclareClass": + case "DeclareFunction": + case "DeclareInterface": + case "DeclareModule": + case "DeclareModuleExports": + case "DeclareTypeAlias": + case "DeclareOpaqueType": + case "DeclareVariable": + case "DeclareExportDeclaration": + case "DeclareExportAllDeclaration": + case "InterfaceDeclaration": + case "OpaqueType": + case "TypeAlias": + case "EnumDeclaration": + case "TSDeclareFunction": + case "TSInterfaceDeclaration": + case "TSTypeAliasDeclaration": + case "TSEnumDeclaration": + case "TSModuleDeclaration": + case "TSImportEqualsDeclaration": + case "TSExportAssignment": + case "TSNamespaceExportDeclaration": + break; + case "Placeholder": + switch (node.expectedNode) { + case "Statement": + case "Declaration": + case "BlockStatement": + break; + default: + return false; + } + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTerminatorless(node, opts) { + if (!node) return false; + switch (node.type) { + case "BreakStatement": + case "ContinueStatement": + case "ReturnStatement": + case "ThrowStatement": + case "YieldExpression": + case "AwaitExpression": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isCompletionStatement(node, opts) { + if (!node) return false; + switch (node.type) { + case "BreakStatement": + case "ContinueStatement": + case "ReturnStatement": + case "ThrowStatement": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isConditional(node, opts) { + if (!node) return false; + switch (node.type) { + case "ConditionalExpression": + case "IfStatement": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isLoop(node, opts) { + if (!node) return false; + switch (node.type) { + case "DoWhileStatement": + case "ForInStatement": + case "ForStatement": + case "WhileStatement": + case "ForOfStatement": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isWhile(node, opts) { + if (!node) return false; + switch (node.type) { + case "DoWhileStatement": + case "WhileStatement": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isExpressionWrapper(node, opts) { + if (!node) return false; + switch (node.type) { + case "ExpressionStatement": + case "ParenthesizedExpression": + case "TypeCastExpression": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFor(node, opts) { + if (!node) return false; + switch (node.type) { + case "ForInStatement": + case "ForStatement": + case "ForOfStatement": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isForXStatement(node, opts) { + if (!node) return false; + switch (node.type) { + case "ForInStatement": + case "ForOfStatement": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFunction(node, opts) { + if (!node) return false; + switch (node.type) { + case "FunctionDeclaration": + case "FunctionExpression": + case "ObjectMethod": + case "ArrowFunctionExpression": + case "ClassMethod": + case "ClassPrivateMethod": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFunctionParent(node, opts) { + if (!node) return false; + switch (node.type) { + case "FunctionDeclaration": + case "FunctionExpression": + case "ObjectMethod": + case "ArrowFunctionExpression": + case "ClassMethod": + case "ClassPrivateMethod": + case "StaticBlock": + case "TSModuleBlock": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isPureish(node, opts) { + if (!node) return false; + switch (node.type) { + case "FunctionDeclaration": + case "FunctionExpression": + case "StringLiteral": + case "NumericLiteral": + case "NullLiteral": + case "BooleanLiteral": + case "RegExpLiteral": + case "ArrowFunctionExpression": + case "BigIntLiteral": + case "DecimalLiteral": + break; + case "Placeholder": + if (node.expectedNode === "StringLiteral") break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclaration(node, opts) { + if (!node) return false; + switch (node.type) { + case "FunctionDeclaration": + case "VariableDeclaration": + case "ClassDeclaration": + case "ExportAllDeclaration": + case "ExportDefaultDeclaration": + case "ExportNamedDeclaration": + case "ImportDeclaration": + case "DeclareClass": + case "DeclareFunction": + case "DeclareInterface": + case "DeclareModule": + case "DeclareModuleExports": + case "DeclareTypeAlias": + case "DeclareOpaqueType": + case "DeclareVariable": + case "DeclareExportDeclaration": + case "DeclareExportAllDeclaration": + case "InterfaceDeclaration": + case "OpaqueType": + case "TypeAlias": + case "EnumDeclaration": + case "TSDeclareFunction": + case "TSInterfaceDeclaration": + case "TSTypeAliasDeclaration": + case "TSEnumDeclaration": + case "TSModuleDeclaration": + case "TSImportEqualsDeclaration": + break; + case "Placeholder": + if (node.expectedNode === "Declaration") break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFunctionParameter(node, opts) { + if (!node) return false; + switch (node.type) { + case "Identifier": + case "RestElement": + case "AssignmentPattern": + case "ArrayPattern": + case "ObjectPattern": + case "VoidPattern": + break; + case "Placeholder": + if (node.expectedNode === "Identifier") break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isPatternLike(node, opts) { + if (!node) return false; + switch (node.type) { + case "Identifier": + case "MemberExpression": + case "RestElement": + case "AssignmentPattern": + case "ArrayPattern": + case "ObjectPattern": + case "VoidPattern": + case "TSAsExpression": + case "TSSatisfiesExpression": + case "TSTypeAssertion": + case "TSNonNullExpression": + break; + case "Placeholder": + switch (node.expectedNode) { + case "Pattern": + case "Identifier": + break; + default: + return false; + } + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isLVal(node, opts) { + if (!node) return false; + switch (node.type) { + case "Identifier": + case "MemberExpression": + case "RestElement": + case "AssignmentPattern": + case "ArrayPattern": + case "ObjectPattern": + case "TSParameterProperty": + case "TSAsExpression": + case "TSSatisfiesExpression": + case "TSTypeAssertion": + case "TSNonNullExpression": + break; + case "Placeholder": + switch (node.expectedNode) { + case "Pattern": + case "Identifier": + break; + default: + return false; + } + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSEntityName(node, opts) { + if (!node) return false; + switch (node.type) { + case "Identifier": + case "TSQualifiedName": + break; + case "Placeholder": + if (node.expectedNode === "Identifier") break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isLiteral(node, opts) { + if (!node) return false; + switch (node.type) { + case "StringLiteral": + case "NumericLiteral": + case "NullLiteral": + case "BooleanLiteral": + case "RegExpLiteral": + case "TemplateLiteral": + case "BigIntLiteral": + case "DecimalLiteral": + break; + case "Placeholder": + if (node.expectedNode === "StringLiteral") break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isImmutable(node, opts) { + if (!node) return false; + switch (node.type) { + case "StringLiteral": + case "NumericLiteral": + case "NullLiteral": + case "BooleanLiteral": + case "BigIntLiteral": + case "JSXAttribute": + case "JSXClosingElement": + case "JSXElement": + case "JSXExpressionContainer": + case "JSXSpreadChild": + case "JSXOpeningElement": + case "JSXText": + case "JSXFragment": + case "JSXOpeningFragment": + case "JSXClosingFragment": + case "DecimalLiteral": + break; + case "Placeholder": + if (node.expectedNode === "StringLiteral") break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isUserWhitespacable(node, opts) { + if (!node) return false; + switch (node.type) { + case "ObjectMethod": + case "ObjectProperty": + case "ObjectTypeInternalSlot": + case "ObjectTypeCallProperty": + case "ObjectTypeIndexer": + case "ObjectTypeProperty": + case "ObjectTypeSpreadProperty": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isMethod(node, opts) { + if (!node) return false; + switch (node.type) { + case "ObjectMethod": + case "ClassMethod": + case "ClassPrivateMethod": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isObjectMember(node, opts) { + if (!node) return false; + switch (node.type) { + case "ObjectMethod": + case "ObjectProperty": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isProperty(node, opts) { + if (!node) return false; + switch (node.type) { + case "ObjectProperty": + case "ClassProperty": + case "ClassAccessorProperty": + case "ClassPrivateProperty": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isUnaryLike(node, opts) { + if (!node) return false; + switch (node.type) { + case "UnaryExpression": + case "SpreadElement": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isPattern(node, opts) { + if (!node) return false; + switch (node.type) { + case "AssignmentPattern": + case "ArrayPattern": + case "ObjectPattern": + case "VoidPattern": + break; + case "Placeholder": + if (node.expectedNode === "Pattern") break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isClass(node, opts) { + if (!node) return false; + switch (node.type) { + case "ClassExpression": + case "ClassDeclaration": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isImportOrExportDeclaration(node, opts) { + if (!node) return false; + switch (node.type) { + case "ExportAllDeclaration": + case "ExportDefaultDeclaration": + case "ExportNamedDeclaration": + case "ImportDeclaration": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isExportDeclaration(node, opts) { + if (!node) return false; + switch (node.type) { + case "ExportAllDeclaration": + case "ExportDefaultDeclaration": + case "ExportNamedDeclaration": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isModuleSpecifier(node, opts) { + if (!node) return false; + switch (node.type) { + case "ExportSpecifier": + case "ImportDefaultSpecifier": + case "ImportNamespaceSpecifier": + case "ImportSpecifier": + case "ExportNamespaceSpecifier": + case "ExportDefaultSpecifier": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isAccessor(node, opts) { + if (!node) return false; + switch (node.type) { + case "ClassAccessorProperty": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isPrivate(node, opts) { + if (!node) return false; + switch (node.type) { + case "ClassPrivateProperty": + case "ClassPrivateMethod": + case "PrivateName": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFlow(node, opts) { + if (!node) return false; + switch (node.type) { + case "AnyTypeAnnotation": + case "ArrayTypeAnnotation": + case "BooleanTypeAnnotation": + case "BooleanLiteralTypeAnnotation": + case "NullLiteralTypeAnnotation": + case "ClassImplements": + case "DeclareClass": + case "DeclareFunction": + case "DeclareInterface": + case "DeclareModule": + case "DeclareModuleExports": + case "DeclareTypeAlias": + case "DeclareOpaqueType": + case "DeclareVariable": + case "DeclareExportDeclaration": + case "DeclareExportAllDeclaration": + case "DeclaredPredicate": + case "ExistsTypeAnnotation": + case "FunctionTypeAnnotation": + case "FunctionTypeParam": + case "GenericTypeAnnotation": + case "InferredPredicate": + case "InterfaceExtends": + case "InterfaceDeclaration": + case "InterfaceTypeAnnotation": + case "IntersectionTypeAnnotation": + case "MixedTypeAnnotation": + case "EmptyTypeAnnotation": + case "NullableTypeAnnotation": + case "NumberLiteralTypeAnnotation": + case "NumberTypeAnnotation": + case "ObjectTypeAnnotation": + case "ObjectTypeInternalSlot": + case "ObjectTypeCallProperty": + case "ObjectTypeIndexer": + case "ObjectTypeProperty": + case "ObjectTypeSpreadProperty": + case "OpaqueType": + case "QualifiedTypeIdentifier": + case "StringLiteralTypeAnnotation": + case "StringTypeAnnotation": + case "SymbolTypeAnnotation": + case "ThisTypeAnnotation": + case "TupleTypeAnnotation": + case "TypeofTypeAnnotation": + case "TypeAlias": + case "TypeAnnotation": + case "TypeCastExpression": + case "TypeParameter": + case "TypeParameterDeclaration": + case "TypeParameterInstantiation": + case "UnionTypeAnnotation": + case "Variance": + case "VoidTypeAnnotation": + case "EnumDeclaration": + case "EnumBooleanBody": + case "EnumNumberBody": + case "EnumStringBody": + case "EnumSymbolBody": + case "EnumBooleanMember": + case "EnumNumberMember": + case "EnumStringMember": + case "EnumDefaultedMember": + case "IndexedAccessType": + case "OptionalIndexedAccessType": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFlowType(node, opts) { + if (!node) return false; + switch (node.type) { + case "AnyTypeAnnotation": + case "ArrayTypeAnnotation": + case "BooleanTypeAnnotation": + case "BooleanLiteralTypeAnnotation": + case "NullLiteralTypeAnnotation": + case "ExistsTypeAnnotation": + case "FunctionTypeAnnotation": + case "GenericTypeAnnotation": + case "InterfaceTypeAnnotation": + case "IntersectionTypeAnnotation": + case "MixedTypeAnnotation": + case "EmptyTypeAnnotation": + case "NullableTypeAnnotation": + case "NumberLiteralTypeAnnotation": + case "NumberTypeAnnotation": + case "ObjectTypeAnnotation": + case "StringLiteralTypeAnnotation": + case "StringTypeAnnotation": + case "SymbolTypeAnnotation": + case "ThisTypeAnnotation": + case "TupleTypeAnnotation": + case "TypeofTypeAnnotation": + case "UnionTypeAnnotation": + case "VoidTypeAnnotation": + case "IndexedAccessType": + case "OptionalIndexedAccessType": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFlowBaseAnnotation(node, opts) { + if (!node) return false; + switch (node.type) { + case "AnyTypeAnnotation": + case "BooleanTypeAnnotation": + case "NullLiteralTypeAnnotation": + case "MixedTypeAnnotation": + case "EmptyTypeAnnotation": + case "NumberTypeAnnotation": + case "StringTypeAnnotation": + case "SymbolTypeAnnotation": + case "ThisTypeAnnotation": + case "VoidTypeAnnotation": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFlowDeclaration(node, opts) { + if (!node) return false; + switch (node.type) { + case "DeclareClass": + case "DeclareFunction": + case "DeclareInterface": + case "DeclareModule": + case "DeclareModuleExports": + case "DeclareTypeAlias": + case "DeclareOpaqueType": + case "DeclareVariable": + case "DeclareExportDeclaration": + case "DeclareExportAllDeclaration": + case "InterfaceDeclaration": + case "OpaqueType": + case "TypeAlias": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFlowPredicate(node, opts) { + if (!node) return false; + switch (node.type) { + case "DeclaredPredicate": + case "InferredPredicate": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEnumBody(node, opts) { + if (!node) return false; + switch (node.type) { + case "EnumBooleanBody": + case "EnumNumberBody": + case "EnumStringBody": + case "EnumSymbolBody": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEnumMember(node, opts) { + if (!node) return false; + switch (node.type) { + case "EnumBooleanMember": + case "EnumNumberMember": + case "EnumStringMember": + case "EnumDefaultedMember": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSX(node, opts) { + if (!node) return false; + switch (node.type) { + case "JSXAttribute": + case "JSXClosingElement": + case "JSXElement": + case "JSXEmptyExpression": + case "JSXExpressionContainer": + case "JSXSpreadChild": + case "JSXIdentifier": + case "JSXMemberExpression": + case "JSXNamespacedName": + case "JSXOpeningElement": + case "JSXSpreadAttribute": + case "JSXText": + case "JSXFragment": + case "JSXOpeningFragment": + case "JSXClosingFragment": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isMiscellaneous(node, opts) { + if (!node) return false; + switch (node.type) { + case "Noop": + case "Placeholder": + case "V8IntrinsicIdentifier": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTypeScript(node, opts) { + if (!node) return false; + switch (node.type) { + case "TSParameterProperty": + case "TSDeclareFunction": + case "TSDeclareMethod": + case "TSQualifiedName": + case "TSCallSignatureDeclaration": + case "TSConstructSignatureDeclaration": + case "TSPropertySignature": + case "TSMethodSignature": + case "TSIndexSignature": + case "TSAnyKeyword": + case "TSBooleanKeyword": + case "TSBigIntKeyword": + case "TSIntrinsicKeyword": + case "TSNeverKeyword": + case "TSNullKeyword": + case "TSNumberKeyword": + case "TSObjectKeyword": + case "TSStringKeyword": + case "TSSymbolKeyword": + case "TSUndefinedKeyword": + case "TSUnknownKeyword": + case "TSVoidKeyword": + case "TSThisType": + case "TSFunctionType": + case "TSConstructorType": + case "TSTypeReference": + case "TSTypePredicate": + case "TSTypeQuery": + case "TSTypeLiteral": + case "TSArrayType": + case "TSTupleType": + case "TSOptionalType": + case "TSRestType": + case "TSNamedTupleMember": + case "TSUnionType": + case "TSIntersectionType": + case "TSConditionalType": + case "TSInferType": + case "TSParenthesizedType": + case "TSTypeOperator": + case "TSIndexedAccessType": + case "TSMappedType": + case "TSTemplateLiteralType": + case "TSLiteralType": + case "TSExpressionWithTypeArguments": + case "TSInterfaceDeclaration": + case "TSInterfaceBody": + case "TSTypeAliasDeclaration": + case "TSInstantiationExpression": + case "TSAsExpression": + case "TSSatisfiesExpression": + case "TSTypeAssertion": + case "TSEnumBody": + case "TSEnumDeclaration": + case "TSEnumMember": + case "TSModuleDeclaration": + case "TSModuleBlock": + case "TSImportType": + case "TSImportEqualsDeclaration": + case "TSExternalModuleReference": + case "TSNonNullExpression": + case "TSExportAssignment": + case "TSNamespaceExportDeclaration": + case "TSTypeAnnotation": + case "TSTypeParameterInstantiation": + case "TSTypeParameterDeclaration": + case "TSTypeParameter": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypeElement(node, opts) { + if (!node) return false; + switch (node.type) { + case "TSCallSignatureDeclaration": + case "TSConstructSignatureDeclaration": + case "TSPropertySignature": + case "TSMethodSignature": + case "TSIndexSignature": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSType(node, opts) { + if (!node) return false; + switch (node.type) { + case "TSAnyKeyword": + case "TSBooleanKeyword": + case "TSBigIntKeyword": + case "TSIntrinsicKeyword": + case "TSNeverKeyword": + case "TSNullKeyword": + case "TSNumberKeyword": + case "TSObjectKeyword": + case "TSStringKeyword": + case "TSSymbolKeyword": + case "TSUndefinedKeyword": + case "TSUnknownKeyword": + case "TSVoidKeyword": + case "TSThisType": + case "TSFunctionType": + case "TSConstructorType": + case "TSTypeReference": + case "TSTypePredicate": + case "TSTypeQuery": + case "TSTypeLiteral": + case "TSArrayType": + case "TSTupleType": + case "TSOptionalType": + case "TSRestType": + case "TSUnionType": + case "TSIntersectionType": + case "TSConditionalType": + case "TSInferType": + case "TSParenthesizedType": + case "TSTypeOperator": + case "TSIndexedAccessType": + case "TSMappedType": + case "TSTemplateLiteralType": + case "TSLiteralType": + case "TSExpressionWithTypeArguments": + case "TSImportType": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSBaseType(node, opts) { + if (!node) return false; + switch (node.type) { + case "TSAnyKeyword": + case "TSBooleanKeyword": + case "TSBigIntKeyword": + case "TSIntrinsicKeyword": + case "TSNeverKeyword": + case "TSNullKeyword": + case "TSNumberKeyword": + case "TSObjectKeyword": + case "TSStringKeyword": + case "TSSymbolKeyword": + case "TSUndefinedKeyword": + case "TSUnknownKeyword": + case "TSVoidKeyword": + case "TSThisType": + case "TSTemplateLiteralType": + case "TSLiteralType": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isNumberLiteral(node, opts) { + (0, _deprecationWarning.default)("isNumberLiteral", "isNumericLiteral"); + if (!node) return false; + if (node.type !== "NumberLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isRegexLiteral(node, opts) { + (0, _deprecationWarning.default)("isRegexLiteral", "isRegExpLiteral"); + if (!node) return false; + if (node.type !== "RegexLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isRestProperty(node, opts) { + (0, _deprecationWarning.default)("isRestProperty", "isRestElement"); + if (!node) return false; + if (node.type !== "RestProperty") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isSpreadProperty(node, opts) { + (0, _deprecationWarning.default)("isSpreadProperty", "isSpreadElement"); + if (!node) return false; + if (node.type !== "SpreadProperty") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isModuleDeclaration(node, opts) { + (0, _deprecationWarning.default)("isModuleDeclaration", "isImportOrExportDeclaration"); + return isImportOrExportDeclaration(node, opts); +} + +//# sourceMappingURL=index.js.map diff --git a/scripts/node_modules/@babel/types/lib/validators/generated/index.js.map b/scripts/node_modules/@babel/types/lib/validators/generated/index.js.map new file mode 100644 index 0000000000000000000000000000000000000000..377396963244980e0c68d5d616e32b1a359483ff --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/generated/index.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_shallowEqual","require","_deprecationWarning","isArrayExpression","node","opts","type","shallowEqual","isAssignmentExpression","isBinaryExpression","isInterpreterDirective","isDirective","isDirectiveLiteral","isBlockStatement","isBreakStatement","isCallExpression","isCatchClause","isConditionalExpression","isContinueStatement","isDebuggerStatement","isDoWhileStatement","isEmptyStatement","isExpressionStatement","isFile","isForInStatement","isForStatement","isFunctionDeclaration","isFunctionExpression","isIdentifier","isIfStatement","isLabeledStatement","isStringLiteral","isNumericLiteral","isNullLiteral","isBooleanLiteral","isRegExpLiteral","isLogicalExpression","isMemberExpression","isNewExpression","isProgram","isObjectExpression","isObjectMethod","isObjectProperty","isRestElement","isReturnStatement","isSequenceExpression","isParenthesizedExpression","isSwitchCase","isSwitchStatement","isThisExpression","isThrowStatement","isTryStatement","isUnaryExpression","isUpdateExpression","isVariableDeclaration","isVariableDeclarator","isWhileStatement","isWithStatement","isAssignmentPattern","isArrayPattern","isArrowFunctionExpression","isClassBody","isClassExpression","isClassDeclaration","isExportAllDeclaration","isExportDefaultDeclaration","isExportNamedDeclaration","isExportSpecifier","isForOfStatement","isImportDeclaration","isImportDefaultSpecifier","isImportNamespaceSpecifier","isImportSpecifier","isImportExpression","isMetaProperty","isClassMethod","isObjectPattern","isSpreadElement","isSuper","isTaggedTemplateExpression","isTemplateElement","isTemplateLiteral","isYieldExpression","isAwaitExpression","isImport","isBigIntLiteral","isExportNamespaceSpecifier","isOptionalMemberExpression","isOptionalCallExpression","isClassProperty","isClassAccessorProperty","isClassPrivateProperty","isClassPrivateMethod","isPrivateName","isStaticBlock","isImportAttribute","isAnyTypeAnnotation","isArrayTypeAnnotation","isBooleanTypeAnnotation","isBooleanLiteralTypeAnnotation","isNullLiteralTypeAnnotation","isClassImplements","isDeclareClass","isDeclareFunction","isDeclareInterface","isDeclareModule","isDeclareModuleExports","isDeclareTypeAlias","isDeclareOpaqueType","isDeclareVariable","isDeclareExportDeclaration","isDeclareExportAllDeclaration","isDeclaredPredicate","isExistsTypeAnnotation","isFunctionTypeAnnotation","isFunctionTypeParam","isGenericTypeAnnotation","isInferredPredicate","isInterfaceExtends","isInterfaceDeclaration","isInterfaceTypeAnnotation","isIntersectionTypeAnnotation","isMixedTypeAnnotation","isEmptyTypeAnnotation","isNullableTypeAnnotation","isNumberLiteralTypeAnnotation","isNumberTypeAnnotation","isObjectTypeAnnotation","isObjectTypeInternalSlot","isObjectTypeCallProperty","isObjectTypeIndexer","isObjectTypeProperty","isObjectTypeSpreadProperty","isOpaqueType","isQualifiedTypeIdentifier","isStringLiteralTypeAnnotation","isStringTypeAnnotation","isSymbolTypeAnnotation","isThisTypeAnnotation","isTupleTypeAnnotation","isTypeofTypeAnnotation","isTypeAlias","isTypeAnnotation","isTypeCastExpression","isTypeParameter","isTypeParameterDeclaration","isTypeParameterInstantiation","isUnionTypeAnnotation","isVariance","isVoidTypeAnnotation","isEnumDeclaration","isEnumBooleanBody","isEnumNumberBody","isEnumStringBody","isEnumSymbolBody","isEnumBooleanMember","isEnumNumberMember","isEnumStringMember","isEnumDefaultedMember","isIndexedAccessType","isOptionalIndexedAccessType","isJSXAttribute","isJSXClosingElement","isJSXElement","isJSXEmptyExpression","isJSXExpressionContainer","isJSXSpreadChild","isJSXIdentifier","isJSXMemberExpression","isJSXNamespacedName","isJSXOpeningElement","isJSXSpreadAttribute","isJSXText","isJSXFragment","isJSXOpeningFragment","isJSXClosingFragment","isNoop","isPlaceholder","isV8IntrinsicIdentifier","isArgumentPlaceholder","isBindExpression","isDecorator","isDoExpression","isExportDefaultSpecifier","isRecordExpression","isTupleExpression","isDecimalLiteral","isModuleExpression","isTopicReference","isPipelineTopicExpression","isPipelineBareFunction","isPipelinePrimaryTopicReference","isVoidPattern","isTSParameterProperty","isTSDeclareFunction","isTSDeclareMethod","isTSQualifiedName","isTSCallSignatureDeclaration","isTSConstructSignatureDeclaration","isTSPropertySignature","isTSMethodSignature","isTSIndexSignature","isTSAnyKeyword","isTSBooleanKeyword","isTSBigIntKeyword","isTSIntrinsicKeyword","isTSNeverKeyword","isTSNullKeyword","isTSNumberKeyword","isTSObjectKeyword","isTSStringKeyword","isTSSymbolKeyword","isTSUndefinedKeyword","isTSUnknownKeyword","isTSVoidKeyword","isTSThisType","isTSFunctionType","isTSConstructorType","isTSTypeReference","isTSTypePredicate","isTSTypeQuery","isTSTypeLiteral","isTSArrayType","isTSTupleType","isTSOptionalType","isTSRestType","isTSNamedTupleMember","isTSUnionType","isTSIntersectionType","isTSConditionalType","isTSInferType","isTSParenthesizedType","isTSTypeOperator","isTSIndexedAccessType","isTSMappedType","isTSTemplateLiteralType","isTSLiteralType","isTSExpressionWithTypeArguments","isTSInterfaceDeclaration","isTSInterfaceBody","isTSTypeAliasDeclaration","isTSInstantiationExpression","isTSAsExpression","isTSSatisfiesExpression","isTSTypeAssertion","isTSEnumBody","isTSEnumDeclaration","isTSEnumMember","isTSModuleDeclaration","isTSModuleBlock","isTSImportType","isTSImportEqualsDeclaration","isTSExternalModuleReference","isTSNonNullExpression","isTSExportAssignment","isTSNamespaceExportDeclaration","isTSTypeAnnotation","isTSTypeParameterInstantiation","isTSTypeParameterDeclaration","isTSTypeParameter","isStandardized","expectedNode","isExpression","isBinary","isScopable","isBlockParent","isBlock","isStatement","isTerminatorless","isCompletionStatement","isConditional","isLoop","isWhile","isExpressionWrapper","isFor","isForXStatement","isFunction","isFunctionParent","isPureish","isDeclaration","isFunctionParameter","isPatternLike","isLVal","isTSEntityName","isLiteral","isImmutable","isUserWhitespacable","isMethod","isObjectMember","isProperty","isUnaryLike","isPattern","isClass","isImportOrExportDeclaration","isExportDeclaration","isModuleSpecifier","isAccessor","isPrivate","isFlow","isFlowType","isFlowBaseAnnotation","isFlowDeclaration","isFlowPredicate","isEnumBody","isEnumMember","isJSX","isMiscellaneous","isTypeScript","isTSTypeElement","isTSType","isTSBaseType","isNumberLiteral","deprecationWarning","isRegexLiteral","isRestProperty","isSpreadProperty","isModuleDeclaration"],"sources":["../../../src/validators/generated/index.ts"],"sourcesContent":["/*\n * This file is auto-generated! Do not modify it directly.\n * To re-generate run 'make build'\n */\n\n/* eslint-disable no-fallthrough */\n\nimport shallowEqual from \"../../utils/shallowEqual.ts\";\nimport type * as t from \"../../index.ts\";\nimport deprecationWarning from \"../../utils/deprecationWarning.ts\";\n\ntype Options = Partial<{\n [Prop in Exclude]: Obj[Prop] extends t.Node\n ? t.Node\n : Obj[Prop] extends t.Node[]\n ? t.Node[]\n : Obj[Prop];\n}>;\n\nexport function isArrayExpression(\n node: t.Node | null | undefined,\n): node is t.ArrayExpression;\nexport function isArrayExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ArrayExpression & Opts;\nexport function isArrayExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ArrayExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isAssignmentExpression(\n node: t.Node | null | undefined,\n): node is t.AssignmentExpression;\nexport function isAssignmentExpression<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.AssignmentExpression & Opts;\nexport function isAssignmentExpression<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"AssignmentExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isBinaryExpression(\n node: t.Node | null | undefined,\n): node is t.BinaryExpression;\nexport function isBinaryExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.BinaryExpression & Opts;\nexport function isBinaryExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"BinaryExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isInterpreterDirective(\n node: t.Node | null | undefined,\n): node is t.InterpreterDirective;\nexport function isInterpreterDirective<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.InterpreterDirective & Opts;\nexport function isInterpreterDirective<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"InterpreterDirective\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isDirective(\n node: t.Node | null | undefined,\n): node is t.Directive;\nexport function isDirective>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Directive & Opts;\nexport function isDirective>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"Directive\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isDirectiveLiteral(\n node: t.Node | null | undefined,\n): node is t.DirectiveLiteral;\nexport function isDirectiveLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.DirectiveLiteral & Opts;\nexport function isDirectiveLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"DirectiveLiteral\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isBlockStatement(\n node: t.Node | null | undefined,\n): node is t.BlockStatement;\nexport function isBlockStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.BlockStatement & Opts;\nexport function isBlockStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"BlockStatement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isBreakStatement(\n node: t.Node | null | undefined,\n): node is t.BreakStatement;\nexport function isBreakStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.BreakStatement & Opts;\nexport function isBreakStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"BreakStatement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isCallExpression(\n node: t.Node | null | undefined,\n): node is t.CallExpression;\nexport function isCallExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.CallExpression & Opts;\nexport function isCallExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"CallExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isCatchClause(\n node: t.Node | null | undefined,\n): node is t.CatchClause;\nexport function isCatchClause>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.CatchClause & Opts;\nexport function isCatchClause>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"CatchClause\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isConditionalExpression(\n node: t.Node | null | undefined,\n): node is t.ConditionalExpression;\nexport function isConditionalExpression<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ConditionalExpression & Opts;\nexport function isConditionalExpression<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"ConditionalExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isContinueStatement(\n node: t.Node | null | undefined,\n): node is t.ContinueStatement;\nexport function isContinueStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ContinueStatement & Opts;\nexport function isContinueStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ContinueStatement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isDebuggerStatement(\n node: t.Node | null | undefined,\n): node is t.DebuggerStatement;\nexport function isDebuggerStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.DebuggerStatement & Opts;\nexport function isDebuggerStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"DebuggerStatement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isDoWhileStatement(\n node: t.Node | null | undefined,\n): node is t.DoWhileStatement;\nexport function isDoWhileStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.DoWhileStatement & Opts;\nexport function isDoWhileStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"DoWhileStatement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isEmptyStatement(\n node: t.Node | null | undefined,\n): node is t.EmptyStatement;\nexport function isEmptyStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.EmptyStatement & Opts;\nexport function isEmptyStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"EmptyStatement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isExpressionStatement(\n node: t.Node | null | undefined,\n): node is t.ExpressionStatement;\nexport function isExpressionStatement<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ExpressionStatement & Opts;\nexport function isExpressionStatement<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"ExpressionStatement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isFile(node: t.Node | null | undefined): node is t.File;\nexport function isFile>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.File & Opts;\nexport function isFile>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"File\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isForInStatement(\n node: t.Node | null | undefined,\n): node is t.ForInStatement;\nexport function isForInStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ForInStatement & Opts;\nexport function isForInStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ForInStatement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isForStatement(\n node: t.Node | null | undefined,\n): node is t.ForStatement;\nexport function isForStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ForStatement & Opts;\nexport function isForStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ForStatement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isFunctionDeclaration(\n node: t.Node | null | undefined,\n): node is t.FunctionDeclaration;\nexport function isFunctionDeclaration<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.FunctionDeclaration & Opts;\nexport function isFunctionDeclaration<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"FunctionDeclaration\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isFunctionExpression(\n node: t.Node | null | undefined,\n): node is t.FunctionExpression;\nexport function isFunctionExpression<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.FunctionExpression & Opts;\nexport function isFunctionExpression<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"FunctionExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isIdentifier(\n node: t.Node | null | undefined,\n): node is t.Identifier;\nexport function isIdentifier>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Identifier & Opts;\nexport function isIdentifier>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"Identifier\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isIfStatement(\n node: t.Node | null | undefined,\n): node is t.IfStatement;\nexport function isIfStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.IfStatement & Opts;\nexport function isIfStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"IfStatement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isLabeledStatement(\n node: t.Node | null | undefined,\n): node is t.LabeledStatement;\nexport function isLabeledStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.LabeledStatement & Opts;\nexport function isLabeledStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"LabeledStatement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isStringLiteral(\n node: t.Node | null | undefined,\n): node is t.StringLiteral;\nexport function isStringLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.StringLiteral & Opts;\nexport function isStringLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"StringLiteral\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isNumericLiteral(\n node: t.Node | null | undefined,\n): node is t.NumericLiteral;\nexport function isNumericLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.NumericLiteral & Opts;\nexport function isNumericLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"NumericLiteral\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isNullLiteral(\n node: t.Node | null | undefined,\n): node is t.NullLiteral;\nexport function isNullLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.NullLiteral & Opts;\nexport function isNullLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"NullLiteral\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isBooleanLiteral(\n node: t.Node | null | undefined,\n): node is t.BooleanLiteral;\nexport function isBooleanLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.BooleanLiteral & Opts;\nexport function isBooleanLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"BooleanLiteral\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isRegExpLiteral(\n node: t.Node | null | undefined,\n): node is t.RegExpLiteral;\nexport function isRegExpLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.RegExpLiteral & Opts;\nexport function isRegExpLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"RegExpLiteral\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isLogicalExpression(\n node: t.Node | null | undefined,\n): node is t.LogicalExpression;\nexport function isLogicalExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.LogicalExpression & Opts;\nexport function isLogicalExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"LogicalExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isMemberExpression(\n node: t.Node | null | undefined,\n): node is t.MemberExpression;\nexport function isMemberExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.MemberExpression & Opts;\nexport function isMemberExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"MemberExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isNewExpression(\n node: t.Node | null | undefined,\n): node is t.NewExpression;\nexport function isNewExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.NewExpression & Opts;\nexport function isNewExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"NewExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isProgram(node: t.Node | null | undefined): node is t.Program;\nexport function isProgram>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Program & Opts;\nexport function isProgram>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"Program\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isObjectExpression(\n node: t.Node | null | undefined,\n): node is t.ObjectExpression;\nexport function isObjectExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ObjectExpression & Opts;\nexport function isObjectExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ObjectExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isObjectMethod(\n node: t.Node | null | undefined,\n): node is t.ObjectMethod;\nexport function isObjectMethod>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ObjectMethod & Opts;\nexport function isObjectMethod>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ObjectMethod\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isObjectProperty(\n node: t.Node | null | undefined,\n): node is t.ObjectProperty;\nexport function isObjectProperty>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ObjectProperty & Opts;\nexport function isObjectProperty>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ObjectProperty\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isRestElement(\n node: t.Node | null | undefined,\n): node is t.RestElement;\nexport function isRestElement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.RestElement & Opts;\nexport function isRestElement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"RestElement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isReturnStatement(\n node: t.Node | null | undefined,\n): node is t.ReturnStatement;\nexport function isReturnStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ReturnStatement & Opts;\nexport function isReturnStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ReturnStatement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isSequenceExpression(\n node: t.Node | null | undefined,\n): node is t.SequenceExpression;\nexport function isSequenceExpression<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.SequenceExpression & Opts;\nexport function isSequenceExpression<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"SequenceExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isParenthesizedExpression(\n node: t.Node | null | undefined,\n): node is t.ParenthesizedExpression;\nexport function isParenthesizedExpression<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ParenthesizedExpression & Opts;\nexport function isParenthesizedExpression<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"ParenthesizedExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isSwitchCase(\n node: t.Node | null | undefined,\n): node is t.SwitchCase;\nexport function isSwitchCase>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.SwitchCase & Opts;\nexport function isSwitchCase>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"SwitchCase\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isSwitchStatement(\n node: t.Node | null | undefined,\n): node is t.SwitchStatement;\nexport function isSwitchStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.SwitchStatement & Opts;\nexport function isSwitchStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"SwitchStatement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isThisExpression(\n node: t.Node | null | undefined,\n): node is t.ThisExpression;\nexport function isThisExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ThisExpression & Opts;\nexport function isThisExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ThisExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isThrowStatement(\n node: t.Node | null | undefined,\n): node is t.ThrowStatement;\nexport function isThrowStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ThrowStatement & Opts;\nexport function isThrowStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ThrowStatement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTryStatement(\n node: t.Node | null | undefined,\n): node is t.TryStatement;\nexport function isTryStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TryStatement & Opts;\nexport function isTryStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TryStatement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isUnaryExpression(\n node: t.Node | null | undefined,\n): node is t.UnaryExpression;\nexport function isUnaryExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.UnaryExpression & Opts;\nexport function isUnaryExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"UnaryExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isUpdateExpression(\n node: t.Node | null | undefined,\n): node is t.UpdateExpression;\nexport function isUpdateExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.UpdateExpression & Opts;\nexport function isUpdateExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"UpdateExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isVariableDeclaration(\n node: t.Node | null | undefined,\n): node is t.VariableDeclaration;\nexport function isVariableDeclaration<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.VariableDeclaration & Opts;\nexport function isVariableDeclaration<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"VariableDeclaration\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isVariableDeclarator(\n node: t.Node | null | undefined,\n): node is t.VariableDeclarator;\nexport function isVariableDeclarator<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.VariableDeclarator & Opts;\nexport function isVariableDeclarator<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"VariableDeclarator\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isWhileStatement(\n node: t.Node | null | undefined,\n): node is t.WhileStatement;\nexport function isWhileStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.WhileStatement & Opts;\nexport function isWhileStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"WhileStatement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isWithStatement(\n node: t.Node | null | undefined,\n): node is t.WithStatement;\nexport function isWithStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.WithStatement & Opts;\nexport function isWithStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"WithStatement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isAssignmentPattern(\n node: t.Node | null | undefined,\n): node is t.AssignmentPattern;\nexport function isAssignmentPattern>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.AssignmentPattern & Opts;\nexport function isAssignmentPattern>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"AssignmentPattern\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isArrayPattern(\n node: t.Node | null | undefined,\n): node is t.ArrayPattern;\nexport function isArrayPattern>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ArrayPattern & Opts;\nexport function isArrayPattern>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ArrayPattern\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isArrowFunctionExpression(\n node: t.Node | null | undefined,\n): node is t.ArrowFunctionExpression;\nexport function isArrowFunctionExpression<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ArrowFunctionExpression & Opts;\nexport function isArrowFunctionExpression<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"ArrowFunctionExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isClassBody(\n node: t.Node | null | undefined,\n): node is t.ClassBody;\nexport function isClassBody>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ClassBody & Opts;\nexport function isClassBody>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ClassBody\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isClassExpression(\n node: t.Node | null | undefined,\n): node is t.ClassExpression;\nexport function isClassExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ClassExpression & Opts;\nexport function isClassExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ClassExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isClassDeclaration(\n node: t.Node | null | undefined,\n): node is t.ClassDeclaration;\nexport function isClassDeclaration>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ClassDeclaration & Opts;\nexport function isClassDeclaration>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ClassDeclaration\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isExportAllDeclaration(\n node: t.Node | null | undefined,\n): node is t.ExportAllDeclaration;\nexport function isExportAllDeclaration<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ExportAllDeclaration & Opts;\nexport function isExportAllDeclaration<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"ExportAllDeclaration\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isExportDefaultDeclaration(\n node: t.Node | null | undefined,\n): node is t.ExportDefaultDeclaration;\nexport function isExportDefaultDeclaration<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ExportDefaultDeclaration & Opts;\nexport function isExportDefaultDeclaration<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"ExportDefaultDeclaration\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isExportNamedDeclaration(\n node: t.Node | null | undefined,\n): node is t.ExportNamedDeclaration;\nexport function isExportNamedDeclaration<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ExportNamedDeclaration & Opts;\nexport function isExportNamedDeclaration<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"ExportNamedDeclaration\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isExportSpecifier(\n node: t.Node | null | undefined,\n): node is t.ExportSpecifier;\nexport function isExportSpecifier>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ExportSpecifier & Opts;\nexport function isExportSpecifier>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ExportSpecifier\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isForOfStatement(\n node: t.Node | null | undefined,\n): node is t.ForOfStatement;\nexport function isForOfStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ForOfStatement & Opts;\nexport function isForOfStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ForOfStatement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isImportDeclaration(\n node: t.Node | null | undefined,\n): node is t.ImportDeclaration;\nexport function isImportDeclaration>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ImportDeclaration & Opts;\nexport function isImportDeclaration>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ImportDeclaration\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isImportDefaultSpecifier(\n node: t.Node | null | undefined,\n): node is t.ImportDefaultSpecifier;\nexport function isImportDefaultSpecifier<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ImportDefaultSpecifier & Opts;\nexport function isImportDefaultSpecifier<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"ImportDefaultSpecifier\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isImportNamespaceSpecifier(\n node: t.Node | null | undefined,\n): node is t.ImportNamespaceSpecifier;\nexport function isImportNamespaceSpecifier<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ImportNamespaceSpecifier & Opts;\nexport function isImportNamespaceSpecifier<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"ImportNamespaceSpecifier\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isImportSpecifier(\n node: t.Node | null | undefined,\n): node is t.ImportSpecifier;\nexport function isImportSpecifier>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ImportSpecifier & Opts;\nexport function isImportSpecifier>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ImportSpecifier\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isImportExpression(\n node: t.Node | null | undefined,\n): node is t.ImportExpression;\nexport function isImportExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ImportExpression & Opts;\nexport function isImportExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ImportExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isMetaProperty(\n node: t.Node | null | undefined,\n): node is t.MetaProperty;\nexport function isMetaProperty>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.MetaProperty & Opts;\nexport function isMetaProperty>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"MetaProperty\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isClassMethod(\n node: t.Node | null | undefined,\n): node is t.ClassMethod;\nexport function isClassMethod>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ClassMethod & Opts;\nexport function isClassMethod>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ClassMethod\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isObjectPattern(\n node: t.Node | null | undefined,\n): node is t.ObjectPattern;\nexport function isObjectPattern>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ObjectPattern & Opts;\nexport function isObjectPattern>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ObjectPattern\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isSpreadElement(\n node: t.Node | null | undefined,\n): node is t.SpreadElement;\nexport function isSpreadElement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.SpreadElement & Opts;\nexport function isSpreadElement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"SpreadElement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isSuper(node: t.Node | null | undefined): node is t.Super;\nexport function isSuper>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Super & Opts;\nexport function isSuper>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"Super\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTaggedTemplateExpression(\n node: t.Node | null | undefined,\n): node is t.TaggedTemplateExpression;\nexport function isTaggedTemplateExpression<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TaggedTemplateExpression & Opts;\nexport function isTaggedTemplateExpression<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TaggedTemplateExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTemplateElement(\n node: t.Node | null | undefined,\n): node is t.TemplateElement;\nexport function isTemplateElement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TemplateElement & Opts;\nexport function isTemplateElement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TemplateElement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTemplateLiteral(\n node: t.Node | null | undefined,\n): node is t.TemplateLiteral;\nexport function isTemplateLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TemplateLiteral & Opts;\nexport function isTemplateLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TemplateLiteral\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isYieldExpression(\n node: t.Node | null | undefined,\n): node is t.YieldExpression;\nexport function isYieldExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.YieldExpression & Opts;\nexport function isYieldExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"YieldExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isAwaitExpression(\n node: t.Node | null | undefined,\n): node is t.AwaitExpression;\nexport function isAwaitExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.AwaitExpression & Opts;\nexport function isAwaitExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"AwaitExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isImport(node: t.Node | null | undefined): node is t.Import;\nexport function isImport>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Import & Opts;\nexport function isImport>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"Import\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isBigIntLiteral(\n node: t.Node | null | undefined,\n): node is t.BigIntLiteral;\nexport function isBigIntLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.BigIntLiteral & Opts;\nexport function isBigIntLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"BigIntLiteral\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isExportNamespaceSpecifier(\n node: t.Node | null | undefined,\n): node is t.ExportNamespaceSpecifier;\nexport function isExportNamespaceSpecifier<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ExportNamespaceSpecifier & Opts;\nexport function isExportNamespaceSpecifier<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"ExportNamespaceSpecifier\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isOptionalMemberExpression(\n node: t.Node | null | undefined,\n): node is t.OptionalMemberExpression;\nexport function isOptionalMemberExpression<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.OptionalMemberExpression & Opts;\nexport function isOptionalMemberExpression<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"OptionalMemberExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isOptionalCallExpression(\n node: t.Node | null | undefined,\n): node is t.OptionalCallExpression;\nexport function isOptionalCallExpression<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.OptionalCallExpression & Opts;\nexport function isOptionalCallExpression<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"OptionalCallExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isClassProperty(\n node: t.Node | null | undefined,\n): node is t.ClassProperty;\nexport function isClassProperty>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ClassProperty & Opts;\nexport function isClassProperty>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ClassProperty\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isClassAccessorProperty(\n node: t.Node | null | undefined,\n): node is t.ClassAccessorProperty;\nexport function isClassAccessorProperty<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ClassAccessorProperty & Opts;\nexport function isClassAccessorProperty<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"ClassAccessorProperty\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isClassPrivateProperty(\n node: t.Node | null | undefined,\n): node is t.ClassPrivateProperty;\nexport function isClassPrivateProperty<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ClassPrivateProperty & Opts;\nexport function isClassPrivateProperty<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"ClassPrivateProperty\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isClassPrivateMethod(\n node: t.Node | null | undefined,\n): node is t.ClassPrivateMethod;\nexport function isClassPrivateMethod<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ClassPrivateMethod & Opts;\nexport function isClassPrivateMethod<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"ClassPrivateMethod\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isPrivateName(\n node: t.Node | null | undefined,\n): node is t.PrivateName;\nexport function isPrivateName>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.PrivateName & Opts;\nexport function isPrivateName>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"PrivateName\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isStaticBlock(\n node: t.Node | null | undefined,\n): node is t.StaticBlock;\nexport function isStaticBlock>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.StaticBlock & Opts;\nexport function isStaticBlock>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"StaticBlock\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isImportAttribute(\n node: t.Node | null | undefined,\n): node is t.ImportAttribute;\nexport function isImportAttribute>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ImportAttribute & Opts;\nexport function isImportAttribute>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ImportAttribute\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isAnyTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.AnyTypeAnnotation;\nexport function isAnyTypeAnnotation>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.AnyTypeAnnotation & Opts;\nexport function isAnyTypeAnnotation>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"AnyTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isArrayTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.ArrayTypeAnnotation;\nexport function isArrayTypeAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ArrayTypeAnnotation & Opts;\nexport function isArrayTypeAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"ArrayTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isBooleanTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.BooleanTypeAnnotation;\nexport function isBooleanTypeAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.BooleanTypeAnnotation & Opts;\nexport function isBooleanTypeAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"BooleanTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isBooleanLiteralTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.BooleanLiteralTypeAnnotation;\nexport function isBooleanLiteralTypeAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.BooleanLiteralTypeAnnotation & Opts;\nexport function isBooleanLiteralTypeAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"BooleanLiteralTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isNullLiteralTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.NullLiteralTypeAnnotation;\nexport function isNullLiteralTypeAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.NullLiteralTypeAnnotation & Opts;\nexport function isNullLiteralTypeAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"NullLiteralTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isClassImplements(\n node: t.Node | null | undefined,\n): node is t.ClassImplements;\nexport function isClassImplements>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ClassImplements & Opts;\nexport function isClassImplements>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ClassImplements\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isDeclareClass(\n node: t.Node | null | undefined,\n): node is t.DeclareClass;\nexport function isDeclareClass>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.DeclareClass & Opts;\nexport function isDeclareClass>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"DeclareClass\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isDeclareFunction(\n node: t.Node | null | undefined,\n): node is t.DeclareFunction;\nexport function isDeclareFunction>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.DeclareFunction & Opts;\nexport function isDeclareFunction>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"DeclareFunction\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isDeclareInterface(\n node: t.Node | null | undefined,\n): node is t.DeclareInterface;\nexport function isDeclareInterface>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.DeclareInterface & Opts;\nexport function isDeclareInterface>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"DeclareInterface\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isDeclareModule(\n node: t.Node | null | undefined,\n): node is t.DeclareModule;\nexport function isDeclareModule>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.DeclareModule & Opts;\nexport function isDeclareModule>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"DeclareModule\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isDeclareModuleExports(\n node: t.Node | null | undefined,\n): node is t.DeclareModuleExports;\nexport function isDeclareModuleExports<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.DeclareModuleExports & Opts;\nexport function isDeclareModuleExports<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"DeclareModuleExports\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isDeclareTypeAlias(\n node: t.Node | null | undefined,\n): node is t.DeclareTypeAlias;\nexport function isDeclareTypeAlias>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.DeclareTypeAlias & Opts;\nexport function isDeclareTypeAlias>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"DeclareTypeAlias\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isDeclareOpaqueType(\n node: t.Node | null | undefined,\n): node is t.DeclareOpaqueType;\nexport function isDeclareOpaqueType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.DeclareOpaqueType & Opts;\nexport function isDeclareOpaqueType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"DeclareOpaqueType\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isDeclareVariable(\n node: t.Node | null | undefined,\n): node is t.DeclareVariable;\nexport function isDeclareVariable>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.DeclareVariable & Opts;\nexport function isDeclareVariable>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"DeclareVariable\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isDeclareExportDeclaration(\n node: t.Node | null | undefined,\n): node is t.DeclareExportDeclaration;\nexport function isDeclareExportDeclaration<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.DeclareExportDeclaration & Opts;\nexport function isDeclareExportDeclaration<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"DeclareExportDeclaration\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isDeclareExportAllDeclaration(\n node: t.Node | null | undefined,\n): node is t.DeclareExportAllDeclaration;\nexport function isDeclareExportAllDeclaration<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.DeclareExportAllDeclaration & Opts;\nexport function isDeclareExportAllDeclaration<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"DeclareExportAllDeclaration\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isDeclaredPredicate(\n node: t.Node | null | undefined,\n): node is t.DeclaredPredicate;\nexport function isDeclaredPredicate>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.DeclaredPredicate & Opts;\nexport function isDeclaredPredicate>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"DeclaredPredicate\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isExistsTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.ExistsTypeAnnotation;\nexport function isExistsTypeAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ExistsTypeAnnotation & Opts;\nexport function isExistsTypeAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"ExistsTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isFunctionTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.FunctionTypeAnnotation;\nexport function isFunctionTypeAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.FunctionTypeAnnotation & Opts;\nexport function isFunctionTypeAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"FunctionTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isFunctionTypeParam(\n node: t.Node | null | undefined,\n): node is t.FunctionTypeParam;\nexport function isFunctionTypeParam>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.FunctionTypeParam & Opts;\nexport function isFunctionTypeParam>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"FunctionTypeParam\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isGenericTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.GenericTypeAnnotation;\nexport function isGenericTypeAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.GenericTypeAnnotation & Opts;\nexport function isGenericTypeAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"GenericTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isInferredPredicate(\n node: t.Node | null | undefined,\n): node is t.InferredPredicate;\nexport function isInferredPredicate>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.InferredPredicate & Opts;\nexport function isInferredPredicate>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"InferredPredicate\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isInterfaceExtends(\n node: t.Node | null | undefined,\n): node is t.InterfaceExtends;\nexport function isInterfaceExtends>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.InterfaceExtends & Opts;\nexport function isInterfaceExtends>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"InterfaceExtends\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isInterfaceDeclaration(\n node: t.Node | null | undefined,\n): node is t.InterfaceDeclaration;\nexport function isInterfaceDeclaration<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.InterfaceDeclaration & Opts;\nexport function isInterfaceDeclaration<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"InterfaceDeclaration\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isInterfaceTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.InterfaceTypeAnnotation;\nexport function isInterfaceTypeAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.InterfaceTypeAnnotation & Opts;\nexport function isInterfaceTypeAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"InterfaceTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isIntersectionTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.IntersectionTypeAnnotation;\nexport function isIntersectionTypeAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.IntersectionTypeAnnotation & Opts;\nexport function isIntersectionTypeAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"IntersectionTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isMixedTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.MixedTypeAnnotation;\nexport function isMixedTypeAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.MixedTypeAnnotation & Opts;\nexport function isMixedTypeAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"MixedTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isEmptyTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.EmptyTypeAnnotation;\nexport function isEmptyTypeAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.EmptyTypeAnnotation & Opts;\nexport function isEmptyTypeAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"EmptyTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isNullableTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.NullableTypeAnnotation;\nexport function isNullableTypeAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.NullableTypeAnnotation & Opts;\nexport function isNullableTypeAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"NullableTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isNumberLiteralTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.NumberLiteralTypeAnnotation;\nexport function isNumberLiteralTypeAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.NumberLiteralTypeAnnotation & Opts;\nexport function isNumberLiteralTypeAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"NumberLiteralTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isNumberTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.NumberTypeAnnotation;\nexport function isNumberTypeAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.NumberTypeAnnotation & Opts;\nexport function isNumberTypeAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"NumberTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isObjectTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.ObjectTypeAnnotation;\nexport function isObjectTypeAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ObjectTypeAnnotation & Opts;\nexport function isObjectTypeAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"ObjectTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isObjectTypeInternalSlot(\n node: t.Node | null | undefined,\n): node is t.ObjectTypeInternalSlot;\nexport function isObjectTypeInternalSlot<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ObjectTypeInternalSlot & Opts;\nexport function isObjectTypeInternalSlot<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"ObjectTypeInternalSlot\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isObjectTypeCallProperty(\n node: t.Node | null | undefined,\n): node is t.ObjectTypeCallProperty;\nexport function isObjectTypeCallProperty<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ObjectTypeCallProperty & Opts;\nexport function isObjectTypeCallProperty<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"ObjectTypeCallProperty\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isObjectTypeIndexer(\n node: t.Node | null | undefined,\n): node is t.ObjectTypeIndexer;\nexport function isObjectTypeIndexer>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ObjectTypeIndexer & Opts;\nexport function isObjectTypeIndexer>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ObjectTypeIndexer\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isObjectTypeProperty(\n node: t.Node | null | undefined,\n): node is t.ObjectTypeProperty;\nexport function isObjectTypeProperty<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ObjectTypeProperty & Opts;\nexport function isObjectTypeProperty<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"ObjectTypeProperty\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isObjectTypeSpreadProperty(\n node: t.Node | null | undefined,\n): node is t.ObjectTypeSpreadProperty;\nexport function isObjectTypeSpreadProperty<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ObjectTypeSpreadProperty & Opts;\nexport function isObjectTypeSpreadProperty<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"ObjectTypeSpreadProperty\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isOpaqueType(\n node: t.Node | null | undefined,\n): node is t.OpaqueType;\nexport function isOpaqueType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.OpaqueType & Opts;\nexport function isOpaqueType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"OpaqueType\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isQualifiedTypeIdentifier(\n node: t.Node | null | undefined,\n): node is t.QualifiedTypeIdentifier;\nexport function isQualifiedTypeIdentifier<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.QualifiedTypeIdentifier & Opts;\nexport function isQualifiedTypeIdentifier<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"QualifiedTypeIdentifier\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isStringLiteralTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.StringLiteralTypeAnnotation;\nexport function isStringLiteralTypeAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.StringLiteralTypeAnnotation & Opts;\nexport function isStringLiteralTypeAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"StringLiteralTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isStringTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.StringTypeAnnotation;\nexport function isStringTypeAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.StringTypeAnnotation & Opts;\nexport function isStringTypeAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"StringTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isSymbolTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.SymbolTypeAnnotation;\nexport function isSymbolTypeAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.SymbolTypeAnnotation & Opts;\nexport function isSymbolTypeAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"SymbolTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isThisTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.ThisTypeAnnotation;\nexport function isThisTypeAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ThisTypeAnnotation & Opts;\nexport function isThisTypeAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"ThisTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTupleTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.TupleTypeAnnotation;\nexport function isTupleTypeAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TupleTypeAnnotation & Opts;\nexport function isTupleTypeAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TupleTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTypeofTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.TypeofTypeAnnotation;\nexport function isTypeofTypeAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TypeofTypeAnnotation & Opts;\nexport function isTypeofTypeAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TypeofTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTypeAlias(\n node: t.Node | null | undefined,\n): node is t.TypeAlias;\nexport function isTypeAlias>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TypeAlias & Opts;\nexport function isTypeAlias>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TypeAlias\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.TypeAnnotation;\nexport function isTypeAnnotation>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TypeAnnotation & Opts;\nexport function isTypeAnnotation>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTypeCastExpression(\n node: t.Node | null | undefined,\n): node is t.TypeCastExpression;\nexport function isTypeCastExpression<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TypeCastExpression & Opts;\nexport function isTypeCastExpression<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TypeCastExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTypeParameter(\n node: t.Node | null | undefined,\n): node is t.TypeParameter;\nexport function isTypeParameter>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TypeParameter & Opts;\nexport function isTypeParameter>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TypeParameter\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTypeParameterDeclaration(\n node: t.Node | null | undefined,\n): node is t.TypeParameterDeclaration;\nexport function isTypeParameterDeclaration<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TypeParameterDeclaration & Opts;\nexport function isTypeParameterDeclaration<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TypeParameterDeclaration\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTypeParameterInstantiation(\n node: t.Node | null | undefined,\n): node is t.TypeParameterInstantiation;\nexport function isTypeParameterInstantiation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TypeParameterInstantiation & Opts;\nexport function isTypeParameterInstantiation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TypeParameterInstantiation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isUnionTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.UnionTypeAnnotation;\nexport function isUnionTypeAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.UnionTypeAnnotation & Opts;\nexport function isUnionTypeAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"UnionTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isVariance(node: t.Node | null | undefined): node is t.Variance;\nexport function isVariance>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Variance & Opts;\nexport function isVariance>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"Variance\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isVoidTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.VoidTypeAnnotation;\nexport function isVoidTypeAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.VoidTypeAnnotation & Opts;\nexport function isVoidTypeAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"VoidTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isEnumDeclaration(\n node: t.Node | null | undefined,\n): node is t.EnumDeclaration;\nexport function isEnumDeclaration>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.EnumDeclaration & Opts;\nexport function isEnumDeclaration>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"EnumDeclaration\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isEnumBooleanBody(\n node: t.Node | null | undefined,\n): node is t.EnumBooleanBody;\nexport function isEnumBooleanBody>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.EnumBooleanBody & Opts;\nexport function isEnumBooleanBody>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"EnumBooleanBody\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isEnumNumberBody(\n node: t.Node | null | undefined,\n): node is t.EnumNumberBody;\nexport function isEnumNumberBody>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.EnumNumberBody & Opts;\nexport function isEnumNumberBody>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"EnumNumberBody\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isEnumStringBody(\n node: t.Node | null | undefined,\n): node is t.EnumStringBody;\nexport function isEnumStringBody>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.EnumStringBody & Opts;\nexport function isEnumStringBody>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"EnumStringBody\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isEnumSymbolBody(\n node: t.Node | null | undefined,\n): node is t.EnumSymbolBody;\nexport function isEnumSymbolBody>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.EnumSymbolBody & Opts;\nexport function isEnumSymbolBody>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"EnumSymbolBody\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isEnumBooleanMember(\n node: t.Node | null | undefined,\n): node is t.EnumBooleanMember;\nexport function isEnumBooleanMember>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.EnumBooleanMember & Opts;\nexport function isEnumBooleanMember>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"EnumBooleanMember\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isEnumNumberMember(\n node: t.Node | null | undefined,\n): node is t.EnumNumberMember;\nexport function isEnumNumberMember>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.EnumNumberMember & Opts;\nexport function isEnumNumberMember>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"EnumNumberMember\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isEnumStringMember(\n node: t.Node | null | undefined,\n): node is t.EnumStringMember;\nexport function isEnumStringMember>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.EnumStringMember & Opts;\nexport function isEnumStringMember>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"EnumStringMember\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isEnumDefaultedMember(\n node: t.Node | null | undefined,\n): node is t.EnumDefaultedMember;\nexport function isEnumDefaultedMember<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.EnumDefaultedMember & Opts;\nexport function isEnumDefaultedMember<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"EnumDefaultedMember\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isIndexedAccessType(\n node: t.Node | null | undefined,\n): node is t.IndexedAccessType;\nexport function isIndexedAccessType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.IndexedAccessType & Opts;\nexport function isIndexedAccessType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"IndexedAccessType\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isOptionalIndexedAccessType(\n node: t.Node | null | undefined,\n): node is t.OptionalIndexedAccessType;\nexport function isOptionalIndexedAccessType<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.OptionalIndexedAccessType & Opts;\nexport function isOptionalIndexedAccessType<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"OptionalIndexedAccessType\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isJSXAttribute(\n node: t.Node | null | undefined,\n): node is t.JSXAttribute;\nexport function isJSXAttribute>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.JSXAttribute & Opts;\nexport function isJSXAttribute>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"JSXAttribute\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isJSXClosingElement(\n node: t.Node | null | undefined,\n): node is t.JSXClosingElement;\nexport function isJSXClosingElement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.JSXClosingElement & Opts;\nexport function isJSXClosingElement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"JSXClosingElement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isJSXElement(\n node: t.Node | null | undefined,\n): node is t.JSXElement;\nexport function isJSXElement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.JSXElement & Opts;\nexport function isJSXElement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"JSXElement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isJSXEmptyExpression(\n node: t.Node | null | undefined,\n): node is t.JSXEmptyExpression;\nexport function isJSXEmptyExpression<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.JSXEmptyExpression & Opts;\nexport function isJSXEmptyExpression<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"JSXEmptyExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isJSXExpressionContainer(\n node: t.Node | null | undefined,\n): node is t.JSXExpressionContainer;\nexport function isJSXExpressionContainer<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.JSXExpressionContainer & Opts;\nexport function isJSXExpressionContainer<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"JSXExpressionContainer\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isJSXSpreadChild(\n node: t.Node | null | undefined,\n): node is t.JSXSpreadChild;\nexport function isJSXSpreadChild>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.JSXSpreadChild & Opts;\nexport function isJSXSpreadChild>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"JSXSpreadChild\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isJSXIdentifier(\n node: t.Node | null | undefined,\n): node is t.JSXIdentifier;\nexport function isJSXIdentifier>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.JSXIdentifier & Opts;\nexport function isJSXIdentifier>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"JSXIdentifier\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isJSXMemberExpression(\n node: t.Node | null | undefined,\n): node is t.JSXMemberExpression;\nexport function isJSXMemberExpression<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.JSXMemberExpression & Opts;\nexport function isJSXMemberExpression<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"JSXMemberExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isJSXNamespacedName(\n node: t.Node | null | undefined,\n): node is t.JSXNamespacedName;\nexport function isJSXNamespacedName>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.JSXNamespacedName & Opts;\nexport function isJSXNamespacedName>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"JSXNamespacedName\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isJSXOpeningElement(\n node: t.Node | null | undefined,\n): node is t.JSXOpeningElement;\nexport function isJSXOpeningElement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.JSXOpeningElement & Opts;\nexport function isJSXOpeningElement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"JSXOpeningElement\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isJSXSpreadAttribute(\n node: t.Node | null | undefined,\n): node is t.JSXSpreadAttribute;\nexport function isJSXSpreadAttribute<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.JSXSpreadAttribute & Opts;\nexport function isJSXSpreadAttribute<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"JSXSpreadAttribute\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isJSXText(node: t.Node | null | undefined): node is t.JSXText;\nexport function isJSXText>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.JSXText & Opts;\nexport function isJSXText>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"JSXText\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isJSXFragment(\n node: t.Node | null | undefined,\n): node is t.JSXFragment;\nexport function isJSXFragment>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.JSXFragment & Opts;\nexport function isJSXFragment>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"JSXFragment\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isJSXOpeningFragment(\n node: t.Node | null | undefined,\n): node is t.JSXOpeningFragment;\nexport function isJSXOpeningFragment<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.JSXOpeningFragment & Opts;\nexport function isJSXOpeningFragment<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"JSXOpeningFragment\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isJSXClosingFragment(\n node: t.Node | null | undefined,\n): node is t.JSXClosingFragment;\nexport function isJSXClosingFragment<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.JSXClosingFragment & Opts;\nexport function isJSXClosingFragment<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"JSXClosingFragment\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isNoop(node: t.Node | null | undefined): node is t.Noop;\nexport function isNoop>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Noop & Opts;\nexport function isNoop>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"Noop\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isPlaceholder(\n node: t.Node | null | undefined,\n): node is t.Placeholder;\nexport function isPlaceholder>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Placeholder & Opts;\nexport function isPlaceholder>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"Placeholder\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isV8IntrinsicIdentifier(\n node: t.Node | null | undefined,\n): node is t.V8IntrinsicIdentifier;\nexport function isV8IntrinsicIdentifier<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.V8IntrinsicIdentifier & Opts;\nexport function isV8IntrinsicIdentifier<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"V8IntrinsicIdentifier\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isArgumentPlaceholder(\n node: t.Node | null | undefined,\n): node is t.ArgumentPlaceholder;\nexport function isArgumentPlaceholder<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ArgumentPlaceholder & Opts;\nexport function isArgumentPlaceholder<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"ArgumentPlaceholder\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isBindExpression(\n node: t.Node | null | undefined,\n): node is t.BindExpression;\nexport function isBindExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.BindExpression & Opts;\nexport function isBindExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"BindExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isDecorator(\n node: t.Node | null | undefined,\n): node is t.Decorator;\nexport function isDecorator>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Decorator & Opts;\nexport function isDecorator>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"Decorator\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isDoExpression(\n node: t.Node | null | undefined,\n): node is t.DoExpression;\nexport function isDoExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.DoExpression & Opts;\nexport function isDoExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"DoExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isExportDefaultSpecifier(\n node: t.Node | null | undefined,\n): node is t.ExportDefaultSpecifier;\nexport function isExportDefaultSpecifier<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ExportDefaultSpecifier & Opts;\nexport function isExportDefaultSpecifier<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"ExportDefaultSpecifier\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isRecordExpression(\n node: t.Node | null | undefined,\n): node is t.RecordExpression;\nexport function isRecordExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.RecordExpression & Opts;\nexport function isRecordExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"RecordExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTupleExpression(\n node: t.Node | null | undefined,\n): node is t.TupleExpression;\nexport function isTupleExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TupleExpression & Opts;\nexport function isTupleExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TupleExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isDecimalLiteral(\n node: t.Node | null | undefined,\n): node is t.DecimalLiteral;\nexport function isDecimalLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.DecimalLiteral & Opts;\nexport function isDecimalLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"DecimalLiteral\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isModuleExpression(\n node: t.Node | null | undefined,\n): node is t.ModuleExpression;\nexport function isModuleExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ModuleExpression & Opts;\nexport function isModuleExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"ModuleExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTopicReference(\n node: t.Node | null | undefined,\n): node is t.TopicReference;\nexport function isTopicReference>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TopicReference & Opts;\nexport function isTopicReference>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TopicReference\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isPipelineTopicExpression(\n node: t.Node | null | undefined,\n): node is t.PipelineTopicExpression;\nexport function isPipelineTopicExpression<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.PipelineTopicExpression & Opts;\nexport function isPipelineTopicExpression<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"PipelineTopicExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isPipelineBareFunction(\n node: t.Node | null | undefined,\n): node is t.PipelineBareFunction;\nexport function isPipelineBareFunction<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.PipelineBareFunction & Opts;\nexport function isPipelineBareFunction<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"PipelineBareFunction\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isPipelinePrimaryTopicReference(\n node: t.Node | null | undefined,\n): node is t.PipelinePrimaryTopicReference;\nexport function isPipelinePrimaryTopicReference<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.PipelinePrimaryTopicReference & Opts;\nexport function isPipelinePrimaryTopicReference<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"PipelinePrimaryTopicReference\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isVoidPattern(\n node: t.Node | null | undefined,\n): node is t.VoidPattern;\nexport function isVoidPattern>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.VoidPattern & Opts;\nexport function isVoidPattern>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"VoidPattern\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSParameterProperty(\n node: t.Node | null | undefined,\n): node is t.TSParameterProperty;\nexport function isTSParameterProperty<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSParameterProperty & Opts;\nexport function isTSParameterProperty<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSParameterProperty\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSDeclareFunction(\n node: t.Node | null | undefined,\n): node is t.TSDeclareFunction;\nexport function isTSDeclareFunction>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSDeclareFunction & Opts;\nexport function isTSDeclareFunction>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSDeclareFunction\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSDeclareMethod(\n node: t.Node | null | undefined,\n): node is t.TSDeclareMethod;\nexport function isTSDeclareMethod>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSDeclareMethod & Opts;\nexport function isTSDeclareMethod>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSDeclareMethod\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSQualifiedName(\n node: t.Node | null | undefined,\n): node is t.TSQualifiedName;\nexport function isTSQualifiedName>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSQualifiedName & Opts;\nexport function isTSQualifiedName>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSQualifiedName\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSCallSignatureDeclaration(\n node: t.Node | null | undefined,\n): node is t.TSCallSignatureDeclaration;\nexport function isTSCallSignatureDeclaration<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSCallSignatureDeclaration & Opts;\nexport function isTSCallSignatureDeclaration<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSCallSignatureDeclaration\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSConstructSignatureDeclaration(\n node: t.Node | null | undefined,\n): node is t.TSConstructSignatureDeclaration;\nexport function isTSConstructSignatureDeclaration<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSConstructSignatureDeclaration & Opts;\nexport function isTSConstructSignatureDeclaration<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSConstructSignatureDeclaration\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSPropertySignature(\n node: t.Node | null | undefined,\n): node is t.TSPropertySignature;\nexport function isTSPropertySignature<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSPropertySignature & Opts;\nexport function isTSPropertySignature<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSPropertySignature\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSMethodSignature(\n node: t.Node | null | undefined,\n): node is t.TSMethodSignature;\nexport function isTSMethodSignature>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSMethodSignature & Opts;\nexport function isTSMethodSignature>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSMethodSignature\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSIndexSignature(\n node: t.Node | null | undefined,\n): node is t.TSIndexSignature;\nexport function isTSIndexSignature>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSIndexSignature & Opts;\nexport function isTSIndexSignature>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSIndexSignature\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSAnyKeyword(\n node: t.Node | null | undefined,\n): node is t.TSAnyKeyword;\nexport function isTSAnyKeyword>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSAnyKeyword & Opts;\nexport function isTSAnyKeyword>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSAnyKeyword\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSBooleanKeyword(\n node: t.Node | null | undefined,\n): node is t.TSBooleanKeyword;\nexport function isTSBooleanKeyword>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSBooleanKeyword & Opts;\nexport function isTSBooleanKeyword>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSBooleanKeyword\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSBigIntKeyword(\n node: t.Node | null | undefined,\n): node is t.TSBigIntKeyword;\nexport function isTSBigIntKeyword>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSBigIntKeyword & Opts;\nexport function isTSBigIntKeyword>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSBigIntKeyword\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSIntrinsicKeyword(\n node: t.Node | null | undefined,\n): node is t.TSIntrinsicKeyword;\nexport function isTSIntrinsicKeyword<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSIntrinsicKeyword & Opts;\nexport function isTSIntrinsicKeyword<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSIntrinsicKeyword\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSNeverKeyword(\n node: t.Node | null | undefined,\n): node is t.TSNeverKeyword;\nexport function isTSNeverKeyword>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSNeverKeyword & Opts;\nexport function isTSNeverKeyword>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSNeverKeyword\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSNullKeyword(\n node: t.Node | null | undefined,\n): node is t.TSNullKeyword;\nexport function isTSNullKeyword>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSNullKeyword & Opts;\nexport function isTSNullKeyword>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSNullKeyword\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSNumberKeyword(\n node: t.Node | null | undefined,\n): node is t.TSNumberKeyword;\nexport function isTSNumberKeyword>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSNumberKeyword & Opts;\nexport function isTSNumberKeyword>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSNumberKeyword\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSObjectKeyword(\n node: t.Node | null | undefined,\n): node is t.TSObjectKeyword;\nexport function isTSObjectKeyword>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSObjectKeyword & Opts;\nexport function isTSObjectKeyword>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSObjectKeyword\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSStringKeyword(\n node: t.Node | null | undefined,\n): node is t.TSStringKeyword;\nexport function isTSStringKeyword>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSStringKeyword & Opts;\nexport function isTSStringKeyword>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSStringKeyword\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSSymbolKeyword(\n node: t.Node | null | undefined,\n): node is t.TSSymbolKeyword;\nexport function isTSSymbolKeyword>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSSymbolKeyword & Opts;\nexport function isTSSymbolKeyword>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSSymbolKeyword\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSUndefinedKeyword(\n node: t.Node | null | undefined,\n): node is t.TSUndefinedKeyword;\nexport function isTSUndefinedKeyword<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSUndefinedKeyword & Opts;\nexport function isTSUndefinedKeyword<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSUndefinedKeyword\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSUnknownKeyword(\n node: t.Node | null | undefined,\n): node is t.TSUnknownKeyword;\nexport function isTSUnknownKeyword>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSUnknownKeyword & Opts;\nexport function isTSUnknownKeyword>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSUnknownKeyword\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSVoidKeyword(\n node: t.Node | null | undefined,\n): node is t.TSVoidKeyword;\nexport function isTSVoidKeyword>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSVoidKeyword & Opts;\nexport function isTSVoidKeyword>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSVoidKeyword\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSThisType(\n node: t.Node | null | undefined,\n): node is t.TSThisType;\nexport function isTSThisType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSThisType & Opts;\nexport function isTSThisType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSThisType\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSFunctionType(\n node: t.Node | null | undefined,\n): node is t.TSFunctionType;\nexport function isTSFunctionType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSFunctionType & Opts;\nexport function isTSFunctionType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSFunctionType\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSConstructorType(\n node: t.Node | null | undefined,\n): node is t.TSConstructorType;\nexport function isTSConstructorType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSConstructorType & Opts;\nexport function isTSConstructorType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSConstructorType\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSTypeReference(\n node: t.Node | null | undefined,\n): node is t.TSTypeReference;\nexport function isTSTypeReference>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSTypeReference & Opts;\nexport function isTSTypeReference>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSTypeReference\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSTypePredicate(\n node: t.Node | null | undefined,\n): node is t.TSTypePredicate;\nexport function isTSTypePredicate>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSTypePredicate & Opts;\nexport function isTSTypePredicate>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSTypePredicate\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSTypeQuery(\n node: t.Node | null | undefined,\n): node is t.TSTypeQuery;\nexport function isTSTypeQuery>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSTypeQuery & Opts;\nexport function isTSTypeQuery>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSTypeQuery\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSTypeLiteral(\n node: t.Node | null | undefined,\n): node is t.TSTypeLiteral;\nexport function isTSTypeLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSTypeLiteral & Opts;\nexport function isTSTypeLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSTypeLiteral\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSArrayType(\n node: t.Node | null | undefined,\n): node is t.TSArrayType;\nexport function isTSArrayType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSArrayType & Opts;\nexport function isTSArrayType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSArrayType\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSTupleType(\n node: t.Node | null | undefined,\n): node is t.TSTupleType;\nexport function isTSTupleType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSTupleType & Opts;\nexport function isTSTupleType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSTupleType\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSOptionalType(\n node: t.Node | null | undefined,\n): node is t.TSOptionalType;\nexport function isTSOptionalType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSOptionalType & Opts;\nexport function isTSOptionalType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSOptionalType\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSRestType(\n node: t.Node | null | undefined,\n): node is t.TSRestType;\nexport function isTSRestType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSRestType & Opts;\nexport function isTSRestType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSRestType\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSNamedTupleMember(\n node: t.Node | null | undefined,\n): node is t.TSNamedTupleMember;\nexport function isTSNamedTupleMember<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSNamedTupleMember & Opts;\nexport function isTSNamedTupleMember<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSNamedTupleMember\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSUnionType(\n node: t.Node | null | undefined,\n): node is t.TSUnionType;\nexport function isTSUnionType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSUnionType & Opts;\nexport function isTSUnionType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSUnionType\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSIntersectionType(\n node: t.Node | null | undefined,\n): node is t.TSIntersectionType;\nexport function isTSIntersectionType<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSIntersectionType & Opts;\nexport function isTSIntersectionType<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSIntersectionType\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSConditionalType(\n node: t.Node | null | undefined,\n): node is t.TSConditionalType;\nexport function isTSConditionalType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSConditionalType & Opts;\nexport function isTSConditionalType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSConditionalType\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSInferType(\n node: t.Node | null | undefined,\n): node is t.TSInferType;\nexport function isTSInferType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSInferType & Opts;\nexport function isTSInferType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSInferType\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSParenthesizedType(\n node: t.Node | null | undefined,\n): node is t.TSParenthesizedType;\nexport function isTSParenthesizedType<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSParenthesizedType & Opts;\nexport function isTSParenthesizedType<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSParenthesizedType\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSTypeOperator(\n node: t.Node | null | undefined,\n): node is t.TSTypeOperator;\nexport function isTSTypeOperator>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSTypeOperator & Opts;\nexport function isTSTypeOperator>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSTypeOperator\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSIndexedAccessType(\n node: t.Node | null | undefined,\n): node is t.TSIndexedAccessType;\nexport function isTSIndexedAccessType<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSIndexedAccessType & Opts;\nexport function isTSIndexedAccessType<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSIndexedAccessType\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSMappedType(\n node: t.Node | null | undefined,\n): node is t.TSMappedType;\nexport function isTSMappedType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSMappedType & Opts;\nexport function isTSMappedType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSMappedType\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSTemplateLiteralType(\n node: t.Node | null | undefined,\n): node is t.TSTemplateLiteralType;\nexport function isTSTemplateLiteralType<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSTemplateLiteralType & Opts;\nexport function isTSTemplateLiteralType<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSTemplateLiteralType\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSLiteralType(\n node: t.Node | null | undefined,\n): node is t.TSLiteralType;\nexport function isTSLiteralType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSLiteralType & Opts;\nexport function isTSLiteralType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSLiteralType\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSExpressionWithTypeArguments(\n node: t.Node | null | undefined,\n): node is t.TSExpressionWithTypeArguments;\nexport function isTSExpressionWithTypeArguments<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSExpressionWithTypeArguments & Opts;\nexport function isTSExpressionWithTypeArguments<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSExpressionWithTypeArguments\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSInterfaceDeclaration(\n node: t.Node | null | undefined,\n): node is t.TSInterfaceDeclaration;\nexport function isTSInterfaceDeclaration<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSInterfaceDeclaration & Opts;\nexport function isTSInterfaceDeclaration<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSInterfaceDeclaration\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSInterfaceBody(\n node: t.Node | null | undefined,\n): node is t.TSInterfaceBody;\nexport function isTSInterfaceBody>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSInterfaceBody & Opts;\nexport function isTSInterfaceBody>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSInterfaceBody\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSTypeAliasDeclaration(\n node: t.Node | null | undefined,\n): node is t.TSTypeAliasDeclaration;\nexport function isTSTypeAliasDeclaration<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSTypeAliasDeclaration & Opts;\nexport function isTSTypeAliasDeclaration<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSTypeAliasDeclaration\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSInstantiationExpression(\n node: t.Node | null | undefined,\n): node is t.TSInstantiationExpression;\nexport function isTSInstantiationExpression<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSInstantiationExpression & Opts;\nexport function isTSInstantiationExpression<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSInstantiationExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSAsExpression(\n node: t.Node | null | undefined,\n): node is t.TSAsExpression;\nexport function isTSAsExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSAsExpression & Opts;\nexport function isTSAsExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSAsExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSSatisfiesExpression(\n node: t.Node | null | undefined,\n): node is t.TSSatisfiesExpression;\nexport function isTSSatisfiesExpression<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSSatisfiesExpression & Opts;\nexport function isTSSatisfiesExpression<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSSatisfiesExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSTypeAssertion(\n node: t.Node | null | undefined,\n): node is t.TSTypeAssertion;\nexport function isTSTypeAssertion>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSTypeAssertion & Opts;\nexport function isTSTypeAssertion>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSTypeAssertion\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSEnumBody(\n node: t.Node | null | undefined,\n): node is t.TSEnumBody;\nexport function isTSEnumBody>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSEnumBody & Opts;\nexport function isTSEnumBody>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSEnumBody\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSEnumDeclaration(\n node: t.Node | null | undefined,\n): node is t.TSEnumDeclaration;\nexport function isTSEnumDeclaration>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSEnumDeclaration & Opts;\nexport function isTSEnumDeclaration>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSEnumDeclaration\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSEnumMember(\n node: t.Node | null | undefined,\n): node is t.TSEnumMember;\nexport function isTSEnumMember>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSEnumMember & Opts;\nexport function isTSEnumMember>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSEnumMember\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSModuleDeclaration(\n node: t.Node | null | undefined,\n): node is t.TSModuleDeclaration;\nexport function isTSModuleDeclaration<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSModuleDeclaration & Opts;\nexport function isTSModuleDeclaration<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSModuleDeclaration\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSModuleBlock(\n node: t.Node | null | undefined,\n): node is t.TSModuleBlock;\nexport function isTSModuleBlock>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSModuleBlock & Opts;\nexport function isTSModuleBlock>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSModuleBlock\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSImportType(\n node: t.Node | null | undefined,\n): node is t.TSImportType;\nexport function isTSImportType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSImportType & Opts;\nexport function isTSImportType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSImportType\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSImportEqualsDeclaration(\n node: t.Node | null | undefined,\n): node is t.TSImportEqualsDeclaration;\nexport function isTSImportEqualsDeclaration<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSImportEqualsDeclaration & Opts;\nexport function isTSImportEqualsDeclaration<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSImportEqualsDeclaration\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSExternalModuleReference(\n node: t.Node | null | undefined,\n): node is t.TSExternalModuleReference;\nexport function isTSExternalModuleReference<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSExternalModuleReference & Opts;\nexport function isTSExternalModuleReference<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSExternalModuleReference\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSNonNullExpression(\n node: t.Node | null | undefined,\n): node is t.TSNonNullExpression;\nexport function isTSNonNullExpression<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSNonNullExpression & Opts;\nexport function isTSNonNullExpression<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSNonNullExpression\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSExportAssignment(\n node: t.Node | null | undefined,\n): node is t.TSExportAssignment;\nexport function isTSExportAssignment<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSExportAssignment & Opts;\nexport function isTSExportAssignment<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSExportAssignment\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSNamespaceExportDeclaration(\n node: t.Node | null | undefined,\n): node is t.TSNamespaceExportDeclaration;\nexport function isTSNamespaceExportDeclaration<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSNamespaceExportDeclaration & Opts;\nexport function isTSNamespaceExportDeclaration<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSNamespaceExportDeclaration\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSTypeAnnotation(\n node: t.Node | null | undefined,\n): node is t.TSTypeAnnotation;\nexport function isTSTypeAnnotation>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSTypeAnnotation & Opts;\nexport function isTSTypeAnnotation>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSTypeAnnotation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSTypeParameterInstantiation(\n node: t.Node | null | undefined,\n): node is t.TSTypeParameterInstantiation;\nexport function isTSTypeParameterInstantiation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSTypeParameterInstantiation & Opts;\nexport function isTSTypeParameterInstantiation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSTypeParameterInstantiation\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSTypeParameterDeclaration(\n node: t.Node | null | undefined,\n): node is t.TSTypeParameterDeclaration;\nexport function isTSTypeParameterDeclaration<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSTypeParameterDeclaration & Opts;\nexport function isTSTypeParameterDeclaration<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSTypeParameterDeclaration\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSTypeParameter(\n node: t.Node | null | undefined,\n): node is t.TSTypeParameter;\nexport function isTSTypeParameter>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSTypeParameter & Opts;\nexport function isTSTypeParameter>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n if (node.type !== \"TSTypeParameter\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isStandardized(\n node: t.Node | null | undefined,\n): node is t.Standardized;\nexport function isStandardized>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Standardized & Opts;\nexport function isStandardized>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"ArrayExpression\":\n case \"AssignmentExpression\":\n case \"BinaryExpression\":\n case \"InterpreterDirective\":\n case \"Directive\":\n case \"DirectiveLiteral\":\n case \"BlockStatement\":\n case \"BreakStatement\":\n case \"CallExpression\":\n case \"CatchClause\":\n case \"ConditionalExpression\":\n case \"ContinueStatement\":\n case \"DebuggerStatement\":\n case \"DoWhileStatement\":\n case \"EmptyStatement\":\n case \"ExpressionStatement\":\n case \"File\":\n case \"ForInStatement\":\n case \"ForStatement\":\n case \"FunctionDeclaration\":\n case \"FunctionExpression\":\n case \"Identifier\":\n case \"IfStatement\":\n case \"LabeledStatement\":\n case \"StringLiteral\":\n case \"NumericLiteral\":\n case \"NullLiteral\":\n case \"BooleanLiteral\":\n case \"RegExpLiteral\":\n case \"LogicalExpression\":\n case \"MemberExpression\":\n case \"NewExpression\":\n case \"Program\":\n case \"ObjectExpression\":\n case \"ObjectMethod\":\n case \"ObjectProperty\":\n case \"RestElement\":\n case \"ReturnStatement\":\n case \"SequenceExpression\":\n case \"ParenthesizedExpression\":\n case \"SwitchCase\":\n case \"SwitchStatement\":\n case \"ThisExpression\":\n case \"ThrowStatement\":\n case \"TryStatement\":\n case \"UnaryExpression\":\n case \"UpdateExpression\":\n case \"VariableDeclaration\":\n case \"VariableDeclarator\":\n case \"WhileStatement\":\n case \"WithStatement\":\n case \"AssignmentPattern\":\n case \"ArrayPattern\":\n case \"ArrowFunctionExpression\":\n case \"ClassBody\":\n case \"ClassExpression\":\n case \"ClassDeclaration\":\n case \"ExportAllDeclaration\":\n case \"ExportDefaultDeclaration\":\n case \"ExportNamedDeclaration\":\n case \"ExportSpecifier\":\n case \"ForOfStatement\":\n case \"ImportDeclaration\":\n case \"ImportDefaultSpecifier\":\n case \"ImportNamespaceSpecifier\":\n case \"ImportSpecifier\":\n case \"ImportExpression\":\n case \"MetaProperty\":\n case \"ClassMethod\":\n case \"ObjectPattern\":\n case \"SpreadElement\":\n case \"Super\":\n case \"TaggedTemplateExpression\":\n case \"TemplateElement\":\n case \"TemplateLiteral\":\n case \"YieldExpression\":\n case \"AwaitExpression\":\n case \"Import\":\n case \"BigIntLiteral\":\n case \"ExportNamespaceSpecifier\":\n case \"OptionalMemberExpression\":\n case \"OptionalCallExpression\":\n case \"ClassProperty\":\n case \"ClassAccessorProperty\":\n case \"ClassPrivateProperty\":\n case \"ClassPrivateMethod\":\n case \"PrivateName\":\n case \"StaticBlock\":\n case \"ImportAttribute\":\n break;\n case \"Placeholder\":\n switch (node.expectedNode) {\n case \"Identifier\":\n case \"StringLiteral\":\n case \"BlockStatement\":\n case \"ClassBody\":\n break;\n default:\n return false;\n }\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isExpression(\n node: t.Node | null | undefined,\n): node is t.Expression;\nexport function isExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Expression & Opts;\nexport function isExpression>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"ArrayExpression\":\n case \"AssignmentExpression\":\n case \"BinaryExpression\":\n case \"CallExpression\":\n case \"ConditionalExpression\":\n case \"FunctionExpression\":\n case \"Identifier\":\n case \"StringLiteral\":\n case \"NumericLiteral\":\n case \"NullLiteral\":\n case \"BooleanLiteral\":\n case \"RegExpLiteral\":\n case \"LogicalExpression\":\n case \"MemberExpression\":\n case \"NewExpression\":\n case \"ObjectExpression\":\n case \"SequenceExpression\":\n case \"ParenthesizedExpression\":\n case \"ThisExpression\":\n case \"UnaryExpression\":\n case \"UpdateExpression\":\n case \"ArrowFunctionExpression\":\n case \"ClassExpression\":\n case \"ImportExpression\":\n case \"MetaProperty\":\n case \"Super\":\n case \"TaggedTemplateExpression\":\n case \"TemplateLiteral\":\n case \"YieldExpression\":\n case \"AwaitExpression\":\n case \"Import\":\n case \"BigIntLiteral\":\n case \"OptionalMemberExpression\":\n case \"OptionalCallExpression\":\n case \"TypeCastExpression\":\n case \"JSXElement\":\n case \"JSXFragment\":\n case \"BindExpression\":\n case \"DoExpression\":\n case \"RecordExpression\":\n case \"TupleExpression\":\n case \"DecimalLiteral\":\n case \"ModuleExpression\":\n case \"TopicReference\":\n case \"PipelineTopicExpression\":\n case \"PipelineBareFunction\":\n case \"PipelinePrimaryTopicReference\":\n case \"TSInstantiationExpression\":\n case \"TSAsExpression\":\n case \"TSSatisfiesExpression\":\n case \"TSTypeAssertion\":\n case \"TSNonNullExpression\":\n break;\n case \"Placeholder\":\n switch (node.expectedNode) {\n case \"Expression\":\n case \"Identifier\":\n case \"StringLiteral\":\n break;\n default:\n return false;\n }\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isBinary(node: t.Node | null | undefined): node is t.Binary;\nexport function isBinary>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Binary & Opts;\nexport function isBinary>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"BinaryExpression\":\n case \"LogicalExpression\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isScopable(node: t.Node | null | undefined): node is t.Scopable;\nexport function isScopable>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Scopable & Opts;\nexport function isScopable>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"BlockStatement\":\n case \"CatchClause\":\n case \"DoWhileStatement\":\n case \"ForInStatement\":\n case \"ForStatement\":\n case \"FunctionDeclaration\":\n case \"FunctionExpression\":\n case \"Program\":\n case \"ObjectMethod\":\n case \"SwitchStatement\":\n case \"WhileStatement\":\n case \"ArrowFunctionExpression\":\n case \"ClassExpression\":\n case \"ClassDeclaration\":\n case \"ForOfStatement\":\n case \"ClassMethod\":\n case \"ClassPrivateMethod\":\n case \"StaticBlock\":\n case \"TSModuleBlock\":\n break;\n case \"Placeholder\":\n if (node.expectedNode === \"BlockStatement\") break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isBlockParent(\n node: t.Node | null | undefined,\n): node is t.BlockParent;\nexport function isBlockParent>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.BlockParent & Opts;\nexport function isBlockParent>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"BlockStatement\":\n case \"CatchClause\":\n case \"DoWhileStatement\":\n case \"ForInStatement\":\n case \"ForStatement\":\n case \"FunctionDeclaration\":\n case \"FunctionExpression\":\n case \"Program\":\n case \"ObjectMethod\":\n case \"SwitchStatement\":\n case \"WhileStatement\":\n case \"ArrowFunctionExpression\":\n case \"ForOfStatement\":\n case \"ClassMethod\":\n case \"ClassPrivateMethod\":\n case \"StaticBlock\":\n case \"TSModuleBlock\":\n break;\n case \"Placeholder\":\n if (node.expectedNode === \"BlockStatement\") break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isBlock(node: t.Node | null | undefined): node is t.Block;\nexport function isBlock>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Block & Opts;\nexport function isBlock>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"BlockStatement\":\n case \"Program\":\n case \"TSModuleBlock\":\n break;\n case \"Placeholder\":\n if (node.expectedNode === \"BlockStatement\") break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isStatement(\n node: t.Node | null | undefined,\n): node is t.Statement;\nexport function isStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Statement & Opts;\nexport function isStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"BlockStatement\":\n case \"BreakStatement\":\n case \"ContinueStatement\":\n case \"DebuggerStatement\":\n case \"DoWhileStatement\":\n case \"EmptyStatement\":\n case \"ExpressionStatement\":\n case \"ForInStatement\":\n case \"ForStatement\":\n case \"FunctionDeclaration\":\n case \"IfStatement\":\n case \"LabeledStatement\":\n case \"ReturnStatement\":\n case \"SwitchStatement\":\n case \"ThrowStatement\":\n case \"TryStatement\":\n case \"VariableDeclaration\":\n case \"WhileStatement\":\n case \"WithStatement\":\n case \"ClassDeclaration\":\n case \"ExportAllDeclaration\":\n case \"ExportDefaultDeclaration\":\n case \"ExportNamedDeclaration\":\n case \"ForOfStatement\":\n case \"ImportDeclaration\":\n case \"DeclareClass\":\n case \"DeclareFunction\":\n case \"DeclareInterface\":\n case \"DeclareModule\":\n case \"DeclareModuleExports\":\n case \"DeclareTypeAlias\":\n case \"DeclareOpaqueType\":\n case \"DeclareVariable\":\n case \"DeclareExportDeclaration\":\n case \"DeclareExportAllDeclaration\":\n case \"InterfaceDeclaration\":\n case \"OpaqueType\":\n case \"TypeAlias\":\n case \"EnumDeclaration\":\n case \"TSDeclareFunction\":\n case \"TSInterfaceDeclaration\":\n case \"TSTypeAliasDeclaration\":\n case \"TSEnumDeclaration\":\n case \"TSModuleDeclaration\":\n case \"TSImportEqualsDeclaration\":\n case \"TSExportAssignment\":\n case \"TSNamespaceExportDeclaration\":\n break;\n case \"Placeholder\":\n switch (node.expectedNode) {\n case \"Statement\":\n case \"Declaration\":\n case \"BlockStatement\":\n break;\n default:\n return false;\n }\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTerminatorless(\n node: t.Node | null | undefined,\n): node is t.Terminatorless;\nexport function isTerminatorless>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Terminatorless & Opts;\nexport function isTerminatorless>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"BreakStatement\":\n case \"ContinueStatement\":\n case \"ReturnStatement\":\n case \"ThrowStatement\":\n case \"YieldExpression\":\n case \"AwaitExpression\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isCompletionStatement(\n node: t.Node | null | undefined,\n): node is t.CompletionStatement;\nexport function isCompletionStatement<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.CompletionStatement & Opts;\nexport function isCompletionStatement<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"BreakStatement\":\n case \"ContinueStatement\":\n case \"ReturnStatement\":\n case \"ThrowStatement\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isConditional(\n node: t.Node | null | undefined,\n): node is t.Conditional;\nexport function isConditional>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Conditional & Opts;\nexport function isConditional>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"ConditionalExpression\":\n case \"IfStatement\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isLoop(node: t.Node | null | undefined): node is t.Loop;\nexport function isLoop>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Loop & Opts;\nexport function isLoop>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"DoWhileStatement\":\n case \"ForInStatement\":\n case \"ForStatement\":\n case \"WhileStatement\":\n case \"ForOfStatement\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isWhile(node: t.Node | null | undefined): node is t.While;\nexport function isWhile>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.While & Opts;\nexport function isWhile>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"DoWhileStatement\":\n case \"WhileStatement\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isExpressionWrapper(\n node: t.Node | null | undefined,\n): node is t.ExpressionWrapper;\nexport function isExpressionWrapper>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ExpressionWrapper & Opts;\nexport function isExpressionWrapper>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"ExpressionStatement\":\n case \"ParenthesizedExpression\":\n case \"TypeCastExpression\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isFor(node: t.Node | null | undefined): node is t.For;\nexport function isFor>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.For & Opts;\nexport function isFor>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"ForInStatement\":\n case \"ForStatement\":\n case \"ForOfStatement\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isForXStatement(\n node: t.Node | null | undefined,\n): node is t.ForXStatement;\nexport function isForXStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ForXStatement & Opts;\nexport function isForXStatement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"ForInStatement\":\n case \"ForOfStatement\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isFunction(node: t.Node | null | undefined): node is t.Function;\nexport function isFunction>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Function & Opts;\nexport function isFunction>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"FunctionDeclaration\":\n case \"FunctionExpression\":\n case \"ObjectMethod\":\n case \"ArrowFunctionExpression\":\n case \"ClassMethod\":\n case \"ClassPrivateMethod\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isFunctionParent(\n node: t.Node | null | undefined,\n): node is t.FunctionParent;\nexport function isFunctionParent>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.FunctionParent & Opts;\nexport function isFunctionParent>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"FunctionDeclaration\":\n case \"FunctionExpression\":\n case \"ObjectMethod\":\n case \"ArrowFunctionExpression\":\n case \"ClassMethod\":\n case \"ClassPrivateMethod\":\n case \"StaticBlock\":\n case \"TSModuleBlock\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isPureish(node: t.Node | null | undefined): node is t.Pureish;\nexport function isPureish>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Pureish & Opts;\nexport function isPureish>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"FunctionDeclaration\":\n case \"FunctionExpression\":\n case \"StringLiteral\":\n case \"NumericLiteral\":\n case \"NullLiteral\":\n case \"BooleanLiteral\":\n case \"RegExpLiteral\":\n case \"ArrowFunctionExpression\":\n case \"BigIntLiteral\":\n case \"DecimalLiteral\":\n break;\n case \"Placeholder\":\n if (node.expectedNode === \"StringLiteral\") break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isDeclaration(\n node: t.Node | null | undefined,\n): node is t.Declaration;\nexport function isDeclaration>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Declaration & Opts;\nexport function isDeclaration>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"FunctionDeclaration\":\n case \"VariableDeclaration\":\n case \"ClassDeclaration\":\n case \"ExportAllDeclaration\":\n case \"ExportDefaultDeclaration\":\n case \"ExportNamedDeclaration\":\n case \"ImportDeclaration\":\n case \"DeclareClass\":\n case \"DeclareFunction\":\n case \"DeclareInterface\":\n case \"DeclareModule\":\n case \"DeclareModuleExports\":\n case \"DeclareTypeAlias\":\n case \"DeclareOpaqueType\":\n case \"DeclareVariable\":\n case \"DeclareExportDeclaration\":\n case \"DeclareExportAllDeclaration\":\n case \"InterfaceDeclaration\":\n case \"OpaqueType\":\n case \"TypeAlias\":\n case \"EnumDeclaration\":\n case \"TSDeclareFunction\":\n case \"TSInterfaceDeclaration\":\n case \"TSTypeAliasDeclaration\":\n case \"TSEnumDeclaration\":\n case \"TSModuleDeclaration\":\n case \"TSImportEqualsDeclaration\":\n break;\n case \"Placeholder\":\n if (node.expectedNode === \"Declaration\") break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isFunctionParameter(\n node: t.Node | null | undefined,\n): node is t.FunctionParameter;\nexport function isFunctionParameter>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.FunctionParameter & Opts;\nexport function isFunctionParameter>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"Identifier\":\n case \"RestElement\":\n case \"AssignmentPattern\":\n case \"ArrayPattern\":\n case \"ObjectPattern\":\n case \"VoidPattern\":\n break;\n case \"Placeholder\":\n if (node.expectedNode === \"Identifier\") break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isPatternLike(\n node: t.Node | null | undefined,\n): node is t.PatternLike;\nexport function isPatternLike>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.PatternLike & Opts;\nexport function isPatternLike>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"Identifier\":\n case \"MemberExpression\":\n case \"RestElement\":\n case \"AssignmentPattern\":\n case \"ArrayPattern\":\n case \"ObjectPattern\":\n case \"VoidPattern\":\n case \"TSAsExpression\":\n case \"TSSatisfiesExpression\":\n case \"TSTypeAssertion\":\n case \"TSNonNullExpression\":\n break;\n case \"Placeholder\":\n switch (node.expectedNode) {\n case \"Pattern\":\n case \"Identifier\":\n break;\n default:\n return false;\n }\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isLVal(node: t.Node | null | undefined): node is t.LVal;\nexport function isLVal>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.LVal & Opts;\nexport function isLVal>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"Identifier\":\n case \"MemberExpression\":\n case \"RestElement\":\n case \"AssignmentPattern\":\n case \"ArrayPattern\":\n case \"ObjectPattern\":\n case \"TSParameterProperty\":\n case \"TSAsExpression\":\n case \"TSSatisfiesExpression\":\n case \"TSTypeAssertion\":\n case \"TSNonNullExpression\":\n break;\n case \"Placeholder\":\n switch (node.expectedNode) {\n case \"Pattern\":\n case \"Identifier\":\n break;\n default:\n return false;\n }\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSEntityName(\n node: t.Node | null | undefined,\n): node is t.TSEntityName;\nexport function isTSEntityName>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSEntityName & Opts;\nexport function isTSEntityName>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"Identifier\":\n case \"TSQualifiedName\":\n break;\n case \"Placeholder\":\n if (node.expectedNode === \"Identifier\") break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isLiteral(node: t.Node | null | undefined): node is t.Literal;\nexport function isLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Literal & Opts;\nexport function isLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"StringLiteral\":\n case \"NumericLiteral\":\n case \"NullLiteral\":\n case \"BooleanLiteral\":\n case \"RegExpLiteral\":\n case \"TemplateLiteral\":\n case \"BigIntLiteral\":\n case \"DecimalLiteral\":\n break;\n case \"Placeholder\":\n if (node.expectedNode === \"StringLiteral\") break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isImmutable(\n node: t.Node | null | undefined,\n): node is t.Immutable;\nexport function isImmutable>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Immutable & Opts;\nexport function isImmutable>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"StringLiteral\":\n case \"NumericLiteral\":\n case \"NullLiteral\":\n case \"BooleanLiteral\":\n case \"BigIntLiteral\":\n case \"JSXAttribute\":\n case \"JSXClosingElement\":\n case \"JSXElement\":\n case \"JSXExpressionContainer\":\n case \"JSXSpreadChild\":\n case \"JSXOpeningElement\":\n case \"JSXText\":\n case \"JSXFragment\":\n case \"JSXOpeningFragment\":\n case \"JSXClosingFragment\":\n case \"DecimalLiteral\":\n break;\n case \"Placeholder\":\n if (node.expectedNode === \"StringLiteral\") break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isUserWhitespacable(\n node: t.Node | null | undefined,\n): node is t.UserWhitespacable;\nexport function isUserWhitespacable>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.UserWhitespacable & Opts;\nexport function isUserWhitespacable>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"ObjectMethod\":\n case \"ObjectProperty\":\n case \"ObjectTypeInternalSlot\":\n case \"ObjectTypeCallProperty\":\n case \"ObjectTypeIndexer\":\n case \"ObjectTypeProperty\":\n case \"ObjectTypeSpreadProperty\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isMethod(node: t.Node | null | undefined): node is t.Method;\nexport function isMethod>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Method & Opts;\nexport function isMethod>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"ObjectMethod\":\n case \"ClassMethod\":\n case \"ClassPrivateMethod\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isObjectMember(\n node: t.Node | null | undefined,\n): node is t.ObjectMember;\nexport function isObjectMember>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ObjectMember & Opts;\nexport function isObjectMember>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"ObjectMethod\":\n case \"ObjectProperty\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isProperty(node: t.Node | null | undefined): node is t.Property;\nexport function isProperty>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Property & Opts;\nexport function isProperty>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"ObjectProperty\":\n case \"ClassProperty\":\n case \"ClassAccessorProperty\":\n case \"ClassPrivateProperty\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isUnaryLike(\n node: t.Node | null | undefined,\n): node is t.UnaryLike;\nexport function isUnaryLike>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.UnaryLike & Opts;\nexport function isUnaryLike>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"UnaryExpression\":\n case \"SpreadElement\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isPattern(node: t.Node | null | undefined): node is t.Pattern;\nexport function isPattern>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Pattern & Opts;\nexport function isPattern>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"AssignmentPattern\":\n case \"ArrayPattern\":\n case \"ObjectPattern\":\n case \"VoidPattern\":\n break;\n case \"Placeholder\":\n if (node.expectedNode === \"Pattern\") break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isClass(node: t.Node | null | undefined): node is t.Class;\nexport function isClass>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Class & Opts;\nexport function isClass>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"ClassExpression\":\n case \"ClassDeclaration\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isImportOrExportDeclaration(\n node: t.Node | null | undefined,\n): node is t.ImportOrExportDeclaration;\nexport function isImportOrExportDeclaration<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ImportOrExportDeclaration & Opts;\nexport function isImportOrExportDeclaration<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"ExportAllDeclaration\":\n case \"ExportDefaultDeclaration\":\n case \"ExportNamedDeclaration\":\n case \"ImportDeclaration\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isExportDeclaration(\n node: t.Node | null | undefined,\n): node is t.ExportDeclaration;\nexport function isExportDeclaration>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ExportDeclaration & Opts;\nexport function isExportDeclaration>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"ExportAllDeclaration\":\n case \"ExportDefaultDeclaration\":\n case \"ExportNamedDeclaration\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isModuleSpecifier(\n node: t.Node | null | undefined,\n): node is t.ModuleSpecifier;\nexport function isModuleSpecifier>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ModuleSpecifier & Opts;\nexport function isModuleSpecifier>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"ExportSpecifier\":\n case \"ImportDefaultSpecifier\":\n case \"ImportNamespaceSpecifier\":\n case \"ImportSpecifier\":\n case \"ExportNamespaceSpecifier\":\n case \"ExportDefaultSpecifier\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isAccessor(node: t.Node | null | undefined): node is t.Accessor;\nexport function isAccessor>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Accessor & Opts;\nexport function isAccessor>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"ClassAccessorProperty\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isPrivate(node: t.Node | null | undefined): node is t.Private;\nexport function isPrivate>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Private & Opts;\nexport function isPrivate>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"ClassPrivateProperty\":\n case \"ClassPrivateMethod\":\n case \"PrivateName\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isFlow(node: t.Node | null | undefined): node is t.Flow;\nexport function isFlow>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Flow & Opts;\nexport function isFlow>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"AnyTypeAnnotation\":\n case \"ArrayTypeAnnotation\":\n case \"BooleanTypeAnnotation\":\n case \"BooleanLiteralTypeAnnotation\":\n case \"NullLiteralTypeAnnotation\":\n case \"ClassImplements\":\n case \"DeclareClass\":\n case \"DeclareFunction\":\n case \"DeclareInterface\":\n case \"DeclareModule\":\n case \"DeclareModuleExports\":\n case \"DeclareTypeAlias\":\n case \"DeclareOpaqueType\":\n case \"DeclareVariable\":\n case \"DeclareExportDeclaration\":\n case \"DeclareExportAllDeclaration\":\n case \"DeclaredPredicate\":\n case \"ExistsTypeAnnotation\":\n case \"FunctionTypeAnnotation\":\n case \"FunctionTypeParam\":\n case \"GenericTypeAnnotation\":\n case \"InferredPredicate\":\n case \"InterfaceExtends\":\n case \"InterfaceDeclaration\":\n case \"InterfaceTypeAnnotation\":\n case \"IntersectionTypeAnnotation\":\n case \"MixedTypeAnnotation\":\n case \"EmptyTypeAnnotation\":\n case \"NullableTypeAnnotation\":\n case \"NumberLiteralTypeAnnotation\":\n case \"NumberTypeAnnotation\":\n case \"ObjectTypeAnnotation\":\n case \"ObjectTypeInternalSlot\":\n case \"ObjectTypeCallProperty\":\n case \"ObjectTypeIndexer\":\n case \"ObjectTypeProperty\":\n case \"ObjectTypeSpreadProperty\":\n case \"OpaqueType\":\n case \"QualifiedTypeIdentifier\":\n case \"StringLiteralTypeAnnotation\":\n case \"StringTypeAnnotation\":\n case \"SymbolTypeAnnotation\":\n case \"ThisTypeAnnotation\":\n case \"TupleTypeAnnotation\":\n case \"TypeofTypeAnnotation\":\n case \"TypeAlias\":\n case \"TypeAnnotation\":\n case \"TypeCastExpression\":\n case \"TypeParameter\":\n case \"TypeParameterDeclaration\":\n case \"TypeParameterInstantiation\":\n case \"UnionTypeAnnotation\":\n case \"Variance\":\n case \"VoidTypeAnnotation\":\n case \"EnumDeclaration\":\n case \"EnumBooleanBody\":\n case \"EnumNumberBody\":\n case \"EnumStringBody\":\n case \"EnumSymbolBody\":\n case \"EnumBooleanMember\":\n case \"EnumNumberMember\":\n case \"EnumStringMember\":\n case \"EnumDefaultedMember\":\n case \"IndexedAccessType\":\n case \"OptionalIndexedAccessType\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isFlowType(node: t.Node | null | undefined): node is t.FlowType;\nexport function isFlowType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.FlowType & Opts;\nexport function isFlowType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"AnyTypeAnnotation\":\n case \"ArrayTypeAnnotation\":\n case \"BooleanTypeAnnotation\":\n case \"BooleanLiteralTypeAnnotation\":\n case \"NullLiteralTypeAnnotation\":\n case \"ExistsTypeAnnotation\":\n case \"FunctionTypeAnnotation\":\n case \"GenericTypeAnnotation\":\n case \"InterfaceTypeAnnotation\":\n case \"IntersectionTypeAnnotation\":\n case \"MixedTypeAnnotation\":\n case \"EmptyTypeAnnotation\":\n case \"NullableTypeAnnotation\":\n case \"NumberLiteralTypeAnnotation\":\n case \"NumberTypeAnnotation\":\n case \"ObjectTypeAnnotation\":\n case \"StringLiteralTypeAnnotation\":\n case \"StringTypeAnnotation\":\n case \"SymbolTypeAnnotation\":\n case \"ThisTypeAnnotation\":\n case \"TupleTypeAnnotation\":\n case \"TypeofTypeAnnotation\":\n case \"UnionTypeAnnotation\":\n case \"VoidTypeAnnotation\":\n case \"IndexedAccessType\":\n case \"OptionalIndexedAccessType\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isFlowBaseAnnotation(\n node: t.Node | null | undefined,\n): node is t.FlowBaseAnnotation;\nexport function isFlowBaseAnnotation<\n Opts extends Options,\n>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.FlowBaseAnnotation & Opts;\nexport function isFlowBaseAnnotation<\n Opts extends Options,\n>(node: t.Node | null | undefined, opts?: Opts | null): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"AnyTypeAnnotation\":\n case \"BooleanTypeAnnotation\":\n case \"NullLiteralTypeAnnotation\":\n case \"MixedTypeAnnotation\":\n case \"EmptyTypeAnnotation\":\n case \"NumberTypeAnnotation\":\n case \"StringTypeAnnotation\":\n case \"SymbolTypeAnnotation\":\n case \"ThisTypeAnnotation\":\n case \"VoidTypeAnnotation\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isFlowDeclaration(\n node: t.Node | null | undefined,\n): node is t.FlowDeclaration;\nexport function isFlowDeclaration>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.FlowDeclaration & Opts;\nexport function isFlowDeclaration>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"DeclareClass\":\n case \"DeclareFunction\":\n case \"DeclareInterface\":\n case \"DeclareModule\":\n case \"DeclareModuleExports\":\n case \"DeclareTypeAlias\":\n case \"DeclareOpaqueType\":\n case \"DeclareVariable\":\n case \"DeclareExportDeclaration\":\n case \"DeclareExportAllDeclaration\":\n case \"InterfaceDeclaration\":\n case \"OpaqueType\":\n case \"TypeAlias\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isFlowPredicate(\n node: t.Node | null | undefined,\n): node is t.FlowPredicate;\nexport function isFlowPredicate>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.FlowPredicate & Opts;\nexport function isFlowPredicate>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"DeclaredPredicate\":\n case \"InferredPredicate\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isEnumBody(node: t.Node | null | undefined): node is t.EnumBody;\nexport function isEnumBody>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.EnumBody & Opts;\nexport function isEnumBody>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"EnumBooleanBody\":\n case \"EnumNumberBody\":\n case \"EnumStringBody\":\n case \"EnumSymbolBody\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isEnumMember(\n node: t.Node | null | undefined,\n): node is t.EnumMember;\nexport function isEnumMember>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.EnumMember & Opts;\nexport function isEnumMember>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"EnumBooleanMember\":\n case \"EnumNumberMember\":\n case \"EnumStringMember\":\n case \"EnumDefaultedMember\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isJSX(node: t.Node | null | undefined): node is t.JSX;\nexport function isJSX>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.JSX & Opts;\nexport function isJSX>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"JSXAttribute\":\n case \"JSXClosingElement\":\n case \"JSXElement\":\n case \"JSXEmptyExpression\":\n case \"JSXExpressionContainer\":\n case \"JSXSpreadChild\":\n case \"JSXIdentifier\":\n case \"JSXMemberExpression\":\n case \"JSXNamespacedName\":\n case \"JSXOpeningElement\":\n case \"JSXSpreadAttribute\":\n case \"JSXText\":\n case \"JSXFragment\":\n case \"JSXOpeningFragment\":\n case \"JSXClosingFragment\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isMiscellaneous(\n node: t.Node | null | undefined,\n): node is t.Miscellaneous;\nexport function isMiscellaneous>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.Miscellaneous & Opts;\nexport function isMiscellaneous>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"Noop\":\n case \"Placeholder\":\n case \"V8IntrinsicIdentifier\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTypeScript(\n node: t.Node | null | undefined,\n): node is t.TypeScript;\nexport function isTypeScript>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TypeScript & Opts;\nexport function isTypeScript>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"TSParameterProperty\":\n case \"TSDeclareFunction\":\n case \"TSDeclareMethod\":\n case \"TSQualifiedName\":\n case \"TSCallSignatureDeclaration\":\n case \"TSConstructSignatureDeclaration\":\n case \"TSPropertySignature\":\n case \"TSMethodSignature\":\n case \"TSIndexSignature\":\n case \"TSAnyKeyword\":\n case \"TSBooleanKeyword\":\n case \"TSBigIntKeyword\":\n case \"TSIntrinsicKeyword\":\n case \"TSNeverKeyword\":\n case \"TSNullKeyword\":\n case \"TSNumberKeyword\":\n case \"TSObjectKeyword\":\n case \"TSStringKeyword\":\n case \"TSSymbolKeyword\":\n case \"TSUndefinedKeyword\":\n case \"TSUnknownKeyword\":\n case \"TSVoidKeyword\":\n case \"TSThisType\":\n case \"TSFunctionType\":\n case \"TSConstructorType\":\n case \"TSTypeReference\":\n case \"TSTypePredicate\":\n case \"TSTypeQuery\":\n case \"TSTypeLiteral\":\n case \"TSArrayType\":\n case \"TSTupleType\":\n case \"TSOptionalType\":\n case \"TSRestType\":\n case \"TSNamedTupleMember\":\n case \"TSUnionType\":\n case \"TSIntersectionType\":\n case \"TSConditionalType\":\n case \"TSInferType\":\n case \"TSParenthesizedType\":\n case \"TSTypeOperator\":\n case \"TSIndexedAccessType\":\n case \"TSMappedType\":\n case \"TSTemplateLiteralType\":\n case \"TSLiteralType\":\n case \"TSExpressionWithTypeArguments\":\n case \"TSInterfaceDeclaration\":\n case \"TSInterfaceBody\":\n case \"TSTypeAliasDeclaration\":\n case \"TSInstantiationExpression\":\n case \"TSAsExpression\":\n case \"TSSatisfiesExpression\":\n case \"TSTypeAssertion\":\n case \"TSEnumBody\":\n case \"TSEnumDeclaration\":\n case \"TSEnumMember\":\n case \"TSModuleDeclaration\":\n case \"TSModuleBlock\":\n case \"TSImportType\":\n case \"TSImportEqualsDeclaration\":\n case \"TSExternalModuleReference\":\n case \"TSNonNullExpression\":\n case \"TSExportAssignment\":\n case \"TSNamespaceExportDeclaration\":\n case \"TSTypeAnnotation\":\n case \"TSTypeParameterInstantiation\":\n case \"TSTypeParameterDeclaration\":\n case \"TSTypeParameter\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSTypeElement(\n node: t.Node | null | undefined,\n): node is t.TSTypeElement;\nexport function isTSTypeElement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSTypeElement & Opts;\nexport function isTSTypeElement>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"TSCallSignatureDeclaration\":\n case \"TSConstructSignatureDeclaration\":\n case \"TSPropertySignature\":\n case \"TSMethodSignature\":\n case \"TSIndexSignature\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSType(node: t.Node | null | undefined): node is t.TSType;\nexport function isTSType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSType & Opts;\nexport function isTSType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"TSAnyKeyword\":\n case \"TSBooleanKeyword\":\n case \"TSBigIntKeyword\":\n case \"TSIntrinsicKeyword\":\n case \"TSNeverKeyword\":\n case \"TSNullKeyword\":\n case \"TSNumberKeyword\":\n case \"TSObjectKeyword\":\n case \"TSStringKeyword\":\n case \"TSSymbolKeyword\":\n case \"TSUndefinedKeyword\":\n case \"TSUnknownKeyword\":\n case \"TSVoidKeyword\":\n case \"TSThisType\":\n case \"TSFunctionType\":\n case \"TSConstructorType\":\n case \"TSTypeReference\":\n case \"TSTypePredicate\":\n case \"TSTypeQuery\":\n case \"TSTypeLiteral\":\n case \"TSArrayType\":\n case \"TSTupleType\":\n case \"TSOptionalType\":\n case \"TSRestType\":\n case \"TSUnionType\":\n case \"TSIntersectionType\":\n case \"TSConditionalType\":\n case \"TSInferType\":\n case \"TSParenthesizedType\":\n case \"TSTypeOperator\":\n case \"TSIndexedAccessType\":\n case \"TSMappedType\":\n case \"TSTemplateLiteralType\":\n case \"TSLiteralType\":\n case \"TSExpressionWithTypeArguments\":\n case \"TSImportType\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\nexport function isTSBaseType(\n node: t.Node | null | undefined,\n): node is t.TSBaseType;\nexport function isTSBaseType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.TSBaseType & Opts;\nexport function isTSBaseType>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n if (!node) return false;\n\n switch (node.type) {\n case \"TSAnyKeyword\":\n case \"TSBooleanKeyword\":\n case \"TSBigIntKeyword\":\n case \"TSIntrinsicKeyword\":\n case \"TSNeverKeyword\":\n case \"TSNullKeyword\":\n case \"TSNumberKeyword\":\n case \"TSObjectKeyword\":\n case \"TSStringKeyword\":\n case \"TSSymbolKeyword\":\n case \"TSUndefinedKeyword\":\n case \"TSUnknownKeyword\":\n case \"TSVoidKeyword\":\n case \"TSThisType\":\n case \"TSTemplateLiteralType\":\n case \"TSLiteralType\":\n break;\n default:\n return false;\n }\n\n return opts == null || shallowEqual(node, opts);\n}\n/**\n * @deprecated Use `isNumericLiteral`\n */\nexport function isNumberLiteral(node: t.Node | null | undefined): boolean;\nexport function isNumberLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean;\nexport function isNumberLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n deprecationWarning(\"isNumberLiteral\", \"isNumericLiteral\");\n if (!node) return false;\n\n if (node.type !== \"NumberLiteral\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\n/**\n * @deprecated Use `isRegExpLiteral`\n */\nexport function isRegexLiteral(node: t.Node | null | undefined): boolean;\nexport function isRegexLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean;\nexport function isRegexLiteral>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n deprecationWarning(\"isRegexLiteral\", \"isRegExpLiteral\");\n if (!node) return false;\n\n if (node.type !== \"RegexLiteral\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\n/**\n * @deprecated Use `isRestElement`\n */\nexport function isRestProperty(node: t.Node | null | undefined): boolean;\nexport function isRestProperty>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean;\nexport function isRestProperty>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n deprecationWarning(\"isRestProperty\", \"isRestElement\");\n if (!node) return false;\n\n if (node.type !== \"RestProperty\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\n/**\n * @deprecated Use `isSpreadElement`\n */\nexport function isSpreadProperty(node: t.Node | null | undefined): boolean;\nexport function isSpreadProperty>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean;\nexport function isSpreadProperty>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): boolean {\n deprecationWarning(\"isSpreadProperty\", \"isSpreadElement\");\n if (!node) return false;\n\n if (node.type !== \"SpreadProperty\") return false;\n\n return opts == null || shallowEqual(node, opts);\n}\n/**\n * @deprecated Use `isImportOrExportDeclaration`\n */\nexport function isModuleDeclaration>(\n node: t.Node | null | undefined,\n opts?: Opts | null,\n): node is t.ImportOrExportDeclaration & Opts {\n deprecationWarning(\"isModuleDeclaration\", \"isImportOrExportDeclaration\");\n return isImportOrExportDeclaration(node, opts);\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/validators/is.js b/scripts/node_modules/@babel/types/lib/validators/is.js new file mode 100644 index 0000000000000000000000000000000000000000..39c04889d5b64e821360dbe3d89c61bfdadb2e6f --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/is.js @@ -0,0 +1,27 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = is; +var _shallowEqual = require("../utils/shallowEqual.js"); +var _isType = require("./isType.js"); +var _isPlaceholderType = require("./isPlaceholderType.js"); +var _index = require("../definitions/index.js"); +function is(type, node, opts) { + if (!node) return false; + const matches = (0, _isType.default)(node.type, type); + if (!matches) { + if (!opts && node.type === "Placeholder" && type in _index.FLIPPED_ALIAS_KEYS) { + return (0, _isPlaceholderType.default)(node.expectedNode, type); + } + return false; + } + if (opts === undefined) { + return true; + } else { + return (0, _shallowEqual.default)(node, opts); + } +} + +//# sourceMappingURL=is.js.map diff --git a/scripts/node_modules/@babel/types/lib/validators/is.js.map b/scripts/node_modules/@babel/types/lib/validators/is.js.map new file mode 100644 index 0000000000000000000000000000000000000000..06ba31fc1165ed1ea608477a6482391839ae103d --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/is.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_shallowEqual","require","_isType","_isPlaceholderType","_index","is","type","node","opts","matches","isType","FLIPPED_ALIAS_KEYS","isPlaceholderType","expectedNode","undefined","shallowEqual"],"sources":["../../src/validators/is.ts"],"sourcesContent":["import shallowEqual from \"../utils/shallowEqual.ts\";\nimport isType from \"./isType.ts\";\nimport isPlaceholderType from \"./isPlaceholderType.ts\";\nimport { FLIPPED_ALIAS_KEYS } from \"../definitions/index.ts\";\nimport type * as t from \"../index.ts\";\n\nexport default function is(\n type: T,\n node: t.Node | null | undefined,\n opts?: undefined,\n): node is Extract;\n\nexport default function is<\n T extends t.Node[\"type\"],\n P extends Extract,\n>(type: T, n: t.Node | null | undefined, required: Partial

): n is P;\n\nexport default function is

(\n type: string,\n node: t.Node | null | undefined,\n opts: Partial

,\n): node is P;\n\nexport default function is(\n type: string,\n node: t.Node | null | undefined,\n opts?: Partial,\n): node is t.Node;\n/**\n * Returns whether `node` is of given `type`.\n *\n * For better performance, use this instead of `is[Type]` when `type` is unknown.\n */\nexport default function is(\n type: string,\n node: t.Node | null | undefined,\n opts?: Partial,\n): node is t.Node {\n if (!node) return false;\n\n const matches = isType(node.type, type);\n if (!matches) {\n if (!opts && node.type === \"Placeholder\" && type in FLIPPED_ALIAS_KEYS) {\n // We can only return true if the placeholder doesn't replace a real node,\n // but it replaces a category of nodes (an alias).\n //\n // t.is(\"Identifier\", node) gives some guarantees about node's shape, so we\n // can't say that Placeholder(expectedNode: \"Identifier\") is an identifier\n // because it doesn't have the same properties.\n // On the other hand, t.is(\"Expression\", node) doesn't say anything about\n // the shape of node because Expression can be many different nodes: we can,\n // and should, safely report expression placeholders as Expressions.\n return isPlaceholderType(node.expectedNode, type);\n }\n return false;\n }\n\n if (opts === undefined) {\n return true;\n } else {\n return shallowEqual(node, opts);\n }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,aAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AACA,IAAAE,kBAAA,GAAAF,OAAA;AACA,IAAAG,MAAA,GAAAH,OAAA;AA8Be,SAASI,EAAEA,CACxBC,IAAY,EACZC,IAA+B,EAC/BC,IAAsB,EACN;EAChB,IAAI,CAACD,IAAI,EAAE,OAAO,KAAK;EAEvB,MAAME,OAAO,GAAG,IAAAC,eAAM,EAACH,IAAI,CAACD,IAAI,EAAEA,IAAI,CAAC;EACvC,IAAI,CAACG,OAAO,EAAE;IACZ,IAAI,CAACD,IAAI,IAAID,IAAI,CAACD,IAAI,KAAK,aAAa,IAAIA,IAAI,IAAIK,yBAAkB,EAAE;MAUtE,OAAO,IAAAC,0BAAiB,EAACL,IAAI,CAACM,YAAY,EAAEP,IAAI,CAAC;IACnD;IACA,OAAO,KAAK;EACd;EAEA,IAAIE,IAAI,KAAKM,SAAS,EAAE;IACtB,OAAO,IAAI;EACb,CAAC,MAAM;IACL,OAAO,IAAAC,qBAAY,EAACR,IAAI,EAAEC,IAAI,CAAC;EACjC;AACF","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/validators/isBinding.js b/scripts/node_modules/@babel/types/lib/validators/isBinding.js new file mode 100644 index 0000000000000000000000000000000000000000..b3b1a4b835e2366c8aa24899ab6e8fc3b0960dcb --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isBinding.js @@ -0,0 +1,27 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isBinding; +var _getBindingIdentifiers = require("../retrievers/getBindingIdentifiers.js"); +function isBinding(node, parent, grandparent) { + if (grandparent && node.type === "Identifier" && parent.type === "ObjectProperty" && grandparent.type === "ObjectExpression") { + return false; + } + const keys = _getBindingIdentifiers.default.keys[parent.type]; + if (keys) { + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const val = parent[key]; + if (Array.isArray(val)) { + if (val.includes(node)) return true; + } else { + if (val === node) return true; + } + } + } + return false; +} + +//# sourceMappingURL=isBinding.js.map diff --git a/scripts/node_modules/@babel/types/lib/validators/isBinding.js.map b/scripts/node_modules/@babel/types/lib/validators/isBinding.js.map new file mode 100644 index 0000000000000000000000000000000000000000..d6c9c0531aae72d2bfd981eca031d4307a9df6c3 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isBinding.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_getBindingIdentifiers","require","isBinding","node","parent","grandparent","type","keys","getBindingIdentifiers","i","length","key","val","Array","isArray","includes"],"sources":["../../src/validators/isBinding.ts"],"sourcesContent":["import getBindingIdentifiers from \"../retrievers/getBindingIdentifiers.ts\";\nimport type * as t from \"../index.ts\";\n/**\n * Check if the input `node` is a binding identifier.\n */\nexport default function isBinding(\n node: t.Node,\n parent: t.Node,\n grandparent?: t.Node,\n): boolean {\n if (\n grandparent &&\n node.type === \"Identifier\" &&\n parent.type === \"ObjectProperty\" &&\n grandparent.type === \"ObjectExpression\"\n ) {\n // We need to special-case this, because getBindingIdentifiers\n // has an ObjectProperty->value entry for destructuring patterns.\n return false;\n }\n\n const keys = getBindingIdentifiers.keys[parent.type];\n if (keys) {\n for (let i = 0; i < keys.length; i++) {\n const key = keys[i];\n const val =\n // @ts-expect-error key must present in parent\n parent[key];\n if (Array.isArray(val)) {\n if (val.includes(node)) return true;\n } else {\n if (val === node) return true;\n }\n }\n }\n\n return false;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,sBAAA,GAAAC,OAAA;AAKe,SAASC,SAASA,CAC/BC,IAAY,EACZC,MAAc,EACdC,WAAoB,EACX;EACT,IACEA,WAAW,IACXF,IAAI,CAACG,IAAI,KAAK,YAAY,IAC1BF,MAAM,CAACE,IAAI,KAAK,gBAAgB,IAChCD,WAAW,CAACC,IAAI,KAAK,kBAAkB,EACvC;IAGA,OAAO,KAAK;EACd;EAEA,MAAMC,IAAI,GAAGC,8BAAqB,CAACD,IAAI,CAACH,MAAM,CAACE,IAAI,CAAC;EACpD,IAAIC,IAAI,EAAE;IACR,KAAK,IAAIE,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,IAAI,CAACG,MAAM,EAAED,CAAC,EAAE,EAAE;MACpC,MAAME,GAAG,GAAGJ,IAAI,CAACE,CAAC,CAAC;MACnB,MAAMG,GAAG,GAEPR,MAAM,CAACO,GAAG,CAAC;MACb,IAAIE,KAAK,CAACC,OAAO,CAACF,GAAG,CAAC,EAAE;QACtB,IAAIA,GAAG,CAACG,QAAQ,CAACZ,IAAI,CAAC,EAAE,OAAO,IAAI;MACrC,CAAC,MAAM;QACL,IAAIS,GAAG,KAAKT,IAAI,EAAE,OAAO,IAAI;MAC/B;IACF;EACF;EAEA,OAAO,KAAK;AACd","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/validators/isBlockScoped.js b/scripts/node_modules/@babel/types/lib/validators/isBlockScoped.js new file mode 100644 index 0000000000000000000000000000000000000000..a552f65f62ba6c5af7878451feb094a99867a976 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isBlockScoped.js @@ -0,0 +1,13 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isBlockScoped; +var _index = require("./generated/index.js"); +var _isLet = require("./isLet.js"); +function isBlockScoped(node) { + return (0, _index.isFunctionDeclaration)(node) || (0, _index.isClassDeclaration)(node) || (0, _isLet.default)(node); +} + +//# sourceMappingURL=isBlockScoped.js.map diff --git a/scripts/node_modules/@babel/types/lib/validators/isBlockScoped.js.map b/scripts/node_modules/@babel/types/lib/validators/isBlockScoped.js.map new file mode 100644 index 0000000000000000000000000000000000000000..89ecfed7118a97eb225a409d5b1c8bd41576d714 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isBlockScoped.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_index","require","_isLet","isBlockScoped","node","isFunctionDeclaration","isClassDeclaration","isLet"],"sources":["../../src/validators/isBlockScoped.ts"],"sourcesContent":["import {\n isClassDeclaration,\n isFunctionDeclaration,\n} from \"./generated/index.ts\";\nimport isLet from \"./isLet.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Check if the input `node` is block scoped.\n */\nexport default function isBlockScoped(\n node: t.Node | null | undefined,\n): boolean {\n return isFunctionDeclaration(node) || isClassDeclaration(node) || isLet(node);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAIA,IAAAC,MAAA,GAAAD,OAAA;AAMe,SAASE,aAAaA,CACnCC,IAA+B,EACtB;EACT,OAAO,IAAAC,4BAAqB,EAACD,IAAI,CAAC,IAAI,IAAAE,yBAAkB,EAACF,IAAI,CAAC,IAAI,IAAAG,cAAK,EAACH,IAAI,CAAC;AAC/E","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/validators/isImmutable.js b/scripts/node_modules/@babel/types/lib/validators/isImmutable.js new file mode 100644 index 0000000000000000000000000000000000000000..324fae63afadf317f6e71635c874cbfb724eef45 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isImmutable.js @@ -0,0 +1,21 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isImmutable; +var _isType = require("./isType.js"); +var _index = require("./generated/index.js"); +function isImmutable(node) { + if ((0, _isType.default)(node.type, "Immutable")) return true; + if ((0, _index.isIdentifier)(node)) { + if (node.name === "undefined") { + return true; + } else { + return false; + } + } + return false; +} + +//# sourceMappingURL=isImmutable.js.map diff --git a/scripts/node_modules/@babel/types/lib/validators/isImmutable.js.map b/scripts/node_modules/@babel/types/lib/validators/isImmutable.js.map new file mode 100644 index 0000000000000000000000000000000000000000..023471001e234872452435cb17aa81a194274d3c --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isImmutable.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_isType","require","_index","isImmutable","node","isType","type","isIdentifier","name"],"sources":["../../src/validators/isImmutable.ts"],"sourcesContent":["import isType from \"./isType.ts\";\nimport { isIdentifier } from \"./generated/index.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Check if the input `node` is definitely immutable.\n */\nexport default function isImmutable(node: t.Node): boolean {\n if (isType(node.type, \"Immutable\")) return true;\n\n if (isIdentifier(node)) {\n if (node.name === \"undefined\") {\n // immutable!\n return true;\n } else {\n // no idea...\n return false;\n }\n }\n\n return false;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AAMe,SAASE,WAAWA,CAACC,IAAY,EAAW;EACzD,IAAI,IAAAC,eAAM,EAACD,IAAI,CAACE,IAAI,EAAE,WAAW,CAAC,EAAE,OAAO,IAAI;EAE/C,IAAI,IAAAC,mBAAY,EAACH,IAAI,CAAC,EAAE;IACtB,IAAIA,IAAI,CAACI,IAAI,KAAK,WAAW,EAAE;MAE7B,OAAO,IAAI;IACb,CAAC,MAAM;MAEL,OAAO,KAAK;IACd;EACF;EAEA,OAAO,KAAK;AACd","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/validators/isLet.js b/scripts/node_modules/@babel/types/lib/validators/isLet.js new file mode 100644 index 0000000000000000000000000000000000000000..be1906e0432569112e0593666e88a34803f76945 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isLet.js @@ -0,0 +1,13 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isLet; +var _index = require("./generated/index.js"); +var BLOCK_SCOPED_SYMBOL = Symbol.for("var used to be block scoped"); +function isLet(node) { + return (0, _index.isVariableDeclaration)(node) && (node.kind !== "var" || node[BLOCK_SCOPED_SYMBOL]); +} + +//# sourceMappingURL=isLet.js.map diff --git a/scripts/node_modules/@babel/types/lib/validators/isLet.js.map b/scripts/node_modules/@babel/types/lib/validators/isLet.js.map new file mode 100644 index 0000000000000000000000000000000000000000..1524938103b0006756956a151612b70e4e631be0 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isLet.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_index","require","BLOCK_SCOPED_SYMBOL","Symbol","for","isLet","node","isVariableDeclaration","kind"],"sources":["../../src/validators/isLet.ts"],"sourcesContent":["import { isVariableDeclaration } from \"./generated/index.ts\";\nimport type * as t from \"../index.ts\";\n\nif (!process.env.BABEL_8_BREAKING) {\n // eslint-disable-next-line no-var\n var BLOCK_SCOPED_SYMBOL = Symbol.for(\"var used to be block scoped\");\n}\n\n/**\n * Check if the input `node` is a `let` variable declaration.\n */\nexport default function isLet(node: t.Node): boolean {\n if (process.env.BABEL_8_BREAKING) {\n return isVariableDeclaration(node) && node.kind !== \"var\";\n } else {\n return (\n isVariableDeclaration(node) &&\n (node.kind !== \"var\" ||\n // @ts-expect-error Fixme: document private properties\n node[BLOCK_SCOPED_SYMBOL])\n );\n }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAKE,IAAIC,mBAAmB,GAAGC,MAAM,CAACC,GAAG,CAAC,6BAA6B,CAAC;AAMtD,SAASC,KAAKA,CAACC,IAAY,EAAW;EAIjD,OACE,IAAAC,4BAAqB,EAACD,IAAI,CAAC,KAC1BA,IAAI,CAACE,IAAI,KAAK,KAAK,IAElBF,IAAI,CAACJ,mBAAmB,CAAC,CAAC;AAGlC","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/validators/isNode.js b/scripts/node_modules/@babel/types/lib/validators/isNode.js new file mode 100644 index 0000000000000000000000000000000000000000..d80ce74a5c948b7cb55cc8906f6eb59a414d8b78 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isNode.js @@ -0,0 +1,12 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isNode; +var _index = require("../definitions/index.js"); +function isNode(node) { + return !!(node && _index.VISITOR_KEYS[node.type]); +} + +//# sourceMappingURL=isNode.js.map diff --git a/scripts/node_modules/@babel/types/lib/validators/isNode.js.map b/scripts/node_modules/@babel/types/lib/validators/isNode.js.map new file mode 100644 index 0000000000000000000000000000000000000000..0577fec29a059c83aaff50c37d7c4b5f1bce710b --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isNode.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_index","require","isNode","node","VISITOR_KEYS","type"],"sources":["../../src/validators/isNode.ts"],"sourcesContent":["import { VISITOR_KEYS } from \"../definitions/index.ts\";\nimport type * as t from \"../index.ts\";\n\nexport default function isNode(node: any): node is t.Node {\n return !!(node && VISITOR_KEYS[node.type]);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAGe,SAASC,MAAMA,CAACC,IAAS,EAAkB;EACxD,OAAO,CAAC,EAAEA,IAAI,IAAIC,mBAAY,CAACD,IAAI,CAACE,IAAI,CAAC,CAAC;AAC5C","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/validators/isNodesEquivalent.js b/scripts/node_modules/@babel/types/lib/validators/isNodesEquivalent.js new file mode 100644 index 0000000000000000000000000000000000000000..fc399028b439f21af0bb078e2be68078981405fb --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isNodesEquivalent.js @@ -0,0 +1,57 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isNodesEquivalent; +var _index = require("../definitions/index.js"); +function isNodesEquivalent(a, b) { + if (typeof a !== "object" || typeof b !== "object" || a == null || b == null) { + return a === b; + } + if (a.type !== b.type) { + return false; + } + const fields = Object.keys(_index.NODE_FIELDS[a.type] || a.type); + const visitorKeys = _index.VISITOR_KEYS[a.type]; + for (const field of fields) { + const val_a = a[field]; + const val_b = b[field]; + if (typeof val_a !== typeof val_b) { + return false; + } + if (val_a == null && val_b == null) { + continue; + } else if (val_a == null || val_b == null) { + return false; + } + if (Array.isArray(val_a)) { + if (!Array.isArray(val_b)) { + return false; + } + if (val_a.length !== val_b.length) { + return false; + } + for (let i = 0; i < val_a.length; i++) { + if (!isNodesEquivalent(val_a[i], val_b[i])) { + return false; + } + } + continue; + } + if (typeof val_a === "object" && !(visitorKeys != null && visitorKeys.includes(field))) { + for (const key of Object.keys(val_a)) { + if (val_a[key] !== val_b[key]) { + return false; + } + } + continue; + } + if (!isNodesEquivalent(val_a, val_b)) { + return false; + } + } + return true; +} + +//# sourceMappingURL=isNodesEquivalent.js.map diff --git a/scripts/node_modules/@babel/types/lib/validators/isNodesEquivalent.js.map b/scripts/node_modules/@babel/types/lib/validators/isNodesEquivalent.js.map new file mode 100644 index 0000000000000000000000000000000000000000..c718316dd28e04763df589a07deb2e01678c6dec --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isNodesEquivalent.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_index","require","isNodesEquivalent","a","b","type","fields","Object","keys","NODE_FIELDS","visitorKeys","VISITOR_KEYS","field","val_a","val_b","Array","isArray","length","i","includes","key"],"sources":["../../src/validators/isNodesEquivalent.ts"],"sourcesContent":["import { NODE_FIELDS, VISITOR_KEYS } from \"../definitions/index.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Check if two nodes are equivalent\n */\nexport default function isNodesEquivalent>(\n a: T,\n b: any,\n): b is T {\n if (\n typeof a !== \"object\" ||\n typeof b !== \"object\" ||\n a == null ||\n b == null\n ) {\n return a === b;\n }\n\n if (a.type !== b.type) {\n return false;\n }\n\n const fields = Object.keys(NODE_FIELDS[a.type] || a.type);\n const visitorKeys = VISITOR_KEYS[a.type];\n\n for (const field of fields) {\n const val_a =\n // @ts-expect-error field must present in a\n a[field];\n const val_b = b[field];\n if (typeof val_a !== typeof val_b) {\n return false;\n }\n if (val_a == null && val_b == null) {\n continue;\n } else if (val_a == null || val_b == null) {\n return false;\n }\n\n if (Array.isArray(val_a)) {\n if (!Array.isArray(val_b)) {\n return false;\n }\n if (val_a.length !== val_b.length) {\n return false;\n }\n\n for (let i = 0; i < val_a.length; i++) {\n if (!isNodesEquivalent(val_a[i], val_b[i])) {\n return false;\n }\n }\n continue;\n }\n\n if (typeof val_a === \"object\" && !visitorKeys?.includes(field)) {\n for (const key of Object.keys(val_a)) {\n if (val_a[key] !== val_b[key]) {\n return false;\n }\n }\n continue;\n }\n\n if (!isNodesEquivalent(val_a, val_b)) {\n return false;\n }\n }\n\n return true;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAMe,SAASC,iBAAiBA,CACvCC,CAAI,EACJC,CAAM,EACE;EACR,IACE,OAAOD,CAAC,KAAK,QAAQ,IACrB,OAAOC,CAAC,KAAK,QAAQ,IACrBD,CAAC,IAAI,IAAI,IACTC,CAAC,IAAI,IAAI,EACT;IACA,OAAOD,CAAC,KAAKC,CAAC;EAChB;EAEA,IAAID,CAAC,CAACE,IAAI,KAAKD,CAAC,CAACC,IAAI,EAAE;IACrB,OAAO,KAAK;EACd;EAEA,MAAMC,MAAM,GAAGC,MAAM,CAACC,IAAI,CAACC,kBAAW,CAACN,CAAC,CAACE,IAAI,CAAC,IAAIF,CAAC,CAACE,IAAI,CAAC;EACzD,MAAMK,WAAW,GAAGC,mBAAY,CAACR,CAAC,CAACE,IAAI,CAAC;EAExC,KAAK,MAAMO,KAAK,IAAIN,MAAM,EAAE;IAC1B,MAAMO,KAAK,GAETV,CAAC,CAACS,KAAK,CAAC;IACV,MAAME,KAAK,GAAGV,CAAC,CAACQ,KAAK,CAAC;IACtB,IAAI,OAAOC,KAAK,KAAK,OAAOC,KAAK,EAAE;MACjC,OAAO,KAAK;IACd;IACA,IAAID,KAAK,IAAI,IAAI,IAAIC,KAAK,IAAI,IAAI,EAAE;MAClC;IACF,CAAC,MAAM,IAAID,KAAK,IAAI,IAAI,IAAIC,KAAK,IAAI,IAAI,EAAE;MACzC,OAAO,KAAK;IACd;IAEA,IAAIC,KAAK,CAACC,OAAO,CAACH,KAAK,CAAC,EAAE;MACxB,IAAI,CAACE,KAAK,CAACC,OAAO,CAACF,KAAK,CAAC,EAAE;QACzB,OAAO,KAAK;MACd;MACA,IAAID,KAAK,CAACI,MAAM,KAAKH,KAAK,CAACG,MAAM,EAAE;QACjC,OAAO,KAAK;MACd;MAEA,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGL,KAAK,CAACI,MAAM,EAAEC,CAAC,EAAE,EAAE;QACrC,IAAI,CAAChB,iBAAiB,CAACW,KAAK,CAACK,CAAC,CAAC,EAAEJ,KAAK,CAACI,CAAC,CAAC,CAAC,EAAE;UAC1C,OAAO,KAAK;QACd;MACF;MACA;IACF;IAEA,IAAI,OAAOL,KAAK,KAAK,QAAQ,IAAI,EAACH,WAAW,YAAXA,WAAW,CAAES,QAAQ,CAACP,KAAK,CAAC,GAAE;MAC9D,KAAK,MAAMQ,GAAG,IAAIb,MAAM,CAACC,IAAI,CAACK,KAAK,CAAC,EAAE;QACpC,IAAIA,KAAK,CAACO,GAAG,CAAC,KAAKN,KAAK,CAACM,GAAG,CAAC,EAAE;UAC7B,OAAO,KAAK;QACd;MACF;MACA;IACF;IAEA,IAAI,CAAClB,iBAAiB,CAACW,KAAK,EAAEC,KAAK,CAAC,EAAE;MACpC,OAAO,KAAK;IACd;EACF;EAEA,OAAO,IAAI;AACb","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/validators/isPlaceholderType.js b/scripts/node_modules/@babel/types/lib/validators/isPlaceholderType.js new file mode 100644 index 0000000000000000000000000000000000000000..023bff16dbdeebeea06ca94c823aee639bb4b20e --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isPlaceholderType.js @@ -0,0 +1,15 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isPlaceholderType; +var _index = require("../definitions/index.js"); +function isPlaceholderType(placeholderType, targetType) { + if (placeholderType === targetType) return true; + const aliases = _index.PLACEHOLDERS_ALIAS[placeholderType]; + if (aliases != null && aliases.includes(targetType)) return true; + return false; +} + +//# sourceMappingURL=isPlaceholderType.js.map diff --git a/scripts/node_modules/@babel/types/lib/validators/isPlaceholderType.js.map b/scripts/node_modules/@babel/types/lib/validators/isPlaceholderType.js.map new file mode 100644 index 0000000000000000000000000000000000000000..beab534edcb7e8462cc2c0641034aec19ac4eae8 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isPlaceholderType.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_index","require","isPlaceholderType","placeholderType","targetType","aliases","PLACEHOLDERS_ALIAS","includes"],"sources":["../../src/validators/isPlaceholderType.ts"],"sourcesContent":["import { PLACEHOLDERS_ALIAS } from \"../definitions/index.ts\";\n\n/**\n * Test if a `placeholderType` is a `targetType` or if `targetType` is an alias of `placeholderType`.\n */\nexport default function isPlaceholderType(\n placeholderType: string,\n targetType: string,\n): boolean {\n if (placeholderType === targetType) return true;\n\n const aliases: string[] | undefined = PLACEHOLDERS_ALIAS[placeholderType];\n if (aliases?.includes(targetType)) return true;\n\n return false;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAKe,SAASC,iBAAiBA,CACvCC,eAAuB,EACvBC,UAAkB,EACT;EACT,IAAID,eAAe,KAAKC,UAAU,EAAE,OAAO,IAAI;EAE/C,MAAMC,OAA6B,GAAGC,yBAAkB,CAACH,eAAe,CAAC;EACzE,IAAIE,OAAO,YAAPA,OAAO,CAAEE,QAAQ,CAACH,UAAU,CAAC,EAAE,OAAO,IAAI;EAE9C,OAAO,KAAK;AACd","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/validators/isReferenced.js b/scripts/node_modules/@babel/types/lib/validators/isReferenced.js new file mode 100644 index 0000000000000000000000000000000000000000..b2718d77b9ab034c8e65b8b6389ffda1d529088c --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isReferenced.js @@ -0,0 +1,96 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isReferenced; +function isReferenced(node, parent, grandparent) { + switch (parent.type) { + case "MemberExpression": + case "OptionalMemberExpression": + if (parent.property === node) { + return !!parent.computed; + } + return parent.object === node; + case "JSXMemberExpression": + return parent.object === node; + case "VariableDeclarator": + return parent.init === node; + case "ArrowFunctionExpression": + return parent.body === node; + case "PrivateName": + return false; + case "ClassMethod": + case "ClassPrivateMethod": + case "ObjectMethod": + if (parent.key === node) { + return !!parent.computed; + } + return false; + case "ObjectProperty": + if (parent.key === node) { + return !!parent.computed; + } + return (grandparent == null ? void 0 : grandparent.type) !== "ObjectPattern"; + case "ClassProperty": + case "ClassAccessorProperty": + if (parent.key === node) { + return !!parent.computed; + } + return true; + case "ClassPrivateProperty": + return parent.key !== node; + case "ClassDeclaration": + case "ClassExpression": + return parent.superClass === node; + case "AssignmentExpression": + return parent.right === node; + case "AssignmentPattern": + return parent.right === node; + case "LabeledStatement": + return false; + case "CatchClause": + return false; + case "RestElement": + return false; + case "BreakStatement": + case "ContinueStatement": + return false; + case "FunctionDeclaration": + case "FunctionExpression": + return false; + case "ExportNamespaceSpecifier": + case "ExportDefaultSpecifier": + return false; + case "ExportSpecifier": + if (grandparent != null && grandparent.source) { + return false; + } + return parent.local === node; + case "ImportDefaultSpecifier": + case "ImportNamespaceSpecifier": + case "ImportSpecifier": + return false; + case "ImportAttribute": + return false; + case "JSXAttribute": + return false; + case "ObjectPattern": + case "ArrayPattern": + return false; + case "MetaProperty": + return false; + case "ObjectTypeProperty": + return parent.key !== node; + case "TSEnumMember": + return parent.id !== node; + case "TSPropertySignature": + if (parent.key === node) { + return !!parent.computed; + } + return true; + } + return true; +} + +//# sourceMappingURL=isReferenced.js.map diff --git a/scripts/node_modules/@babel/types/lib/validators/isReferenced.js.map b/scripts/node_modules/@babel/types/lib/validators/isReferenced.js.map new file mode 100644 index 0000000000000000000000000000000000000000..16b12f43ee9c18dc2923570f9a39537311864da6 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isReferenced.js.map @@ -0,0 +1 @@ +{"version":3,"names":["isReferenced","node","parent","grandparent","type","property","computed","object","init","body","key","superClass","right","source","local","id"],"sources":["../../src/validators/isReferenced.ts"],"sourcesContent":["import type * as t from \"../index.ts\";\n\n/**\n * Check if the input `node` is a reference to a bound variable.\n */\nexport default function isReferenced(\n node: t.Node | null | undefined,\n parent: t.Node,\n grandparent?: t.Node,\n): boolean {\n switch (parent.type) {\n // yes: PARENT[NODE]\n // yes: NODE.child\n // no: parent.NODE\n case \"MemberExpression\":\n case \"OptionalMemberExpression\":\n if (parent.property === node) {\n return !!parent.computed;\n }\n return parent.object === node;\n\n case \"JSXMemberExpression\":\n return parent.object === node;\n // no: let NODE = init;\n // yes: let id = NODE;\n case \"VariableDeclarator\":\n return parent.init === node;\n\n // yes: () => NODE\n // no: (NODE) => {}\n case \"ArrowFunctionExpression\":\n return parent.body === node;\n\n // no: class { #NODE; }\n // no: class { get #NODE() {} }\n // no: class { #NODE() {} }\n // no: class { fn() { return this.#NODE; } }\n case \"PrivateName\":\n return false;\n\n // no: class { NODE() {} }\n // yes: class { [NODE]() {} }\n // no: class { foo(NODE) {} }\n case \"ClassMethod\":\n case \"ClassPrivateMethod\":\n case \"ObjectMethod\":\n if (parent.key === node) {\n return !!parent.computed;\n }\n return false;\n\n // yes: { [NODE]: \"\" }\n // no: { NODE: \"\" }\n // depends: { NODE }\n // depends: { key: NODE }\n case \"ObjectProperty\":\n if (parent.key === node) {\n return !!parent.computed;\n }\n // parent.value === node\n return grandparent?.type !== \"ObjectPattern\";\n // no: class { NODE = value; }\n // yes: class { [NODE] = value; }\n // yes: class { key = NODE; }\n case \"ClassProperty\":\n case \"ClassAccessorProperty\":\n if (parent.key === node) {\n return !!parent.computed;\n }\n return true;\n case \"ClassPrivateProperty\":\n return parent.key !== node;\n\n // no: class NODE {}\n // yes: class Foo extends NODE {}\n case \"ClassDeclaration\":\n case \"ClassExpression\":\n return parent.superClass === node;\n\n // yes: left = NODE;\n // no: NODE = right;\n case \"AssignmentExpression\":\n return parent.right === node;\n\n // no: [NODE = foo] = [];\n // yes: [foo = NODE] = [];\n case \"AssignmentPattern\":\n return parent.right === node;\n\n // no: NODE: for (;;) {}\n case \"LabeledStatement\":\n return false;\n\n // no: try {} catch (NODE) {}\n case \"CatchClause\":\n return false;\n\n // no: function foo(...NODE) {}\n case \"RestElement\":\n return false;\n\n case \"BreakStatement\":\n case \"ContinueStatement\":\n return false;\n\n // no: function NODE() {}\n // no: function foo(NODE) {}\n case \"FunctionDeclaration\":\n case \"FunctionExpression\":\n return false;\n\n // no: export NODE from \"foo\";\n // no: export * as NODE from \"foo\";\n case \"ExportNamespaceSpecifier\":\n case \"ExportDefaultSpecifier\":\n return false;\n\n // no: export { foo as NODE };\n // yes: export { NODE as foo };\n // no: export { NODE as foo } from \"foo\";\n case \"ExportSpecifier\":\n // @ts-expect-error todo(flow->ts): Property 'source' does not exist on type 'AnyTypeAnnotation'.\n if (grandparent?.source) {\n return false;\n }\n return parent.local === node;\n\n // no: import NODE from \"foo\";\n // no: import * as NODE from \"foo\";\n // no: import { NODE as foo } from \"foo\";\n // no: import { foo as NODE } from \"foo\";\n // no: import NODE from \"bar\";\n case \"ImportDefaultSpecifier\":\n case \"ImportNamespaceSpecifier\":\n case \"ImportSpecifier\":\n return false;\n\n // no: import \"foo\" assert { NODE: \"json\" }\n case \"ImportAttribute\":\n return false;\n\n // no:

\n case \"JSXAttribute\":\n return false;\n\n // no: [NODE] = [];\n // no: ({ NODE }) = [];\n case \"ObjectPattern\":\n case \"ArrayPattern\":\n return false;\n\n // no: new.NODE\n // no: NODE.target\n case \"MetaProperty\":\n return false;\n\n // yes: type X = { someProperty: NODE }\n // no: type X = { NODE: OtherType }\n case \"ObjectTypeProperty\":\n return parent.key !== node;\n\n // yes: enum X { Foo = NODE }\n // no: enum X { NODE }\n case \"TSEnumMember\":\n return parent.id !== node;\n\n // yes: { [NODE]: value }\n // no: { NODE: value }\n case \"TSPropertySignature\":\n if (parent.key === node) {\n return !!parent.computed;\n }\n\n return true;\n }\n\n return true;\n}\n"],"mappings":";;;;;;AAKe,SAASA,YAAYA,CAClCC,IAA+B,EAC/BC,MAAc,EACdC,WAAoB,EACX;EACT,QAAQD,MAAM,CAACE,IAAI;IAIjB,KAAK,kBAAkB;IACvB,KAAK,0BAA0B;MAC7B,IAAIF,MAAM,CAACG,QAAQ,KAAKJ,IAAI,EAAE;QAC5B,OAAO,CAAC,CAACC,MAAM,CAACI,QAAQ;MAC1B;MACA,OAAOJ,MAAM,CAACK,MAAM,KAAKN,IAAI;IAE/B,KAAK,qBAAqB;MACxB,OAAOC,MAAM,CAACK,MAAM,KAAKN,IAAI;IAG/B,KAAK,oBAAoB;MACvB,OAAOC,MAAM,CAACM,IAAI,KAAKP,IAAI;IAI7B,KAAK,yBAAyB;MAC5B,OAAOC,MAAM,CAACO,IAAI,KAAKR,IAAI;IAM7B,KAAK,aAAa;MAChB,OAAO,KAAK;IAKd,KAAK,aAAa;IAClB,KAAK,oBAAoB;IACzB,KAAK,cAAc;MACjB,IAAIC,MAAM,CAACQ,GAAG,KAAKT,IAAI,EAAE;QACvB,OAAO,CAAC,CAACC,MAAM,CAACI,QAAQ;MAC1B;MACA,OAAO,KAAK;IAMd,KAAK,gBAAgB;MACnB,IAAIJ,MAAM,CAACQ,GAAG,KAAKT,IAAI,EAAE;QACvB,OAAO,CAAC,CAACC,MAAM,CAACI,QAAQ;MAC1B;MAEA,OAAO,CAAAH,WAAW,oBAAXA,WAAW,CAAEC,IAAI,MAAK,eAAe;IAI9C,KAAK,eAAe;IACpB,KAAK,uBAAuB;MAC1B,IAAIF,MAAM,CAACQ,GAAG,KAAKT,IAAI,EAAE;QACvB,OAAO,CAAC,CAACC,MAAM,CAACI,QAAQ;MAC1B;MACA,OAAO,IAAI;IACb,KAAK,sBAAsB;MACzB,OAAOJ,MAAM,CAACQ,GAAG,KAAKT,IAAI;IAI5B,KAAK,kBAAkB;IACvB,KAAK,iBAAiB;MACpB,OAAOC,MAAM,CAACS,UAAU,KAAKV,IAAI;IAInC,KAAK,sBAAsB;MACzB,OAAOC,MAAM,CAACU,KAAK,KAAKX,IAAI;IAI9B,KAAK,mBAAmB;MACtB,OAAOC,MAAM,CAACU,KAAK,KAAKX,IAAI;IAG9B,KAAK,kBAAkB;MACrB,OAAO,KAAK;IAGd,KAAK,aAAa;MAChB,OAAO,KAAK;IAGd,KAAK,aAAa;MAChB,OAAO,KAAK;IAEd,KAAK,gBAAgB;IACrB,KAAK,mBAAmB;MACtB,OAAO,KAAK;IAId,KAAK,qBAAqB;IAC1B,KAAK,oBAAoB;MACvB,OAAO,KAAK;IAId,KAAK,0BAA0B;IAC/B,KAAK,wBAAwB;MAC3B,OAAO,KAAK;IAKd,KAAK,iBAAiB;MAEpB,IAAIE,WAAW,YAAXA,WAAW,CAAEU,MAAM,EAAE;QACvB,OAAO,KAAK;MACd;MACA,OAAOX,MAAM,CAACY,KAAK,KAAKb,IAAI;IAO9B,KAAK,wBAAwB;IAC7B,KAAK,0BAA0B;IAC/B,KAAK,iBAAiB;MACpB,OAAO,KAAK;IAGd,KAAK,iBAAiB;MACpB,OAAO,KAAK;IAGd,KAAK,cAAc;MACjB,OAAO,KAAK;IAId,KAAK,eAAe;IACpB,KAAK,cAAc;MACjB,OAAO,KAAK;IAId,KAAK,cAAc;MACjB,OAAO,KAAK;IAId,KAAK,oBAAoB;MACvB,OAAOC,MAAM,CAACQ,GAAG,KAAKT,IAAI;IAI5B,KAAK,cAAc;MACjB,OAAOC,MAAM,CAACa,EAAE,KAAKd,IAAI;IAI3B,KAAK,qBAAqB;MACxB,IAAIC,MAAM,CAACQ,GAAG,KAAKT,IAAI,EAAE;QACvB,OAAO,CAAC,CAACC,MAAM,CAACI,QAAQ;MAC1B;MAEA,OAAO,IAAI;EACf;EAEA,OAAO,IAAI;AACb","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/validators/isScope.js b/scripts/node_modules/@babel/types/lib/validators/isScope.js new file mode 100644 index 0000000000000000000000000000000000000000..40b5dc28ee41b89f69610e411d4bec455943ea54 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isScope.js @@ -0,0 +1,18 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isScope; +var _index = require("./generated/index.js"); +function isScope(node, parent) { + if ((0, _index.isBlockStatement)(node) && ((0, _index.isFunction)(parent) || (0, _index.isCatchClause)(parent))) { + return false; + } + if ((0, _index.isPattern)(node) && ((0, _index.isFunction)(parent) || (0, _index.isCatchClause)(parent))) { + return true; + } + return (0, _index.isScopable)(node); +} + +//# sourceMappingURL=isScope.js.map diff --git a/scripts/node_modules/@babel/types/lib/validators/isScope.js.map b/scripts/node_modules/@babel/types/lib/validators/isScope.js.map new file mode 100644 index 0000000000000000000000000000000000000000..7f8a243fdefea1fda366cf956583016d8548ada3 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isScope.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_index","require","isScope","node","parent","isBlockStatement","isFunction","isCatchClause","isPattern","isScopable"],"sources":["../../src/validators/isScope.ts"],"sourcesContent":["import {\n isFunction,\n isCatchClause,\n isBlockStatement,\n isScopable,\n isPattern,\n} from \"./generated/index.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Check if the input `node` is a scope.\n */\nexport default function isScope(\n node: t.Node | null | undefined,\n parent: t.Node,\n): boolean {\n // If a BlockStatement is an immediate descendent of a Function/CatchClause, it must be in the body.\n // Hence we skipped the parentKey === \"params\" check\n if (isBlockStatement(node) && (isFunction(parent) || isCatchClause(parent))) {\n return false;\n }\n\n // If a Pattern is an immediate descendent of a Function/CatchClause, it must be in the params.\n // Hence we skipped the parentKey === \"params\" check\n if (isPattern(node) && (isFunction(parent) || isCatchClause(parent))) {\n return true;\n }\n\n return isScopable(node);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAYe,SAASC,OAAOA,CAC7BC,IAA+B,EAC/BC,MAAc,EACL;EAGT,IAAI,IAAAC,uBAAgB,EAACF,IAAI,CAAC,KAAK,IAAAG,iBAAU,EAACF,MAAM,CAAC,IAAI,IAAAG,oBAAa,EAACH,MAAM,CAAC,CAAC,EAAE;IAC3E,OAAO,KAAK;EACd;EAIA,IAAI,IAAAI,gBAAS,EAACL,IAAI,CAAC,KAAK,IAAAG,iBAAU,EAACF,MAAM,CAAC,IAAI,IAAAG,oBAAa,EAACH,MAAM,CAAC,CAAC,EAAE;IACpE,OAAO,IAAI;EACb;EAEA,OAAO,IAAAK,iBAAU,EAACN,IAAI,CAAC;AACzB","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/validators/isSpecifierDefault.js b/scripts/node_modules/@babel/types/lib/validators/isSpecifierDefault.js new file mode 100644 index 0000000000000000000000000000000000000000..fc492b1cfdaf1e8bbef82f28f8c0082e198cbc0e --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isSpecifierDefault.js @@ -0,0 +1,14 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isSpecifierDefault; +var _index = require("./generated/index.js"); +function isSpecifierDefault(specifier) { + return (0, _index.isImportDefaultSpecifier)(specifier) || (0, _index.isIdentifier)(specifier.imported || specifier.exported, { + name: "default" + }); +} + +//# sourceMappingURL=isSpecifierDefault.js.map diff --git a/scripts/node_modules/@babel/types/lib/validators/isSpecifierDefault.js.map b/scripts/node_modules/@babel/types/lib/validators/isSpecifierDefault.js.map new file mode 100644 index 0000000000000000000000000000000000000000..eefd1b0909ce1aa49d72890e7471a6d005ee4e84 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isSpecifierDefault.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_index","require","isSpecifierDefault","specifier","isImportDefaultSpecifier","isIdentifier","imported","exported","name"],"sources":["../../src/validators/isSpecifierDefault.ts"],"sourcesContent":["import { isIdentifier, isImportDefaultSpecifier } from \"./generated/index.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Check if the input `specifier` is a `default` import or export.\n */\nexport default function isSpecifierDefault(\n specifier: t.ModuleSpecifier,\n): boolean {\n return (\n isImportDefaultSpecifier(specifier) ||\n // @ts-expect-error todo(flow->ts): stricter type for specifier\n isIdentifier(specifier.imported || specifier.exported, {\n name: \"default\",\n })\n );\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAMe,SAASC,kBAAkBA,CACxCC,SAA4B,EACnB;EACT,OACE,IAAAC,+BAAwB,EAACD,SAAS,CAAC,IAEnC,IAAAE,mBAAY,EAACF,SAAS,CAACG,QAAQ,IAAIH,SAAS,CAACI,QAAQ,EAAE;IACrDC,IAAI,EAAE;EACR,CAAC,CAAC;AAEN","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/validators/isType.js b/scripts/node_modules/@babel/types/lib/validators/isType.js new file mode 100644 index 0000000000000000000000000000000000000000..de8945ddcea89bf255a689eb3576ad1975de11ee --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isType.js @@ -0,0 +1,17 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isType; +var _index = require("../definitions/index.js"); +function isType(nodeType, targetType) { + if (nodeType === targetType) return true; + if (nodeType == null) return false; + if (_index.ALIAS_KEYS[targetType]) return false; + const aliases = _index.FLIPPED_ALIAS_KEYS[targetType]; + if (aliases != null && aliases.includes(nodeType)) return true; + return false; +} + +//# sourceMappingURL=isType.js.map diff --git a/scripts/node_modules/@babel/types/lib/validators/isType.js.map b/scripts/node_modules/@babel/types/lib/validators/isType.js.map new file mode 100644 index 0000000000000000000000000000000000000000..642ee4c9126454794b18cee36f51d6c68f26a495 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isType.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_index","require","isType","nodeType","targetType","ALIAS_KEYS","aliases","FLIPPED_ALIAS_KEYS","includes"],"sources":["../../src/validators/isType.ts"],"sourcesContent":["import { FLIPPED_ALIAS_KEYS, ALIAS_KEYS } from \"../definitions/index.ts\";\nimport type * as t from \"../index.ts\";\n\nexport default function isType(\n nodeType: string,\n targetType: T,\n): nodeType is T;\n\nexport default function isType(\n nodeType: string | null | undefined,\n targetType: string,\n): boolean;\n\n/**\n * Test if a `nodeType` is a `targetType` or if `targetType` is an alias of `nodeType`.\n */\nexport default function isType(nodeType: string, targetType: string): boolean {\n if (nodeType === targetType) return true;\n\n // If nodeType is nullish, it can't be an alias of targetType.\n if (nodeType == null) return false;\n\n // This is a fast-path. If the test above failed, but an alias key is found, then the\n // targetType was a primary node type, so there's no need to check the aliases.\n // @ts-expect-error targetType may not index ALIAS_KEYS\n if (ALIAS_KEYS[targetType]) return false;\n\n const aliases: string[] | undefined = FLIPPED_ALIAS_KEYS[targetType];\n if (aliases?.includes(nodeType)) return true;\n\n return false;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAgBe,SAASC,MAAMA,CAACC,QAAgB,EAAEC,UAAkB,EAAW;EAC5E,IAAID,QAAQ,KAAKC,UAAU,EAAE,OAAO,IAAI;EAGxC,IAAID,QAAQ,IAAI,IAAI,EAAE,OAAO,KAAK;EAKlC,IAAIE,iBAAU,CAACD,UAAU,CAAC,EAAE,OAAO,KAAK;EAExC,MAAME,OAA6B,GAAGC,yBAAkB,CAACH,UAAU,CAAC;EACpE,IAAIE,OAAO,YAAPA,OAAO,CAAEE,QAAQ,CAACL,QAAQ,CAAC,EAAE,OAAO,IAAI;EAE5C,OAAO,KAAK;AACd","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/validators/isValidES3Identifier.js b/scripts/node_modules/@babel/types/lib/validators/isValidES3Identifier.js new file mode 100644 index 0000000000000000000000000000000000000000..08c7d0ab1236b534f4aa5429711c3221323cd8b8 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isValidES3Identifier.js @@ -0,0 +1,13 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isValidES3Identifier; +var _isValidIdentifier = require("./isValidIdentifier.js"); +const RESERVED_WORDS_ES3_ONLY = new Set(["abstract", "boolean", "byte", "char", "double", "enum", "final", "float", "goto", "implements", "int", "interface", "long", "native", "package", "private", "protected", "public", "short", "static", "synchronized", "throws", "transient", "volatile"]); +function isValidES3Identifier(name) { + return (0, _isValidIdentifier.default)(name) && !RESERVED_WORDS_ES3_ONLY.has(name); +} + +//# sourceMappingURL=isValidES3Identifier.js.map diff --git a/scripts/node_modules/@babel/types/lib/validators/isValidES3Identifier.js.map b/scripts/node_modules/@babel/types/lib/validators/isValidES3Identifier.js.map new file mode 100644 index 0000000000000000000000000000000000000000..b864009a15323f9496672048335aa6529cdf8cde --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isValidES3Identifier.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_isValidIdentifier","require","RESERVED_WORDS_ES3_ONLY","Set","isValidES3Identifier","name","isValidIdentifier","has"],"sources":["../../src/validators/isValidES3Identifier.ts"],"sourcesContent":["import isValidIdentifier from \"./isValidIdentifier.ts\";\n\nconst RESERVED_WORDS_ES3_ONLY = new Set([\n \"abstract\",\n \"boolean\",\n \"byte\",\n \"char\",\n \"double\",\n \"enum\",\n \"final\",\n \"float\",\n \"goto\",\n \"implements\",\n \"int\",\n \"interface\",\n \"long\",\n \"native\",\n \"package\",\n \"private\",\n \"protected\",\n \"public\",\n \"short\",\n \"static\",\n \"synchronized\",\n \"throws\",\n \"transient\",\n \"volatile\",\n]);\n\n/**\n * Check if the input `name` is a valid identifier name according to the ES3 specification.\n *\n * Additional ES3 reserved words are\n */\nexport default function isValidES3Identifier(name: string): boolean {\n return isValidIdentifier(name) && !RESERVED_WORDS_ES3_ONLY.has(name);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,kBAAA,GAAAC,OAAA;AAEA,MAAMC,uBAAuB,GAAG,IAAIC,GAAG,CAAS,CAC9C,UAAU,EACV,SAAS,EACT,MAAM,EACN,MAAM,EACN,QAAQ,EACR,MAAM,EACN,OAAO,EACP,OAAO,EACP,MAAM,EACN,YAAY,EACZ,KAAK,EACL,WAAW,EACX,MAAM,EACN,QAAQ,EACR,SAAS,EACT,SAAS,EACT,WAAW,EACX,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,cAAc,EACd,QAAQ,EACR,WAAW,EACX,UAAU,CACX,CAAC;AAOa,SAASC,oBAAoBA,CAACC,IAAY,EAAW;EAClE,OAAO,IAAAC,0BAAiB,EAACD,IAAI,CAAC,IAAI,CAACH,uBAAuB,CAACK,GAAG,CAACF,IAAI,CAAC;AACtE","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/validators/isValidIdentifier.js b/scripts/node_modules/@babel/types/lib/validators/isValidIdentifier.js new file mode 100644 index 0000000000000000000000000000000000000000..b8674b5d680cfdf65a34ccba33b24eadba474989 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isValidIdentifier.js @@ -0,0 +1,18 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isValidIdentifier; +var _helperValidatorIdentifier = require("@babel/helper-validator-identifier"); +function isValidIdentifier(name, reserved = true) { + if (typeof name !== "string") return false; + if (reserved) { + if ((0, _helperValidatorIdentifier.isKeyword)(name) || (0, _helperValidatorIdentifier.isStrictReservedWord)(name, true)) { + return false; + } + } + return (0, _helperValidatorIdentifier.isIdentifierName)(name); +} + +//# sourceMappingURL=isValidIdentifier.js.map diff --git a/scripts/node_modules/@babel/types/lib/validators/isValidIdentifier.js.map b/scripts/node_modules/@babel/types/lib/validators/isValidIdentifier.js.map new file mode 100644 index 0000000000000000000000000000000000000000..1b595c4d3b5b648a2f8389f691f1ab346436b6d4 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isValidIdentifier.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_helperValidatorIdentifier","require","isValidIdentifier","name","reserved","isKeyword","isStrictReservedWord","isIdentifierName"],"sources":["../../src/validators/isValidIdentifier.ts"],"sourcesContent":["import {\n isIdentifierName,\n isStrictReservedWord,\n isKeyword,\n} from \"@babel/helper-validator-identifier\";\n\n/**\n * Check if the input `name` is a valid identifier name\n * and isn't a reserved word.\n */\nexport default function isValidIdentifier(\n name: string,\n reserved: boolean = true,\n): boolean {\n if (typeof name !== \"string\") return false;\n\n if (reserved) {\n // \"await\" is invalid in module, valid in script; better be safe (see #4952)\n if (isKeyword(name) || isStrictReservedWord(name, true)) {\n return false;\n }\n }\n\n return isIdentifierName(name);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,0BAAA,GAAAC,OAAA;AAUe,SAASC,iBAAiBA,CACvCC,IAAY,EACZC,QAAiB,GAAG,IAAI,EACf;EACT,IAAI,OAAOD,IAAI,KAAK,QAAQ,EAAE,OAAO,KAAK;EAE1C,IAAIC,QAAQ,EAAE;IAEZ,IAAI,IAAAC,oCAAS,EAACF,IAAI,CAAC,IAAI,IAAAG,+CAAoB,EAACH,IAAI,EAAE,IAAI,CAAC,EAAE;MACvD,OAAO,KAAK;IACd;EACF;EAEA,OAAO,IAAAI,2CAAgB,EAACJ,IAAI,CAAC;AAC/B","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/validators/isVar.js b/scripts/node_modules/@babel/types/lib/validators/isVar.js new file mode 100644 index 0000000000000000000000000000000000000000..3018b41a4d07a5be3d80e43872ababbdf95d3f60 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isVar.js @@ -0,0 +1,15 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isVar; +var _index = require("./generated/index.js"); +var BLOCK_SCOPED_SYMBOL = Symbol.for("var used to be block scoped"); +function isVar(node) { + return (0, _index.isVariableDeclaration)(node, { + kind: "var" + }) && !node[BLOCK_SCOPED_SYMBOL]; +} + +//# sourceMappingURL=isVar.js.map diff --git a/scripts/node_modules/@babel/types/lib/validators/isVar.js.map b/scripts/node_modules/@babel/types/lib/validators/isVar.js.map new file mode 100644 index 0000000000000000000000000000000000000000..81b3cd7d3be7e2b17de93833079c5e906f325e9d --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/isVar.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_index","require","BLOCK_SCOPED_SYMBOL","Symbol","for","isVar","node","isVariableDeclaration","kind"],"sources":["../../src/validators/isVar.ts"],"sourcesContent":["import { isVariableDeclaration } from \"./generated/index.ts\";\nimport type * as t from \"../index.ts\";\n\nif (!process.env.BABEL_8_BREAKING) {\n // eslint-disable-next-line no-var\n var BLOCK_SCOPED_SYMBOL = Symbol.for(\"var used to be block scoped\");\n}\n\n/**\n * Check if the input `node` is a variable declaration.\n */\nexport default function isVar(node: t.Node | null | undefined): boolean {\n if (process.env.BABEL_8_BREAKING) {\n return isVariableDeclaration(node) && node.kind === \"var\";\n } else {\n return (\n isVariableDeclaration(node, { kind: \"var\" }) &&\n !(\n // @ts-expect-error document private properties\n node[BLOCK_SCOPED_SYMBOL]\n )\n );\n }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAKE,IAAIC,mBAAmB,GAAGC,MAAM,CAACC,GAAG,CAAC,6BAA6B,CAAC;AAMtD,SAASC,KAAKA,CAACC,IAA+B,EAAW;EAIpE,OACE,IAAAC,4BAAqB,EAACD,IAAI,EAAE;IAAEE,IAAI,EAAE;EAAM,CAAC,CAAC,IAC5C,CAEEF,IAAI,CAACJ,mBAAmB,CACzB;AAGP","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/validators/matchesPattern.js b/scripts/node_modules/@babel/types/lib/validators/matchesPattern.js new file mode 100644 index 0000000000000000000000000000000000000000..37f0484c69d9d3e7a6058ea67b48efb19e804a83 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/matchesPattern.js @@ -0,0 +1,44 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = matchesPattern; +var _index = require("./generated/index.js"); +function isMemberExpressionLike(node) { + return (0, _index.isMemberExpression)(node) || (0, _index.isMetaProperty)(node); +} +function matchesPattern(member, match, allowPartial) { + if (!isMemberExpressionLike(member)) return false; + const parts = Array.isArray(match) ? match : match.split("."); + const nodes = []; + let node; + for (node = member; isMemberExpressionLike(node); node = (_object = node.object) != null ? _object : node.meta) { + var _object; + nodes.push(node.property); + } + nodes.push(node); + if (nodes.length < parts.length) return false; + if (!allowPartial && nodes.length > parts.length) return false; + for (let i = 0, j = nodes.length - 1; i < parts.length; i++, j--) { + const node = nodes[j]; + let value; + if ((0, _index.isIdentifier)(node)) { + value = node.name; + } else if ((0, _index.isStringLiteral)(node)) { + value = node.value; + } else if ((0, _index.isThisExpression)(node)) { + value = "this"; + } else if ((0, _index.isSuper)(node)) { + value = "super"; + } else if ((0, _index.isPrivateName)(node)) { + value = "#" + node.id.name; + } else { + return false; + } + if (parts[i] !== value) return false; + } + return true; +} + +//# sourceMappingURL=matchesPattern.js.map diff --git a/scripts/node_modules/@babel/types/lib/validators/matchesPattern.js.map b/scripts/node_modules/@babel/types/lib/validators/matchesPattern.js.map new file mode 100644 index 0000000000000000000000000000000000000000..7a9b379daf5c72b16d3b43086f80be515437b3d7 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/matchesPattern.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_index","require","isMemberExpressionLike","node","isMemberExpression","isMetaProperty","matchesPattern","member","match","allowPartial","parts","Array","isArray","split","nodes","_object","object","meta","push","property","length","i","j","value","isIdentifier","name","isStringLiteral","isThisExpression","isSuper","isPrivateName","id"],"sources":["../../src/validators/matchesPattern.ts"],"sourcesContent":["import {\n isIdentifier,\n isMetaProperty,\n isMemberExpression,\n isPrivateName,\n isStringLiteral,\n isSuper,\n isThisExpression,\n} from \"./generated/index.ts\";\nimport type * as t from \"../index.ts\";\n\nfunction isMemberExpressionLike(\n node: t.Node,\n): node is t.MemberExpression | t.MetaProperty {\n return isMemberExpression(node) || isMetaProperty(node);\n}\n\n/**\n * Determines whether or not the input node `member` matches the\n * input `match`.\n *\n * For example, given the match `React.createClass` it would match the\n * parsed nodes of `React.createClass` and `React[\"createClass\"]`.\n */\nexport default function matchesPattern(\n member: t.Node | null | undefined,\n match: string | string[],\n allowPartial?: boolean,\n): boolean {\n // not a member expression\n if (!isMemberExpressionLike(member)) return false;\n\n const parts = Array.isArray(match) ? match : match.split(\".\");\n const nodes = [];\n\n let node;\n for (\n node = member;\n isMemberExpressionLike(node);\n node = (node as t.MemberExpression).object ?? (node as t.MetaProperty).meta\n ) {\n nodes.push(node.property);\n }\n nodes.push(node);\n\n if (nodes.length < parts.length) return false;\n if (!allowPartial && nodes.length > parts.length) return false;\n\n for (let i = 0, j = nodes.length - 1; i < parts.length; i++, j--) {\n const node = nodes[j];\n let value;\n if (isIdentifier(node)) {\n value = node.name;\n } else if (isStringLiteral(node)) {\n value = node.value;\n } else if (isThisExpression(node)) {\n value = \"this\";\n } else if (isSuper(node)) {\n value = \"super\";\n } else if (isPrivateName(node)) {\n value = \"#\" + node.id.name;\n } else {\n return false;\n }\n\n if (parts[i] !== value) return false;\n }\n\n return true;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAWA,SAASC,sBAAsBA,CAC7BC,IAAY,EACiC;EAC7C,OAAO,IAAAC,yBAAkB,EAACD,IAAI,CAAC,IAAI,IAAAE,qBAAc,EAACF,IAAI,CAAC;AACzD;AASe,SAASG,cAAcA,CACpCC,MAAiC,EACjCC,KAAwB,EACxBC,YAAsB,EACb;EAET,IAAI,CAACP,sBAAsB,CAACK,MAAM,CAAC,EAAE,OAAO,KAAK;EAEjD,MAAMG,KAAK,GAAGC,KAAK,CAACC,OAAO,CAACJ,KAAK,CAAC,GAAGA,KAAK,GAAGA,KAAK,CAACK,KAAK,CAAC,GAAG,CAAC;EAC7D,MAAMC,KAAK,GAAG,EAAE;EAEhB,IAAIX,IAAI;EACR,KACEA,IAAI,GAAGI,MAAM,EACbL,sBAAsB,CAACC,IAAI,CAAC,EAC5BA,IAAI,IAAAY,OAAA,GAAIZ,IAAI,CAAwBa,MAAM,YAAAD,OAAA,GAAKZ,IAAI,CAAoBc,IAAI,EAC3E;IAAA,IAAAF,OAAA;IACAD,KAAK,CAACI,IAAI,CAACf,IAAI,CAACgB,QAAQ,CAAC;EAC3B;EACAL,KAAK,CAACI,IAAI,CAACf,IAAI,CAAC;EAEhB,IAAIW,KAAK,CAACM,MAAM,GAAGV,KAAK,CAACU,MAAM,EAAE,OAAO,KAAK;EAC7C,IAAI,CAACX,YAAY,IAAIK,KAAK,CAACM,MAAM,GAAGV,KAAK,CAACU,MAAM,EAAE,OAAO,KAAK;EAE9D,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEC,CAAC,GAAGR,KAAK,CAACM,MAAM,GAAG,CAAC,EAAEC,CAAC,GAAGX,KAAK,CAACU,MAAM,EAAEC,CAAC,EAAE,EAAEC,CAAC,EAAE,EAAE;IAChE,MAAMnB,IAAI,GAAGW,KAAK,CAACQ,CAAC,CAAC;IACrB,IAAIC,KAAK;IACT,IAAI,IAAAC,mBAAY,EAACrB,IAAI,CAAC,EAAE;MACtBoB,KAAK,GAAGpB,IAAI,CAACsB,IAAI;IACnB,CAAC,MAAM,IAAI,IAAAC,sBAAe,EAACvB,IAAI,CAAC,EAAE;MAChCoB,KAAK,GAAGpB,IAAI,CAACoB,KAAK;IACpB,CAAC,MAAM,IAAI,IAAAI,uBAAgB,EAACxB,IAAI,CAAC,EAAE;MACjCoB,KAAK,GAAG,MAAM;IAChB,CAAC,MAAM,IAAI,IAAAK,cAAO,EAACzB,IAAI,CAAC,EAAE;MACxBoB,KAAK,GAAG,OAAO;IACjB,CAAC,MAAM,IAAI,IAAAM,oBAAa,EAAC1B,IAAI,CAAC,EAAE;MAC9BoB,KAAK,GAAG,GAAG,GAAGpB,IAAI,CAAC2B,EAAE,CAACL,IAAI;IAC5B,CAAC,MAAM;MACL,OAAO,KAAK;IACd;IAEA,IAAIf,KAAK,CAACW,CAAC,CAAC,KAAKE,KAAK,EAAE,OAAO,KAAK;EACtC;EAEA,OAAO,IAAI;AACb","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/validators/react/isCompatTag.js b/scripts/node_modules/@babel/types/lib/validators/react/isCompatTag.js new file mode 100644 index 0000000000000000000000000000000000000000..868b8441a10972418b8a94f5cdb688b315320605 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/react/isCompatTag.js @@ -0,0 +1,11 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isCompatTag; +function isCompatTag(tagName) { + return !!tagName && /^[a-z]/.test(tagName); +} + +//# sourceMappingURL=isCompatTag.js.map diff --git a/scripts/node_modules/@babel/types/lib/validators/react/isCompatTag.js.map b/scripts/node_modules/@babel/types/lib/validators/react/isCompatTag.js.map new file mode 100644 index 0000000000000000000000000000000000000000..570f2863dcb0fd26678d6c05dae54fafbbe52cbc --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/react/isCompatTag.js.map @@ -0,0 +1 @@ +{"version":3,"names":["isCompatTag","tagName","test"],"sources":["../../../src/validators/react/isCompatTag.ts"],"sourcesContent":["export default function isCompatTag(tagName?: string): boolean {\n // Must start with a lowercase ASCII letter\n return !!tagName && /^[a-z]/.test(tagName);\n}\n"],"mappings":";;;;;;AAAe,SAASA,WAAWA,CAACC,OAAgB,EAAW;EAE7D,OAAO,CAAC,CAACA,OAAO,IAAI,QAAQ,CAACC,IAAI,CAACD,OAAO,CAAC;AAC5C","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/validators/react/isReactComponent.js b/scripts/node_modules/@babel/types/lib/validators/react/isReactComponent.js new file mode 100644 index 0000000000000000000000000000000000000000..34b3467250c1e51a33faf954db5ed835a42d2ac1 --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/react/isReactComponent.js @@ -0,0 +1,11 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; +var _buildMatchMemberExpression = require("../buildMatchMemberExpression.js"); +const isReactComponent = (0, _buildMatchMemberExpression.default)("React.Component"); +var _default = exports.default = isReactComponent; + +//# sourceMappingURL=isReactComponent.js.map diff --git a/scripts/node_modules/@babel/types/lib/validators/react/isReactComponent.js.map b/scripts/node_modules/@babel/types/lib/validators/react/isReactComponent.js.map new file mode 100644 index 0000000000000000000000000000000000000000..16fb3e36d4a1715a3841b0b3bf45ff1af2d1065b --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/react/isReactComponent.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_buildMatchMemberExpression","require","isReactComponent","buildMatchMemberExpression","_default","exports","default"],"sources":["../../../src/validators/react/isReactComponent.ts"],"sourcesContent":["import buildMatchMemberExpression from \"../buildMatchMemberExpression.ts\";\n\nconst isReactComponent = buildMatchMemberExpression(\"React.Component\");\n\nexport default isReactComponent;\n"],"mappings":";;;;;;AAAA,IAAAA,2BAAA,GAAAC,OAAA;AAEA,MAAMC,gBAAgB,GAAG,IAAAC,mCAA0B,EAAC,iBAAiB,CAAC;AAAC,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAExDJ,gBAAgB","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/lib/validators/validate.js b/scripts/node_modules/@babel/types/lib/validators/validate.js new file mode 100644 index 0000000000000000000000000000000000000000..146f5ccb94cb131316f387857fd35e5c0ea5eacd --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/validate.js @@ -0,0 +1,42 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = validate; +exports.validateChild = validateChild; +exports.validateField = validateField; +exports.validateInternal = validateInternal; +var _index = require("../definitions/index.js"); +function validate(node, key, val) { + if (!node) return; + const fields = _index.NODE_FIELDS[node.type]; + if (!fields) return; + const field = fields[key]; + validateField(node, key, val, field); + validateChild(node, key, val); +} +function validateInternal(field, node, key, val, maybeNode) { + if (!(field != null && field.validate)) return; + if (field.optional && val == null) return; + field.validate(node, key, val); + if (maybeNode) { + var _NODE_PARENT_VALIDATI; + const type = val.type; + if (type == null) return; + (_NODE_PARENT_VALIDATI = _index.NODE_PARENT_VALIDATIONS[type]) == null || _NODE_PARENT_VALIDATI.call(_index.NODE_PARENT_VALIDATIONS, node, key, val); + } +} +function validateField(node, key, val, field) { + if (!(field != null && field.validate)) return; + if (field.optional && val == null) return; + field.validate(node, key, val); +} +function validateChild(node, key, val) { + var _NODE_PARENT_VALIDATI2; + const type = val == null ? void 0 : val.type; + if (type == null) return; + (_NODE_PARENT_VALIDATI2 = _index.NODE_PARENT_VALIDATIONS[type]) == null || _NODE_PARENT_VALIDATI2.call(_index.NODE_PARENT_VALIDATIONS, node, key, val); +} + +//# sourceMappingURL=validate.js.map diff --git a/scripts/node_modules/@babel/types/lib/validators/validate.js.map b/scripts/node_modules/@babel/types/lib/validators/validate.js.map new file mode 100644 index 0000000000000000000000000000000000000000..8cb8aa79bb1be12d89ddf508d6fdd3a4f57dc7bd --- /dev/null +++ b/scripts/node_modules/@babel/types/lib/validators/validate.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_index","require","validate","node","key","val","fields","NODE_FIELDS","type","field","validateField","validateChild","validateInternal","maybeNode","optional","_NODE_PARENT_VALIDATI","NODE_PARENT_VALIDATIONS","call","_NODE_PARENT_VALIDATI2"],"sources":["../../src/validators/validate.ts"],"sourcesContent":["import {\n NODE_FIELDS,\n NODE_PARENT_VALIDATIONS,\n type FieldOptions,\n} from \"../definitions/index.ts\";\nimport type * as t from \"../index.ts\";\n\nexport default function validate(\n node: t.Node | undefined | null,\n key: string,\n val: unknown,\n): void {\n if (!node) return;\n\n const fields = NODE_FIELDS[node.type];\n if (!fields) return;\n\n const field = fields[key];\n validateField(node, key, val, field);\n validateChild(node, key, val);\n}\n\nexport function validateInternal(\n field: FieldOptions,\n node: t.Node | undefined | null,\n key: string,\n val: unknown,\n maybeNode?: 1,\n): void {\n if (!field?.validate) return;\n if (field.optional && val == null) return;\n\n field.validate(node, key, val);\n\n if (maybeNode) {\n const type = (val as t.Node).type;\n if (type == null) return;\n NODE_PARENT_VALIDATIONS[type]?.(node, key, val);\n }\n}\n\nexport function validateField(\n node: t.Node | undefined | null,\n key: string,\n val: unknown,\n field: FieldOptions | undefined | null,\n): void {\n if (!field?.validate) return;\n if (field.optional && val == null) return;\n\n field.validate(node, key, val);\n}\n\nexport function validateChild(\n node: t.Node | undefined | null,\n key: string | { toString(): string },\n val?: unknown,\n) {\n const type = (val as t.Node)?.type;\n if (type == null) return;\n NODE_PARENT_VALIDATIONS[type]?.(node, key, val);\n}\n"],"mappings":";;;;;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAOe,SAASC,QAAQA,CAC9BC,IAA+B,EAC/BC,GAAW,EACXC,GAAY,EACN;EACN,IAAI,CAACF,IAAI,EAAE;EAEX,MAAMG,MAAM,GAAGC,kBAAW,CAACJ,IAAI,CAACK,IAAI,CAAC;EACrC,IAAI,CAACF,MAAM,EAAE;EAEb,MAAMG,KAAK,GAAGH,MAAM,CAACF,GAAG,CAAC;EACzBM,aAAa,CAACP,IAAI,EAAEC,GAAG,EAAEC,GAAG,EAAEI,KAAK,CAAC;EACpCE,aAAa,CAACR,IAAI,EAAEC,GAAG,EAAEC,GAAG,CAAC;AAC/B;AAEO,SAASO,gBAAgBA,CAC9BH,KAAmB,EACnBN,IAA+B,EAC/BC,GAAW,EACXC,GAAY,EACZQ,SAAa,EACP;EACN,IAAI,EAACJ,KAAK,YAALA,KAAK,CAAEP,QAAQ,GAAE;EACtB,IAAIO,KAAK,CAACK,QAAQ,IAAIT,GAAG,IAAI,IAAI,EAAE;EAEnCI,KAAK,CAACP,QAAQ,CAACC,IAAI,EAAEC,GAAG,EAAEC,GAAG,CAAC;EAE9B,IAAIQ,SAAS,EAAE;IAAA,IAAAE,qBAAA;IACb,MAAMP,IAAI,GAAIH,GAAG,CAAYG,IAAI;IACjC,IAAIA,IAAI,IAAI,IAAI,EAAE;IAClB,CAAAO,qBAAA,GAAAC,8BAAuB,CAACR,IAAI,CAAC,aAA7BO,qBAAA,CAAAE,IAAA,CAAAD,8BAAuB,EAASb,IAAI,EAAEC,GAAG,EAAEC,GAAG,CAAC;EACjD;AACF;AAEO,SAASK,aAAaA,CAC3BP,IAA+B,EAC/BC,GAAW,EACXC,GAAY,EACZI,KAAsC,EAChC;EACN,IAAI,EAACA,KAAK,YAALA,KAAK,CAAEP,QAAQ,GAAE;EACtB,IAAIO,KAAK,CAACK,QAAQ,IAAIT,GAAG,IAAI,IAAI,EAAE;EAEnCI,KAAK,CAACP,QAAQ,CAACC,IAAI,EAAEC,GAAG,EAAEC,GAAG,CAAC;AAChC;AAEO,SAASM,aAAaA,CAC3BR,IAA+B,EAC/BC,GAAoC,EACpCC,GAAa,EACb;EAAA,IAAAa,sBAAA;EACA,MAAMV,IAAI,GAAIH,GAAG,oBAAHA,GAAG,CAAaG,IAAI;EAClC,IAAIA,IAAI,IAAI,IAAI,EAAE;EAClB,CAAAU,sBAAA,GAAAF,8BAAuB,CAACR,IAAI,CAAC,aAA7BU,sBAAA,CAAAD,IAAA,CAAAD,8BAAuB,EAASb,IAAI,EAAEC,GAAG,EAAEC,GAAG,CAAC;AACjD","ignoreList":[]} \ No newline at end of file diff --git a/scripts/node_modules/@babel/types/package.json b/scripts/node_modules/@babel/types/package.json new file mode 100644 index 0000000000000000000000000000000000000000..db753538d6ca17ccceb048536f3a2a1378afda2c --- /dev/null +++ b/scripts/node_modules/@babel/types/package.json @@ -0,0 +1,39 @@ +{ + "name": "@babel/types", + "version": "7.29.0", + "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.28.5" + }, + "devDependencies": { + "@babel/generator": "^7.29.0", + "@babel/helper-fixtures": "^7.28.6", + "@babel/parser": "^7.29.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/scripts/node_modules/@esbuild/win32-x64/README.md b/scripts/node_modules/@esbuild/win32-x64/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a99ee7cf84e91677bc3c6100ac37a60fc8ec8fdb --- /dev/null +++ b/scripts/node_modules/@esbuild/win32-x64/README.md @@ -0,0 +1,3 @@ +# esbuild + +This is the Windows 64-bit binary for esbuild, a JavaScript bundler and minifier. See https://github.com/evanw/esbuild for details. diff --git a/scripts/node_modules/@esbuild/win32-x64/esbuild.exe b/scripts/node_modules/@esbuild/win32-x64/esbuild.exe new file mode 100644 index 0000000000000000000000000000000000000000..284c5c116e86c23eebd05798d22d2181b66c9342 --- /dev/null +++ b/scripts/node_modules/@esbuild/win32-x64/esbuild.exe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b868c8d988ffe76006c03c91f856312c312e42e2f3932a6bb56d7f4a1790c8b3 +size 9913856 diff --git a/scripts/node_modules/@esbuild/win32-x64/package.json b/scripts/node_modules/@esbuild/win32-x64/package.json new file mode 100644 index 0000000000000000000000000000000000000000..94abf8c99361398a4d6091f280f9bbfa03448ddf --- /dev/null +++ b/scripts/node_modules/@esbuild/win32-x64/package.json @@ -0,0 +1,20 @@ +{ + "name": "@esbuild/win32-x64", + "version": "0.21.5", + "description": "The Windows 64-bit binary for esbuild, a JavaScript bundler.", + "repository": { + "type": "git", + "url": "git+https://github.com/evanw/esbuild.git" + }, + "license": "MIT", + "preferUnplugged": true, + "engines": { + "node": ">=12" + }, + "os": [ + "win32" + ], + "cpu": [ + "x64" + ] +} diff --git a/scripts/node_modules/@jridgewell/gen-mapping/LICENSE b/scripts/node_modules/@jridgewell/gen-mapping/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..1f6ce94c11912496b96298630d84753dbf593a7d --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/LICENSE @@ -0,0 +1,19 @@ +Copyright 2024 Justin Ridgewell + +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/scripts/node_modules/@jridgewell/gen-mapping/README.md b/scripts/node_modules/@jridgewell/gen-mapping/README.md new file mode 100644 index 0000000000000000000000000000000000000000..93692b10655a33f4bb4f37c28a576edf83b0c8e2 --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/README.md @@ -0,0 +1,227 @@ +# @jridgewell/gen-mapping + +> Generate source maps + +`gen-mapping` allows you to generate a source map during transpilation or minification. +With a source map, you're able to trace the original location in the source file, either in Chrome's +DevTools or using a library like [`@jridgewell/trace-mapping`][trace-mapping]. + +You may already be familiar with the [`source-map`][source-map] package's `SourceMapGenerator`. This +provides the same `addMapping` and `setSourceContent` API. + +## Installation + +```sh +npm install @jridgewell/gen-mapping +``` + +## Usage + +```typescript +import { GenMapping, addMapping, setSourceContent, toEncodedMap, toDecodedMap } from '@jridgewell/gen-mapping'; + +const map = new GenMapping({ + file: 'output.js', + sourceRoot: 'https://example.com/', +}); + +setSourceContent(map, 'input.js', `function foo() {}`); + +addMapping(map, { + // Lines start at line 1, columns at column 0. + generated: { line: 1, column: 0 }, + source: 'input.js', + original: { line: 1, column: 0 }, +}); + +addMapping(map, { + generated: { line: 1, column: 9 }, + source: 'input.js', + original: { line: 1, column: 9 }, + name: 'foo', +}); + +assert.deepEqual(toDecodedMap(map), { + version: 3, + file: 'output.js', + names: ['foo'], + sourceRoot: 'https://example.com/', + sources: ['input.js'], + sourcesContent: ['function foo() {}'], + mappings: [ + [ [0, 0, 0, 0], [9, 0, 0, 9, 0] ] + ], +}); + +assert.deepEqual(toEncodedMap(map), { + version: 3, + file: 'output.js', + names: ['foo'], + sourceRoot: 'https://example.com/', + sources: ['input.js'], + sourcesContent: ['function foo() {}'], + mappings: 'AAAA,SAASA', +}); +``` + +### Smaller Sourcemaps + +Not everything needs to be added to a sourcemap, and needless markings can cause signficantly +larger file sizes. `gen-mapping` exposes `maybeAddSegment`/`maybeAddMapping` APIs that will +intelligently determine if this marking adds useful information. If not, the marking will be +skipped. + +```typescript +import { maybeAddMapping } from '@jridgewell/gen-mapping'; + +const map = new GenMapping(); + +// Adding a sourceless marking at the beginning of a line isn't useful. +maybeAddMapping(map, { + generated: { line: 1, column: 0 }, +}); + +// Adding a new source marking is useful. +maybeAddMapping(map, { + generated: { line: 1, column: 0 }, + source: 'input.js', + original: { line: 1, column: 0 }, +}); + +// But adding another marking pointing to the exact same original location isn't, even if the +// generated column changed. +maybeAddMapping(map, { + generated: { line: 1, column: 9 }, + source: 'input.js', + original: { line: 1, column: 0 }, +}); + +assert.deepEqual(toEncodedMap(map), { + version: 3, + names: [], + sources: ['input.js'], + sourcesContent: [null], + mappings: 'AAAA', +}); +``` + +## Benchmarks + +``` +node v18.0.0 + +amp.js.map +Memory Usage: +gen-mapping: addSegment 5852872 bytes +gen-mapping: addMapping 7716042 bytes +source-map-js 6143250 bytes +source-map-0.6.1 6124102 bytes +source-map-0.8.0 6121173 bytes +Smallest memory usage is gen-mapping: addSegment + +Adding speed: +gen-mapping: addSegment x 441 ops/sec ±2.07% (90 runs sampled) +gen-mapping: addMapping x 350 ops/sec ±2.40% (86 runs sampled) +source-map-js: addMapping x 169 ops/sec ±2.42% (80 runs sampled) +source-map-0.6.1: addMapping x 167 ops/sec ±2.56% (80 runs sampled) +source-map-0.8.0: addMapping x 168 ops/sec ±2.52% (80 runs sampled) +Fastest is gen-mapping: addSegment + +Generate speed: +gen-mapping: decoded output x 150,824,370 ops/sec ±0.07% (102 runs sampled) +gen-mapping: encoded output x 663 ops/sec ±0.22% (98 runs sampled) +source-map-js: encoded output x 197 ops/sec ±0.45% (84 runs sampled) +source-map-0.6.1: encoded output x 198 ops/sec ±0.33% (85 runs sampled) +source-map-0.8.0: encoded output x 197 ops/sec ±0.06% (93 runs sampled) +Fastest is gen-mapping: decoded output + + +*** + + +babel.min.js.map +Memory Usage: +gen-mapping: addSegment 37578063 bytes +gen-mapping: addMapping 37212897 bytes +source-map-js 47638527 bytes +source-map-0.6.1 47690503 bytes +source-map-0.8.0 47470188 bytes +Smallest memory usage is gen-mapping: addMapping + +Adding speed: +gen-mapping: addSegment x 31.05 ops/sec ±8.31% (43 runs sampled) +gen-mapping: addMapping x 29.83 ops/sec ±7.36% (51 runs sampled) +source-map-js: addMapping x 20.73 ops/sec ±6.22% (38 runs sampled) +source-map-0.6.1: addMapping x 20.03 ops/sec ±10.51% (38 runs sampled) +source-map-0.8.0: addMapping x 19.30 ops/sec ±8.27% (37 runs sampled) +Fastest is gen-mapping: addSegment + +Generate speed: +gen-mapping: decoded output x 381,379,234 ops/sec ±0.29% (96 runs sampled) +gen-mapping: encoded output x 95.15 ops/sec ±2.98% (72 runs sampled) +source-map-js: encoded output x 15.20 ops/sec ±7.41% (33 runs sampled) +source-map-0.6.1: encoded output x 16.36 ops/sec ±10.46% (31 runs sampled) +source-map-0.8.0: encoded output x 16.06 ops/sec ±6.45% (31 runs sampled) +Fastest is gen-mapping: decoded output + + +*** + + +preact.js.map +Memory Usage: +gen-mapping: addSegment 416247 bytes +gen-mapping: addMapping 419824 bytes +source-map-js 1024619 bytes +source-map-0.6.1 1146004 bytes +source-map-0.8.0 1113250 bytes +Smallest memory usage is gen-mapping: addSegment + +Adding speed: +gen-mapping: addSegment x 13,755 ops/sec ±0.15% (98 runs sampled) +gen-mapping: addMapping x 13,013 ops/sec ±0.11% (101 runs sampled) +source-map-js: addMapping x 4,564 ops/sec ±0.21% (98 runs sampled) +source-map-0.6.1: addMapping x 4,562 ops/sec ±0.11% (99 runs sampled) +source-map-0.8.0: addMapping x 4,593 ops/sec ±0.11% (100 runs sampled) +Fastest is gen-mapping: addSegment + +Generate speed: +gen-mapping: decoded output x 379,864,020 ops/sec ±0.23% (93 runs sampled) +gen-mapping: encoded output x 14,368 ops/sec ±4.07% (82 runs sampled) +source-map-js: encoded output x 5,261 ops/sec ±0.21% (99 runs sampled) +source-map-0.6.1: encoded output x 5,124 ops/sec ±0.58% (99 runs sampled) +source-map-0.8.0: encoded output x 5,434 ops/sec ±0.33% (96 runs sampled) +Fastest is gen-mapping: decoded output + + +*** + + +react.js.map +Memory Usage: +gen-mapping: addSegment 975096 bytes +gen-mapping: addMapping 1102981 bytes +source-map-js 2918836 bytes +source-map-0.6.1 2885435 bytes +source-map-0.8.0 2874336 bytes +Smallest memory usage is gen-mapping: addSegment + +Adding speed: +gen-mapping: addSegment x 4,772 ops/sec ±0.15% (100 runs sampled) +gen-mapping: addMapping x 4,456 ops/sec ±0.13% (97 runs sampled) +source-map-js: addMapping x 1,618 ops/sec ±0.24% (97 runs sampled) +source-map-0.6.1: addMapping x 1,622 ops/sec ±0.12% (99 runs sampled) +source-map-0.8.0: addMapping x 1,631 ops/sec ±0.12% (100 runs sampled) +Fastest is gen-mapping: addSegment + +Generate speed: +gen-mapping: decoded output x 379,107,695 ops/sec ±0.07% (99 runs sampled) +gen-mapping: encoded output x 5,421 ops/sec ±1.60% (89 runs sampled) +source-map-js: encoded output x 2,113 ops/sec ±1.81% (98 runs sampled) +source-map-0.6.1: encoded output x 2,126 ops/sec ±0.10% (100 runs sampled) +source-map-0.8.0: encoded output x 2,176 ops/sec ±0.39% (98 runs sampled) +Fastest is gen-mapping: decoded output +``` + +[source-map]: https://www.npmjs.com/package/source-map +[trace-mapping]: https://github.com/jridgewell/sourcemaps/tree/main/packages/trace-mapping diff --git a/scripts/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs b/scripts/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs new file mode 100644 index 0000000000000000000000000000000000000000..bbb0cacc5a77ef06b4a9921fe075914135d80f0f --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs @@ -0,0 +1,292 @@ +// src/set-array.ts +var SetArray = class { + constructor() { + this._indexes = { __proto__: null }; + this.array = []; + } +}; +function cast(set) { + return set; +} +function get(setarr, key) { + return cast(setarr)._indexes[key]; +} +function put(setarr, key) { + const index = get(setarr, key); + if (index !== void 0) return index; + const { array, _indexes: indexes } = cast(setarr); + const length = array.push(key); + return indexes[key] = length - 1; +} +function remove(setarr, key) { + const index = get(setarr, key); + if (index === void 0) return; + const { array, _indexes: indexes } = cast(setarr); + for (let i = index + 1; i < array.length; i++) { + const k = array[i]; + array[i - 1] = k; + indexes[k]--; + } + indexes[key] = void 0; + array.pop(); +} + +// src/gen-mapping.ts +import { + encode +} from "@jridgewell/sourcemap-codec"; +import { TraceMap, decodedMappings } from "@jridgewell/trace-mapping"; + +// src/sourcemap-segment.ts +var COLUMN = 0; +var SOURCES_INDEX = 1; +var SOURCE_LINE = 2; +var SOURCE_COLUMN = 3; +var NAMES_INDEX = 4; + +// src/gen-mapping.ts +var NO_NAME = -1; +var GenMapping = class { + constructor({ file, sourceRoot } = {}) { + this._names = new SetArray(); + this._sources = new SetArray(); + this._sourcesContent = []; + this._mappings = []; + this.file = file; + this.sourceRoot = sourceRoot; + this._ignoreList = new SetArray(); + } +}; +function cast2(map) { + return map; +} +function addSegment(map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) { + return addSegmentInternal( + false, + map, + genLine, + genColumn, + source, + sourceLine, + sourceColumn, + name, + content + ); +} +function addMapping(map, mapping) { + return addMappingInternal(false, map, mapping); +} +var maybeAddSegment = (map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => { + return addSegmentInternal( + true, + map, + genLine, + genColumn, + source, + sourceLine, + sourceColumn, + name, + content + ); +}; +var maybeAddMapping = (map, mapping) => { + return addMappingInternal(true, map, mapping); +}; +function setSourceContent(map, source, content) { + const { + _sources: sources, + _sourcesContent: sourcesContent + // _originalScopes: originalScopes, + } = cast2(map); + const index = put(sources, source); + sourcesContent[index] = content; +} +function setIgnore(map, source, ignore = true) { + const { + _sources: sources, + _sourcesContent: sourcesContent, + _ignoreList: ignoreList + // _originalScopes: originalScopes, + } = cast2(map); + const index = put(sources, source); + if (index === sourcesContent.length) sourcesContent[index] = null; + if (ignore) put(ignoreList, index); + else remove(ignoreList, index); +} +function toDecodedMap(map) { + const { + _mappings: mappings, + _sources: sources, + _sourcesContent: sourcesContent, + _names: names, + _ignoreList: ignoreList + // _originalScopes: originalScopes, + // _generatedRanges: generatedRanges, + } = cast2(map); + removeEmptyFinalLines(mappings); + return { + version: 3, + file: map.file || void 0, + names: names.array, + sourceRoot: map.sourceRoot || void 0, + sources: sources.array, + sourcesContent, + mappings, + // originalScopes, + // generatedRanges, + ignoreList: ignoreList.array + }; +} +function toEncodedMap(map) { + const decoded = toDecodedMap(map); + return Object.assign({}, decoded, { + // originalScopes: decoded.originalScopes.map((os) => encodeOriginalScopes(os)), + // generatedRanges: encodeGeneratedRanges(decoded.generatedRanges as GeneratedRange[]), + mappings: encode(decoded.mappings) + }); +} +function fromMap(input) { + const map = new TraceMap(input); + const gen = new GenMapping({ file: map.file, sourceRoot: map.sourceRoot }); + putAll(cast2(gen)._names, map.names); + putAll(cast2(gen)._sources, map.sources); + cast2(gen)._sourcesContent = map.sourcesContent || map.sources.map(() => null); + cast2(gen)._mappings = decodedMappings(map); + if (map.ignoreList) putAll(cast2(gen)._ignoreList, map.ignoreList); + return gen; +} +function allMappings(map) { + const out = []; + const { _mappings: mappings, _sources: sources, _names: names } = cast2(map); + for (let i = 0; i < mappings.length; i++) { + const line = mappings[i]; + for (let j = 0; j < line.length; j++) { + const seg = line[j]; + const generated = { line: i + 1, column: seg[COLUMN] }; + let source = void 0; + let original = void 0; + let name = void 0; + if (seg.length !== 1) { + source = sources.array[seg[SOURCES_INDEX]]; + original = { line: seg[SOURCE_LINE] + 1, column: seg[SOURCE_COLUMN] }; + if (seg.length === 5) name = names.array[seg[NAMES_INDEX]]; + } + out.push({ generated, source, original, name }); + } + } + return out; +} +function addSegmentInternal(skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) { + const { + _mappings: mappings, + _sources: sources, + _sourcesContent: sourcesContent, + _names: names + // _originalScopes: originalScopes, + } = cast2(map); + const line = getIndex(mappings, genLine); + const index = getColumnIndex(line, genColumn); + if (!source) { + if (skipable && skipSourceless(line, index)) return; + return insert(line, index, [genColumn]); + } + assert(sourceLine); + assert(sourceColumn); + const sourcesIndex = put(sources, source); + const namesIndex = name ? put(names, name) : NO_NAME; + if (sourcesIndex === sourcesContent.length) sourcesContent[sourcesIndex] = content != null ? content : null; + if (skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) { + return; + } + return insert( + line, + index, + name ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex] : [genColumn, sourcesIndex, sourceLine, sourceColumn] + ); +} +function assert(_val) { +} +function getIndex(arr, index) { + for (let i = arr.length; i <= index; i++) { + arr[i] = []; + } + return arr[index]; +} +function getColumnIndex(line, genColumn) { + let index = line.length; + for (let i = index - 1; i >= 0; index = i--) { + const current = line[i]; + if (genColumn >= current[COLUMN]) break; + } + return index; +} +function insert(array, index, value) { + for (let i = array.length; i > index; i--) { + array[i] = array[i - 1]; + } + array[index] = value; +} +function removeEmptyFinalLines(mappings) { + const { length } = mappings; + let len = length; + for (let i = len - 1; i >= 0; len = i, i--) { + if (mappings[i].length > 0) break; + } + if (len < length) mappings.length = len; +} +function putAll(setarr, array) { + for (let i = 0; i < array.length; i++) put(setarr, array[i]); +} +function skipSourceless(line, index) { + if (index === 0) return true; + const prev = line[index - 1]; + return prev.length === 1; +} +function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex) { + if (index === 0) return false; + const prev = line[index - 1]; + if (prev.length === 1) return false; + return sourcesIndex === prev[SOURCES_INDEX] && sourceLine === prev[SOURCE_LINE] && sourceColumn === prev[SOURCE_COLUMN] && namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME); +} +function addMappingInternal(skipable, map, mapping) { + const { generated, source, original, name, content } = mapping; + if (!source) { + return addSegmentInternal( + skipable, + map, + generated.line - 1, + generated.column, + null, + null, + null, + null, + null + ); + } + assert(original); + return addSegmentInternal( + skipable, + map, + generated.line - 1, + generated.column, + source, + original.line - 1, + original.column, + name, + content + ); +} +export { + GenMapping, + addMapping, + addSegment, + allMappings, + fromMap, + maybeAddMapping, + maybeAddSegment, + setIgnore, + setSourceContent, + toDecodedMap, + toEncodedMap +}; +//# sourceMappingURL=gen-mapping.mjs.map diff --git a/scripts/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs.map b/scripts/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs.map new file mode 100644 index 0000000000000000000000000000000000000000..4e37e457b383d40504afea5419ff2b20afd0eb85 --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs.map @@ -0,0 +1,6 @@ +{ + "version": 3, + "sources": ["../src/set-array.ts", "../src/gen-mapping.ts", "../src/sourcemap-segment.ts"], + "mappings": "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", + "names": ["cast"] +} diff --git a/scripts/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js b/scripts/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js new file mode 100644 index 0000000000000000000000000000000000000000..cb84af55fb03a9f4c966be7f375a4a151bb8c6c2 --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js @@ -0,0 +1,358 @@ +(function (global, factory) { + if (typeof exports === 'object' && typeof module !== 'undefined') { + factory(module, require('@jridgewell/sourcemap-codec'), require('@jridgewell/trace-mapping')); + module.exports = def(module); + } else if (typeof define === 'function' && define.amd) { + define(['module', '@jridgewell/sourcemap-codec', '@jridgewell/trace-mapping'], function(mod) { + factory.apply(this, arguments); + mod.exports = def(mod); + }); + } else { + const mod = { exports: {} }; + factory(mod, global.sourcemapCodec, global.traceMapping); + global = typeof globalThis !== 'undefined' ? globalThis : global || self; + global.genMapping = def(mod); + } + function def(m) { return 'default' in m.exports ? m.exports.default : m.exports; } +})(this, (function (module, require_sourcemapCodec, require_traceMapping) { +"use strict"; +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// umd:@jridgewell/sourcemap-codec +var require_sourcemap_codec = __commonJS({ + "umd:@jridgewell/sourcemap-codec"(exports, module2) { + module2.exports = require_sourcemapCodec; + } +}); + +// umd:@jridgewell/trace-mapping +var require_trace_mapping = __commonJS({ + "umd:@jridgewell/trace-mapping"(exports, module2) { + module2.exports = require_traceMapping; + } +}); + +// src/gen-mapping.ts +var gen_mapping_exports = {}; +__export(gen_mapping_exports, { + GenMapping: () => GenMapping, + addMapping: () => addMapping, + addSegment: () => addSegment, + allMappings: () => allMappings, + fromMap: () => fromMap, + maybeAddMapping: () => maybeAddMapping, + maybeAddSegment: () => maybeAddSegment, + setIgnore: () => setIgnore, + setSourceContent: () => setSourceContent, + toDecodedMap: () => toDecodedMap, + toEncodedMap: () => toEncodedMap +}); +module.exports = __toCommonJS(gen_mapping_exports); + +// src/set-array.ts +var SetArray = class { + constructor() { + this._indexes = { __proto__: null }; + this.array = []; + } +}; +function cast(set) { + return set; +} +function get(setarr, key) { + return cast(setarr)._indexes[key]; +} +function put(setarr, key) { + const index = get(setarr, key); + if (index !== void 0) return index; + const { array, _indexes: indexes } = cast(setarr); + const length = array.push(key); + return indexes[key] = length - 1; +} +function remove(setarr, key) { + const index = get(setarr, key); + if (index === void 0) return; + const { array, _indexes: indexes } = cast(setarr); + for (let i = index + 1; i < array.length; i++) { + const k = array[i]; + array[i - 1] = k; + indexes[k]--; + } + indexes[key] = void 0; + array.pop(); +} + +// src/gen-mapping.ts +var import_sourcemap_codec = __toESM(require_sourcemap_codec()); +var import_trace_mapping = __toESM(require_trace_mapping()); + +// src/sourcemap-segment.ts +var COLUMN = 0; +var SOURCES_INDEX = 1; +var SOURCE_LINE = 2; +var SOURCE_COLUMN = 3; +var NAMES_INDEX = 4; + +// src/gen-mapping.ts +var NO_NAME = -1; +var GenMapping = class { + constructor({ file, sourceRoot } = {}) { + this._names = new SetArray(); + this._sources = new SetArray(); + this._sourcesContent = []; + this._mappings = []; + this.file = file; + this.sourceRoot = sourceRoot; + this._ignoreList = new SetArray(); + } +}; +function cast2(map) { + return map; +} +function addSegment(map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) { + return addSegmentInternal( + false, + map, + genLine, + genColumn, + source, + sourceLine, + sourceColumn, + name, + content + ); +} +function addMapping(map, mapping) { + return addMappingInternal(false, map, mapping); +} +var maybeAddSegment = (map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => { + return addSegmentInternal( + true, + map, + genLine, + genColumn, + source, + sourceLine, + sourceColumn, + name, + content + ); +}; +var maybeAddMapping = (map, mapping) => { + return addMappingInternal(true, map, mapping); +}; +function setSourceContent(map, source, content) { + const { + _sources: sources, + _sourcesContent: sourcesContent + // _originalScopes: originalScopes, + } = cast2(map); + const index = put(sources, source); + sourcesContent[index] = content; +} +function setIgnore(map, source, ignore = true) { + const { + _sources: sources, + _sourcesContent: sourcesContent, + _ignoreList: ignoreList + // _originalScopes: originalScopes, + } = cast2(map); + const index = put(sources, source); + if (index === sourcesContent.length) sourcesContent[index] = null; + if (ignore) put(ignoreList, index); + else remove(ignoreList, index); +} +function toDecodedMap(map) { + const { + _mappings: mappings, + _sources: sources, + _sourcesContent: sourcesContent, + _names: names, + _ignoreList: ignoreList + // _originalScopes: originalScopes, + // _generatedRanges: generatedRanges, + } = cast2(map); + removeEmptyFinalLines(mappings); + return { + version: 3, + file: map.file || void 0, + names: names.array, + sourceRoot: map.sourceRoot || void 0, + sources: sources.array, + sourcesContent, + mappings, + // originalScopes, + // generatedRanges, + ignoreList: ignoreList.array + }; +} +function toEncodedMap(map) { + const decoded = toDecodedMap(map); + return Object.assign({}, decoded, { + // originalScopes: decoded.originalScopes.map((os) => encodeOriginalScopes(os)), + // generatedRanges: encodeGeneratedRanges(decoded.generatedRanges as GeneratedRange[]), + mappings: (0, import_sourcemap_codec.encode)(decoded.mappings) + }); +} +function fromMap(input) { + const map = new import_trace_mapping.TraceMap(input); + const gen = new GenMapping({ file: map.file, sourceRoot: map.sourceRoot }); + putAll(cast2(gen)._names, map.names); + putAll(cast2(gen)._sources, map.sources); + cast2(gen)._sourcesContent = map.sourcesContent || map.sources.map(() => null); + cast2(gen)._mappings = (0, import_trace_mapping.decodedMappings)(map); + if (map.ignoreList) putAll(cast2(gen)._ignoreList, map.ignoreList); + return gen; +} +function allMappings(map) { + const out = []; + const { _mappings: mappings, _sources: sources, _names: names } = cast2(map); + for (let i = 0; i < mappings.length; i++) { + const line = mappings[i]; + for (let j = 0; j < line.length; j++) { + const seg = line[j]; + const generated = { line: i + 1, column: seg[COLUMN] }; + let source = void 0; + let original = void 0; + let name = void 0; + if (seg.length !== 1) { + source = sources.array[seg[SOURCES_INDEX]]; + original = { line: seg[SOURCE_LINE] + 1, column: seg[SOURCE_COLUMN] }; + if (seg.length === 5) name = names.array[seg[NAMES_INDEX]]; + } + out.push({ generated, source, original, name }); + } + } + return out; +} +function addSegmentInternal(skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) { + const { + _mappings: mappings, + _sources: sources, + _sourcesContent: sourcesContent, + _names: names + // _originalScopes: originalScopes, + } = cast2(map); + const line = getIndex(mappings, genLine); + const index = getColumnIndex(line, genColumn); + if (!source) { + if (skipable && skipSourceless(line, index)) return; + return insert(line, index, [genColumn]); + } + assert(sourceLine); + assert(sourceColumn); + const sourcesIndex = put(sources, source); + const namesIndex = name ? put(names, name) : NO_NAME; + if (sourcesIndex === sourcesContent.length) sourcesContent[sourcesIndex] = content != null ? content : null; + if (skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) { + return; + } + return insert( + line, + index, + name ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex] : [genColumn, sourcesIndex, sourceLine, sourceColumn] + ); +} +function assert(_val) { +} +function getIndex(arr, index) { + for (let i = arr.length; i <= index; i++) { + arr[i] = []; + } + return arr[index]; +} +function getColumnIndex(line, genColumn) { + let index = line.length; + for (let i = index - 1; i >= 0; index = i--) { + const current = line[i]; + if (genColumn >= current[COLUMN]) break; + } + return index; +} +function insert(array, index, value) { + for (let i = array.length; i > index; i--) { + array[i] = array[i - 1]; + } + array[index] = value; +} +function removeEmptyFinalLines(mappings) { + const { length } = mappings; + let len = length; + for (let i = len - 1; i >= 0; len = i, i--) { + if (mappings[i].length > 0) break; + } + if (len < length) mappings.length = len; +} +function putAll(setarr, array) { + for (let i = 0; i < array.length; i++) put(setarr, array[i]); +} +function skipSourceless(line, index) { + if (index === 0) return true; + const prev = line[index - 1]; + return prev.length === 1; +} +function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex) { + if (index === 0) return false; + const prev = line[index - 1]; + if (prev.length === 1) return false; + return sourcesIndex === prev[SOURCES_INDEX] && sourceLine === prev[SOURCE_LINE] && sourceColumn === prev[SOURCE_COLUMN] && namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME); +} +function addMappingInternal(skipable, map, mapping) { + const { generated, source, original, name, content } = mapping; + if (!source) { + return addSegmentInternal( + skipable, + map, + generated.line - 1, + generated.column, + null, + null, + null, + null, + null + ); + } + assert(original); + return addSegmentInternal( + skipable, + map, + generated.line - 1, + generated.column, + source, + original.line - 1, + original.column, + name, + content + ); +} +})); +//# sourceMappingURL=gen-mapping.umd.js.map diff --git a/scripts/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js.map b/scripts/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js.map new file mode 100644 index 0000000000000000000000000000000000000000..b13750bf67818b051645f7c332594e3cf7786375 --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js.map @@ -0,0 +1,6 @@ +{ + "version": 3, + "sources": ["umd:@jridgewell/sourcemap-codec", "umd:@jridgewell/trace-mapping", "../src/gen-mapping.ts", "../src/set-array.ts", "../src/sourcemap-segment.ts"], + "mappings": "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", + "names": ["module", "module", "cast"] +} diff --git a/scripts/node_modules/@jridgewell/gen-mapping/dist/types/gen-mapping.d.ts b/scripts/node_modules/@jridgewell/gen-mapping/dist/types/gen-mapping.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9ba936e82bcf799e9d42bdb5ecd3ef11e978189e --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/dist/types/gen-mapping.d.ts @@ -0,0 +1,88 @@ +import type { SourceMapInput } from '@jridgewell/trace-mapping'; +import type { DecodedSourceMap, EncodedSourceMap, Pos, Mapping } from './types'; +export type { DecodedSourceMap, EncodedSourceMap, Mapping }; +export type Options = { + file?: string | null; + sourceRoot?: string | null; +}; +/** + * Provides the state to generate a sourcemap. + */ +export declare class GenMapping { + private _names; + private _sources; + private _sourcesContent; + private _mappings; + private _ignoreList; + file: string | null | undefined; + sourceRoot: string | null | undefined; + constructor({ file, sourceRoot }?: Options); +} +/** + * A low-level API to associate a generated position with an original source position. Line and + * column here are 0-based, unlike `addMapping`. + */ +export declare function addSegment(map: GenMapping, genLine: number, genColumn: number, source?: null, sourceLine?: null, sourceColumn?: null, name?: null, content?: null): void; +export declare function addSegment(map: GenMapping, genLine: number, genColumn: number, source: string, sourceLine: number, sourceColumn: number, name?: null, content?: string | null): void; +export declare function addSegment(map: GenMapping, genLine: number, genColumn: number, source: string, sourceLine: number, sourceColumn: number, name: string, content?: string | null): void; +/** + * A high-level API to associate a generated position with an original source position. Line is + * 1-based, but column is 0-based, due to legacy behavior in `source-map` library. + */ +export declare function addMapping(map: GenMapping, mapping: { + generated: Pos; + source?: null; + original?: null; + name?: null; + content?: null; +}): void; +export declare function addMapping(map: GenMapping, mapping: { + generated: Pos; + source: string; + original: Pos; + name?: null; + content?: string | null; +}): void; +export declare function addMapping(map: GenMapping, mapping: { + generated: Pos; + source: string; + original: Pos; + name: string; + content?: string | null; +}): void; +/** + * Same as `addSegment`, but will only add the segment if it generates useful information in the + * resulting map. This only works correctly if segments are added **in order**, meaning you should + * not add a segment with a lower generated line/column than one that came before. + */ +export declare const maybeAddSegment: typeof addSegment; +/** + * Same as `addMapping`, but will only add the mapping if it generates useful information in the + * resulting map. This only works correctly if mappings are added **in order**, meaning you should + * not add a mapping with a lower generated line/column than one that came before. + */ +export declare const maybeAddMapping: typeof addMapping; +/** + * Adds/removes the content of the source file to the source map. + */ +export declare function setSourceContent(map: GenMapping, source: string, content: string | null): void; +export declare function setIgnore(map: GenMapping, source: string, ignore?: boolean): void; +/** + * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects + * a sourcemap, or to JSON.stringify. + */ +export declare function toDecodedMap(map: GenMapping): DecodedSourceMap; +/** + * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects + * a sourcemap, or to JSON.stringify. + */ +export declare function toEncodedMap(map: GenMapping): EncodedSourceMap; +/** + * Constructs a new GenMapping, using the already present mappings of the input. + */ +export declare function fromMap(input: SourceMapInput): GenMapping; +/** + * Returns an array of high-level mapping objects for every recorded segment, which could then be + * passed to the `source-map` library. + */ +export declare function allMappings(map: GenMapping): Mapping[]; diff --git a/scripts/node_modules/@jridgewell/gen-mapping/dist/types/set-array.d.ts b/scripts/node_modules/@jridgewell/gen-mapping/dist/types/set-array.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6ed43543e9c70b62a90af8dfe05c9e470532e083 --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/dist/types/set-array.d.ts @@ -0,0 +1,32 @@ +type Key = string | number | symbol; +/** + * SetArray acts like a `Set` (allowing only one occurrence of a string `key`), but provides the + * index of the `key` in the backing array. + * + * This is designed to allow synchronizing a second array with the contents of the backing array, + * like how in a sourcemap `sourcesContent[i]` is the source content associated with `source[i]`, + * and there are never duplicates. + */ +export declare class SetArray { + private _indexes; + array: readonly T[]; + constructor(); +} +/** + * Gets the index associated with `key` in the backing array, if it is already present. + */ +export declare function get(setarr: SetArray, key: T): number | undefined; +/** + * Puts `key` into the backing array, if it is not already present. Returns + * the index of the `key` in the backing array. + */ +export declare function put(setarr: SetArray, key: T): number; +/** + * Pops the last added item out of the SetArray. + */ +export declare function pop(setarr: SetArray): void; +/** + * Removes the key, if it exists in the set. + */ +export declare function remove(setarr: SetArray, key: T): void; +export {}; diff --git a/scripts/node_modules/@jridgewell/gen-mapping/dist/types/sourcemap-segment.d.ts b/scripts/node_modules/@jridgewell/gen-mapping/dist/types/sourcemap-segment.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..aa19fb5e72da1d12d3484c44b13daa608cece5ba --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/dist/types/sourcemap-segment.d.ts @@ -0,0 +1,12 @@ +type GeneratedColumn = number; +type SourcesIndex = number; +type SourceLine = number; +type SourceColumn = number; +type NamesIndex = number; +export type SourceMapSegment = [GeneratedColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex]; +export declare const COLUMN = 0; +export declare const SOURCES_INDEX = 1; +export declare const SOURCE_LINE = 2; +export declare const SOURCE_COLUMN = 3; +export declare const NAMES_INDEX = 4; +export {}; diff --git a/scripts/node_modules/@jridgewell/gen-mapping/dist/types/types.d.ts b/scripts/node_modules/@jridgewell/gen-mapping/dist/types/types.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8eb90fb47477b1e82336ff79f6caaab4722b38d7 --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/dist/types/types.d.ts @@ -0,0 +1,43 @@ +import type { SourceMapSegment } from './sourcemap-segment'; +export interface SourceMapV3 { + file?: string | null; + names: readonly string[]; + sourceRoot?: string; + sources: readonly (string | null)[]; + sourcesContent?: readonly (string | null)[]; + version: 3; + ignoreList?: readonly number[]; +} +export interface EncodedSourceMap extends SourceMapV3 { + mappings: string; +} +export interface DecodedSourceMap extends SourceMapV3 { + mappings: readonly SourceMapSegment[][]; +} +export interface Pos { + line: number; + column: number; +} +export interface OriginalPos extends Pos { + source: string; +} +export interface BindingExpressionRange { + start: Pos; + expression: string; +} +export type Mapping = { + generated: Pos; + source: undefined; + original: undefined; + name: undefined; +} | { + generated: Pos; + source: string; + original: Pos; + name: string; +} | { + generated: Pos; + source: string; + original: Pos; + name: undefined; +}; diff --git a/scripts/node_modules/@jridgewell/gen-mapping/package.json b/scripts/node_modules/@jridgewell/gen-mapping/package.json new file mode 100644 index 0000000000000000000000000000000000000000..036f9b799d93aca59d80244410216583eda2d97b --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/package.json @@ -0,0 +1,67 @@ +{ + "name": "@jridgewell/gen-mapping", + "version": "0.3.13", + "description": "Generate source maps", + "keywords": [ + "source", + "map" + ], + "main": "dist/gen-mapping.umd.js", + "module": "dist/gen-mapping.mjs", + "types": "types/gen-mapping.d.cts", + "files": [ + "dist", + "src", + "types" + ], + "exports": { + ".": [ + { + "import": { + "types": "./types/gen-mapping.d.mts", + "default": "./dist/gen-mapping.mjs" + }, + "default": { + "types": "./types/gen-mapping.d.cts", + "default": "./dist/gen-mapping.umd.js" + } + }, + "./dist/gen-mapping.umd.js" + ], + "./package.json": "./package.json" + }, + "scripts": { + "benchmark": "run-s build:code benchmark:*", + "benchmark:install": "cd benchmark && npm install", + "benchmark:only": "node --expose-gc benchmark/index.js", + "build": "run-s -n build:code build:types", + "build:code": "node ../../esbuild.mjs gen-mapping.ts", + "build:types": "run-s build:types:force build:types:emit build:types:mts", + "build:types:force": "rimraf tsconfig.build.tsbuildinfo", + "build:types:emit": "tsc --project tsconfig.build.json", + "build:types:mts": "node ../../mts-types.mjs", + "clean": "run-s -n clean:code clean:types", + "clean:code": "tsc --build --clean tsconfig.build.json", + "clean:types": "rimraf dist types", + "test": "run-s -n test:types test:only test:format", + "test:format": "prettier --check '{src,test}/**/*.ts'", + "test:only": "mocha", + "test:types": "eslint '{src,test}/**/*.ts'", + "lint": "run-s -n lint:types lint:format", + "lint:format": "npm run test:format -- --write", + "lint:types": "npm run test:types -- --fix", + "prepublishOnly": "npm run-s -n build test" + }, + "homepage": "https://github.com/jridgewell/sourcemaps/tree/main/packages/gen-mapping", + "repository": { + "type": "git", + "url": "git+https://github.com/jridgewell/sourcemaps.git", + "directory": "packages/gen-mapping" + }, + "author": "Justin Ridgewell ", + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.0", + "@jridgewell/trace-mapping": "^0.3.24" + } +} diff --git a/scripts/node_modules/@jridgewell/gen-mapping/src/gen-mapping.ts b/scripts/node_modules/@jridgewell/gen-mapping/src/gen-mapping.ts new file mode 100644 index 0000000000000000000000000000000000000000..ecc878c5755eea6e252d31475e3c0f87817140e0 --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/src/gen-mapping.ts @@ -0,0 +1,614 @@ +import { SetArray, put, remove } from './set-array'; +import { + encode, + // encodeGeneratedRanges, + // encodeOriginalScopes +} from '@jridgewell/sourcemap-codec'; +import { TraceMap, decodedMappings } from '@jridgewell/trace-mapping'; + +import { + COLUMN, + SOURCES_INDEX, + SOURCE_LINE, + SOURCE_COLUMN, + NAMES_INDEX, +} from './sourcemap-segment'; + +import type { SourceMapInput } from '@jridgewell/trace-mapping'; +// import type { OriginalScope, GeneratedRange } from '@jridgewell/sourcemap-codec'; +import type { SourceMapSegment } from './sourcemap-segment'; +import type { + DecodedSourceMap, + EncodedSourceMap, + Pos, + Mapping, + // BindingExpressionRange, + // OriginalPos, + // OriginalScopeInfo, + // GeneratedRangeInfo, +} from './types'; + +export type { DecodedSourceMap, EncodedSourceMap, Mapping }; + +export type Options = { + file?: string | null; + sourceRoot?: string | null; +}; + +const NO_NAME = -1; + +/** + * Provides the state to generate a sourcemap. + */ +export class GenMapping { + declare private _names: SetArray; + declare private _sources: SetArray; + declare private _sourcesContent: (string | null)[]; + declare private _mappings: SourceMapSegment[][]; + // private declare _originalScopes: OriginalScope[][]; + // private declare _generatedRanges: GeneratedRange[]; + declare private _ignoreList: SetArray; + declare file: string | null | undefined; + declare sourceRoot: string | null | undefined; + + constructor({ file, sourceRoot }: Options = {}) { + this._names = new SetArray(); + this._sources = new SetArray(); + this._sourcesContent = []; + this._mappings = []; + // this._originalScopes = []; + // this._generatedRanges = []; + this.file = file; + this.sourceRoot = sourceRoot; + this._ignoreList = new SetArray(); + } +} + +interface PublicMap { + _names: GenMapping['_names']; + _sources: GenMapping['_sources']; + _sourcesContent: GenMapping['_sourcesContent']; + _mappings: GenMapping['_mappings']; + // _originalScopes: GenMapping['_originalScopes']; + // _generatedRanges: GenMapping['_generatedRanges']; + _ignoreList: GenMapping['_ignoreList']; +} + +/** + * Typescript doesn't allow friend access to private fields, so this just casts the map into a type + * with public access modifiers. + */ +function cast(map: unknown): PublicMap { + return map as any; +} + +/** + * A low-level API to associate a generated position with an original source position. Line and + * column here are 0-based, unlike `addMapping`. + */ +export function addSegment( + map: GenMapping, + genLine: number, + genColumn: number, + source?: null, + sourceLine?: null, + sourceColumn?: null, + name?: null, + content?: null, +): void; +export function addSegment( + map: GenMapping, + genLine: number, + genColumn: number, + source: string, + sourceLine: number, + sourceColumn: number, + name?: null, + content?: string | null, +): void; +export function addSegment( + map: GenMapping, + genLine: number, + genColumn: number, + source: string, + sourceLine: number, + sourceColumn: number, + name: string, + content?: string | null, +): void; +export function addSegment( + map: GenMapping, + genLine: number, + genColumn: number, + source?: string | null, + sourceLine?: number | null, + sourceColumn?: number | null, + name?: string | null, + content?: string | null, +): void { + return addSegmentInternal( + false, + map, + genLine, + genColumn, + source, + sourceLine, + sourceColumn, + name, + content, + ); +} + +/** + * A high-level API to associate a generated position with an original source position. Line is + * 1-based, but column is 0-based, due to legacy behavior in `source-map` library. + */ +export function addMapping( + map: GenMapping, + mapping: { + generated: Pos; + source?: null; + original?: null; + name?: null; + content?: null; + }, +): void; +export function addMapping( + map: GenMapping, + mapping: { + generated: Pos; + source: string; + original: Pos; + name?: null; + content?: string | null; + }, +): void; +export function addMapping( + map: GenMapping, + mapping: { + generated: Pos; + source: string; + original: Pos; + name: string; + content?: string | null; + }, +): void; +export function addMapping( + map: GenMapping, + mapping: { + generated: Pos; + source?: string | null; + original?: Pos | null; + name?: string | null; + content?: string | null; + }, +): void { + return addMappingInternal(false, map, mapping as Parameters[2]); +} + +/** + * Same as `addSegment`, but will only add the segment if it generates useful information in the + * resulting map. This only works correctly if segments are added **in order**, meaning you should + * not add a segment with a lower generated line/column than one that came before. + */ +export const maybeAddSegment: typeof addSegment = ( + map, + genLine, + genColumn, + source, + sourceLine, + sourceColumn, + name, + content, +) => { + return addSegmentInternal( + true, + map, + genLine, + genColumn, + source, + sourceLine, + sourceColumn, + name, + content, + ); +}; + +/** + * Same as `addMapping`, but will only add the mapping if it generates useful information in the + * resulting map. This only works correctly if mappings are added **in order**, meaning you should + * not add a mapping with a lower generated line/column than one that came before. + */ +export const maybeAddMapping: typeof addMapping = (map, mapping) => { + return addMappingInternal(true, map, mapping as Parameters[2]); +}; + +/** + * Adds/removes the content of the source file to the source map. + */ +export function setSourceContent(map: GenMapping, source: string, content: string | null): void { + const { + _sources: sources, + _sourcesContent: sourcesContent, + // _originalScopes: originalScopes, + } = cast(map); + const index = put(sources, source); + sourcesContent[index] = content; + // if (index === originalScopes.length) originalScopes[index] = []; +} + +export function setIgnore(map: GenMapping, source: string, ignore = true) { + const { + _sources: sources, + _sourcesContent: sourcesContent, + _ignoreList: ignoreList, + // _originalScopes: originalScopes, + } = cast(map); + const index = put(sources, source); + if (index === sourcesContent.length) sourcesContent[index] = null; + // if (index === originalScopes.length) originalScopes[index] = []; + if (ignore) put(ignoreList, index); + else remove(ignoreList, index); +} + +/** + * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects + * a sourcemap, or to JSON.stringify. + */ +export function toDecodedMap(map: GenMapping): DecodedSourceMap { + const { + _mappings: mappings, + _sources: sources, + _sourcesContent: sourcesContent, + _names: names, + _ignoreList: ignoreList, + // _originalScopes: originalScopes, + // _generatedRanges: generatedRanges, + } = cast(map); + removeEmptyFinalLines(mappings); + + return { + version: 3, + file: map.file || undefined, + names: names.array, + sourceRoot: map.sourceRoot || undefined, + sources: sources.array, + sourcesContent, + mappings, + // originalScopes, + // generatedRanges, + ignoreList: ignoreList.array, + }; +} + +/** + * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects + * a sourcemap, or to JSON.stringify. + */ +export function toEncodedMap(map: GenMapping): EncodedSourceMap { + const decoded = toDecodedMap(map); + return Object.assign({}, decoded, { + // originalScopes: decoded.originalScopes.map((os) => encodeOriginalScopes(os)), + // generatedRanges: encodeGeneratedRanges(decoded.generatedRanges as GeneratedRange[]), + mappings: encode(decoded.mappings as SourceMapSegment[][]), + }); +} + +/** + * Constructs a new GenMapping, using the already present mappings of the input. + */ +export function fromMap(input: SourceMapInput): GenMapping { + const map = new TraceMap(input); + const gen = new GenMapping({ file: map.file, sourceRoot: map.sourceRoot }); + + putAll(cast(gen)._names, map.names); + putAll(cast(gen)._sources, map.sources as string[]); + cast(gen)._sourcesContent = map.sourcesContent || map.sources.map(() => null); + cast(gen)._mappings = decodedMappings(map) as GenMapping['_mappings']; + // TODO: implement originalScopes/generatedRanges + if (map.ignoreList) putAll(cast(gen)._ignoreList, map.ignoreList); + + return gen; +} + +/** + * Returns an array of high-level mapping objects for every recorded segment, which could then be + * passed to the `source-map` library. + */ +export function allMappings(map: GenMapping): Mapping[] { + const out: Mapping[] = []; + const { _mappings: mappings, _sources: sources, _names: names } = cast(map); + + for (let i = 0; i < mappings.length; i++) { + const line = mappings[i]; + for (let j = 0; j < line.length; j++) { + const seg = line[j]; + + const generated = { line: i + 1, column: seg[COLUMN] }; + let source: string | undefined = undefined; + let original: Pos | undefined = undefined; + let name: string | undefined = undefined; + + if (seg.length !== 1) { + source = sources.array[seg[SOURCES_INDEX]]; + original = { line: seg[SOURCE_LINE] + 1, column: seg[SOURCE_COLUMN] }; + + if (seg.length === 5) name = names.array[seg[NAMES_INDEX]]; + } + + out.push({ generated, source, original, name } as Mapping); + } + } + + return out; +} + +// This split declaration is only so that terser can elminiate the static initialization block. +function addSegmentInternal( + skipable: boolean, + map: GenMapping, + genLine: number, + genColumn: number, + source: S, + sourceLine: S extends string ? number : null | undefined, + sourceColumn: S extends string ? number : null | undefined, + name: S extends string ? string | null | undefined : null | undefined, + content: S extends string ? string | null | undefined : null | undefined, +): void { + const { + _mappings: mappings, + _sources: sources, + _sourcesContent: sourcesContent, + _names: names, + // _originalScopes: originalScopes, + } = cast(map); + const line = getIndex(mappings, genLine); + const index = getColumnIndex(line, genColumn); + + if (!source) { + if (skipable && skipSourceless(line, index)) return; + return insert(line, index, [genColumn]); + } + + // Sigh, TypeScript can't figure out sourceLine and sourceColumn aren't nullish if source + // isn't nullish. + assert(sourceLine); + assert(sourceColumn); + + const sourcesIndex = put(sources, source); + const namesIndex = name ? put(names, name) : NO_NAME; + if (sourcesIndex === sourcesContent.length) sourcesContent[sourcesIndex] = content ?? null; + // if (sourcesIndex === originalScopes.length) originalScopes[sourcesIndex] = []; + + if (skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) { + return; + } + + return insert( + line, + index, + name + ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex] + : [genColumn, sourcesIndex, sourceLine, sourceColumn], + ); +} + +function assert(_val: unknown): asserts _val is T { + // noop. +} + +function getIndex(arr: T[][], index: number): T[] { + for (let i = arr.length; i <= index; i++) { + arr[i] = []; + } + return arr[index]; +} + +function getColumnIndex(line: SourceMapSegment[], genColumn: number): number { + let index = line.length; + for (let i = index - 1; i >= 0; index = i--) { + const current = line[i]; + if (genColumn >= current[COLUMN]) break; + } + return index; +} + +function insert(array: T[], index: number, value: T) { + for (let i = array.length; i > index; i--) { + array[i] = array[i - 1]; + } + array[index] = value; +} + +function removeEmptyFinalLines(mappings: SourceMapSegment[][]) { + const { length } = mappings; + let len = length; + for (let i = len - 1; i >= 0; len = i, i--) { + if (mappings[i].length > 0) break; + } + if (len < length) mappings.length = len; +} + +function putAll(setarr: SetArray, array: T[]) { + for (let i = 0; i < array.length; i++) put(setarr, array[i]); +} + +function skipSourceless(line: SourceMapSegment[], index: number): boolean { + // The start of a line is already sourceless, so adding a sourceless segment to the beginning + // doesn't generate any useful information. + if (index === 0) return true; + + const prev = line[index - 1]; + // If the previous segment is also sourceless, then adding another sourceless segment doesn't + // genrate any new information. Else, this segment will end the source/named segment and point to + // a sourceless position, which is useful. + return prev.length === 1; +} + +function skipSource( + line: SourceMapSegment[], + index: number, + sourcesIndex: number, + sourceLine: number, + sourceColumn: number, + namesIndex: number, +): boolean { + // A source/named segment at the start of a line gives position at that genColumn + if (index === 0) return false; + + const prev = line[index - 1]; + + // If the previous segment is sourceless, then we're transitioning to a source. + if (prev.length === 1) return false; + + // If the previous segment maps to the exact same source position, then this segment doesn't + // provide any new position information. + return ( + sourcesIndex === prev[SOURCES_INDEX] && + sourceLine === prev[SOURCE_LINE] && + sourceColumn === prev[SOURCE_COLUMN] && + namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME) + ); +} + +function addMappingInternal( + skipable: boolean, + map: GenMapping, + mapping: { + generated: Pos; + source: S; + original: S extends string ? Pos : null | undefined; + name: S extends string ? string | null | undefined : null | undefined; + content: S extends string ? string | null | undefined : null | undefined; + }, +) { + const { generated, source, original, name, content } = mapping; + if (!source) { + return addSegmentInternal( + skipable, + map, + generated.line - 1, + generated.column, + null, + null, + null, + null, + null, + ); + } + assert(original); + return addSegmentInternal( + skipable, + map, + generated.line - 1, + generated.column, + source as string, + original.line - 1, + original.column, + name, + content, + ); +} + +/* +export function addOriginalScope( + map: GenMapping, + data: { + start: Pos; + end: Pos; + source: string; + kind: string; + name?: string; + variables?: string[]; + }, +): OriginalScopeInfo { + const { start, end, source, kind, name, variables } = data; + const { + _sources: sources, + _sourcesContent: sourcesContent, + _originalScopes: originalScopes, + _names: names, + } = cast(map); + const index = put(sources, source); + if (index === sourcesContent.length) sourcesContent[index] = null; + if (index === originalScopes.length) originalScopes[index] = []; + + const kindIndex = put(names, kind); + const scope: OriginalScope = name + ? [start.line - 1, start.column, end.line - 1, end.column, kindIndex, put(names, name)] + : [start.line - 1, start.column, end.line - 1, end.column, kindIndex]; + if (variables) { + scope.vars = variables.map((v) => put(names, v)); + } + const len = originalScopes[index].push(scope); + return [index, len - 1, variables]; +} +*/ + +// Generated Ranges +/* +export function addGeneratedRange( + map: GenMapping, + data: { + start: Pos; + isScope: boolean; + originalScope?: OriginalScopeInfo; + callsite?: OriginalPos; + }, +): GeneratedRangeInfo { + const { start, isScope, originalScope, callsite } = data; + const { + _originalScopes: originalScopes, + _sources: sources, + _sourcesContent: sourcesContent, + _generatedRanges: generatedRanges, + } = cast(map); + + const range: GeneratedRange = [ + start.line - 1, + start.column, + 0, + 0, + originalScope ? originalScope[0] : -1, + originalScope ? originalScope[1] : -1, + ]; + if (originalScope?.[2]) { + range.bindings = originalScope[2].map(() => [[-1]]); + } + if (callsite) { + const index = put(sources, callsite.source); + if (index === sourcesContent.length) sourcesContent[index] = null; + if (index === originalScopes.length) originalScopes[index] = []; + range.callsite = [index, callsite.line - 1, callsite.column]; + } + if (isScope) range.isScope = true; + generatedRanges.push(range); + + return [range, originalScope?.[2]]; +} + +export function setEndPosition(range: GeneratedRangeInfo, pos: Pos) { + range[0][2] = pos.line - 1; + range[0][3] = pos.column; +} + +export function addBinding( + map: GenMapping, + range: GeneratedRangeInfo, + variable: string, + expression: string | BindingExpressionRange, +) { + const { _names: names } = cast(map); + const bindings = (range[0].bindings ||= []); + const vars = range[1]; + + const index = vars!.indexOf(variable); + const binding = getIndex(bindings, index); + + if (typeof expression === 'string') binding[0] = [put(names, expression)]; + else { + const { start } = expression; + binding.push([put(names, expression.expression), start.line - 1, start.column]); + } +} +*/ diff --git a/scripts/node_modules/@jridgewell/gen-mapping/src/set-array.ts b/scripts/node_modules/@jridgewell/gen-mapping/src/set-array.ts new file mode 100644 index 0000000000000000000000000000000000000000..a2a73a5229e176a34a4bb418bd1189999731b7a1 --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/src/set-array.ts @@ -0,0 +1,82 @@ +type Key = string | number | symbol; + +/** + * SetArray acts like a `Set` (allowing only one occurrence of a string `key`), but provides the + * index of the `key` in the backing array. + * + * This is designed to allow synchronizing a second array with the contents of the backing array, + * like how in a sourcemap `sourcesContent[i]` is the source content associated with `source[i]`, + * and there are never duplicates. + */ +export class SetArray { + declare private _indexes: Record; + declare array: readonly T[]; + + constructor() { + this._indexes = { __proto__: null } as any; + this.array = []; + } +} + +interface PublicSet { + array: T[]; + _indexes: SetArray['_indexes']; +} + +/** + * Typescript doesn't allow friend access to private fields, so this just casts the set into a type + * with public access modifiers. + */ +function cast(set: SetArray): PublicSet { + return set as any; +} + +/** + * Gets the index associated with `key` in the backing array, if it is already present. + */ +export function get(setarr: SetArray, key: T): number | undefined { + return cast(setarr)._indexes[key]; +} + +/** + * Puts `key` into the backing array, if it is not already present. Returns + * the index of the `key` in the backing array. + */ +export function put(setarr: SetArray, key: T): number { + // The key may or may not be present. If it is present, it's a number. + const index = get(setarr, key); + if (index !== undefined) return index; + + const { array, _indexes: indexes } = cast(setarr); + + const length = array.push(key); + return (indexes[key] = length - 1); +} + +/** + * Pops the last added item out of the SetArray. + */ +export function pop(setarr: SetArray): void { + const { array, _indexes: indexes } = cast(setarr); + if (array.length === 0) return; + + const last = array.pop()!; + indexes[last] = undefined; +} + +/** + * Removes the key, if it exists in the set. + */ +export function remove(setarr: SetArray, key: T): void { + const index = get(setarr, key); + if (index === undefined) return; + + const { array, _indexes: indexes } = cast(setarr); + for (let i = index + 1; i < array.length; i++) { + const k = array[i]; + array[i - 1] = k; + indexes[k]!--; + } + indexes[key] = undefined; + array.pop(); +} diff --git a/scripts/node_modules/@jridgewell/gen-mapping/src/sourcemap-segment.ts b/scripts/node_modules/@jridgewell/gen-mapping/src/sourcemap-segment.ts new file mode 100644 index 0000000000000000000000000000000000000000..fb296dd30234bc61899000bbcc706e71765264c8 --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/src/sourcemap-segment.ts @@ -0,0 +1,16 @@ +type GeneratedColumn = number; +type SourcesIndex = number; +type SourceLine = number; +type SourceColumn = number; +type NamesIndex = number; + +export type SourceMapSegment = + | [GeneratedColumn] + | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] + | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex]; + +export const COLUMN = 0; +export const SOURCES_INDEX = 1; +export const SOURCE_LINE = 2; +export const SOURCE_COLUMN = 3; +export const NAMES_INDEX = 4; diff --git a/scripts/node_modules/@jridgewell/gen-mapping/src/types.ts b/scripts/node_modules/@jridgewell/gen-mapping/src/types.ts new file mode 100644 index 0000000000000000000000000000000000000000..b087f706a0394e6f8921e92a9c005c3c6ac13de0 --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/src/types.ts @@ -0,0 +1,61 @@ +// import type { GeneratedRange, OriginalScope } from '@jridgewell/sourcemap-codec'; +import type { SourceMapSegment } from './sourcemap-segment'; + +export interface SourceMapV3 { + file?: string | null; + names: readonly string[]; + sourceRoot?: string; + sources: readonly (string | null)[]; + sourcesContent?: readonly (string | null)[]; + version: 3; + ignoreList?: readonly number[]; +} + +export interface EncodedSourceMap extends SourceMapV3 { + mappings: string; + // originalScopes: string[]; + // generatedRanges: string; +} + +export interface DecodedSourceMap extends SourceMapV3 { + mappings: readonly SourceMapSegment[][]; + // originalScopes: readonly OriginalScope[][]; + // generatedRanges: readonly GeneratedRange[]; +} + +export interface Pos { + line: number; // 1-based + column: number; // 0-based +} + +export interface OriginalPos extends Pos { + source: string; +} + +export interface BindingExpressionRange { + start: Pos; + expression: string; +} + +// export type OriginalScopeInfo = [number, number, string[] | undefined]; +// export type GeneratedRangeInfo = [GeneratedRange, string[] | undefined]; + +export type Mapping = + | { + generated: Pos; + source: undefined; + original: undefined; + name: undefined; + } + | { + generated: Pos; + source: string; + original: Pos; + name: string; + } + | { + generated: Pos; + source: string; + original: Pos; + name: undefined; + }; diff --git a/scripts/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.cts b/scripts/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..7618d8572b325324ccde88eb0a046a0bed73626e --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.cts @@ -0,0 +1,89 @@ +import type { SourceMapInput } from '@jridgewell/trace-mapping'; +import type { DecodedSourceMap, EncodedSourceMap, Pos, Mapping } from './types.cts'; +export type { DecodedSourceMap, EncodedSourceMap, Mapping }; +export type Options = { + file?: string | null; + sourceRoot?: string | null; +}; +/** + * Provides the state to generate a sourcemap. + */ +export declare class GenMapping { + private _names; + private _sources; + private _sourcesContent; + private _mappings; + private _ignoreList; + file: string | null | undefined; + sourceRoot: string | null | undefined; + constructor({ file, sourceRoot }?: Options); +} +/** + * A low-level API to associate a generated position with an original source position. Line and + * column here are 0-based, unlike `addMapping`. + */ +export declare function addSegment(map: GenMapping, genLine: number, genColumn: number, source?: null, sourceLine?: null, sourceColumn?: null, name?: null, content?: null): void; +export declare function addSegment(map: GenMapping, genLine: number, genColumn: number, source: string, sourceLine: number, sourceColumn: number, name?: null, content?: string | null): void; +export declare function addSegment(map: GenMapping, genLine: number, genColumn: number, source: string, sourceLine: number, sourceColumn: number, name: string, content?: string | null): void; +/** + * A high-level API to associate a generated position with an original source position. Line is + * 1-based, but column is 0-based, due to legacy behavior in `source-map` library. + */ +export declare function addMapping(map: GenMapping, mapping: { + generated: Pos; + source?: null; + original?: null; + name?: null; + content?: null; +}): void; +export declare function addMapping(map: GenMapping, mapping: { + generated: Pos; + source: string; + original: Pos; + name?: null; + content?: string | null; +}): void; +export declare function addMapping(map: GenMapping, mapping: { + generated: Pos; + source: string; + original: Pos; + name: string; + content?: string | null; +}): void; +/** + * Same as `addSegment`, but will only add the segment if it generates useful information in the + * resulting map. This only works correctly if segments are added **in order**, meaning you should + * not add a segment with a lower generated line/column than one that came before. + */ +export declare const maybeAddSegment: typeof addSegment; +/** + * Same as `addMapping`, but will only add the mapping if it generates useful information in the + * resulting map. This only works correctly if mappings are added **in order**, meaning you should + * not add a mapping with a lower generated line/column than one that came before. + */ +export declare const maybeAddMapping: typeof addMapping; +/** + * Adds/removes the content of the source file to the source map. + */ +export declare function setSourceContent(map: GenMapping, source: string, content: string | null): void; +export declare function setIgnore(map: GenMapping, source: string, ignore?: boolean): void; +/** + * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects + * a sourcemap, or to JSON.stringify. + */ +export declare function toDecodedMap(map: GenMapping): DecodedSourceMap; +/** + * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects + * a sourcemap, or to JSON.stringify. + */ +export declare function toEncodedMap(map: GenMapping): EncodedSourceMap; +/** + * Constructs a new GenMapping, using the already present mappings of the input. + */ +export declare function fromMap(input: SourceMapInput): GenMapping; +/** + * Returns an array of high-level mapping objects for every recorded segment, which could then be + * passed to the `source-map` library. + */ +export declare function allMappings(map: GenMapping): Mapping[]; +//# sourceMappingURL=gen-mapping.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.cts.map b/scripts/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.cts.map new file mode 100644 index 0000000000000000000000000000000000000000..8a2b1835336445da0c96f2785ce5b8625a3af4c7 --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"gen-mapping.d.ts","sourceRoot":"","sources":["../src/gen-mapping.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.mts b/scripts/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..bbc0d89cfd861c2c66cdb2458956c013bd59508e --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.mts @@ -0,0 +1,89 @@ +import type { SourceMapInput } from '@jridgewell/trace-mapping'; +import type { DecodedSourceMap, EncodedSourceMap, Pos, Mapping } from './types.mts'; +export type { DecodedSourceMap, EncodedSourceMap, Mapping }; +export type Options = { + file?: string | null; + sourceRoot?: string | null; +}; +/** + * Provides the state to generate a sourcemap. + */ +export declare class GenMapping { + private _names; + private _sources; + private _sourcesContent; + private _mappings; + private _ignoreList; + file: string | null | undefined; + sourceRoot: string | null | undefined; + constructor({ file, sourceRoot }?: Options); +} +/** + * A low-level API to associate a generated position with an original source position. Line and + * column here are 0-based, unlike `addMapping`. + */ +export declare function addSegment(map: GenMapping, genLine: number, genColumn: number, source?: null, sourceLine?: null, sourceColumn?: null, name?: null, content?: null): void; +export declare function addSegment(map: GenMapping, genLine: number, genColumn: number, source: string, sourceLine: number, sourceColumn: number, name?: null, content?: string | null): void; +export declare function addSegment(map: GenMapping, genLine: number, genColumn: number, source: string, sourceLine: number, sourceColumn: number, name: string, content?: string | null): void; +/** + * A high-level API to associate a generated position with an original source position. Line is + * 1-based, but column is 0-based, due to legacy behavior in `source-map` library. + */ +export declare function addMapping(map: GenMapping, mapping: { + generated: Pos; + source?: null; + original?: null; + name?: null; + content?: null; +}): void; +export declare function addMapping(map: GenMapping, mapping: { + generated: Pos; + source: string; + original: Pos; + name?: null; + content?: string | null; +}): void; +export declare function addMapping(map: GenMapping, mapping: { + generated: Pos; + source: string; + original: Pos; + name: string; + content?: string | null; +}): void; +/** + * Same as `addSegment`, but will only add the segment if it generates useful information in the + * resulting map. This only works correctly if segments are added **in order**, meaning you should + * not add a segment with a lower generated line/column than one that came before. + */ +export declare const maybeAddSegment: typeof addSegment; +/** + * Same as `addMapping`, but will only add the mapping if it generates useful information in the + * resulting map. This only works correctly if mappings are added **in order**, meaning you should + * not add a mapping with a lower generated line/column than one that came before. + */ +export declare const maybeAddMapping: typeof addMapping; +/** + * Adds/removes the content of the source file to the source map. + */ +export declare function setSourceContent(map: GenMapping, source: string, content: string | null): void; +export declare function setIgnore(map: GenMapping, source: string, ignore?: boolean): void; +/** + * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects + * a sourcemap, or to JSON.stringify. + */ +export declare function toDecodedMap(map: GenMapping): DecodedSourceMap; +/** + * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects + * a sourcemap, or to JSON.stringify. + */ +export declare function toEncodedMap(map: GenMapping): EncodedSourceMap; +/** + * Constructs a new GenMapping, using the already present mappings of the input. + */ +export declare function fromMap(input: SourceMapInput): GenMapping; +/** + * Returns an array of high-level mapping objects for every recorded segment, which could then be + * passed to the `source-map` library. + */ +export declare function allMappings(map: GenMapping): Mapping[]; +//# sourceMappingURL=gen-mapping.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.mts.map b/scripts/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..8a2b1835336445da0c96f2785ce5b8625a3af4c7 --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"gen-mapping.d.ts","sourceRoot":"","sources":["../src/gen-mapping.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/gen-mapping/types/set-array.d.cts b/scripts/node_modules/@jridgewell/gen-mapping/types/set-array.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..5d8cda35a7e698625549fc38e9d89a6c7e89fadf --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/types/set-array.d.cts @@ -0,0 +1,33 @@ +type Key = string | number | symbol; +/** + * SetArray acts like a `Set` (allowing only one occurrence of a string `key`), but provides the + * index of the `key` in the backing array. + * + * This is designed to allow synchronizing a second array with the contents of the backing array, + * like how in a sourcemap `sourcesContent[i]` is the source content associated with `source[i]`, + * and there are never duplicates. + */ +export declare class SetArray { + private _indexes; + array: readonly T[]; + constructor(); +} +/** + * Gets the index associated with `key` in the backing array, if it is already present. + */ +export declare function get(setarr: SetArray, key: T): number | undefined; +/** + * Puts `key` into the backing array, if it is not already present. Returns + * the index of the `key` in the backing array. + */ +export declare function put(setarr: SetArray, key: T): number; +/** + * Pops the last added item out of the SetArray. + */ +export declare function pop(setarr: SetArray): void; +/** + * Removes the key, if it exists in the set. + */ +export declare function remove(setarr: SetArray, key: T): void; +export {}; +//# sourceMappingURL=set-array.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/gen-mapping/types/set-array.d.cts.map b/scripts/node_modules/@jridgewell/gen-mapping/types/set-array.d.cts.map new file mode 100644 index 0000000000000000000000000000000000000000..c52b8bcee0042015be193c19481001d8e8fbd01f --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/types/set-array.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"set-array.d.ts","sourceRoot":"","sources":["../src/set-array.ts"],"names":[],"mappings":"AAAA,KAAK,GAAG,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AAEpC;;;;;;;GAOG;AACH,qBAAa,QAAQ,CAAC,CAAC,SAAS,GAAG,GAAG,GAAG;IACvC,QAAgB,QAAQ,CAAgC;IAChD,KAAK,EAAE,SAAS,CAAC,EAAE,CAAC;;CAM7B;AAeD;;GAEG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,MAAM,GAAG,SAAS,CAElF;AAED;;;GAGG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,MAAM,CAStE;AAED;;GAEG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,CAM5D;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,IAAI,CAYvE"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/gen-mapping/types/set-array.d.mts b/scripts/node_modules/@jridgewell/gen-mapping/types/set-array.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..5d8cda35a7e698625549fc38e9d89a6c7e89fadf --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/types/set-array.d.mts @@ -0,0 +1,33 @@ +type Key = string | number | symbol; +/** + * SetArray acts like a `Set` (allowing only one occurrence of a string `key`), but provides the + * index of the `key` in the backing array. + * + * This is designed to allow synchronizing a second array with the contents of the backing array, + * like how in a sourcemap `sourcesContent[i]` is the source content associated with `source[i]`, + * and there are never duplicates. + */ +export declare class SetArray { + private _indexes; + array: readonly T[]; + constructor(); +} +/** + * Gets the index associated with `key` in the backing array, if it is already present. + */ +export declare function get(setarr: SetArray, key: T): number | undefined; +/** + * Puts `key` into the backing array, if it is not already present. Returns + * the index of the `key` in the backing array. + */ +export declare function put(setarr: SetArray, key: T): number; +/** + * Pops the last added item out of the SetArray. + */ +export declare function pop(setarr: SetArray): void; +/** + * Removes the key, if it exists in the set. + */ +export declare function remove(setarr: SetArray, key: T): void; +export {}; +//# sourceMappingURL=set-array.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/gen-mapping/types/set-array.d.mts.map b/scripts/node_modules/@jridgewell/gen-mapping/types/set-array.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..c52b8bcee0042015be193c19481001d8e8fbd01f --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/types/set-array.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"set-array.d.ts","sourceRoot":"","sources":["../src/set-array.ts"],"names":[],"mappings":"AAAA,KAAK,GAAG,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AAEpC;;;;;;;GAOG;AACH,qBAAa,QAAQ,CAAC,CAAC,SAAS,GAAG,GAAG,GAAG;IACvC,QAAgB,QAAQ,CAAgC;IAChD,KAAK,EAAE,SAAS,CAAC,EAAE,CAAC;;CAM7B;AAeD;;GAEG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,MAAM,GAAG,SAAS,CAElF;AAED;;;GAGG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,MAAM,CAStE;AAED;;GAEG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,CAM5D;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,IAAI,CAYvE"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.cts b/scripts/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..68862952d54b0caba765fcd7c04f64bed329756d --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.cts @@ -0,0 +1,13 @@ +type GeneratedColumn = number; +type SourcesIndex = number; +type SourceLine = number; +type SourceColumn = number; +type NamesIndex = number; +export type SourceMapSegment = [GeneratedColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex]; +export declare const COLUMN = 0; +export declare const SOURCES_INDEX = 1; +export declare const SOURCE_LINE = 2; +export declare const SOURCE_COLUMN = 3; +export declare const NAMES_INDEX = 4; +export {}; +//# sourceMappingURL=sourcemap-segment.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.cts.map b/scripts/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.cts.map new file mode 100644 index 0000000000000000000000000000000000000000..23cdc45288829ff39c538527202d24649c8a78ff --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"sourcemap-segment.d.ts","sourceRoot":"","sources":["../src/sourcemap-segment.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG,MAAM,CAAC;AAC9B,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,UAAU,GAAG,MAAM,CAAC;AACzB,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,UAAU,GAAG,MAAM,CAAC;AAEzB,MAAM,MAAM,gBAAgB,GACxB,CAAC,eAAe,CAAC,GACjB,CAAC,eAAe,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,CAAC,GACzD,CAAC,eAAe,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;AAE1E,eAAO,MAAM,MAAM,IAAI,CAAC;AACxB,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,WAAW,IAAI,CAAC;AAC7B,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,WAAW,IAAI,CAAC"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.mts b/scripts/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..68862952d54b0caba765fcd7c04f64bed329756d --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.mts @@ -0,0 +1,13 @@ +type GeneratedColumn = number; +type SourcesIndex = number; +type SourceLine = number; +type SourceColumn = number; +type NamesIndex = number; +export type SourceMapSegment = [GeneratedColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex]; +export declare const COLUMN = 0; +export declare const SOURCES_INDEX = 1; +export declare const SOURCE_LINE = 2; +export declare const SOURCE_COLUMN = 3; +export declare const NAMES_INDEX = 4; +export {}; +//# sourceMappingURL=sourcemap-segment.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.mts.map b/scripts/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..23cdc45288829ff39c538527202d24649c8a78ff --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"sourcemap-segment.d.ts","sourceRoot":"","sources":["../src/sourcemap-segment.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG,MAAM,CAAC;AAC9B,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,UAAU,GAAG,MAAM,CAAC;AACzB,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,UAAU,GAAG,MAAM,CAAC;AAEzB,MAAM,MAAM,gBAAgB,GACxB,CAAC,eAAe,CAAC,GACjB,CAAC,eAAe,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,CAAC,GACzD,CAAC,eAAe,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;AAE1E,eAAO,MAAM,MAAM,IAAI,CAAC;AACxB,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,WAAW,IAAI,CAAC;AAC7B,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,WAAW,IAAI,CAAC"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/gen-mapping/types/types.d.cts b/scripts/node_modules/@jridgewell/gen-mapping/types/types.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..58da00a9fb250d52be96d60c70ee7ccdd1cd0deb --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/types/types.d.cts @@ -0,0 +1,44 @@ +import type { SourceMapSegment } from './sourcemap-segment.cts'; +export interface SourceMapV3 { + file?: string | null; + names: readonly string[]; + sourceRoot?: string; + sources: readonly (string | null)[]; + sourcesContent?: readonly (string | null)[]; + version: 3; + ignoreList?: readonly number[]; +} +export interface EncodedSourceMap extends SourceMapV3 { + mappings: string; +} +export interface DecodedSourceMap extends SourceMapV3 { + mappings: readonly SourceMapSegment[][]; +} +export interface Pos { + line: number; + column: number; +} +export interface OriginalPos extends Pos { + source: string; +} +export interface BindingExpressionRange { + start: Pos; + expression: string; +} +export type Mapping = { + generated: Pos; + source: undefined; + original: undefined; + name: undefined; +} | { + generated: Pos; + source: string; + original: Pos; + name: string; +} | { + generated: Pos; + source: string; + original: Pos; + name: undefined; +}; +//# sourceMappingURL=types.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/gen-mapping/types/types.d.cts.map b/scripts/node_modules/@jridgewell/gen-mapping/types/types.d.cts.map new file mode 100644 index 0000000000000000000000000000000000000000..159e734d5f994f5ed32fcdc1640096994dc12d72 --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/types/types.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IACpC,cAAc,CAAC,EAAE,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IAC5C,OAAO,EAAE,CAAC,CAAC;IACX,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACnD,QAAQ,EAAE,MAAM,CAAC;CAGlB;AAED,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACnD,QAAQ,EAAE,SAAS,gBAAgB,EAAE,EAAE,CAAC;CAGzC;AAED,MAAM,WAAW,GAAG;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,WAAY,SAAQ,GAAG;IACtC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,GAAG,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;CACpB;AAKD,MAAM,MAAM,OAAO,GACf;IACE,SAAS,EAAE,GAAG,CAAC;IACf,MAAM,EAAE,SAAS,CAAC;IAClB,QAAQ,EAAE,SAAS,CAAC;IACpB,IAAI,EAAE,SAAS,CAAC;CACjB,GACD;IACE,SAAS,EAAE,GAAG,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,GAAG,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd,GACD;IACE,SAAS,EAAE,GAAG,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,GAAG,CAAC;IACd,IAAI,EAAE,SAAS,CAAC;CACjB,CAAC"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/gen-mapping/types/types.d.mts b/scripts/node_modules/@jridgewell/gen-mapping/types/types.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e9837ebe53aa653a2a295e60069813f47e456fc3 --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/types/types.d.mts @@ -0,0 +1,44 @@ +import type { SourceMapSegment } from './sourcemap-segment.mts'; +export interface SourceMapV3 { + file?: string | null; + names: readonly string[]; + sourceRoot?: string; + sources: readonly (string | null)[]; + sourcesContent?: readonly (string | null)[]; + version: 3; + ignoreList?: readonly number[]; +} +export interface EncodedSourceMap extends SourceMapV3 { + mappings: string; +} +export interface DecodedSourceMap extends SourceMapV3 { + mappings: readonly SourceMapSegment[][]; +} +export interface Pos { + line: number; + column: number; +} +export interface OriginalPos extends Pos { + source: string; +} +export interface BindingExpressionRange { + start: Pos; + expression: string; +} +export type Mapping = { + generated: Pos; + source: undefined; + original: undefined; + name: undefined; +} | { + generated: Pos; + source: string; + original: Pos; + name: string; +} | { + generated: Pos; + source: string; + original: Pos; + name: undefined; +}; +//# sourceMappingURL=types.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/gen-mapping/types/types.d.mts.map b/scripts/node_modules/@jridgewell/gen-mapping/types/types.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..159e734d5f994f5ed32fcdc1640096994dc12d72 --- /dev/null +++ b/scripts/node_modules/@jridgewell/gen-mapping/types/types.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IACpC,cAAc,CAAC,EAAE,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IAC5C,OAAO,EAAE,CAAC,CAAC;IACX,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACnD,QAAQ,EAAE,MAAM,CAAC;CAGlB;AAED,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACnD,QAAQ,EAAE,SAAS,gBAAgB,EAAE,EAAE,CAAC;CAGzC;AAED,MAAM,WAAW,GAAG;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,WAAY,SAAQ,GAAG;IACtC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,GAAG,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;CACpB;AAKD,MAAM,MAAM,OAAO,GACf;IACE,SAAS,EAAE,GAAG,CAAC;IACf,MAAM,EAAE,SAAS,CAAC;IAClB,QAAQ,EAAE,SAAS,CAAC;IACpB,IAAI,EAAE,SAAS,CAAC;CACjB,GACD;IACE,SAAS,EAAE,GAAG,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,GAAG,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd,GACD;IACE,SAAS,EAAE,GAAG,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,GAAG,CAAC;IACd,IAAI,EAAE,SAAS,CAAC;CACjB,CAAC"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/remapping/LICENSE b/scripts/node_modules/@jridgewell/remapping/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..1f6ce94c11912496b96298630d84753dbf593a7d --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/LICENSE @@ -0,0 +1,19 @@ +Copyright 2024 Justin Ridgewell + +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/scripts/node_modules/@jridgewell/remapping/README.md b/scripts/node_modules/@jridgewell/remapping/README.md new file mode 100644 index 0000000000000000000000000000000000000000..6d092d7eaad3a73a8f094a63b7fe85fe714ef9eb --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/README.md @@ -0,0 +1,218 @@ +# @jridgewell/remapping + +> Remap sequential sourcemaps through transformations to point at the original source code + +Remapping allows you to take the sourcemaps generated through transforming your code and "remap" +them to the original source locations. Think "my minified code, transformed with babel and bundled +with webpack", all pointing to the correct location in your original source code. + +With remapping, none of your source code transformations need to be aware of the input's sourcemap, +they only need to generate an output sourcemap. This greatly simplifies building custom +transformations (think a find-and-replace). + +## Installation + +```sh +npm install @jridgewell/remapping +``` + +## Usage + +```typescript +function remapping( + map: SourceMap | SourceMap[], + loader: (file: string, ctx: LoaderContext) => (SourceMap | null | undefined), + options?: { excludeContent: boolean, decodedMappings: boolean } +): SourceMap; + +// LoaderContext gives the loader the importing sourcemap, tree depth, the ability to override the +// "source" location (where child sources are resolved relative to, or the location of original +// source), and the ability to override the "content" of an original source for inclusion in the +// output sourcemap. +type LoaderContext = { + readonly importer: string; + readonly depth: number; + source: string; + content: string | null | undefined; +} +``` + +`remapping` takes the final output sourcemap, and a `loader` function. For every source file pointer +in the sourcemap, the `loader` will be called with the resolved path. If the path itself represents +a transformed file (it has a sourcmap associated with it), then the `loader` should return that +sourcemap. If not, the path will be treated as an original, untransformed source code. + +```js +// Babel transformed "helloworld.js" into "transformed.js" +const transformedMap = JSON.stringify({ + file: 'transformed.js', + // 1st column of 2nd line of output file translates into the 1st source + // file, line 3, column 2 + mappings: ';CAEE', + sources: ['helloworld.js'], + version: 3, +}); + +// Uglify minified "transformed.js" into "transformed.min.js" +const minifiedTransformedMap = JSON.stringify({ + file: 'transformed.min.js', + // 0th column of 1st line of output file translates into the 1st source + // file, line 2, column 1. + mappings: 'AACC', + names: [], + sources: ['transformed.js'], + version: 3, +}); + +const remapped = remapping( + minifiedTransformedMap, + (file, ctx) => { + + // The "transformed.js" file is an transformed file. + if (file === 'transformed.js') { + // The root importer is empty. + console.assert(ctx.importer === ''); + // The depth in the sourcemap tree we're currently loading. + // The root `minifiedTransformedMap` is depth 0, and its source children are depth 1, etc. + console.assert(ctx.depth === 1); + + return transformedMap; + } + + // Loader will be called to load transformedMap's source file pointers as well. + console.assert(file === 'helloworld.js'); + // `transformed.js`'s sourcemap points into `helloworld.js`. + console.assert(ctx.importer === 'transformed.js'); + // This is a source child of `transformed`, which is a source child of `minifiedTransformedMap`. + console.assert(ctx.depth === 2); + return null; + } +); + +console.log(remapped); +// { +// file: 'transpiled.min.js', +// mappings: 'AAEE', +// sources: ['helloworld.js'], +// version: 3, +// }; +``` + +In this example, `loader` will be called twice: + +1. `"transformed.js"`, the first source file pointer in the `minifiedTransformedMap`. We return the + associated sourcemap for it (its a transformed file, after all) so that sourcemap locations can + be traced through it into the source files it represents. +2. `"helloworld.js"`, our original, unmodified source code. This file does not have a sourcemap, so + we return `null`. + +The `remapped` sourcemap now points from `transformed.min.js` into locations in `helloworld.js`. If +you were to read the `mappings`, it says "0th column of the first line output line points to the 1st +column of the 2nd line of the file `helloworld.js`". + +### Multiple transformations of a file + +As a convenience, if you have multiple single-source transformations of a file, you may pass an +array of sourcemap files in the order of most-recent transformation sourcemap first. Note that this +changes the `importer` and `depth` of each call to our loader. So our above example could have been +written as: + +```js +const remapped = remapping( + [minifiedTransformedMap, transformedMap], + () => null +); + +console.log(remapped); +// { +// file: 'transpiled.min.js', +// mappings: 'AAEE', +// sources: ['helloworld.js'], +// version: 3, +// }; +``` + +### Advanced control of the loading graph + +#### `source` + +The `source` property can overridden to any value to change the location of the current load. Eg, +for an original source file, it allows us to change the location to the original source regardless +of what the sourcemap source entry says. And for transformed files, it allows us to change the +relative resolving location for child sources of the loaded sourcemap. + +```js +const remapped = remapping( + minifiedTransformedMap, + (file, ctx) => { + + if (file === 'transformed.js') { + // We pretend the transformed.js file actually exists in the 'src/' directory. When the nested + // source files are loaded, they will now be relative to `src/`. + ctx.source = 'src/transformed.js'; + return transformedMap; + } + + console.assert(file === 'src/helloworld.js'); + // We could futher change the source of this original file, eg, to be inside a nested directory + // itself. This will be reflected in the remapped sourcemap. + ctx.source = 'src/nested/transformed.js'; + return null; + } +); + +console.log(remapped); +// { +// …, +// sources: ['src/nested/helloworld.js'], +// }; +``` + + +#### `content` + +The `content` property can be overridden when we encounter an original source file. Eg, this allows +you to manually provide the source content of the original file regardless of whether the +`sourcesContent` field is present in the parent sourcemap. It can also be set to `null` to remove +the source content. + +```js +const remapped = remapping( + minifiedTransformedMap, + (file, ctx) => { + + if (file === 'transformed.js') { + // transformedMap does not include a `sourcesContent` field, so usually the remapped sourcemap + // would not include any `sourcesContent` values. + return transformedMap; + } + + console.assert(file === 'helloworld.js'); + // We can read the file to provide the source content. + ctx.content = fs.readFileSync(file, 'utf8'); + return null; + } +); + +console.log(remapped); +// { +// …, +// sourcesContent: [ +// 'console.log("Hello world!")', +// ], +// }; +``` + +### Options + +#### excludeContent + +By default, `excludeContent` is `false`. Passing `{ excludeContent: true }` will exclude the +`sourcesContent` field from the returned sourcemap. This is mainly useful when you want to reduce +the size out the sourcemap. + +#### decodedMappings + +By default, `decodedMappings` is `false`. Passing `{ decodedMappings: true }` will leave the +`mappings` field in a [decoded state](https://github.com/rich-harris/sourcemap-codec) instead of +encoding into a VLQ string. diff --git a/scripts/node_modules/@jridgewell/remapping/dist/remapping.mjs b/scripts/node_modules/@jridgewell/remapping/dist/remapping.mjs new file mode 100644 index 0000000000000000000000000000000000000000..8b7009c049e3188f5fda149852d3e17fd5de4009 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/dist/remapping.mjs @@ -0,0 +1,144 @@ +// src/build-source-map-tree.ts +import { TraceMap } from "@jridgewell/trace-mapping"; + +// src/source-map-tree.ts +import { GenMapping, maybeAddSegment, setIgnore, setSourceContent } from "@jridgewell/gen-mapping"; +import { traceSegment, decodedMappings } from "@jridgewell/trace-mapping"; +var SOURCELESS_MAPPING = /* @__PURE__ */ SegmentObject("", -1, -1, "", null, false); +var EMPTY_SOURCES = []; +function SegmentObject(source, line, column, name, content, ignore) { + return { source, line, column, name, content, ignore }; +} +function Source(map, sources, source, content, ignore) { + return { + map, + sources, + source, + content, + ignore + }; +} +function MapSource(map, sources) { + return Source(map, sources, "", null, false); +} +function OriginalSource(source, content, ignore) { + return Source(null, EMPTY_SOURCES, source, content, ignore); +} +function traceMappings(tree) { + const gen = new GenMapping({ file: tree.map.file }); + const { sources: rootSources, map } = tree; + const rootNames = map.names; + const rootMappings = decodedMappings(map); + for (let i = 0; i < rootMappings.length; i++) { + const segments = rootMappings[i]; + for (let j = 0; j < segments.length; j++) { + const segment = segments[j]; + const genCol = segment[0]; + let traced = SOURCELESS_MAPPING; + if (segment.length !== 1) { + const source2 = rootSources[segment[1]]; + traced = originalPositionFor( + source2, + segment[2], + segment[3], + segment.length === 5 ? rootNames[segment[4]] : "" + ); + if (traced == null) continue; + } + const { column, line, name, content, source, ignore } = traced; + maybeAddSegment(gen, i, genCol, source, line, column, name); + if (source && content != null) setSourceContent(gen, source, content); + if (ignore) setIgnore(gen, source, true); + } + } + return gen; +} +function originalPositionFor(source, line, column, name) { + if (!source.map) { + return SegmentObject(source.source, line, column, name, source.content, source.ignore); + } + const segment = traceSegment(source.map, line, column); + if (segment == null) return null; + if (segment.length === 1) return SOURCELESS_MAPPING; + return originalPositionFor( + source.sources[segment[1]], + segment[2], + segment[3], + segment.length === 5 ? source.map.names[segment[4]] : name + ); +} + +// src/build-source-map-tree.ts +function asArray(value) { + if (Array.isArray(value)) return value; + return [value]; +} +function buildSourceMapTree(input, loader) { + const maps = asArray(input).map((m) => new TraceMap(m, "")); + const map = maps.pop(); + for (let i = 0; i < maps.length; i++) { + if (maps[i].sources.length > 1) { + throw new Error( + `Transformation map ${i} must have exactly one source file. +Did you specify these with the most recent transformation maps first?` + ); + } + } + let tree = build(map, loader, "", 0); + for (let i = maps.length - 1; i >= 0; i--) { + tree = MapSource(maps[i], [tree]); + } + return tree; +} +function build(map, loader, importer, importerDepth) { + const { resolvedSources, sourcesContent, ignoreList } = map; + const depth = importerDepth + 1; + const children = resolvedSources.map((sourceFile, i) => { + const ctx = { + importer, + depth, + source: sourceFile || "", + content: void 0, + ignore: void 0 + }; + const sourceMap = loader(ctx.source, ctx); + const { source, content, ignore } = ctx; + if (sourceMap) return build(new TraceMap(sourceMap, source), loader, source, depth); + const sourceContent = content !== void 0 ? content : sourcesContent ? sourcesContent[i] : null; + const ignored = ignore !== void 0 ? ignore : ignoreList ? ignoreList.includes(i) : false; + return OriginalSource(source, sourceContent, ignored); + }); + return MapSource(map, children); +} + +// src/source-map.ts +import { toDecodedMap, toEncodedMap } from "@jridgewell/gen-mapping"; +var SourceMap = class { + constructor(map, options) { + const out = options.decodedMappings ? toDecodedMap(map) : toEncodedMap(map); + this.version = out.version; + this.file = out.file; + this.mappings = out.mappings; + this.names = out.names; + this.ignoreList = out.ignoreList; + this.sourceRoot = out.sourceRoot; + this.sources = out.sources; + if (!options.excludeContent) { + this.sourcesContent = out.sourcesContent; + } + } + toString() { + return JSON.stringify(this); + } +}; + +// src/remapping.ts +function remapping(input, loader, options) { + const opts = typeof options === "object" ? options : { excludeContent: !!options, decodedMappings: false }; + const tree = buildSourceMapTree(input, loader); + return new SourceMap(traceMappings(tree), opts); +} +export { + remapping as default +}; +//# sourceMappingURL=remapping.mjs.map diff --git a/scripts/node_modules/@jridgewell/remapping/dist/remapping.mjs.map b/scripts/node_modules/@jridgewell/remapping/dist/remapping.mjs.map new file mode 100644 index 0000000000000000000000000000000000000000..66801e6d1c7566a5873a127112df792aac35347d --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/dist/remapping.mjs.map @@ -0,0 +1,6 @@ +{ + "version": 3, + "sources": ["../src/build-source-map-tree.ts", "../src/source-map-tree.ts", "../src/source-map.ts", "../src/remapping.ts"], + "mappings": "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", + "names": ["source"] +} diff --git a/scripts/node_modules/@jridgewell/remapping/dist/remapping.umd.js b/scripts/node_modules/@jridgewell/remapping/dist/remapping.umd.js new file mode 100644 index 0000000000000000000000000000000000000000..077eb4d5dc61564539a2f580533940f4f5ad7e23 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/dist/remapping.umd.js @@ -0,0 +1,212 @@ +(function (global, factory) { + if (typeof exports === 'object' && typeof module !== 'undefined') { + factory(module, require('@jridgewell/gen-mapping'), require('@jridgewell/trace-mapping')); + module.exports = def(module); + } else if (typeof define === 'function' && define.amd) { + define(['module', '@jridgewell/gen-mapping', '@jridgewell/trace-mapping'], function(mod) { + factory.apply(this, arguments); + mod.exports = def(mod); + }); + } else { + const mod = { exports: {} }; + factory(mod, global.genMapping, global.traceMapping); + global = typeof globalThis !== 'undefined' ? globalThis : global || self; + global.remapping = def(mod); + } + function def(m) { return 'default' in m.exports ? m.exports.default : m.exports; } +})(this, (function (module, require_genMapping, require_traceMapping) { +"use strict"; +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// umd:@jridgewell/trace-mapping +var require_trace_mapping = __commonJS({ + "umd:@jridgewell/trace-mapping"(exports, module2) { + module2.exports = require_traceMapping; + } +}); + +// umd:@jridgewell/gen-mapping +var require_gen_mapping = __commonJS({ + "umd:@jridgewell/gen-mapping"(exports, module2) { + module2.exports = require_genMapping; + } +}); + +// src/remapping.ts +var remapping_exports = {}; +__export(remapping_exports, { + default: () => remapping +}); +module.exports = __toCommonJS(remapping_exports); + +// src/build-source-map-tree.ts +var import_trace_mapping2 = __toESM(require_trace_mapping()); + +// src/source-map-tree.ts +var import_gen_mapping = __toESM(require_gen_mapping()); +var import_trace_mapping = __toESM(require_trace_mapping()); +var SOURCELESS_MAPPING = /* @__PURE__ */ SegmentObject("", -1, -1, "", null, false); +var EMPTY_SOURCES = []; +function SegmentObject(source, line, column, name, content, ignore) { + return { source, line, column, name, content, ignore }; +} +function Source(map, sources, source, content, ignore) { + return { + map, + sources, + source, + content, + ignore + }; +} +function MapSource(map, sources) { + return Source(map, sources, "", null, false); +} +function OriginalSource(source, content, ignore) { + return Source(null, EMPTY_SOURCES, source, content, ignore); +} +function traceMappings(tree) { + const gen = new import_gen_mapping.GenMapping({ file: tree.map.file }); + const { sources: rootSources, map } = tree; + const rootNames = map.names; + const rootMappings = (0, import_trace_mapping.decodedMappings)(map); + for (let i = 0; i < rootMappings.length; i++) { + const segments = rootMappings[i]; + for (let j = 0; j < segments.length; j++) { + const segment = segments[j]; + const genCol = segment[0]; + let traced = SOURCELESS_MAPPING; + if (segment.length !== 1) { + const source2 = rootSources[segment[1]]; + traced = originalPositionFor( + source2, + segment[2], + segment[3], + segment.length === 5 ? rootNames[segment[4]] : "" + ); + if (traced == null) continue; + } + const { column, line, name, content, source, ignore } = traced; + (0, import_gen_mapping.maybeAddSegment)(gen, i, genCol, source, line, column, name); + if (source && content != null) (0, import_gen_mapping.setSourceContent)(gen, source, content); + if (ignore) (0, import_gen_mapping.setIgnore)(gen, source, true); + } + } + return gen; +} +function originalPositionFor(source, line, column, name) { + if (!source.map) { + return SegmentObject(source.source, line, column, name, source.content, source.ignore); + } + const segment = (0, import_trace_mapping.traceSegment)(source.map, line, column); + if (segment == null) return null; + if (segment.length === 1) return SOURCELESS_MAPPING; + return originalPositionFor( + source.sources[segment[1]], + segment[2], + segment[3], + segment.length === 5 ? source.map.names[segment[4]] : name + ); +} + +// src/build-source-map-tree.ts +function asArray(value) { + if (Array.isArray(value)) return value; + return [value]; +} +function buildSourceMapTree(input, loader) { + const maps = asArray(input).map((m) => new import_trace_mapping2.TraceMap(m, "")); + const map = maps.pop(); + for (let i = 0; i < maps.length; i++) { + if (maps[i].sources.length > 1) { + throw new Error( + `Transformation map ${i} must have exactly one source file. +Did you specify these with the most recent transformation maps first?` + ); + } + } + let tree = build(map, loader, "", 0); + for (let i = maps.length - 1; i >= 0; i--) { + tree = MapSource(maps[i], [tree]); + } + return tree; +} +function build(map, loader, importer, importerDepth) { + const { resolvedSources, sourcesContent, ignoreList } = map; + const depth = importerDepth + 1; + const children = resolvedSources.map((sourceFile, i) => { + const ctx = { + importer, + depth, + source: sourceFile || "", + content: void 0, + ignore: void 0 + }; + const sourceMap = loader(ctx.source, ctx); + const { source, content, ignore } = ctx; + if (sourceMap) return build(new import_trace_mapping2.TraceMap(sourceMap, source), loader, source, depth); + const sourceContent = content !== void 0 ? content : sourcesContent ? sourcesContent[i] : null; + const ignored = ignore !== void 0 ? ignore : ignoreList ? ignoreList.includes(i) : false; + return OriginalSource(source, sourceContent, ignored); + }); + return MapSource(map, children); +} + +// src/source-map.ts +var import_gen_mapping2 = __toESM(require_gen_mapping()); +var SourceMap = class { + constructor(map, options) { + const out = options.decodedMappings ? (0, import_gen_mapping2.toDecodedMap)(map) : (0, import_gen_mapping2.toEncodedMap)(map); + this.version = out.version; + this.file = out.file; + this.mappings = out.mappings; + this.names = out.names; + this.ignoreList = out.ignoreList; + this.sourceRoot = out.sourceRoot; + this.sources = out.sources; + if (!options.excludeContent) { + this.sourcesContent = out.sourcesContent; + } + } + toString() { + return JSON.stringify(this); + } +}; + +// src/remapping.ts +function remapping(input, loader, options) { + const opts = typeof options === "object" ? options : { excludeContent: !!options, decodedMappings: false }; + const tree = buildSourceMapTree(input, loader); + return new SourceMap(traceMappings(tree), opts); +} +})); +//# sourceMappingURL=remapping.umd.js.map diff --git a/scripts/node_modules/@jridgewell/remapping/dist/remapping.umd.js.map b/scripts/node_modules/@jridgewell/remapping/dist/remapping.umd.js.map new file mode 100644 index 0000000000000000000000000000000000000000..d5e0786411414c3565f1914751a7a1c0073153eb --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/dist/remapping.umd.js.map @@ -0,0 +1,6 @@ +{ + "version": 3, + "sources": ["umd:@jridgewell/trace-mapping", "umd:@jridgewell/gen-mapping", "../src/remapping.ts", "../src/build-source-map-tree.ts", "../src/source-map-tree.ts", "../src/source-map.ts"], + "mappings": "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", + "names": ["module", "module", "import_trace_mapping", "source", "import_gen_mapping"] +} diff --git a/scripts/node_modules/@jridgewell/remapping/package.json b/scripts/node_modules/@jridgewell/remapping/package.json new file mode 100644 index 0000000000000000000000000000000000000000..ed00441ea559a1546bd16b7915e2e9fe6e7708bb --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/package.json @@ -0,0 +1,71 @@ +{ + "name": "@jridgewell/remapping", + "version": "2.3.5", + "description": "Remap sequential sourcemaps through transformations to point at the original source code", + "keywords": [ + "source", + "map", + "remap" + ], + "main": "dist/remapping.umd.js", + "module": "dist/remapping.mjs", + "types": "types/remapping.d.cts", + "files": [ + "dist", + "src", + "types" + ], + "exports": { + ".": [ + { + "import": { + "types": "./types/remapping.d.mts", + "default": "./dist/remapping.mjs" + }, + "default": { + "types": "./types/remapping.d.cts", + "default": "./dist/remapping.umd.js" + } + }, + "./dist/remapping.umd.js" + ], + "./package.json": "./package.json" + }, + "scripts": { + "benchmark": "run-s build:code benchmark:*", + "benchmark:install": "cd benchmark && npm install", + "benchmark:only": "node --expose-gc benchmark/index.js", + "build": "run-s -n build:code build:types", + "build:code": "node ../../esbuild.mjs remapping.ts", + "build:types": "run-s build:types:force build:types:emit build:types:mts", + "build:types:force": "rimraf tsconfig.build.tsbuildinfo", + "build:types:emit": "tsc --project tsconfig.build.json", + "build:types:mts": "node ../../mts-types.mjs", + "clean": "run-s -n clean:code clean:types", + "clean:code": "tsc --build --clean tsconfig.build.json", + "clean:types": "rimraf dist types", + "test": "run-s -n test:types test:only test:format", + "test:format": "prettier --check '{src,test}/**/*.ts'", + "test:only": "mocha", + "test:types": "eslint '{src,test}/**/*.ts'", + "lint": "run-s -n lint:types lint:format", + "lint:format": "npm run test:format -- --write", + "lint:types": "npm run test:types -- --fix", + "prepublishOnly": "npm run-s -n build test" + }, + "homepage": "https://github.com/jridgewell/sourcemaps/tree/main/packages/remapping", + "repository": { + "type": "git", + "url": "git+https://github.com/jridgewell/sourcemaps.git", + "directory": "packages/remapping" + }, + "author": "Justin Ridgewell ", + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.24" + }, + "devDependencies": { + "source-map": "0.6.1" + } +} diff --git a/scripts/node_modules/@jridgewell/remapping/src/build-source-map-tree.ts b/scripts/node_modules/@jridgewell/remapping/src/build-source-map-tree.ts new file mode 100644 index 0000000000000000000000000000000000000000..3e0262bd7c981be3b510203ea08841ea1a47fc89 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/src/build-source-map-tree.ts @@ -0,0 +1,89 @@ +import { TraceMap } from '@jridgewell/trace-mapping'; + +import { OriginalSource, MapSource } from './source-map-tree'; + +import type { Sources, MapSource as MapSourceType } from './source-map-tree'; +import type { SourceMapInput, SourceMapLoader, LoaderContext } from './types'; + +function asArray(value: T | T[]): T[] { + if (Array.isArray(value)) return value; + return [value]; +} + +/** + * Recursively builds a tree structure out of sourcemap files, with each node + * being either an `OriginalSource` "leaf" or a `SourceMapTree` composed of + * `OriginalSource`s and `SourceMapTree`s. + * + * Every sourcemap is composed of a collection of source files and mappings + * into locations of those source files. When we generate a `SourceMapTree` for + * the sourcemap, we attempt to load each source file's own sourcemap. If it + * does not have an associated sourcemap, it is considered an original, + * unmodified source file. + */ +export default function buildSourceMapTree( + input: SourceMapInput | SourceMapInput[], + loader: SourceMapLoader, +): MapSourceType { + const maps = asArray(input).map((m) => new TraceMap(m, '')); + const map = maps.pop()!; + + for (let i = 0; i < maps.length; i++) { + if (maps[i].sources.length > 1) { + throw new Error( + `Transformation map ${i} must have exactly one source file.\n` + + 'Did you specify these with the most recent transformation maps first?', + ); + } + } + + let tree = build(map, loader, '', 0); + for (let i = maps.length - 1; i >= 0; i--) { + tree = MapSource(maps[i], [tree]); + } + return tree; +} + +function build( + map: TraceMap, + loader: SourceMapLoader, + importer: string, + importerDepth: number, +): MapSourceType { + const { resolvedSources, sourcesContent, ignoreList } = map; + + const depth = importerDepth + 1; + const children = resolvedSources.map((sourceFile: string | null, i: number): Sources => { + // The loading context gives the loader more information about why this file is being loaded + // (eg, from which importer). It also allows the loader to override the location of the loaded + // sourcemap/original source, or to override the content in the sourcesContent field if it's + // an unmodified source file. + const ctx: LoaderContext = { + importer, + depth, + source: sourceFile || '', + content: undefined, + ignore: undefined, + }; + + // Use the provided loader callback to retrieve the file's sourcemap. + // TODO: We should eventually support async loading of sourcemap files. + const sourceMap = loader(ctx.source, ctx); + + const { source, content, ignore } = ctx; + + // If there is a sourcemap, then we need to recurse into it to load its source files. + if (sourceMap) return build(new TraceMap(sourceMap, source), loader, source, depth); + + // Else, it's an unmodified source file. + // The contents of this unmodified source file can be overridden via the loader context, + // allowing it to be explicitly null or a string. If it remains undefined, we fall back to + // the importing sourcemap's `sourcesContent` field. + const sourceContent = + content !== undefined ? content : sourcesContent ? sourcesContent[i] : null; + const ignored = ignore !== undefined ? ignore : ignoreList ? ignoreList.includes(i) : false; + return OriginalSource(source, sourceContent, ignored); + }); + + return MapSource(map, children); +} diff --git a/scripts/node_modules/@jridgewell/remapping/src/remapping.ts b/scripts/node_modules/@jridgewell/remapping/src/remapping.ts new file mode 100644 index 0000000000000000000000000000000000000000..c0f8b0ded2debe99b5f94b84ba7ce76dc04dafac --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/src/remapping.ts @@ -0,0 +1,42 @@ +import buildSourceMapTree from './build-source-map-tree'; +import { traceMappings } from './source-map-tree'; +import SourceMap from './source-map'; + +import type { SourceMapInput, SourceMapLoader, Options } from './types'; +export type { + SourceMapSegment, + EncodedSourceMap, + EncodedSourceMap as RawSourceMap, + DecodedSourceMap, + SourceMapInput, + SourceMapLoader, + LoaderContext, + Options, +} from './types'; +export type { SourceMap }; + +/** + * Traces through all the mappings in the root sourcemap, through the sources + * (and their sourcemaps), all the way back to the original source location. + * + * `loader` will be called every time we encounter a source file. If it returns + * a sourcemap, we will recurse into that sourcemap to continue the trace. If + * it returns a falsey value, that source file is treated as an original, + * unmodified source file. + * + * Pass `excludeContent` to exclude any self-containing source file content + * from the output sourcemap. + * + * Pass `decodedMappings` to receive a SourceMap with decoded (instead of + * VLQ encoded) mappings. + */ +export default function remapping( + input: SourceMapInput | SourceMapInput[], + loader: SourceMapLoader, + options?: boolean | Options, +): SourceMap { + const opts = + typeof options === 'object' ? options : { excludeContent: !!options, decodedMappings: false }; + const tree = buildSourceMapTree(input, loader); + return new SourceMap(traceMappings(tree), opts); +} diff --git a/scripts/node_modules/@jridgewell/remapping/src/source-map-tree.ts b/scripts/node_modules/@jridgewell/remapping/src/source-map-tree.ts new file mode 100644 index 0000000000000000000000000000000000000000..935240f913436d8ad8c0a2befedeb270f820dad0 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/src/source-map-tree.ts @@ -0,0 +1,172 @@ +import { GenMapping, maybeAddSegment, setIgnore, setSourceContent } from '@jridgewell/gen-mapping'; +import { traceSegment, decodedMappings } from '@jridgewell/trace-mapping'; + +import type { TraceMap } from '@jridgewell/trace-mapping'; + +export type SourceMapSegmentObject = { + column: number; + line: number; + name: string; + source: string; + content: string | null; + ignore: boolean; +}; + +export type OriginalSource = { + map: null; + sources: Sources[]; + source: string; + content: string | null; + ignore: boolean; +}; + +export type MapSource = { + map: TraceMap; + sources: Sources[]; + source: string; + content: null; + ignore: false; +}; + +export type Sources = OriginalSource | MapSource; + +const SOURCELESS_MAPPING = /* #__PURE__ */ SegmentObject('', -1, -1, '', null, false); +const EMPTY_SOURCES: Sources[] = []; + +function SegmentObject( + source: string, + line: number, + column: number, + name: string, + content: string | null, + ignore: boolean, +): SourceMapSegmentObject { + return { source, line, column, name, content, ignore }; +} + +function Source( + map: TraceMap, + sources: Sources[], + source: '', + content: null, + ignore: false, +): MapSource; +function Source( + map: null, + sources: Sources[], + source: string, + content: string | null, + ignore: boolean, +): OriginalSource; +function Source( + map: TraceMap | null, + sources: Sources[], + source: string | '', + content: string | null, + ignore: boolean, +): Sources { + return { + map, + sources, + source, + content, + ignore, + } as any; +} + +/** + * MapSource represents a single sourcemap, with the ability to trace mappings into its child nodes + * (which may themselves be SourceMapTrees). + */ +export function MapSource(map: TraceMap, sources: Sources[]): MapSource { + return Source(map, sources, '', null, false); +} + +/** + * A "leaf" node in the sourcemap tree, representing an original, unmodified source file. Recursive + * segment tracing ends at the `OriginalSource`. + */ +export function OriginalSource( + source: string, + content: string | null, + ignore: boolean, +): OriginalSource { + return Source(null, EMPTY_SOURCES, source, content, ignore); +} + +/** + * traceMappings is only called on the root level SourceMapTree, and begins the process of + * resolving each mapping in terms of the original source files. + */ +export function traceMappings(tree: MapSource): GenMapping { + // TODO: Eventually support sourceRoot, which has to be removed because the sources are already + // fully resolved. We'll need to make sources relative to the sourceRoot before adding them. + const gen = new GenMapping({ file: tree.map.file }); + const { sources: rootSources, map } = tree; + const rootNames = map.names; + const rootMappings = decodedMappings(map); + + for (let i = 0; i < rootMappings.length; i++) { + const segments = rootMappings[i]; + + for (let j = 0; j < segments.length; j++) { + const segment = segments[j]; + const genCol = segment[0]; + let traced: SourceMapSegmentObject | null = SOURCELESS_MAPPING; + + // 1-length segments only move the current generated column, there's no source information + // to gather from it. + if (segment.length !== 1) { + const source = rootSources[segment[1]]; + traced = originalPositionFor( + source, + segment[2], + segment[3], + segment.length === 5 ? rootNames[segment[4]] : '', + ); + + // If the trace is invalid, then the trace ran into a sourcemap that doesn't contain a + // respective segment into an original source. + if (traced == null) continue; + } + + const { column, line, name, content, source, ignore } = traced; + + maybeAddSegment(gen, i, genCol, source, line, column, name); + if (source && content != null) setSourceContent(gen, source, content); + if (ignore) setIgnore(gen, source, true); + } + } + + return gen; +} + +/** + * originalPositionFor is only called on children SourceMapTrees. It recurses down into its own + * child SourceMapTrees, until we find the original source map. + */ +export function originalPositionFor( + source: Sources, + line: number, + column: number, + name: string, +): SourceMapSegmentObject | null { + if (!source.map) { + return SegmentObject(source.source, line, column, name, source.content, source.ignore); + } + + const segment = traceSegment(source.map, line, column); + + // If we couldn't find a segment, then this doesn't exist in the sourcemap. + if (segment == null) return null; + // 1-length segments only move the current generated column, there's no source information + // to gather from it. + if (segment.length === 1) return SOURCELESS_MAPPING; + + return originalPositionFor( + source.sources[segment[1]], + segment[2], + segment[3], + segment.length === 5 ? source.map.names[segment[4]] : name, + ); +} diff --git a/scripts/node_modules/@jridgewell/remapping/src/source-map.ts b/scripts/node_modules/@jridgewell/remapping/src/source-map.ts new file mode 100644 index 0000000000000000000000000000000000000000..5156086f210f4b7264601aa83a6639d9b076b284 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/src/source-map.ts @@ -0,0 +1,38 @@ +import { toDecodedMap, toEncodedMap } from '@jridgewell/gen-mapping'; + +import type { GenMapping } from '@jridgewell/gen-mapping'; +import type { DecodedSourceMap, EncodedSourceMap, Options } from './types'; + +/** + * A SourceMap v3 compatible sourcemap, which only includes fields that were + * provided to it. + */ +export default class SourceMap { + declare file?: string | null; + declare mappings: EncodedSourceMap['mappings'] | DecodedSourceMap['mappings']; + declare sourceRoot?: string; + declare names: string[]; + declare sources: (string | null)[]; + declare sourcesContent?: (string | null)[]; + declare version: 3; + declare ignoreList: number[] | undefined; + + constructor(map: GenMapping, options: Options) { + const out = options.decodedMappings ? toDecodedMap(map) : toEncodedMap(map); + this.version = out.version; // SourceMap spec says this should be first. + this.file = out.file; + this.mappings = out.mappings as SourceMap['mappings']; + this.names = out.names as SourceMap['names']; + this.ignoreList = out.ignoreList as SourceMap['ignoreList']; + this.sourceRoot = out.sourceRoot; + + this.sources = out.sources as SourceMap['sources']; + if (!options.excludeContent) { + this.sourcesContent = out.sourcesContent as SourceMap['sourcesContent']; + } + } + + toString(): string { + return JSON.stringify(this); + } +} diff --git a/scripts/node_modules/@jridgewell/remapping/src/types.ts b/scripts/node_modules/@jridgewell/remapping/src/types.ts new file mode 100644 index 0000000000000000000000000000000000000000..384961d20d5f6933d9c7f47fc753e934a6cbebc8 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/src/types.ts @@ -0,0 +1,27 @@ +import type { SourceMapInput } from '@jridgewell/trace-mapping'; + +export type { + SourceMapSegment, + DecodedSourceMap, + EncodedSourceMap, +} from '@jridgewell/trace-mapping'; + +export type { SourceMapInput }; + +export type LoaderContext = { + readonly importer: string; + readonly depth: number; + source: string; + content: string | null | undefined; + ignore: boolean | undefined; +}; + +export type SourceMapLoader = ( + file: string, + ctx: LoaderContext, +) => SourceMapInput | null | undefined | void; + +export type Options = { + excludeContent?: boolean; + decodedMappings?: boolean; +}; diff --git a/scripts/node_modules/@jridgewell/remapping/types/build-source-map-tree.d.cts b/scripts/node_modules/@jridgewell/remapping/types/build-source-map-tree.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..e089aeaab3a0fba9c7d264f0f65eff992180e036 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/types/build-source-map-tree.d.cts @@ -0,0 +1,15 @@ +import type { MapSource as MapSourceType } from './source-map-tree.cts'; +import type { SourceMapInput, SourceMapLoader } from './types.cts'; +/** + * Recursively builds a tree structure out of sourcemap files, with each node + * being either an `OriginalSource` "leaf" or a `SourceMapTree` composed of + * `OriginalSource`s and `SourceMapTree`s. + * + * Every sourcemap is composed of a collection of source files and mappings + * into locations of those source files. When we generate a `SourceMapTree` for + * the sourcemap, we attempt to load each source file's own sourcemap. If it + * does not have an associated sourcemap, it is considered an original, + * unmodified source file. + */ +export = function buildSourceMapTree(input: SourceMapInput | SourceMapInput[], loader: SourceMapLoader): MapSourceType; +//# sourceMappingURL=build-source-map-tree.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/remapping/types/build-source-map-tree.d.cts.map b/scripts/node_modules/@jridgewell/remapping/types/build-source-map-tree.d.cts.map new file mode 100644 index 0000000000000000000000000000000000000000..38e4290dbeacd537e9c3dc783c6848dfe441e5e3 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/types/build-source-map-tree.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"build-source-map-tree.d.ts","sourceRoot":"","sources":["../src/build-source-map-tree.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAW,SAAS,IAAI,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAC7E,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAiB,MAAM,SAAS,CAAC;AAO9E;;;;;;;;;;GAUG;AACH,MAAM,CAAC,OAAO,UAAU,kBAAkB,CACxC,KAAK,EAAE,cAAc,GAAG,cAAc,EAAE,EACxC,MAAM,EAAE,eAAe,GACtB,aAAa,CAkBf"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/remapping/types/build-source-map-tree.d.mts b/scripts/node_modules/@jridgewell/remapping/types/build-source-map-tree.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..746ac5f730888a0ca6c071ec975b64291537ee57 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/types/build-source-map-tree.d.mts @@ -0,0 +1,15 @@ +import type { MapSource as MapSourceType } from './source-map-tree.mts'; +import type { SourceMapInput, SourceMapLoader } from './types.mts'; +/** + * Recursively builds a tree structure out of sourcemap files, with each node + * being either an `OriginalSource` "leaf" or a `SourceMapTree` composed of + * `OriginalSource`s and `SourceMapTree`s. + * + * Every sourcemap is composed of a collection of source files and mappings + * into locations of those source files. When we generate a `SourceMapTree` for + * the sourcemap, we attempt to load each source file's own sourcemap. If it + * does not have an associated sourcemap, it is considered an original, + * unmodified source file. + */ +export default function buildSourceMapTree(input: SourceMapInput | SourceMapInput[], loader: SourceMapLoader): MapSourceType; +//# sourceMappingURL=build-source-map-tree.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/remapping/types/build-source-map-tree.d.mts.map b/scripts/node_modules/@jridgewell/remapping/types/build-source-map-tree.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..38e4290dbeacd537e9c3dc783c6848dfe441e5e3 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/types/build-source-map-tree.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"build-source-map-tree.d.ts","sourceRoot":"","sources":["../src/build-source-map-tree.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAW,SAAS,IAAI,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAC7E,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAiB,MAAM,SAAS,CAAC;AAO9E;;;;;;;;;;GAUG;AACH,MAAM,CAAC,OAAO,UAAU,kBAAkB,CACxC,KAAK,EAAE,cAAc,GAAG,cAAc,EAAE,EACxC,MAAM,EAAE,eAAe,GACtB,aAAa,CAkBf"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/remapping/types/remapping.d.cts b/scripts/node_modules/@jridgewell/remapping/types/remapping.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..2022784752343ea9079b466504b00f93026e4f93 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/types/remapping.d.cts @@ -0,0 +1,21 @@ +import SourceMap from './source-map.cts'; +import type { SourceMapInput, SourceMapLoader, Options } from './types.cts'; +export type { SourceMapSegment, EncodedSourceMap, EncodedSourceMap as RawSourceMap, DecodedSourceMap, SourceMapInput, SourceMapLoader, LoaderContext, Options, } from './types.cts'; +export type { SourceMap }; +/** + * Traces through all the mappings in the root sourcemap, through the sources + * (and their sourcemaps), all the way back to the original source location. + * + * `loader` will be called every time we encounter a source file. If it returns + * a sourcemap, we will recurse into that sourcemap to continue the trace. If + * it returns a falsey value, that source file is treated as an original, + * unmodified source file. + * + * Pass `excludeContent` to exclude any self-containing source file content + * from the output sourcemap. + * + * Pass `decodedMappings` to receive a SourceMap with decoded (instead of + * VLQ encoded) mappings. + */ +export = function remapping(input: SourceMapInput | SourceMapInput[], loader: SourceMapLoader, options?: boolean | Options): SourceMap; +//# sourceMappingURL=remapping.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/remapping/types/remapping.d.cts.map b/scripts/node_modules/@jridgewell/remapping/types/remapping.d.cts.map new file mode 100644 index 0000000000000000000000000000000000000000..9f2fd0efd61b77ee14bd4aa44f5e597e1b8ffcdf --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/types/remapping.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"remapping.d.ts","sourceRoot":"","sources":["../src/remapping.ts"],"names":[],"mappings":"AAEA,OAAO,SAAS,MAAM,cAAc,CAAC;AAErC,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AACxE,YAAY,EACV,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,IAAI,YAAY,EAChC,gBAAgB,EAChB,cAAc,EACd,eAAe,EACf,aAAa,EACb,OAAO,GACR,MAAM,SAAS,CAAC;AACjB,YAAY,EAAE,SAAS,EAAE,CAAC;AAE1B;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,KAAK,EAAE,cAAc,GAAG,cAAc,EAAE,EACxC,MAAM,EAAE,eAAe,EACvB,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,GAC1B,SAAS,CAKX"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/remapping/types/remapping.d.mts b/scripts/node_modules/@jridgewell/remapping/types/remapping.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..95c406698754b2f70d5040ff33c1a332ac18e266 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/types/remapping.d.mts @@ -0,0 +1,21 @@ +import SourceMap from './source-map.mts'; +import type { SourceMapInput, SourceMapLoader, Options } from './types.mts'; +export type { SourceMapSegment, EncodedSourceMap, EncodedSourceMap as RawSourceMap, DecodedSourceMap, SourceMapInput, SourceMapLoader, LoaderContext, Options, } from './types.mts'; +export type { SourceMap }; +/** + * Traces through all the mappings in the root sourcemap, through the sources + * (and their sourcemaps), all the way back to the original source location. + * + * `loader` will be called every time we encounter a source file. If it returns + * a sourcemap, we will recurse into that sourcemap to continue the trace. If + * it returns a falsey value, that source file is treated as an original, + * unmodified source file. + * + * Pass `excludeContent` to exclude any self-containing source file content + * from the output sourcemap. + * + * Pass `decodedMappings` to receive a SourceMap with decoded (instead of + * VLQ encoded) mappings. + */ +export default function remapping(input: SourceMapInput | SourceMapInput[], loader: SourceMapLoader, options?: boolean | Options): SourceMap; +//# sourceMappingURL=remapping.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/remapping/types/remapping.d.mts.map b/scripts/node_modules/@jridgewell/remapping/types/remapping.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..9f2fd0efd61b77ee14bd4aa44f5e597e1b8ffcdf --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/types/remapping.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"remapping.d.ts","sourceRoot":"","sources":["../src/remapping.ts"],"names":[],"mappings":"AAEA,OAAO,SAAS,MAAM,cAAc,CAAC;AAErC,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AACxE,YAAY,EACV,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,IAAI,YAAY,EAChC,gBAAgB,EAChB,cAAc,EACd,eAAe,EACf,aAAa,EACb,OAAO,GACR,MAAM,SAAS,CAAC;AACjB,YAAY,EAAE,SAAS,EAAE,CAAC;AAE1B;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,KAAK,EAAE,cAAc,GAAG,cAAc,EAAE,EACxC,MAAM,EAAE,eAAe,EACvB,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,GAC1B,SAAS,CAKX"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/remapping/types/source-map-tree.d.cts b/scripts/node_modules/@jridgewell/remapping/types/source-map-tree.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..440f65b8c2d471b558ac0700f04265c796fe0664 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/types/source-map-tree.d.cts @@ -0,0 +1,46 @@ +import { GenMapping } from '@jridgewell/gen-mapping'; +import type { TraceMap } from '@jridgewell/trace-mapping'; +export type SourceMapSegmentObject = { + column: number; + line: number; + name: string; + source: string; + content: string | null; + ignore: boolean; +}; +export type OriginalSource = { + map: null; + sources: Sources[]; + source: string; + content: string | null; + ignore: boolean; +}; +export type MapSource = { + map: TraceMap; + sources: Sources[]; + source: string; + content: null; + ignore: false; +}; +export type Sources = OriginalSource | MapSource; +/** + * MapSource represents a single sourcemap, with the ability to trace mappings into its child nodes + * (which may themselves be SourceMapTrees). + */ +export declare function MapSource(map: TraceMap, sources: Sources[]): MapSource; +/** + * A "leaf" node in the sourcemap tree, representing an original, unmodified source file. Recursive + * segment tracing ends at the `OriginalSource`. + */ +export declare function OriginalSource(source: string, content: string | null, ignore: boolean): OriginalSource; +/** + * traceMappings is only called on the root level SourceMapTree, and begins the process of + * resolving each mapping in terms of the original source files. + */ +export declare function traceMappings(tree: MapSource): GenMapping; +/** + * originalPositionFor is only called on children SourceMapTrees. It recurses down into its own + * child SourceMapTrees, until we find the original source map. + */ +export declare function originalPositionFor(source: Sources, line: number, column: number, name: string): SourceMapSegmentObject | null; +//# sourceMappingURL=source-map-tree.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/remapping/types/source-map-tree.d.cts.map b/scripts/node_modules/@jridgewell/remapping/types/source-map-tree.d.cts.map new file mode 100644 index 0000000000000000000000000000000000000000..e7cbfb9563f40b30775b981a4cb06376a97796e1 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/types/source-map-tree.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"source-map-tree.d.ts","sourceRoot":"","sources":["../src/source-map-tree.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAgD,MAAM,yBAAyB,CAAC;AAGnG,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAE1D,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,GAAG,EAAE,IAAI,CAAC;IACV,OAAO,EAAE,OAAO,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,GAAG,EAAE,QAAQ,CAAC;IACd,OAAO,EAAE,OAAO,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,IAAI,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG,cAAc,GAAG,SAAS,CAAC;AA8CjD;;;GAGG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,SAAS,CAEtE;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,GAAG,IAAI,EACtB,MAAM,EAAE,OAAO,GACd,cAAc,CAEhB;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,GAAG,UAAU,CAyCzD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,OAAO,EACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,GACX,sBAAsB,GAAG,IAAI,CAmB/B"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/remapping/types/source-map-tree.d.mts b/scripts/node_modules/@jridgewell/remapping/types/source-map-tree.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..440f65b8c2d471b558ac0700f04265c796fe0664 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/types/source-map-tree.d.mts @@ -0,0 +1,46 @@ +import { GenMapping } from '@jridgewell/gen-mapping'; +import type { TraceMap } from '@jridgewell/trace-mapping'; +export type SourceMapSegmentObject = { + column: number; + line: number; + name: string; + source: string; + content: string | null; + ignore: boolean; +}; +export type OriginalSource = { + map: null; + sources: Sources[]; + source: string; + content: string | null; + ignore: boolean; +}; +export type MapSource = { + map: TraceMap; + sources: Sources[]; + source: string; + content: null; + ignore: false; +}; +export type Sources = OriginalSource | MapSource; +/** + * MapSource represents a single sourcemap, with the ability to trace mappings into its child nodes + * (which may themselves be SourceMapTrees). + */ +export declare function MapSource(map: TraceMap, sources: Sources[]): MapSource; +/** + * A "leaf" node in the sourcemap tree, representing an original, unmodified source file. Recursive + * segment tracing ends at the `OriginalSource`. + */ +export declare function OriginalSource(source: string, content: string | null, ignore: boolean): OriginalSource; +/** + * traceMappings is only called on the root level SourceMapTree, and begins the process of + * resolving each mapping in terms of the original source files. + */ +export declare function traceMappings(tree: MapSource): GenMapping; +/** + * originalPositionFor is only called on children SourceMapTrees. It recurses down into its own + * child SourceMapTrees, until we find the original source map. + */ +export declare function originalPositionFor(source: Sources, line: number, column: number, name: string): SourceMapSegmentObject | null; +//# sourceMappingURL=source-map-tree.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/remapping/types/source-map-tree.d.mts.map b/scripts/node_modules/@jridgewell/remapping/types/source-map-tree.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..e7cbfb9563f40b30775b981a4cb06376a97796e1 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/types/source-map-tree.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"source-map-tree.d.ts","sourceRoot":"","sources":["../src/source-map-tree.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAgD,MAAM,yBAAyB,CAAC;AAGnG,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAE1D,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,GAAG,EAAE,IAAI,CAAC;IACV,OAAO,EAAE,OAAO,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,GAAG,EAAE,QAAQ,CAAC;IACd,OAAO,EAAE,OAAO,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,IAAI,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG,cAAc,GAAG,SAAS,CAAC;AA8CjD;;;GAGG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,SAAS,CAEtE;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,GAAG,IAAI,EACtB,MAAM,EAAE,OAAO,GACd,cAAc,CAEhB;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,GAAG,UAAU,CAyCzD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,OAAO,EACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,GACX,sBAAsB,GAAG,IAAI,CAmB/B"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/remapping/types/source-map.d.cts b/scripts/node_modules/@jridgewell/remapping/types/source-map.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..fdb7eedeb3b3f01125d66832f345e31d1f77d786 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/types/source-map.d.cts @@ -0,0 +1,19 @@ +import type { GenMapping } from '@jridgewell/gen-mapping'; +import type { DecodedSourceMap, EncodedSourceMap, Options } from './types.cts'; +/** + * A SourceMap v3 compatible sourcemap, which only includes fields that were + * provided to it. + */ +export = class SourceMap { + file?: string | null; + mappings: EncodedSourceMap['mappings'] | DecodedSourceMap['mappings']; + sourceRoot?: string; + names: string[]; + sources: (string | null)[]; + sourcesContent?: (string | null)[]; + version: 3; + ignoreList: number[] | undefined; + constructor(map: GenMapping, options: Options); + toString(): string; +} +//# sourceMappingURL=source-map.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/remapping/types/source-map.d.cts.map b/scripts/node_modules/@jridgewell/remapping/types/source-map.d.cts.map new file mode 100644 index 0000000000000000000000000000000000000000..593daf8e0abaffe983e2c1166b3e8180d9649644 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/types/source-map.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"source-map.d.ts","sourceRoot":"","sources":["../src/source-map.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAE3E;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,SAAS;IACpB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,QAAQ,EAAE,gBAAgB,CAAC,UAAU,CAAC,GAAG,gBAAgB,CAAC,UAAU,CAAC,CAAC;IACtE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IAC3B,cAAc,CAAC,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IACnC,OAAO,EAAE,CAAC,CAAC;IACX,UAAU,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;gBAE7B,GAAG,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO;IAe7C,QAAQ,IAAI,MAAM;CAGnB"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/remapping/types/source-map.d.mts b/scripts/node_modules/@jridgewell/remapping/types/source-map.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..52ebba2f72b103271db863d1f667105bb65163b3 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/types/source-map.d.mts @@ -0,0 +1,19 @@ +import type { GenMapping } from '@jridgewell/gen-mapping'; +import type { DecodedSourceMap, EncodedSourceMap, Options } from './types.mts'; +/** + * A SourceMap v3 compatible sourcemap, which only includes fields that were + * provided to it. + */ +export default class SourceMap { + file?: string | null; + mappings: EncodedSourceMap['mappings'] | DecodedSourceMap['mappings']; + sourceRoot?: string; + names: string[]; + sources: (string | null)[]; + sourcesContent?: (string | null)[]; + version: 3; + ignoreList: number[] | undefined; + constructor(map: GenMapping, options: Options); + toString(): string; +} +//# sourceMappingURL=source-map.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/remapping/types/source-map.d.mts.map b/scripts/node_modules/@jridgewell/remapping/types/source-map.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..593daf8e0abaffe983e2c1166b3e8180d9649644 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/types/source-map.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"source-map.d.ts","sourceRoot":"","sources":["../src/source-map.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAE3E;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,SAAS;IACpB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,QAAQ,EAAE,gBAAgB,CAAC,UAAU,CAAC,GAAG,gBAAgB,CAAC,UAAU,CAAC,CAAC;IACtE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IAC3B,cAAc,CAAC,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IACnC,OAAO,EAAE,CAAC,CAAC;IACX,UAAU,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;gBAE7B,GAAG,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO;IAe7C,QAAQ,IAAI,MAAM;CAGnB"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/remapping/types/types.d.cts b/scripts/node_modules/@jridgewell/remapping/types/types.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..eeb320f847682b723d15ea336d35f8c3109faa75 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/types/types.d.cts @@ -0,0 +1,16 @@ +import type { SourceMapInput } from '@jridgewell/trace-mapping'; +export type { SourceMapSegment, DecodedSourceMap, EncodedSourceMap, } from '@jridgewell/trace-mapping'; +export type { SourceMapInput }; +export type LoaderContext = { + readonly importer: string; + readonly depth: number; + source: string; + content: string | null | undefined; + ignore: boolean | undefined; +}; +export type SourceMapLoader = (file: string, ctx: LoaderContext) => SourceMapInput | null | undefined | void; +export type Options = { + excludeContent?: boolean; + decodedMappings?: boolean; +}; +//# sourceMappingURL=types.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/remapping/types/types.d.cts.map b/scripts/node_modules/@jridgewell/remapping/types/types.d.cts.map new file mode 100644 index 0000000000000000000000000000000000000000..4f8647e4c9c5d4075fd48dd86a5fe1028fa7ad65 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/types/types.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAEhE,YAAY,EACV,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,2BAA2B,CAAC;AAEnC,YAAY,EAAE,cAAc,EAAE,CAAC;AAE/B,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACnC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAC5B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,aAAa,KACf,cAAc,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAAC;AAE9C,MAAM,MAAM,OAAO,GAAG;IACpB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/remapping/types/types.d.mts b/scripts/node_modules/@jridgewell/remapping/types/types.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..eeb320f847682b723d15ea336d35f8c3109faa75 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/types/types.d.mts @@ -0,0 +1,16 @@ +import type { SourceMapInput } from '@jridgewell/trace-mapping'; +export type { SourceMapSegment, DecodedSourceMap, EncodedSourceMap, } from '@jridgewell/trace-mapping'; +export type { SourceMapInput }; +export type LoaderContext = { + readonly importer: string; + readonly depth: number; + source: string; + content: string | null | undefined; + ignore: boolean | undefined; +}; +export type SourceMapLoader = (file: string, ctx: LoaderContext) => SourceMapInput | null | undefined | void; +export type Options = { + excludeContent?: boolean; + decodedMappings?: boolean; +}; +//# sourceMappingURL=types.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/remapping/types/types.d.mts.map b/scripts/node_modules/@jridgewell/remapping/types/types.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..4f8647e4c9c5d4075fd48dd86a5fe1028fa7ad65 --- /dev/null +++ b/scripts/node_modules/@jridgewell/remapping/types/types.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAEhE,YAAY,EACV,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,2BAA2B,CAAC;AAEnC,YAAY,EAAE,cAAc,EAAE,CAAC;AAE/B,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACnC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAC5B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,aAAa,KACf,cAAc,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAAC;AAE9C,MAAM,MAAM,OAAO,GAAG;IACpB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/resolve-uri/LICENSE b/scripts/node_modules/@jridgewell/resolve-uri/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..0a81b2ade1c77efc8ed0e73172efd07ea1c73539 --- /dev/null +++ b/scripts/node_modules/@jridgewell/resolve-uri/LICENSE @@ -0,0 +1,19 @@ +Copyright 2019 Justin Ridgewell + +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. \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/resolve-uri/README.md b/scripts/node_modules/@jridgewell/resolve-uri/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2fe70df77ec8e109faf2bc857e9893d486ad9eb1 --- /dev/null +++ b/scripts/node_modules/@jridgewell/resolve-uri/README.md @@ -0,0 +1,40 @@ +# @jridgewell/resolve-uri + +> Resolve a URI relative to an optional base URI + +Resolve any combination of absolute URIs, protocol-realtive URIs, absolute paths, or relative paths. + +## Installation + +```sh +npm install @jridgewell/resolve-uri +``` + +## Usage + +```typescript +function resolve(input: string, base?: string): string; +``` + +```js +import resolve from '@jridgewell/resolve-uri'; + +resolve('foo', 'https://example.com'); // => 'https://example.com/foo' +``` + +| Input | Base | Resolution | Explanation | +|-----------------------|-------------------------|--------------------------------|--------------------------------------------------------------| +| `https://example.com` | _any_ | `https://example.com/` | Input is normalized only | +| `//example.com` | `https://base.com/` | `https://example.com/` | Input inherits the base's protocol | +| `//example.com` | _rest_ | `//example.com/` | Input is normalized only | +| `/example` | `https://base.com/` | `https://base.com/example` | Input inherits the base's origin | +| `/example` | `//base.com/` | `//base.com/example` | Input inherits the base's host and remains protocol relative | +| `/example` | _rest_ | `/example` | Input is normalized only | +| `example` | `https://base.com/dir/` | `https://base.com/dir/example` | Input is joined with the base | +| `example` | `https://base.com/file` | `https://base.com/example` | Input is joined with the base without its file | +| `example` | `//base.com/dir/` | `//base.com/dir/example` | Input is joined with the base's last directory | +| `example` | `//base.com/file` | `//base.com/example` | Input is joined with the base without its file | +| `example` | `/base/dir/` | `/base/dir/example` | Input is joined with the base's last directory | +| `example` | `/base/file` | `/base/example` | Input is joined with the base without its file | +| `example` | `base/dir/` | `base/dir/example` | Input is joined with the base's last directory | +| `example` | `base/file` | `base/example` | Input is joined with the base without its file | diff --git a/scripts/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs b/scripts/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs new file mode 100644 index 0000000000000000000000000000000000000000..e958e8817081205d26fc8b1298cae205420e3936 --- /dev/null +++ b/scripts/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs @@ -0,0 +1,232 @@ +// Matches the scheme of a URL, eg "http://" +const schemeRegex = /^[\w+.-]+:\/\//; +/** + * Matches the parts of a URL: + * 1. Scheme, including ":", guaranteed. + * 2. User/password, including "@", optional. + * 3. Host, guaranteed. + * 4. Port, including ":", optional. + * 5. Path, including "/", optional. + * 6. Query, including "?", optional. + * 7. Hash, including "#", optional. + */ +const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/; +/** + * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start + * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive). + * + * 1. Host, optional. + * 2. Path, which may include "/", guaranteed. + * 3. Query, including "?", optional. + * 4. Hash, including "#", optional. + */ +const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i; +function isAbsoluteUrl(input) { + return schemeRegex.test(input); +} +function isSchemeRelativeUrl(input) { + return input.startsWith('//'); +} +function isAbsolutePath(input) { + return input.startsWith('/'); +} +function isFileUrl(input) { + return input.startsWith('file:'); +} +function isRelative(input) { + return /^[.?#]/.test(input); +} +function parseAbsoluteUrl(input) { + const match = urlRegex.exec(input); + return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || ''); +} +function parseFileUrl(input) { + const match = fileRegex.exec(input); + const path = match[2]; + return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path, match[3] || '', match[4] || ''); +} +function makeUrl(scheme, user, host, port, path, query, hash) { + return { + scheme, + user, + host, + port, + path, + query, + hash, + type: 7 /* Absolute */, + }; +} +function parseUrl(input) { + if (isSchemeRelativeUrl(input)) { + const url = parseAbsoluteUrl('http:' + input); + url.scheme = ''; + url.type = 6 /* SchemeRelative */; + return url; + } + if (isAbsolutePath(input)) { + const url = parseAbsoluteUrl('http://foo.com' + input); + url.scheme = ''; + url.host = ''; + url.type = 5 /* AbsolutePath */; + return url; + } + if (isFileUrl(input)) + return parseFileUrl(input); + if (isAbsoluteUrl(input)) + return parseAbsoluteUrl(input); + const url = parseAbsoluteUrl('http://foo.com/' + input); + url.scheme = ''; + url.host = ''; + url.type = input + ? input.startsWith('?') + ? 3 /* Query */ + : input.startsWith('#') + ? 2 /* Hash */ + : 4 /* RelativePath */ + : 1 /* Empty */; + return url; +} +function stripPathFilename(path) { + // If a path ends with a parent directory "..", then it's a relative path with excess parent + // paths. It's not a file, so we can't strip it. + if (path.endsWith('/..')) + return path; + const index = path.lastIndexOf('/'); + return path.slice(0, index + 1); +} +function mergePaths(url, base) { + normalizePath(base, base.type); + // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative + // path). + if (url.path === '/') { + url.path = base.path; + } + else { + // Resolution happens relative to the base path's directory, not the file. + url.path = stripPathFilename(base.path) + url.path; + } +} +/** + * The path can have empty directories "//", unneeded parents "foo/..", or current directory + * "foo/.". We need to normalize to a standard representation. + */ +function normalizePath(url, type) { + const rel = type <= 4 /* RelativePath */; + const pieces = url.path.split('/'); + // We need to preserve the first piece always, so that we output a leading slash. The item at + // pieces[0] is an empty string. + let pointer = 1; + // Positive is the number of real directories we've output, used for popping a parent directory. + // Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo". + let positive = 0; + // We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will + // generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a + // real directory, we won't need to append, unless the other conditions happen again. + let addTrailingSlash = false; + for (let i = 1; i < pieces.length; i++) { + const piece = pieces[i]; + // An empty directory, could be a trailing slash, or just a double "//" in the path. + if (!piece) { + addTrailingSlash = true; + continue; + } + // If we encounter a real directory, then we don't need to append anymore. + addTrailingSlash = false; + // A current directory, which we can always drop. + if (piece === '.') + continue; + // A parent directory, we need to see if there are any real directories we can pop. Else, we + // have an excess of parents, and we'll need to keep the "..". + if (piece === '..') { + if (positive) { + addTrailingSlash = true; + positive--; + pointer--; + } + else if (rel) { + // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute + // URL, protocol relative URL, or an absolute path, we don't need to keep excess. + pieces[pointer++] = piece; + } + continue; + } + // We've encountered a real directory. Move it to the next insertion pointer, which accounts for + // any popped or dropped directories. + pieces[pointer++] = piece; + positive++; + } + let path = ''; + for (let i = 1; i < pointer; i++) { + path += '/' + pieces[i]; + } + if (!path || (addTrailingSlash && !path.endsWith('/..'))) { + path += '/'; + } + url.path = path; +} +/** + * Attempts to resolve `input` URL/path relative to `base`. + */ +function resolve(input, base) { + if (!input && !base) + return ''; + const url = parseUrl(input); + let inputType = url.type; + if (base && inputType !== 7 /* Absolute */) { + const baseUrl = parseUrl(base); + const baseType = baseUrl.type; + switch (inputType) { + case 1 /* Empty */: + url.hash = baseUrl.hash; + // fall through + case 2 /* Hash */: + url.query = baseUrl.query; + // fall through + case 3 /* Query */: + case 4 /* RelativePath */: + mergePaths(url, baseUrl); + // fall through + case 5 /* AbsolutePath */: + // The host, user, and port are joined, you can't copy one without the others. + url.user = baseUrl.user; + url.host = baseUrl.host; + url.port = baseUrl.port; + // fall through + case 6 /* SchemeRelative */: + // The input doesn't have a schema at least, so we need to copy at least that over. + url.scheme = baseUrl.scheme; + } + if (baseType > inputType) + inputType = baseType; + } + normalizePath(url, inputType); + const queryHash = url.query + url.hash; + switch (inputType) { + // This is impossible, because of the empty checks at the start of the function. + // case UrlType.Empty: + case 2 /* Hash */: + case 3 /* Query */: + return queryHash; + case 4 /* RelativePath */: { + // The first char is always a "/", and we need it to be relative. + const path = url.path.slice(1); + if (!path) + return queryHash || '.'; + if (isRelative(base || input) && !isRelative(path)) { + // If base started with a leading ".", or there is no base and input started with a ".", + // then we need to ensure that the relative path starts with a ".". We don't know if + // relative starts with a "..", though, so check before prepending. + return './' + path + queryHash; + } + return path + queryHash; + } + case 5 /* AbsolutePath */: + return url.path + queryHash; + default: + return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash; + } +} + +export { resolve as default }; +//# sourceMappingURL=resolve-uri.mjs.map diff --git a/scripts/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs.map b/scripts/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs.map new file mode 100644 index 0000000000000000000000000000000000000000..1de97d011e53986c4497437eec6b649a51611fdf --- /dev/null +++ b/scripts/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"resolve-uri.mjs","sources":["../src/resolve-uri.ts"],"sourcesContent":["// Matches the scheme of a URL, eg \"http://\"\nconst schemeRegex = /^[\\w+.-]+:\\/\\//;\n\n/**\n * Matches the parts of a URL:\n * 1. Scheme, including \":\", guaranteed.\n * 2. User/password, including \"@\", optional.\n * 3. Host, guaranteed.\n * 4. Port, including \":\", optional.\n * 5. Path, including \"/\", optional.\n * 6. Query, including \"?\", optional.\n * 7. Hash, including \"#\", optional.\n */\nconst urlRegex = /^([\\w+.-]+:)\\/\\/([^@/#?]*@)?([^:/#?]*)(:\\d+)?(\\/[^#?]*)?(\\?[^#]*)?(#.*)?/;\n\n/**\n * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start\n * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).\n *\n * 1. Host, optional.\n * 2. Path, which may include \"/\", guaranteed.\n * 3. Query, including \"?\", optional.\n * 4. Hash, including \"#\", optional.\n */\nconst fileRegex = /^file:(?:\\/\\/((?![a-z]:)[^/#?]*)?)?(\\/?[^#?]*)(\\?[^#]*)?(#.*)?/i;\n\ntype Url = {\n scheme: string;\n user: string;\n host: string;\n port: string;\n path: string;\n query: string;\n hash: string;\n type: UrlType;\n};\n\nconst enum UrlType {\n Empty = 1,\n Hash = 2,\n Query = 3,\n RelativePath = 4,\n AbsolutePath = 5,\n SchemeRelative = 6,\n Absolute = 7,\n}\n\nfunction isAbsoluteUrl(input: string): boolean {\n return schemeRegex.test(input);\n}\n\nfunction isSchemeRelativeUrl(input: string): boolean {\n return input.startsWith('//');\n}\n\nfunction isAbsolutePath(input: string): boolean {\n return input.startsWith('/');\n}\n\nfunction isFileUrl(input: string): boolean {\n return input.startsWith('file:');\n}\n\nfunction isRelative(input: string): boolean {\n return /^[.?#]/.test(input);\n}\n\nfunction parseAbsoluteUrl(input: string): Url {\n const match = urlRegex.exec(input)!;\n return makeUrl(\n match[1],\n match[2] || '',\n match[3],\n match[4] || '',\n match[5] || '/',\n match[6] || '',\n match[7] || '',\n );\n}\n\nfunction parseFileUrl(input: string): Url {\n const match = fileRegex.exec(input)!;\n const path = match[2];\n return makeUrl(\n 'file:',\n '',\n match[1] || '',\n '',\n isAbsolutePath(path) ? path : '/' + path,\n match[3] || '',\n match[4] || '',\n );\n}\n\nfunction makeUrl(\n scheme: string,\n user: string,\n host: string,\n port: string,\n path: string,\n query: string,\n hash: string,\n): Url {\n return {\n scheme,\n user,\n host,\n port,\n path,\n query,\n hash,\n type: UrlType.Absolute,\n };\n}\n\nfunction parseUrl(input: string): Url {\n if (isSchemeRelativeUrl(input)) {\n const url = parseAbsoluteUrl('http:' + input);\n url.scheme = '';\n url.type = UrlType.SchemeRelative;\n return url;\n }\n\n if (isAbsolutePath(input)) {\n const url = parseAbsoluteUrl('http://foo.com' + input);\n url.scheme = '';\n url.host = '';\n url.type = UrlType.AbsolutePath;\n return url;\n }\n\n if (isFileUrl(input)) return parseFileUrl(input);\n\n if (isAbsoluteUrl(input)) return parseAbsoluteUrl(input);\n\n const url = parseAbsoluteUrl('http://foo.com/' + input);\n url.scheme = '';\n url.host = '';\n url.type = input\n ? input.startsWith('?')\n ? UrlType.Query\n : input.startsWith('#')\n ? UrlType.Hash\n : UrlType.RelativePath\n : UrlType.Empty;\n return url;\n}\n\nfunction stripPathFilename(path: string): string {\n // If a path ends with a parent directory \"..\", then it's a relative path with excess parent\n // paths. It's not a file, so we can't strip it.\n if (path.endsWith('/..')) return path;\n const index = path.lastIndexOf('/');\n return path.slice(0, index + 1);\n}\n\nfunction mergePaths(url: Url, base: Url) {\n normalizePath(base, base.type);\n\n // If the path is just a \"/\", then it was an empty path to begin with (remember, we're a relative\n // path).\n if (url.path === '/') {\n url.path = base.path;\n } else {\n // Resolution happens relative to the base path's directory, not the file.\n url.path = stripPathFilename(base.path) + url.path;\n }\n}\n\n/**\n * The path can have empty directories \"//\", unneeded parents \"foo/..\", or current directory\n * \"foo/.\". We need to normalize to a standard representation.\n */\nfunction normalizePath(url: Url, type: UrlType) {\n const rel = type <= UrlType.RelativePath;\n const pieces = url.path.split('/');\n\n // We need to preserve the first piece always, so that we output a leading slash. The item at\n // pieces[0] is an empty string.\n let pointer = 1;\n\n // Positive is the number of real directories we've output, used for popping a parent directory.\n // Eg, \"foo/bar/..\" will have a positive 2, and we can decrement to be left with just \"foo\".\n let positive = 0;\n\n // We need to keep a trailing slash if we encounter an empty directory (eg, splitting \"foo/\" will\n // generate `[\"foo\", \"\"]` pieces). And, if we pop a parent directory. But once we encounter a\n // real directory, we won't need to append, unless the other conditions happen again.\n let addTrailingSlash = false;\n\n for (let i = 1; i < pieces.length; i++) {\n const piece = pieces[i];\n\n // An empty directory, could be a trailing slash, or just a double \"//\" in the path.\n if (!piece) {\n addTrailingSlash = true;\n continue;\n }\n\n // If we encounter a real directory, then we don't need to append anymore.\n addTrailingSlash = false;\n\n // A current directory, which we can always drop.\n if (piece === '.') continue;\n\n // A parent directory, we need to see if there are any real directories we can pop. Else, we\n // have an excess of parents, and we'll need to keep the \"..\".\n if (piece === '..') {\n if (positive) {\n addTrailingSlash = true;\n positive--;\n pointer--;\n } else if (rel) {\n // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute\n // URL, protocol relative URL, or an absolute path, we don't need to keep excess.\n pieces[pointer++] = piece;\n }\n continue;\n }\n\n // We've encountered a real directory. Move it to the next insertion pointer, which accounts for\n // any popped or dropped directories.\n pieces[pointer++] = piece;\n positive++;\n }\n\n let path = '';\n for (let i = 1; i < pointer; i++) {\n path += '/' + pieces[i];\n }\n if (!path || (addTrailingSlash && !path.endsWith('/..'))) {\n path += '/';\n }\n url.path = path;\n}\n\n/**\n * Attempts to resolve `input` URL/path relative to `base`.\n */\nexport default function resolve(input: string, base: string | undefined): string {\n if (!input && !base) return '';\n\n const url = parseUrl(input);\n let inputType = url.type;\n\n if (base && inputType !== UrlType.Absolute) {\n const baseUrl = parseUrl(base);\n const baseType = baseUrl.type;\n\n switch (inputType) {\n case UrlType.Empty:\n url.hash = baseUrl.hash;\n // fall through\n\n case UrlType.Hash:\n url.query = baseUrl.query;\n // fall through\n\n case UrlType.Query:\n case UrlType.RelativePath:\n mergePaths(url, baseUrl);\n // fall through\n\n case UrlType.AbsolutePath:\n // The host, user, and port are joined, you can't copy one without the others.\n url.user = baseUrl.user;\n url.host = baseUrl.host;\n url.port = baseUrl.port;\n // fall through\n\n case UrlType.SchemeRelative:\n // The input doesn't have a schema at least, so we need to copy at least that over.\n url.scheme = baseUrl.scheme;\n }\n if (baseType > inputType) inputType = baseType;\n }\n\n normalizePath(url, inputType);\n\n const queryHash = url.query + url.hash;\n switch (inputType) {\n // This is impossible, because of the empty checks at the start of the function.\n // case UrlType.Empty:\n\n case UrlType.Hash:\n case UrlType.Query:\n return queryHash;\n\n case UrlType.RelativePath: {\n // The first char is always a \"/\", and we need it to be relative.\n const path = url.path.slice(1);\n\n if (!path) return queryHash || '.';\n\n if (isRelative(base || input) && !isRelative(path)) {\n // If base started with a leading \".\", or there is no base and input started with a \".\",\n // then we need to ensure that the relative path starts with a \".\". We don't know if\n // relative starts with a \"..\", though, so check before prepending.\n return './' + path + queryHash;\n }\n\n return path + queryHash;\n }\n\n case UrlType.AbsolutePath:\n return url.path + queryHash;\n\n default:\n return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;\n }\n}\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js b/scripts/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js new file mode 100644 index 0000000000000000000000000000000000000000..a783049b0136da9128af243b699229e0870aa390 --- /dev/null +++ b/scripts/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js @@ -0,0 +1,240 @@ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : + typeof define === 'function' && define.amd ? define(factory) : + (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.resolveURI = factory()); +})(this, (function () { 'use strict'; + + // Matches the scheme of a URL, eg "http://" + const schemeRegex = /^[\w+.-]+:\/\//; + /** + * Matches the parts of a URL: + * 1. Scheme, including ":", guaranteed. + * 2. User/password, including "@", optional. + * 3. Host, guaranteed. + * 4. Port, including ":", optional. + * 5. Path, including "/", optional. + * 6. Query, including "?", optional. + * 7. Hash, including "#", optional. + */ + const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/; + /** + * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start + * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive). + * + * 1. Host, optional. + * 2. Path, which may include "/", guaranteed. + * 3. Query, including "?", optional. + * 4. Hash, including "#", optional. + */ + const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i; + function isAbsoluteUrl(input) { + return schemeRegex.test(input); + } + function isSchemeRelativeUrl(input) { + return input.startsWith('//'); + } + function isAbsolutePath(input) { + return input.startsWith('/'); + } + function isFileUrl(input) { + return input.startsWith('file:'); + } + function isRelative(input) { + return /^[.?#]/.test(input); + } + function parseAbsoluteUrl(input) { + const match = urlRegex.exec(input); + return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || ''); + } + function parseFileUrl(input) { + const match = fileRegex.exec(input); + const path = match[2]; + return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path, match[3] || '', match[4] || ''); + } + function makeUrl(scheme, user, host, port, path, query, hash) { + return { + scheme, + user, + host, + port, + path, + query, + hash, + type: 7 /* Absolute */, + }; + } + function parseUrl(input) { + if (isSchemeRelativeUrl(input)) { + const url = parseAbsoluteUrl('http:' + input); + url.scheme = ''; + url.type = 6 /* SchemeRelative */; + return url; + } + if (isAbsolutePath(input)) { + const url = parseAbsoluteUrl('http://foo.com' + input); + url.scheme = ''; + url.host = ''; + url.type = 5 /* AbsolutePath */; + return url; + } + if (isFileUrl(input)) + return parseFileUrl(input); + if (isAbsoluteUrl(input)) + return parseAbsoluteUrl(input); + const url = parseAbsoluteUrl('http://foo.com/' + input); + url.scheme = ''; + url.host = ''; + url.type = input + ? input.startsWith('?') + ? 3 /* Query */ + : input.startsWith('#') + ? 2 /* Hash */ + : 4 /* RelativePath */ + : 1 /* Empty */; + return url; + } + function stripPathFilename(path) { + // If a path ends with a parent directory "..", then it's a relative path with excess parent + // paths. It's not a file, so we can't strip it. + if (path.endsWith('/..')) + return path; + const index = path.lastIndexOf('/'); + return path.slice(0, index + 1); + } + function mergePaths(url, base) { + normalizePath(base, base.type); + // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative + // path). + if (url.path === '/') { + url.path = base.path; + } + else { + // Resolution happens relative to the base path's directory, not the file. + url.path = stripPathFilename(base.path) + url.path; + } + } + /** + * The path can have empty directories "//", unneeded parents "foo/..", or current directory + * "foo/.". We need to normalize to a standard representation. + */ + function normalizePath(url, type) { + const rel = type <= 4 /* RelativePath */; + const pieces = url.path.split('/'); + // We need to preserve the first piece always, so that we output a leading slash. The item at + // pieces[0] is an empty string. + let pointer = 1; + // Positive is the number of real directories we've output, used for popping a parent directory. + // Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo". + let positive = 0; + // We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will + // generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a + // real directory, we won't need to append, unless the other conditions happen again. + let addTrailingSlash = false; + for (let i = 1; i < pieces.length; i++) { + const piece = pieces[i]; + // An empty directory, could be a trailing slash, or just a double "//" in the path. + if (!piece) { + addTrailingSlash = true; + continue; + } + // If we encounter a real directory, then we don't need to append anymore. + addTrailingSlash = false; + // A current directory, which we can always drop. + if (piece === '.') + continue; + // A parent directory, we need to see if there are any real directories we can pop. Else, we + // have an excess of parents, and we'll need to keep the "..". + if (piece === '..') { + if (positive) { + addTrailingSlash = true; + positive--; + pointer--; + } + else if (rel) { + // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute + // URL, protocol relative URL, or an absolute path, we don't need to keep excess. + pieces[pointer++] = piece; + } + continue; + } + // We've encountered a real directory. Move it to the next insertion pointer, which accounts for + // any popped or dropped directories. + pieces[pointer++] = piece; + positive++; + } + let path = ''; + for (let i = 1; i < pointer; i++) { + path += '/' + pieces[i]; + } + if (!path || (addTrailingSlash && !path.endsWith('/..'))) { + path += '/'; + } + url.path = path; + } + /** + * Attempts to resolve `input` URL/path relative to `base`. + */ + function resolve(input, base) { + if (!input && !base) + return ''; + const url = parseUrl(input); + let inputType = url.type; + if (base && inputType !== 7 /* Absolute */) { + const baseUrl = parseUrl(base); + const baseType = baseUrl.type; + switch (inputType) { + case 1 /* Empty */: + url.hash = baseUrl.hash; + // fall through + case 2 /* Hash */: + url.query = baseUrl.query; + // fall through + case 3 /* Query */: + case 4 /* RelativePath */: + mergePaths(url, baseUrl); + // fall through + case 5 /* AbsolutePath */: + // The host, user, and port are joined, you can't copy one without the others. + url.user = baseUrl.user; + url.host = baseUrl.host; + url.port = baseUrl.port; + // fall through + case 6 /* SchemeRelative */: + // The input doesn't have a schema at least, so we need to copy at least that over. + url.scheme = baseUrl.scheme; + } + if (baseType > inputType) + inputType = baseType; + } + normalizePath(url, inputType); + const queryHash = url.query + url.hash; + switch (inputType) { + // This is impossible, because of the empty checks at the start of the function. + // case UrlType.Empty: + case 2 /* Hash */: + case 3 /* Query */: + return queryHash; + case 4 /* RelativePath */: { + // The first char is always a "/", and we need it to be relative. + const path = url.path.slice(1); + if (!path) + return queryHash || '.'; + if (isRelative(base || input) && !isRelative(path)) { + // If base started with a leading ".", or there is no base and input started with a ".", + // then we need to ensure that the relative path starts with a ".". We don't know if + // relative starts with a "..", though, so check before prepending. + return './' + path + queryHash; + } + return path + queryHash; + } + case 5 /* AbsolutePath */: + return url.path + queryHash; + default: + return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash; + } + } + + return resolve; + +})); +//# sourceMappingURL=resolve-uri.umd.js.map diff --git a/scripts/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js.map b/scripts/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js.map new file mode 100644 index 0000000000000000000000000000000000000000..70a37f21da35cad5db599004fb8ca601f3dfa57b --- /dev/null +++ b/scripts/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js.map @@ -0,0 +1 @@ +{"version":3,"file":"resolve-uri.umd.js","sources":["../src/resolve-uri.ts"],"sourcesContent":["// Matches the scheme of a URL, eg \"http://\"\nconst schemeRegex = /^[\\w+.-]+:\\/\\//;\n\n/**\n * Matches the parts of a URL:\n * 1. Scheme, including \":\", guaranteed.\n * 2. User/password, including \"@\", optional.\n * 3. Host, guaranteed.\n * 4. Port, including \":\", optional.\n * 5. Path, including \"/\", optional.\n * 6. Query, including \"?\", optional.\n * 7. Hash, including \"#\", optional.\n */\nconst urlRegex = /^([\\w+.-]+:)\\/\\/([^@/#?]*@)?([^:/#?]*)(:\\d+)?(\\/[^#?]*)?(\\?[^#]*)?(#.*)?/;\n\n/**\n * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start\n * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).\n *\n * 1. Host, optional.\n * 2. Path, which may include \"/\", guaranteed.\n * 3. Query, including \"?\", optional.\n * 4. Hash, including \"#\", optional.\n */\nconst fileRegex = /^file:(?:\\/\\/((?![a-z]:)[^/#?]*)?)?(\\/?[^#?]*)(\\?[^#]*)?(#.*)?/i;\n\ntype Url = {\n scheme: string;\n user: string;\n host: string;\n port: string;\n path: string;\n query: string;\n hash: string;\n type: UrlType;\n};\n\nconst enum UrlType {\n Empty = 1,\n Hash = 2,\n Query = 3,\n RelativePath = 4,\n AbsolutePath = 5,\n SchemeRelative = 6,\n Absolute = 7,\n}\n\nfunction isAbsoluteUrl(input: string): boolean {\n return schemeRegex.test(input);\n}\n\nfunction isSchemeRelativeUrl(input: string): boolean {\n return input.startsWith('//');\n}\n\nfunction isAbsolutePath(input: string): boolean {\n return input.startsWith('/');\n}\n\nfunction isFileUrl(input: string): boolean {\n return input.startsWith('file:');\n}\n\nfunction isRelative(input: string): boolean {\n return /^[.?#]/.test(input);\n}\n\nfunction parseAbsoluteUrl(input: string): Url {\n const match = urlRegex.exec(input)!;\n return makeUrl(\n match[1],\n match[2] || '',\n match[3],\n match[4] || '',\n match[5] || '/',\n match[6] || '',\n match[7] || '',\n );\n}\n\nfunction parseFileUrl(input: string): Url {\n const match = fileRegex.exec(input)!;\n const path = match[2];\n return makeUrl(\n 'file:',\n '',\n match[1] || '',\n '',\n isAbsolutePath(path) ? path : '/' + path,\n match[3] || '',\n match[4] || '',\n );\n}\n\nfunction makeUrl(\n scheme: string,\n user: string,\n host: string,\n port: string,\n path: string,\n query: string,\n hash: string,\n): Url {\n return {\n scheme,\n user,\n host,\n port,\n path,\n query,\n hash,\n type: UrlType.Absolute,\n };\n}\n\nfunction parseUrl(input: string): Url {\n if (isSchemeRelativeUrl(input)) {\n const url = parseAbsoluteUrl('http:' + input);\n url.scheme = '';\n url.type = UrlType.SchemeRelative;\n return url;\n }\n\n if (isAbsolutePath(input)) {\n const url = parseAbsoluteUrl('http://foo.com' + input);\n url.scheme = '';\n url.host = '';\n url.type = UrlType.AbsolutePath;\n return url;\n }\n\n if (isFileUrl(input)) return parseFileUrl(input);\n\n if (isAbsoluteUrl(input)) return parseAbsoluteUrl(input);\n\n const url = parseAbsoluteUrl('http://foo.com/' + input);\n url.scheme = '';\n url.host = '';\n url.type = input\n ? input.startsWith('?')\n ? UrlType.Query\n : input.startsWith('#')\n ? UrlType.Hash\n : UrlType.RelativePath\n : UrlType.Empty;\n return url;\n}\n\nfunction stripPathFilename(path: string): string {\n // If a path ends with a parent directory \"..\", then it's a relative path with excess parent\n // paths. It's not a file, so we can't strip it.\n if (path.endsWith('/..')) return path;\n const index = path.lastIndexOf('/');\n return path.slice(0, index + 1);\n}\n\nfunction mergePaths(url: Url, base: Url) {\n normalizePath(base, base.type);\n\n // If the path is just a \"/\", then it was an empty path to begin with (remember, we're a relative\n // path).\n if (url.path === '/') {\n url.path = base.path;\n } else {\n // Resolution happens relative to the base path's directory, not the file.\n url.path = stripPathFilename(base.path) + url.path;\n }\n}\n\n/**\n * The path can have empty directories \"//\", unneeded parents \"foo/..\", or current directory\n * \"foo/.\". We need to normalize to a standard representation.\n */\nfunction normalizePath(url: Url, type: UrlType) {\n const rel = type <= UrlType.RelativePath;\n const pieces = url.path.split('/');\n\n // We need to preserve the first piece always, so that we output a leading slash. The item at\n // pieces[0] is an empty string.\n let pointer = 1;\n\n // Positive is the number of real directories we've output, used for popping a parent directory.\n // Eg, \"foo/bar/..\" will have a positive 2, and we can decrement to be left with just \"foo\".\n let positive = 0;\n\n // We need to keep a trailing slash if we encounter an empty directory (eg, splitting \"foo/\" will\n // generate `[\"foo\", \"\"]` pieces). And, if we pop a parent directory. But once we encounter a\n // real directory, we won't need to append, unless the other conditions happen again.\n let addTrailingSlash = false;\n\n for (let i = 1; i < pieces.length; i++) {\n const piece = pieces[i];\n\n // An empty directory, could be a trailing slash, or just a double \"//\" in the path.\n if (!piece) {\n addTrailingSlash = true;\n continue;\n }\n\n // If we encounter a real directory, then we don't need to append anymore.\n addTrailingSlash = false;\n\n // A current directory, which we can always drop.\n if (piece === '.') continue;\n\n // A parent directory, we need to see if there are any real directories we can pop. Else, we\n // have an excess of parents, and we'll need to keep the \"..\".\n if (piece === '..') {\n if (positive) {\n addTrailingSlash = true;\n positive--;\n pointer--;\n } else if (rel) {\n // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute\n // URL, protocol relative URL, or an absolute path, we don't need to keep excess.\n pieces[pointer++] = piece;\n }\n continue;\n }\n\n // We've encountered a real directory. Move it to the next insertion pointer, which accounts for\n // any popped or dropped directories.\n pieces[pointer++] = piece;\n positive++;\n }\n\n let path = '';\n for (let i = 1; i < pointer; i++) {\n path += '/' + pieces[i];\n }\n if (!path || (addTrailingSlash && !path.endsWith('/..'))) {\n path += '/';\n }\n url.path = path;\n}\n\n/**\n * Attempts to resolve `input` URL/path relative to `base`.\n */\nexport default function resolve(input: string, base: string | undefined): string {\n if (!input && !base) return '';\n\n const url = parseUrl(input);\n let inputType = url.type;\n\n if (base && inputType !== UrlType.Absolute) {\n const baseUrl = parseUrl(base);\n const baseType = baseUrl.type;\n\n switch (inputType) {\n case UrlType.Empty:\n url.hash = baseUrl.hash;\n // fall through\n\n case UrlType.Hash:\n url.query = baseUrl.query;\n // fall through\n\n case UrlType.Query:\n case UrlType.RelativePath:\n mergePaths(url, baseUrl);\n // fall through\n\n case UrlType.AbsolutePath:\n // The host, user, and port are joined, you can't copy one without the others.\n url.user = baseUrl.user;\n url.host = baseUrl.host;\n url.port = baseUrl.port;\n // fall through\n\n case UrlType.SchemeRelative:\n // The input doesn't have a schema at least, so we need to copy at least that over.\n url.scheme = baseUrl.scheme;\n }\n if (baseType > inputType) inputType = baseType;\n }\n\n normalizePath(url, inputType);\n\n const queryHash = url.query + url.hash;\n switch (inputType) {\n // This is impossible, because of the empty checks at the start of the function.\n // case UrlType.Empty:\n\n case UrlType.Hash:\n case UrlType.Query:\n return queryHash;\n\n case UrlType.RelativePath: {\n // The first char is always a \"/\", and we need it to be relative.\n const path = url.path.slice(1);\n\n if (!path) return queryHash || '.';\n\n if (isRelative(base || input) && !isRelative(path)) {\n // If base started with a leading \".\", or there is no base and input started with a \".\",\n // then we need to ensure that the relative path starts with a \".\". We don't know if\n // relative starts with a \"..\", though, so check before prepending.\n return './' + path + queryHash;\n }\n\n return path + queryHash;\n }\n\n case UrlType.AbsolutePath:\n return url.path + queryHash;\n\n default:\n return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;\n }\n}\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/resolve-uri/dist/types/resolve-uri.d.ts b/scripts/node_modules/@jridgewell/resolve-uri/dist/types/resolve-uri.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b7f0b3b2d7d2eba98141e8b346328b1ff6d6118c --- /dev/null +++ b/scripts/node_modules/@jridgewell/resolve-uri/dist/types/resolve-uri.d.ts @@ -0,0 +1,4 @@ +/** + * Attempts to resolve `input` URL/path relative to `base`. + */ +export default function resolve(input: string, base: string | undefined): string; diff --git a/scripts/node_modules/@jridgewell/resolve-uri/package.json b/scripts/node_modules/@jridgewell/resolve-uri/package.json new file mode 100644 index 0000000000000000000000000000000000000000..02a4c5187e7ca726d36ff24dda674400b1c3f846 --- /dev/null +++ b/scripts/node_modules/@jridgewell/resolve-uri/package.json @@ -0,0 +1,69 @@ +{ + "name": "@jridgewell/resolve-uri", + "version": "3.1.2", + "description": "Resolve a URI relative to an optional base URI", + "keywords": [ + "resolve", + "uri", + "url", + "path" + ], + "author": "Justin Ridgewell ", + "license": "MIT", + "repository": "https://github.com/jridgewell/resolve-uri", + "main": "dist/resolve-uri.umd.js", + "module": "dist/resolve-uri.mjs", + "types": "dist/types/resolve-uri.d.ts", + "exports": { + ".": [ + { + "types": "./dist/types/resolve-uri.d.ts", + "browser": "./dist/resolve-uri.umd.js", + "require": "./dist/resolve-uri.umd.js", + "import": "./dist/resolve-uri.mjs" + }, + "./dist/resolve-uri.umd.js" + ], + "./package.json": "./package.json" + }, + "files": [ + "dist" + ], + "engines": { + "node": ">=6.0.0" + }, + "scripts": { + "prebuild": "rm -rf dist", + "build": "run-s -n build:*", + "build:rollup": "rollup -c rollup.config.js", + "build:ts": "tsc --project tsconfig.build.json", + "lint": "run-s -n lint:*", + "lint:prettier": "npm run test:lint:prettier -- --write", + "lint:ts": "npm run test:lint:ts -- --fix", + "pretest": "run-s build:rollup", + "test": "run-s -n test:lint test:only", + "test:debug": "mocha --inspect-brk", + "test:lint": "run-s -n test:lint:*", + "test:lint:prettier": "prettier --check '{src,test}/**/*.ts'", + "test:lint:ts": "eslint '{src,test}/**/*.ts'", + "test:only": "mocha", + "test:coverage": "c8 mocha", + "test:watch": "mocha --watch", + "prepublishOnly": "npm run preversion", + "preversion": "run-s test build" + }, + "devDependencies": { + "@jridgewell/resolve-uri-latest": "npm:@jridgewell/resolve-uri@*", + "@rollup/plugin-typescript": "8.3.0", + "@typescript-eslint/eslint-plugin": "5.10.0", + "@typescript-eslint/parser": "5.10.0", + "c8": "7.11.0", + "eslint": "8.7.0", + "eslint-config-prettier": "8.3.0", + "mocha": "9.2.0", + "npm-run-all": "4.1.5", + "prettier": "2.5.1", + "rollup": "2.66.0", + "typescript": "4.5.5" + } +} diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/LICENSE b/scripts/node_modules/@jridgewell/sourcemap-codec/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..1f6ce94c11912496b96298630d84753dbf593a7d --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/LICENSE @@ -0,0 +1,19 @@ +Copyright 2024 Justin Ridgewell + +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/scripts/node_modules/@jridgewell/sourcemap-codec/README.md b/scripts/node_modules/@jridgewell/sourcemap-codec/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b3e0708bf93737649c24aefc0cf216f23905908e --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/README.md @@ -0,0 +1,264 @@ +# @jridgewell/sourcemap-codec + +Encode/decode the `mappings` property of a [sourcemap](https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit). + + +## Why? + +Sourcemaps are difficult to generate and manipulate, because the `mappings` property – the part that actually links the generated code back to the original source – is encoded using an obscure method called [Variable-length quantity](https://en.wikipedia.org/wiki/Variable-length_quantity). On top of that, each segment in the mapping contains offsets rather than absolute indices, which means that you can't look at a segment in isolation – you have to understand the whole sourcemap. + +This package makes the process slightly easier. + + +## Installation + +```bash +npm install @jridgewell/sourcemap-codec +``` + + +## Usage + +```js +import { encode, decode } from '@jridgewell/sourcemap-codec'; + +var decoded = decode( ';EAEEA,EAAE,EAAC,CAAE;ECQY,UACC' ); + +assert.deepEqual( decoded, [ + // the first line (of the generated code) has no mappings, + // as shown by the starting semi-colon (which separates lines) + [], + + // the second line contains four (comma-separated) segments + [ + // segments are encoded as you'd expect: + // [ generatedCodeColumn, sourceIndex, sourceCodeLine, sourceCodeColumn, nameIndex ] + + // i.e. the first segment begins at column 2, and maps back to the second column + // of the second line (both zero-based) of the 0th source, and uses the 0th + // name in the `map.names` array + [ 2, 0, 2, 2, 0 ], + + // the remaining segments are 4-length rather than 5-length, + // because they don't map a name + [ 4, 0, 2, 4 ], + [ 6, 0, 2, 5 ], + [ 7, 0, 2, 7 ] + ], + + // the final line contains two segments + [ + [ 2, 1, 10, 19 ], + [ 12, 1, 11, 20 ] + ] +]); + +var encoded = encode( decoded ); +assert.equal( encoded, ';EAEEA,EAAE,EAAC,CAAE;ECQY,UACC' ); +``` + +## Benchmarks + +``` +node v20.10.0 + +amp.js.map - 45120 segments + +Decode Memory Usage: +local code 5815135 bytes +@jridgewell/sourcemap-codec 1.4.15 5868160 bytes +sourcemap-codec 5492584 bytes +source-map-0.6.1 13569984 bytes +source-map-0.8.0 6390584 bytes +chrome dev tools 8011136 bytes +Smallest memory usage is sourcemap-codec + +Decode speed: +decode: local code x 492 ops/sec ±1.22% (90 runs sampled) +decode: @jridgewell/sourcemap-codec 1.4.15 x 499 ops/sec ±1.16% (89 runs sampled) +decode: sourcemap-codec x 376 ops/sec ±1.66% (89 runs sampled) +decode: source-map-0.6.1 x 34.99 ops/sec ±0.94% (48 runs sampled) +decode: source-map-0.8.0 x 351 ops/sec ±0.07% (95 runs sampled) +chrome dev tools x 165 ops/sec ±0.91% (86 runs sampled) +Fastest is decode: @jridgewell/sourcemap-codec 1.4.15 + +Encode Memory Usage: +local code 444248 bytes +@jridgewell/sourcemap-codec 1.4.15 623024 bytes +sourcemap-codec 8696280 bytes +source-map-0.6.1 8745176 bytes +source-map-0.8.0 8736624 bytes +Smallest memory usage is local code + +Encode speed: +encode: local code x 796 ops/sec ±0.11% (97 runs sampled) +encode: @jridgewell/sourcemap-codec 1.4.15 x 795 ops/sec ±0.25% (98 runs sampled) +encode: sourcemap-codec x 231 ops/sec ±0.83% (86 runs sampled) +encode: source-map-0.6.1 x 166 ops/sec ±0.57% (86 runs sampled) +encode: source-map-0.8.0 x 203 ops/sec ±0.45% (88 runs sampled) +Fastest is encode: local code,encode: @jridgewell/sourcemap-codec 1.4.15 + + +*** + + +babel.min.js.map - 347793 segments + +Decode Memory Usage: +local code 35424960 bytes +@jridgewell/sourcemap-codec 1.4.15 35424696 bytes +sourcemap-codec 36033464 bytes +source-map-0.6.1 62253704 bytes +source-map-0.8.0 43843920 bytes +chrome dev tools 45111400 bytes +Smallest memory usage is @jridgewell/sourcemap-codec 1.4.15 + +Decode speed: +decode: local code x 38.18 ops/sec ±5.44% (52 runs sampled) +decode: @jridgewell/sourcemap-codec 1.4.15 x 38.36 ops/sec ±5.02% (52 runs sampled) +decode: sourcemap-codec x 34.05 ops/sec ±4.45% (47 runs sampled) +decode: source-map-0.6.1 x 4.31 ops/sec ±2.76% (15 runs sampled) +decode: source-map-0.8.0 x 55.60 ops/sec ±0.13% (73 runs sampled) +chrome dev tools x 16.94 ops/sec ±3.78% (46 runs sampled) +Fastest is decode: source-map-0.8.0 + +Encode Memory Usage: +local code 2606016 bytes +@jridgewell/sourcemap-codec 1.4.15 2626440 bytes +sourcemap-codec 21152576 bytes +source-map-0.6.1 25023928 bytes +source-map-0.8.0 25256448 bytes +Smallest memory usage is local code + +Encode speed: +encode: local code x 127 ops/sec ±0.18% (83 runs sampled) +encode: @jridgewell/sourcemap-codec 1.4.15 x 128 ops/sec ±0.26% (83 runs sampled) +encode: sourcemap-codec x 29.31 ops/sec ±2.55% (53 runs sampled) +encode: source-map-0.6.1 x 18.85 ops/sec ±3.19% (36 runs sampled) +encode: source-map-0.8.0 x 19.34 ops/sec ±1.97% (36 runs sampled) +Fastest is encode: @jridgewell/sourcemap-codec 1.4.15 + + +*** + + +preact.js.map - 1992 segments + +Decode Memory Usage: +local code 261696 bytes +@jridgewell/sourcemap-codec 1.4.15 244296 bytes +sourcemap-codec 302816 bytes +source-map-0.6.1 939176 bytes +source-map-0.8.0 336 bytes +chrome dev tools 587368 bytes +Smallest memory usage is source-map-0.8.0 + +Decode speed: +decode: local code x 17,782 ops/sec ±0.32% (97 runs sampled) +decode: @jridgewell/sourcemap-codec 1.4.15 x 17,863 ops/sec ±0.40% (100 runs sampled) +decode: sourcemap-codec x 12,453 ops/sec ±0.27% (101 runs sampled) +decode: source-map-0.6.1 x 1,288 ops/sec ±1.05% (96 runs sampled) +decode: source-map-0.8.0 x 9,289 ops/sec ±0.27% (101 runs sampled) +chrome dev tools x 4,769 ops/sec ±0.18% (100 runs sampled) +Fastest is decode: @jridgewell/sourcemap-codec 1.4.15 + +Encode Memory Usage: +local code 262944 bytes +@jridgewell/sourcemap-codec 1.4.15 25544 bytes +sourcemap-codec 323048 bytes +source-map-0.6.1 507808 bytes +source-map-0.8.0 507480 bytes +Smallest memory usage is @jridgewell/sourcemap-codec 1.4.15 + +Encode speed: +encode: local code x 24,207 ops/sec ±0.79% (95 runs sampled) +encode: @jridgewell/sourcemap-codec 1.4.15 x 24,288 ops/sec ±0.48% (96 runs sampled) +encode: sourcemap-codec x 6,761 ops/sec ±0.21% (100 runs sampled) +encode: source-map-0.6.1 x 5,374 ops/sec ±0.17% (99 runs sampled) +encode: source-map-0.8.0 x 5,633 ops/sec ±0.32% (99 runs sampled) +Fastest is encode: @jridgewell/sourcemap-codec 1.4.15,encode: local code + + +*** + + +react.js.map - 5726 segments + +Decode Memory Usage: +local code 678816 bytes +@jridgewell/sourcemap-codec 1.4.15 678816 bytes +sourcemap-codec 816400 bytes +source-map-0.6.1 2288864 bytes +source-map-0.8.0 721360 bytes +chrome dev tools 1012512 bytes +Smallest memory usage is local code + +Decode speed: +decode: local code x 6,178 ops/sec ±0.19% (98 runs sampled) +decode: @jridgewell/sourcemap-codec 1.4.15 x 6,261 ops/sec ±0.22% (100 runs sampled) +decode: sourcemap-codec x 4,472 ops/sec ±0.90% (99 runs sampled) +decode: source-map-0.6.1 x 449 ops/sec ±0.31% (95 runs sampled) +decode: source-map-0.8.0 x 3,219 ops/sec ±0.13% (100 runs sampled) +chrome dev tools x 1,743 ops/sec ±0.20% (99 runs sampled) +Fastest is decode: @jridgewell/sourcemap-codec 1.4.15 + +Encode Memory Usage: +local code 140960 bytes +@jridgewell/sourcemap-codec 1.4.15 159808 bytes +sourcemap-codec 969304 bytes +source-map-0.6.1 930520 bytes +source-map-0.8.0 930248 bytes +Smallest memory usage is local code + +Encode speed: +encode: local code x 8,013 ops/sec ±0.19% (100 runs sampled) +encode: @jridgewell/sourcemap-codec 1.4.15 x 7,989 ops/sec ±0.20% (101 runs sampled) +encode: sourcemap-codec x 2,472 ops/sec ±0.21% (99 runs sampled) +encode: source-map-0.6.1 x 2,200 ops/sec ±0.17% (99 runs sampled) +encode: source-map-0.8.0 x 2,220 ops/sec ±0.37% (99 runs sampled) +Fastest is encode: local code + + +*** + + +vscode.map - 2141001 segments + +Decode Memory Usage: +local code 198955264 bytes +@jridgewell/sourcemap-codec 1.4.15 199175352 bytes +sourcemap-codec 199102688 bytes +source-map-0.6.1 386323432 bytes +source-map-0.8.0 244116432 bytes +chrome dev tools 293734280 bytes +Smallest memory usage is local code + +Decode speed: +decode: local code x 3.90 ops/sec ±22.21% (15 runs sampled) +decode: @jridgewell/sourcemap-codec 1.4.15 x 3.95 ops/sec ±23.53% (15 runs sampled) +decode: sourcemap-codec x 3.82 ops/sec ±17.94% (14 runs sampled) +decode: source-map-0.6.1 x 0.61 ops/sec ±7.81% (6 runs sampled) +decode: source-map-0.8.0 x 9.54 ops/sec ±0.28% (28 runs sampled) +chrome dev tools x 2.18 ops/sec ±10.58% (10 runs sampled) +Fastest is decode: source-map-0.8.0 + +Encode Memory Usage: +local code 13509880 bytes +@jridgewell/sourcemap-codec 1.4.15 13537648 bytes +sourcemap-codec 32540104 bytes +source-map-0.6.1 127531040 bytes +source-map-0.8.0 127535312 bytes +Smallest memory usage is local code + +Encode speed: +encode: local code x 20.10 ops/sec ±0.19% (38 runs sampled) +encode: @jridgewell/sourcemap-codec 1.4.15 x 20.26 ops/sec ±0.32% (38 runs sampled) +encode: sourcemap-codec x 5.44 ops/sec ±1.64% (18 runs sampled) +encode: source-map-0.6.1 x 2.30 ops/sec ±4.79% (10 runs sampled) +encode: source-map-0.8.0 x 2.46 ops/sec ±6.53% (10 runs sampled) +Fastest is encode: @jridgewell/sourcemap-codec 1.4.15 +``` + +# License + +MIT diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs b/scripts/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs new file mode 100644 index 0000000000000000000000000000000000000000..532bab39f010d1ce7988e3ae3f7e23a28d5a43a5 --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs @@ -0,0 +1,423 @@ +// src/vlq.ts +var comma = ",".charCodeAt(0); +var semicolon = ";".charCodeAt(0); +var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; +var intToChar = new Uint8Array(64); +var charToInt = new Uint8Array(128); +for (let i = 0; i < chars.length; i++) { + const c = chars.charCodeAt(i); + intToChar[i] = c; + charToInt[c] = i; +} +function decodeInteger(reader, relative) { + let value = 0; + let shift = 0; + let integer = 0; + do { + const c = reader.next(); + integer = charToInt[c]; + value |= (integer & 31) << shift; + shift += 5; + } while (integer & 32); + const shouldNegate = value & 1; + value >>>= 1; + if (shouldNegate) { + value = -2147483648 | -value; + } + return relative + value; +} +function encodeInteger(builder, num, relative) { + let delta = num - relative; + delta = delta < 0 ? -delta << 1 | 1 : delta << 1; + do { + let clamped = delta & 31; + delta >>>= 5; + if (delta > 0) clamped |= 32; + builder.write(intToChar[clamped]); + } while (delta > 0); + return num; +} +function hasMoreVlq(reader, max) { + if (reader.pos >= max) return false; + return reader.peek() !== comma; +} + +// src/strings.ts +var bufLength = 1024 * 16; +var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? { + decode(buf) { + const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength); + return out.toString(); + } +} : { + decode(buf) { + let out = ""; + for (let i = 0; i < buf.length; i++) { + out += String.fromCharCode(buf[i]); + } + return out; + } +}; +var StringWriter = class { + constructor() { + this.pos = 0; + this.out = ""; + this.buffer = new Uint8Array(bufLength); + } + write(v) { + const { buffer } = this; + buffer[this.pos++] = v; + if (this.pos === bufLength) { + this.out += td.decode(buffer); + this.pos = 0; + } + } + flush() { + const { buffer, out, pos } = this; + return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out; + } +}; +var StringReader = class { + constructor(buffer) { + this.pos = 0; + this.buffer = buffer; + } + next() { + return this.buffer.charCodeAt(this.pos++); + } + peek() { + return this.buffer.charCodeAt(this.pos); + } + indexOf(char) { + const { buffer, pos } = this; + const idx = buffer.indexOf(char, pos); + return idx === -1 ? buffer.length : idx; + } +}; + +// src/scopes.ts +var EMPTY = []; +function decodeOriginalScopes(input) { + const { length } = input; + const reader = new StringReader(input); + const scopes = []; + const stack = []; + let line = 0; + for (; reader.pos < length; reader.pos++) { + line = decodeInteger(reader, line); + const column = decodeInteger(reader, 0); + if (!hasMoreVlq(reader, length)) { + const last = stack.pop(); + last[2] = line; + last[3] = column; + continue; + } + const kind = decodeInteger(reader, 0); + const fields = decodeInteger(reader, 0); + const hasName = fields & 1; + const scope = hasName ? [line, column, 0, 0, kind, decodeInteger(reader, 0)] : [line, column, 0, 0, kind]; + let vars = EMPTY; + if (hasMoreVlq(reader, length)) { + vars = []; + do { + const varsIndex = decodeInteger(reader, 0); + vars.push(varsIndex); + } while (hasMoreVlq(reader, length)); + } + scope.vars = vars; + scopes.push(scope); + stack.push(scope); + } + return scopes; +} +function encodeOriginalScopes(scopes) { + const writer = new StringWriter(); + for (let i = 0; i < scopes.length; ) { + i = _encodeOriginalScopes(scopes, i, writer, [0]); + } + return writer.flush(); +} +function _encodeOriginalScopes(scopes, index, writer, state) { + const scope = scopes[index]; + const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, 4: kind, vars } = scope; + if (index > 0) writer.write(comma); + state[0] = encodeInteger(writer, startLine, state[0]); + encodeInteger(writer, startColumn, 0); + encodeInteger(writer, kind, 0); + const fields = scope.length === 6 ? 1 : 0; + encodeInteger(writer, fields, 0); + if (scope.length === 6) encodeInteger(writer, scope[5], 0); + for (const v of vars) { + encodeInteger(writer, v, 0); + } + for (index++; index < scopes.length; ) { + const next = scopes[index]; + const { 0: l, 1: c } = next; + if (l > endLine || l === endLine && c >= endColumn) { + break; + } + index = _encodeOriginalScopes(scopes, index, writer, state); + } + writer.write(comma); + state[0] = encodeInteger(writer, endLine, state[0]); + encodeInteger(writer, endColumn, 0); + return index; +} +function decodeGeneratedRanges(input) { + const { length } = input; + const reader = new StringReader(input); + const ranges = []; + const stack = []; + let genLine = 0; + let definitionSourcesIndex = 0; + let definitionScopeIndex = 0; + let callsiteSourcesIndex = 0; + let callsiteLine = 0; + let callsiteColumn = 0; + let bindingLine = 0; + let bindingColumn = 0; + do { + const semi = reader.indexOf(";"); + let genColumn = 0; + for (; reader.pos < semi; reader.pos++) { + genColumn = decodeInteger(reader, genColumn); + if (!hasMoreVlq(reader, semi)) { + const last = stack.pop(); + last[2] = genLine; + last[3] = genColumn; + continue; + } + const fields = decodeInteger(reader, 0); + const hasDefinition = fields & 1; + const hasCallsite = fields & 2; + const hasScope = fields & 4; + let callsite = null; + let bindings = EMPTY; + let range; + if (hasDefinition) { + const defSourcesIndex = decodeInteger(reader, definitionSourcesIndex); + definitionScopeIndex = decodeInteger( + reader, + definitionSourcesIndex === defSourcesIndex ? definitionScopeIndex : 0 + ); + definitionSourcesIndex = defSourcesIndex; + range = [genLine, genColumn, 0, 0, defSourcesIndex, definitionScopeIndex]; + } else { + range = [genLine, genColumn, 0, 0]; + } + range.isScope = !!hasScope; + if (hasCallsite) { + const prevCsi = callsiteSourcesIndex; + const prevLine = callsiteLine; + callsiteSourcesIndex = decodeInteger(reader, callsiteSourcesIndex); + const sameSource = prevCsi === callsiteSourcesIndex; + callsiteLine = decodeInteger(reader, sameSource ? callsiteLine : 0); + callsiteColumn = decodeInteger( + reader, + sameSource && prevLine === callsiteLine ? callsiteColumn : 0 + ); + callsite = [callsiteSourcesIndex, callsiteLine, callsiteColumn]; + } + range.callsite = callsite; + if (hasMoreVlq(reader, semi)) { + bindings = []; + do { + bindingLine = genLine; + bindingColumn = genColumn; + const expressionsCount = decodeInteger(reader, 0); + let expressionRanges; + if (expressionsCount < -1) { + expressionRanges = [[decodeInteger(reader, 0)]]; + for (let i = -1; i > expressionsCount; i--) { + const prevBl = bindingLine; + bindingLine = decodeInteger(reader, bindingLine); + bindingColumn = decodeInteger(reader, bindingLine === prevBl ? bindingColumn : 0); + const expression = decodeInteger(reader, 0); + expressionRanges.push([expression, bindingLine, bindingColumn]); + } + } else { + expressionRanges = [[expressionsCount]]; + } + bindings.push(expressionRanges); + } while (hasMoreVlq(reader, semi)); + } + range.bindings = bindings; + ranges.push(range); + stack.push(range); + } + genLine++; + reader.pos = semi + 1; + } while (reader.pos < length); + return ranges; +} +function encodeGeneratedRanges(ranges) { + if (ranges.length === 0) return ""; + const writer = new StringWriter(); + for (let i = 0; i < ranges.length; ) { + i = _encodeGeneratedRanges(ranges, i, writer, [0, 0, 0, 0, 0, 0, 0]); + } + return writer.flush(); +} +function _encodeGeneratedRanges(ranges, index, writer, state) { + const range = ranges[index]; + const { + 0: startLine, + 1: startColumn, + 2: endLine, + 3: endColumn, + isScope, + callsite, + bindings + } = range; + if (state[0] < startLine) { + catchupLine(writer, state[0], startLine); + state[0] = startLine; + state[1] = 0; + } else if (index > 0) { + writer.write(comma); + } + state[1] = encodeInteger(writer, range[1], state[1]); + const fields = (range.length === 6 ? 1 : 0) | (callsite ? 2 : 0) | (isScope ? 4 : 0); + encodeInteger(writer, fields, 0); + if (range.length === 6) { + const { 4: sourcesIndex, 5: scopesIndex } = range; + if (sourcesIndex !== state[2]) { + state[3] = 0; + } + state[2] = encodeInteger(writer, sourcesIndex, state[2]); + state[3] = encodeInteger(writer, scopesIndex, state[3]); + } + if (callsite) { + const { 0: sourcesIndex, 1: callLine, 2: callColumn } = range.callsite; + if (sourcesIndex !== state[4]) { + state[5] = 0; + state[6] = 0; + } else if (callLine !== state[5]) { + state[6] = 0; + } + state[4] = encodeInteger(writer, sourcesIndex, state[4]); + state[5] = encodeInteger(writer, callLine, state[5]); + state[6] = encodeInteger(writer, callColumn, state[6]); + } + if (bindings) { + for (const binding of bindings) { + if (binding.length > 1) encodeInteger(writer, -binding.length, 0); + const expression = binding[0][0]; + encodeInteger(writer, expression, 0); + let bindingStartLine = startLine; + let bindingStartColumn = startColumn; + for (let i = 1; i < binding.length; i++) { + const expRange = binding[i]; + bindingStartLine = encodeInteger(writer, expRange[1], bindingStartLine); + bindingStartColumn = encodeInteger(writer, expRange[2], bindingStartColumn); + encodeInteger(writer, expRange[0], 0); + } + } + } + for (index++; index < ranges.length; ) { + const next = ranges[index]; + const { 0: l, 1: c } = next; + if (l > endLine || l === endLine && c >= endColumn) { + break; + } + index = _encodeGeneratedRanges(ranges, index, writer, state); + } + if (state[0] < endLine) { + catchupLine(writer, state[0], endLine); + state[0] = endLine; + state[1] = 0; + } else { + writer.write(comma); + } + state[1] = encodeInteger(writer, endColumn, state[1]); + return index; +} +function catchupLine(writer, lastLine, line) { + do { + writer.write(semicolon); + } while (++lastLine < line); +} + +// src/sourcemap-codec.ts +function decode(mappings) { + const { length } = mappings; + const reader = new StringReader(mappings); + const decoded = []; + let genColumn = 0; + let sourcesIndex = 0; + let sourceLine = 0; + let sourceColumn = 0; + let namesIndex = 0; + do { + const semi = reader.indexOf(";"); + const line = []; + let sorted = true; + let lastCol = 0; + genColumn = 0; + while (reader.pos < semi) { + let seg; + genColumn = decodeInteger(reader, genColumn); + if (genColumn < lastCol) sorted = false; + lastCol = genColumn; + if (hasMoreVlq(reader, semi)) { + sourcesIndex = decodeInteger(reader, sourcesIndex); + sourceLine = decodeInteger(reader, sourceLine); + sourceColumn = decodeInteger(reader, sourceColumn); + if (hasMoreVlq(reader, semi)) { + namesIndex = decodeInteger(reader, namesIndex); + seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]; + } else { + seg = [genColumn, sourcesIndex, sourceLine, sourceColumn]; + } + } else { + seg = [genColumn]; + } + line.push(seg); + reader.pos++; + } + if (!sorted) sort(line); + decoded.push(line); + reader.pos = semi + 1; + } while (reader.pos <= length); + return decoded; +} +function sort(line) { + line.sort(sortComparator); +} +function sortComparator(a, b) { + return a[0] - b[0]; +} +function encode(decoded) { + const writer = new StringWriter(); + let sourcesIndex = 0; + let sourceLine = 0; + let sourceColumn = 0; + let namesIndex = 0; + for (let i = 0; i < decoded.length; i++) { + const line = decoded[i]; + if (i > 0) writer.write(semicolon); + if (line.length === 0) continue; + let genColumn = 0; + for (let j = 0; j < line.length; j++) { + const segment = line[j]; + if (j > 0) writer.write(comma); + genColumn = encodeInteger(writer, segment[0], genColumn); + if (segment.length === 1) continue; + sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex); + sourceLine = encodeInteger(writer, segment[2], sourceLine); + sourceColumn = encodeInteger(writer, segment[3], sourceColumn); + if (segment.length === 4) continue; + namesIndex = encodeInteger(writer, segment[4], namesIndex); + } + } + return writer.flush(); +} +export { + decode, + decodeGeneratedRanges, + decodeOriginalScopes, + encode, + encodeGeneratedRanges, + encodeOriginalScopes +}; +//# sourceMappingURL=sourcemap-codec.mjs.map diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs.map b/scripts/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs.map new file mode 100644 index 0000000000000000000000000000000000000000..c276844b25973802e167a1da9521f7b54f058b72 --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs.map @@ -0,0 +1,6 @@ +{ + "version": 3, + "sources": ["../src/vlq.ts", "../src/strings.ts", "../src/scopes.ts", "../src/sourcemap-codec.ts"], + "mappings": "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", + "names": [] +} diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js b/scripts/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js new file mode 100644 index 0000000000000000000000000000000000000000..2d8e459f3e2f952d02a62b795bab39252a81d481 --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js @@ -0,0 +1,464 @@ +(function (global, factory) { + if (typeof exports === 'object' && typeof module !== 'undefined') { + factory(module); + module.exports = def(module); + } else if (typeof define === 'function' && define.amd) { + define(['module'], function(mod) { + factory.apply(this, arguments); + mod.exports = def(mod); + }); + } else { + const mod = { exports: {} }; + factory(mod); + global = typeof globalThis !== 'undefined' ? globalThis : global || self; + global.sourcemapCodec = def(mod); + } + function def(m) { return 'default' in m.exports ? m.exports.default : m.exports; } +})(this, (function (module) { +"use strict"; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// src/sourcemap-codec.ts +var sourcemap_codec_exports = {}; +__export(sourcemap_codec_exports, { + decode: () => decode, + decodeGeneratedRanges: () => decodeGeneratedRanges, + decodeOriginalScopes: () => decodeOriginalScopes, + encode: () => encode, + encodeGeneratedRanges: () => encodeGeneratedRanges, + encodeOriginalScopes: () => encodeOriginalScopes +}); +module.exports = __toCommonJS(sourcemap_codec_exports); + +// src/vlq.ts +var comma = ",".charCodeAt(0); +var semicolon = ";".charCodeAt(0); +var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; +var intToChar = new Uint8Array(64); +var charToInt = new Uint8Array(128); +for (let i = 0; i < chars.length; i++) { + const c = chars.charCodeAt(i); + intToChar[i] = c; + charToInt[c] = i; +} +function decodeInteger(reader, relative) { + let value = 0; + let shift = 0; + let integer = 0; + do { + const c = reader.next(); + integer = charToInt[c]; + value |= (integer & 31) << shift; + shift += 5; + } while (integer & 32); + const shouldNegate = value & 1; + value >>>= 1; + if (shouldNegate) { + value = -2147483648 | -value; + } + return relative + value; +} +function encodeInteger(builder, num, relative) { + let delta = num - relative; + delta = delta < 0 ? -delta << 1 | 1 : delta << 1; + do { + let clamped = delta & 31; + delta >>>= 5; + if (delta > 0) clamped |= 32; + builder.write(intToChar[clamped]); + } while (delta > 0); + return num; +} +function hasMoreVlq(reader, max) { + if (reader.pos >= max) return false; + return reader.peek() !== comma; +} + +// src/strings.ts +var bufLength = 1024 * 16; +var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? { + decode(buf) { + const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength); + return out.toString(); + } +} : { + decode(buf) { + let out = ""; + for (let i = 0; i < buf.length; i++) { + out += String.fromCharCode(buf[i]); + } + return out; + } +}; +var StringWriter = class { + constructor() { + this.pos = 0; + this.out = ""; + this.buffer = new Uint8Array(bufLength); + } + write(v) { + const { buffer } = this; + buffer[this.pos++] = v; + if (this.pos === bufLength) { + this.out += td.decode(buffer); + this.pos = 0; + } + } + flush() { + const { buffer, out, pos } = this; + return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out; + } +}; +var StringReader = class { + constructor(buffer) { + this.pos = 0; + this.buffer = buffer; + } + next() { + return this.buffer.charCodeAt(this.pos++); + } + peek() { + return this.buffer.charCodeAt(this.pos); + } + indexOf(char) { + const { buffer, pos } = this; + const idx = buffer.indexOf(char, pos); + return idx === -1 ? buffer.length : idx; + } +}; + +// src/scopes.ts +var EMPTY = []; +function decodeOriginalScopes(input) { + const { length } = input; + const reader = new StringReader(input); + const scopes = []; + const stack = []; + let line = 0; + for (; reader.pos < length; reader.pos++) { + line = decodeInteger(reader, line); + const column = decodeInteger(reader, 0); + if (!hasMoreVlq(reader, length)) { + const last = stack.pop(); + last[2] = line; + last[3] = column; + continue; + } + const kind = decodeInteger(reader, 0); + const fields = decodeInteger(reader, 0); + const hasName = fields & 1; + const scope = hasName ? [line, column, 0, 0, kind, decodeInteger(reader, 0)] : [line, column, 0, 0, kind]; + let vars = EMPTY; + if (hasMoreVlq(reader, length)) { + vars = []; + do { + const varsIndex = decodeInteger(reader, 0); + vars.push(varsIndex); + } while (hasMoreVlq(reader, length)); + } + scope.vars = vars; + scopes.push(scope); + stack.push(scope); + } + return scopes; +} +function encodeOriginalScopes(scopes) { + const writer = new StringWriter(); + for (let i = 0; i < scopes.length; ) { + i = _encodeOriginalScopes(scopes, i, writer, [0]); + } + return writer.flush(); +} +function _encodeOriginalScopes(scopes, index, writer, state) { + const scope = scopes[index]; + const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, 4: kind, vars } = scope; + if (index > 0) writer.write(comma); + state[0] = encodeInteger(writer, startLine, state[0]); + encodeInteger(writer, startColumn, 0); + encodeInteger(writer, kind, 0); + const fields = scope.length === 6 ? 1 : 0; + encodeInteger(writer, fields, 0); + if (scope.length === 6) encodeInteger(writer, scope[5], 0); + for (const v of vars) { + encodeInteger(writer, v, 0); + } + for (index++; index < scopes.length; ) { + const next = scopes[index]; + const { 0: l, 1: c } = next; + if (l > endLine || l === endLine && c >= endColumn) { + break; + } + index = _encodeOriginalScopes(scopes, index, writer, state); + } + writer.write(comma); + state[0] = encodeInteger(writer, endLine, state[0]); + encodeInteger(writer, endColumn, 0); + return index; +} +function decodeGeneratedRanges(input) { + const { length } = input; + const reader = new StringReader(input); + const ranges = []; + const stack = []; + let genLine = 0; + let definitionSourcesIndex = 0; + let definitionScopeIndex = 0; + let callsiteSourcesIndex = 0; + let callsiteLine = 0; + let callsiteColumn = 0; + let bindingLine = 0; + let bindingColumn = 0; + do { + const semi = reader.indexOf(";"); + let genColumn = 0; + for (; reader.pos < semi; reader.pos++) { + genColumn = decodeInteger(reader, genColumn); + if (!hasMoreVlq(reader, semi)) { + const last = stack.pop(); + last[2] = genLine; + last[3] = genColumn; + continue; + } + const fields = decodeInteger(reader, 0); + const hasDefinition = fields & 1; + const hasCallsite = fields & 2; + const hasScope = fields & 4; + let callsite = null; + let bindings = EMPTY; + let range; + if (hasDefinition) { + const defSourcesIndex = decodeInteger(reader, definitionSourcesIndex); + definitionScopeIndex = decodeInteger( + reader, + definitionSourcesIndex === defSourcesIndex ? definitionScopeIndex : 0 + ); + definitionSourcesIndex = defSourcesIndex; + range = [genLine, genColumn, 0, 0, defSourcesIndex, definitionScopeIndex]; + } else { + range = [genLine, genColumn, 0, 0]; + } + range.isScope = !!hasScope; + if (hasCallsite) { + const prevCsi = callsiteSourcesIndex; + const prevLine = callsiteLine; + callsiteSourcesIndex = decodeInteger(reader, callsiteSourcesIndex); + const sameSource = prevCsi === callsiteSourcesIndex; + callsiteLine = decodeInteger(reader, sameSource ? callsiteLine : 0); + callsiteColumn = decodeInteger( + reader, + sameSource && prevLine === callsiteLine ? callsiteColumn : 0 + ); + callsite = [callsiteSourcesIndex, callsiteLine, callsiteColumn]; + } + range.callsite = callsite; + if (hasMoreVlq(reader, semi)) { + bindings = []; + do { + bindingLine = genLine; + bindingColumn = genColumn; + const expressionsCount = decodeInteger(reader, 0); + let expressionRanges; + if (expressionsCount < -1) { + expressionRanges = [[decodeInteger(reader, 0)]]; + for (let i = -1; i > expressionsCount; i--) { + const prevBl = bindingLine; + bindingLine = decodeInteger(reader, bindingLine); + bindingColumn = decodeInteger(reader, bindingLine === prevBl ? bindingColumn : 0); + const expression = decodeInteger(reader, 0); + expressionRanges.push([expression, bindingLine, bindingColumn]); + } + } else { + expressionRanges = [[expressionsCount]]; + } + bindings.push(expressionRanges); + } while (hasMoreVlq(reader, semi)); + } + range.bindings = bindings; + ranges.push(range); + stack.push(range); + } + genLine++; + reader.pos = semi + 1; + } while (reader.pos < length); + return ranges; +} +function encodeGeneratedRanges(ranges) { + if (ranges.length === 0) return ""; + const writer = new StringWriter(); + for (let i = 0; i < ranges.length; ) { + i = _encodeGeneratedRanges(ranges, i, writer, [0, 0, 0, 0, 0, 0, 0]); + } + return writer.flush(); +} +function _encodeGeneratedRanges(ranges, index, writer, state) { + const range = ranges[index]; + const { + 0: startLine, + 1: startColumn, + 2: endLine, + 3: endColumn, + isScope, + callsite, + bindings + } = range; + if (state[0] < startLine) { + catchupLine(writer, state[0], startLine); + state[0] = startLine; + state[1] = 0; + } else if (index > 0) { + writer.write(comma); + } + state[1] = encodeInteger(writer, range[1], state[1]); + const fields = (range.length === 6 ? 1 : 0) | (callsite ? 2 : 0) | (isScope ? 4 : 0); + encodeInteger(writer, fields, 0); + if (range.length === 6) { + const { 4: sourcesIndex, 5: scopesIndex } = range; + if (sourcesIndex !== state[2]) { + state[3] = 0; + } + state[2] = encodeInteger(writer, sourcesIndex, state[2]); + state[3] = encodeInteger(writer, scopesIndex, state[3]); + } + if (callsite) { + const { 0: sourcesIndex, 1: callLine, 2: callColumn } = range.callsite; + if (sourcesIndex !== state[4]) { + state[5] = 0; + state[6] = 0; + } else if (callLine !== state[5]) { + state[6] = 0; + } + state[4] = encodeInteger(writer, sourcesIndex, state[4]); + state[5] = encodeInteger(writer, callLine, state[5]); + state[6] = encodeInteger(writer, callColumn, state[6]); + } + if (bindings) { + for (const binding of bindings) { + if (binding.length > 1) encodeInteger(writer, -binding.length, 0); + const expression = binding[0][0]; + encodeInteger(writer, expression, 0); + let bindingStartLine = startLine; + let bindingStartColumn = startColumn; + for (let i = 1; i < binding.length; i++) { + const expRange = binding[i]; + bindingStartLine = encodeInteger(writer, expRange[1], bindingStartLine); + bindingStartColumn = encodeInteger(writer, expRange[2], bindingStartColumn); + encodeInteger(writer, expRange[0], 0); + } + } + } + for (index++; index < ranges.length; ) { + const next = ranges[index]; + const { 0: l, 1: c } = next; + if (l > endLine || l === endLine && c >= endColumn) { + break; + } + index = _encodeGeneratedRanges(ranges, index, writer, state); + } + if (state[0] < endLine) { + catchupLine(writer, state[0], endLine); + state[0] = endLine; + state[1] = 0; + } else { + writer.write(comma); + } + state[1] = encodeInteger(writer, endColumn, state[1]); + return index; +} +function catchupLine(writer, lastLine, line) { + do { + writer.write(semicolon); + } while (++lastLine < line); +} + +// src/sourcemap-codec.ts +function decode(mappings) { + const { length } = mappings; + const reader = new StringReader(mappings); + const decoded = []; + let genColumn = 0; + let sourcesIndex = 0; + let sourceLine = 0; + let sourceColumn = 0; + let namesIndex = 0; + do { + const semi = reader.indexOf(";"); + const line = []; + let sorted = true; + let lastCol = 0; + genColumn = 0; + while (reader.pos < semi) { + let seg; + genColumn = decodeInteger(reader, genColumn); + if (genColumn < lastCol) sorted = false; + lastCol = genColumn; + if (hasMoreVlq(reader, semi)) { + sourcesIndex = decodeInteger(reader, sourcesIndex); + sourceLine = decodeInteger(reader, sourceLine); + sourceColumn = decodeInteger(reader, sourceColumn); + if (hasMoreVlq(reader, semi)) { + namesIndex = decodeInteger(reader, namesIndex); + seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]; + } else { + seg = [genColumn, sourcesIndex, sourceLine, sourceColumn]; + } + } else { + seg = [genColumn]; + } + line.push(seg); + reader.pos++; + } + if (!sorted) sort(line); + decoded.push(line); + reader.pos = semi + 1; + } while (reader.pos <= length); + return decoded; +} +function sort(line) { + line.sort(sortComparator); +} +function sortComparator(a, b) { + return a[0] - b[0]; +} +function encode(decoded) { + const writer = new StringWriter(); + let sourcesIndex = 0; + let sourceLine = 0; + let sourceColumn = 0; + let namesIndex = 0; + for (let i = 0; i < decoded.length; i++) { + const line = decoded[i]; + if (i > 0) writer.write(semicolon); + if (line.length === 0) continue; + let genColumn = 0; + for (let j = 0; j < line.length; j++) { + const segment = line[j]; + if (j > 0) writer.write(comma); + genColumn = encodeInteger(writer, segment[0], genColumn); + if (segment.length === 1) continue; + sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex); + sourceLine = encodeInteger(writer, segment[2], sourceLine); + sourceColumn = encodeInteger(writer, segment[3], sourceColumn); + if (segment.length === 4) continue; + namesIndex = encodeInteger(writer, segment[4], namesIndex); + } + } + return writer.flush(); +} +})); +//# sourceMappingURL=sourcemap-codec.umd.js.map diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js.map b/scripts/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js.map new file mode 100644 index 0000000000000000000000000000000000000000..abc18d286e183092e99784dedb2651c3a551c20d --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js.map @@ -0,0 +1,6 @@ +{ + "version": 3, + "sources": ["../src/sourcemap-codec.ts", "../src/vlq.ts", "../src/strings.ts", "../src/scopes.ts"], + "mappings": "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", + "names": [] +} diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/package.json b/scripts/node_modules/@jridgewell/sourcemap-codec/package.json new file mode 100644 index 0000000000000000000000000000000000000000..da551376440ae3d77c4159d2385403459a4f447f --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/package.json @@ -0,0 +1,63 @@ +{ + "name": "@jridgewell/sourcemap-codec", + "version": "1.5.5", + "description": "Encode/decode sourcemap mappings", + "keywords": [ + "sourcemap", + "vlq" + ], + "main": "dist/sourcemap-codec.umd.js", + "module": "dist/sourcemap-codec.mjs", + "types": "types/sourcemap-codec.d.cts", + "files": [ + "dist", + "src", + "types" + ], + "exports": { + ".": [ + { + "import": { + "types": "./types/sourcemap-codec.d.mts", + "default": "./dist/sourcemap-codec.mjs" + }, + "default": { + "types": "./types/sourcemap-codec.d.cts", + "default": "./dist/sourcemap-codec.umd.js" + } + }, + "./dist/sourcemap-codec.umd.js" + ], + "./package.json": "./package.json" + }, + "scripts": { + "benchmark": "run-s build:code benchmark:*", + "benchmark:install": "cd benchmark && npm install", + "benchmark:only": "node --expose-gc benchmark/index.js", + "build": "run-s -n build:code build:types", + "build:code": "node ../../esbuild.mjs sourcemap-codec.ts", + "build:types": "run-s build:types:force build:types:emit build:types:mts", + "build:types:force": "rimraf tsconfig.build.tsbuildinfo", + "build:types:emit": "tsc --project tsconfig.build.json", + "build:types:mts": "node ../../mts-types.mjs", + "clean": "run-s -n clean:code clean:types", + "clean:code": "tsc --build --clean tsconfig.build.json", + "clean:types": "rimraf dist types", + "test": "run-s -n test:types test:only test:format", + "test:format": "prettier --check '{src,test}/**/*.ts'", + "test:only": "mocha", + "test:types": "eslint '{src,test}/**/*.ts'", + "lint": "run-s -n lint:types lint:format", + "lint:format": "npm run test:format -- --write", + "lint:types": "npm run test:types -- --fix", + "prepublishOnly": "npm run-s -n build test" + }, + "homepage": "https://github.com/jridgewell/sourcemaps/tree/main/packages/sourcemap-codec", + "repository": { + "type": "git", + "url": "git+https://github.com/jridgewell/sourcemaps.git", + "directory": "packages/sourcemap-codec" + }, + "author": "Justin Ridgewell ", + "license": "MIT" +} diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/src/scopes.ts b/scripts/node_modules/@jridgewell/sourcemap-codec/src/scopes.ts new file mode 100644 index 0000000000000000000000000000000000000000..d194c2f0a66567fdc42e7d4bddc79a5e5d1ad005 --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/src/scopes.ts @@ -0,0 +1,345 @@ +import { StringReader, StringWriter } from './strings'; +import { comma, decodeInteger, encodeInteger, hasMoreVlq, semicolon } from './vlq'; + +const EMPTY: any[] = []; + +type Line = number; +type Column = number; +type Kind = number; +type Name = number; +type Var = number; +type SourcesIndex = number; +type ScopesIndex = number; + +type Mix = (A & O) | (B & O); + +export type OriginalScope = Mix< + [Line, Column, Line, Column, Kind], + [Line, Column, Line, Column, Kind, Name], + { vars: Var[] } +>; + +export type GeneratedRange = Mix< + [Line, Column, Line, Column], + [Line, Column, Line, Column, SourcesIndex, ScopesIndex], + { + callsite: CallSite | null; + bindings: Binding[]; + isScope: boolean; + } +>; +export type CallSite = [SourcesIndex, Line, Column]; +type Binding = BindingExpressionRange[]; +export type BindingExpressionRange = [Name] | [Name, Line, Column]; + +export function decodeOriginalScopes(input: string): OriginalScope[] { + const { length } = input; + const reader = new StringReader(input); + const scopes: OriginalScope[] = []; + const stack: OriginalScope[] = []; + let line = 0; + + for (; reader.pos < length; reader.pos++) { + line = decodeInteger(reader, line); + const column = decodeInteger(reader, 0); + + if (!hasMoreVlq(reader, length)) { + const last = stack.pop()!; + last[2] = line; + last[3] = column; + continue; + } + + const kind = decodeInteger(reader, 0); + const fields = decodeInteger(reader, 0); + const hasName = fields & 0b0001; + + const scope: OriginalScope = ( + hasName ? [line, column, 0, 0, kind, decodeInteger(reader, 0)] : [line, column, 0, 0, kind] + ) as OriginalScope; + + let vars: Var[] = EMPTY; + if (hasMoreVlq(reader, length)) { + vars = []; + do { + const varsIndex = decodeInteger(reader, 0); + vars.push(varsIndex); + } while (hasMoreVlq(reader, length)); + } + scope.vars = vars; + + scopes.push(scope); + stack.push(scope); + } + + return scopes; +} + +export function encodeOriginalScopes(scopes: OriginalScope[]): string { + const writer = new StringWriter(); + + for (let i = 0; i < scopes.length; ) { + i = _encodeOriginalScopes(scopes, i, writer, [0]); + } + + return writer.flush(); +} + +function _encodeOriginalScopes( + scopes: OriginalScope[], + index: number, + writer: StringWriter, + state: [ + number, // GenColumn + ], +): number { + const scope = scopes[index]; + const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, 4: kind, vars } = scope; + + if (index > 0) writer.write(comma); + + state[0] = encodeInteger(writer, startLine, state[0]); + encodeInteger(writer, startColumn, 0); + encodeInteger(writer, kind, 0); + + const fields = scope.length === 6 ? 0b0001 : 0; + encodeInteger(writer, fields, 0); + if (scope.length === 6) encodeInteger(writer, scope[5], 0); + + for (const v of vars) { + encodeInteger(writer, v, 0); + } + + for (index++; index < scopes.length; ) { + const next = scopes[index]; + const { 0: l, 1: c } = next; + if (l > endLine || (l === endLine && c >= endColumn)) { + break; + } + index = _encodeOriginalScopes(scopes, index, writer, state); + } + + writer.write(comma); + state[0] = encodeInteger(writer, endLine, state[0]); + encodeInteger(writer, endColumn, 0); + + return index; +} + +export function decodeGeneratedRanges(input: string): GeneratedRange[] { + const { length } = input; + const reader = new StringReader(input); + const ranges: GeneratedRange[] = []; + const stack: GeneratedRange[] = []; + + let genLine = 0; + let definitionSourcesIndex = 0; + let definitionScopeIndex = 0; + let callsiteSourcesIndex = 0; + let callsiteLine = 0; + let callsiteColumn = 0; + let bindingLine = 0; + let bindingColumn = 0; + + do { + const semi = reader.indexOf(';'); + let genColumn = 0; + + for (; reader.pos < semi; reader.pos++) { + genColumn = decodeInteger(reader, genColumn); + + if (!hasMoreVlq(reader, semi)) { + const last = stack.pop()!; + last[2] = genLine; + last[3] = genColumn; + continue; + } + + const fields = decodeInteger(reader, 0); + const hasDefinition = fields & 0b0001; + const hasCallsite = fields & 0b0010; + const hasScope = fields & 0b0100; + + let callsite: CallSite | null = null; + let bindings: Binding[] = EMPTY; + let range: GeneratedRange; + if (hasDefinition) { + const defSourcesIndex = decodeInteger(reader, definitionSourcesIndex); + definitionScopeIndex = decodeInteger( + reader, + definitionSourcesIndex === defSourcesIndex ? definitionScopeIndex : 0, + ); + + definitionSourcesIndex = defSourcesIndex; + range = [genLine, genColumn, 0, 0, defSourcesIndex, definitionScopeIndex] as GeneratedRange; + } else { + range = [genLine, genColumn, 0, 0] as GeneratedRange; + } + + range.isScope = !!hasScope; + + if (hasCallsite) { + const prevCsi = callsiteSourcesIndex; + const prevLine = callsiteLine; + callsiteSourcesIndex = decodeInteger(reader, callsiteSourcesIndex); + const sameSource = prevCsi === callsiteSourcesIndex; + callsiteLine = decodeInteger(reader, sameSource ? callsiteLine : 0); + callsiteColumn = decodeInteger( + reader, + sameSource && prevLine === callsiteLine ? callsiteColumn : 0, + ); + + callsite = [callsiteSourcesIndex, callsiteLine, callsiteColumn]; + } + range.callsite = callsite; + + if (hasMoreVlq(reader, semi)) { + bindings = []; + do { + bindingLine = genLine; + bindingColumn = genColumn; + const expressionsCount = decodeInteger(reader, 0); + let expressionRanges: BindingExpressionRange[]; + if (expressionsCount < -1) { + expressionRanges = [[decodeInteger(reader, 0)]]; + for (let i = -1; i > expressionsCount; i--) { + const prevBl = bindingLine; + bindingLine = decodeInteger(reader, bindingLine); + bindingColumn = decodeInteger(reader, bindingLine === prevBl ? bindingColumn : 0); + const expression = decodeInteger(reader, 0); + expressionRanges.push([expression, bindingLine, bindingColumn]); + } + } else { + expressionRanges = [[expressionsCount]]; + } + bindings.push(expressionRanges); + } while (hasMoreVlq(reader, semi)); + } + range.bindings = bindings; + + ranges.push(range); + stack.push(range); + } + + genLine++; + reader.pos = semi + 1; + } while (reader.pos < length); + + return ranges; +} + +export function encodeGeneratedRanges(ranges: GeneratedRange[]): string { + if (ranges.length === 0) return ''; + + const writer = new StringWriter(); + + for (let i = 0; i < ranges.length; ) { + i = _encodeGeneratedRanges(ranges, i, writer, [0, 0, 0, 0, 0, 0, 0]); + } + + return writer.flush(); +} + +function _encodeGeneratedRanges( + ranges: GeneratedRange[], + index: number, + writer: StringWriter, + state: [ + number, // GenLine + number, // GenColumn + number, // DefSourcesIndex + number, // DefScopesIndex + number, // CallSourcesIndex + number, // CallLine + number, // CallColumn + ], +): number { + const range = ranges[index]; + const { + 0: startLine, + 1: startColumn, + 2: endLine, + 3: endColumn, + isScope, + callsite, + bindings, + } = range; + + if (state[0] < startLine) { + catchupLine(writer, state[0], startLine); + state[0] = startLine; + state[1] = 0; + } else if (index > 0) { + writer.write(comma); + } + + state[1] = encodeInteger(writer, range[1], state[1]); + + const fields = + (range.length === 6 ? 0b0001 : 0) | (callsite ? 0b0010 : 0) | (isScope ? 0b0100 : 0); + encodeInteger(writer, fields, 0); + + if (range.length === 6) { + const { 4: sourcesIndex, 5: scopesIndex } = range; + if (sourcesIndex !== state[2]) { + state[3] = 0; + } + state[2] = encodeInteger(writer, sourcesIndex, state[2]); + state[3] = encodeInteger(writer, scopesIndex, state[3]); + } + + if (callsite) { + const { 0: sourcesIndex, 1: callLine, 2: callColumn } = range.callsite!; + if (sourcesIndex !== state[4]) { + state[5] = 0; + state[6] = 0; + } else if (callLine !== state[5]) { + state[6] = 0; + } + state[4] = encodeInteger(writer, sourcesIndex, state[4]); + state[5] = encodeInteger(writer, callLine, state[5]); + state[6] = encodeInteger(writer, callColumn, state[6]); + } + + if (bindings) { + for (const binding of bindings) { + if (binding.length > 1) encodeInteger(writer, -binding.length, 0); + const expression = binding[0][0]; + encodeInteger(writer, expression, 0); + let bindingStartLine = startLine; + let bindingStartColumn = startColumn; + for (let i = 1; i < binding.length; i++) { + const expRange = binding[i]; + bindingStartLine = encodeInteger(writer, expRange[1]!, bindingStartLine); + bindingStartColumn = encodeInteger(writer, expRange[2]!, bindingStartColumn); + encodeInteger(writer, expRange[0]!, 0); + } + } + } + + for (index++; index < ranges.length; ) { + const next = ranges[index]; + const { 0: l, 1: c } = next; + if (l > endLine || (l === endLine && c >= endColumn)) { + break; + } + index = _encodeGeneratedRanges(ranges, index, writer, state); + } + + if (state[0] < endLine) { + catchupLine(writer, state[0], endLine); + state[0] = endLine; + state[1] = 0; + } else { + writer.write(comma); + } + state[1] = encodeInteger(writer, endColumn, state[1]); + + return index; +} + +function catchupLine(writer: StringWriter, lastLine: number, line: number) { + do { + writer.write(semicolon); + } while (++lastLine < line); +} diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/src/sourcemap-codec.ts b/scripts/node_modules/@jridgewell/sourcemap-codec/src/sourcemap-codec.ts new file mode 100644 index 0000000000000000000000000000000000000000..a81f894dc1f18937c58978ee1351b6e70bbc8c86 --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/src/sourcemap-codec.ts @@ -0,0 +1,111 @@ +import { comma, decodeInteger, encodeInteger, hasMoreVlq, semicolon } from './vlq'; +import { StringWriter, StringReader } from './strings'; + +export { + decodeOriginalScopes, + encodeOriginalScopes, + decodeGeneratedRanges, + encodeGeneratedRanges, +} from './scopes'; +export type { OriginalScope, GeneratedRange, CallSite, BindingExpressionRange } from './scopes'; + +export type SourceMapSegment = + | [number] + | [number, number, number, number] + | [number, number, number, number, number]; +export type SourceMapLine = SourceMapSegment[]; +export type SourceMapMappings = SourceMapLine[]; + +export function decode(mappings: string): SourceMapMappings { + const { length } = mappings; + const reader = new StringReader(mappings); + const decoded: SourceMapMappings = []; + let genColumn = 0; + let sourcesIndex = 0; + let sourceLine = 0; + let sourceColumn = 0; + let namesIndex = 0; + + do { + const semi = reader.indexOf(';'); + const line: SourceMapLine = []; + let sorted = true; + let lastCol = 0; + genColumn = 0; + + while (reader.pos < semi) { + let seg: SourceMapSegment; + + genColumn = decodeInteger(reader, genColumn); + if (genColumn < lastCol) sorted = false; + lastCol = genColumn; + + if (hasMoreVlq(reader, semi)) { + sourcesIndex = decodeInteger(reader, sourcesIndex); + sourceLine = decodeInteger(reader, sourceLine); + sourceColumn = decodeInteger(reader, sourceColumn); + + if (hasMoreVlq(reader, semi)) { + namesIndex = decodeInteger(reader, namesIndex); + seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]; + } else { + seg = [genColumn, sourcesIndex, sourceLine, sourceColumn]; + } + } else { + seg = [genColumn]; + } + + line.push(seg); + reader.pos++; + } + + if (!sorted) sort(line); + decoded.push(line); + reader.pos = semi + 1; + } while (reader.pos <= length); + + return decoded; +} + +function sort(line: SourceMapSegment[]) { + line.sort(sortComparator); +} + +function sortComparator(a: SourceMapSegment, b: SourceMapSegment): number { + return a[0] - b[0]; +} + +export function encode(decoded: SourceMapMappings): string; +export function encode(decoded: Readonly): string; +export function encode(decoded: Readonly): string { + const writer = new StringWriter(); + let sourcesIndex = 0; + let sourceLine = 0; + let sourceColumn = 0; + let namesIndex = 0; + + for (let i = 0; i < decoded.length; i++) { + const line = decoded[i]; + if (i > 0) writer.write(semicolon); + if (line.length === 0) continue; + + let genColumn = 0; + + for (let j = 0; j < line.length; j++) { + const segment = line[j]; + if (j > 0) writer.write(comma); + + genColumn = encodeInteger(writer, segment[0], genColumn); + + if (segment.length === 1) continue; + sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex); + sourceLine = encodeInteger(writer, segment[2], sourceLine); + sourceColumn = encodeInteger(writer, segment[3], sourceColumn); + + if (segment.length === 4) continue; + namesIndex = encodeInteger(writer, segment[4], namesIndex); + } + } + + return writer.flush(); +} diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/src/strings.ts b/scripts/node_modules/@jridgewell/sourcemap-codec/src/strings.ts new file mode 100644 index 0000000000000000000000000000000000000000..d1619650ea773450fe1febaf6a1354c4022f04b6 --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/src/strings.ts @@ -0,0 +1,65 @@ +const bufLength = 1024 * 16; + +// Provide a fallback for older environments. +const td = + typeof TextDecoder !== 'undefined' + ? /* #__PURE__ */ new TextDecoder() + : typeof Buffer !== 'undefined' + ? { + decode(buf: Uint8Array): string { + const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength); + return out.toString(); + }, + } + : { + decode(buf: Uint8Array): string { + let out = ''; + for (let i = 0; i < buf.length; i++) { + out += String.fromCharCode(buf[i]); + } + return out; + }, + }; + +export class StringWriter { + pos = 0; + private out = ''; + private buffer = new Uint8Array(bufLength); + + write(v: number): void { + const { buffer } = this; + buffer[this.pos++] = v; + if (this.pos === bufLength) { + this.out += td.decode(buffer); + this.pos = 0; + } + } + + flush(): string { + const { buffer, out, pos } = this; + return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out; + } +} + +export class StringReader { + pos = 0; + declare private buffer: string; + + constructor(buffer: string) { + this.buffer = buffer; + } + + next(): number { + return this.buffer.charCodeAt(this.pos++); + } + + peek(): number { + return this.buffer.charCodeAt(this.pos); + } + + indexOf(char: string): number { + const { buffer, pos } = this; + const idx = buffer.indexOf(char, pos); + return idx === -1 ? buffer.length : idx; + } +} diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/src/vlq.ts b/scripts/node_modules/@jridgewell/sourcemap-codec/src/vlq.ts new file mode 100644 index 0000000000000000000000000000000000000000..a42c681511bbec0faecd9aeb9e6e7d5dbea0e391 --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/src/vlq.ts @@ -0,0 +1,55 @@ +import type { StringReader, StringWriter } from './strings'; + +export const comma = ','.charCodeAt(0); +export const semicolon = ';'.charCodeAt(0); + +const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; +const intToChar = new Uint8Array(64); // 64 possible chars. +const charToInt = new Uint8Array(128); // z is 122 in ASCII + +for (let i = 0; i < chars.length; i++) { + const c = chars.charCodeAt(i); + intToChar[i] = c; + charToInt[c] = i; +} + +export function decodeInteger(reader: StringReader, relative: number): number { + let value = 0; + let shift = 0; + let integer = 0; + + do { + const c = reader.next(); + integer = charToInt[c]; + value |= (integer & 31) << shift; + shift += 5; + } while (integer & 32); + + const shouldNegate = value & 1; + value >>>= 1; + + if (shouldNegate) { + value = -0x80000000 | -value; + } + + return relative + value; +} + +export function encodeInteger(builder: StringWriter, num: number, relative: number): number { + let delta = num - relative; + + delta = delta < 0 ? (-delta << 1) | 1 : delta << 1; + do { + let clamped = delta & 0b011111; + delta >>>= 5; + if (delta > 0) clamped |= 0b100000; + builder.write(intToChar[clamped]); + } while (delta > 0); + + return num; +} + +export function hasMoreVlq(reader: StringReader, max: number) { + if (reader.pos >= max) return false; + return reader.peek() !== comma; +} diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.cts b/scripts/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..c583c7560dece416257b832315f89fa58f32c782 --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.cts @@ -0,0 +1,50 @@ +type Line = number; +type Column = number; +type Kind = number; +type Name = number; +type Var = number; +type SourcesIndex = number; +type ScopesIndex = number; +type Mix = (A & O) | (B & O); +export type OriginalScope = Mix<[ + Line, + Column, + Line, + Column, + Kind +], [ + Line, + Column, + Line, + Column, + Kind, + Name +], { + vars: Var[]; +}>; +export type GeneratedRange = Mix<[ + Line, + Column, + Line, + Column +], [ + Line, + Column, + Line, + Column, + SourcesIndex, + ScopesIndex +], { + callsite: CallSite | null; + bindings: Binding[]; + isScope: boolean; +}>; +export type CallSite = [SourcesIndex, Line, Column]; +type Binding = BindingExpressionRange[]; +export type BindingExpressionRange = [Name] | [Name, Line, Column]; +export declare function decodeOriginalScopes(input: string): OriginalScope[]; +export declare function encodeOriginalScopes(scopes: OriginalScope[]): string; +export declare function decodeGeneratedRanges(input: string): GeneratedRange[]; +export declare function encodeGeneratedRanges(ranges: GeneratedRange[]): string; +export {}; +//# sourceMappingURL=scopes.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.cts.map b/scripts/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.cts.map new file mode 100644 index 0000000000000000000000000000000000000000..630e6477b73f115c0f660fe2b50b8acb36b54a61 --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"scopes.d.ts","sourceRoot":"","sources":["../src/scopes.ts"],"names":[],"mappings":"AAKA,KAAK,IAAI,GAAG,MAAM,CAAC;AACnB,KAAK,MAAM,GAAG,MAAM,CAAC;AACrB,KAAK,IAAI,GAAG,MAAM,CAAC;AACnB,KAAK,IAAI,GAAG,MAAM,CAAC;AACnB,KAAK,GAAG,GAAG,MAAM,CAAC;AAClB,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,WAAW,GAAG,MAAM,CAAC;AAE1B,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAEtC,MAAM,MAAM,aAAa,GAAG,GAAG,CAC7B;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;IAAE,IAAI;CAAC,EAClC;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,IAAI;CAAC,EACxC;IAAE,IAAI,EAAE,GAAG,EAAE,CAAA;CAAE,CAChB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,GAAG,CAC9B;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;CAAC,EAC5B;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;IAAE,YAAY;IAAE,WAAW;CAAC,EACvD;IACE,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC1B,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;CAClB,CACF,CAAC;AACF,MAAM,MAAM,QAAQ,GAAG,CAAC,YAAY,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;AACpD,KAAK,OAAO,GAAG,sBAAsB,EAAE,CAAC;AACxC,MAAM,MAAM,sBAAsB,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;AAEnE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,EAAE,CAyCnE;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,MAAM,CAQpE;AA2CD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,EAAE,CAoGrE;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,cAAc,EAAE,GAAG,MAAM,CAUtE"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.mts b/scripts/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..c583c7560dece416257b832315f89fa58f32c782 --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.mts @@ -0,0 +1,50 @@ +type Line = number; +type Column = number; +type Kind = number; +type Name = number; +type Var = number; +type SourcesIndex = number; +type ScopesIndex = number; +type Mix = (A & O) | (B & O); +export type OriginalScope = Mix<[ + Line, + Column, + Line, + Column, + Kind +], [ + Line, + Column, + Line, + Column, + Kind, + Name +], { + vars: Var[]; +}>; +export type GeneratedRange = Mix<[ + Line, + Column, + Line, + Column +], [ + Line, + Column, + Line, + Column, + SourcesIndex, + ScopesIndex +], { + callsite: CallSite | null; + bindings: Binding[]; + isScope: boolean; +}>; +export type CallSite = [SourcesIndex, Line, Column]; +type Binding = BindingExpressionRange[]; +export type BindingExpressionRange = [Name] | [Name, Line, Column]; +export declare function decodeOriginalScopes(input: string): OriginalScope[]; +export declare function encodeOriginalScopes(scopes: OriginalScope[]): string; +export declare function decodeGeneratedRanges(input: string): GeneratedRange[]; +export declare function encodeGeneratedRanges(ranges: GeneratedRange[]): string; +export {}; +//# sourceMappingURL=scopes.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.mts.map b/scripts/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..630e6477b73f115c0f660fe2b50b8acb36b54a61 --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"scopes.d.ts","sourceRoot":"","sources":["../src/scopes.ts"],"names":[],"mappings":"AAKA,KAAK,IAAI,GAAG,MAAM,CAAC;AACnB,KAAK,MAAM,GAAG,MAAM,CAAC;AACrB,KAAK,IAAI,GAAG,MAAM,CAAC;AACnB,KAAK,IAAI,GAAG,MAAM,CAAC;AACnB,KAAK,GAAG,GAAG,MAAM,CAAC;AAClB,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,WAAW,GAAG,MAAM,CAAC;AAE1B,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAEtC,MAAM,MAAM,aAAa,GAAG,GAAG,CAC7B;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;IAAE,IAAI;CAAC,EAClC;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,IAAI;CAAC,EACxC;IAAE,IAAI,EAAE,GAAG,EAAE,CAAA;CAAE,CAChB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,GAAG,CAC9B;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;CAAC,EAC5B;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;IAAE,YAAY;IAAE,WAAW;CAAC,EACvD;IACE,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC1B,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;CAClB,CACF,CAAC;AACF,MAAM,MAAM,QAAQ,GAAG,CAAC,YAAY,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;AACpD,KAAK,OAAO,GAAG,sBAAsB,EAAE,CAAC;AACxC,MAAM,MAAM,sBAAsB,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;AAEnE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,EAAE,CAyCnE;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,MAAM,CAQpE;AA2CD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,EAAE,CAoGrE;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,cAAc,EAAE,GAAG,MAAM,CAUtE"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.cts b/scripts/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..5f35e22fbd820a22774712e8ee9a143198181570 --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.cts @@ -0,0 +1,9 @@ +export { decodeOriginalScopes, encodeOriginalScopes, decodeGeneratedRanges, encodeGeneratedRanges, } from './scopes.cts'; +export type { OriginalScope, GeneratedRange, CallSite, BindingExpressionRange } from './scopes.cts'; +export type SourceMapSegment = [number] | [number, number, number, number] | [number, number, number, number, number]; +export type SourceMapLine = SourceMapSegment[]; +export type SourceMapMappings = SourceMapLine[]; +export declare function decode(mappings: string): SourceMapMappings; +export declare function encode(decoded: SourceMapMappings): string; +export declare function encode(decoded: Readonly): string; +//# sourceMappingURL=sourcemap-codec.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.cts.map b/scripts/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.cts.map new file mode 100644 index 0000000000000000000000000000000000000000..7123d5208334960664abfaae0e5b663819462c0b --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"sourcemap-codec.d.ts","sourceRoot":"","sources":["../src/sourcemap-codec.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,QAAQ,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAEhG,MAAM,MAAM,gBAAgB,GACxB,CAAC,MAAM,CAAC,GACR,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAChC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAC7C,MAAM,MAAM,aAAa,GAAG,gBAAgB,EAAE,CAAC;AAC/C,MAAM,MAAM,iBAAiB,GAAG,aAAa,EAAE,CAAC;AAEhD,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,CAiD1D;AAUD,wBAAgB,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM,CAAC;AAC3D,wBAAgB,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,iBAAiB,CAAC,GAAG,MAAM,CAAC"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.mts b/scripts/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..199fb9f534fe625d4c18c27c2b79e2309708279c --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.mts @@ -0,0 +1,9 @@ +export { decodeOriginalScopes, encodeOriginalScopes, decodeGeneratedRanges, encodeGeneratedRanges, } from './scopes.mts'; +export type { OriginalScope, GeneratedRange, CallSite, BindingExpressionRange } from './scopes.mts'; +export type SourceMapSegment = [number] | [number, number, number, number] | [number, number, number, number, number]; +export type SourceMapLine = SourceMapSegment[]; +export type SourceMapMappings = SourceMapLine[]; +export declare function decode(mappings: string): SourceMapMappings; +export declare function encode(decoded: SourceMapMappings): string; +export declare function encode(decoded: Readonly): string; +//# sourceMappingURL=sourcemap-codec.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.mts.map b/scripts/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..7123d5208334960664abfaae0e5b663819462c0b --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"sourcemap-codec.d.ts","sourceRoot":"","sources":["../src/sourcemap-codec.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,QAAQ,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAEhG,MAAM,MAAM,gBAAgB,GACxB,CAAC,MAAM,CAAC,GACR,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAChC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAC7C,MAAM,MAAM,aAAa,GAAG,gBAAgB,EAAE,CAAC;AAC/C,MAAM,MAAM,iBAAiB,GAAG,aAAa,EAAE,CAAC;AAEhD,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,CAiD1D;AAUD,wBAAgB,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM,CAAC;AAC3D,wBAAgB,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,iBAAiB,CAAC,GAAG,MAAM,CAAC"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/types/strings.d.cts b/scripts/node_modules/@jridgewell/sourcemap-codec/types/strings.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..62faceb3de9c90532158206c1ab55ee35ac24a89 --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/types/strings.d.cts @@ -0,0 +1,16 @@ +export declare class StringWriter { + pos: number; + private out; + private buffer; + write(v: number): void; + flush(): string; +} +export declare class StringReader { + pos: number; + private buffer; + constructor(buffer: string); + next(): number; + peek(): number; + indexOf(char: string): number; +} +//# sourceMappingURL=strings.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/types/strings.d.cts.map b/scripts/node_modules/@jridgewell/sourcemap-codec/types/strings.d.cts.map new file mode 100644 index 0000000000000000000000000000000000000000..d3602da4257449b6145da1bcaf14314073d6f31a --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/types/strings.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../src/strings.ts"],"names":[],"mappings":"AAuBA,qBAAa,YAAY;IACvB,GAAG,SAAK;IACR,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,MAAM,CAA6B;IAE3C,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAStB,KAAK,IAAI,MAAM;CAIhB;AAED,qBAAa,YAAY;IACvB,GAAG,SAAK;IACR,QAAgB,MAAM,CAAS;gBAEnB,MAAM,EAAE,MAAM;IAI1B,IAAI,IAAI,MAAM;IAId,IAAI,IAAI,MAAM;IAId,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAK9B"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/types/strings.d.mts b/scripts/node_modules/@jridgewell/sourcemap-codec/types/strings.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..62faceb3de9c90532158206c1ab55ee35ac24a89 --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/types/strings.d.mts @@ -0,0 +1,16 @@ +export declare class StringWriter { + pos: number; + private out; + private buffer; + write(v: number): void; + flush(): string; +} +export declare class StringReader { + pos: number; + private buffer; + constructor(buffer: string); + next(): number; + peek(): number; + indexOf(char: string): number; +} +//# sourceMappingURL=strings.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/types/strings.d.mts.map b/scripts/node_modules/@jridgewell/sourcemap-codec/types/strings.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..d3602da4257449b6145da1bcaf14314073d6f31a --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/types/strings.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../src/strings.ts"],"names":[],"mappings":"AAuBA,qBAAa,YAAY;IACvB,GAAG,SAAK;IACR,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,MAAM,CAA6B;IAE3C,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAStB,KAAK,IAAI,MAAM;CAIhB;AAED,qBAAa,YAAY;IACvB,GAAG,SAAK;IACR,QAAgB,MAAM,CAAS;gBAEnB,MAAM,EAAE,MAAM;IAI1B,IAAI,IAAI,MAAM;IAId,IAAI,IAAI,MAAM;IAId,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAK9B"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.cts b/scripts/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..dbd6602d1876df8089ce52b3309b340d1a088555 --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.cts @@ -0,0 +1,7 @@ +import type { StringReader, StringWriter } from './strings.cts'; +export declare const comma: number; +export declare const semicolon: number; +export declare function decodeInteger(reader: StringReader, relative: number): number; +export declare function encodeInteger(builder: StringWriter, num: number, relative: number): number; +export declare function hasMoreVlq(reader: StringReader, max: number): boolean; +//# sourceMappingURL=vlq.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.cts.map b/scripts/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.cts.map new file mode 100644 index 0000000000000000000000000000000000000000..6fdc356977cc89df14692e21863ed6724b63a0fc --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"vlq.d.ts","sourceRoot":"","sources":["../src/vlq.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE5D,eAAO,MAAM,KAAK,QAAoB,CAAC;AACvC,eAAO,MAAM,SAAS,QAAoB,CAAC;AAY3C,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAoB5E;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAY1F;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,WAG3D"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.mts b/scripts/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..2c739bc9fedb038a659a85726a98af7c5f32c5da --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.mts @@ -0,0 +1,7 @@ +import type { StringReader, StringWriter } from './strings.mts'; +export declare const comma: number; +export declare const semicolon: number; +export declare function decodeInteger(reader: StringReader, relative: number): number; +export declare function encodeInteger(builder: StringWriter, num: number, relative: number): number; +export declare function hasMoreVlq(reader: StringReader, max: number): boolean; +//# sourceMappingURL=vlq.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.mts.map b/scripts/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..6fdc356977cc89df14692e21863ed6724b63a0fc --- /dev/null +++ b/scripts/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"vlq.d.ts","sourceRoot":"","sources":["../src/vlq.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE5D,eAAO,MAAM,KAAK,QAAoB,CAAC;AACvC,eAAO,MAAM,SAAS,QAAoB,CAAC;AAY3C,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAoB5E;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAY1F;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,WAG3D"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/LICENSE b/scripts/node_modules/@jridgewell/trace-mapping/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..1f6ce94c11912496b96298630d84753dbf593a7d --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/LICENSE @@ -0,0 +1,19 @@ +Copyright 2024 Justin Ridgewell + +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/scripts/node_modules/@jridgewell/trace-mapping/README.md b/scripts/node_modules/@jridgewell/trace-mapping/README.md new file mode 100644 index 0000000000000000000000000000000000000000..9fc0ed09cedeb0eea388b5d2b891b87886830776 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/README.md @@ -0,0 +1,348 @@ +# @jridgewell/trace-mapping + +> Trace the original position through a source map + +`trace-mapping` allows you to take the line and column of an output file and trace it to the +original location in the source file through a source map. + +You may already be familiar with the [`source-map`][source-map] package's `SourceMapConsumer`. This +provides the same `originalPositionFor` and `generatedPositionFor` API, without requiring WASM. + +## Installation + +```sh +npm install @jridgewell/trace-mapping +``` + +## Usage + +```typescript +import { + TraceMap, + originalPositionFor, + generatedPositionFor, + sourceContentFor, + isIgnored, +} from '@jridgewell/trace-mapping'; + +const tracer = new TraceMap({ + version: 3, + sources: ['input.js'], + sourcesContent: ['content of input.js'], + names: ['foo'], + mappings: 'KAyCIA', + ignoreList: [], +}); + +// Lines start at line 1, columns at column 0. +const traced = originalPositionFor(tracer, { line: 1, column: 5 }); +assert.deepEqual(traced, { + source: 'input.js', + line: 42, + column: 4, + name: 'foo', +}); + +const content = sourceContentFor(tracer, traced.source); +assert.strictEqual(content, 'content for input.js'); + +const generated = generatedPositionFor(tracer, { + source: 'input.js', + line: 42, + column: 4, +}); +assert.deepEqual(generated, { + line: 1, + column: 5, +}); + +const ignored = isIgnored(tracer, 'input.js'); +assert.equal(ignored, false); +``` + +We also provide a lower level API to get the actual segment that matches our line and column. Unlike +`originalPositionFor`, `traceSegment` uses a 0-base for `line`: + +```typescript +import { traceSegment } from '@jridgewell/trace-mapping'; + +// line is 0-base. +const traced = traceSegment(tracer, /* line */ 0, /* column */ 5); + +// Segments are [outputColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex] +// Again, line is 0-base and so is sourceLine +assert.deepEqual(traced, [5, 0, 41, 4, 0]); +``` + +### SectionedSourceMaps + +The sourcemap spec defines a special `sections` field that's designed to handle concatenation of +output code with associated sourcemaps. This type of sourcemap is rarely used (no major build tool +produces it), but if you are hand coding a concatenation you may need it. We provide an `AnyMap` +helper that can receive either a regular sourcemap or a `SectionedSourceMap` and returns a +`TraceMap` instance: + +```typescript +import { AnyMap } from '@jridgewell/trace-mapping'; +const fooOutput = 'foo'; +const barOutput = 'bar'; +const output = [fooOutput, barOutput].join('\n'); + +const sectioned = new AnyMap({ + version: 3, + sections: [ + { + // 0-base line and column + offset: { line: 0, column: 0 }, + // fooOutput's sourcemap + map: { + version: 3, + sources: ['foo.js'], + names: ['foo'], + mappings: 'AAAAA', + }, + }, + { + // barOutput's sourcemap will not affect the first line, only the second + offset: { line: 1, column: 0 }, + map: { + version: 3, + sources: ['bar.js'], + names: ['bar'], + mappings: 'AAAAA', + }, + }, + ], +}); + +const traced = originalPositionFor(sectioned, { + line: 2, + column: 0, +}); + +assert.deepEqual(traced, { + source: 'bar.js', + line: 1, + column: 0, + name: 'bar', +}); +``` + +## Benchmarks + +``` +node v20.10.0 + +amp.js.map - 45120 segments + +Memory Usage: +trace-mapping decoded 414164 bytes +trace-mapping encoded 6274352 bytes +source-map-js 10968904 bytes +source-map-0.6.1 17587160 bytes +source-map-0.8.0 8812155 bytes +Chrome dev tools 8672912 bytes +Smallest memory usage is trace-mapping decoded + +Init speed: +trace-mapping: decoded JSON input x 205 ops/sec ±0.19% (88 runs sampled) +trace-mapping: encoded JSON input x 405 ops/sec ±1.47% (88 runs sampled) +trace-mapping: decoded Object input x 4,645 ops/sec ±0.15% (98 runs sampled) +trace-mapping: encoded Object input x 458 ops/sec ±1.63% (91 runs sampled) +source-map-js: encoded Object input x 75.48 ops/sec ±1.64% (67 runs sampled) +source-map-0.6.1: encoded Object input x 39.37 ops/sec ±1.44% (53 runs sampled) +Chrome dev tools: encoded Object input x 150 ops/sec ±1.76% (79 runs sampled) +Fastest is trace-mapping: decoded Object input + +Trace speed (random): +trace-mapping: decoded originalPositionFor x 44,946 ops/sec ±0.16% (99 runs sampled) +trace-mapping: encoded originalPositionFor x 37,995 ops/sec ±1.81% (89 runs sampled) +source-map-js: encoded originalPositionFor x 9,230 ops/sec ±1.36% (93 runs sampled) +source-map-0.6.1: encoded originalPositionFor x 8,057 ops/sec ±0.84% (96 runs sampled) +source-map-0.8.0: encoded originalPositionFor x 28,198 ops/sec ±1.12% (91 runs sampled) +Chrome dev tools: encoded originalPositionFor x 46,276 ops/sec ±1.35% (95 runs sampled) +Fastest is Chrome dev tools: encoded originalPositionFor + +Trace speed (ascending): +trace-mapping: decoded originalPositionFor x 204,406 ops/sec ±0.19% (97 runs sampled) +trace-mapping: encoded originalPositionFor x 196,695 ops/sec ±0.24% (99 runs sampled) +source-map-js: encoded originalPositionFor x 11,948 ops/sec ±0.94% (99 runs sampled) +source-map-0.6.1: encoded originalPositionFor x 10,730 ops/sec ±0.36% (100 runs sampled) +source-map-0.8.0: encoded originalPositionFor x 51,427 ops/sec ±0.21% (98 runs sampled) +Chrome dev tools: encoded originalPositionFor x 162,615 ops/sec ±0.18% (98 runs sampled) +Fastest is trace-mapping: decoded originalPositionFor + + +*** + + +babel.min.js.map - 347793 segments + +Memory Usage: +trace-mapping decoded 18504 bytes +trace-mapping encoded 35428008 bytes +source-map-js 51676808 bytes +source-map-0.6.1 63367136 bytes +source-map-0.8.0 43158400 bytes +Chrome dev tools 50721552 bytes +Smallest memory usage is trace-mapping decoded + +Init speed: +trace-mapping: decoded JSON input x 17.82 ops/sec ±6.35% (35 runs sampled) +trace-mapping: encoded JSON input x 31.57 ops/sec ±7.50% (43 runs sampled) +trace-mapping: decoded Object input x 867 ops/sec ±0.74% (94 runs sampled) +trace-mapping: encoded Object input x 33.83 ops/sec ±7.66% (46 runs sampled) +source-map-js: encoded Object input x 6.58 ops/sec ±3.31% (20 runs sampled) +source-map-0.6.1: encoded Object input x 4.23 ops/sec ±3.43% (15 runs sampled) +Chrome dev tools: encoded Object input x 22.14 ops/sec ±3.79% (41 runs sampled) +Fastest is trace-mapping: decoded Object input + +Trace speed (random): +trace-mapping: decoded originalPositionFor x 78,234 ops/sec ±1.48% (29 runs sampled) +trace-mapping: encoded originalPositionFor x 60,761 ops/sec ±1.35% (21 runs sampled) +source-map-js: encoded originalPositionFor x 51,448 ops/sec ±2.17% (89 runs sampled) +source-map-0.6.1: encoded originalPositionFor x 47,221 ops/sec ±1.99% (15 runs sampled) +source-map-0.8.0: encoded originalPositionFor x 84,002 ops/sec ±1.45% (27 runs sampled) +Chrome dev tools: encoded originalPositionFor x 106,457 ops/sec ±1.38% (37 runs sampled) +Fastest is Chrome dev tools: encoded originalPositionFor + +Trace speed (ascending): +trace-mapping: decoded originalPositionFor x 930,943 ops/sec ±0.25% (99 runs sampled) +trace-mapping: encoded originalPositionFor x 843,545 ops/sec ±0.34% (97 runs sampled) +source-map-js: encoded originalPositionFor x 114,510 ops/sec ±1.37% (36 runs sampled) +source-map-0.6.1: encoded originalPositionFor x 87,412 ops/sec ±0.72% (92 runs sampled) +source-map-0.8.0: encoded originalPositionFor x 197,709 ops/sec ±0.89% (59 runs sampled) +Chrome dev tools: encoded originalPositionFor x 688,983 ops/sec ±0.33% (98 runs sampled) +Fastest is trace-mapping: decoded originalPositionFor + + +*** + + +preact.js.map - 1992 segments + +Memory Usage: +trace-mapping decoded 33136 bytes +trace-mapping encoded 254240 bytes +source-map-js 837488 bytes +source-map-0.6.1 961928 bytes +source-map-0.8.0 54384 bytes +Chrome dev tools 709680 bytes +Smallest memory usage is trace-mapping decoded + +Init speed: +trace-mapping: decoded JSON input x 3,709 ops/sec ±0.13% (99 runs sampled) +trace-mapping: encoded JSON input x 6,447 ops/sec ±0.22% (101 runs sampled) +trace-mapping: decoded Object input x 83,062 ops/sec ±0.23% (100 runs sampled) +trace-mapping: encoded Object input x 14,980 ops/sec ±0.28% (100 runs sampled) +source-map-js: encoded Object input x 2,544 ops/sec ±0.16% (99 runs sampled) +source-map-0.6.1: encoded Object input x 1,221 ops/sec ±0.37% (97 runs sampled) +Chrome dev tools: encoded Object input x 4,241 ops/sec ±0.39% (93 runs sampled) +Fastest is trace-mapping: decoded Object input + +Trace speed (random): +trace-mapping: decoded originalPositionFor x 91,028 ops/sec ±0.14% (94 runs sampled) +trace-mapping: encoded originalPositionFor x 84,348 ops/sec ±0.26% (98 runs sampled) +source-map-js: encoded originalPositionFor x 26,998 ops/sec ±0.23% (98 runs sampled) +source-map-0.6.1: encoded originalPositionFor x 18,049 ops/sec ±0.26% (100 runs sampled) +source-map-0.8.0: encoded originalPositionFor x 41,916 ops/sec ±0.28% (98 runs sampled) +Chrome dev tools: encoded originalPositionFor x 88,616 ops/sec ±0.14% (98 runs sampled) +Fastest is trace-mapping: decoded originalPositionFor + +Trace speed (ascending): +trace-mapping: decoded originalPositionFor x 319,960 ops/sec ±0.16% (100 runs sampled) +trace-mapping: encoded originalPositionFor x 302,153 ops/sec ±0.18% (100 runs sampled) +source-map-js: encoded originalPositionFor x 35,574 ops/sec ±0.19% (100 runs sampled) +source-map-0.6.1: encoded originalPositionFor x 19,943 ops/sec ±0.12% (101 runs sampled) +source-map-0.8.0: encoded originalPositionFor x 54,648 ops/sec ±0.20% (99 runs sampled) +Chrome dev tools: encoded originalPositionFor x 278,319 ops/sec ±0.17% (102 runs sampled) +Fastest is trace-mapping: decoded originalPositionFor + + +*** + + +react.js.map - 5726 segments + +Memory Usage: +trace-mapping decoded 10872 bytes +trace-mapping encoded 681512 bytes +source-map-js 2563944 bytes +source-map-0.6.1 2150864 bytes +source-map-0.8.0 88680 bytes +Chrome dev tools 1149576 bytes +Smallest memory usage is trace-mapping decoded + +Init speed: +trace-mapping: decoded JSON input x 1,887 ops/sec ±0.28% (99 runs sampled) +trace-mapping: encoded JSON input x 4,749 ops/sec ±0.48% (97 runs sampled) +trace-mapping: decoded Object input x 74,236 ops/sec ±0.11% (99 runs sampled) +trace-mapping: encoded Object input x 5,752 ops/sec ±0.38% (100 runs sampled) +source-map-js: encoded Object input x 806 ops/sec ±0.19% (97 runs sampled) +source-map-0.6.1: encoded Object input x 418 ops/sec ±0.33% (94 runs sampled) +Chrome dev tools: encoded Object input x 1,524 ops/sec ±0.57% (92 runs sampled) +Fastest is trace-mapping: decoded Object input + +Trace speed (random): +trace-mapping: decoded originalPositionFor x 620,201 ops/sec ±0.33% (96 runs sampled) +trace-mapping: encoded originalPositionFor x 579,548 ops/sec ±0.35% (97 runs sampled) +source-map-js: encoded originalPositionFor x 230,983 ops/sec ±0.62% (54 runs sampled) +source-map-0.6.1: encoded originalPositionFor x 158,145 ops/sec ±0.80% (46 runs sampled) +source-map-0.8.0: encoded originalPositionFor x 343,801 ops/sec ±0.55% (96 runs sampled) +Chrome dev tools: encoded originalPositionFor x 659,649 ops/sec ±0.49% (98 runs sampled) +Fastest is Chrome dev tools: encoded originalPositionFor + +Trace speed (ascending): +trace-mapping: decoded originalPositionFor x 2,368,079 ops/sec ±0.32% (98 runs sampled) +trace-mapping: encoded originalPositionFor x 2,134,039 ops/sec ±2.72% (87 runs sampled) +source-map-js: encoded originalPositionFor x 290,120 ops/sec ±2.49% (82 runs sampled) +source-map-0.6.1: encoded originalPositionFor x 187,613 ops/sec ±0.86% (49 runs sampled) +source-map-0.8.0: encoded originalPositionFor x 479,569 ops/sec ±0.65% (96 runs sampled) +Chrome dev tools: encoded originalPositionFor x 2,048,414 ops/sec ±0.24% (98 runs sampled) +Fastest is trace-mapping: decoded originalPositionFor + + +*** + + +vscode.map - 2141001 segments + +Memory Usage: +trace-mapping decoded 5206584 bytes +trace-mapping encoded 208370336 bytes +source-map-js 278493008 bytes +source-map-0.6.1 391564048 bytes +source-map-0.8.0 257508787 bytes +Chrome dev tools 291053000 bytes +Smallest memory usage is trace-mapping decoded + +Init speed: +trace-mapping: decoded JSON input x 1.63 ops/sec ±33.88% (9 runs sampled) +trace-mapping: encoded JSON input x 3.29 ops/sec ±36.13% (13 runs sampled) +trace-mapping: decoded Object input x 103 ops/sec ±0.93% (77 runs sampled) +trace-mapping: encoded Object input x 5.42 ops/sec ±28.54% (19 runs sampled) +source-map-js: encoded Object input x 1.07 ops/sec ±13.84% (7 runs sampled) +source-map-0.6.1: encoded Object input x 0.60 ops/sec ±2.43% (6 runs sampled) +Chrome dev tools: encoded Object input x 2.61 ops/sec ±22.00% (11 runs sampled) +Fastest is trace-mapping: decoded Object input + +Trace speed (random): +trace-mapping: decoded originalPositionFor x 257,019 ops/sec ±0.97% (93 runs sampled) +trace-mapping: encoded originalPositionFor x 179,163 ops/sec ±0.83% (92 runs sampled) +source-map-js: encoded originalPositionFor x 73,337 ops/sec ±1.35% (87 runs sampled) +source-map-0.6.1: encoded originalPositionFor x 38,797 ops/sec ±1.66% (88 runs sampled) +source-map-0.8.0: encoded originalPositionFor x 107,758 ops/sec ±1.94% (45 runs sampled) +Chrome dev tools: encoded originalPositionFor x 188,550 ops/sec ±1.85% (79 runs sampled) +Fastest is trace-mapping: decoded originalPositionFor + +Trace speed (ascending): +trace-mapping: decoded originalPositionFor x 447,621 ops/sec ±3.64% (94 runs sampled) +trace-mapping: encoded originalPositionFor x 323,698 ops/sec ±5.20% (88 runs sampled) +source-map-js: encoded originalPositionFor x 78,387 ops/sec ±1.69% (89 runs sampled) +source-map-0.6.1: encoded originalPositionFor x 41,016 ops/sec ±3.01% (25 runs sampled) +source-map-0.8.0: encoded originalPositionFor x 124,204 ops/sec ±0.90% (92 runs sampled) +Chrome dev tools: encoded originalPositionFor x 230,087 ops/sec ±2.61% (93 runs sampled) +Fastest is trace-mapping: decoded originalPositionFor +``` + +[source-map]: https://www.npmjs.com/package/source-map diff --git a/scripts/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs b/scripts/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs new file mode 100644 index 0000000000000000000000000000000000000000..73a95c77d0329af0dcabf21caaa14a49956d0cbd --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs @@ -0,0 +1,493 @@ +// src/trace-mapping.ts +import { encode, decode } from "@jridgewell/sourcemap-codec"; + +// src/resolve.ts +import resolveUri from "@jridgewell/resolve-uri"; + +// src/strip-filename.ts +function stripFilename(path) { + if (!path) return ""; + const index = path.lastIndexOf("/"); + return path.slice(0, index + 1); +} + +// src/resolve.ts +function resolver(mapUrl, sourceRoot) { + const from = stripFilename(mapUrl); + const prefix = sourceRoot ? sourceRoot + "/" : ""; + return (source) => resolveUri(prefix + (source || ""), from); +} + +// src/sourcemap-segment.ts +var COLUMN = 0; +var SOURCES_INDEX = 1; +var SOURCE_LINE = 2; +var SOURCE_COLUMN = 3; +var NAMES_INDEX = 4; +var REV_GENERATED_LINE = 1; +var REV_GENERATED_COLUMN = 2; + +// src/sort.ts +function maybeSort(mappings, owned) { + const unsortedIndex = nextUnsortedSegmentLine(mappings, 0); + if (unsortedIndex === mappings.length) return mappings; + if (!owned) mappings = mappings.slice(); + for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) { + mappings[i] = sortSegments(mappings[i], owned); + } + return mappings; +} +function nextUnsortedSegmentLine(mappings, start) { + for (let i = start; i < mappings.length; i++) { + if (!isSorted(mappings[i])) return i; + } + return mappings.length; +} +function isSorted(line) { + for (let j = 1; j < line.length; j++) { + if (line[j][COLUMN] < line[j - 1][COLUMN]) { + return false; + } + } + return true; +} +function sortSegments(line, owned) { + if (!owned) line = line.slice(); + return line.sort(sortComparator); +} +function sortComparator(a, b) { + return a[COLUMN] - b[COLUMN]; +} + +// src/by-source.ts +function buildBySources(decoded, memos) { + const sources = memos.map(() => []); + for (let i = 0; i < decoded.length; i++) { + const line = decoded[i]; + for (let j = 0; j < line.length; j++) { + const seg = line[j]; + if (seg.length === 1) continue; + const sourceIndex2 = seg[SOURCES_INDEX]; + const sourceLine = seg[SOURCE_LINE]; + const sourceColumn = seg[SOURCE_COLUMN]; + const source = sources[sourceIndex2]; + const segs = source[sourceLine] || (source[sourceLine] = []); + segs.push([sourceColumn, i, seg[COLUMN]]); + } + } + for (let i = 0; i < sources.length; i++) { + const source = sources[i]; + for (let j = 0; j < source.length; j++) { + const line = source[j]; + if (line) line.sort(sortComparator); + } + } + return sources; +} + +// src/binary-search.ts +var found = false; +function binarySearch(haystack, needle, low, high) { + while (low <= high) { + const mid = low + (high - low >> 1); + const cmp = haystack[mid][COLUMN] - needle; + if (cmp === 0) { + found = true; + return mid; + } + if (cmp < 0) { + low = mid + 1; + } else { + high = mid - 1; + } + } + found = false; + return low - 1; +} +function upperBound(haystack, needle, index) { + for (let i = index + 1; i < haystack.length; index = i++) { + if (haystack[i][COLUMN] !== needle) break; + } + return index; +} +function lowerBound(haystack, needle, index) { + for (let i = index - 1; i >= 0; index = i--) { + if (haystack[i][COLUMN] !== needle) break; + } + return index; +} +function memoizedState() { + return { + lastKey: -1, + lastNeedle: -1, + lastIndex: -1 + }; +} +function memoizedBinarySearch(haystack, needle, state, key) { + const { lastKey, lastNeedle, lastIndex } = state; + let low = 0; + let high = haystack.length - 1; + if (key === lastKey) { + if (needle === lastNeedle) { + found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle; + return lastIndex; + } + if (needle >= lastNeedle) { + low = lastIndex === -1 ? 0 : lastIndex; + } else { + high = lastIndex; + } + } + state.lastKey = key; + state.lastNeedle = needle; + return state.lastIndex = binarySearch(haystack, needle, low, high); +} + +// src/types.ts +function parse(map) { + return typeof map === "string" ? JSON.parse(map) : map; +} + +// src/flatten-map.ts +var FlattenMap = function(map, mapUrl) { + const parsed = parse(map); + if (!("sections" in parsed)) { + return new TraceMap(parsed, mapUrl); + } + const mappings = []; + const sources = []; + const sourcesContent = []; + const names = []; + const ignoreList = []; + recurse( + parsed, + mapUrl, + mappings, + sources, + sourcesContent, + names, + ignoreList, + 0, + 0, + Infinity, + Infinity + ); + const joined = { + version: 3, + file: parsed.file, + names, + sources, + sourcesContent, + mappings, + ignoreList + }; + return presortedDecodedMap(joined); +}; +function recurse(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) { + const { sections } = input; + for (let i = 0; i < sections.length; i++) { + const { map, offset } = sections[i]; + let sl = stopLine; + let sc = stopColumn; + if (i + 1 < sections.length) { + const nextOffset = sections[i + 1].offset; + sl = Math.min(stopLine, lineOffset + nextOffset.line); + if (sl === stopLine) { + sc = Math.min(stopColumn, columnOffset + nextOffset.column); + } else if (sl < stopLine) { + sc = columnOffset + nextOffset.column; + } + } + addSection( + map, + mapUrl, + mappings, + sources, + sourcesContent, + names, + ignoreList, + lineOffset + offset.line, + columnOffset + offset.column, + sl, + sc + ); + } +} +function addSection(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) { + const parsed = parse(input); + if ("sections" in parsed) return recurse(...arguments); + const map = new TraceMap(parsed, mapUrl); + const sourcesOffset = sources.length; + const namesOffset = names.length; + const decoded = decodedMappings(map); + const { resolvedSources, sourcesContent: contents, ignoreList: ignores } = map; + append(sources, resolvedSources); + append(names, map.names); + if (contents) append(sourcesContent, contents); + else for (let i = 0; i < resolvedSources.length; i++) sourcesContent.push(null); + if (ignores) for (let i = 0; i < ignores.length; i++) ignoreList.push(ignores[i] + sourcesOffset); + for (let i = 0; i < decoded.length; i++) { + const lineI = lineOffset + i; + if (lineI > stopLine) return; + const out = getLine(mappings, lineI); + const cOffset = i === 0 ? columnOffset : 0; + const line = decoded[i]; + for (let j = 0; j < line.length; j++) { + const seg = line[j]; + const column = cOffset + seg[COLUMN]; + if (lineI === stopLine && column >= stopColumn) return; + if (seg.length === 1) { + out.push([column]); + continue; + } + const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX]; + const sourceLine = seg[SOURCE_LINE]; + const sourceColumn = seg[SOURCE_COLUMN]; + out.push( + seg.length === 4 ? [column, sourcesIndex, sourceLine, sourceColumn] : [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]] + ); + } + } +} +function append(arr, other) { + for (let i = 0; i < other.length; i++) arr.push(other[i]); +} +function getLine(arr, index) { + for (let i = arr.length; i <= index; i++) arr[i] = []; + return arr[index]; +} + +// src/trace-mapping.ts +var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)"; +var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)"; +var LEAST_UPPER_BOUND = -1; +var GREATEST_LOWER_BOUND = 1; +var TraceMap = class { + constructor(map, mapUrl) { + const isString = typeof map === "string"; + if (!isString && map._decodedMemo) return map; + const parsed = parse(map); + const { version, file, names, sourceRoot, sources, sourcesContent } = parsed; + this.version = version; + this.file = file; + this.names = names || []; + this.sourceRoot = sourceRoot; + this.sources = sources; + this.sourcesContent = sourcesContent; + this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0; + const resolve = resolver(mapUrl, sourceRoot); + this.resolvedSources = sources.map(resolve); + const { mappings } = parsed; + if (typeof mappings === "string") { + this._encoded = mappings; + this._decoded = void 0; + } else if (Array.isArray(mappings)) { + this._encoded = void 0; + this._decoded = maybeSort(mappings, isString); + } else if (parsed.sections) { + throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`); + } else { + throw new Error(`invalid source map: ${JSON.stringify(parsed)}`); + } + this._decodedMemo = memoizedState(); + this._bySources = void 0; + this._bySourceMemos = void 0; + } +}; +function cast(map) { + return map; +} +function encodedMappings(map) { + var _a, _b; + return (_b = (_a = cast(map))._encoded) != null ? _b : _a._encoded = encode(cast(map)._decoded); +} +function decodedMappings(map) { + var _a; + return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded)); +} +function traceSegment(map, line, column) { + const decoded = decodedMappings(map); + if (line >= decoded.length) return null; + const segments = decoded[line]; + const index = traceSegmentInternal( + segments, + cast(map)._decodedMemo, + line, + column, + GREATEST_LOWER_BOUND + ); + return index === -1 ? null : segments[index]; +} +function originalPositionFor(map, needle) { + let { line, column, bias } = needle; + line--; + if (line < 0) throw new Error(LINE_GTR_ZERO); + if (column < 0) throw new Error(COL_GTR_EQ_ZERO); + const decoded = decodedMappings(map); + if (line >= decoded.length) return OMapping(null, null, null, null); + const segments = decoded[line]; + const index = traceSegmentInternal( + segments, + cast(map)._decodedMemo, + line, + column, + bias || GREATEST_LOWER_BOUND + ); + if (index === -1) return OMapping(null, null, null, null); + const segment = segments[index]; + if (segment.length === 1) return OMapping(null, null, null, null); + const { names, resolvedSources } = map; + return OMapping( + resolvedSources[segment[SOURCES_INDEX]], + segment[SOURCE_LINE] + 1, + segment[SOURCE_COLUMN], + segment.length === 5 ? names[segment[NAMES_INDEX]] : null + ); +} +function generatedPositionFor(map, needle) { + const { source, line, column, bias } = needle; + return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false); +} +function allGeneratedPositionsFor(map, needle) { + const { source, line, column, bias } = needle; + return generatedPosition(map, source, line, column, bias || LEAST_UPPER_BOUND, true); +} +function eachMapping(map, cb) { + const decoded = decodedMappings(map); + const { names, resolvedSources } = map; + for (let i = 0; i < decoded.length; i++) { + const line = decoded[i]; + for (let j = 0; j < line.length; j++) { + const seg = line[j]; + const generatedLine = i + 1; + const generatedColumn = seg[0]; + let source = null; + let originalLine = null; + let originalColumn = null; + let name = null; + if (seg.length !== 1) { + source = resolvedSources[seg[1]]; + originalLine = seg[2] + 1; + originalColumn = seg[3]; + } + if (seg.length === 5) name = names[seg[4]]; + cb({ + generatedLine, + generatedColumn, + source, + originalLine, + originalColumn, + name + }); + } + } +} +function sourceIndex(map, source) { + const { sources, resolvedSources } = map; + let index = sources.indexOf(source); + if (index === -1) index = resolvedSources.indexOf(source); + return index; +} +function sourceContentFor(map, source) { + const { sourcesContent } = map; + if (sourcesContent == null) return null; + const index = sourceIndex(map, source); + return index === -1 ? null : sourcesContent[index]; +} +function isIgnored(map, source) { + const { ignoreList } = map; + if (ignoreList == null) return false; + const index = sourceIndex(map, source); + return index === -1 ? false : ignoreList.includes(index); +} +function presortedDecodedMap(map, mapUrl) { + const tracer = new TraceMap(clone(map, []), mapUrl); + cast(tracer)._decoded = map.mappings; + return tracer; +} +function decodedMap(map) { + return clone(map, decodedMappings(map)); +} +function encodedMap(map) { + return clone(map, encodedMappings(map)); +} +function clone(map, mappings) { + return { + version: map.version, + file: map.file, + names: map.names, + sourceRoot: map.sourceRoot, + sources: map.sources, + sourcesContent: map.sourcesContent, + mappings, + ignoreList: map.ignoreList || map.x_google_ignoreList + }; +} +function OMapping(source, line, column, name) { + return { source, line, column, name }; +} +function GMapping(line, column) { + return { line, column }; +} +function traceSegmentInternal(segments, memo, line, column, bias) { + let index = memoizedBinarySearch(segments, column, memo, line); + if (found) { + index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index); + } else if (bias === LEAST_UPPER_BOUND) index++; + if (index === -1 || index === segments.length) return -1; + return index; +} +function sliceGeneratedPositions(segments, memo, line, column, bias) { + let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND); + if (!found && bias === LEAST_UPPER_BOUND) min++; + if (min === -1 || min === segments.length) return []; + const matchedColumn = found ? column : segments[min][COLUMN]; + if (!found) min = lowerBound(segments, matchedColumn, min); + const max = upperBound(segments, matchedColumn, min); + const result = []; + for (; min <= max; min++) { + const segment = segments[min]; + result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN])); + } + return result; +} +function generatedPosition(map, source, line, column, bias, all) { + var _a, _b; + line--; + if (line < 0) throw new Error(LINE_GTR_ZERO); + if (column < 0) throw new Error(COL_GTR_EQ_ZERO); + const { sources, resolvedSources } = map; + let sourceIndex2 = sources.indexOf(source); + if (sourceIndex2 === -1) sourceIndex2 = resolvedSources.indexOf(source); + if (sourceIndex2 === -1) return all ? [] : GMapping(null, null); + const bySourceMemos = (_a = cast(map))._bySourceMemos || (_a._bySourceMemos = sources.map(memoizedState)); + const generated = (_b = cast(map))._bySources || (_b._bySources = buildBySources(decodedMappings(map), bySourceMemos)); + const segments = generated[sourceIndex2][line]; + if (segments == null) return all ? [] : GMapping(null, null); + const memo = bySourceMemos[sourceIndex2]; + if (all) return sliceGeneratedPositions(segments, memo, line, column, bias); + const index = traceSegmentInternal(segments, memo, line, column, bias); + if (index === -1) return GMapping(null, null); + const segment = segments[index]; + return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]); +} +export { + FlattenMap as AnyMap, + FlattenMap, + GREATEST_LOWER_BOUND, + LEAST_UPPER_BOUND, + TraceMap, + allGeneratedPositionsFor, + decodedMap, + decodedMappings, + eachMapping, + encodedMap, + encodedMappings, + generatedPositionFor, + isIgnored, + originalPositionFor, + presortedDecodedMap, + sourceContentFor, + traceSegment +}; +//# sourceMappingURL=trace-mapping.mjs.map diff --git a/scripts/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs.map b/scripts/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs.map new file mode 100644 index 0000000000000000000000000000000000000000..a78958143be1bbc8f203e6efe48e41663e9ce534 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs.map @@ -0,0 +1,6 @@ +{ + "version": 3, + "sources": ["../src/trace-mapping.ts", "../src/resolve.ts", "../src/strip-filename.ts", "../src/sourcemap-segment.ts", "../src/sort.ts", "../src/by-source.ts", "../src/binary-search.ts", "../src/types.ts", "../src/flatten-map.ts"], + "mappings": ";AAAA,SAAS,QAAQ,cAAc;;;ACA/B,OAAO,gBAAgB;;;ACGR,SAAR,cAA+B,MAAyC;AAC7E,MAAI,CAAC,KAAM,QAAO;AAClB,QAAM,QAAQ,KAAK,YAAY,GAAG;AAClC,SAAO,KAAK,MAAM,GAAG,QAAQ,CAAC;AAChC;;;ADHe,SAAR,SACL,QACA,YACS;AACT,QAAM,OAAO,cAAc,MAAM;AAIjC,QAAM,SAAS,aAAa,aAAa,MAAM;AAE/C,SAAO,CAAC,WAAW,WAAW,UAAU,UAAU,KAAK,IAAI;AAC7D;;;AEAO,IAAM,SAAS;AACf,IAAM,gBAAgB;AACtB,IAAM,cAAc;AACpB,IAAM,gBAAgB;AACtB,IAAM,cAAc;AAEpB,IAAM,qBAAqB;AAC3B,IAAM,uBAAuB;;;AClBrB,SAAR,UACL,UACA,OACsB;AACtB,QAAM,gBAAgB,wBAAwB,UAAU,CAAC;AACzD,MAAI,kBAAkB,SAAS,OAAQ,QAAO;AAI9C,MAAI,CAAC,MAAO,YAAW,SAAS,MAAM;AAEtC,WAAS,IAAI,eAAe,IAAI,SAAS,QAAQ,IAAI,wBAAwB,UAAU,IAAI,CAAC,GAAG;AAC7F,aAAS,CAAC,IAAI,aAAa,SAAS,CAAC,GAAG,KAAK;AAAA,EAC/C;AACA,SAAO;AACT;AAEA,SAAS,wBAAwB,UAAgC,OAAuB;AACtF,WAAS,IAAI,OAAO,IAAI,SAAS,QAAQ,KAAK;AAC5C,QAAI,CAAC,SAAS,SAAS,CAAC,CAAC,EAAG,QAAO;AAAA,EACrC;AACA,SAAO,SAAS;AAClB;AAEA,SAAS,SAAS,MAAmC;AACnD,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,QAAI,KAAK,CAAC,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC,EAAE,MAAM,GAAG;AACzC,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;AAEA,SAAS,aAAa,MAA0B,OAAoC;AAClF,MAAI,CAAC,MAAO,QAAO,KAAK,MAAM;AAC9B,SAAO,KAAK,KAAK,cAAc;AACjC;AAEO,SAAS,eAA4D,GAAM,GAAc;AAC9F,SAAO,EAAE,MAAM,IAAI,EAAE,MAAM;AAC7B;;;ACnCe,SAAR,eACL,SACA,OACU;AACV,QAAM,UAAoB,MAAM,IAAI,MAAM,CAAC,CAAC;AAE5C,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,UAAM,OAAO,QAAQ,CAAC;AACtB,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,YAAM,MAAM,KAAK,CAAC;AAClB,UAAI,IAAI,WAAW,EAAG;AAEtB,YAAMA,eAAc,IAAI,aAAa;AACrC,YAAM,aAAa,IAAI,WAAW;AAClC,YAAM,eAAe,IAAI,aAAa;AAEtC,YAAM,SAAS,QAAQA,YAAW;AAClC,YAAM,OAAQ,4CAAuB,CAAC;AACtC,WAAK,KAAK,CAAC,cAAc,GAAG,IAAI,MAAM,CAAC,CAAC;AAAA,IAC1C;AAAA,EACF;AAEA,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,UAAM,SAAS,QAAQ,CAAC;AACxB,aAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,YAAM,OAAO,OAAO,CAAC;AACrB,UAAI,KAAM,MAAK,KAAK,cAAc;AAAA,IACpC;AAAA,EACF;AAEA,SAAO;AACT;;;AC/BO,IAAI,QAAQ;AAkBZ,SAAS,aACd,UACA,QACA,KACA,MACQ;AACR,SAAO,OAAO,MAAM;AAClB,UAAM,MAAM,OAAQ,OAAO,OAAQ;AACnC,UAAM,MAAM,SAAS,GAAG,EAAE,MAAM,IAAI;AAEpC,QAAI,QAAQ,GAAG;AACb,cAAQ;AACR,aAAO;AAAA,IACT;AAEA,QAAI,MAAM,GAAG;AACX,YAAM,MAAM;AAAA,IACd,OAAO;AACL,aAAO,MAAM;AAAA,IACf;AAAA,EACF;AAEA,UAAQ;AACR,SAAO,MAAM;AACf;AAEO,SAAS,WACd,UACA,QACA,OACQ;AACR,WAAS,IAAI,QAAQ,GAAG,IAAI,SAAS,QAAQ,QAAQ,KAAK;AACxD,QAAI,SAAS,CAAC,EAAE,MAAM,MAAM,OAAQ;AAAA,EACtC;AACA,SAAO;AACT;AAEO,SAAS,WACd,UACA,QACA,OACQ;AACR,WAAS,IAAI,QAAQ,GAAG,KAAK,GAAG,QAAQ,KAAK;AAC3C,QAAI,SAAS,CAAC,EAAE,MAAM,MAAM,OAAQ;AAAA,EACtC;AACA,SAAO;AACT;AAEO,SAAS,gBAA2B;AACzC,SAAO;AAAA,IACL,SAAS;AAAA,IACT,YAAY;AAAA,IACZ,WAAW;AAAA,EACb;AACF;AAMO,SAAS,qBACd,UACA,QACA,OACA,KACQ;AACR,QAAM,EAAE,SAAS,YAAY,UAAU,IAAI;AAE3C,MAAI,MAAM;AACV,MAAI,OAAO,SAAS,SAAS;AAC7B,MAAI,QAAQ,SAAS;AACnB,QAAI,WAAW,YAAY;AACzB,cAAQ,cAAc,MAAM,SAAS,SAAS,EAAE,MAAM,MAAM;AAC5D,aAAO;AAAA,IACT;AAEA,QAAI,UAAU,YAAY;AAExB,YAAM,cAAc,KAAK,IAAI;AAAA,IAC/B,OAAO;AACL,aAAO;AAAA,IACT;AAAA,EACF;AACA,QAAM,UAAU;AAChB,QAAM,aAAa;AAEnB,SAAQ,MAAM,YAAY,aAAa,UAAU,QAAQ,KAAK,IAAI;AACpE;;;ACHO,SAAS,MAAS,KAA4B;AACnD,SAAO,OAAO,QAAQ,WAAW,KAAK,MAAM,GAAG,IAAK;AACtD;;;ACvFO,IAAM,aAAyB,SAAU,KAAK,QAAQ;AAC3D,QAAM,SAAS,MAAM,GAA8B;AAEnD,MAAI,EAAE,cAAc,SAAS;AAC3B,WAAO,IAAI,SAAS,QAA2D,MAAM;AAAA,EACvF;AAEA,QAAM,WAAiC,CAAC;AACxC,QAAM,UAAoB,CAAC;AAC3B,QAAM,iBAAoC,CAAC;AAC3C,QAAM,QAAkB,CAAC;AACzB,QAAM,aAAuB,CAAC;AAE9B;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAEA,QAAM,SAA2B;AAAA,IAC/B,SAAS;AAAA,IACT,MAAM,OAAO;AAAA,IACb;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAEA,SAAO,oBAAoB,MAAM;AACnC;AAEA,SAAS,QACP,OACA,QACA,UACA,SACA,gBACA,OACA,YACA,YACA,cACA,UACA,YACA;AACA,QAAM,EAAE,SAAS,IAAI;AACrB,WAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;AACxC,UAAM,EAAE,KAAK,OAAO,IAAI,SAAS,CAAC;AAElC,QAAI,KAAK;AACT,QAAI,KAAK;AACT,QAAI,IAAI,IAAI,SAAS,QAAQ;AAC3B,YAAM,aAAa,SAAS,IAAI,CAAC,EAAE;AACnC,WAAK,KAAK,IAAI,UAAU,aAAa,WAAW,IAAI;AAEpD,UAAI,OAAO,UAAU;AACnB,aAAK,KAAK,IAAI,YAAY,eAAe,WAAW,MAAM;AAAA,MAC5D,WAAW,KAAK,UAAU;AACxB,aAAK,eAAe,WAAW;AAAA,MACjC;AAAA,IACF;AAEA;AAAA,MACE;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,aAAa,OAAO;AAAA,MACpB,eAAe,OAAO;AAAA,MACtB;AAAA,MACA;AAAA,IACF;AAAA,EACF;AACF;AAEA,SAAS,WACP,OACA,QACA,UACA,SACA,gBACA,OACA,YACA,YACA,cACA,UACA,YACA;AACA,QAAM,SAAS,MAAM,KAAK;AAC1B,MAAI,cAAc,OAAQ,QAAO,QAAQ,GAAI,SAAmD;AAEhG,QAAM,MAAM,IAAI,SAAS,QAAQ,MAAM;AACvC,QAAM,gBAAgB,QAAQ;AAC9B,QAAM,cAAc,MAAM;AAC1B,QAAM,UAAU,gBAAgB,GAAG;AACnC,QAAM,EAAE,iBAAiB,gBAAgB,UAAU,YAAY,QAAQ,IAAI;AAE3E,SAAO,SAAS,eAAe;AAC/B,SAAO,OAAO,IAAI,KAAK;AAEvB,MAAI,SAAU,QAAO,gBAAgB,QAAQ;AAAA,MACxC,UAAS,IAAI,GAAG,IAAI,gBAAgB,QAAQ,IAAK,gBAAe,KAAK,IAAI;AAE9E,MAAI,QAAS,UAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,IAAK,YAAW,KAAK,QAAQ,CAAC,IAAI,aAAa;AAEhG,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,UAAM,QAAQ,aAAa;AAM3B,QAAI,QAAQ,SAAU;AAItB,UAAM,MAAM,QAAQ,UAAU,KAAK;AAGnC,UAAM,UAAU,MAAM,IAAI,eAAe;AAEzC,UAAM,OAAO,QAAQ,CAAC;AACtB,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,YAAM,MAAM,KAAK,CAAC;AAClB,YAAM,SAAS,UAAU,IAAI,MAAM;AAInC,UAAI,UAAU,YAAY,UAAU,WAAY;AAEhD,UAAI,IAAI,WAAW,GAAG;AACpB,YAAI,KAAK,CAAC,MAAM,CAAC;AACjB;AAAA,MACF;AAEA,YAAM,eAAe,gBAAgB,IAAI,aAAa;AACtD,YAAM,aAAa,IAAI,WAAW;AAClC,YAAM,eAAe,IAAI,aAAa;AACtC,UAAI;AAAA,QACF,IAAI,WAAW,IACX,CAAC,QAAQ,cAAc,YAAY,YAAY,IAC/C,CAAC,QAAQ,cAAc,YAAY,cAAc,cAAc,IAAI,WAAW,CAAC;AAAA,MACrF;AAAA,IACF;AAAA,EACF;AACF;AAEA,SAAS,OAAU,KAAU,OAAY;AACvC,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,IAAK,KAAI,KAAK,MAAM,CAAC,CAAC;AAC1D;AAEA,SAAS,QAAW,KAAY,OAAoB;AAClD,WAAS,IAAI,IAAI,QAAQ,KAAK,OAAO,IAAK,KAAI,CAAC,IAAI,CAAC;AACpD,SAAO,IAAI,KAAK;AAClB;;;ARhHA,IAAM,gBAAgB;AACtB,IAAM,kBAAkB;AAEjB,IAAM,oBAAoB;AAC1B,IAAM,uBAAuB;AAI7B,IAAM,WAAN,MAAoC;AAAA,EAkBzC,YAAY,KAAyB,QAAwB;AAC3D,UAAM,WAAW,OAAO,QAAQ;AAChC,QAAI,CAAC,YAAa,IAAyC,aAAc,QAAO;AAEhF,UAAM,SAAS,MAAM,GAAwC;AAE7D,UAAM,EAAE,SAAS,MAAM,OAAO,YAAY,SAAS,eAAe,IAAI;AACtE,SAAK,UAAU;AACf,SAAK,OAAO;AACZ,SAAK,QAAQ,SAAS,CAAC;AACvB,SAAK,aAAa;AAClB,SAAK,UAAU;AACf,SAAK,iBAAiB;AACtB,SAAK,aAAa,OAAO,cAAe,OAAkB,uBAAuB;AAEjF,UAAM,UAAU,SAAS,QAAQ,UAAU;AAC3C,SAAK,kBAAkB,QAAQ,IAAI,OAAO;AAE1C,UAAM,EAAE,SAAS,IAAI;AACrB,QAAI,OAAO,aAAa,UAAU;AAChC,WAAK,WAAW;AAChB,WAAK,WAAW;AAAA,IAClB,WAAW,MAAM,QAAQ,QAAQ,GAAG;AAClC,WAAK,WAAW;AAChB,WAAK,WAAW,UAAU,UAAU,QAAQ;AAAA,IAC9C,WAAY,OAAyC,UAAU;AAC7D,YAAM,IAAI,MAAM,4EAA4E;AAAA,IAC9F,OAAO;AACL,YAAM,IAAI,MAAM,uBAAuB,KAAK,UAAU,MAAM,CAAC,EAAE;AAAA,IACjE;AAEA,SAAK,eAAe,cAAc;AAClC,SAAK,aAAa;AAClB,SAAK,iBAAiB;AAAA,EACxB;AACF;AAMA,SAAS,KAAK,KAAyB;AACrC,SAAO;AACT;AAKO,SAAS,gBAAgB,KAA6C;AAzJ7E;AA0JE,UAAQ,gBAAK,GAAG,GAAE,aAAV,eAAU,WAAa,OAAO,KAAK,GAAG,EAAE,QAAS;AAC3D;AAKO,SAAS,gBAAgB,KAAuD;AAhKvF;AAiKE,UAAQ,UAAK,GAAG,GAAE,aAAV,GAAU,WAAa,OAAO,KAAK,GAAG,EAAE,QAAS;AAC3D;AAMO,SAAS,aACd,KACA,MACA,QACmC;AACnC,QAAM,UAAU,gBAAgB,GAAG;AAInC,MAAI,QAAQ,QAAQ,OAAQ,QAAO;AAEnC,QAAM,WAAW,QAAQ,IAAI;AAC7B,QAAM,QAAQ;AAAA,IACZ;AAAA,IACA,KAAK,GAAG,EAAE;AAAA,IACV;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAEA,SAAO,UAAU,KAAK,OAAO,SAAS,KAAK;AAC7C;AAOO,SAAS,oBACd,KACA,QAC0C;AAC1C,MAAI,EAAE,MAAM,QAAQ,KAAK,IAAI;AAC7B;AACA,MAAI,OAAO,EAAG,OAAM,IAAI,MAAM,aAAa;AAC3C,MAAI,SAAS,EAAG,OAAM,IAAI,MAAM,eAAe;AAE/C,QAAM,UAAU,gBAAgB,GAAG;AAInC,MAAI,QAAQ,QAAQ,OAAQ,QAAO,SAAS,MAAM,MAAM,MAAM,IAAI;AAElE,QAAM,WAAW,QAAQ,IAAI;AAC7B,QAAM,QAAQ;AAAA,IACZ;AAAA,IACA,KAAK,GAAG,EAAE;AAAA,IACV;AAAA,IACA;AAAA,IACA,QAAQ;AAAA,EACV;AAEA,MAAI,UAAU,GAAI,QAAO,SAAS,MAAM,MAAM,MAAM,IAAI;AAExD,QAAM,UAAU,SAAS,KAAK;AAC9B,MAAI,QAAQ,WAAW,EAAG,QAAO,SAAS,MAAM,MAAM,MAAM,IAAI;AAEhE,QAAM,EAAE,OAAO,gBAAgB,IAAI;AACnC,SAAO;AAAA,IACL,gBAAgB,QAAQ,aAAa,CAAC;AAAA,IACtC,QAAQ,WAAW,IAAI;AAAA,IACvB,QAAQ,aAAa;AAAA,IACrB,QAAQ,WAAW,IAAI,MAAM,QAAQ,WAAW,CAAC,IAAI;AAAA,EACvD;AACF;AAKO,SAAS,qBACd,KACA,QAC4C;AAC5C,QAAM,EAAE,QAAQ,MAAM,QAAQ,KAAK,IAAI;AACvC,SAAO,kBAAkB,KAAK,QAAQ,MAAM,QAAQ,QAAQ,sBAAsB,KAAK;AACzF;AAKO,SAAS,yBAAyB,KAAe,QAA0C;AAChG,QAAM,EAAE,QAAQ,MAAM,QAAQ,KAAK,IAAI;AAEvC,SAAO,kBAAkB,KAAK,QAAQ,MAAM,QAAQ,QAAQ,mBAAmB,IAAI;AACrF;AAKO,SAAS,YAAY,KAAe,IAA0C;AACnF,QAAM,UAAU,gBAAgB,GAAG;AACnC,QAAM,EAAE,OAAO,gBAAgB,IAAI;AAEnC,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,UAAM,OAAO,QAAQ,CAAC;AACtB,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,YAAM,MAAM,KAAK,CAAC;AAElB,YAAM,gBAAgB,IAAI;AAC1B,YAAM,kBAAkB,IAAI,CAAC;AAC7B,UAAI,SAAS;AACb,UAAI,eAAe;AACnB,UAAI,iBAAiB;AACrB,UAAI,OAAO;AACX,UAAI,IAAI,WAAW,GAAG;AACpB,iBAAS,gBAAgB,IAAI,CAAC,CAAC;AAC/B,uBAAe,IAAI,CAAC,IAAI;AACxB,yBAAiB,IAAI,CAAC;AAAA,MACxB;AACA,UAAI,IAAI,WAAW,EAAG,QAAO,MAAM,IAAI,CAAC,CAAC;AAEzC,SAAG;AAAA,QACD;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAgB;AAAA,IAClB;AAAA,EACF;AACF;AAEA,SAAS,YAAY,KAAe,QAAwB;AAC1D,QAAM,EAAE,SAAS,gBAAgB,IAAI;AACrC,MAAI,QAAQ,QAAQ,QAAQ,MAAM;AAClC,MAAI,UAAU,GAAI,SAAQ,gBAAgB,QAAQ,MAAM;AACxD,SAAO;AACT;AAKO,SAAS,iBAAiB,KAAe,QAA+B;AAC7E,QAAM,EAAE,eAAe,IAAI;AAC3B,MAAI,kBAAkB,KAAM,QAAO;AACnC,QAAM,QAAQ,YAAY,KAAK,MAAM;AACrC,SAAO,UAAU,KAAK,OAAO,eAAe,KAAK;AACnD;AAKO,SAAS,UAAU,KAAe,QAAyB;AAChE,QAAM,EAAE,WAAW,IAAI;AACvB,MAAI,cAAc,KAAM,QAAO;AAC/B,QAAM,QAAQ,YAAY,KAAK,MAAM;AACrC,SAAO,UAAU,KAAK,QAAQ,WAAW,SAAS,KAAK;AACzD;AAMO,SAAS,oBAAoB,KAAuB,QAA2B;AACpF,QAAM,SAAS,IAAI,SAAS,MAAM,KAAK,CAAC,CAAC,GAAG,MAAM;AAClD,OAAK,MAAM,EAAE,WAAW,IAAI;AAC5B,SAAO;AACT;AAMO,SAAS,WACd,KACkF;AAClF,SAAO,MAAM,KAAK,gBAAgB,GAAG,CAAC;AACxC;AAMO,SAAS,WAAW,KAAiC;AAC1D,SAAO,MAAM,KAAK,gBAAgB,GAAG,CAAC;AACxC;AAEA,SAAS,MACP,KACA,UACwD;AACxD,SAAO;AAAA,IACL,SAAS,IAAI;AAAA,IACb,MAAM,IAAI;AAAA,IACV,OAAO,IAAI;AAAA,IACX,YAAY,IAAI;AAAA,IAChB,SAAS,IAAI;AAAA,IACb,gBAAgB,IAAI;AAAA,IACpB;AAAA,IACA,YAAY,IAAI,cAAe,IAAe;AAAA,EAChD;AACF;AASA,SAAS,SACP,QACA,MACA,QACA,MAC0C;AAC1C,SAAO,EAAE,QAAQ,MAAM,QAAQ,KAAK;AACtC;AAIA,SAAS,SACP,MACA,QAC4C;AAC5C,SAAO,EAAE,MAAM,OAAO;AACxB;AAgBA,SAAS,qBACP,UACA,MACA,MACA,QACA,MACQ;AACR,MAAI,QAAQ,qBAAqB,UAAU,QAAQ,MAAM,IAAI;AAC7D,MAAI,OAAS;AACX,aAAS,SAAS,oBAAoB,aAAa,YAAY,UAAU,QAAQ,KAAK;AAAA,EACxF,WAAW,SAAS,kBAAmB;AAEvC,MAAI,UAAU,MAAM,UAAU,SAAS,OAAQ,QAAO;AACtD,SAAO;AACT;AAEA,SAAS,wBACP,UACA,MACA,MACA,QACA,MACoB;AACpB,MAAI,MAAM,qBAAqB,UAAU,MAAM,MAAM,QAAQ,oBAAoB;AAQjF,MAAI,CAAC,SAAW,SAAS,kBAAmB;AAE5C,MAAI,QAAQ,MAAM,QAAQ,SAAS,OAAQ,QAAO,CAAC;AAKnD,QAAM,gBAAgB,QAAU,SAAS,SAAS,GAAG,EAAE,MAAM;AAG7D,MAAI,CAAC,MAAS,OAAM,WAAW,UAAU,eAAe,GAAG;AAC3D,QAAM,MAAM,WAAW,UAAU,eAAe,GAAG;AAEnD,QAAM,SAAS,CAAC;AAChB,SAAO,OAAO,KAAK,OAAO;AACxB,UAAM,UAAU,SAAS,GAAG;AAC5B,WAAO,KAAK,SAAS,QAAQ,kBAAkB,IAAI,GAAG,QAAQ,oBAAoB,CAAC,CAAC;AAAA,EACtF;AACA,SAAO;AACT;AAkBA,SAAS,kBACP,KACA,QACA,MACA,QACA,MACA,KACiE;AA5dnE;AA6dE;AACA,MAAI,OAAO,EAAG,OAAM,IAAI,MAAM,aAAa;AAC3C,MAAI,SAAS,EAAG,OAAM,IAAI,MAAM,eAAe;AAE/C,QAAM,EAAE,SAAS,gBAAgB,IAAI;AACrC,MAAIC,eAAc,QAAQ,QAAQ,MAAM;AACxC,MAAIA,iBAAgB,GAAI,CAAAA,eAAc,gBAAgB,QAAQ,MAAM;AACpE,MAAIA,iBAAgB,GAAI,QAAO,MAAM,CAAC,IAAI,SAAS,MAAM,IAAI;AAE7D,QAAM,iBAAiB,UAAK,GAAG,GAAE,mBAAV,GAAU,iBAAmB,QAAQ,IAAI,aAAa;AAC7E,QAAM,aAAa,UAAK,GAAG,GAAE,eAAV,GAAU,aAAe,eAAe,gBAAgB,GAAG,GAAG,aAAa;AAE9F,QAAM,WAAW,UAAUA,YAAW,EAAE,IAAI;AAC5C,MAAI,YAAY,KAAM,QAAO,MAAM,CAAC,IAAI,SAAS,MAAM,IAAI;AAE3D,QAAM,OAAO,cAAcA,YAAW;AAEtC,MAAI,IAAK,QAAO,wBAAwB,UAAU,MAAM,MAAM,QAAQ,IAAI;AAE1E,QAAM,QAAQ,qBAAqB,UAAU,MAAM,MAAM,QAAQ,IAAI;AACrE,MAAI,UAAU,GAAI,QAAO,SAAS,MAAM,IAAI;AAE5C,QAAM,UAAU,SAAS,KAAK;AAC9B,SAAO,SAAS,QAAQ,kBAAkB,IAAI,GAAG,QAAQ,oBAAoB,CAAC;AAChF;", + "names": ["sourceIndex", "sourceIndex"] +} diff --git a/scripts/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js b/scripts/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js new file mode 100644 index 0000000000000000000000000000000000000000..0387ae38c67017175d2441333ff49781ca5094fa --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js @@ -0,0 +1,559 @@ +(function (global, factory) { + if (typeof exports === 'object' && typeof module !== 'undefined') { + factory(module, require('@jridgewell/resolve-uri'), require('@jridgewell/sourcemap-codec')); + module.exports = def(module); + } else if (typeof define === 'function' && define.amd) { + define(['module', '@jridgewell/resolve-uri', '@jridgewell/sourcemap-codec'], function(mod) { + factory.apply(this, arguments); + mod.exports = def(mod); + }); + } else { + const mod = { exports: {} }; + factory(mod, global.resolveURI, global.sourcemapCodec); + global = typeof globalThis !== 'undefined' ? globalThis : global || self; + global.traceMapping = def(mod); + } + function def(m) { return 'default' in m.exports ? m.exports.default : m.exports; } +})(this, (function (module, require_resolveURI, require_sourcemapCodec) { +"use strict"; +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// umd:@jridgewell/sourcemap-codec +var require_sourcemap_codec = __commonJS({ + "umd:@jridgewell/sourcemap-codec"(exports, module2) { + module2.exports = require_sourcemapCodec; + } +}); + +// umd:@jridgewell/resolve-uri +var require_resolve_uri = __commonJS({ + "umd:@jridgewell/resolve-uri"(exports, module2) { + module2.exports = require_resolveURI; + } +}); + +// src/trace-mapping.ts +var trace_mapping_exports = {}; +__export(trace_mapping_exports, { + AnyMap: () => FlattenMap, + FlattenMap: () => FlattenMap, + GREATEST_LOWER_BOUND: () => GREATEST_LOWER_BOUND, + LEAST_UPPER_BOUND: () => LEAST_UPPER_BOUND, + TraceMap: () => TraceMap, + allGeneratedPositionsFor: () => allGeneratedPositionsFor, + decodedMap: () => decodedMap, + decodedMappings: () => decodedMappings, + eachMapping: () => eachMapping, + encodedMap: () => encodedMap, + encodedMappings: () => encodedMappings, + generatedPositionFor: () => generatedPositionFor, + isIgnored: () => isIgnored, + originalPositionFor: () => originalPositionFor, + presortedDecodedMap: () => presortedDecodedMap, + sourceContentFor: () => sourceContentFor, + traceSegment: () => traceSegment +}); +module.exports = __toCommonJS(trace_mapping_exports); +var import_sourcemap_codec = __toESM(require_sourcemap_codec()); + +// src/resolve.ts +var import_resolve_uri = __toESM(require_resolve_uri()); + +// src/strip-filename.ts +function stripFilename(path) { + if (!path) return ""; + const index = path.lastIndexOf("/"); + return path.slice(0, index + 1); +} + +// src/resolve.ts +function resolver(mapUrl, sourceRoot) { + const from = stripFilename(mapUrl); + const prefix = sourceRoot ? sourceRoot + "/" : ""; + return (source) => (0, import_resolve_uri.default)(prefix + (source || ""), from); +} + +// src/sourcemap-segment.ts +var COLUMN = 0; +var SOURCES_INDEX = 1; +var SOURCE_LINE = 2; +var SOURCE_COLUMN = 3; +var NAMES_INDEX = 4; +var REV_GENERATED_LINE = 1; +var REV_GENERATED_COLUMN = 2; + +// src/sort.ts +function maybeSort(mappings, owned) { + const unsortedIndex = nextUnsortedSegmentLine(mappings, 0); + if (unsortedIndex === mappings.length) return mappings; + if (!owned) mappings = mappings.slice(); + for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) { + mappings[i] = sortSegments(mappings[i], owned); + } + return mappings; +} +function nextUnsortedSegmentLine(mappings, start) { + for (let i = start; i < mappings.length; i++) { + if (!isSorted(mappings[i])) return i; + } + return mappings.length; +} +function isSorted(line) { + for (let j = 1; j < line.length; j++) { + if (line[j][COLUMN] < line[j - 1][COLUMN]) { + return false; + } + } + return true; +} +function sortSegments(line, owned) { + if (!owned) line = line.slice(); + return line.sort(sortComparator); +} +function sortComparator(a, b) { + return a[COLUMN] - b[COLUMN]; +} + +// src/by-source.ts +function buildBySources(decoded, memos) { + const sources = memos.map(() => []); + for (let i = 0; i < decoded.length; i++) { + const line = decoded[i]; + for (let j = 0; j < line.length; j++) { + const seg = line[j]; + if (seg.length === 1) continue; + const sourceIndex2 = seg[SOURCES_INDEX]; + const sourceLine = seg[SOURCE_LINE]; + const sourceColumn = seg[SOURCE_COLUMN]; + const source = sources[sourceIndex2]; + const segs = source[sourceLine] || (source[sourceLine] = []); + segs.push([sourceColumn, i, seg[COLUMN]]); + } + } + for (let i = 0; i < sources.length; i++) { + const source = sources[i]; + for (let j = 0; j < source.length; j++) { + const line = source[j]; + if (line) line.sort(sortComparator); + } + } + return sources; +} + +// src/binary-search.ts +var found = false; +function binarySearch(haystack, needle, low, high) { + while (low <= high) { + const mid = low + (high - low >> 1); + const cmp = haystack[mid][COLUMN] - needle; + if (cmp === 0) { + found = true; + return mid; + } + if (cmp < 0) { + low = mid + 1; + } else { + high = mid - 1; + } + } + found = false; + return low - 1; +} +function upperBound(haystack, needle, index) { + for (let i = index + 1; i < haystack.length; index = i++) { + if (haystack[i][COLUMN] !== needle) break; + } + return index; +} +function lowerBound(haystack, needle, index) { + for (let i = index - 1; i >= 0; index = i--) { + if (haystack[i][COLUMN] !== needle) break; + } + return index; +} +function memoizedState() { + return { + lastKey: -1, + lastNeedle: -1, + lastIndex: -1 + }; +} +function memoizedBinarySearch(haystack, needle, state, key) { + const { lastKey, lastNeedle, lastIndex } = state; + let low = 0; + let high = haystack.length - 1; + if (key === lastKey) { + if (needle === lastNeedle) { + found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle; + return lastIndex; + } + if (needle >= lastNeedle) { + low = lastIndex === -1 ? 0 : lastIndex; + } else { + high = lastIndex; + } + } + state.lastKey = key; + state.lastNeedle = needle; + return state.lastIndex = binarySearch(haystack, needle, low, high); +} + +// src/types.ts +function parse(map) { + return typeof map === "string" ? JSON.parse(map) : map; +} + +// src/flatten-map.ts +var FlattenMap = function(map, mapUrl) { + const parsed = parse(map); + if (!("sections" in parsed)) { + return new TraceMap(parsed, mapUrl); + } + const mappings = []; + const sources = []; + const sourcesContent = []; + const names = []; + const ignoreList = []; + recurse( + parsed, + mapUrl, + mappings, + sources, + sourcesContent, + names, + ignoreList, + 0, + 0, + Infinity, + Infinity + ); + const joined = { + version: 3, + file: parsed.file, + names, + sources, + sourcesContent, + mappings, + ignoreList + }; + return presortedDecodedMap(joined); +}; +function recurse(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) { + const { sections } = input; + for (let i = 0; i < sections.length; i++) { + const { map, offset } = sections[i]; + let sl = stopLine; + let sc = stopColumn; + if (i + 1 < sections.length) { + const nextOffset = sections[i + 1].offset; + sl = Math.min(stopLine, lineOffset + nextOffset.line); + if (sl === stopLine) { + sc = Math.min(stopColumn, columnOffset + nextOffset.column); + } else if (sl < stopLine) { + sc = columnOffset + nextOffset.column; + } + } + addSection( + map, + mapUrl, + mappings, + sources, + sourcesContent, + names, + ignoreList, + lineOffset + offset.line, + columnOffset + offset.column, + sl, + sc + ); + } +} +function addSection(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) { + const parsed = parse(input); + if ("sections" in parsed) return recurse(...arguments); + const map = new TraceMap(parsed, mapUrl); + const sourcesOffset = sources.length; + const namesOffset = names.length; + const decoded = decodedMappings(map); + const { resolvedSources, sourcesContent: contents, ignoreList: ignores } = map; + append(sources, resolvedSources); + append(names, map.names); + if (contents) append(sourcesContent, contents); + else for (let i = 0; i < resolvedSources.length; i++) sourcesContent.push(null); + if (ignores) for (let i = 0; i < ignores.length; i++) ignoreList.push(ignores[i] + sourcesOffset); + for (let i = 0; i < decoded.length; i++) { + const lineI = lineOffset + i; + if (lineI > stopLine) return; + const out = getLine(mappings, lineI); + const cOffset = i === 0 ? columnOffset : 0; + const line = decoded[i]; + for (let j = 0; j < line.length; j++) { + const seg = line[j]; + const column = cOffset + seg[COLUMN]; + if (lineI === stopLine && column >= stopColumn) return; + if (seg.length === 1) { + out.push([column]); + continue; + } + const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX]; + const sourceLine = seg[SOURCE_LINE]; + const sourceColumn = seg[SOURCE_COLUMN]; + out.push( + seg.length === 4 ? [column, sourcesIndex, sourceLine, sourceColumn] : [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]] + ); + } + } +} +function append(arr, other) { + for (let i = 0; i < other.length; i++) arr.push(other[i]); +} +function getLine(arr, index) { + for (let i = arr.length; i <= index; i++) arr[i] = []; + return arr[index]; +} + +// src/trace-mapping.ts +var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)"; +var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)"; +var LEAST_UPPER_BOUND = -1; +var GREATEST_LOWER_BOUND = 1; +var TraceMap = class { + constructor(map, mapUrl) { + const isString = typeof map === "string"; + if (!isString && map._decodedMemo) return map; + const parsed = parse(map); + const { version, file, names, sourceRoot, sources, sourcesContent } = parsed; + this.version = version; + this.file = file; + this.names = names || []; + this.sourceRoot = sourceRoot; + this.sources = sources; + this.sourcesContent = sourcesContent; + this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0; + const resolve = resolver(mapUrl, sourceRoot); + this.resolvedSources = sources.map(resolve); + const { mappings } = parsed; + if (typeof mappings === "string") { + this._encoded = mappings; + this._decoded = void 0; + } else if (Array.isArray(mappings)) { + this._encoded = void 0; + this._decoded = maybeSort(mappings, isString); + } else if (parsed.sections) { + throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`); + } else { + throw new Error(`invalid source map: ${JSON.stringify(parsed)}`); + } + this._decodedMemo = memoizedState(); + this._bySources = void 0; + this._bySourceMemos = void 0; + } +}; +function cast(map) { + return map; +} +function encodedMappings(map) { + var _a, _b; + return (_b = (_a = cast(map))._encoded) != null ? _b : _a._encoded = (0, import_sourcemap_codec.encode)(cast(map)._decoded); +} +function decodedMappings(map) { + var _a; + return (_a = cast(map))._decoded || (_a._decoded = (0, import_sourcemap_codec.decode)(cast(map)._encoded)); +} +function traceSegment(map, line, column) { + const decoded = decodedMappings(map); + if (line >= decoded.length) return null; + const segments = decoded[line]; + const index = traceSegmentInternal( + segments, + cast(map)._decodedMemo, + line, + column, + GREATEST_LOWER_BOUND + ); + return index === -1 ? null : segments[index]; +} +function originalPositionFor(map, needle) { + let { line, column, bias } = needle; + line--; + if (line < 0) throw new Error(LINE_GTR_ZERO); + if (column < 0) throw new Error(COL_GTR_EQ_ZERO); + const decoded = decodedMappings(map); + if (line >= decoded.length) return OMapping(null, null, null, null); + const segments = decoded[line]; + const index = traceSegmentInternal( + segments, + cast(map)._decodedMemo, + line, + column, + bias || GREATEST_LOWER_BOUND + ); + if (index === -1) return OMapping(null, null, null, null); + const segment = segments[index]; + if (segment.length === 1) return OMapping(null, null, null, null); + const { names, resolvedSources } = map; + return OMapping( + resolvedSources[segment[SOURCES_INDEX]], + segment[SOURCE_LINE] + 1, + segment[SOURCE_COLUMN], + segment.length === 5 ? names[segment[NAMES_INDEX]] : null + ); +} +function generatedPositionFor(map, needle) { + const { source, line, column, bias } = needle; + return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false); +} +function allGeneratedPositionsFor(map, needle) { + const { source, line, column, bias } = needle; + return generatedPosition(map, source, line, column, bias || LEAST_UPPER_BOUND, true); +} +function eachMapping(map, cb) { + const decoded = decodedMappings(map); + const { names, resolvedSources } = map; + for (let i = 0; i < decoded.length; i++) { + const line = decoded[i]; + for (let j = 0; j < line.length; j++) { + const seg = line[j]; + const generatedLine = i + 1; + const generatedColumn = seg[0]; + let source = null; + let originalLine = null; + let originalColumn = null; + let name = null; + if (seg.length !== 1) { + source = resolvedSources[seg[1]]; + originalLine = seg[2] + 1; + originalColumn = seg[3]; + } + if (seg.length === 5) name = names[seg[4]]; + cb({ + generatedLine, + generatedColumn, + source, + originalLine, + originalColumn, + name + }); + } + } +} +function sourceIndex(map, source) { + const { sources, resolvedSources } = map; + let index = sources.indexOf(source); + if (index === -1) index = resolvedSources.indexOf(source); + return index; +} +function sourceContentFor(map, source) { + const { sourcesContent } = map; + if (sourcesContent == null) return null; + const index = sourceIndex(map, source); + return index === -1 ? null : sourcesContent[index]; +} +function isIgnored(map, source) { + const { ignoreList } = map; + if (ignoreList == null) return false; + const index = sourceIndex(map, source); + return index === -1 ? false : ignoreList.includes(index); +} +function presortedDecodedMap(map, mapUrl) { + const tracer = new TraceMap(clone(map, []), mapUrl); + cast(tracer)._decoded = map.mappings; + return tracer; +} +function decodedMap(map) { + return clone(map, decodedMappings(map)); +} +function encodedMap(map) { + return clone(map, encodedMappings(map)); +} +function clone(map, mappings) { + return { + version: map.version, + file: map.file, + names: map.names, + sourceRoot: map.sourceRoot, + sources: map.sources, + sourcesContent: map.sourcesContent, + mappings, + ignoreList: map.ignoreList || map.x_google_ignoreList + }; +} +function OMapping(source, line, column, name) { + return { source, line, column, name }; +} +function GMapping(line, column) { + return { line, column }; +} +function traceSegmentInternal(segments, memo, line, column, bias) { + let index = memoizedBinarySearch(segments, column, memo, line); + if (found) { + index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index); + } else if (bias === LEAST_UPPER_BOUND) index++; + if (index === -1 || index === segments.length) return -1; + return index; +} +function sliceGeneratedPositions(segments, memo, line, column, bias) { + let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND); + if (!found && bias === LEAST_UPPER_BOUND) min++; + if (min === -1 || min === segments.length) return []; + const matchedColumn = found ? column : segments[min][COLUMN]; + if (!found) min = lowerBound(segments, matchedColumn, min); + const max = upperBound(segments, matchedColumn, min); + const result = []; + for (; min <= max; min++) { + const segment = segments[min]; + result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN])); + } + return result; +} +function generatedPosition(map, source, line, column, bias, all) { + var _a, _b; + line--; + if (line < 0) throw new Error(LINE_GTR_ZERO); + if (column < 0) throw new Error(COL_GTR_EQ_ZERO); + const { sources, resolvedSources } = map; + let sourceIndex2 = sources.indexOf(source); + if (sourceIndex2 === -1) sourceIndex2 = resolvedSources.indexOf(source); + if (sourceIndex2 === -1) return all ? [] : GMapping(null, null); + const bySourceMemos = (_a = cast(map))._bySourceMemos || (_a._bySourceMemos = sources.map(memoizedState)); + const generated = (_b = cast(map))._bySources || (_b._bySources = buildBySources(decodedMappings(map), bySourceMemos)); + const segments = generated[sourceIndex2][line]; + if (segments == null) return all ? [] : GMapping(null, null); + const memo = bySourceMemos[sourceIndex2]; + if (all) return sliceGeneratedPositions(segments, memo, line, column, bias); + const index = traceSegmentInternal(segments, memo, line, column, bias); + if (index === -1) return GMapping(null, null); + const segment = segments[index]; + return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]); +} +})); +//# sourceMappingURL=trace-mapping.umd.js.map diff --git a/scripts/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js.map b/scripts/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js.map new file mode 100644 index 0000000000000000000000000000000000000000..68b0c775d6a8c2d06f07fc5d1d5dd7d86c564b8b --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js.map @@ -0,0 +1,6 @@ +{ + "version": 3, + "sources": ["umd:@jridgewell/sourcemap-codec", "umd:@jridgewell/resolve-uri", "../src/trace-mapping.ts", "../src/resolve.ts", "../src/strip-filename.ts", "../src/sourcemap-segment.ts", "../src/sort.ts", "../src/by-source.ts", "../src/binary-search.ts", "../src/types.ts", "../src/flatten-map.ts"], + "mappings": "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", + "names": ["module", "module", "resolveUri", "sourceIndex", "sourceIndex"] +} diff --git a/scripts/node_modules/@jridgewell/trace-mapping/package.json b/scripts/node_modules/@jridgewell/trace-mapping/package.json new file mode 100644 index 0000000000000000000000000000000000000000..9d3a1c08e5d4c0316371ed16f966c353ab34e790 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/package.json @@ -0,0 +1,67 @@ +{ + "name": "@jridgewell/trace-mapping", + "version": "0.3.31", + "description": "Trace the original position through a source map", + "keywords": [ + "source", + "map" + ], + "main": "dist/trace-mapping.umd.js", + "module": "dist/trace-mapping.mjs", + "types": "types/trace-mapping.d.cts", + "files": [ + "dist", + "src", + "types" + ], + "exports": { + ".": [ + { + "import": { + "types": "./types/trace-mapping.d.mts", + "default": "./dist/trace-mapping.mjs" + }, + "default": { + "types": "./types/trace-mapping.d.cts", + "default": "./dist/trace-mapping.umd.js" + } + }, + "./dist/trace-mapping.umd.js" + ], + "./package.json": "./package.json" + }, + "scripts": { + "benchmark": "run-s build:code benchmark:*", + "benchmark:install": "cd benchmark && npm install", + "benchmark:only": "node --expose-gc benchmark/index.mjs", + "build": "run-s -n build:code build:types", + "build:code": "node ../../esbuild.mjs trace-mapping.ts", + "build:types": "run-s build:types:force build:types:emit build:types:mts", + "build:types:force": "rimraf tsconfig.build.tsbuildinfo", + "build:types:emit": "tsc --project tsconfig.build.json", + "build:types:mts": "node ../../mts-types.mjs", + "clean": "run-s -n clean:code clean:types", + "clean:code": "tsc --build --clean tsconfig.build.json", + "clean:types": "rimraf dist types", + "test": "run-s -n test:types test:only test:format", + "test:format": "prettier --check '{src,test}/**/*.ts'", + "test:only": "mocha", + "test:types": "eslint '{src,test}/**/*.ts'", + "lint": "run-s -n lint:types lint:format", + "lint:format": "npm run test:format -- --write", + "lint:types": "npm run test:types -- --fix", + "prepublishOnly": "npm run-s -n build test" + }, + "homepage": "https://github.com/jridgewell/sourcemaps/tree/main/packages/trace-mapping", + "repository": { + "type": "git", + "url": "git+https://github.com/jridgewell/sourcemaps.git", + "directory": "packages/trace-mapping" + }, + "author": "Justin Ridgewell ", + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } +} diff --git a/scripts/node_modules/@jridgewell/trace-mapping/src/binary-search.ts b/scripts/node_modules/@jridgewell/trace-mapping/src/binary-search.ts new file mode 100644 index 0000000000000000000000000000000000000000..c1144ad1cdcdf6dcdfbfe3fed3f4daeeb2b1bd8d --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/src/binary-search.ts @@ -0,0 +1,115 @@ +import type { SourceMapSegment, ReverseSegment } from './sourcemap-segment'; +import { COLUMN } from './sourcemap-segment'; + +export type MemoState = { + lastKey: number; + lastNeedle: number; + lastIndex: number; +}; + +export let found = false; + +/** + * A binary search implementation that returns the index if a match is found. + * If no match is found, then the left-index (the index associated with the item that comes just + * before the desired index) is returned. To maintain proper sort order, a splice would happen at + * the next index: + * + * ```js + * const array = [1, 3]; + * const needle = 2; + * const index = binarySearch(array, needle, (item, needle) => item - needle); + * + * assert.equal(index, 0); + * array.splice(index + 1, 0, needle); + * assert.deepEqual(array, [1, 2, 3]); + * ``` + */ +export function binarySearch( + haystack: SourceMapSegment[] | ReverseSegment[], + needle: number, + low: number, + high: number, +): number { + while (low <= high) { + const mid = low + ((high - low) >> 1); + const cmp = haystack[mid][COLUMN] - needle; + + if (cmp === 0) { + found = true; + return mid; + } + + if (cmp < 0) { + low = mid + 1; + } else { + high = mid - 1; + } + } + + found = false; + return low - 1; +} + +export function upperBound( + haystack: SourceMapSegment[] | ReverseSegment[], + needle: number, + index: number, +): number { + for (let i = index + 1; i < haystack.length; index = i++) { + if (haystack[i][COLUMN] !== needle) break; + } + return index; +} + +export function lowerBound( + haystack: SourceMapSegment[] | ReverseSegment[], + needle: number, + index: number, +): number { + for (let i = index - 1; i >= 0; index = i--) { + if (haystack[i][COLUMN] !== needle) break; + } + return index; +} + +export function memoizedState(): MemoState { + return { + lastKey: -1, + lastNeedle: -1, + lastIndex: -1, + }; +} + +/** + * This overly complicated beast is just to record the last tested line/column and the resulting + * index, allowing us to skip a few tests if mappings are monotonically increasing. + */ +export function memoizedBinarySearch( + haystack: SourceMapSegment[] | ReverseSegment[], + needle: number, + state: MemoState, + key: number, +): number { + const { lastKey, lastNeedle, lastIndex } = state; + + let low = 0; + let high = haystack.length - 1; + if (key === lastKey) { + if (needle === lastNeedle) { + found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle; + return lastIndex; + } + + if (needle >= lastNeedle) { + // lastIndex may be -1 if the previous needle was not found. + low = lastIndex === -1 ? 0 : lastIndex; + } else { + high = lastIndex; + } + } + state.lastKey = key; + state.lastNeedle = needle; + + return (state.lastIndex = binarySearch(haystack, needle, low, high)); +} diff --git a/scripts/node_modules/@jridgewell/trace-mapping/src/by-source.ts b/scripts/node_modules/@jridgewell/trace-mapping/src/by-source.ts new file mode 100644 index 0000000000000000000000000000000000000000..1da6af05cae200e2c4df1322a08910d0c5082e37 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/src/by-source.ts @@ -0,0 +1,41 @@ +import { COLUMN, SOURCES_INDEX, SOURCE_LINE, SOURCE_COLUMN } from './sourcemap-segment'; +import { sortComparator } from './sort'; + +import type { ReverseSegment, SourceMapSegment } from './sourcemap-segment'; + +export type Source = ReverseSegment[][]; + +// Rebuilds the original source files, with mappings that are ordered by source line/column instead +// of generated line/column. +export default function buildBySources( + decoded: readonly SourceMapSegment[][], + memos: unknown[], +): Source[] { + const sources: Source[] = memos.map(() => []); + + for (let i = 0; i < decoded.length; i++) { + const line = decoded[i]; + for (let j = 0; j < line.length; j++) { + const seg = line[j]; + if (seg.length === 1) continue; + + const sourceIndex = seg[SOURCES_INDEX]; + const sourceLine = seg[SOURCE_LINE]; + const sourceColumn = seg[SOURCE_COLUMN]; + + const source = sources[sourceIndex]; + const segs = (source[sourceLine] ||= []); + segs.push([sourceColumn, i, seg[COLUMN]]); + } + } + + for (let i = 0; i < sources.length; i++) { + const source = sources[i]; + for (let j = 0; j < source.length; j++) { + const line = source[j]; + if (line) line.sort(sortComparator); + } + } + + return sources; +} diff --git a/scripts/node_modules/@jridgewell/trace-mapping/src/flatten-map.ts b/scripts/node_modules/@jridgewell/trace-mapping/src/flatten-map.ts new file mode 100644 index 0000000000000000000000000000000000000000..61ac40caabeb70e1759bf67e0582d01240120713 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/src/flatten-map.ts @@ -0,0 +1,192 @@ +import { TraceMap, presortedDecodedMap, decodedMappings } from './trace-mapping'; +import { + COLUMN, + SOURCES_INDEX, + SOURCE_LINE, + SOURCE_COLUMN, + NAMES_INDEX, +} from './sourcemap-segment'; +import { parse } from './types'; + +import type { + DecodedSourceMap, + DecodedSourceMapXInput, + EncodedSourceMapXInput, + SectionedSourceMapXInput, + SectionedSourceMapInput, + SectionXInput, + Ro, +} from './types'; +import type { SourceMapSegment } from './sourcemap-segment'; + +type FlattenMap = { + new (map: Ro, mapUrl?: string | null): TraceMap; + (map: Ro, mapUrl?: string | null): TraceMap; +}; + +export const FlattenMap: FlattenMap = function (map, mapUrl) { + const parsed = parse(map as SectionedSourceMapInput); + + if (!('sections' in parsed)) { + return new TraceMap(parsed as DecodedSourceMapXInput | EncodedSourceMapXInput, mapUrl); + } + + const mappings: SourceMapSegment[][] = []; + const sources: string[] = []; + const sourcesContent: (string | null)[] = []; + const names: string[] = []; + const ignoreList: number[] = []; + + recurse( + parsed, + mapUrl, + mappings, + sources, + sourcesContent, + names, + ignoreList, + 0, + 0, + Infinity, + Infinity, + ); + + const joined: DecodedSourceMap = { + version: 3, + file: parsed.file, + names, + sources, + sourcesContent, + mappings, + ignoreList, + }; + + return presortedDecodedMap(joined); +} as FlattenMap; + +function recurse( + input: SectionedSourceMapXInput, + mapUrl: string | null | undefined, + mappings: SourceMapSegment[][], + sources: string[], + sourcesContent: (string | null)[], + names: string[], + ignoreList: number[], + lineOffset: number, + columnOffset: number, + stopLine: number, + stopColumn: number, +) { + const { sections } = input; + for (let i = 0; i < sections.length; i++) { + const { map, offset } = sections[i]; + + let sl = stopLine; + let sc = stopColumn; + if (i + 1 < sections.length) { + const nextOffset = sections[i + 1].offset; + sl = Math.min(stopLine, lineOffset + nextOffset.line); + + if (sl === stopLine) { + sc = Math.min(stopColumn, columnOffset + nextOffset.column); + } else if (sl < stopLine) { + sc = columnOffset + nextOffset.column; + } + } + + addSection( + map, + mapUrl, + mappings, + sources, + sourcesContent, + names, + ignoreList, + lineOffset + offset.line, + columnOffset + offset.column, + sl, + sc, + ); + } +} + +function addSection( + input: SectionXInput['map'], + mapUrl: string | null | undefined, + mappings: SourceMapSegment[][], + sources: string[], + sourcesContent: (string | null)[], + names: string[], + ignoreList: number[], + lineOffset: number, + columnOffset: number, + stopLine: number, + stopColumn: number, +) { + const parsed = parse(input); + if ('sections' in parsed) return recurse(...(arguments as unknown as Parameters)); + + const map = new TraceMap(parsed, mapUrl); + const sourcesOffset = sources.length; + const namesOffset = names.length; + const decoded = decodedMappings(map); + const { resolvedSources, sourcesContent: contents, ignoreList: ignores } = map; + + append(sources, resolvedSources); + append(names, map.names); + + if (contents) append(sourcesContent, contents); + else for (let i = 0; i < resolvedSources.length; i++) sourcesContent.push(null); + + if (ignores) for (let i = 0; i < ignores.length; i++) ignoreList.push(ignores[i] + sourcesOffset); + + for (let i = 0; i < decoded.length; i++) { + const lineI = lineOffset + i; + + // We can only add so many lines before we step into the range that the next section's map + // controls. When we get to the last line, then we'll start checking the segments to see if + // they've crossed into the column range. But it may not have any columns that overstep, so we + // still need to check that we don't overstep lines, too. + if (lineI > stopLine) return; + + // The out line may already exist in mappings (if we're continuing the line started by a + // previous section). Or, we may have jumped ahead several lines to start this section. + const out = getLine(mappings, lineI); + // On the 0th loop, the section's column offset shifts us forward. On all other lines (since the + // map can be multiple lines), it doesn't. + const cOffset = i === 0 ? columnOffset : 0; + + const line = decoded[i]; + for (let j = 0; j < line.length; j++) { + const seg = line[j]; + const column = cOffset + seg[COLUMN]; + + // If this segment steps into the column range that the next section's map controls, we need + // to stop early. + if (lineI === stopLine && column >= stopColumn) return; + + if (seg.length === 1) { + out.push([column]); + continue; + } + + const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX]; + const sourceLine = seg[SOURCE_LINE]; + const sourceColumn = seg[SOURCE_COLUMN]; + out.push( + seg.length === 4 + ? [column, sourcesIndex, sourceLine, sourceColumn] + : [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]], + ); + } + } +} + +function append(arr: T[], other: T[]) { + for (let i = 0; i < other.length; i++) arr.push(other[i]); +} + +function getLine(arr: T[][], index: number): T[] { + for (let i = arr.length; i <= index; i++) arr[i] = []; + return arr[index]; +} diff --git a/scripts/node_modules/@jridgewell/trace-mapping/src/resolve.ts b/scripts/node_modules/@jridgewell/trace-mapping/src/resolve.ts new file mode 100644 index 0000000000000000000000000000000000000000..30bfa3b226f8990dc650a372d0fa8300b9521a56 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/src/resolve.ts @@ -0,0 +1,16 @@ +import resolveUri from '@jridgewell/resolve-uri'; +import stripFilename from './strip-filename'; + +type Resolve = (source: string | null) => string; +export default function resolver( + mapUrl: string | null | undefined, + sourceRoot: string | undefined, +): Resolve { + const from = stripFilename(mapUrl); + // The sourceRoot is always treated as a directory, if it's not empty. + // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327 + // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401 + const prefix = sourceRoot ? sourceRoot + '/' : ''; + + return (source) => resolveUri(prefix + (source || ''), from); +} diff --git a/scripts/node_modules/@jridgewell/trace-mapping/src/sort.ts b/scripts/node_modules/@jridgewell/trace-mapping/src/sort.ts new file mode 100644 index 0000000000000000000000000000000000000000..5d016cb78cfca482b736ec06d25f334d2ab849ff --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/src/sort.ts @@ -0,0 +1,45 @@ +import { COLUMN } from './sourcemap-segment'; + +import type { ReverseSegment, SourceMapSegment } from './sourcemap-segment'; + +export default function maybeSort( + mappings: SourceMapSegment[][], + owned: boolean, +): SourceMapSegment[][] { + const unsortedIndex = nextUnsortedSegmentLine(mappings, 0); + if (unsortedIndex === mappings.length) return mappings; + + // If we own the array (meaning we parsed it from JSON), then we're free to directly mutate it. If + // not, we do not want to modify the consumer's input array. + if (!owned) mappings = mappings.slice(); + + for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) { + mappings[i] = sortSegments(mappings[i], owned); + } + return mappings; +} + +function nextUnsortedSegmentLine(mappings: SourceMapSegment[][], start: number): number { + for (let i = start; i < mappings.length; i++) { + if (!isSorted(mappings[i])) return i; + } + return mappings.length; +} + +function isSorted(line: SourceMapSegment[]): boolean { + for (let j = 1; j < line.length; j++) { + if (line[j][COLUMN] < line[j - 1][COLUMN]) { + return false; + } + } + return true; +} + +function sortSegments(line: SourceMapSegment[], owned: boolean): SourceMapSegment[] { + if (!owned) line = line.slice(); + return line.sort(sortComparator); +} + +export function sortComparator(a: T, b: T): number { + return a[COLUMN] - b[COLUMN]; +} diff --git a/scripts/node_modules/@jridgewell/trace-mapping/src/sourcemap-segment.ts b/scripts/node_modules/@jridgewell/trace-mapping/src/sourcemap-segment.ts new file mode 100644 index 0000000000000000000000000000000000000000..94f1b6ab0d675ecdf00cd0416bcb228cba1ba604 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/src/sourcemap-segment.ts @@ -0,0 +1,23 @@ +type GeneratedColumn = number; +type SourcesIndex = number; +type SourceLine = number; +type SourceColumn = number; +type NamesIndex = number; + +type GeneratedLine = number; + +export type SourceMapSegment = + | [GeneratedColumn] + | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] + | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex]; + +export type ReverseSegment = [SourceColumn, GeneratedLine, GeneratedColumn]; + +export const COLUMN = 0; +export const SOURCES_INDEX = 1; +export const SOURCE_LINE = 2; +export const SOURCE_COLUMN = 3; +export const NAMES_INDEX = 4; + +export const REV_GENERATED_LINE = 1; +export const REV_GENERATED_COLUMN = 2; diff --git a/scripts/node_modules/@jridgewell/trace-mapping/src/strip-filename.ts b/scripts/node_modules/@jridgewell/trace-mapping/src/strip-filename.ts new file mode 100644 index 0000000000000000000000000000000000000000..2c889800e196e1728b8f4e6c50dd686b5f874376 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/src/strip-filename.ts @@ -0,0 +1,8 @@ +/** + * Removes everything after the last "/", but leaves the slash. + */ +export default function stripFilename(path: string | undefined | null): string { + if (!path) return ''; + const index = path.lastIndexOf('/'); + return path.slice(0, index + 1); +} diff --git a/scripts/node_modules/@jridgewell/trace-mapping/src/trace-mapping.ts b/scripts/node_modules/@jridgewell/trace-mapping/src/trace-mapping.ts new file mode 100644 index 0000000000000000000000000000000000000000..0b793d5bb342398516285157e8ed5bc09aef306d --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/src/trace-mapping.ts @@ -0,0 +1,502 @@ +import { encode, decode } from '@jridgewell/sourcemap-codec'; + +import resolver from './resolve'; +import maybeSort from './sort'; +import buildBySources from './by-source'; +import { + memoizedState, + memoizedBinarySearch, + upperBound, + lowerBound, + found as bsFound, +} from './binary-search'; +import { + COLUMN, + SOURCES_INDEX, + SOURCE_LINE, + SOURCE_COLUMN, + NAMES_INDEX, + REV_GENERATED_LINE, + REV_GENERATED_COLUMN, +} from './sourcemap-segment'; +import { parse } from './types'; + +import type { SourceMapSegment, ReverseSegment } from './sourcemap-segment'; +import type { + SourceMapV3, + DecodedSourceMap, + EncodedSourceMap, + InvalidOriginalMapping, + OriginalMapping, + InvalidGeneratedMapping, + GeneratedMapping, + SourceMapInput, + Needle, + SourceNeedle, + SourceMap, + EachMapping, + Bias, + XInput, + SectionedSourceMap, + Ro, +} from './types'; +import type { Source } from './by-source'; +import type { MemoState } from './binary-search'; + +export type { SourceMapSegment } from './sourcemap-segment'; +export type { + SourceMap, + DecodedSourceMap, + EncodedSourceMap, + Section, + SectionedSourceMap, + SourceMapV3, + Bias, + EachMapping, + GeneratedMapping, + InvalidGeneratedMapping, + InvalidOriginalMapping, + Needle, + OriginalMapping, + OriginalMapping as Mapping, + SectionedSourceMapInput, + SourceMapInput, + SourceNeedle, + XInput, + EncodedSourceMapXInput, + DecodedSourceMapXInput, + SectionedSourceMapXInput, + SectionXInput, +} from './types'; + +interface PublicMap { + _encoded: TraceMap['_encoded']; + _decoded: TraceMap['_decoded']; + _decodedMemo: TraceMap['_decodedMemo']; + _bySources: TraceMap['_bySources']; + _bySourceMemos: TraceMap['_bySourceMemos']; +} + +const LINE_GTR_ZERO = '`line` must be greater than 0 (lines start at line 1)'; +const COL_GTR_EQ_ZERO = '`column` must be greater than or equal to 0 (columns start at column 0)'; + +export const LEAST_UPPER_BOUND = -1; +export const GREATEST_LOWER_BOUND = 1; + +export { FlattenMap, FlattenMap as AnyMap } from './flatten-map'; + +export class TraceMap implements SourceMap { + declare version: SourceMapV3['version']; + declare file: SourceMapV3['file']; + declare names: SourceMapV3['names']; + declare sourceRoot: SourceMapV3['sourceRoot']; + declare sources: SourceMapV3['sources']; + declare sourcesContent: SourceMapV3['sourcesContent']; + declare ignoreList: SourceMapV3['ignoreList']; + + declare resolvedSources: string[]; + declare private _encoded: string | undefined; + + declare private _decoded: SourceMapSegment[][] | undefined; + declare private _decodedMemo: MemoState; + + declare private _bySources: Source[] | undefined; + declare private _bySourceMemos: MemoState[] | undefined; + + constructor(map: Ro, mapUrl?: string | null) { + const isString = typeof map === 'string'; + if (!isString && (map as unknown as { _decodedMemo: any })._decodedMemo) return map as TraceMap; + + const parsed = parse(map as Exclude); + + const { version, file, names, sourceRoot, sources, sourcesContent } = parsed; + this.version = version; + this.file = file; + this.names = names || []; + this.sourceRoot = sourceRoot; + this.sources = sources; + this.sourcesContent = sourcesContent; + this.ignoreList = parsed.ignoreList || (parsed as XInput).x_google_ignoreList || undefined; + + const resolve = resolver(mapUrl, sourceRoot); + this.resolvedSources = sources.map(resolve); + + const { mappings } = parsed; + if (typeof mappings === 'string') { + this._encoded = mappings; + this._decoded = undefined; + } else if (Array.isArray(mappings)) { + this._encoded = undefined; + this._decoded = maybeSort(mappings, isString); + } else if ((parsed as unknown as SectionedSourceMap).sections) { + throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`); + } else { + throw new Error(`invalid source map: ${JSON.stringify(parsed)}`); + } + + this._decodedMemo = memoizedState(); + this._bySources = undefined; + this._bySourceMemos = undefined; + } +} + +/** + * Typescript doesn't allow friend access to private fields, so this just casts the map into a type + * with public access modifiers. + */ +function cast(map: unknown): PublicMap { + return map as any; +} + +/** + * Returns the encoded (VLQ string) form of the SourceMap's mappings field. + */ +export function encodedMappings(map: TraceMap): EncodedSourceMap['mappings'] { + return (cast(map)._encoded ??= encode(cast(map)._decoded!)); +} + +/** + * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field. + */ +export function decodedMappings(map: TraceMap): Readonly { + return (cast(map)._decoded ||= decode(cast(map)._encoded!)); +} + +/** + * A low-level API to find the segment associated with a generated line/column (think, from a + * stack trace). Line and column here are 0-based, unlike `originalPositionFor`. + */ +export function traceSegment( + map: TraceMap, + line: number, + column: number, +): Readonly | null { + const decoded = decodedMappings(map); + + // It's common for parent source maps to have pointers to lines that have no + // mapping (like a "//# sourceMappingURL=") at the end of the child file. + if (line >= decoded.length) return null; + + const segments = decoded[line]; + const index = traceSegmentInternal( + segments, + cast(map)._decodedMemo, + line, + column, + GREATEST_LOWER_BOUND, + ); + + return index === -1 ? null : segments[index]; +} + +/** + * A higher-level API to find the source/line/column associated with a generated line/column + * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in + * `source-map` library. + */ +export function originalPositionFor( + map: TraceMap, + needle: Needle, +): OriginalMapping | InvalidOriginalMapping { + let { line, column, bias } = needle; + line--; + if (line < 0) throw new Error(LINE_GTR_ZERO); + if (column < 0) throw new Error(COL_GTR_EQ_ZERO); + + const decoded = decodedMappings(map); + + // It's common for parent source maps to have pointers to lines that have no + // mapping (like a "//# sourceMappingURL=") at the end of the child file. + if (line >= decoded.length) return OMapping(null, null, null, null); + + const segments = decoded[line]; + const index = traceSegmentInternal( + segments, + cast(map)._decodedMemo, + line, + column, + bias || GREATEST_LOWER_BOUND, + ); + + if (index === -1) return OMapping(null, null, null, null); + + const segment = segments[index]; + if (segment.length === 1) return OMapping(null, null, null, null); + + const { names, resolvedSources } = map; + return OMapping( + resolvedSources[segment[SOURCES_INDEX]], + segment[SOURCE_LINE] + 1, + segment[SOURCE_COLUMN], + segment.length === 5 ? names[segment[NAMES_INDEX]] : null, + ); +} + +/** + * Finds the generated line/column position of the provided source/line/column source position. + */ +export function generatedPositionFor( + map: TraceMap, + needle: SourceNeedle, +): GeneratedMapping | InvalidGeneratedMapping { + const { source, line, column, bias } = needle; + return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false); +} + +/** + * Finds all generated line/column positions of the provided source/line/column source position. + */ +export function allGeneratedPositionsFor(map: TraceMap, needle: SourceNeedle): GeneratedMapping[] { + const { source, line, column, bias } = needle; + // SourceMapConsumer uses LEAST_UPPER_BOUND for some reason, so we follow suit. + return generatedPosition(map, source, line, column, bias || LEAST_UPPER_BOUND, true); +} + +/** + * Iterates each mapping in generated position order. + */ +export function eachMapping(map: TraceMap, cb: (mapping: EachMapping) => void): void { + const decoded = decodedMappings(map); + const { names, resolvedSources } = map; + + for (let i = 0; i < decoded.length; i++) { + const line = decoded[i]; + for (let j = 0; j < line.length; j++) { + const seg = line[j]; + + const generatedLine = i + 1; + const generatedColumn = seg[0]; + let source = null; + let originalLine = null; + let originalColumn = null; + let name = null; + if (seg.length !== 1) { + source = resolvedSources[seg[1]]; + originalLine = seg[2] + 1; + originalColumn = seg[3]; + } + if (seg.length === 5) name = names[seg[4]]; + + cb({ + generatedLine, + generatedColumn, + source, + originalLine, + originalColumn, + name, + } as EachMapping); + } + } +} + +function sourceIndex(map: TraceMap, source: string): number { + const { sources, resolvedSources } = map; + let index = sources.indexOf(source); + if (index === -1) index = resolvedSources.indexOf(source); + return index; +} + +/** + * Retrieves the source content for a particular source, if its found. Returns null if not. + */ +export function sourceContentFor(map: TraceMap, source: string): string | null { + const { sourcesContent } = map; + if (sourcesContent == null) return null; + const index = sourceIndex(map, source); + return index === -1 ? null : sourcesContent[index]; +} + +/** + * Determines if the source is marked to ignore by the source map. + */ +export function isIgnored(map: TraceMap, source: string): boolean { + const { ignoreList } = map; + if (ignoreList == null) return false; + const index = sourceIndex(map, source); + return index === -1 ? false : ignoreList.includes(index); +} + +/** + * A helper that skips sorting of the input map's mappings array, which can be expensive for larger + * maps. + */ +export function presortedDecodedMap(map: DecodedSourceMap, mapUrl?: string): TraceMap { + const tracer = new TraceMap(clone(map, []), mapUrl); + cast(tracer)._decoded = map.mappings; + return tracer; +} + +/** + * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects + * a sourcemap, or to JSON.stringify. + */ +export function decodedMap( + map: TraceMap, +): Omit & { mappings: readonly SourceMapSegment[][] } { + return clone(map, decodedMappings(map)); +} + +/** + * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects + * a sourcemap, or to JSON.stringify. + */ +export function encodedMap(map: TraceMap): EncodedSourceMap { + return clone(map, encodedMappings(map)); +} + +function clone( + map: TraceMap | DecodedSourceMap, + mappings: T, +): T extends string ? EncodedSourceMap : DecodedSourceMap { + return { + version: map.version, + file: map.file, + names: map.names, + sourceRoot: map.sourceRoot, + sources: map.sources, + sourcesContent: map.sourcesContent, + mappings, + ignoreList: map.ignoreList || (map as XInput).x_google_ignoreList, + } as any; +} + +function OMapping(source: null, line: null, column: null, name: null): InvalidOriginalMapping; +function OMapping( + source: string, + line: number, + column: number, + name: string | null, +): OriginalMapping; +function OMapping( + source: string | null, + line: number | null, + column: number | null, + name: string | null, +): OriginalMapping | InvalidOriginalMapping { + return { source, line, column, name } as any; +} + +function GMapping(line: null, column: null): InvalidGeneratedMapping; +function GMapping(line: number, column: number): GeneratedMapping; +function GMapping( + line: number | null, + column: number | null, +): GeneratedMapping | InvalidGeneratedMapping { + return { line, column } as any; +} + +function traceSegmentInternal( + segments: SourceMapSegment[], + memo: MemoState, + line: number, + column: number, + bias: Bias, +): number; +function traceSegmentInternal( + segments: ReverseSegment[], + memo: MemoState, + line: number, + column: number, + bias: Bias, +): number; +function traceSegmentInternal( + segments: SourceMapSegment[] | ReverseSegment[], + memo: MemoState, + line: number, + column: number, + bias: Bias, +): number { + let index = memoizedBinarySearch(segments, column, memo, line); + if (bsFound) { + index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index); + } else if (bias === LEAST_UPPER_BOUND) index++; + + if (index === -1 || index === segments.length) return -1; + return index; +} + +function sliceGeneratedPositions( + segments: ReverseSegment[], + memo: MemoState, + line: number, + column: number, + bias: Bias, +): GeneratedMapping[] { + let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND); + + // We ignored the bias when tracing the segment so that we're guarnateed to find the first (in + // insertion order) segment that matched. Even if we did respect the bias when tracing, we would + // still need to call `lowerBound()` to find the first segment, which is slower than just looking + // for the GREATEST_LOWER_BOUND to begin with. The only difference that matters for us is when the + // binary search didn't match, in which case GREATEST_LOWER_BOUND just needs to increment to + // match LEAST_UPPER_BOUND. + if (!bsFound && bias === LEAST_UPPER_BOUND) min++; + + if (min === -1 || min === segments.length) return []; + + // We may have found the segment that started at an earlier column. If this is the case, then we + // need to slice all generated segments that match _that_ column, because all such segments span + // to our desired column. + const matchedColumn = bsFound ? column : segments[min][COLUMN]; + + // The binary search is not guaranteed to find the lower bound when a match wasn't found. + if (!bsFound) min = lowerBound(segments, matchedColumn, min); + const max = upperBound(segments, matchedColumn, min); + + const result = []; + for (; min <= max; min++) { + const segment = segments[min]; + result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN])); + } + return result; +} + +function generatedPosition( + map: TraceMap, + source: string, + line: number, + column: number, + bias: Bias, + all: false, +): GeneratedMapping | InvalidGeneratedMapping; +function generatedPosition( + map: TraceMap, + source: string, + line: number, + column: number, + bias: Bias, + all: true, +): GeneratedMapping[]; +function generatedPosition( + map: TraceMap, + source: string, + line: number, + column: number, + bias: Bias, + all: boolean, +): GeneratedMapping | InvalidGeneratedMapping | GeneratedMapping[] { + line--; + if (line < 0) throw new Error(LINE_GTR_ZERO); + if (column < 0) throw new Error(COL_GTR_EQ_ZERO); + + const { sources, resolvedSources } = map; + let sourceIndex = sources.indexOf(source); + if (sourceIndex === -1) sourceIndex = resolvedSources.indexOf(source); + if (sourceIndex === -1) return all ? [] : GMapping(null, null); + + const bySourceMemos = (cast(map)._bySourceMemos ||= sources.map(memoizedState)); + const generated = (cast(map)._bySources ||= buildBySources(decodedMappings(map), bySourceMemos)); + + const segments = generated[sourceIndex][line]; + if (segments == null) return all ? [] : GMapping(null, null); + + const memo = bySourceMemos[sourceIndex]; + + if (all) return sliceGeneratedPositions(segments, memo, line, column, bias); + + const index = traceSegmentInternal(segments, memo, line, column, bias); + if (index === -1) return GMapping(null, null); + + const segment = segments[index]; + return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]); +} diff --git a/scripts/node_modules/@jridgewell/trace-mapping/src/types.ts b/scripts/node_modules/@jridgewell/trace-mapping/src/types.ts new file mode 100644 index 0000000000000000000000000000000000000000..730a61fb5ca1e2a389b6bff8dc773828a0372421 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/src/types.ts @@ -0,0 +1,114 @@ +import type { SourceMapSegment } from './sourcemap-segment'; +import type { GREATEST_LOWER_BOUND, LEAST_UPPER_BOUND, TraceMap } from './trace-mapping'; + +export interface SourceMapV3 { + file?: string | null; + names: string[]; + sourceRoot?: string; + sources: (string | null)[]; + sourcesContent?: (string | null)[]; + version: 3; + ignoreList?: number[]; +} + +export interface EncodedSourceMap extends SourceMapV3 { + mappings: string; +} + +export interface DecodedSourceMap extends SourceMapV3 { + mappings: SourceMapSegment[][]; +} + +export interface Section { + offset: { line: number; column: number }; + map: EncodedSourceMap | DecodedSourceMap | SectionedSourceMap; +} + +export interface SectionedSourceMap { + file?: string | null; + sections: Section[]; + version: 3; +} + +export type OriginalMapping = { + source: string | null; + line: number; + column: number; + name: string | null; +}; + +export type InvalidOriginalMapping = { + source: null; + line: null; + column: null; + name: null; +}; + +export type GeneratedMapping = { + line: number; + column: number; +}; +export type InvalidGeneratedMapping = { + line: null; + column: null; +}; + +export type Bias = typeof GREATEST_LOWER_BOUND | typeof LEAST_UPPER_BOUND; + +export type XInput = { x_google_ignoreList?: SourceMapV3['ignoreList'] }; +export type EncodedSourceMapXInput = EncodedSourceMap & XInput; +export type DecodedSourceMapXInput = DecodedSourceMap & XInput; +export type SectionedSourceMapXInput = Omit & { + sections: SectionXInput[]; +}; +export type SectionXInput = Omit & { + map: SectionedSourceMapInput; +}; + +export type SourceMapInput = string | EncodedSourceMapXInput | DecodedSourceMapXInput | TraceMap; +export type SectionedSourceMapInput = SourceMapInput | SectionedSourceMapXInput; + +export type Needle = { line: number; column: number; bias?: Bias }; +export type SourceNeedle = { source: string; line: number; column: number; bias?: Bias }; + +export type EachMapping = + | { + generatedLine: number; + generatedColumn: number; + source: null; + originalLine: null; + originalColumn: null; + name: null; + } + | { + generatedLine: number; + generatedColumn: number; + source: string | null; + originalLine: number; + originalColumn: number; + name: string | null; + }; + +export abstract class SourceMap { + declare version: SourceMapV3['version']; + declare file: SourceMapV3['file']; + declare names: SourceMapV3['names']; + declare sourceRoot: SourceMapV3['sourceRoot']; + declare sources: SourceMapV3['sources']; + declare sourcesContent: SourceMapV3['sourcesContent']; + declare resolvedSources: SourceMapV3['sources']; + declare ignoreList: SourceMapV3['ignoreList']; +} + +export type Ro = + T extends Array + ? V[] | Readonly | RoArray | Readonly> + : T extends object + ? T | Readonly | RoObject | Readonly> + : T; +type RoArray = Ro[]; +type RoObject = { [K in keyof T]: T[K] | Ro }; + +export function parse(map: T): Exclude { + return typeof map === 'string' ? JSON.parse(map) : (map as Exclude); +} diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/binary-search.d.cts b/scripts/node_modules/@jridgewell/trace-mapping/types/binary-search.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..b7bb85c913b38b846273813e77c3c9aecbcaa3cd --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/binary-search.d.cts @@ -0,0 +1,33 @@ +import type { SourceMapSegment, ReverseSegment } from './sourcemap-segment.cts'; +export type MemoState = { + lastKey: number; + lastNeedle: number; + lastIndex: number; +}; +export declare let found: boolean; +/** + * A binary search implementation that returns the index if a match is found. + * If no match is found, then the left-index (the index associated with the item that comes just + * before the desired index) is returned. To maintain proper sort order, a splice would happen at + * the next index: + * + * ```js + * const array = [1, 3]; + * const needle = 2; + * const index = binarySearch(array, needle, (item, needle) => item - needle); + * + * assert.equal(index, 0); + * array.splice(index + 1, 0, needle); + * assert.deepEqual(array, [1, 2, 3]); + * ``` + */ +export declare function binarySearch(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, low: number, high: number): number; +export declare function upperBound(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, index: number): number; +export declare function lowerBound(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, index: number): number; +export declare function memoizedState(): MemoState; +/** + * This overly complicated beast is just to record the last tested line/column and the resulting + * index, allowing us to skip a few tests if mappings are monotonically increasing. + */ +export declare function memoizedBinarySearch(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, state: MemoState, key: number): number; +//# sourceMappingURL=binary-search.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/binary-search.d.cts.map b/scripts/node_modules/@jridgewell/trace-mapping/types/binary-search.d.cts.map new file mode 100644 index 0000000000000000000000000000000000000000..648e84c1e7a5c587e300fe348389c500fa2af2c6 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/binary-search.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"binary-search.d.ts","sourceRoot":"","sources":["../src/binary-search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAG5E,MAAM,MAAM,SAAS,GAAG;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,eAAO,IAAI,KAAK,SAAQ,CAAC;AAEzB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,GACX,MAAM,CAmBR;AAED,wBAAgB,UAAU,CACxB,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,MAAM,CAKR;AAED,wBAAgB,UAAU,CACxB,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,MAAM,CAKR;AAED,wBAAgB,aAAa,IAAI,SAAS,CAMzC;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,MAAM,GACV,MAAM,CAsBR"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/binary-search.d.mts b/scripts/node_modules/@jridgewell/trace-mapping/types/binary-search.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..19e1e6b9eb4e26e90df2e4bc21d1e27ae149d132 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/binary-search.d.mts @@ -0,0 +1,33 @@ +import type { SourceMapSegment, ReverseSegment } from './sourcemap-segment.mts'; +export type MemoState = { + lastKey: number; + lastNeedle: number; + lastIndex: number; +}; +export declare let found: boolean; +/** + * A binary search implementation that returns the index if a match is found. + * If no match is found, then the left-index (the index associated with the item that comes just + * before the desired index) is returned. To maintain proper sort order, a splice would happen at + * the next index: + * + * ```js + * const array = [1, 3]; + * const needle = 2; + * const index = binarySearch(array, needle, (item, needle) => item - needle); + * + * assert.equal(index, 0); + * array.splice(index + 1, 0, needle); + * assert.deepEqual(array, [1, 2, 3]); + * ``` + */ +export declare function binarySearch(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, low: number, high: number): number; +export declare function upperBound(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, index: number): number; +export declare function lowerBound(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, index: number): number; +export declare function memoizedState(): MemoState; +/** + * This overly complicated beast is just to record the last tested line/column and the resulting + * index, allowing us to skip a few tests if mappings are monotonically increasing. + */ +export declare function memoizedBinarySearch(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, state: MemoState, key: number): number; +//# sourceMappingURL=binary-search.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/binary-search.d.mts.map b/scripts/node_modules/@jridgewell/trace-mapping/types/binary-search.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..648e84c1e7a5c587e300fe348389c500fa2af2c6 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/binary-search.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"binary-search.d.ts","sourceRoot":"","sources":["../src/binary-search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAG5E,MAAM,MAAM,SAAS,GAAG;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,eAAO,IAAI,KAAK,SAAQ,CAAC;AAEzB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,GACX,MAAM,CAmBR;AAED,wBAAgB,UAAU,CACxB,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,MAAM,CAKR;AAED,wBAAgB,UAAU,CACxB,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,MAAM,CAKR;AAED,wBAAgB,aAAa,IAAI,SAAS,CAMzC;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,MAAM,GACV,MAAM,CAsBR"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/by-source.d.cts b/scripts/node_modules/@jridgewell/trace-mapping/types/by-source.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..da496939c7c9d357a14710fcf16254e54e129c17 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/by-source.d.cts @@ -0,0 +1,4 @@ +import type { ReverseSegment, SourceMapSegment } from './sourcemap-segment.cts'; +export type Source = ReverseSegment[][]; +export = function buildBySources(decoded: readonly SourceMapSegment[][], memos: unknown[]): Source[]; +//# sourceMappingURL=by-source.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/by-source.d.cts.map b/scripts/node_modules/@jridgewell/trace-mapping/types/by-source.d.cts.map new file mode 100644 index 0000000000000000000000000000000000000000..32d2a7a1a941010c0b0315b458ba23d53d839b35 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/by-source.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"by-source.d.ts","sourceRoot":"","sources":["../src/by-source.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5E,MAAM,MAAM,MAAM,GAAG,cAAc,EAAE,EAAE,CAAC;AAIxC,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,OAAO,EAAE,SAAS,gBAAgB,EAAE,EAAE,EACtC,KAAK,EAAE,OAAO,EAAE,GACf,MAAM,EAAE,CA4BV"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/by-source.d.mts b/scripts/node_modules/@jridgewell/trace-mapping/types/by-source.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f36104955fbc695200a077cb96bc6019ec73c7c0 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/by-source.d.mts @@ -0,0 +1,4 @@ +import type { ReverseSegment, SourceMapSegment } from './sourcemap-segment.mts'; +export type Source = ReverseSegment[][]; +export default function buildBySources(decoded: readonly SourceMapSegment[][], memos: unknown[]): Source[]; +//# sourceMappingURL=by-source.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/by-source.d.mts.map b/scripts/node_modules/@jridgewell/trace-mapping/types/by-source.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..32d2a7a1a941010c0b0315b458ba23d53d839b35 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/by-source.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"by-source.d.ts","sourceRoot":"","sources":["../src/by-source.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5E,MAAM,MAAM,MAAM,GAAG,cAAc,EAAE,EAAE,CAAC;AAIxC,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,OAAO,EAAE,SAAS,gBAAgB,EAAE,EAAE,EACtC,KAAK,EAAE,OAAO,EAAE,GACf,MAAM,EAAE,CA4BV"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.cts b/scripts/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..433d849b7c4a8cec8c2dc50013b26b2ebd5f61ad --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.cts @@ -0,0 +1,9 @@ +import { TraceMap } from './trace-mapping.cts'; +import type { SectionedSourceMapInput, Ro } from './types.cts'; +type FlattenMap = { + new (map: Ro, mapUrl?: string | null): TraceMap; + (map: Ro, mapUrl?: string | null): TraceMap; +}; +export declare const FlattenMap: FlattenMap; +export {}; +//# sourceMappingURL=flatten-map.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.cts.map b/scripts/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.cts.map new file mode 100644 index 0000000000000000000000000000000000000000..994b208adfdb40a78e7b788b3bb039ca5da41031 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"flatten-map.d.ts","sourceRoot":"","sources":["../src/flatten-map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAwC,MAAM,iBAAiB,CAAC;AAUjF,OAAO,KAAK,EAKV,uBAAuB,EAEvB,EAAE,EACH,MAAM,SAAS,CAAC;AAGjB,KAAK,UAAU,GAAG;IAChB,KAAK,GAAG,EAAE,EAAE,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,QAAQ,CAAC;IACzE,CAAC,GAAG,EAAE,EAAE,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,QAAQ,CAAC;CACtE,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,UAsCV,CAAC"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.mts b/scripts/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..444a1bed55f5210de610d9dd8360ce9c8db37f10 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.mts @@ -0,0 +1,9 @@ +import { TraceMap } from './trace-mapping.mts'; +import type { SectionedSourceMapInput, Ro } from './types.mts'; +type FlattenMap = { + new (map: Ro, mapUrl?: string | null): TraceMap; + (map: Ro, mapUrl?: string | null): TraceMap; +}; +export declare const FlattenMap: FlattenMap; +export {}; +//# sourceMappingURL=flatten-map.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.mts.map b/scripts/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..994b208adfdb40a78e7b788b3bb039ca5da41031 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"flatten-map.d.ts","sourceRoot":"","sources":["../src/flatten-map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAwC,MAAM,iBAAiB,CAAC;AAUjF,OAAO,KAAK,EAKV,uBAAuB,EAEvB,EAAE,EACH,MAAM,SAAS,CAAC;AAGjB,KAAK,UAAU,GAAG;IAChB,KAAK,GAAG,EAAE,EAAE,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,QAAQ,CAAC;IACzE,CAAC,GAAG,EAAE,EAAE,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,QAAQ,CAAC;CACtE,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,UAsCV,CAAC"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/resolve.d.cts b/scripts/node_modules/@jridgewell/trace-mapping/types/resolve.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..62aeedb5b381de715b75ad8d15553fae994ee079 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/resolve.d.cts @@ -0,0 +1,4 @@ +type Resolve = (source: string | null) => string; +export = function resolver(mapUrl: string | null | undefined, sourceRoot: string | undefined): Resolve; +export {}; +//# sourceMappingURL=resolve.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/resolve.d.cts.map b/scripts/node_modules/@jridgewell/trace-mapping/types/resolve.d.cts.map new file mode 100644 index 0000000000000000000000000000000000000000..9f155ace7bab5ceb34974af9ea919c4760c4e9a4 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/resolve.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../src/resolve.ts"],"names":[],"mappings":"AAGA,KAAK,OAAO,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,KAAK,MAAM,CAAC;AACjD,MAAM,CAAC,OAAO,UAAU,QAAQ,CAC9B,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,UAAU,EAAE,MAAM,GAAG,SAAS,GAC7B,OAAO,CAQT"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/resolve.d.mts b/scripts/node_modules/@jridgewell/trace-mapping/types/resolve.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e2798a19ccb20ab2d94ffa7a8bd1bab03303fe69 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/resolve.d.mts @@ -0,0 +1,4 @@ +type Resolve = (source: string | null) => string; +export default function resolver(mapUrl: string | null | undefined, sourceRoot: string | undefined): Resolve; +export {}; +//# sourceMappingURL=resolve.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/resolve.d.mts.map b/scripts/node_modules/@jridgewell/trace-mapping/types/resolve.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..9f155ace7bab5ceb34974af9ea919c4760c4e9a4 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/resolve.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../src/resolve.ts"],"names":[],"mappings":"AAGA,KAAK,OAAO,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,KAAK,MAAM,CAAC;AACjD,MAAM,CAAC,OAAO,UAAU,QAAQ,CAC9B,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,UAAU,EAAE,MAAM,GAAG,SAAS,GAC7B,OAAO,CAQT"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/sort.d.cts b/scripts/node_modules/@jridgewell/trace-mapping/types/sort.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..aa14c129008da878cf9443414951b8a9c2d0799f --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/sort.d.cts @@ -0,0 +1,4 @@ +import type { ReverseSegment, SourceMapSegment } from './sourcemap-segment.cts'; +export = function maybeSort(mappings: SourceMapSegment[][], owned: boolean): SourceMapSegment[][]; +export declare function sortComparator(a: T, b: T): number; +//# sourceMappingURL=sort.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/sort.d.cts.map b/scripts/node_modules/@jridgewell/trace-mapping/types/sort.d.cts.map new file mode 100644 index 0000000000000000000000000000000000000000..48b8e67418d400b7c68921231f0028b2cee0652a --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/sort.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../src/sort.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5E,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,QAAQ,EAAE,gBAAgB,EAAE,EAAE,EAC9B,KAAK,EAAE,OAAO,GACb,gBAAgB,EAAE,EAAE,CAYtB;AAuBD,wBAAgB,cAAc,CAAC,CAAC,SAAS,gBAAgB,GAAG,cAAc,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,MAAM,CAE9F"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/sort.d.mts b/scripts/node_modules/@jridgewell/trace-mapping/types/sort.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..c5b94e64fd5595680120201212a03e905ebeb4c3 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/sort.d.mts @@ -0,0 +1,4 @@ +import type { ReverseSegment, SourceMapSegment } from './sourcemap-segment.mts'; +export default function maybeSort(mappings: SourceMapSegment[][], owned: boolean): SourceMapSegment[][]; +export declare function sortComparator(a: T, b: T): number; +//# sourceMappingURL=sort.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/sort.d.mts.map b/scripts/node_modules/@jridgewell/trace-mapping/types/sort.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..48b8e67418d400b7c68921231f0028b2cee0652a --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/sort.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../src/sort.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5E,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,QAAQ,EAAE,gBAAgB,EAAE,EAAE,EAC9B,KAAK,EAAE,OAAO,GACb,gBAAgB,EAAE,EAAE,CAYtB;AAuBD,wBAAgB,cAAc,CAAC,CAAC,SAAS,gBAAgB,GAAG,cAAc,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,MAAM,CAE9F"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.cts b/scripts/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..8d3cabc13032461848e6bcef75d702402517991f --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.cts @@ -0,0 +1,17 @@ +type GeneratedColumn = number; +type SourcesIndex = number; +type SourceLine = number; +type SourceColumn = number; +type NamesIndex = number; +type GeneratedLine = number; +export type SourceMapSegment = [GeneratedColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex]; +export type ReverseSegment = [SourceColumn, GeneratedLine, GeneratedColumn]; +export declare const COLUMN = 0; +export declare const SOURCES_INDEX = 1; +export declare const SOURCE_LINE = 2; +export declare const SOURCE_COLUMN = 3; +export declare const NAMES_INDEX = 4; +export declare const REV_GENERATED_LINE = 1; +export declare const REV_GENERATED_COLUMN = 2; +export {}; +//# sourceMappingURL=sourcemap-segment.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.cts.map b/scripts/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.cts.map new file mode 100644 index 0000000000000000000000000000000000000000..0c94a4610db499464df13dfe8456019983053a56 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"sourcemap-segment.d.ts","sourceRoot":"","sources":["../src/sourcemap-segment.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG,MAAM,CAAC;AAC9B,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,UAAU,GAAG,MAAM,CAAC;AACzB,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,UAAU,GAAG,MAAM,CAAC;AAEzB,KAAK,aAAa,GAAG,MAAM,CAAC;AAE5B,MAAM,MAAM,gBAAgB,GACxB,CAAC,eAAe,CAAC,GACjB,CAAC,eAAe,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,CAAC,GACzD,CAAC,eAAe,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;AAE1E,MAAM,MAAM,cAAc,GAAG,CAAC,YAAY,EAAE,aAAa,EAAE,eAAe,CAAC,CAAC;AAE5E,eAAO,MAAM,MAAM,IAAI,CAAC;AACxB,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,WAAW,IAAI,CAAC;AAC7B,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,WAAW,IAAI,CAAC;AAE7B,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,oBAAoB,IAAI,CAAC"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.mts b/scripts/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..8d3cabc13032461848e6bcef75d702402517991f --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.mts @@ -0,0 +1,17 @@ +type GeneratedColumn = number; +type SourcesIndex = number; +type SourceLine = number; +type SourceColumn = number; +type NamesIndex = number; +type GeneratedLine = number; +export type SourceMapSegment = [GeneratedColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex]; +export type ReverseSegment = [SourceColumn, GeneratedLine, GeneratedColumn]; +export declare const COLUMN = 0; +export declare const SOURCES_INDEX = 1; +export declare const SOURCE_LINE = 2; +export declare const SOURCE_COLUMN = 3; +export declare const NAMES_INDEX = 4; +export declare const REV_GENERATED_LINE = 1; +export declare const REV_GENERATED_COLUMN = 2; +export {}; +//# sourceMappingURL=sourcemap-segment.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.mts.map b/scripts/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..0c94a4610db499464df13dfe8456019983053a56 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"sourcemap-segment.d.ts","sourceRoot":"","sources":["../src/sourcemap-segment.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG,MAAM,CAAC;AAC9B,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,UAAU,GAAG,MAAM,CAAC;AACzB,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,UAAU,GAAG,MAAM,CAAC;AAEzB,KAAK,aAAa,GAAG,MAAM,CAAC;AAE5B,MAAM,MAAM,gBAAgB,GACxB,CAAC,eAAe,CAAC,GACjB,CAAC,eAAe,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,CAAC,GACzD,CAAC,eAAe,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;AAE1E,MAAM,MAAM,cAAc,GAAG,CAAC,YAAY,EAAE,aAAa,EAAE,eAAe,CAAC,CAAC;AAE5E,eAAO,MAAM,MAAM,IAAI,CAAC;AACxB,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,WAAW,IAAI,CAAC;AAC7B,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,WAAW,IAAI,CAAC;AAE7B,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,oBAAoB,IAAI,CAAC"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.cts b/scripts/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..8b3c0e9b9b8b4d94280c825ec48f41b4db0310a2 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.cts @@ -0,0 +1,5 @@ +/** + * Removes everything after the last "/", but leaves the slash. + */ +export = function stripFilename(path: string | undefined | null): string; +//# sourceMappingURL=strip-filename.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.cts.map b/scripts/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.cts.map new file mode 100644 index 0000000000000000000000000000000000000000..17a25da0d4301a031587b6098f8a21f987b909f9 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"strip-filename.d.ts","sourceRoot":"","sources":["../src/strip-filename.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,CAI7E"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.mts b/scripts/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..cbbaee0db3016c0532f2b10e6acc31ee28c8a48f --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.mts @@ -0,0 +1,5 @@ +/** + * Removes everything after the last "/", but leaves the slash. + */ +export default function stripFilename(path: string | undefined | null): string; +//# sourceMappingURL=strip-filename.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.mts.map b/scripts/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..17a25da0d4301a031587b6098f8a21f987b909f9 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"strip-filename.d.ts","sourceRoot":"","sources":["../src/strip-filename.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,CAI7E"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.cts b/scripts/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..a40f305476fd50c93d8209b43a09cba84f4bc68d --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.cts @@ -0,0 +1,80 @@ +import type { SourceMapSegment } from './sourcemap-segment.cts'; +import type { SourceMapV3, DecodedSourceMap, EncodedSourceMap, InvalidOriginalMapping, OriginalMapping, InvalidGeneratedMapping, GeneratedMapping, SourceMapInput, Needle, SourceNeedle, SourceMap, EachMapping, Ro } from './types.cts'; +export type { SourceMapSegment } from './sourcemap-segment.cts'; +export type { SourceMap, DecodedSourceMap, EncodedSourceMap, Section, SectionedSourceMap, SourceMapV3, Bias, EachMapping, GeneratedMapping, InvalidGeneratedMapping, InvalidOriginalMapping, Needle, OriginalMapping, OriginalMapping as Mapping, SectionedSourceMapInput, SourceMapInput, SourceNeedle, XInput, EncodedSourceMapXInput, DecodedSourceMapXInput, SectionedSourceMapXInput, SectionXInput, } from './types.cts'; +export declare const LEAST_UPPER_BOUND = -1; +export declare const GREATEST_LOWER_BOUND = 1; +export { FlattenMap, FlattenMap as AnyMap } from './flatten-map.cts'; +export declare class TraceMap implements SourceMap { + version: SourceMapV3['version']; + file: SourceMapV3['file']; + names: SourceMapV3['names']; + sourceRoot: SourceMapV3['sourceRoot']; + sources: SourceMapV3['sources']; + sourcesContent: SourceMapV3['sourcesContent']; + ignoreList: SourceMapV3['ignoreList']; + resolvedSources: string[]; + private _encoded; + private _decoded; + private _decodedMemo; + private _bySources; + private _bySourceMemos; + constructor(map: Ro, mapUrl?: string | null); +} +/** + * Returns the encoded (VLQ string) form of the SourceMap's mappings field. + */ +export declare function encodedMappings(map: TraceMap): EncodedSourceMap['mappings']; +/** + * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field. + */ +export declare function decodedMappings(map: TraceMap): Readonly; +/** + * A low-level API to find the segment associated with a generated line/column (think, from a + * stack trace). Line and column here are 0-based, unlike `originalPositionFor`. + */ +export declare function traceSegment(map: TraceMap, line: number, column: number): Readonly | null; +/** + * A higher-level API to find the source/line/column associated with a generated line/column + * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in + * `source-map` library. + */ +export declare function originalPositionFor(map: TraceMap, needle: Needle): OriginalMapping | InvalidOriginalMapping; +/** + * Finds the generated line/column position of the provided source/line/column source position. + */ +export declare function generatedPositionFor(map: TraceMap, needle: SourceNeedle): GeneratedMapping | InvalidGeneratedMapping; +/** + * Finds all generated line/column positions of the provided source/line/column source position. + */ +export declare function allGeneratedPositionsFor(map: TraceMap, needle: SourceNeedle): GeneratedMapping[]; +/** + * Iterates each mapping in generated position order. + */ +export declare function eachMapping(map: TraceMap, cb: (mapping: EachMapping) => void): void; +/** + * Retrieves the source content for a particular source, if its found. Returns null if not. + */ +export declare function sourceContentFor(map: TraceMap, source: string): string | null; +/** + * Determines if the source is marked to ignore by the source map. + */ +export declare function isIgnored(map: TraceMap, source: string): boolean; +/** + * A helper that skips sorting of the input map's mappings array, which can be expensive for larger + * maps. + */ +export declare function presortedDecodedMap(map: DecodedSourceMap, mapUrl?: string): TraceMap; +/** + * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects + * a sourcemap, or to JSON.stringify. + */ +export declare function decodedMap(map: TraceMap): Omit & { + mappings: readonly SourceMapSegment[][]; +}; +/** + * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects + * a sourcemap, or to JSON.stringify. + */ +export declare function encodedMap(map: TraceMap): EncodedSourceMap; +//# sourceMappingURL=trace-mapping.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.cts.map b/scripts/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.cts.map new file mode 100644 index 0000000000000000000000000000000000000000..b5a874c05a941f0f90a77a747f6ff27bd97200be --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"trace-mapping.d.ts","sourceRoot":"","sources":["../src/trace-mapping.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.mts b/scripts/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..bc2ff0f10ada49589f151943d011f212852abd81 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.mts @@ -0,0 +1,80 @@ +import type { SourceMapSegment } from './sourcemap-segment.mts'; +import type { SourceMapV3, DecodedSourceMap, EncodedSourceMap, InvalidOriginalMapping, OriginalMapping, InvalidGeneratedMapping, GeneratedMapping, SourceMapInput, Needle, SourceNeedle, SourceMap, EachMapping, Ro } from './types.mts'; +export type { SourceMapSegment } from './sourcemap-segment.mts'; +export type { SourceMap, DecodedSourceMap, EncodedSourceMap, Section, SectionedSourceMap, SourceMapV3, Bias, EachMapping, GeneratedMapping, InvalidGeneratedMapping, InvalidOriginalMapping, Needle, OriginalMapping, OriginalMapping as Mapping, SectionedSourceMapInput, SourceMapInput, SourceNeedle, XInput, EncodedSourceMapXInput, DecodedSourceMapXInput, SectionedSourceMapXInput, SectionXInput, } from './types.mts'; +export declare const LEAST_UPPER_BOUND = -1; +export declare const GREATEST_LOWER_BOUND = 1; +export { FlattenMap, FlattenMap as AnyMap } from './flatten-map.mts'; +export declare class TraceMap implements SourceMap { + version: SourceMapV3['version']; + file: SourceMapV3['file']; + names: SourceMapV3['names']; + sourceRoot: SourceMapV3['sourceRoot']; + sources: SourceMapV3['sources']; + sourcesContent: SourceMapV3['sourcesContent']; + ignoreList: SourceMapV3['ignoreList']; + resolvedSources: string[]; + private _encoded; + private _decoded; + private _decodedMemo; + private _bySources; + private _bySourceMemos; + constructor(map: Ro, mapUrl?: string | null); +} +/** + * Returns the encoded (VLQ string) form of the SourceMap's mappings field. + */ +export declare function encodedMappings(map: TraceMap): EncodedSourceMap['mappings']; +/** + * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field. + */ +export declare function decodedMappings(map: TraceMap): Readonly; +/** + * A low-level API to find the segment associated with a generated line/column (think, from a + * stack trace). Line and column here are 0-based, unlike `originalPositionFor`. + */ +export declare function traceSegment(map: TraceMap, line: number, column: number): Readonly | null; +/** + * A higher-level API to find the source/line/column associated with a generated line/column + * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in + * `source-map` library. + */ +export declare function originalPositionFor(map: TraceMap, needle: Needle): OriginalMapping | InvalidOriginalMapping; +/** + * Finds the generated line/column position of the provided source/line/column source position. + */ +export declare function generatedPositionFor(map: TraceMap, needle: SourceNeedle): GeneratedMapping | InvalidGeneratedMapping; +/** + * Finds all generated line/column positions of the provided source/line/column source position. + */ +export declare function allGeneratedPositionsFor(map: TraceMap, needle: SourceNeedle): GeneratedMapping[]; +/** + * Iterates each mapping in generated position order. + */ +export declare function eachMapping(map: TraceMap, cb: (mapping: EachMapping) => void): void; +/** + * Retrieves the source content for a particular source, if its found. Returns null if not. + */ +export declare function sourceContentFor(map: TraceMap, source: string): string | null; +/** + * Determines if the source is marked to ignore by the source map. + */ +export declare function isIgnored(map: TraceMap, source: string): boolean; +/** + * A helper that skips sorting of the input map's mappings array, which can be expensive for larger + * maps. + */ +export declare function presortedDecodedMap(map: DecodedSourceMap, mapUrl?: string): TraceMap; +/** + * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects + * a sourcemap, or to JSON.stringify. + */ +export declare function decodedMap(map: TraceMap): Omit & { + mappings: readonly SourceMapSegment[][]; +}; +/** + * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects + * a sourcemap, or to JSON.stringify. + */ +export declare function encodedMap(map: TraceMap): EncodedSourceMap; +//# sourceMappingURL=trace-mapping.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.mts.map b/scripts/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..b5a874c05a941f0f90a77a747f6ff27bd97200be --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"trace-mapping.d.ts","sourceRoot":"","sources":["../src/trace-mapping.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/types.d.cts b/scripts/node_modules/@jridgewell/trace-mapping/types/types.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..729c2c3218138386b9ac9e462ed46b2503c2407d --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/types.d.cts @@ -0,0 +1,107 @@ +import type { SourceMapSegment } from './sourcemap-segment.cts'; +import type { GREATEST_LOWER_BOUND, LEAST_UPPER_BOUND, TraceMap } from './trace-mapping.cts'; +export interface SourceMapV3 { + file?: string | null; + names: string[]; + sourceRoot?: string; + sources: (string | null)[]; + sourcesContent?: (string | null)[]; + version: 3; + ignoreList?: number[]; +} +export interface EncodedSourceMap extends SourceMapV3 { + mappings: string; +} +export interface DecodedSourceMap extends SourceMapV3 { + mappings: SourceMapSegment[][]; +} +export interface Section { + offset: { + line: number; + column: number; + }; + map: EncodedSourceMap | DecodedSourceMap | SectionedSourceMap; +} +export interface SectionedSourceMap { + file?: string | null; + sections: Section[]; + version: 3; +} +export type OriginalMapping = { + source: string | null; + line: number; + column: number; + name: string | null; +}; +export type InvalidOriginalMapping = { + source: null; + line: null; + column: null; + name: null; +}; +export type GeneratedMapping = { + line: number; + column: number; +}; +export type InvalidGeneratedMapping = { + line: null; + column: null; +}; +export type Bias = typeof GREATEST_LOWER_BOUND | typeof LEAST_UPPER_BOUND; +export type XInput = { + x_google_ignoreList?: SourceMapV3['ignoreList']; +}; +export type EncodedSourceMapXInput = EncodedSourceMap & XInput; +export type DecodedSourceMapXInput = DecodedSourceMap & XInput; +export type SectionedSourceMapXInput = Omit & { + sections: SectionXInput[]; +}; +export type SectionXInput = Omit & { + map: SectionedSourceMapInput; +}; +export type SourceMapInput = string | EncodedSourceMapXInput | DecodedSourceMapXInput | TraceMap; +export type SectionedSourceMapInput = SourceMapInput | SectionedSourceMapXInput; +export type Needle = { + line: number; + column: number; + bias?: Bias; +}; +export type SourceNeedle = { + source: string; + line: number; + column: number; + bias?: Bias; +}; +export type EachMapping = { + generatedLine: number; + generatedColumn: number; + source: null; + originalLine: null; + originalColumn: null; + name: null; +} | { + generatedLine: number; + generatedColumn: number; + source: string | null; + originalLine: number; + originalColumn: number; + name: string | null; +}; +export declare abstract class SourceMap { + version: SourceMapV3['version']; + file: SourceMapV3['file']; + names: SourceMapV3['names']; + sourceRoot: SourceMapV3['sourceRoot']; + sources: SourceMapV3['sources']; + sourcesContent: SourceMapV3['sourcesContent']; + resolvedSources: SourceMapV3['sources']; + ignoreList: SourceMapV3['ignoreList']; +} +export type Ro = T extends Array ? V[] | Readonly | RoArray | Readonly> : T extends object ? T | Readonly | RoObject | Readonly> : T; +type RoArray = Ro[]; +type RoObject = { + [K in keyof T]: T[K] | Ro; +}; +export declare function parse(map: T): Exclude; +export {}; +//# sourceMappingURL=types.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/types.d.cts.map b/scripts/node_modules/@jridgewell/trace-mapping/types/types.d.cts.map new file mode 100644 index 0000000000000000000000000000000000000000..922478396d1e658b7b43c40a4e461bf1d3e327fd --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/types.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/types.d.mts b/scripts/node_modules/@jridgewell/trace-mapping/types/types.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..a26d1866b4832bbce021f14bdcd28af6eb5db464 --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/types.d.mts @@ -0,0 +1,107 @@ +import type { SourceMapSegment } from './sourcemap-segment.mts'; +import type { GREATEST_LOWER_BOUND, LEAST_UPPER_BOUND, TraceMap } from './trace-mapping.mts'; +export interface SourceMapV3 { + file?: string | null; + names: string[]; + sourceRoot?: string; + sources: (string | null)[]; + sourcesContent?: (string | null)[]; + version: 3; + ignoreList?: number[]; +} +export interface EncodedSourceMap extends SourceMapV3 { + mappings: string; +} +export interface DecodedSourceMap extends SourceMapV3 { + mappings: SourceMapSegment[][]; +} +export interface Section { + offset: { + line: number; + column: number; + }; + map: EncodedSourceMap | DecodedSourceMap | SectionedSourceMap; +} +export interface SectionedSourceMap { + file?: string | null; + sections: Section[]; + version: 3; +} +export type OriginalMapping = { + source: string | null; + line: number; + column: number; + name: string | null; +}; +export type InvalidOriginalMapping = { + source: null; + line: null; + column: null; + name: null; +}; +export type GeneratedMapping = { + line: number; + column: number; +}; +export type InvalidGeneratedMapping = { + line: null; + column: null; +}; +export type Bias = typeof GREATEST_LOWER_BOUND | typeof LEAST_UPPER_BOUND; +export type XInput = { + x_google_ignoreList?: SourceMapV3['ignoreList']; +}; +export type EncodedSourceMapXInput = EncodedSourceMap & XInput; +export type DecodedSourceMapXInput = DecodedSourceMap & XInput; +export type SectionedSourceMapXInput = Omit & { + sections: SectionXInput[]; +}; +export type SectionXInput = Omit & { + map: SectionedSourceMapInput; +}; +export type SourceMapInput = string | EncodedSourceMapXInput | DecodedSourceMapXInput | TraceMap; +export type SectionedSourceMapInput = SourceMapInput | SectionedSourceMapXInput; +export type Needle = { + line: number; + column: number; + bias?: Bias; +}; +export type SourceNeedle = { + source: string; + line: number; + column: number; + bias?: Bias; +}; +export type EachMapping = { + generatedLine: number; + generatedColumn: number; + source: null; + originalLine: null; + originalColumn: null; + name: null; +} | { + generatedLine: number; + generatedColumn: number; + source: string | null; + originalLine: number; + originalColumn: number; + name: string | null; +}; +export declare abstract class SourceMap { + version: SourceMapV3['version']; + file: SourceMapV3['file']; + names: SourceMapV3['names']; + sourceRoot: SourceMapV3['sourceRoot']; + sources: SourceMapV3['sources']; + sourcesContent: SourceMapV3['sourcesContent']; + resolvedSources: SourceMapV3['sources']; + ignoreList: SourceMapV3['ignoreList']; +} +export type Ro = T extends Array ? V[] | Readonly | RoArray | Readonly> : T extends object ? T | Readonly | RoObject | Readonly> : T; +type RoArray = Ro[]; +type RoObject = { + [K in keyof T]: T[K] | Ro; +}; +export declare function parse(map: T): Exclude; +export {}; +//# sourceMappingURL=types.d.ts.map \ No newline at end of file diff --git a/scripts/node_modules/@jridgewell/trace-mapping/types/types.d.mts.map b/scripts/node_modules/@jridgewell/trace-mapping/types/types.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..922478396d1e658b7b43c40a4e461bf1d3e327fd --- /dev/null +++ b/scripts/node_modules/@jridgewell/trace-mapping/types/types.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/scripts/node_modules/@rolldown/pluginutils/LICENSE b/scripts/node_modules/@rolldown/pluginutils/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..afc0cdbabfb99ed4030bf9be2b852977f1ed72a0 --- /dev/null +++ b/scripts/node_modules/@rolldown/pluginutils/LICENSE @@ -0,0 +1,25 @@ +MIT License + +Copyright (c) 2024-present VoidZero Inc. & 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. + +end of terms and conditions + +The licenses of externally maintained libraries from which parts of the Software is derived are listed [here](https://github.com/rolldown/rolldown/blob/main/THIRD-PARTY-LICENSE). diff --git a/scripts/node_modules/@rolldown/pluginutils/dist/index.cjs b/scripts/node_modules/@rolldown/pluginutils/dist/index.cjs new file mode 100644 index 0000000000000000000000000000000000000000..e1ed5329678c4d9d47b141cfa0e901dc9e21ae96 --- /dev/null +++ b/scripts/node_modules/@rolldown/pluginutils/dist/index.cjs @@ -0,0 +1,271 @@ + +//#region src/utils.ts +const postfixRE = /[?#].*$/; +function cleanUrl(url) { + return url.replace(postfixRE, ""); +} +function extractQueryWithoutFragment(url) { + const questionMarkIndex = url.indexOf("?"); + if (questionMarkIndex === -1) return ""; + const fragmentIndex = url.indexOf("#", questionMarkIndex); + if (fragmentIndex === -1) return url.substring(questionMarkIndex); + else return url.substring(questionMarkIndex, fragmentIndex); +} + +//#endregion +//#region src/composable-filters.ts +var And = class { + kind; + args; + constructor(...args) { + if (args.length === 0) throw new Error("`And` expects at least one operand"); + this.args = args; + this.kind = "and"; + } +}; +var Or = class { + kind; + args; + constructor(...args) { + if (args.length === 0) throw new Error("`Or` expects at least one operand"); + this.args = args; + this.kind = "or"; + } +}; +var Not = class { + kind; + expr; + constructor(expr) { + this.expr = expr; + this.kind = "not"; + } +}; +var Id = class { + kind; + pattern; + params; + constructor(pattern, params) { + this.pattern = pattern; + this.kind = "id"; + this.params = params ?? { cleanUrl: false }; + } +}; +var ModuleType = class { + kind; + pattern; + constructor(pattern) { + this.pattern = pattern; + this.kind = "moduleType"; + } +}; +var Code = class { + kind; + pattern; + constructor(expr) { + this.pattern = expr; + this.kind = "code"; + } +}; +var Query = class { + kind; + key; + pattern; + constructor(key, pattern) { + this.pattern = pattern; + this.key = key; + this.kind = "query"; + } +}; +var Include = class { + kind; + expr; + constructor(expr) { + this.expr = expr; + this.kind = "include"; + } +}; +var Exclude = class { + kind; + expr; + constructor(expr) { + this.expr = expr; + this.kind = "exclude"; + } +}; +function and(...args) { + return new And(...args); +} +function or(...args) { + return new Or(...args); +} +function not(expr) { + return new Not(expr); +} +function id(pattern, params) { + return new Id(pattern, params); +} +function moduleType(pattern) { + return new ModuleType(pattern); +} +function code(pattern) { + return new Code(pattern); +} +function query(key, pattern) { + return new Query(key, pattern); +} +function include(expr) { + return new Include(expr); +} +function exclude(expr) { + return new Exclude(expr); +} +/** +* convert a queryObject to FilterExpression like +* ```js +* and(query(k1, v1), query(k2, v2)) +* ``` +* @param queryFilterObject The query filter object needs to be matched. +* @returns a `And` FilterExpression +*/ +function queries(queryFilter) { + let arr = Object.entries(queryFilter).map(([key, value]) => { + return new Query(key, value); + }); + return and(...arr); +} +function interpreter(exprs, code$1, id$1, moduleType$1) { + let arr = []; + if (Array.isArray(exprs)) arr = exprs; + else arr = [exprs]; + return interpreterImpl(arr, code$1, id$1, moduleType$1); +} +function interpreterImpl(expr, code$1, id$1, moduleType$1, ctx = {}) { + let hasInclude = false; + for (const e of expr) switch (e.kind) { + case "include": { + hasInclude = true; + if (exprInterpreter(e.expr, code$1, id$1, moduleType$1, ctx)) return true; + break; + } + case "exclude": { + if (exprInterpreter(e.expr, code$1, id$1, moduleType$1)) return false; + break; + } + } + return !hasInclude; +} +function exprInterpreter(expr, code$1, id$1, moduleType$1, ctx = {}) { + switch (expr.kind) { + case "and": return expr.args.every((e) => exprInterpreter(e, code$1, id$1, moduleType$1, ctx)); + case "or": return expr.args.some((e) => exprInterpreter(e, code$1, id$1, moduleType$1, ctx)); + case "not": return !exprInterpreter(expr.expr, code$1, id$1, moduleType$1, ctx); + case "id": { + if (id$1 === void 0) throw new Error("`id` is required for `id` expression"); + if (expr.params.cleanUrl) id$1 = cleanUrl(id$1); + return typeof expr.pattern === "string" ? id$1 === expr.pattern : expr.pattern.test(id$1); + } + case "moduleType": { + if (moduleType$1 === void 0) throw new Error("`moduleType` is required for `moduleType` expression"); + return moduleType$1 === expr.pattern; + } + case "code": { + if (code$1 === void 0) throw new Error("`code` is required for `code` expression"); + return typeof expr.pattern === "string" ? code$1.includes(expr.pattern) : expr.pattern.test(code$1); + } + case "query": { + if (id$1 === void 0) throw new Error("`id` is required for `Query` expression"); + if (!ctx.urlSearchParamsCache) { + let queryString = extractQueryWithoutFragment(id$1); + ctx.urlSearchParamsCache = new URLSearchParams(queryString); + } + let urlParams = ctx.urlSearchParamsCache; + if (typeof expr.pattern === "boolean") if (expr.pattern) return urlParams.has(expr.key); + else return !urlParams.has(expr.key); + else if (typeof expr.pattern === "string") return urlParams.get(expr.key) === expr.pattern; + else return expr.pattern.test(urlParams.get(expr.key) ?? ""); + } + default: throw new Error(`Expression ${JSON.stringify(expr)} is not expected.`); + } +} + +//#endregion +//#region src/simple-filters.ts +/** +* Constructs a RegExp that matches the exact string specified. +* +* This is useful for plugin hook filters. +* +* @param str the string to match. +* @param flags flags for the RegExp. +* +* @example +* ```ts +* import { exactRegex } from '@rolldown/pluginutils'; +* const plugin = { +* name: 'plugin', +* resolveId: { +* filter: { id: exactRegex('foo') }, +* handler(id) {} // will only be called for `foo` +* } +* } +* ``` +*/ +function exactRegex(str, flags) { + return new RegExp(`^${escapeRegex(str)}$`, flags); +} +/** +* Constructs a RegExp that matches a value that has the specified prefix. +* +* This is useful for plugin hook filters. +* +* @param str the string to match. +* @param flags flags for the RegExp. +* +* @example +* ```ts +* import { prefixRegex } from '@rolldown/pluginutils'; +* const plugin = { +* name: 'plugin', +* resolveId: { +* filter: { id: prefixRegex('foo') }, +* handler(id) {} // will only be called for IDs starting with `foo` +* } +* } +* ``` +*/ +function prefixRegex(str, flags) { + return new RegExp(`^${escapeRegex(str)}`, flags); +} +const escapeRegexRE = /[-/\\^$*+?.()|[\]{}]/g; +function escapeRegex(str) { + return str.replace(escapeRegexRE, "\\$&"); +} +function makeIdFiltersToMatchWithQuery(input) { + if (!Array.isArray(input)) return makeIdFilterToMatchWithQuery(input); + return input.map((i) => makeIdFilterToMatchWithQuery(i)); +} +function makeIdFilterToMatchWithQuery(input) { + if (typeof input === "string") return `${input}{?*,}`; + return makeRegexIdFilterToMatchWithQuery(input); +} +function makeRegexIdFilterToMatchWithQuery(input) { + return new RegExp(input.source.replace(/(? = T extends string ? string : T; +/** +* Converts a id filter to match with an id with a query. +* +* @param input the id filters to convert. +* +* @example +* ```ts +* import { makeIdFiltersToMatchWithQuery } from '@rolldown/pluginutils'; +* const plugin = { +* name: 'plugin', +* transform: { +* filter: { id: makeIdFiltersToMatchWithQuery(['**' + '/*.js', /\.ts$/]) }, +* // The handler will be called for IDs like: +* // - foo.js +* // - foo.js?foo +* // - foo.txt?foo.js +* // - foo.ts +* // - foo.ts?foo +* // - foo.txt?foo.ts +* handler(code, id) {} +* } +* } +* ``` +*/ +declare function makeIdFiltersToMatchWithQuery(input: T): WidenString; +declare function makeIdFiltersToMatchWithQuery(input: readonly T[]): WidenString[]; +declare function makeIdFiltersToMatchWithQuery(input: string | RegExp | readonly (string | RegExp)[]): string | RegExp | (string | RegExp)[]; +//#endregion +export { FilterExpression, FilterExpressionKind, QueryFilterObject, TopLevelFilterExpression, and, code, exactRegex, exclude, exprInterpreter, id, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query }; \ No newline at end of file diff --git a/scripts/node_modules/@rolldown/pluginutils/dist/index.d.ts b/scripts/node_modules/@rolldown/pluginutils/dist/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..97c0163d21d4c689f10af0753dc2d671cc389c5f --- /dev/null +++ b/scripts/node_modules/@rolldown/pluginutils/dist/index.d.ts @@ -0,0 +1,157 @@ +//#region src/composable-filters.d.ts +type StringOrRegExp = string | RegExp; +type PluginModuleType = "js" | "jsx" | "ts" | "tsx" | "json" | "text" | "base64" | "dataurl" | "binary" | "empty" | (string & {}); +type FilterExpressionKind = FilterExpression["kind"]; +type FilterExpression = And | Or | Not | Id | ModuleType | Code | Query; +type TopLevelFilterExpression = Include | Exclude; +declare class And { + kind: "and"; + args: FilterExpression[]; + constructor(...args: FilterExpression[]); +} +declare class Or { + kind: "or"; + args: FilterExpression[]; + constructor(...args: FilterExpression[]); +} +declare class Not { + kind: "not"; + expr: FilterExpression; + constructor(expr: FilterExpression); +} +interface QueryFilterObject { + [key: string]: StringOrRegExp | boolean; +} +interface IdParams { + cleanUrl?: boolean; +} +declare class Id { + kind: "id"; + pattern: StringOrRegExp; + params: IdParams; + constructor(pattern: StringOrRegExp, params?: IdParams); +} +declare class ModuleType { + kind: "moduleType"; + pattern: PluginModuleType; + constructor(pattern: PluginModuleType); +} +declare class Code { + kind: "code"; + pattern: StringOrRegExp; + constructor(expr: StringOrRegExp); +} +declare class Query { + kind: "query"; + key: string; + pattern: StringOrRegExp | boolean; + constructor(key: string, pattern: StringOrRegExp | boolean); +} +declare class Include { + kind: "include"; + expr: FilterExpression; + constructor(expr: FilterExpression); +} +declare class Exclude { + kind: "exclude"; + expr: FilterExpression; + constructor(expr: FilterExpression); +} +declare function and(...args: FilterExpression[]): And; +declare function or(...args: FilterExpression[]): Or; +declare function not(expr: FilterExpression): Not; +declare function id(pattern: StringOrRegExp, params?: IdParams): Id; +declare function moduleType(pattern: PluginModuleType): ModuleType; +declare function code(pattern: StringOrRegExp): Code; +declare function query(key: string, pattern: StringOrRegExp | boolean): Query; +declare function include(expr: FilterExpression): Include; +declare function exclude(expr: FilterExpression): Exclude; +/** +* convert a queryObject to FilterExpression like +* ```js +* and(query(k1, v1), query(k2, v2)) +* ``` +* @param queryFilterObject The query filter object needs to be matched. +* @returns a `And` FilterExpression +*/ +declare function queries(queryFilter: QueryFilterObject): And; +declare function interpreter(exprs: TopLevelFilterExpression | TopLevelFilterExpression[], code?: string, id?: string, moduleType?: PluginModuleType): boolean; +interface InterpreterCtx { + urlSearchParamsCache?: URLSearchParams; +} +declare function interpreterImpl(expr: TopLevelFilterExpression[], code?: string, id?: string, moduleType?: PluginModuleType, ctx?: InterpreterCtx): boolean; +declare function exprInterpreter(expr: FilterExpression, code?: string, id?: string, moduleType?: PluginModuleType, ctx?: InterpreterCtx): boolean; +//#endregion +//#region src/simple-filters.d.ts +/** +* Constructs a RegExp that matches the exact string specified. +* +* This is useful for plugin hook filters. +* +* @param str the string to match. +* @param flags flags for the RegExp. +* +* @example +* ```ts +* import { exactRegex } from '@rolldown/pluginutils'; +* const plugin = { +* name: 'plugin', +* resolveId: { +* filter: { id: exactRegex('foo') }, +* handler(id) {} // will only be called for `foo` +* } +* } +* ``` +*/ +declare function exactRegex(str: string, flags?: string): RegExp; +/** +* Constructs a RegExp that matches a value that has the specified prefix. +* +* This is useful for plugin hook filters. +* +* @param str the string to match. +* @param flags flags for the RegExp. +* +* @example +* ```ts +* import { prefixRegex } from '@rolldown/pluginutils'; +* const plugin = { +* name: 'plugin', +* resolveId: { +* filter: { id: prefixRegex('foo') }, +* handler(id) {} // will only be called for IDs starting with `foo` +* } +* } +* ``` +*/ +declare function prefixRegex(str: string, flags?: string): RegExp; +type WidenString = T extends string ? string : T; +/** +* Converts a id filter to match with an id with a query. +* +* @param input the id filters to convert. +* +* @example +* ```ts +* import { makeIdFiltersToMatchWithQuery } from '@rolldown/pluginutils'; +* const plugin = { +* name: 'plugin', +* transform: { +* filter: { id: makeIdFiltersToMatchWithQuery(['**' + '/*.js', /\.ts$/]) }, +* // The handler will be called for IDs like: +* // - foo.js +* // - foo.js?foo +* // - foo.txt?foo.js +* // - foo.ts +* // - foo.ts?foo +* // - foo.txt?foo.ts +* handler(code, id) {} +* } +* } +* ``` +*/ +declare function makeIdFiltersToMatchWithQuery(input: T): WidenString; +declare function makeIdFiltersToMatchWithQuery(input: readonly T[]): WidenString[]; +declare function makeIdFiltersToMatchWithQuery(input: string | RegExp | readonly (string | RegExp)[]): string | RegExp | (string | RegExp)[]; +//#endregion +export { FilterExpression, FilterExpressionKind, QueryFilterObject, TopLevelFilterExpression, and, code, exactRegex, exclude, exprInterpreter, id, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query }; \ No newline at end of file diff --git a/scripts/node_modules/@rolldown/pluginutils/dist/index.js b/scripts/node_modules/@rolldown/pluginutils/dist/index.js new file mode 100644 index 0000000000000000000000000000000000000000..18361e8388eb813e48b897984bfc44babcd39613 --- /dev/null +++ b/scripts/node_modules/@rolldown/pluginutils/dist/index.js @@ -0,0 +1,255 @@ +//#region src/utils.ts +const postfixRE = /[?#].*$/; +function cleanUrl(url) { + return url.replace(postfixRE, ""); +} +function extractQueryWithoutFragment(url) { + const questionMarkIndex = url.indexOf("?"); + if (questionMarkIndex === -1) return ""; + const fragmentIndex = url.indexOf("#", questionMarkIndex); + if (fragmentIndex === -1) return url.substring(questionMarkIndex); + else return url.substring(questionMarkIndex, fragmentIndex); +} + +//#endregion +//#region src/composable-filters.ts +var And = class { + kind; + args; + constructor(...args) { + if (args.length === 0) throw new Error("`And` expects at least one operand"); + this.args = args; + this.kind = "and"; + } +}; +var Or = class { + kind; + args; + constructor(...args) { + if (args.length === 0) throw new Error("`Or` expects at least one operand"); + this.args = args; + this.kind = "or"; + } +}; +var Not = class { + kind; + expr; + constructor(expr) { + this.expr = expr; + this.kind = "not"; + } +}; +var Id = class { + kind; + pattern; + params; + constructor(pattern, params) { + this.pattern = pattern; + this.kind = "id"; + this.params = params ?? { cleanUrl: false }; + } +}; +var ModuleType = class { + kind; + pattern; + constructor(pattern) { + this.pattern = pattern; + this.kind = "moduleType"; + } +}; +var Code = class { + kind; + pattern; + constructor(expr) { + this.pattern = expr; + this.kind = "code"; + } +}; +var Query = class { + kind; + key; + pattern; + constructor(key, pattern) { + this.pattern = pattern; + this.key = key; + this.kind = "query"; + } +}; +var Include = class { + kind; + expr; + constructor(expr) { + this.expr = expr; + this.kind = "include"; + } +}; +var Exclude = class { + kind; + expr; + constructor(expr) { + this.expr = expr; + this.kind = "exclude"; + } +}; +function and(...args) { + return new And(...args); +} +function or(...args) { + return new Or(...args); +} +function not(expr) { + return new Not(expr); +} +function id(pattern, params) { + return new Id(pattern, params); +} +function moduleType(pattern) { + return new ModuleType(pattern); +} +function code(pattern) { + return new Code(pattern); +} +function query(key, pattern) { + return new Query(key, pattern); +} +function include(expr) { + return new Include(expr); +} +function exclude(expr) { + return new Exclude(expr); +} +/** +* convert a queryObject to FilterExpression like +* ```js +* and(query(k1, v1), query(k2, v2)) +* ``` +* @param queryFilterObject The query filter object needs to be matched. +* @returns a `And` FilterExpression +*/ +function queries(queryFilter) { + let arr = Object.entries(queryFilter).map(([key, value]) => { + return new Query(key, value); + }); + return and(...arr); +} +function interpreter(exprs, code$1, id$1, moduleType$1) { + let arr = []; + if (Array.isArray(exprs)) arr = exprs; + else arr = [exprs]; + return interpreterImpl(arr, code$1, id$1, moduleType$1); +} +function interpreterImpl(expr, code$1, id$1, moduleType$1, ctx = {}) { + let hasInclude = false; + for (const e of expr) switch (e.kind) { + case "include": { + hasInclude = true; + if (exprInterpreter(e.expr, code$1, id$1, moduleType$1, ctx)) return true; + break; + } + case "exclude": { + if (exprInterpreter(e.expr, code$1, id$1, moduleType$1)) return false; + break; + } + } + return !hasInclude; +} +function exprInterpreter(expr, code$1, id$1, moduleType$1, ctx = {}) { + switch (expr.kind) { + case "and": return expr.args.every((e) => exprInterpreter(e, code$1, id$1, moduleType$1, ctx)); + case "or": return expr.args.some((e) => exprInterpreter(e, code$1, id$1, moduleType$1, ctx)); + case "not": return !exprInterpreter(expr.expr, code$1, id$1, moduleType$1, ctx); + case "id": { + if (id$1 === void 0) throw new Error("`id` is required for `id` expression"); + if (expr.params.cleanUrl) id$1 = cleanUrl(id$1); + return typeof expr.pattern === "string" ? id$1 === expr.pattern : expr.pattern.test(id$1); + } + case "moduleType": { + if (moduleType$1 === void 0) throw new Error("`moduleType` is required for `moduleType` expression"); + return moduleType$1 === expr.pattern; + } + case "code": { + if (code$1 === void 0) throw new Error("`code` is required for `code` expression"); + return typeof expr.pattern === "string" ? code$1.includes(expr.pattern) : expr.pattern.test(code$1); + } + case "query": { + if (id$1 === void 0) throw new Error("`id` is required for `Query` expression"); + if (!ctx.urlSearchParamsCache) { + let queryString = extractQueryWithoutFragment(id$1); + ctx.urlSearchParamsCache = new URLSearchParams(queryString); + } + let urlParams = ctx.urlSearchParamsCache; + if (typeof expr.pattern === "boolean") if (expr.pattern) return urlParams.has(expr.key); + else return !urlParams.has(expr.key); + else if (typeof expr.pattern === "string") return urlParams.get(expr.key) === expr.pattern; + else return expr.pattern.test(urlParams.get(expr.key) ?? ""); + } + default: throw new Error(`Expression ${JSON.stringify(expr)} is not expected.`); + } +} + +//#endregion +//#region src/simple-filters.ts +/** +* Constructs a RegExp that matches the exact string specified. +* +* This is useful for plugin hook filters. +* +* @param str the string to match. +* @param flags flags for the RegExp. +* +* @example +* ```ts +* import { exactRegex } from '@rolldown/pluginutils'; +* const plugin = { +* name: 'plugin', +* resolveId: { +* filter: { id: exactRegex('foo') }, +* handler(id) {} // will only be called for `foo` +* } +* } +* ``` +*/ +function exactRegex(str, flags) { + return new RegExp(`^${escapeRegex(str)}$`, flags); +} +/** +* Constructs a RegExp that matches a value that has the specified prefix. +* +* This is useful for plugin hook filters. +* +* @param str the string to match. +* @param flags flags for the RegExp. +* +* @example +* ```ts +* import { prefixRegex } from '@rolldown/pluginutils'; +* const plugin = { +* name: 'plugin', +* resolveId: { +* filter: { id: prefixRegex('foo') }, +* handler(id) {} // will only be called for IDs starting with `foo` +* } +* } +* ``` +*/ +function prefixRegex(str, flags) { + return new RegExp(`^${escapeRegex(str)}`, flags); +} +const escapeRegexRE = /[-/\\^$*+?.()|[\]{}]/g; +function escapeRegex(str) { + return str.replace(escapeRegexRE, "\\$&"); +} +function makeIdFiltersToMatchWithQuery(input) { + if (!Array.isArray(input)) return makeIdFilterToMatchWithQuery(input); + return input.map((i) => makeIdFilterToMatchWithQuery(i)); +} +function makeIdFilterToMatchWithQuery(input) { + if (typeof input === "string") return `${input}{?*,}`; + return makeRegexIdFilterToMatchWithQuery(input); +} +function makeRegexIdFilterToMatchWithQuery(input) { + return new RegExp(input.source.replace(/(? onBackButtonPress` for Android back button handling. + +### Enhancements + +- [`59089723f`](https://www.github.com/tauri-apps/tauri/commit/59089723fc20d66f3f305f2008adeb279bf87462) ([#14091](https://www.github.com/tauri-apps/tauri/pull/14091)) Added a config to set a data_directory relative to the app-specific data dir in JavaScript and `tauri.conf.json`. + +### Bug Fixes + +- [`08bda64c2`](https://www.github.com/tauri-apps/tauri/commit/08bda64c25008bd45c5b58d06ff14649081a2f5d) ([#14132](https://www.github.com/tauri-apps/tauri/pull/14132)) Fix `core > addPluginListener` failing on command permission check. + +## \[2.8.0] + +### New Features + +- [`68874c68c`](https://www.github.com/tauri-apps/tauri/commit/68874c68c566638b4c21a3aa67844d1bdaeb6dab) ([#13564](https://www.github.com/tauri-apps/tauri/pull/13564) by [@robertrpf](https://www.github.com/tauri-apps/tauri/../../robertrpf)) Add window focusable attribute and set_focusable API. +- [`5110a762e`](https://www.github.com/tauri-apps/tauri/commit/5110a762e9db978a28a15400bf76e3c864da2a86) ([#13830](https://www.github.com/tauri-apps/tauri/pull/13830) by [@Sky-walkerX](https://www.github.com/tauri-apps/tauri/../../Sky-walkerX)) Added `Window::setSimpleFullscreen`. + +### Enhancements + +- [`5ba1c3faa`](https://www.github.com/tauri-apps/tauri/commit/5ba1c3faa468073512bdb5035a01f7f99720fcf0) ([#13722](https://www.github.com/tauri-apps/tauri/pull/13722) by [@s00d](https://www.github.com/tauri-apps/tauri/../../s00d)) Added icon (icon and nativeIcon) support for Submenu: + + - In the Rust API (`tauri`), you can now set an icon for submenus via the builder and dedicated methods. + - In the JS/TS API (`@tauri-apps/api`), `SubmenuOptions` now has an `icon` field, and the `Submenu` class provides `setIcon` and `setNativeIcon` methods. + - Usage examples are added to the documentation and demo app. + + This is a backwards-compatible feature. Submenus can now display icons just like regular menu items. + +## \[2.7.0] + +### New Features + +- [`232265c70`](https://www.github.com/tauri-apps/tauri/commit/232265c70e1c213bbb3f84b5541ddc07d330fce1) ([#13209](https://www.github.com/tauri-apps/tauri/pull/13209) by [@kandrelczyk](https://www.github.com/tauri-apps/tauri/../../kandrelczyk)) Added `getBundleType` to the app module. + +### Enhancements + +- [`96391467e`](https://www.github.com/tauri-apps/tauri/commit/96391467e967c1e3c6475ce75166c58a326116a3) ([#13783](https://www.github.com/tauri-apps/tauri/pull/13783) by [@JosephBrooksbank](https://www.github.com/tauri-apps/tauri/../../JosephBrooksbank)) Allow events emitted with `emit` to be handled correctly by `listen` callbacks when in a mocked environment + +### Bug Fixes + +- [`152d971bc`](https://www.github.com/tauri-apps/tauri/commit/152d971bcd6c1fdc5716f7d5417dd4df5ce7479f) ([#13744](https://www.github.com/tauri-apps/tauri/pull/13744) by [@Legend-Master](https://www.github.com/tauri-apps/tauri/../../Legend-Master)) Expose `unregisterCallback`, `runCallback`, `callbacks` in `mockIPC` +- [`b821796ad`](https://www.github.com/tauri-apps/tauri/commit/b821796add33cca4de72f48882684af487936d02) ([#13810](https://www.github.com/tauri-apps/tauri/pull/13810) by [@asdolo](https://www.github.com/tauri-apps/tauri/../../asdolo)) Add missing `trafficLightPosition` TypeScript type definition + +## \[2.6.0] + +### New Features + +- [`50ebddaa2`](https://www.github.com/tauri-apps/tauri/commit/50ebddaa2d83033a393a176ba07ef28352b98210) ([#13319](https://www.github.com/tauri-apps/tauri/pull/13319) by [@kingsword09](https://www.github.com/tauri-apps/tauri/../../kingsword09)) Expose the `setAutoResize` API for webviews in `@tauri-apps/api`. +- [`267368fd4`](https://www.github.com/tauri-apps/tauri/commit/267368fd4f83e0a71dfb1b72a66d56592a2066bc) ([#13276](https://www.github.com/tauri-apps/tauri/pull/13276) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Add `Monitor.workArea` field. + +### Bug Fixes + +- [`23b9da75b`](https://www.github.com/tauri-apps/tauri/commit/23b9da75b91379cca9520bc53b10fdf39ebae241) ([#13324](https://www.github.com/tauri-apps/tauri/pull/13324) by [@kingsword09](https://www.github.com/tauri-apps/tauri/../../kingsword09)) Fixed path joining behavior where `path.join('', 'a')` incorrectly returns "/a" instead of "a". +- [`b985eaf0a`](https://www.github.com/tauri-apps/tauri/commit/b985eaf0a231ea570e36d686c665cddbc76ab4f6) ([#13306](https://www.github.com/tauri-apps/tauri/pull/13306) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Immediately unregister event listener when the unlisten function is called. + +### What's Changed + +- [`b5c549d18`](https://www.github.com/tauri-apps/tauri/commit/b5c549d1898ecdb712822c02dc665cc6771fbd07) ([#13325](https://www.github.com/tauri-apps/tauri/pull/13325) by [@Legend-Master](https://www.github.com/tauri-apps/tauri/../../Legend-Master)) `transformCallback` now registers the callbacks inside `window.__TAURI_INTERNALS__.callbacks` instead of directly on `window['_{id}']` + +## \[2.5.0] + +### New Features + +- [`66e6325f4`](https://www.github.com/tauri-apps/tauri/commit/66e6325f43efa49ec2165c45afec911a1a14ecfb) ([#13136](https://www.github.com/tauri-apps/tauri/pull/13136)) Allow passing the callback as the parameter of constructor of `Channel` so you can use it like this `new Channel((message) => console.log(message))` +- [`ea36294cb`](https://www.github.com/tauri-apps/tauri/commit/ea36294cbca98f7725c91d1464fd92e77c89698a) ([#13208](https://www.github.com/tauri-apps/tauri/pull/13208)) Added `disableInputAccessoryView: bool` config for iOS. +- [`c1cd0a2dd`](https://www.github.com/tauri-apps/tauri/commit/c1cd0a2ddb5bc3e99451cbe399b5fc9f0035f571) ([#13090](https://www.github.com/tauri-apps/tauri/pull/13090)) macOS/iOS: add option to disable or enable link previews when building a webview (the webkit api has it enabled by default) + + - `WindowOptions::allowLinkPreview` + - `WebviewOptions::allowLinkPreview` +- [`b072e2b29`](https://www.github.com/tauri-apps/tauri/commit/b072e2b2967640ae4fa1af466ae878c156551edd) ([#9687](https://www.github.com/tauri-apps/tauri/pull/9687)) Add `preventOverflow` config option to prevent the window from overflowing the monitor size on creation +- [`dd4f13ce4`](https://www.github.com/tauri-apps/tauri/commit/dd4f13ce4b3cd89cde2fa3f18a063c272f215621) ([#13185](https://www.github.com/tauri-apps/tauri/pull/13185)) Added `app.setDockVisibility` for macOS. + +### Enhancements + +- [`b8f86669a`](https://www.github.com/tauri-apps/tauri/commit/b8f86669ab05f7dbdd15839a20999e63dc43bda6) ([#13145](https://www.github.com/tauri-apps/tauri/pull/13145)) `core.isTauri` now leverages `globalThis` instead of `window` in order to be used in unit tests. + +### Bug Fixes + +- [`66e6325f4`](https://www.github.com/tauri-apps/tauri/commit/66e6325f43efa49ec2165c45afec911a1a14ecfb) ([#13136](https://www.github.com/tauri-apps/tauri/pull/13136)) Fix `Channel`'s callback attached to `window` never cleaned up + +## \[2.4.1] + +### Enhancements + +- [`dd1372833`](https://www.github.com/tauri-apps/tauri/commit/dd137283341ce0e6aabfd158d07d77c6feeb920e) ([#13066](https://www.github.com/tauri-apps/tauri/pull/13066) by [@ahaoboy](https://www.github.com/tauri-apps/tauri/../../ahaoboy)) Add a generic to `emit` and `emitTo` functions for the `payload` instead of the previously used type (`unknown`). + +## \[2.4.0] + +### New Features + +- [`d8059bad3`](https://www.github.com/tauri-apps/tauri/commit/d8059bad3cc922dc369c39ca1cfa49aaec31322e) ([#12900](https://www.github.com/tauri-apps/tauri/pull/12900) by [@Simon-Laux](https://www.github.com/tauri-apps/tauri/../../Simon-Laux)) add `AppHandle.fetch_data_store_identifiers` and `AppHandle.remove_data_store` (macOS and iOS only) +- [`20c190691`](https://www.github.com/tauri-apps/tauri/commit/20c19069125c89b2d45a2127278c9ffc2df35fc2) ([#12821](https://www.github.com/tauri-apps/tauri/pull/12821) by [@Simon-Laux](https://www.github.com/tauri-apps/tauri/../../Simon-Laux)) Added `WindowOptions::javascriptDisabled` and `WebviewOptions::javascriptDisabled`. +- [`060de5bbd`](https://www.github.com/tauri-apps/tauri/commit/060de5bbdddca384e3965a8938d89840f27c581d) ([#12837](https://www.github.com/tauri-apps/tauri/pull/12837) by [@niladrix719](https://www.github.com/tauri-apps/tauri/../../niladrix719)) Added `getIdentifier()` function to get the application identifier configured in tauri.conf.json +- [`be2e6b85f`](https://www.github.com/tauri-apps/tauri/commit/be2e6b85fed226732b4a98f68cc5d72b4f8f5a13) ([#12944](https://www.github.com/tauri-apps/tauri/pull/12944) by [@Simon-Laux](https://www.github.com/tauri-apps/tauri/../../Simon-Laux)) Added `Window#isAlwaysOnTop` and `WebviewWindow#isAlwaysOnTop` methods. +- [`bcdd51025`](https://www.github.com/tauri-apps/tauri/commit/bcdd510254ebe37827e22a5ffeb944321361e97c) ([#13012](https://www.github.com/tauri-apps/tauri/pull/13012) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) The `path` basename and extname APIs now accept Android content URIs, such as the paths returned by the dialog plugin. + +### Bug Fixes + +- [`3a74dc8f3`](https://www.github.com/tauri-apps/tauri/commit/3a74dc8f3421112b1d0a32b6a432606b1f33cc25) ([#12935](https://www.github.com/tauri-apps/tauri/pull/12935) by [@tk103331](https://www.github.com/tauri-apps/tauri/../../tk103331)) Fix `Webview.close` always fail with command not found + +## \[2.3.0] + +### Enhancements + +- [`a2d36b8c3`](https://www.github.com/tauri-apps/tauri/commit/a2d36b8c34a8dcfc6736797ca5cd4665faf75e7e) ([#12181](https://www.github.com/tauri-apps/tauri/pull/12181) by [@bastiankistner](https://www.github.com/tauri-apps/tauri/../../bastiankistner)) Add an option to change the default background throttling policy (currently for WebKit only). + +## \[2.2.0] + +### New Features + +- [`020ea0556`](https://www.github.com/tauri-apps/tauri/commit/020ea05561348dcd6d2a7df358f8a5190f661ba2) ([#11661](https://www.github.com/tauri-apps/tauri/pull/11661) by [@ahqsoftwares](https://www.github.com/tauri-apps/tauri/../../ahqsoftwares)) Add badging APIs: + + - `Window/WebviewWindow::set_badge_count` for Linux, macOS and IOS. + - `Window/WebviewWindow::set_overlay_icon` for Windows Only. + - `Window/WebviewWindow::set_badge_label`for macOS Only. +- [`fc30b20be`](https://www.github.com/tauri-apps/tauri/commit/fc30b20bea125f647db00ca824663f8e1da4d61f) ([#11726](https://www.github.com/tauri-apps/tauri/pull/11726) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Add `TrayIcon.setShowMenuOnLeftClick` method and deprecate `TrayIcon.setMenuOnLeftClick` to match the Rust API. +- [`fc30b20be`](https://www.github.com/tauri-apps/tauri/commit/fc30b20bea125f647db00ca824663f8e1da4d61f) ([#11726](https://www.github.com/tauri-apps/tauri/pull/11726) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Add `TrayIconOptions.showMenuOnLeftClick` field and deprecate `TrayIconOptions.menuOnLeftClick` to match the Rust API. + +### Enhancements + +- [`fc30b20be`](https://www.github.com/tauri-apps/tauri/commit/fc30b20bea125f647db00ca824663f8e1da4d61f) ([#11726](https://www.github.com/tauri-apps/tauri/pull/11726) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Add support for `TrayIconOptions.menuOnLeftClick` option and `TrayIcon.setMenuOnLeftClick` on Windows. + +### Bug Fixes + +- [`a16796a55`](https://www.github.com/tauri-apps/tauri/commit/a16796a55592cf5be80043edfbb630dd2e32efab) ([#12069](https://www.github.com/tauri-apps/tauri/pull/12069) by [@Legend-Master](https://www.github.com/tauri-apps/tauri/../../Legend-Master)) Fix `Channel` never calls `onmessage` in some cases +- [`12a48d1e2`](https://www.github.com/tauri-apps/tauri/commit/12a48d1e26a83c3915eaa0687b196fbc8f2d457a) ([#11741](https://www.github.com/tauri-apps/tauri/pull/11741) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Fix error when calling `PredefinedMenuItem.new` to create an `About` menu item that uses an `Image` instance for the about icon. +- [`12a48d1e2`](https://www.github.com/tauri-apps/tauri/commit/12a48d1e26a83c3915eaa0687b196fbc8f2d457a) ([#11741](https://www.github.com/tauri-apps/tauri/pull/11741) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Fix error when calling `IconMenuItem.new` using an `Image` instance for the icon. +- [`b63262cd4`](https://www.github.com/tauri-apps/tauri/commit/b63262cd4d6a3667ca1664607a0a5444ad79fe0e) ([#11724](https://www.github.com/tauri-apps/tauri/pull/11724) by [@FabianLars](https://www.github.com/tauri-apps/tauri/../../FabianLars)) Removed the generic in the type of the callback function argument in `mockIPC` which prevented its proper use in tests using TypeScript. +- [`a6e84f7d2`](https://www.github.com/tauri-apps/tauri/commit/a6e84f7d2c1d5fdc65901fce683502be3f47833f) ([#11835](https://www.github.com/tauri-apps/tauri/pull/11835) by [@ilittlebig](https://www.github.com/tauri-apps/tauri/../../ilittlebig)) Fix error where using `isAbsolute` would return `Command not found`. + +## \[2.1.1] + +### Bug Fixes + +- [`7f81f0523`](https://www.github.com/tauri-apps/tauri/commit/7f81f052365675721312aafba297a7b67fb872d2) Fix regression in `toLogical` and `toPhysical` for position types in `dpi` module returning incorrect `y` value. +- [`e8a50f6d7`](https://www.github.com/tauri-apps/tauri/commit/e8a50f6d760fad4529e7abb400302a1b487f11dd) ([#11645](https://www.github.com/tauri-apps/tauri/pull/11645)) Fix integer values of `BasDirectory.Home` and `BaseDirectory.Font` regression which broke path APIs in JS. + +## \[2.1.0] + +### New Features + +- [`5c4b83084`](https://www.github.com/tauri-apps/tauri/commit/5c4b830843ab085f8ff9db9e08d832223b027e4e) ([#11191](https://www.github.com/tauri-apps/tauri/pull/11191) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Improved support for `dpi` module types to allow these types to be used without manual conversions with `invoke`: + + - Added `SERIALIZE_TO_IPC_FN` const in `core` module which can be used to implement custom IPC serialization for types passed to `invoke`. + - Added `Size` and `Position` classes in `dpi` module. + - Implementd `SERIALIZE_TO_IPC_FN` method on `PhysicalSize`, `PhysicalPosition`, `LogicalSize` and `LogicalPosition` to convert it into a valid IPC-compatible value that can be deserialized correctly on the Rust side into its equivalent struct. +- [`4d545ab3c`](https://www.github.com/tauri-apps/tauri/commit/4d545ab3ca228c8a21b966b709f84a0da2864479) ([#11486](https://www.github.com/tauri-apps/tauri/pull/11486) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Added `Webview::setBackgroundColor`, `WebviewWindow::setBackgroundColor` APIs to set the window background color dynamically + and a `backgroundColor` window option to set the background color on window creation. +- [`cbc095ec5`](https://www.github.com/tauri-apps/tauri/commit/cbc095ec5fe7de29b5c9265576d4e071ec159c1c) ([#11451](https://www.github.com/tauri-apps/tauri/pull/11451) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Add `app > windows > devtools` config option and when creating the webview from JS, to enable or disable devtools for a specific webview. +- [`2a75c64b5`](https://www.github.com/tauri-apps/tauri/commit/2a75c64b5431284e7340e8743d4ea56a62c75466) ([#11469](https://www.github.com/tauri-apps/tauri/pull/11469) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Added `windowClassname` option, when constructing a `Webview` or `WebviewWindow`, to specify the name of the window class on Windows. + +### Bug Fixes + +- [`54cbf59b5`](https://www.github.com/tauri-apps/tauri/commit/54cbf59b5a572570a47237a3b5e6505f2a9e5d5d) ([#11441](https://www.github.com/tauri-apps/tauri/pull/11441) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Fix submenu created as a menu item instead of a submenu when created by using an object in the `items` field in the options object passed to `Menu.new` or `Submenu.new`. + +## \[2.0.3] + +### Bug Fixes + +- [`fbb45c674`](https://www.github.com/tauri-apps/tauri/commit/fbb45c674ca92fbbe04f1a8360e5f2e477dd4297) ([#11423](https://www.github.com/tauri-apps/tauri/pull/11423) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fixes `addPluginListener` not working. + +### What's Changed + +- [`2e88633ba`](https://www.github.com/tauri-apps/tauri/commit/2e88633ba4da8fc289c6d8a29c36f3327f9b576e) ([#11369](https://www.github.com/tauri-apps/tauri/pull/11369) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Remove references to no longer used `__TAURI_INTERNALS__.metadata.windows` and `__TAURI_INTERNALS__.metadata.webviews`. + +## \[2.0.2] + +### What's Changed + +- [`e968b3d25`](https://www.github.com/tauri-apps/tauri/commit/e968b3d2527b8edf7653e6cf7284dc4a8889b5fe) ([#11219](https://www.github.com/tauri-apps/tauri/pull/11219) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Actually publish package with the latest tag. + +## \[2.0.1] + +### What's Changed + +- [`be683e2ac`](https://www.github.com/tauri-apps/tauri/commit/be683e2ac36df9c51a5c050d9d500247bd019090) ([#11199](https://www.github.com/tauri-apps/tauri/pull/11199) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Publish package with the latest NPM tag. + +## \[2.0.0] + +### What's Changed + +- [`637285790`](https://www.github.com/tauri-apps/tauri/commit/6372857905ae9c0aedb7f482ddf6cf9f9836c9f2) Promote to v2 stable! + +## \[2.0.0-rc.6] + +### New Features + +- [`9014a3f17`](https://www.github.com/tauri-apps/tauri/commit/9014a3f1765ca406ea5c3e5224267a79c52cd53d) ([#11066](https://www.github.com/tauri-apps/tauri/pull/11066) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Add `WebviewWindow.clearAllBrowsingData` and `Webview.clearAllBrowsingData` to clear the webview browsing data. +- [`95df53a2e`](https://www.github.com/tauri-apps/tauri/commit/95df53a2ed96873cd35a4b14a5e312d07e4e3004) ([#11143](https://www.github.com/tauri-apps/tauri/pull/11143) by [@Legend-Master](https://www.github.com/tauri-apps/tauri/../../Legend-Master)) Add the ability to set theme dynamically using `Window.setTheme` or `setTheme` function from the `app` module +- [`d9d2502b4`](https://www.github.com/tauri-apps/tauri/commit/d9d2502b41e39efde679e30c8955006e2ba9ea64) ([#11140](https://www.github.com/tauri-apps/tauri/pull/11140) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Add `Webview.hide` and `Webview.show` methods. +- [`de7414aab`](https://www.github.com/tauri-apps/tauri/commit/de7414aab935e45540594ea930eb60bae4dbc979) ([#11154](https://www.github.com/tauri-apps/tauri/pull/11154) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Add `Window::setEnabled` and `Window::isEnabled` methods + +### Bug Fixes + +- [`948772a65`](https://www.github.com/tauri-apps/tauri/commit/948772a657eb3caf20843628abac9109e3b67d41) ([#11114](https://www.github.com/tauri-apps/tauri/pull/11114) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Change the `button_state` tray event field to camelCase `buttonState`. + +### Breaking Changes + +- [`0b4495996`](https://www.github.com/tauri-apps/tauri/commit/0b4495996d3131a5ee80fbb2c71a28203e491ee7) ([#11121](https://www.github.com/tauri-apps/tauri/pull/11121) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Simplified emitted tray event JS value and updated `TrayIconEvent` type definition to match it. + +## \[2.0.0-rc.5] + +### New Features + +- [`ddf69157b`](https://www.github.com/tauri-apps/tauri/commit/ddf69157b54249f3321ca72db6703812019f1ab9) ([#11031](https://www.github.com/tauri-apps/tauri/pull/11031) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Add `toPhysical` method on `LogicalPositon` and `LogicalSize` classes. + +## \[2.0.0-rc.4] + +### Enhancements + +- [`f81929e25`](https://www.github.com/tauri-apps/tauri/commit/f81929e25104aa1091e464bd012c80649dedf9e5) ([#10799](https://www.github.com/tauri-apps/tauri/pull/10799) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Added `PermissionState`, `checkPermissions` and `requestPermissions` base APIs to the core module, designed for plugin authors to extend. + +### Bug Fixes + +- [`fbe76a955`](https://www.github.com/tauri-apps/tauri/commit/fbe76a955a63af9fb33f66d5f747caf858cf179b) ([#10797](https://www.github.com/tauri-apps/tauri/pull/10797) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Uint8Arrays and ArrayBuffers are now properly serialized as an array of numbers. + +## \[2.0.0-rc.3] + +### What's Changed + +- [`f4d5241b3`](https://www.github.com/tauri-apps/tauri/commit/f4d5241b377d0f7a1b58100ee19f7843384634ac) ([#10731](https://www.github.com/tauri-apps/tauri/pull/10731) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Update documentation icon path. + +## \[2.0.0-rc.2] + +### Bug Fixes + +- [`c689521a7`](https://www.github.com/tauri-apps/tauri/commit/c689521a7674b6562b5dfd4f5cacd12138d99d85) ([#10681](https://www.github.com/tauri-apps/tauri/pull/10681) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fix tslib path in dist. + +## \[2.0.0-rc.1] + +### Breaking Changes + +- [`b6dca99ff`](https://www.github.com/tauri-apps/tauri/commit/b6dca99fff73816a39380b288c299b47b493cfdb) ([#10630](https://www.github.com/tauri-apps/tauri/pull/10630) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Changed `WebviewWindow.getAll`, `WebviewWindow.getByLabel`, `getAllWebviewWindows`, + `Window.getAll`, `Window.getByLabel`, `getAllWindows`, + `Webview.getAll`, `Webview.getByLabel`, `getAllWebviews` + to be async so their return value are synchronized with the state from the Rust side, + meaning new and destroyed windows are reflected. + +## \[2.0.0-rc.0] + +### Changes + +- Promoted to RC! + +## \[2.0.0-beta.16] + +### New Features + +- [`da25f7353`](https://www.github.com/tauri-apps/tauri/commit/da25f7353070477ba969851e974379d7666d6806) ([#10242](https://www.github.com/tauri-apps/tauri/pull/10242) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Add APIs to enable setting window size constraints separately: + + - Added `WindowSizeConstraints` interface in `window` and `webviewWindow` modules. + - Added `Window.setSizeConstraints` and `WebviewWindow.setSizeConstraints` + +### Bug Fixes + +- [`3c17fb64f`](https://www.github.com/tauri-apps/tauri/commit/3c17fb64fd822597d5cc16ee7e7b3f9e1023637b) ([#10277](https://www.github.com/tauri-apps/tauri/pull/10277) by [@Legend-Master](https://www.github.com/tauri-apps/tauri/../../Legend-Master)) Fix `Webview.reparent` pointing to `set_webview_focus` instead of `reparent` Rust API +- [`da25f7353`](https://www.github.com/tauri-apps/tauri/commit/da25f7353070477ba969851e974379d7666d6806) ([#10242](https://www.github.com/tauri-apps/tauri/pull/10242) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Apply `minWidth`, `minHieght`, `maxWidth` and `maxHeight` constraints separately, which fixes a long standing bug where these constraints were never applied unless width and height were constrained together. + +## \[2.0.0-beta.15] + +### New Features + +- [`7bc6a2a1d`](https://www.github.com/tauri-apps/tauri/commit/7bc6a2a1d6d2c5406d91cac94d33bce76443c28f) ([#9788](https://www.github.com/tauri-apps/tauri/pull/9788) by [@pewsheen](https://www.github.com/tauri-apps/tauri/../../pewsheen)) Add a new method to set title bar style dynamically on macOS. + +### Enhancements + +- [`080b6e127`](https://www.github.com/tauri-apps/tauri/commit/080b6e12720b89d839c686d7067cc94d276ed7e4) ([#10246](https://www.github.com/tauri-apps/tauri/pull/10246) by [@Legend-Master](https://www.github.com/tauri-apps/tauri/../../Legend-Master)) Use `EventName` on `Window`, `Webview` and `WebviewWindow`'s `once` so you can get auto complete for tauri's built-in events + +### Bug Fixes + +- [`080b6e127`](https://www.github.com/tauri-apps/tauri/commit/080b6e12720b89d839c686d7067cc94d276ed7e4) ([#10246](https://www.github.com/tauri-apps/tauri/pull/10246) by [@Legend-Master](https://www.github.com/tauri-apps/tauri/../../Legend-Master)) Fix `once` doesn't detached after one callback if event handler throws + +### Breaking Changes + +- [`261c9f942`](https://www.github.com/tauri-apps/tauri/commit/261c9f942de9a598b5c6cc504de6bddd1306113b) ([#10170](https://www.github.com/tauri-apps/tauri/pull/10170) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Renamed drag and drop events in `TauriEvent` enum to better convey when they are triggered: + + - `TauriEvent.DRAG` -> `TauriEvent.DRAG_ENTER` + - `TauriEvent.DROP_OVER` -> `TauriEvent.DRAG_OVER` + - `TauriEvent.DROP` -> `TauriEvent.DRAG_DROP` + - `TauriEvent.DROP_CANCELLED` -> `TauriEvent::DRAG_LEAVE` + + Also the `type` field values in `Window/Webview/WebviewWindow.onDropEvent` and `DragDropEvent` have changed: + + - `dragged` -> `enter` + - `dragOver` -> `over` + - `dropped` -> `drop` + - `cancelled` -> `leave` +- [`2b1ceb40d`](https://www.github.com/tauri-apps/tauri/commit/2b1ceb40d345aef42dd79438fa69ca7989ee0194) ([#10229](https://www.github.com/tauri-apps/tauri/pull/10229) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Renamed the JS `getCurrent` and `getAll` functions to a clearer name to avoid ambiguity: + + - `getCurrent` in `window` module has been renamed to `getCurrentWindow` + - `getCurrent` in `webview` module has been renamed to `getCurrentWebview` + - `getCurrent` in `webviewWindow` module has been renamed to `getCurrentWebviewWindow` + - `getAll` in `window` module has been renamed to `getAllWindows` + - `getAll` in `webview` module has been renamed to `getAllWebviews` + - `getAll` in `webviewWindow` module has been renamed to `getAllWebviewWindows` + +## \[2.0.0-beta.14] + +### New Features + +- [`148f04887`](https://www.github.com/tauri-apps/tauri/commit/148f048871caee21498b236c058b8890f2b66cc7) ([#9979](https://www.github.com/tauri-apps/tauri/pull/9979)) Add `defaultWindowIcon` to the JS `app` module to retrieve the default window icon in JS. + +### Bug Fixes + +- [`c98f385cb`](https://www.github.com/tauri-apps/tauri/commit/c98f385cb5da4d72968df24b1fc0b58212d59653) ([#10044](https://www.github.com/tauri-apps/tauri/pull/10044)) Export `mocks` module in `@tauri-apps/api` npm package. + +## \[2.0.0-beta.13] + +### Breaking Changes + +- [`c4410daa8`](https://www.github.com/tauri-apps/tauri/commit/c4410daa85616340e911c8243fdaa69e6906fd49)([#9777](https://www.github.com/tauri-apps/tauri/pull/9777)) This release contains breaking changes to the tray event structure because of newly added events: + + - Changed `TrayIconEvent` to be an enum instead of a struct. + - Added `MouseButtonState` and `MouseButton` enums. + - Removed `ClickType` enum and replaced it with `MouseButton` enum. + - Added `MouseButtonState` enum. + +## \[2.0.0-beta.12] + +### New Features + +- [`ec0e092ec`](https://www.github.com/tauri-apps/tauri/commit/ec0e092ecd23b547c756c7476f23a0d95be6db80)([#9770](https://www.github.com/tauri-apps/tauri/pull/9770)) Add `monitorFromPoint` function in `window` module to get the monitor from a given point. + +## \[2.0.0-beta.11] + +### Bug Fixes + +- [`aa080696e`](https://www.github.com/tauri-apps/tauri/commit/aa080696e0952abff416dd9088d519eaf2587a3a)([#9618](https://www.github.com/tauri-apps/tauri/pull/9618)) Fix `isTauri` incorrect return type. + +## \[2.0.0-beta.10] + +### New Features + +- [`477bb8cd4`](https://www.github.com/tauri-apps/tauri/commit/477bb8cd4ea88ade3f6c1f268ad1701a68150161)([#9297](https://www.github.com/tauri-apps/tauri/pull/9297)) Add `cursorPosition` function in `window` module to get the current cursor position. + +## \[2.0.0-beta.9] + +### New Features + +- [`70c51371e`](https://www.github.com/tauri-apps/tauri/commit/70c51371e01184223312de3dba8030394a5a9406)([#9539](https://www.github.com/tauri-apps/tauri/pull/9539)) Add `isTauri` function in `core` module to check whether running inside tauri or not. + +### Bug Fixes + +- [`be7eab209`](https://www.github.com/tauri-apps/tauri/commit/be7eab209c60c45e140f7bcb4bab1037d62d4c03)([#9486](https://www.github.com/tauri-apps/tauri/pull/9486)) Set the `exports > types` package.json field. +- [`cf615e8e4`](https://www.github.com/tauri-apps/tauri/commit/cf615e8e4d5008ee1ac3f77e530ba26fb91e8977)([#9463](https://www.github.com/tauri-apps/tauri/pull/9463)) Fixes a bug when processing channel messages out of order. +- [`35b25f7e5`](https://www.github.com/tauri-apps/tauri/commit/35b25f7e5c0fe03af4ed3582e22a626863f035f0)([#9530](https://www.github.com/tauri-apps/tauri/pull/9530)) Do not use JS optional chaining to prevent script errors on older webviews such as macOS 10.14. + +## \[2.0.0-beta.8] + +### New Features + +- [`58a7a552d`](https://www.github.com/tauri-apps/tauri/commit/58a7a552d739b77b71d61af11c53f7f2dc7a6e7e)([#9378](https://www.github.com/tauri-apps/tauri/pull/9378)) Added the `set_zoom` function to the webview API. +- [`58a7a552d`](https://www.github.com/tauri-apps/tauri/commit/58a7a552d739b77b71d61af11c53f7f2dc7a6e7e)([#9378](https://www.github.com/tauri-apps/tauri/pull/9378)) Add `zoom_hotkeys_enabled` to enable browser native zoom controls on creating webviews. + +### Bug Fixes + +- [`48a7a78f8`](https://www.github.com/tauri-apps/tauri/commit/48a7a78f8094d08e5e403e88050391642d29151b)([#9376](https://www.github.com/tauri-apps/tauri/pull/9376)) Fix `Window/Webview/WebviewWindow.setSize`, `Window/Webview/WebviewWindow.setPostion`, `Window/WebviewWindow.setMinSize`, `Window/WebviewWindow.setMaxSize`, `Window/WebviewWindow.setCursorPosition` and `Menu/Submenu.popup` methods failing with invalid args. + +## \[2.0.0-beta.7] + +### Bug Fixes + +- [`c33f6e6cf`](https://www.github.com/tauri-apps/tauri/commit/c33f6e6cf35a0d34b5598875a2e5b642a01c8b38)([#9211](https://www.github.com/tauri-apps/tauri/pull/9211)) Re-added the `TauriEvent.WINDOW_CREATED` (`tauri://window-created`) event. + +### Breaking Changes + +- [`06833f4fa`](https://www.github.com/tauri-apps/tauri/commit/06833f4fa8e63ecc55fe3fc874a9e397e77a5709)([#9100](https://www.github.com/tauri-apps/tauri/pull/9100)) Rename `FileDrop` to `DragDrop` on structs, enums and enum variants. Also renamed `file_drop` to `drag_drop` on fields and function names. + +## \[2.0.0-beta.6] + +### New Features + +- [`acdd76833`](https://www.github.com/tauri-apps/tauri/commit/acdd76833db6d81f4012418133d0042220de100b)([#9155](https://www.github.com/tauri-apps/tauri/pull/9155)) Add `TrayIcon.getById` and `TrayIcon.removeById` static methods. + +### Enhancements + +- [`ea0242db4`](https://www.github.com/tauri-apps/tauri/commit/ea0242db4aa6c127d2bb4a2e275000ba47c9e68c)([#9179](https://www.github.com/tauri-apps/tauri/pull/9179)) The `Image` constructor is now public (for internal use only). + +### Bug Fixes + +- [`379cc2b35`](https://www.github.com/tauri-apps/tauri/commit/379cc2b3547395474d4b66b4222679cf4538428d)([#9165](https://www.github.com/tauri-apps/tauri/pull/9165)) Fix `basename(path, 'ext')` JS API when removing all occurances of `ext` where it should only remove the last one. + +### Breaking Changes + +- [`ea0242db4`](https://www.github.com/tauri-apps/tauri/commit/ea0242db4aa6c127d2bb4a2e275000ba47c9e68c)([#9179](https://www.github.com/tauri-apps/tauri/pull/9179)) `Image::rgba()` now returns `Promise`. +- [`ea0242db4`](https://www.github.com/tauri-apps/tauri/commit/ea0242db4aa6c127d2bb4a2e275000ba47c9e68c)([#9179](https://www.github.com/tauri-apps/tauri/pull/9179)) Removed `width` and `height` methods on the JS `Image` class, use `size` instead. + +## \[2.0.0-beta.5] + +### Breaking Changes + +- [`db0a24a97`](https://www.github.com/tauri-apps/tauri/commit/db0a24a973191752aeecfbd556faa254b0f17e79)([#9132](https://www.github.com/tauri-apps/tauri/pull/9132)) Remove the `Image.fromPngBytes` and `Image.fromIcoBytes` APIs. Use `Image.fromBytes` instead. + +## \[2.0.0-beta.4] + +### New Features + +- [`d1e77acd8`](https://www.github.com/tauri-apps/tauri/commit/d1e77acd8dfdf554b90b542513a58a2de1ef2360)([#9011](https://www.github.com/tauri-apps/tauri/pull/9011)) Add a new `Image` type in Rust and JS. + +### Enhancements + +- [`e62ca4ee9`](https://www.github.com/tauri-apps/tauri/commit/e62ca4ee95f4308a6ad128d0f100c85634e28223)([#9070](https://www.github.com/tauri-apps/tauri/pull/9070)) Added a mechanism to preserve channel message order. + +## \[2.0.0-beta.3] + +### New Features + +- [`fdcaf935`](https://www.github.com/tauri-apps/tauri/commit/fdcaf935fa75ecfa2806939c4faad4fe9e880386)([#8939](https://www.github.com/tauri-apps/tauri/pull/8939)) Added the `reparent` function to the webview API. + +## \[2.0.0-beta.2] + +### Breaking Changes + +- [`361ec37f`](https://www.github.com/tauri-apps/tauri/commit/361ec37fd4a5caa5b6630b9563ef079f53c6c336)([#8932](https://www.github.com/tauri-apps/tauri/pull/8932)) Removed the `unityUri` option from the progress bar state, no longer required. + +## \[2.0.0-beta.1] + +### New Features + +- [`16e550ec`](https://www.github.com/tauri-apps/tauri/commit/16e550ec1503765158cdc3bb2a20e70ec710e981)([#8844](https://www.github.com/tauri-apps/tauri/pull/8844)) Add a new `webviewWindow` module that exports `WebviewWindow` class and related methods such as `getCurrent` and `getAll`. +- [`16e550ec`](https://www.github.com/tauri-apps/tauri/commit/16e550ec1503765158cdc3bb2a20e70ec710e981)([#8844](https://www.github.com/tauri-apps/tauri/pull/8844)) Add `Window.onFileDropEvent` method. + +### Breaking Changes + +- [`16e550ec`](https://www.github.com/tauri-apps/tauri/commit/16e550ec1503765158cdc3bb2a20e70ec710e981)([#8844](https://www.github.com/tauri-apps/tauri/pull/8844)) Renamed the following enum variants of `TauriEvent` enum: + + - `TauriEvent.WEBVIEW_FILE_DROP` -> `TauriEvent.FILE_DROP` + - `TauriEvent.WEBVIEW_FILE_DROP_HOVER` -> `TauriEvent.FILE_DROP_HOVER` + - `TauriEvent.WEBVIEW_FILE_DROP_CANCELLED` -> `TauriEvent.FILE_DROP_CANCELLED` +- [`16e550ec`](https://www.github.com/tauri-apps/tauri/commit/16e550ec1503765158cdc3bb2a20e70ec710e981)([#8844](https://www.github.com/tauri-apps/tauri/pull/8844)) Move `WebviewWindow` class from `webview` module to a new `webviewWindow` module. + +## \[2.0.0-beta.0] + +### New Features + +- [`74a2a603`](https://www.github.com/tauri-apps/tauri/commit/74a2a6036a5e57462f161d728cbd8a6f121028ca)([#8661](https://www.github.com/tauri-apps/tauri/pull/8661)) Implement access control list for IPC usage. +- [`a093682d`](https://www.github.com/tauri-apps/tauri/commit/a093682d2df7169b024bb4f736c7f1fd2ea8b327)([#8621](https://www.github.com/tauri-apps/tauri/pull/8621)) Added `emitTo` api to `event` module which is equivalent to the rust `emit_to` method. Also added `emitTo` method on `Window`, `Webivew` and `WebviewWindow` classes. +- [`a2fc3a63`](https://www.github.com/tauri-apps/tauri/commit/a2fc3a63579ca739646d696870cbecbb3a169d33)([#8657](https://www.github.com/tauri-apps/tauri/pull/8657)) Add `visibleOnAllWorkspaces` option when creating the window in JS and `Window.setVisibleOnAllWorkspaces` method. +- [`7f033f6d`](https://www.github.com/tauri-apps/tauri/commit/7f033f6dcd54c69a4193765a5c1584755ba92c61)([#8537](https://www.github.com/tauri-apps/tauri/pull/8537)) Add `Window.startResizeDragging`. +- [`9eaeb5a8`](https://www.github.com/tauri-apps/tauri/commit/9eaeb5a8cd95ae24b5e66205bdc2763cb7f965ce)([#8622](https://www.github.com/tauri-apps/tauri/pull/8622)) Add `parent` option when creating a window. +- [`af610232`](https://www.github.com/tauri-apps/tauri/commit/af6102327376884364b2075b468bdf08ee0d02aa)([#8710](https://www.github.com/tauri-apps/tauri/pull/8710)) Added `Window::destroy` to force close a window. +- [`c77b4032`](https://www.github.com/tauri-apps/tauri/commit/c77b40324ea9bf580871fc11aed69ba0c9b6b8cf)([#8280](https://www.github.com/tauri-apps/tauri/pull/8280)) Added support to multiwebview via the new `window` and `webview` modules. + +### Breaking Changes + +- [`c77b4032`](https://www.github.com/tauri-apps/tauri/commit/c77b40324ea9bf580871fc11aed69ba0c9b6b8cf)([#8280](https://www.github.com/tauri-apps/tauri/pull/8280)) Removed event callback's `windowLabel`. +- [`c77b4032`](https://www.github.com/tauri-apps/tauri/commit/c77b40324ea9bf580871fc11aed69ba0c9b6b8cf)([#8280](https://www.github.com/tauri-apps/tauri/pull/8280)) The event target is now an object so you can target either a window or a webview. +- [`c77b4032`](https://www.github.com/tauri-apps/tauri/commit/c77b40324ea9bf580871fc11aed69ba0c9b6b8cf)([#8280](https://www.github.com/tauri-apps/tauri/pull/8280)) Moved webview-specific APIs from the `Window` class to the `Webview` class. +- [`c77b4032`](https://www.github.com/tauri-apps/tauri/commit/c77b40324ea9bf580871fc11aed69ba0c9b6b8cf)([#8280](https://www.github.com/tauri-apps/tauri/pull/8280)) Renamed `TauriEvent.WINDOW_FILE_DROP` to `TauriEvent.WEBVIEW_FILE_DROP`, `TauriEvent.WINDOW_FILE_DROP_HOVER` to `TauriEvent.WEBVIEW_FILE_DROP_HOVER` and `TauriEvent.WINDOW_FILE_DROP_CANCELLED` to `TauriEvent.WEBVIEW_FILE_DROP_CANCELLED`. +- [`c77b4032`](https://www.github.com/tauri-apps/tauri/commit/c77b40324ea9bf580871fc11aed69ba0c9b6b8cf)([#8280](https://www.github.com/tauri-apps/tauri/pull/8280)) Added back the `WebviewWindow` API that exposes functionality of a window that hosts a single webview. The dedicated `Window` and `Webview` types are exposed for multiwebview features. +- [`af610232`](https://www.github.com/tauri-apps/tauri/commit/af6102327376884364b2075b468bdf08ee0d02aa)([#8710](https://www.github.com/tauri-apps/tauri/pull/8710)) `Window::close` now triggers a close requested event instead of forcing the window to be closed. + +## \[2.0.0-alpha.14] + +- [`97e33412`](https://www.github.com/tauri-apps/tauri/commit/97e334129956159bbd60e1c531b6acd3bc6139a6)([#8534](https://www.github.com/tauri-apps/tauri/pull/8534)) `mockIPC` and `mockWindows` no longer crash if `window.__TAURI_INTERNALS__` is undefined. + +## \[2.0.0-alpha.13] + +### New Features + +- [`428ea652`](https://www.github.com/tauri-apps/tauri/commit/428ea6524c70545be33aac96d7c22b21f25caa4c)([#8370](https://www.github.com/tauri-apps/tauri/pull/8370)) Exposed `Resource` class which should be extended for Rust-backed resources created through `tauri::Manager::resources_table`. + +### Bug Fixes + +- [`ef21b681`](https://www.github.com/tauri-apps/tauri/commit/ef21b681e237a80592c9118b9c023c1d57231bac)([#8391](https://www.github.com/tauri-apps/tauri/pull/8391)) Fix a regression where typescript could not find types when using `"moduleResolution": "node"` +- [`46451aee`](https://www.github.com/tauri-apps/tauri/commit/46451aee1318f63a6cd861a12b63929b38c64eb6)([#8268](https://www.github.com/tauri-apps/tauri/pull/8268)) Add top-level `main`, `module` and `types` fields in `package.json` to be compliant with typescripts's `"moduleResolution": "node"` + +### Breaking Changes + +- [`c2ad4d28`](https://www.github.com/tauri-apps/tauri/commit/c2ad4d28c481b2d7ed643458db56210cd44a2e0c)([#8273](https://www.github.com/tauri-apps/tauri/pull/8273)) Changed former `tauri` module from `primitives` to `core`. + +## \[2.0.0-alpha.12] + +### New Features + +- [`f93148ea`](https://www.github.com/tauri-apps/tauri/commit/f93148eac05a1428e038bd9351a8149b2464ff4c)([#7709](https://www.github.com/tauri-apps/tauri/pull/7709)) Add `tray` and `menu` modules to create and manage tray icons and menus from Javascript. + +### Enhancements + +- [`b7add750`](https://www.github.com/tauri-apps/tauri/commit/b7add750ef9f32d959de613ab35063ff240281c2)([#8204](https://www.github.com/tauri-apps/tauri/pull/8204)) Added `position` field to the `FileDropEvent` payload. + +## \[2.0.0-alpha.11] + +### Bug Fixes + +- [`822bf15d`](https://www.github.com/tauri-apps/tauri/commit/822bf15d6b258556b689ca55ac2ac224897e913a)([#8130](https://www.github.com/tauri-apps/tauri/pull/8130)) Fix tslib missing in the distributed api package. + +## \[2.0.0-alpha.10] + +### Enhancements + +- [`c6c59cf2`](https://www.github.com/tauri-apps/tauri/commit/c6c59cf2373258b626b00a26f4de4331765dd487) Pull changes from Tauri 1.5 release. + +### Bug Fixes + +- [`287066b2`](https://www.github.com/tauri-apps/tauri/commit/287066b279f503dd09bfd43d5da37d1f471451fb)([#8071](https://www.github.com/tauri-apps/tauri/pull/8071)) No longer crashing in tests without mocks when `clearMocks` is defined in `afterEach` hook. + +## \[2.0.0-alpha.9] + +### New Features + +- [`c1ec0f15`](https://www.github.com/tauri-apps/tauri/commit/c1ec0f155118527361dd5645d920becbc8afd569)([#7933](https://www.github.com/tauri-apps/tauri/pull/7933)) Added `setAlwaysOnBottom` function on `Window` and the `alwaysOnBottom` option when creating a window. +- [`fb10b879`](https://www.github.com/tauri-apps/tauri/commit/fb10b87970a43320ef4d14564f45e7579b774eaf)([#8039](https://www.github.com/tauri-apps/tauri/pull/8039)) Add the `app` module back. +- [`ed32257d`](https://www.github.com/tauri-apps/tauri/commit/ed32257d044f90b5eb15053efd1667125def2d2b)([#7794](https://www.github.com/tauri-apps/tauri/pull/7794)) On Windows, add `Effect.Tabbed`,`Effect.TabbedDark` and `Effect.TabbedLight` effects. +- [`c9a9246c`](https://www.github.com/tauri-apps/tauri/commit/c9a9246c37bdf190661355c8ee406dac6c427344)([#8007](https://www.github.com/tauri-apps/tauri/pull/8007)) Add the `window` module back. +- [`c085adda`](https://www.github.com/tauri-apps/tauri/commit/c085addab58ba851398373c6fd13f9cb026d71e8)([#8009](https://www.github.com/tauri-apps/tauri/pull/8009)) Added the `setProgressBar` API on the `Window` class. + +### What's Changed + +- [`5c0eeb40`](https://www.github.com/tauri-apps/tauri/commit/5c0eeb40c1003583290ff3aebfa02e2b5f5b9c41)([#7638](https://www.github.com/tauri-apps/tauri/pull/7638)) Updated minimum Node.js version to 18. + +### Breaking Changes + +- [`a63e71f9`](https://www.github.com/tauri-apps/tauri/commit/a63e71f9799e9bbc82521d2f17b5238fbf690e89)([#7942](https://www.github.com/tauri-apps/tauri/pull/7942)) Changed `tauri` module to `primitives` and removed the undocumented `invoke` export from the root module. + +## \[2.0.0-alpha.8] + +### Breaking Changes + +- [`d5074af5`](https://www.github.com/tauri-apps/tauri/commit/d5074af562b2b5cb6c5711442097c4058af32db6)([#7801](https://www.github.com/tauri-apps/tauri/pull/7801)) The custom protocol on Android now uses the `http` scheme instead of `https`. + +## \[2.0.0-alpha.7] + +### Breaking Changes + +- [`4cb51a2d`](https://www.github.com/tauri-apps/tauri/commit/4cb51a2d56cfcae0749062c79ede5236bd8c02c2)([#7779](https://www.github.com/tauri-apps/tauri/pull/7779)) The custom protocol on Windows now uses the `http` scheme instead of `https`. + +## \[2.0.0-alpha.6] + +### New Features + +- [`4af5c5a8`](https://www.github.com/tauri-apps/tauri/commit/4af5c5a8293263c16f8a65e8d232f2de52f41701)([#7170](https://www.github.com/tauri-apps/tauri/pull/7170)) Change the IPC call to align with the new format for the custom protocol based API. + +## \[2.0.0-alpha.5] + +### New Features + +- [`e0f0dce2`](https://www.github.com/tauri-apps/tauri/commit/e0f0dce220730e2822fc202463aedf0166145de7)([#6442](https://www.github.com/tauri-apps/tauri/pull/6442)) Added the `windowEffects` option when creating a window and `setWindowEffects` method to change it at runtime. + +### Enhancements + +- [`9e3a18e0`](https://www.github.com/tauri-apps/tauri/commit/9e3a18e04672edad15d0ec654bd8632544871967)([#7132](https://www.github.com/tauri-apps/tauri/pull/7132)) Expose the window target option on event APIs. +- [`6d3f3138`](https://www.github.com/tauri-apps/tauri/commit/6d3f3138b9e2f41cda712c7d9caba0f0e65dfd3c)([#7160](https://www.github.com/tauri-apps/tauri/pull/7160)) Changed `sep` and `delimiter` from `path` module into functions to fix import in frameworks like `next.js` +- [`4652c446`](https://www.github.com/tauri-apps/tauri/commit/4652c446b361a801252bcf45e9da39813bf85482)([#7144](https://www.github.com/tauri-apps/tauri/pull/7144)) Add `tempDir` function to `path` module + +## \[2.0.0-alpha.4] + +- [`0ab5f40d`](https://www.github.com/tauri-apps/tauri/commit/0ab5f40d3a4207f20e4440587b41c4e78f91d233)([#6813](https://www.github.com/tauri-apps/tauri/pull/6813)) Add channel API for sending data across the IPC. +- [`3245d14b`](https://www.github.com/tauri-apps/tauri/commit/3245d14b9eb256a5c5675c7030bac7082855df47)([#6895](https://www.github.com/tauri-apps/tauri/pull/6895)) Moved the `app` feature to its own plugin in the plugins-workspace repository. +- [`09376af5`](https://www.github.com/tauri-apps/tauri/commit/09376af59424cc27803fa2820d2ac0d4cdc90a6d)([#6704](https://www.github.com/tauri-apps/tauri/pull/6704)) Moved the `cli` feature to its own plugin in the plugins-workspace repository. +- [`2d5378bf`](https://www.github.com/tauri-apps/tauri/commit/2d5378bfc1ba817ee2f331b41738a90e5997e5e8)([#6717](https://www.github.com/tauri-apps/tauri/pull/6717)) Moved the dialog APIs to its own plugin in the plugins-workspace repository. +- [`39f1b04f`](https://www.github.com/tauri-apps/tauri/commit/39f1b04f7be4966488484829cd54c8ce72a04200)([#6943](https://www.github.com/tauri-apps/tauri/pull/6943)) Moved the `event` JS APIs to a plugin. +- [`fc4d687e`](https://www.github.com/tauri-apps/tauri/commit/fc4d687ef0ef2ea069ed73c40916da733b5dcb8f)([#6716](https://www.github.com/tauri-apps/tauri/pull/6716)) Moved the file system APIs to its own plugin in the plugins-workspace repository. +- [`f78a3783`](https://www.github.com/tauri-apps/tauri/commit/f78a378344bbec48533641661d865920a8f46f8f)([#6742](https://www.github.com/tauri-apps/tauri/pull/6742)) Moved the `http` feature to its own plugin in the plugins-workspace repository. +- [`29ce9ce2`](https://www.github.com/tauri-apps/tauri/commit/29ce9ce2ce7dfb260d556d5cffd075e8fe06660c)([#6902](https://www.github.com/tauri-apps/tauri/pull/6902)) Moved the `os` feature to its own plugin in the plugins-workspace repository. +- [`60cf9ed2`](https://www.github.com/tauri-apps/tauri/commit/60cf9ed2fcd7be4df41e86cf18735efe9b6cb254)([#6905](https://www.github.com/tauri-apps/tauri/pull/6905)) Moved the `process` feature to its own plugin in the plugins-workspace repository. +- [`96639ca2`](https://www.github.com/tauri-apps/tauri/commit/96639ca239c9e4f75142fc07868ac46822111cff)([#6749](https://www.github.com/tauri-apps/tauri/pull/6749)) Moved the `shell` functionality to its own plugin in the plugins-workspace repository. +- [`b072daa3`](https://www.github.com/tauri-apps/tauri/commit/b072daa3bd3e38b808466666619ddb885052c5b2)([#6919](https://www.github.com/tauri-apps/tauri/pull/6919)) Moved the `updater` feature to its own plugin in the plugins-workspace repository. +- [`cebd7526`](https://www.github.com/tauri-apps/tauri/commit/cebd75261ac71b98976314a450cb292eeeec1515)([#6728](https://www.github.com/tauri-apps/tauri/pull/6728)) Moved the `clipboard` feature to its own plugin in the plugins-workspace repository. +- [`3f17ee82`](https://www.github.com/tauri-apps/tauri/commit/3f17ee82f6ff21108806edb7b00500b8512b8dc7)([#6737](https://www.github.com/tauri-apps/tauri/pull/6737)) Moved the `global-shortcut` feature to its own plugin in the plugins-workspace repository. +- [`9a79dc08`](https://www.github.com/tauri-apps/tauri/commit/9a79dc085870e0c1a5df13481ff271b8c6cc3b78)([#6947](https://www.github.com/tauri-apps/tauri/pull/6947)) Moved the `window` JS APIs to its own plugin in the plugins-workspace repository. + +## \[2.0.0-alpha.3] + +- Overload the dialog `open` function to have better TS result types. + - [1eacd51d](https://www.github.com/tauri-apps/tauri/commit/1eacd51d185ba69a3c3cb2cc93c792e2d5929843) overloaded the open function for convenient type inference ([#5619](https://www.github.com/tauri-apps/tauri/pull/5619)) on 2023-04-07 + +## \[2.0.0-alpha.2] + +- Added `raw` encoding option to read stdout and stderr raw bytes. + - [f992e7f5](https://www.github.com/tauri-apps/tauri/commit/f992e7f58bf975c654a3daf36780b31a32bac064) chore(changes): readd change file on 2023-04-03 +- Removed shell's `Command` constructor and added the `Command.create` static function instead. + - [509d4678](https://www.github.com/tauri-apps/tauri/commit/509d4678b12816c1dd08a9a5efa71ba556d91c27) Support sending raw byte data to the "data" event for child command's stdout and stderr ([#5789](https://www.github.com/tauri-apps/tauri/pull/5789)) on 2023-03-31 + +## \[2.0.0-alpha.1] + +- Added the `shadow` option when creating a window and `setShadow` function. + - [a81750d7](https://www.github.com/tauri-apps/tauri/commit/a81750d779bc72f0fdb7de90b7fbddfd8049b328) feat(core): add shadow APIs ([#6206](https://www.github.com/tauri-apps/tauri/pull/6206)) on 2023-02-08 + +## \[2.0.0-alpha.0] + +- First mobile alpha release! + - [fa3a1098](https://www.github.com/tauri-apps/tauri/commit/fa3a10988a03aed1b66fb17d893b1a9adb90f7cd) feat(ci): prepare 2.0.0-alpha.0 ([#5786](https://www.github.com/tauri-apps/tauri/pull/5786)) on 2022-12-08 + +## \[1.5.3] + +### Bug Fixes + +- [`1c582a94`](https://www.github.com/tauri-apps/tauri/commit/1c582a942e345a066b65620e4db9f688ec142bb9)([#8392](https://www.github.com/tauri-apps/tauri/pull/8392)) Fix a regression where typescript could not find types when using `"moduleResolution": "node"` + +## \[1.5.2] + +### Bug Fixes + +- [`50462702`](https://www.github.com/tauri-apps/tauri/commit/504627027303ef5a0e855aab2abea64c6964223b)([#8267](https://www.github.com/tauri-apps/tauri/pull/8267)) Add top-level `main`, `module` and `types` fields in `package.json` to be compliant with typescripts's `"moduleResolution": "node"` +- [`14544e4b`](https://www.github.com/tauri-apps/tauri/commit/14544e4b87269c06c89fed3647d80f492e0a1d34)([#8219](https://www.github.com/tauri-apps/tauri/pull/8219)) Avoid crashing in `clearMocks` + +## \[1.5.1] + +### New Features + +- [`2b0212af`](https://www.github.com/tauri-apps/tauri/commit/2b0212af49c386e52bb2357381813d6d435ec4af)([#7961](https://www.github.com/tauri-apps/tauri/pull/7961)) Add `mockConvertFileSrc` in `mocks` module, to mock `convertFileSrc` function. + +## \[1.5.0] + +### New Features + +- [`6c408b73`](https://www.github.com/tauri-apps/tauri/commit/6c408b736c7aa2a0a91f0a40d45a2b7a7dedfe78)([#7269](https://www.github.com/tauri-apps/tauri/pull/7269)) Add option to specify notification sound. + +### Enhancements + +- [`58d6b899`](https://www.github.com/tauri-apps/tauri/commit/58d6b899e21d37bb42810890d289deb57f2273bd)([#7636](https://www.github.com/tauri-apps/tauri/pull/7636)) Add `append` option to `FsOptions` in the `fs` JS module, used in `writeTextFile` and `writeBinaryFile`, to be able to append to existing files instead of overwriting it. + +### Bug Fixes + +- [`2eab1505`](https://www.github.com/tauri-apps/tauri/commit/2eab1505632ff71431d4c31c49b5afc78fa5b9dd)([#7394](https://www.github.com/tauri-apps/tauri/pull/7394)) Fix `Body.form` static not reading and sending entries of type `Blob` (including subclasses such as `File`) + +## \[1.4.0] + +### New Features + +- [`359058ce`](https://www.github.com/tauri-apps/tauri/commit/359058cecca44a9c30b65140c44a8bb3a6dd3be8)([#5939](https://www.github.com/tauri-apps/tauri/pull/5939)) Add `locale` function in the `os` module to get the system locale. +- [`c4d6fb4b`](https://www.github.com/tauri-apps/tauri/commit/c4d6fb4b1ea8acf02707a9fe5dcab47c1c5bae7b)([#2353](https://www.github.com/tauri-apps/tauri/pull/2353)) Added the `maximizable`, `minimizable` and `closable` fields on `WindowOptions`. +- [`c4d6fb4b`](https://www.github.com/tauri-apps/tauri/commit/c4d6fb4b1ea8acf02707a9fe5dcab47c1c5bae7b)([#2353](https://www.github.com/tauri-apps/tauri/pull/2353)) Added the `setMaximizable`, `setMinimizable`, `setClosable`, `isMaximizable`, `isMinimizable` and `isClosable` methods. +- [`000104bc`](https://www.github.com/tauri-apps/tauri/commit/000104bc3bc0c9ff3d20558ab9cf2080f126e9e0)([#6472](https://www.github.com/tauri-apps/tauri/pull/6472)) Add `WebviewWindow.is_focused` and `WebviewWindow.getFocusedWindow` getters. + +## \[1.3.0] + +- Return correct type for `event.payload` in `onResized` and `onMoved` window event handlers. + - [0b46637e](https://www.github.com/tauri-apps/tauri/commit/0b46637ebaba54403afa32a1cb466f09df2db999) fix(api): construct correct object for onResized and onMoved, closes [#6507](https://www.github.com/tauri-apps/tauri/pull/6507) ([#6509](https://www.github.com/tauri-apps/tauri/pull/6509)) on 2023-04-03 +- Added the `WindowOptions::contentProtected` option and `WebviewWindow#setContentProtected` to change it at runtime. + - [4ab5545b](https://www.github.com/tauri-apps/tauri/commit/4ab5545b7a831c549f3c65e74de487ede3ab7ce5) feat: add content protection api, closes [#5132](https://www.github.com/tauri-apps/tauri/pull/5132) ([#5513](https://www.github.com/tauri-apps/tauri/pull/5513)) on 2022-12-13 +- Allow setting the text of the dialog buttons. + - [00e1efaa](https://www.github.com/tauri-apps/tauri/commit/00e1efaa9b33876d41dd360624b69971e70d3856) feat: customize button texts of message dialog ([#4383](https://www.github.com/tauri-apps/tauri/pull/4383)) on 2022-12-28 +- Add `is_minimized()` window method. + - [62144ef3](https://www.github.com/tauri-apps/tauri/commit/62144ef3be63b237869e511826edfb938e2c7174) feat: add is_minimized (fix [#3878](https://www.github.com/tauri-apps/tauri/pull/3878)) ([#5618](https://www.github.com/tauri-apps/tauri/pull/5618)) on 2022-12-13 +- Add `title` getter on window. + - [233e43b0](https://www.github.com/tauri-apps/tauri/commit/233e43b0c34fada1ca025378533a0b76931a6540) feat: add `title` getter on window, closes [#5023](https://www.github.com/tauri-apps/tauri/pull/5023) ([#5515](https://www.github.com/tauri-apps/tauri/pull/5515)) on 2022-12-13 + +## \[1.2.0] + +- Added the `acceptFirstMouse` window option. + - [95f467ad](https://www.github.com/tauri-apps/tauri/commit/95f467add51448319983c54e2f382c7c09fb72d6) feat(core): add window `accept_first_mouse` option, closes [#5347](https://www.github.com/tauri-apps/tauri/pull/5347) ([#5374](https://www.github.com/tauri-apps/tauri/pull/5374)) on 2022-10-17 +- Fix incorrect return type on `fs/exists` + - [ca3cd8b3](https://www.github.com/tauri-apps/tauri/commit/ca3cd8b3d11beb9b6102da40b7d27f6dbe6cd2d0) fix(api): fs/exists return type previously set to void when it should be boolean ([#5252](https://www.github.com/tauri-apps/tauri/pull/5252)) on 2022-09-29 +- Initialize `Monitor` instances with the correct classes for `position` and `size` fields instead of plain object. + - [6f41a271](https://www.github.com/tauri-apps/tauri/commit/6f41a2712445ac41a5ed84bbcd40af3b76c8b1d8) fix(api.js): fix `Monitor` initialization, closes [#4672](https://www.github.com/tauri-apps/tauri/pull/4672) ([#5314](https://www.github.com/tauri-apps/tauri/pull/5314)) on 2022-09-30 +- **Breaking change:** Node.js v12 is no longer supported. + - [1129f4f5](https://www.github.com/tauri-apps/tauri/commit/1129f4f575dd02f746abe8e66472c88c8f9fe63d) refactor: simplify api.js bundling ([#4277](https://www.github.com/tauri-apps/tauri/pull/4277)) on 2022-10-04 +- Add new app-specific `BaseDirectory` enum variants `AppConfig`, `AppData`, `AppLocalData`, `AppCache` and `AppLog` along with equivalent functions in `path` module and deprecated ambiguous variants `Log` and `App` along with their equivalent functions in `path` module. + - [5d89905e](https://www.github.com/tauri-apps/tauri/commit/5d89905e39ce0e6eaaec50a693679335449edb32) feat(api): add app-specific directory APIs, closes [#5263](https://www.github.com/tauri-apps/tauri/pull/5263) ([#5272](https://www.github.com/tauri-apps/tauri/pull/5272)) on 2022-09-28 +- Fix `dialog.save` return type + - [8357ce5b](https://www.github.com/tauri-apps/tauri/commit/8357ce5b2efdd6f92c7944822542e48ba0e303ce) Fix dialog.save return type ([#5373](https://www.github.com/tauri-apps/tauri/pull/5373)) on 2022-10-08 +- Added support to `FormData` on the `Body.form` function. + - [aa119f28](https://www.github.com/tauri-apps/tauri/commit/aa119f28364f8ffbc64c6bcdfc77483613076a20) feat(api): add FormData support on Body.form, closes [#5545](https://www.github.com/tauri-apps/tauri/pull/5545) ([#5546](https://www.github.com/tauri-apps/tauri/pull/5546)) on 2022-11-04 +- Added `show` and `hide` methods on the `app` module. + - [39bf895b](https://www.github.com/tauri-apps/tauri/commit/39bf895b73ec6b53f5758815396ba85dda6b9c67) feat(macOS): Add application `show` and `hide` methods ([#3689](https://www.github.com/tauri-apps/tauri/pull/3689)) on 2022-10-03 +- Added `tabbingIdentifier` window option for macOS. + - [4137ab44](https://www.github.com/tauri-apps/tauri/commit/4137ab44a81d739556cbc7583485887e78952bf1) feat(macos): add `tabbing_identifier` option, closes [#2804](https://www.github.com/tauri-apps/tauri/pull/2804), [#3912](https://www.github.com/tauri-apps/tauri/pull/3912) ([#5399](https://www.github.com/tauri-apps/tauri/pull/5399)) on 2022-10-19 +- Added `tabbing_identifier` to the window builder on macOS. + - [4137ab44](https://www.github.com/tauri-apps/tauri/commit/4137ab44a81d739556cbc7583485887e78952bf1) feat(macos): add `tabbing_identifier` option, closes [#2804](https://www.github.com/tauri-apps/tauri/pull/2804), [#3912](https://www.github.com/tauri-apps/tauri/pull/3912) ([#5399](https://www.github.com/tauri-apps/tauri/pull/5399)) on 2022-10-19 +- Added the `user_agent` option when creating a window. + - [a6c94119](https://www.github.com/tauri-apps/tauri/commit/a6c94119d8545d509723b147c273ca5edfe3729f) feat(core): expose user_agent to window config ([#5317](https://www.github.com/tauri-apps/tauri/pull/5317)) on 2022-10-02 + +## \[1.1.0] + +- Update `mockIPC()` handler signature to allow async handler functions. + - [4fa968dc](https://www.github.com/tauri-apps/tauri/commit/4fa968dc0e74b5206bfcd54e704d180c16b67b08) fix(api): add async `mockIPC()` handler signature ([#5056](https://www.github.com/tauri-apps/tauri/pull/5056)) on 2022-08-26 +- Improve shell's `Command`, `Command.stdout` and `Command.stderr` events with new `once`, `off`, `listenerCount`, `prependListener`, `prependOnceListener` and `removeAllListeners` functions. + - [aa9f1243](https://www.github.com/tauri-apps/tauri/commit/aa9f1243e6c1629972a82e469f20c8399741740e) Improved EventEmitter for tauri api shell ([#4697](https://www.github.com/tauri-apps/tauri/pull/4697)) on 2022-07-26 +- Added the `encoding` option to the `Command` options. + - [d8cf9f9f](https://www.github.com/tauri-apps/tauri/commit/d8cf9f9fcd617ac24fa418952fd4a32c08804f5c) Command support for specified character encoding, closes [#4644](https://www.github.com/tauri-apps/tauri/pull/4644) ([#4772](https://www.github.com/tauri-apps/tauri/pull/4772)) on 2022-07-28 +- Add `exists` function to the fs module. + - [3c62dbc9](https://www.github.com/tauri-apps/tauri/commit/3c62dbc902c904d35a7472ce72a969084c95fbbe) feat(api): Add `exists` function to the fs module. ([#5060](https://www.github.com/tauri-apps/tauri/pull/5060)) on 2022-09-15 + +## \[1.0.2] + +- Added helper functions to listen to updater and window events. + - [b02fc90f](https://www.github.com/tauri-apps/tauri/commit/b02fc90f450ff9e9d8a35ee55dc1beced4957869) feat(api): add abstractions to updater and window event listeners ([#4569](https://www.github.com/tauri-apps/tauri/pull/4569)) on 2022-07-05 +- Add support to `ArrayBuffer` in `Body.bytes` and `writeBinaryFile`. + - [92aca55a](https://www.github.com/tauri-apps/tauri/commit/92aca55a6f1f899d5c0c3a6aae9ac9cb0a7e9a86) feat(api): add support to ArrayBuffer ([#4579](https://www.github.com/tauri-apps/tauri/pull/4579)) on 2022-07-05 +- Use `toString()` on message/confirm/ask dialogs title and message values. + - [b8cd2a79](https://www.github.com/tauri-apps/tauri/commit/b8cd2a7993cd2aa5b71b30c545b3307245d254bf) feat(api): call `toString()` on dialog title and message, closes [#4583](https://www.github.com/tauri-apps/tauri/pull/4583) ([#4588](https://www.github.com/tauri-apps/tauri/pull/4588)) on 2022-07-04 +- Remove the `type-fest` dependency, changing the OS types to the specific enum instead of allowing any string. + - [d5e910eb](https://www.github.com/tauri-apps/tauri/commit/d5e910ebcc6c8d7f055ab0691286722b140ffcd4) chore(api): remove `type-fest` ([#4605](https://www.github.com/tauri-apps/tauri/pull/4605)) on 2022-07-06 + +## \[1.0.1] + +- Fixes the `writeBinaryFile` sending an empty file contents when only the first argument is passed. + - [ea43cf52](https://www.github.com/tauri-apps/tauri/commit/ea43cf52db8541d20a6397ef3ecd40f0f2bd6113) fix(api): `writeBinaryFile` sends an empty contents with only one arg ([#4368](https://www.github.com/tauri-apps/tauri/pull/4368)) on 2022-06-16 + +## \[1.0.0] + +- Allow choosing multiple folders in `dialog.open`. + - [4e51dce6](https://www.github.com/tauri-apps/tauri/commit/4e51dce6ca21c7664de779bc78a04be1051371f7) fix: dialog open supports multiple dirs, fixes [#4091](https://www.github.com/tauri-apps/tauri/pull/4091) ([#4354](https://www.github.com/tauri-apps/tauri/pull/4354)) on 2022-06-15 +- Upgrade to `stable`! + - [f4bb30cc](https://www.github.com/tauri-apps/tauri/commit/f4bb30cc73d6ba9b9ef19ef004dc5e8e6bb901d3) feat(covector): prepare for v1 ([#4351](https://www.github.com/tauri-apps/tauri/pull/4351)) on 2022-06-15 + +## \[1.0.0-rc.7] + +- Fix `FilePart` usage in `http.Body.form` by renaming the `value` property to `file`. + - [55f89d5f](https://www.github.com/tauri-apps/tauri/commit/55f89d5f9d429252ad3fd557b1d6233b256495e0) fix(api): Rename FormPart `value` to `file` to match docs and endpoint ([#4307](https://www.github.com/tauri-apps/tauri/pull/4307)) on 2022-06-09 +- Fixes a memory leak in the command system. + - [f72cace3](https://www.github.com/tauri-apps/tauri/commit/f72cace36821dc675a6d25268ae85a21bdbd6296) fix: never remove ipc callback & mem never be released ([#4274](https://www.github.com/tauri-apps/tauri/pull/4274)) on 2022-06-05 +- The notification's `isPermissionGranted` function now returns `boolean` instead of `boolean | null`. The response is never `null` because we won't check the permission for now, always returning `true` instead. + - [f482b094](https://www.github.com/tauri-apps/tauri/commit/f482b0942276e9402ab3725957535039bacb4fef) fix: remove notification permission prompt ([#4302](https://www.github.com/tauri-apps/tauri/pull/4302)) on 2022-06-09 +- Added the `resolveResource` API to the path module. + - [7bba8db8](https://www.github.com/tauri-apps/tauri/commit/7bba8db83ead92e9bd9c4be7863742e71ac47513) feat(api): add `resolveResource` API to the path module ([#4234](https://www.github.com/tauri-apps/tauri/pull/4234)) on 2022-05-29 +- Renamed `writeFile` to `writeTextFile` but kept the original function for backwards compatibility. + - [3f998ca2](https://www.github.com/tauri-apps/tauri/commit/3f998ca29445a349489078a74dd068e157a4d68e) feat(api): add `writeTextFile` and `(path, contents, options)` overload ([#4228](https://www.github.com/tauri-apps/tauri/pull/4228)) on 2022-05-29 +- Added `(path, contents[, options])` overload to the `writeTextFile` and `writeBinaryFile` APIs. + - [3f998ca2](https://www.github.com/tauri-apps/tauri/commit/3f998ca29445a349489078a74dd068e157a4d68e) feat(api): add `writeTextFile` and `(path, contents, options)` overload ([#4228](https://www.github.com/tauri-apps/tauri/pull/4228)) on 2022-05-29 + +## \[1.0.0-rc.6] + +- Expose option to set the dialog type. + - [f46175d5](https://www.github.com/tauri-apps/tauri/commit/f46175d5d46fa3eae66ad2415a0eb1efb7d31da2) feat(core): expose option to set dialog type, closes [#4183](https://www.github.com/tauri-apps/tauri/pull/4183) ([#4187](https://www.github.com/tauri-apps/tauri/pull/4187)) on 2022-05-21 +- Expose `title` option in the message dialog API. + - [ae99f991](https://www.github.com/tauri-apps/tauri/commit/ae99f991674d77c322a2240d10ed4b78ed2f4d4b) feat(core): expose message dialog's title option, ref [#4183](https://www.github.com/tauri-apps/tauri/pull/4183) ([#4186](https://www.github.com/tauri-apps/tauri/pull/4186)) on 2022-05-21 + +## \[1.0.0-rc.5] + +- Fixes the type of `http > connectTimeout`. + - [f3c5ca89](https://www.github.com/tauri-apps/tauri/commit/f3c5ca89e79d429183c4e15a9e7cebada2b493a0) fix(core): http api `connect_timeout` deserialization, closes [#4004](https://www.github.com/tauri-apps/tauri/pull/4004) ([#4006](https://www.github.com/tauri-apps/tauri/pull/4006)) on 2022-04-29 + +## \[1.0.0-rc.4] + +- Encode the file path in the `convertFileSrc` function. + - [42e8d9cf](https://www.github.com/tauri-apps/tauri/commit/42e8d9cf925089e9ad591198ee04b0cc0a0eed48) fix(api): encode file path in `convertFileSrc` function, closes [#3841](https://www.github.com/tauri-apps/tauri/pull/3841) ([#3846](https://www.github.com/tauri-apps/tauri/pull/3846)) on 2022-04-02 +- Added `theme` getter to `WebviewWindow`. + - [4cebcf6d](https://www.github.com/tauri-apps/tauri/commit/4cebcf6da7cad1953e0f01b426afac3b5ef1f81e) feat: expose theme APIs, closes [#3903](https://www.github.com/tauri-apps/tauri/pull/3903) ([#3937](https://www.github.com/tauri-apps/tauri/pull/3937)) on 2022-04-21 +- Added `theme` field to `WindowOptions`. + - [4cebcf6d](https://www.github.com/tauri-apps/tauri/commit/4cebcf6da7cad1953e0f01b426afac3b5ef1f81e) feat: expose theme APIs, closes [#3903](https://www.github.com/tauri-apps/tauri/pull/3903) ([#3937](https://www.github.com/tauri-apps/tauri/pull/3937)) on 2022-04-21 +- Added the `setCursorGrab`, `setCursorVisible`, `setCursorIcon` and `setCursorPosition` methods to the `WebviewWindow` class. + - [c54ddfe9](https://www.github.com/tauri-apps/tauri/commit/c54ddfe9338e7eb90b4d5b02dfde687d432d5bc1) feat: expose window cursor APIs, closes [#3888](https://www.github.com/tauri-apps/tauri/pull/3888) [#3890](https://www.github.com/tauri-apps/tauri/pull/3890) ([#3935](https://www.github.com/tauri-apps/tauri/pull/3935)) on 2022-04-21 +- **Breaking change:** The process Command API stdio lines now includes the trailing `\r`. + - [b5622882](https://www.github.com/tauri-apps/tauri/commit/b5622882cf3748e1e5a90915f415c0cd922aaaf8) fix(cli): exit on non-compilation Cargo errors, closes [#3930](https://www.github.com/tauri-apps/tauri/pull/3930) ([#3942](https://www.github.com/tauri-apps/tauri/pull/3942)) on 2022-04-22 +- Added the `tauri://theme-changed` event. + - [4cebcf6d](https://www.github.com/tauri-apps/tauri/commit/4cebcf6da7cad1953e0f01b426afac3b5ef1f81e) feat: expose theme APIs, closes [#3903](https://www.github.com/tauri-apps/tauri/pull/3903) ([#3937](https://www.github.com/tauri-apps/tauri/pull/3937)) on 2022-04-21 + +## \[1.0.0-rc.3] + +- Properly define the `appWindow` type. + - [1deeb03e](https://www.github.com/tauri-apps/tauri/commit/1deeb03ef6c7cbea8cf585864424a3d66f184a02) fix(api.js): appWindow shown as type `any`, fixes [#3747](https://www.github.com/tauri-apps/tauri/pull/3747) ([#3772](https://www.github.com/tauri-apps/tauri/pull/3772)) on 2022-03-24 +- Added `Temp` to the `BaseDirectory` enum. + - [266156a0](https://www.github.com/tauri-apps/tauri/commit/266156a0b08150b21140dd552c8bc252fe413cdd) feat(core): add `BaseDirectory::Temp` and `$TEMP` variable ([#3763](https://www.github.com/tauri-apps/tauri/pull/3763)) on 2022-03-24 + +## \[1.0.0-rc.2] + +- Do not crash if `__TAURI_METADATA__` is not set, log an error instead. + - [9cb1059a](https://www.github.com/tauri-apps/tauri/commit/9cb1059aa3f81521ccc6da655243acfe0327cd98) fix(api): do not throw an exception if **TAURI_METADATA** is not set, fixes [#3554](https://www.github.com/tauri-apps/tauri/pull/3554) ([#3572](https://www.github.com/tauri-apps/tauri/pull/3572)) on 2022-03-03 +- Reimplement endpoint to read file as string for performance. + - [834ccc51](https://www.github.com/tauri-apps/tauri/commit/834ccc51539401d36a7dfa1c0982623c9c446a4c) feat(core): reimplement `readTextFile` for performance ([#3631](https://www.github.com/tauri-apps/tauri/pull/3631)) on 2022-03-07 +- Fixes a regression on the `unlisten` command. + - [76c791bd](https://www.github.com/tauri-apps/tauri/commit/76c791bd2b836d2055410e37e71716172a3f81ef) fix(core): regression on the unlisten function ([#3623](https://www.github.com/tauri-apps/tauri/pull/3623)) on 2022-03-06 + +## \[1.0.0-rc.1] + +- Provide functions to mock IPC calls during testing and static site generation. + - [7e04c072](https://www.github.com/tauri-apps/tauri/commit/7e04c072c4ee2278c648f44575c6c4710ac047f3) feat: add mock functions for testing and SSG ([#3437](https://www.github.com/tauri-apps/tauri/pull/3437)) on 2022-02-14 + - [6f5ed2e6](https://www.github.com/tauri-apps/tauri/commit/6f5ed2e69cb7ffa0d5c8eb5a744fbf94ed6010d4) fix: change file on 2022-02-14 + +## \[1.0.0-rc.0] + +- Add `fileDropEnabled` property to `WindowOptions` so you can now disable it when creating windows from js. + + - [1bfc32a3](https://www.github.com/tauri-apps/tauri/commit/1bfc32a3b2f31b962ce8a5c611b60cb008360923) fix(api.js): add `fileDropEnabled` to `WindowOptions`, closes [#2968](https://www.github.com/tauri-apps/tauri/pull/2968) ([#2989](https://www.github.com/tauri-apps/tauri/pull/2989)) on 2021-12-09 + +- Add `logDir` function to the `path` module to access the suggested log directory. + Add `BaseDirectory.Log` to the `fs` module. + + - [acbb3ae7](https://www.github.com/tauri-apps/tauri/commit/acbb3ae7bb0165846b9456aea103269f027fc548) feat: add Log directory ([#2736](https://www.github.com/tauri-apps/tauri/pull/2736)) on 2021-10-16 + - [62c7a8ad](https://www.github.com/tauri-apps/tauri/commit/62c7a8ad30fd3031b8679960590e5ef3eef8e4da) chore(covector): prepare for `rc` release ([#3376](https://www.github.com/tauri-apps/tauri/pull/3376)) on 2022-02-10 + +- Expose `ask`, `message` and `confirm` APIs on the dialog module. + + - [e98c1af4](https://www.github.com/tauri-apps/tauri/commit/e98c1af44279a5ff6c8a6f0a506ecc219c9f77af) feat(core): expose message dialog APIs, fix window.confirm, implement HasRawWindowHandle for Window, closes [#2535](https://www.github.com/tauri-apps/tauri/pull/2535) ([#2700](https://www.github.com/tauri-apps/tauri/pull/2700)) on 2021-10-02 + +- Event `emit` now automatically serialize non-string types. + + - [06000996](https://www.github.com/tauri-apps/tauri/commit/060009969627890fa9018e2f1105bad13299394c) feat(api): support unknown types for event emit payload, closes [#2929](https://www.github.com/tauri-apps/tauri/pull/2929) ([#2964](https://www.github.com/tauri-apps/tauri/pull/2964)) on 2022-01-07 + +- Fix `http.fetch` throwing error if the response is successful but the body is empty. + + - [50c63900](https://www.github.com/tauri-apps/tauri/commit/50c63900c7313064037e2ceb798a6432fcd1bcda) fix(api.js): fix `http.fetch` throwing error if response body is empty, closes [#2831](https://www.github.com/tauri-apps/tauri/pull/2831) ([#3008](https://www.github.com/tauri-apps/tauri/pull/3008)) on 2021-12-09 + +- Add `title` option to file open/save dialogs. + + - [e1d6a6e6](https://www.github.com/tauri-apps/tauri/commit/e1d6a6e6445637723e2331ca799a662e720e15a8) Create api-file-dialog-title.md ([#3235](https://www.github.com/tauri-apps/tauri/pull/3235)) on 2022-01-16 + - [62c7a8ad](https://www.github.com/tauri-apps/tauri/commit/62c7a8ad30fd3031b8679960590e5ef3eef8e4da) chore(covector): prepare for `rc` release ([#3376](https://www.github.com/tauri-apps/tauri/pull/3376)) on 2022-02-10 + +- Fix `os.platform` returning `macos` and `windows` instead of `darwin` and `win32`. + + - [3924c3d8](https://www.github.com/tauri-apps/tauri/commit/3924c3d85365df30b376a1ec6c2d933460d66af0) fix(api.js): fix `os.platform` return on macos and windows, closes [#2698](https://www.github.com/tauri-apps/tauri/pull/2698) ([#2699](https://www.github.com/tauri-apps/tauri/pull/2699)) on 2021-10-02 + +- The `formatCallback` helper function now returns a number instead of a string. + + - [a48b8b18](https://www.github.com/tauri-apps/tauri/commit/a48b8b18d428bcc404d489daa690bbefe1f57311) feat(core): validate callbacks and event names \[TRI-038] \[TRI-020] ([#21](https://www.github.com/tauri-apps/tauri/pull/21)) on 2022-01-09 + +- Added `rawHeaders` to `http > Response`. + + - [b7a2345b](https://www.github.com/tauri-apps/tauri/commit/b7a2345b06ca0306988b4ba3d3deadd449e65af9) feat(core): add raw headers to HTTP API, closes [#2695](https://www.github.com/tauri-apps/tauri/pull/2695) ([#3053](https://www.github.com/tauri-apps/tauri/pull/3053)) on 2022-01-07 + +- Removed the `currentDir` API from the `path` module. + + - [a08509c6](https://www.github.com/tauri-apps/tauri/commit/a08509c641f43695e25944a2dd47697b18cd83e2) fix(api): remove `currentDir` API from the `path` module on 2022-02-04 + +- Remove `.ts` files on the published package. + + - [0f321ac0](https://www.github.com/tauri-apps/tauri/commit/0f321ac08d56412edd5bc9d166201fbc95d887d8) fix(api): do not ship TS files, closes [#2598](https://www.github.com/tauri-apps/tauri/pull/2598) ([#2645](https://www.github.com/tauri-apps/tauri/pull/2645)) on 2021-09-23 + +- **Breaking change:** Replaces all usages of `number[]` with `Uint8Array` to be closer aligned with the wider JS ecosystem. + + - [9b19a805](https://www.github.com/tauri-apps/tauri/commit/9b19a805aa8efa64b22f2dfef193a144b8e0cee3) fix(api.js) Replace `number[]`with `Uint8Array`. fixes [#3306](https://www.github.com/tauri-apps/tauri/pull/3306) ([#3305](https://www.github.com/tauri-apps/tauri/pull/3305)) on 2022-02-05 + +- `WindowManager` methods `innerPosition` `outerPosition` now correctly return instance of `PhysicalPosition`. + `WindowManager` methods `innerSize` `outerSize` now correctly return instance of `PhysicalSize`. + + - [cc8b1468](https://www.github.com/tauri-apps/tauri/commit/cc8b1468c821df53ceb771061c919409a9c80978) Fix(api): Window size and position returning wrong class (fix: [#2599](https://www.github.com/tauri-apps/tauri/pull/2599)) ([#2621](https://www.github.com/tauri-apps/tauri/pull/2621)) on 2021-09-22 + +- Change the `event` field of the `Event` interface to type `EventName` instead of `string`. + + - [b5d9bcb4](https://www.github.com/tauri-apps/tauri/commit/b5d9bcb402380abc86ae1fa1a77c629af2275f9d) Consistent event name usage ([#3228](https://www.github.com/tauri-apps/tauri/pull/3228)) on 2022-01-15 + - [62c7a8ad](https://www.github.com/tauri-apps/tauri/commit/62c7a8ad30fd3031b8679960590e5ef3eef8e4da) chore(covector): prepare for `rc` release ([#3376](https://www.github.com/tauri-apps/tauri/pull/3376)) on 2022-02-10 + +- Now `resolve()`, `join()` and `normalize()` from the `path` module, won't throw errors if the path doesn't exist, which matches NodeJS behavior. + + - [fe381a0b](https://www.github.com/tauri-apps/tauri/commit/fe381a0bde86ebf4014007f6e21af4c1a9e58cef) fix: `join` no longer cares if path doesn't exist, closes [#2499](https://www.github.com/tauri-apps/tauri/pull/2499) ([#2548](https://www.github.com/tauri-apps/tauri/pull/2548)) on 2021-09-21 + +- Fixes the dialog `defaultPath` usage on Linux. + + - [2212bd5d](https://www.github.com/tauri-apps/tauri/commit/2212bd5d75146f5a2df27cc2157a057642f626da) fix: dialog default path on Linux, closes [#3091](https://www.github.com/tauri-apps/tauri/pull/3091) ([#3123](https://www.github.com/tauri-apps/tauri/pull/3123)) on 2021-12-27 + +- Fixes `window.label` property returning null instead of the actual label. + + - [f5109e0c](https://www.github.com/tauri-apps/tauri/commit/f5109e0c962e3d25404995194968bade1be33b16) fix(api): window label null instead of actual value, closes [#3295](https://www.github.com/tauri-apps/tauri/pull/3295) ([#3332](https://www.github.com/tauri-apps/tauri/pull/3332)) on 2022-02-04 + +- Remove the `BaseDirectory::Current` enum variant for security reasons. + + - [696dca58](https://www.github.com/tauri-apps/tauri/commit/696dca58a9f8ee127a1cf857eb848e09f5845d18) refactor(core): remove `BaseDirectory::Current` variant on 2022-01-26 + +- Change `WindowLabel` type to `string`. + + - [f68603ae](https://www.github.com/tauri-apps/tauri/commit/f68603aee4e16500dff9e385b217f5dd8b1b39e8) chore(docs): simplify event system documentation on 2021-09-27 + +- When building Universal macOS Binaries through the virtual target `universal-apple-darwin`: + +- Expect a universal binary to be created by the user + +- Ensure that binary is bundled and accessed correctly at runtime + +- [3035e458](https://www.github.com/tauri-apps/tauri/commit/3035e4581c161ec7f0bd6d9b42e9015cf1dd1d77) Remove target triple from sidecar bin paths, closes [#3355](https://www.github.com/tauri-apps/tauri/pull/3355) ([#3356](https://www.github.com/tauri-apps/tauri/pull/3356)) on 2022-02-07 + +## \[1.0.0-beta.8] + +- Revert target back to ES5. + - [657c7dac](https://www.github.com/tauri-apps/tauri/commit/657c7dac734661956b87d021ff531ba530dd92a3) fix(api): revert ES2021 target on 2021-08-23 + +## \[1.0.0-beta.7] + +- Fix missing asset protocol path.Now the protocol is `https://asset.localhost/path/to/file` on Windows. Linux and macOS + is still `asset://path/to/file`. + - [994b5325](https://www.github.com/tauri-apps/tauri/commit/994b5325dd385f564b37fe1530c5d798dc925fff) fix: missing asset protocol path ([#2484](https://www.github.com/tauri-apps/tauri/pull/2484)) on 2021-08-23 + +## \[1.0.0-beta.6] + +- `bundle` now exports `clipboard` module so you can `import { clipboard } from "@tauri-apps/api"`. + - [4f88c3fb](https://www.github.com/tauri-apps/tauri/commit/4f88c3fb94286f3daafb906e3513c9210ecfa76b) fix(api.js): `bundle` now exports `clipboard` mod, closes [#2243](https://www.github.com/tauri-apps/tauri/pull/2243) ([#2244](https://www.github.com/tauri-apps/tauri/pull/2244)) on 2021-07-19 +- Fix double window creation + - [9fbcc024](https://www.github.com/tauri-apps/tauri/commit/9fbcc024542d87f71afd364acdcf2302cf82912c) fix(api.js): fix double window creation, closes [#2284](https://www.github.com/tauri-apps/tauri/pull/2284) ([#2285](https://www.github.com/tauri-apps/tauri/pull/2285)) on 2021-07-23 +- Add `os` module which exports `EOL`, `platform()`, `version()`, `type()`, `arch()`, `tempdir()` + - [05e679a6](https://www.github.com/tauri-apps/tauri/commit/05e679a6d2aca5642c780052bcf1384c49a462de) feat(api.js): add `os` module ([#2299](https://www.github.com/tauri-apps/tauri/pull/2299)) on 2021-07-28 +- - Add new nodejs-inspired functions which are `join`, `resolve`, `normalize`, `dirname`, `basename` and `extname`. +- Add `sep` and `delimiter` constants. +- Removed `resolvePath` API, use `resolve` instead. +- [05b9d81e](https://www.github.com/tauri-apps/tauri/commit/05b9d81ee6bcc920defca76cff00178b301fffe8) feat(api.js): add nodejs-inspired functions in `path` module ([#2310](https://www.github.com/tauri-apps/tauri/pull/2310)) on 2021-08-02 +- Change target to ES2021. + - [97bc52ee](https://www.github.com/tauri-apps/tauri/commit/97bc52ee03dec0b67cc1cced23305a4c53e9eb62) Tooling: \[API] Changed target in tsconfig to es6 ([#2362](https://www.github.com/tauri-apps/tauri/pull/2362)) on 2021-08-09 +- Add `toggleMaximize()` function to the `WebviewWindow` class. + - [1a510066](https://www.github.com/tauri-apps/tauri/commit/1a510066732d5f61c88c0ceed1c5f5cc559faf7d) fix(core): `data-tauri-drag-region` didn't respect resizable, closes [#2314](https://www.github.com/tauri-apps/tauri/pull/2314) ([#2316](https://www.github.com/tauri-apps/tauri/pull/2316)) on 2021-08-02 +- Fix `@ts-expect` error usage + - [dd52e738](https://www.github.com/tauri-apps/tauri/commit/dd52e738f1fd323bd8d185d6e650f412eb031200) fix(api.js): fix `@ts-expect-error` usage, closes [#2249](https://www.github.com/tauri-apps/tauri/pull/2249) ([#2250](https://www.github.com/tauri-apps/tauri/pull/2250)) on 2021-07-20 +- Fixes file drop events being swapped (`file-drop-hover` on drop and `file-drop` on hover). + - [c2b0fe1c](https://www.github.com/tauri-apps/tauri/commit/c2b0fe1ce58e54dbcfdb63162ad17d7e6d8774d9) fix(core): fix wrong file drop events ([#2300](https://www.github.com/tauri-apps/tauri/pull/2300)) on 2021-07-31 +- Fixes the global bundle UMD code. + - [268450b1](https://www.github.com/tauri-apps/tauri/commit/268450b1329a4b55f2043890c565a8563f890c3a) fix(api): global bundle broken code, closes [#2289](https://www.github.com/tauri-apps/tauri/pull/2289) ([#2297](https://www.github.com/tauri-apps/tauri/pull/2297)) on 2021-07-26 +- - Fixes monitor api not working. +- Fixes window.print() not working on macOS. +- [0f63f5e7](https://www.github.com/tauri-apps/tauri/commit/0f63f5e757873f1787a1ae07ca531340d0d45ec3) fix(api): Fix monitor functions, closes [#2294](https://www.github.com/tauri-apps/tauri/pull/2294) ([#2301](https://www.github.com/tauri-apps/tauri/pull/2301)) on 2021-07-29 +- Improve `EventName` type using `type-fest`'s `LiteralUnion`. + - [8e480297](https://www.github.com/tauri-apps/tauri/commit/8e48029790857b38988da4d291aa7458f51bb265) feat(api): improve `EventName` type definition ([#2379](https://www.github.com/tauri-apps/tauri/pull/2379)) on 2021-08-10 +- Update protocol url path with wry 0.12.1 on Windows. + - [88382fe1](https://www.github.com/tauri-apps/tauri/commit/88382fe147ebcb3f59308cc529e5562a04970876) chore(api): update protocol url path with wry 0.12.1 on Windows ([#2409](https://www.github.com/tauri-apps/tauri/pull/2409)) on 2021-08-13 + +## \[1.0.0-beta.5] + +- Adds `convertFileSrc` helper to the `tauri` module, simplifying the process of using file paths as webview source (`img`, `video`, etc). + - [51a5cfe4](https://www.github.com/tauri-apps/tauri/commit/51a5cfe4b5e9890fb6f639c9c929657fd747a595) feat(api): add `convertFileSrc` helper ([#2138](https://www.github.com/tauri-apps/tauri/pull/2138)) on 2021-07-02 +- You can now use `emit`, `listen` and `once` using the `appWindow` exported by the window module. + - [5d7626f8](https://www.github.com/tauri-apps/tauri/commit/5d7626f89781a6ebccceb9ab3b2e8335aa7a0392) feat(api): WindowManager extends WebviewWindowHandle, add events docs ([#2146](https://www.github.com/tauri-apps/tauri/pull/2146)) on 2021-07-03 +- Allow manipulating a spawned window directly using `WebviewWindow`, which now extends `WindowManager`. + - [d69b1cf6](https://www.github.com/tauri-apps/tauri/commit/d69b1cf6d7c13297073073d753e30fe1a22a09cb) feat(api): allow managing windows created on JS ([#2154](https://www.github.com/tauri-apps/tauri/pull/2154)) on 2021-07-05 + +## \[1.0.0-beta.4] + +- Add asset custom protocol to access local file system. + - [ee60e424](https://www.github.com/tauri-apps/tauri/commit/ee60e424221559d3d725716b0003c5566ef2b5cd) feat: asset custom protocol to access local file system ([#2104](https://www.github.com/tauri-apps/tauri/pull/2104)) on 2021-06-28 + +## \[1.0.0-beta.3] + +- Export `Response` and `ResponseType` as value instead of type. + - [394b6e05](https://www.github.com/tauri-apps/tauri/commit/394b6e0572e7a0a92e103e462a7f603f7d569319) fix(api): http `ResponseType` export type error ([#2065](https://www.github.com/tauri-apps/tauri/pull/2065)) on 2021-06-24 + +## \[1.0.0-beta.2] + +- Export `BaseDirectory` in `path` module + - [277f5ca5](https://www.github.com/tauri-apps/tauri/commit/277f5ca5a8ae227bbdccee1ad52bdd88b4a5b11b) feat(api): export `BaseDirectory` in `path` module ([#1885](https://www.github.com/tauri-apps/tauri/pull/1885)) on 2021-05-30 +- Use `export type` to export TS types, enums and interfaces. + - [9a662d26](https://www.github.com/tauri-apps/tauri/commit/9a662d2601b01d712c6bd205f8db1b674f56dfa7) fix: Monitor if --isolatedModules is enabled ([#1825](https://www.github.com/tauri-apps/tauri/pull/1825)) on 2021-05-13 + - [612cd8ec](https://www.github.com/tauri-apps/tauri/commit/612cd8ecb8e02954f3696b9e138cbc7d2c228fad) feat(api): finalize `export type` usage ([#1847](https://www.github.com/tauri-apps/tauri/pull/1847)) on 2021-05-17 +- Adds `focus?: boolean` to the WindowOptions interface. + - [5f351622](https://www.github.com/tauri-apps/tauri/commit/5f351622c7812ad1bb56ddb37364ccaa4124c24b) feat(core): add focus API to the WindowBuilder and WindowOptions, [#1737](https://www.github.com/tauri-apps/tauri/pull/1737) on 2021-05-30 +- Adds `isDecorated` getter on the window API. + - [f58a2114](https://www.github.com/tauri-apps/tauri/commit/f58a2114fbfd5307c349f05c88f2e08fd8baa8aa) feat(core): add `is_decorated` Window getter on 2021-05-30 +- Adds `isResizable` getter on the window API. + - [1e8af280](https://www.github.com/tauri-apps/tauri/commit/1e8af280c27f381828d6209722b10e889082fa00) feat(core): add `is_resizable` Window getter on 2021-05-30 +- Adds `isVisible` getter on the window API. + - [36506c96](https://www.github.com/tauri-apps/tauri/commit/36506c967de82bc7ff453d11e6104ecf66d7a588) feat(core): add `is_visible` API on 2021-05-30 +- Adds `requestUserAttention` API to the `window` module. + - [7dcca6e9](https://www.github.com/tauri-apps/tauri/commit/7dcca6e9281182b11ad3d4a79871f09b30b9b419) feat(core): add `request_user_attention` API, closes [#2023](https://www.github.com/tauri-apps/tauri/pull/2023) ([#2026](https://www.github.com/tauri-apps/tauri/pull/2026)) on 2021-06-20 +- Adds `setFocus` to the window API. + - [bb6992f8](https://www.github.com/tauri-apps/tauri/commit/bb6992f888196ca7c87bb2fe74ad2bd8bf393e05) feat(core): add `set_focus` window API, fixes [#1737](https://www.github.com/tauri-apps/tauri/pull/1737) on 2021-05-30 +- Adds `setSkipTaskbar` to the window API. + - [e06aa277](https://www.github.com/tauri-apps/tauri/commit/e06aa277384450cfef617c0e57b0d5d403bb1e7f) feat(core): add `set_skip_taskbar` API on 2021-05-30 +- Adds `skipTaskbar?: boolean` to the WindowOptions interface. + - [5525b03a](https://www.github.com/tauri-apps/tauri/commit/5525b03a78a2232c650043fbd9894ce1553cad41) feat(core): add `skip_taskbar` API to the WindowBuilder/WindowOptions on 2021-05-30 +- Adds `center?: boolean` to `WindowOptions` and `center()` API to the `appWindow`. + - [5cba6eb4](https://www.github.com/tauri-apps/tauri/commit/5cba6eb4d28d53f06855d60d4d0eae6b95233ccf) feat(core): add window `center` API, closes [#1822](https://www.github.com/tauri-apps/tauri/pull/1822) ([#1954](https://www.github.com/tauri-apps/tauri/pull/1954)) on 2021-06-05 +- Adds `clipboard` APIs (write and read text). + - [285bf64b](https://www.github.com/tauri-apps/tauri/commit/285bf64bf9569efb2df904c69c6df405ff0d62e2) feat(core): add clipboard writeText and readText APIs ([#2035](https://www.github.com/tauri-apps/tauri/pull/2035)) on 2021-06-21 + - [dee71ad5](https://www.github.com/tauri-apps/tauri/commit/dee71ad58349f699995cc9077b79032bacc6afcb) fix(workflows): update docs workflow syntax ([#2054](https://www.github.com/tauri-apps/tauri/pull/2054)) on 2021-06-23 +- The `http` APIs now resolve the returned promise when the API call finishes with an error status code. + - [47f75584](https://www.github.com/tauri-apps/tauri/commit/47f7558417cc654bdb1d018127e8900bc4eac622) fix(core): resolve HTTP API on non-ok status code, fix binary response, closes [#2046](https://www.github.com/tauri-apps/tauri/pull/2046) ([#2053](https://www.github.com/tauri-apps/tauri/pull/2053)) on 2021-06-23 +- Improve RPC security by requiring a numeric code to invoke commands. The codes are generated by the Rust side and injected into the app's code using a closure, so external scripts can't access the backend. This change doesn't protect `withGlobalTauri` (`window.__TAURI__`) usage. + - [160fb052](https://www.github.com/tauri-apps/tauri/commit/160fb0529fd31d755574ae30fbdf01fa221a2acb) feat(core): improve RPC security, closes [#814](https://www.github.com/tauri-apps/tauri/pull/814) ([#2047](https://www.github.com/tauri-apps/tauri/pull/2047)) on 2021-06-22 +- Mark the `WebviewWindow` constructor as public. + - [4aeb936e](https://www.github.com/tauri-apps/tauri/commit/4aeb936e9b60b895d383597dc698ee5d638436f9) fix(api): `WebviewWindow` constructor is public ([#1888](https://www.github.com/tauri-apps/tauri/pull/1888)) on 2021-05-21 +- Validate arguments on the window `setLocation`, `setSize`, `setMinSize` and `setMaxSize` API. + - [7616e6cc](https://www.github.com/tauri-apps/tauri/commit/7616e6cc7bcd49f688b0d00fdc33c94b7b93713d) feat(api): validate window API `size` and `location` arguments ([#1846](https://www.github.com/tauri-apps/tauri/pull/1846)) on 2021-05-17 + +## \[1.0.0-beta.1] + +- Adds `package.json` to the `exports` object. + - [ab1ea96](https://www.github.com/tauri-apps/tauri/commit/ab1ea964786e1781c922582b059c555b6072f1a0) chore(api): add `package.json` to the `exports` field ([#1807](https://www.github.com/tauri-apps/tauri/pull/1807)) on 2021-05-12 + +## \[1.0.0-beta.0] + +- CommonJS chunks are now properly exported with `.cjs` extension + - [ddcd923](https://www.github.com/tauri-apps/tauri/commit/ddcd9233bd6f499aa7f22484d6c151b01778bc1b) fix(api): export commonjs chunks with `.cjs` extension, fix [#1625](https://www.github.com/tauri-apps/tauri/pull/1625) ([#1627](https://www.github.com/tauri-apps/tauri/pull/1627)) on 2021-04-26 +- Adds `transparent?: boolean` to the `WindowOptions` interface. + - [08c1c5c](https://www.github.com/tauri-apps/tauri/commit/08c1c5ca5c0ebe17ea98689a5fe3b7e47a98e955) fix(api): missing `transparent` flag on `WindowOptions` ([#1764](https://www.github.com/tauri-apps/tauri/pull/1764)) on 2021-05-10 +- Adds `options` argument to the shell command API (`env` and `cwd` configuration). + - [721e98f](https://www.github.com/tauri-apps/tauri/commit/721e98f175567b360c86f30565ab1b9d08e7cf85) feat(core): add env, cwd to the command API, closes [#1634](https://www.github.com/tauri-apps/tauri/pull/1634) ([#1635](https://www.github.com/tauri-apps/tauri/pull/1635)) on 2021-04-28 +- Adds `startDragging` API on the window module. + - [c31f097](https://www.github.com/tauri-apps/tauri/commit/c31f0978c535f794fffb75a121e69a323e70b06e) refactor: update to wry 0.9 ([#1630](https://www.github.com/tauri-apps/tauri/pull/1630)) on 2021-04-28 +- Move `exit` and `relaunch` APIs from `app` to `process` module. + - [b0bb796](https://www.github.com/tauri-apps/tauri/commit/b0bb796a42e2560233aea47ce6ced54ac238eb53) refactor: rename `command` mod to `process`, move restart_application ([#1667](https://www.github.com/tauri-apps/tauri/pull/1667)) on 2021-04-30 +- The window management API was refactored: removed `setX`, `setY`, `setWidth`, `setHeight` APIs, renamed `resize` to `setSize` and the size and position APIs now allow defining both logical and physical values. + - [6bfac86](https://www.github.com/tauri-apps/tauri/commit/6bfac866a703f1499a64237fb29b2625703f4e22) refactor(core): add window getters, physical & logical sizes/positions ([#1723](https://www.github.com/tauri-apps/tauri/pull/1723)) on 2021-05-05 +- Adds window getters. + - [6bfac86](https://www.github.com/tauri-apps/tauri/commit/6bfac866a703f1499a64237fb29b2625703f4e22) refactor(core): add window getters, physical & logical sizes/positions ([#1723](https://www.github.com/tauri-apps/tauri/pull/1723)) on 2021-05-05 + +## \[1.0.0-beta-rc.3] + +- Fixes distribution of the `@tauri-apps/api` package for older bundlers. + - [7f998d0](https://www.github.com/tauri-apps/tauri/commit/7f998d08e3ab8823c99190fa283bdfa2c4f2749b) fix(api): distribution ([#1582](https://www.github.com/tauri-apps/tauri/pull/1582)) on 2021-04-22 +- Update minimum Node.js version to v12.13.0 + - [1f089fb](https://www.github.com/tauri-apps/tauri/commit/1f089fb4f964c673dcab5784bdf1da2833487a7c) chore: update minimum nodejs version to 12.13.0 ([#1562](https://www.github.com/tauri-apps/tauri/pull/1562)) on 2021-04-21 + +## \[1.0.0-beta-rc.2] + +- TS was wrongly re-exporting the module. + - [fcb3b48](https://www.github.com/tauri-apps/tauri/commit/fcb3b4857efa17d2a3717f32457e88b24520cc9b) fix: [#1512](https://www.github.com/tauri-apps/tauri/pull/1512) ([#1517](https://www.github.com/tauri-apps/tauri/pull/1517)) on 2021-04-19 + - [ae14a3f](https://www.github.com/tauri-apps/tauri/commit/ae14a3ff51a742b6ab6f76bbfc21f385310f1dc6) fix: [#1517](https://www.github.com/tauri-apps/tauri/pull/1517) had the wrong package reference in the changefile ([#1538](https://www.github.com/tauri-apps/tauri/pull/1538)) on 2021-04-19 + +## \[1.0.0-beta-rc.1] + +- Missing the `files` property in the package.json which mean that the `dist` directory was not published and used. + - [b2569a7](https://www.github.com/tauri-apps/tauri/commit/b2569a729a3caa88bdba62abc31f0665e1323aaa) fix(js-api): dist ([#1498](https://www.github.com/tauri-apps/tauri/pull/1498)) on 2021-04-15 + +## \[1.0.0-beta-rc.0] + +- Add current working directory to the path api module. + - [52c2baf](https://www.github.com/tauri-apps/tauri/commit/52c2baf940773cf7c51647fb6f20d0f7df126115) feat: add current working directory to path api module ([#1375](https://www.github.com/tauri-apps/tauri/pull/1375)) on 2021-03-23 + - [a6def70](https://www.github.com/tauri-apps/tauri/commit/a6def7066eec19c889b0f14cc1e475bf209a332e) Refactor(tauri): move tauri-api and tauri-updater to tauri ([#1455](https://www.github.com/tauri-apps/tauri/pull/1455)) on 2021-04-11 +- The shell process spawning API was rewritten and now includes stream access. + - [3713066](https://www.github.com/tauri-apps/tauri/commit/3713066e451bd30d0cc6f57bb437f08276f4c4ad) refactor(core): rewrite shell execute API, closes [#1229](https://www.github.com/tauri-apps/tauri/pull/1229) ([#1408](https://www.github.com/tauri-apps/tauri/pull/1408)) on 2021-03-31 +- The file dialog API now uses [rfd](https://github.com/PolyMeilex/rfd). The filter option is now an array of `{ name: string, extensions: string[] }`. + - [2326bcd](https://www.github.com/tauri-apps/tauri/commit/2326bcd399411f7f0eabdb7ade910be473adadae) refactor(core): use `nfd` for file dialogs, closes [#1251](https://www.github.com/tauri-apps/tauri/pull/1251) ([#1257](https://www.github.com/tauri-apps/tauri/pull/1257)) on 2021-02-18 + - [a6def70](https://www.github.com/tauri-apps/tauri/commit/a6def7066eec19c889b0f14cc1e475bf209a332e) Refactor(tauri): move tauri-api and tauri-updater to tauri ([#1455](https://www.github.com/tauri-apps/tauri/pull/1455)) on 2021-04-11 +- The HTTP API was improved with client caching and better payload and response types. + - [a7bc472](https://www.github.com/tauri-apps/tauri/commit/a7bc472e994730071f960d09a12ac85296a080ae) refactor(core): improve HTTP API, closes [#1098](https://www.github.com/tauri-apps/tauri/pull/1098) ([#1237](https://www.github.com/tauri-apps/tauri/pull/1237)) on 2021-02-15 + - [a6def70](https://www.github.com/tauri-apps/tauri/commit/a6def7066eec19c889b0f14cc1e475bf209a332e) Refactor(tauri): move tauri-api and tauri-updater to tauri ([#1455](https://www.github.com/tauri-apps/tauri/pull/1455)) on 2021-04-11 +- Update all code files to have our license header. + - [bf82136](https://www.github.com/tauri-apps/tauri/commit/bf8213646689175f8a158b956911f3a43e360690) feat(license): SPDX Headers ([#1449](https://www.github.com/tauri-apps/tauri/pull/1449)) on 2021-04-11 + - [a6def70](https://www.github.com/tauri-apps/tauri/commit/a6def7066eec19c889b0f14cc1e475bf209a332e) Refactor(tauri): move tauri-api and tauri-updater to tauri ([#1455](https://www.github.com/tauri-apps/tauri/pull/1455)) on 2021-04-11 + - [aea6145](https://www.github.com/tauri-apps/tauri/commit/aea614587bddab930d552512b54e18624fbf573e) refactor(repo): add /tooling folder ([#1457](https://www.github.com/tauri-apps/tauri/pull/1457)) on 2021-04-12 +- Use secure RNG on callback function names. + - [c8992bb](https://www.github.com/tauri-apps/tauri/commit/c8992bb0bfb8eaeae8ebed444719f9c9372d39d4) refactor(api): use secure RNG, closes [#1356](https://www.github.com/tauri-apps/tauri/pull/1356) ([#1398](https://www.github.com/tauri-apps/tauri/pull/1398)) on 2021-03-30 +- The invoke function can now be called with the cmd as the first parameter and the args as the second. + - [427d170](https://www.github.com/tauri-apps/tauri/commit/427d170930ab711fd0ca82f7a73b524d6fdc222f) feat(api/invoke): separate cmd arg ([#1321](https://www.github.com/tauri-apps/tauri/pull/1321)) on 2021-03-04 +- Adds a global shortcut API. + - [855effa](https://www.github.com/tauri-apps/tauri/commit/855effadd9ebfb6bc1a3555ac7fc733f6f766b7a) feat(core): globalShortcut API ([#1232](https://www.github.com/tauri-apps/tauri/pull/1232)) on 2021-02-14 + - [a6def70](https://www.github.com/tauri-apps/tauri/commit/a6def7066eec19c889b0f14cc1e475bf209a332e) Refactor(tauri): move tauri-api and tauri-updater to tauri ([#1455](https://www.github.com/tauri-apps/tauri/pull/1455)) on 2021-04-11 +- Added window management and window creation APIs. + - [a3d6dff](https://www.github.com/tauri-apps/tauri/commit/a3d6dff2163c7a45842253edd81dbc62248dc65d) feat(core): window API ([#1225](https://www.github.com/tauri-apps/tauri/pull/1225)) on 2021-02-13 + - [641374b](https://www.github.com/tauri-apps/tauri/commit/641374b15343518cd835bd5ada811941c65dcf2e) feat(core): window creation at runtime ([#1249](https://www.github.com/tauri-apps/tauri/pull/1249)) on 2021-02-17 diff --git a/scripts/node_modules/@tauri-apps/api/LICENSE_APACHE-2.0 b/scripts/node_modules/@tauri-apps/api/LICENSE_APACHE-2.0 new file mode 100644 index 0000000000000000000000000000000000000000..f433b1a53f5b830a205fd2df78e2b34974656c7b --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/LICENSE_APACHE-2.0 @@ -0,0 +1,177 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS diff --git a/scripts/node_modules/@tauri-apps/api/LICENSE_MIT b/scripts/node_modules/@tauri-apps/api/LICENSE_MIT new file mode 100644 index 0000000000000000000000000000000000000000..b08530d59433b3060f4fad8751ac2610c0b0aff3 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/LICENSE_MIT @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2017 - Present Tauri Apps 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/scripts/node_modules/@tauri-apps/api/README.md b/scripts/node_modules/@tauri-apps/api/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d74ab83c7a3555cbf326b933d9e78e7d8fc30649 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/README.md @@ -0,0 +1,52 @@ +# @tauri-apps/api + + + +[![status](https://img.shields.io/badge/status-stable-blue.svg)](https://github.com/tauri-apps/tauri/tree/dev) +[![License](https://img.shields.io/badge/License-MIT%20or%20Apache%202-green.svg)](https://opencollective.com/tauri) +[![lint js](https://img.shields.io/github/actions/workflow/status/tauri-apps/tauri/lint-js.yml?label=lint%20js&logo=github)](https://github.com/tauri-apps/tauri/actions/workflows/lint-js.yml) +[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Ftauri-apps%2Ftauri.svg?type=shield)](https://app.fossa.com/projects/git%2Bgithub.com%2Ftauri-apps%2Ftauri?ref=badge_shield) +[![Chat Server](https://img.shields.io/badge/chat-discord-7289da.svg)](https://discord.gg/SpmNs4S) +[![website](https://img.shields.io/badge/website-tauri.app-purple.svg)](https://tauri.app) +[![https://good-labs.github.io/greater-good-affirmation/assets/images/badge.svg](https://good-labs.github.io/greater-good-affirmation/assets/images/badge.svg)](https://good-labs.github.io/greater-good-affirmation) +[![support](https://img.shields.io/badge/sponsor-Open%20Collective-blue.svg)](https://opencollective.com/tauri) + +| Component | Version | +| --------------- | ----------------------------------------------------- | +| @tauri-apps/api | ![](https://img.shields.io/npm/v/@tauri-apps/api.svg) | + +## About Tauri + +Tauri is a polyglot and generic system that is very composable and allows engineers to make a wide variety of applications. It is used for building applications for Desktop Computers using a combination of Rust tools and HTML rendered in a Webview. Apps built with Tauri can ship with any number of pieces of an optional JS API / Rust API so that webviews can control the system via message passing. In fact, developers can extend the default API with their own functionality and bridge the Webview and Rust-based backend easily. + +Tauri apps can have custom menus and have tray-type interfaces. They can be updated, and are managed by the user's operating system as expected. They are very small, because they use the system's webview. They do not ship a runtime, since the final binary is compiled from rust. This makes the reversing of Tauri apps not a trivial task. + +## This module + +This is a typescript library that creates `cjs` and `esm` JavaScript endpoints for you to import into your Frontend framework so that the Webview can call and listen to backend activity. We also ship the pure typescript, because for some frameworks this is more optimal. It uses the message passing of webviews to their hosts. + +To learn more about the details of how all of these pieces fit together, please consult this [ARCHITECTURE.md](https://github.com/tauri-apps/tauri/blob/dev/ARCHITECTURE.md) document. + +## Installation + +The preferred method is to install this module locally as a dependency: + +``` +$ pnpm add @tauri-apps/api +$ yarn add @tauri-apps/api +$ npm add @tauri-apps/api +``` + +## Semver + +**tauri** is following [Semantic Versioning 2.0](https://semver.org/). + +## Licenses + +Code: (c) 2019 - 2021 - The Tauri Programme within The Commons Conservancy. + +MIT or MIT/Apache 2.0 where applicable. + +Logo: CC-BY-NC-ND + +- Original Tauri Logo Designs by [Daniel Thompson-Yvetot](https://github.com/nothingismagick) and [Guillaume Chau](https://github.com/akryum) diff --git a/scripts/node_modules/@tauri-apps/api/app.cjs b/scripts/node_modules/@tauri-apps/api/app.cjs new file mode 100644 index 0000000000000000000000000000000000000000..12df98f1f803d76034dd96e403f9ca884a3d7a69 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/app.cjs @@ -0,0 +1,235 @@ +'use strict'; + +var core = require('./core.cjs'); +var image = require('./image.cjs'); + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * Bundle type of the current application. + */ +exports.BundleType = void 0; +(function (BundleType) { + /** Windows NSIS */ + BundleType["Nsis"] = "nsis"; + /** Windows MSI */ + BundleType["Msi"] = "msi"; + /** Linux Debian package */ + BundleType["Deb"] = "deb"; + /** Linux RPM */ + BundleType["Rpm"] = "rpm"; + /** Linux AppImage */ + BundleType["AppImage"] = "appimage"; + /** macOS app bundle */ + BundleType["App"] = "app"; +})(exports.BundleType || (exports.BundleType = {})); +/** + * Application metadata and related APIs. + * + * @module + */ +/** + * Gets the application version. + * @example + * ```typescript + * import { getVersion } from '@tauri-apps/api/app'; + * const appVersion = await getVersion(); + * ``` + * + * @since 1.0.0 + */ +async function getVersion() { + return core.invoke('plugin:app|version'); +} +/** + * Gets the application name. + * @example + * ```typescript + * import { getName } from '@tauri-apps/api/app'; + * const appName = await getName(); + * ``` + * + * @since 1.0.0 + */ +async function getName() { + return core.invoke('plugin:app|name'); +} +/** + * Gets the Tauri framework version used by this application. + * + * @example + * ```typescript + * import { getTauriVersion } from '@tauri-apps/api/app'; + * const tauriVersion = await getTauriVersion(); + * ``` + * + * @since 1.0.0 + */ +async function getTauriVersion() { + return core.invoke('plugin:app|tauri_version'); +} +/** + * Gets the application identifier. + * @example + * ```typescript + * import { getIdentifier } from '@tauri-apps/api/app'; + * const identifier = await getIdentifier(); + * ``` + * + * @returns The application identifier as configured in `tauri.conf.json`. + * + * @since 2.4.0 + */ +async function getIdentifier() { + return core.invoke('plugin:app|identifier'); +} +/** + * Shows the application on macOS. This function does not automatically + * focus any specific app window. + * + * @example + * ```typescript + * import { show } from '@tauri-apps/api/app'; + * await show(); + * ``` + * + * @since 1.2.0 + */ +async function show() { + return core.invoke('plugin:app|app_show'); +} +/** + * Hides the application on macOS. + * + * @example + * ```typescript + * import { hide } from '@tauri-apps/api/app'; + * await hide(); + * ``` + * + * @since 1.2.0 + */ +async function hide() { + return core.invoke('plugin:app|app_hide'); +} +/** + * Fetches the data store identifiers on macOS and iOS. + * + * See https://developer.apple.com/documentation/webkit/wkwebsitedatastore for more information. + * + * @example + * ```typescript + * import { fetchDataStoreIdentifiers } from '@tauri-apps/api/app'; + * const ids = await fetchDataStoreIdentifiers(); + * ``` + * + * @since 2.4.0 + */ +async function fetchDataStoreIdentifiers() { + return core.invoke('plugin:app|fetch_data_store_identifiers'); +} +/** + * Removes the data store with the given identifier. + * + * Note that any webview using this data store should be closed before running this API. + * + * See https://developer.apple.com/documentation/webkit/wkwebsitedatastore for more information. + * + * @example + * ```typescript + * import { fetchDataStoreIdentifiers, removeDataStore } from '@tauri-apps/api/app'; + * for (const id of (await fetchDataStoreIdentifiers())) { + * await removeDataStore(id); + * } + * ``` + * + * @since 2.4.0 + */ +async function removeDataStore(uuid) { + return core.invoke('plugin:app|remove_data_store', { uuid }); +} +/** + * Gets the default window icon. + * + * @example + * ```typescript + * import { defaultWindowIcon } from '@tauri-apps/api/app'; + * const icon = await defaultWindowIcon(); + * ``` + * + * @since 2.0.0 + */ +async function defaultWindowIcon() { + return core.invoke('plugin:app|default_window_icon').then((rid) => rid ? new image.Image(rid) : null); +} +/** + * Sets the application's theme. Pass in `null` or `undefined` to follow + * the system theme. + * + * @example + * ```typescript + * import { setTheme } from '@tauri-apps/api/app'; + * await setTheme('dark'); + * ``` + * + * #### Platform-specific + * + * - **iOS / Android:** Unsupported. + * + * @since 2.0.0 + */ +async function setTheme(theme) { + return core.invoke('plugin:app|set_app_theme', { theme }); +} +/** + * Sets the dock visibility for the application on macOS. + * + * @param visible - Whether the dock should be visible or not. + * + * @example + * ```typescript + * import { setDockVisibility } from '@tauri-apps/api/app'; + * await setDockVisibility(false); + * ``` + * + * @since 2.5.0 + */ +async function setDockVisibility(visible) { + return core.invoke('plugin:app|set_dock_visibility', { visible }); +} +/** + * Gets the application bundle type. + * + * @example + * ```typescript + * import { getBundleType } from '@tauri-apps/api/app'; + * const type = await getBundleType(); + * ``` + * + * @since 2.5.0 + */ +async function getBundleType() { + return core.invoke('plugin:app|bundle_type'); +} +/** + * Listens to the backButton event on Android. + * @param handler + */ +async function onBackButtonPress(handler) { + return core.addPluginListener('app', 'back-button', handler); +} + +exports.defaultWindowIcon = defaultWindowIcon; +exports.fetchDataStoreIdentifiers = fetchDataStoreIdentifiers; +exports.getBundleType = getBundleType; +exports.getIdentifier = getIdentifier; +exports.getName = getName; +exports.getTauriVersion = getTauriVersion; +exports.getVersion = getVersion; +exports.hide = hide; +exports.onBackButtonPress = onBackButtonPress; +exports.removeDataStore = removeDataStore; +exports.setDockVisibility = setDockVisibility; +exports.setTheme = setTheme; +exports.show = show; diff --git a/scripts/node_modules/@tauri-apps/api/app.d.ts b/scripts/node_modules/@tauri-apps/api/app.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d535727ac75e182c2c64c19f9c9f0d158e3ca85f --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/app.d.ts @@ -0,0 +1,220 @@ +import { PluginListener } from './core'; +import { Image } from './image'; +import { Theme } from './window'; +/** + * Identifier type used for data stores on macOS and iOS. + * + * Represents a 128-bit identifier, commonly expressed as a 16-byte UUID. + */ +export type DataStoreIdentifier = [ + number, + number, + number, + number, + number, + number, + number, + number, + number, + number, + number, + number, + number, + number, + number, + number +]; +/** + * Bundle type of the current application. + */ +export declare enum BundleType { + /** Windows NSIS */ + Nsis = "nsis", + /** Windows MSI */ + Msi = "msi", + /** Linux Debian package */ + Deb = "deb", + /** Linux RPM */ + Rpm = "rpm", + /** Linux AppImage */ + AppImage = "appimage", + /** macOS app bundle */ + App = "app" +} +/** + * Application metadata and related APIs. + * + * @module + */ +/** + * Gets the application version. + * @example + * ```typescript + * import { getVersion } from '@tauri-apps/api/app'; + * const appVersion = await getVersion(); + * ``` + * + * @since 1.0.0 + */ +declare function getVersion(): Promise; +/** + * Gets the application name. + * @example + * ```typescript + * import { getName } from '@tauri-apps/api/app'; + * const appName = await getName(); + * ``` + * + * @since 1.0.0 + */ +declare function getName(): Promise; +/** + * Gets the Tauri framework version used by this application. + * + * @example + * ```typescript + * import { getTauriVersion } from '@tauri-apps/api/app'; + * const tauriVersion = await getTauriVersion(); + * ``` + * + * @since 1.0.0 + */ +declare function getTauriVersion(): Promise; +/** + * Gets the application identifier. + * @example + * ```typescript + * import { getIdentifier } from '@tauri-apps/api/app'; + * const identifier = await getIdentifier(); + * ``` + * + * @returns The application identifier as configured in `tauri.conf.json`. + * + * @since 2.4.0 + */ +declare function getIdentifier(): Promise; +/** + * Shows the application on macOS. This function does not automatically + * focus any specific app window. + * + * @example + * ```typescript + * import { show } from '@tauri-apps/api/app'; + * await show(); + * ``` + * + * @since 1.2.0 + */ +declare function show(): Promise; +/** + * Hides the application on macOS. + * + * @example + * ```typescript + * import { hide } from '@tauri-apps/api/app'; + * await hide(); + * ``` + * + * @since 1.2.0 + */ +declare function hide(): Promise; +/** + * Fetches the data store identifiers on macOS and iOS. + * + * See https://developer.apple.com/documentation/webkit/wkwebsitedatastore for more information. + * + * @example + * ```typescript + * import { fetchDataStoreIdentifiers } from '@tauri-apps/api/app'; + * const ids = await fetchDataStoreIdentifiers(); + * ``` + * + * @since 2.4.0 + */ +declare function fetchDataStoreIdentifiers(): Promise; +/** + * Removes the data store with the given identifier. + * + * Note that any webview using this data store should be closed before running this API. + * + * See https://developer.apple.com/documentation/webkit/wkwebsitedatastore for more information. + * + * @example + * ```typescript + * import { fetchDataStoreIdentifiers, removeDataStore } from '@tauri-apps/api/app'; + * for (const id of (await fetchDataStoreIdentifiers())) { + * await removeDataStore(id); + * } + * ``` + * + * @since 2.4.0 + */ +declare function removeDataStore(uuid: DataStoreIdentifier): Promise; +/** + * Gets the default window icon. + * + * @example + * ```typescript + * import { defaultWindowIcon } from '@tauri-apps/api/app'; + * const icon = await defaultWindowIcon(); + * ``` + * + * @since 2.0.0 + */ +declare function defaultWindowIcon(): Promise; +/** + * Sets the application's theme. Pass in `null` or `undefined` to follow + * the system theme. + * + * @example + * ```typescript + * import { setTheme } from '@tauri-apps/api/app'; + * await setTheme('dark'); + * ``` + * + * #### Platform-specific + * + * - **iOS / Android:** Unsupported. + * + * @since 2.0.0 + */ +declare function setTheme(theme?: Theme | null): Promise; +/** + * Sets the dock visibility for the application on macOS. + * + * @param visible - Whether the dock should be visible or not. + * + * @example + * ```typescript + * import { setDockVisibility } from '@tauri-apps/api/app'; + * await setDockVisibility(false); + * ``` + * + * @since 2.5.0 + */ +declare function setDockVisibility(visible: boolean): Promise; +/** + * Gets the application bundle type. + * + * @example + * ```typescript + * import { getBundleType } from '@tauri-apps/api/app'; + * const type = await getBundleType(); + * ``` + * + * @since 2.5.0 + */ +declare function getBundleType(): Promise; +/** + * Payload for the onBackButtonPress event. + */ +type OnBackButtonPressPayload = { + /** Whether the webview canGoBack property is true. */ + canGoBack: boolean; +}; +/** + * Listens to the backButton event on Android. + * @param handler + */ +declare function onBackButtonPress(handler: (payload: OnBackButtonPressPayload) => void): Promise; +export { getName, getVersion, getTauriVersion, getIdentifier, show, hide, defaultWindowIcon, setTheme, fetchDataStoreIdentifiers, removeDataStore, setDockVisibility, getBundleType, type OnBackButtonPressPayload, onBackButtonPress }; diff --git a/scripts/node_modules/@tauri-apps/api/app.js b/scripts/node_modules/@tauri-apps/api/app.js new file mode 100644 index 0000000000000000000000000000000000000000..c1f222844d4a32e464e2c61caa3f96881f00670c --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/app.js @@ -0,0 +1,221 @@ +import { invoke, addPluginListener } from './core.js'; +import { Image } from './image.js'; + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * Bundle type of the current application. + */ +var BundleType; +(function (BundleType) { + /** Windows NSIS */ + BundleType["Nsis"] = "nsis"; + /** Windows MSI */ + BundleType["Msi"] = "msi"; + /** Linux Debian package */ + BundleType["Deb"] = "deb"; + /** Linux RPM */ + BundleType["Rpm"] = "rpm"; + /** Linux AppImage */ + BundleType["AppImage"] = "appimage"; + /** macOS app bundle */ + BundleType["App"] = "app"; +})(BundleType || (BundleType = {})); +/** + * Application metadata and related APIs. + * + * @module + */ +/** + * Gets the application version. + * @example + * ```typescript + * import { getVersion } from '@tauri-apps/api/app'; + * const appVersion = await getVersion(); + * ``` + * + * @since 1.0.0 + */ +async function getVersion() { + return invoke('plugin:app|version'); +} +/** + * Gets the application name. + * @example + * ```typescript + * import { getName } from '@tauri-apps/api/app'; + * const appName = await getName(); + * ``` + * + * @since 1.0.0 + */ +async function getName() { + return invoke('plugin:app|name'); +} +/** + * Gets the Tauri framework version used by this application. + * + * @example + * ```typescript + * import { getTauriVersion } from '@tauri-apps/api/app'; + * const tauriVersion = await getTauriVersion(); + * ``` + * + * @since 1.0.0 + */ +async function getTauriVersion() { + return invoke('plugin:app|tauri_version'); +} +/** + * Gets the application identifier. + * @example + * ```typescript + * import { getIdentifier } from '@tauri-apps/api/app'; + * const identifier = await getIdentifier(); + * ``` + * + * @returns The application identifier as configured in `tauri.conf.json`. + * + * @since 2.4.0 + */ +async function getIdentifier() { + return invoke('plugin:app|identifier'); +} +/** + * Shows the application on macOS. This function does not automatically + * focus any specific app window. + * + * @example + * ```typescript + * import { show } from '@tauri-apps/api/app'; + * await show(); + * ``` + * + * @since 1.2.0 + */ +async function show() { + return invoke('plugin:app|app_show'); +} +/** + * Hides the application on macOS. + * + * @example + * ```typescript + * import { hide } from '@tauri-apps/api/app'; + * await hide(); + * ``` + * + * @since 1.2.0 + */ +async function hide() { + return invoke('plugin:app|app_hide'); +} +/** + * Fetches the data store identifiers on macOS and iOS. + * + * See https://developer.apple.com/documentation/webkit/wkwebsitedatastore for more information. + * + * @example + * ```typescript + * import { fetchDataStoreIdentifiers } from '@tauri-apps/api/app'; + * const ids = await fetchDataStoreIdentifiers(); + * ``` + * + * @since 2.4.0 + */ +async function fetchDataStoreIdentifiers() { + return invoke('plugin:app|fetch_data_store_identifiers'); +} +/** + * Removes the data store with the given identifier. + * + * Note that any webview using this data store should be closed before running this API. + * + * See https://developer.apple.com/documentation/webkit/wkwebsitedatastore for more information. + * + * @example + * ```typescript + * import { fetchDataStoreIdentifiers, removeDataStore } from '@tauri-apps/api/app'; + * for (const id of (await fetchDataStoreIdentifiers())) { + * await removeDataStore(id); + * } + * ``` + * + * @since 2.4.0 + */ +async function removeDataStore(uuid) { + return invoke('plugin:app|remove_data_store', { uuid }); +} +/** + * Gets the default window icon. + * + * @example + * ```typescript + * import { defaultWindowIcon } from '@tauri-apps/api/app'; + * const icon = await defaultWindowIcon(); + * ``` + * + * @since 2.0.0 + */ +async function defaultWindowIcon() { + return invoke('plugin:app|default_window_icon').then((rid) => rid ? new Image(rid) : null); +} +/** + * Sets the application's theme. Pass in `null` or `undefined` to follow + * the system theme. + * + * @example + * ```typescript + * import { setTheme } from '@tauri-apps/api/app'; + * await setTheme('dark'); + * ``` + * + * #### Platform-specific + * + * - **iOS / Android:** Unsupported. + * + * @since 2.0.0 + */ +async function setTheme(theme) { + return invoke('plugin:app|set_app_theme', { theme }); +} +/** + * Sets the dock visibility for the application on macOS. + * + * @param visible - Whether the dock should be visible or not. + * + * @example + * ```typescript + * import { setDockVisibility } from '@tauri-apps/api/app'; + * await setDockVisibility(false); + * ``` + * + * @since 2.5.0 + */ +async function setDockVisibility(visible) { + return invoke('plugin:app|set_dock_visibility', { visible }); +} +/** + * Gets the application bundle type. + * + * @example + * ```typescript + * import { getBundleType } from '@tauri-apps/api/app'; + * const type = await getBundleType(); + * ``` + * + * @since 2.5.0 + */ +async function getBundleType() { + return invoke('plugin:app|bundle_type'); +} +/** + * Listens to the backButton event on Android. + * @param handler + */ +async function onBackButtonPress(handler) { + return addPluginListener('app', 'back-button', handler); +} + +export { BundleType, defaultWindowIcon, fetchDataStoreIdentifiers, getBundleType, getIdentifier, getName, getTauriVersion, getVersion, hide, onBackButtonPress, removeDataStore, setDockVisibility, setTheme, show }; diff --git a/scripts/node_modules/@tauri-apps/api/core.cjs b/scripts/node_modules/@tauri-apps/api/core.cjs new file mode 100644 index 0000000000000000000000000000000000000000..8046d4e17e9320849ad098d3cc4fd0572dcdba4d --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/core.cjs @@ -0,0 +1,295 @@ +'use strict'; + +var tslib_es6 = require('./external/tslib/tslib.es6.cjs'); + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +var _Channel_onmessage, _Channel_nextMessageIndex, _Channel_pendingMessages, _Channel_messageEndIndex, _Resource_rid; +/** + * Invoke your custom commands. + * + * This package is also accessible with `window.__TAURI__.core` when [`app.withGlobalTauri`](https://v2.tauri.app/reference/config/#withglobaltauri) in `tauri.conf.json` is set to `true`. + * @module + */ +/** + * A key to be used to implement a special function + * on your types that define how your type should be serialized + * when passing across the IPC. + * @example + * Given a type in Rust that looks like this + * ```rs + * #[derive(serde::Serialize, serde::Deserialize) + * enum UserId { + * String(String), + * Number(u32), + * } + * ``` + * `UserId::String("id")` would be serialized into `{ String: "id" }` + * and so we need to pass the same structure back to Rust + * ```ts + * import { SERIALIZE_TO_IPC_FN } from "@tauri-apps/api/core" + * + * class UserIdString { + * id + * constructor(id) { + * this.id = id + * } + * + * [SERIALIZE_TO_IPC_FN]() { + * return { String: this.id } + * } + * } + * + * class UserIdNumber { + * id + * constructor(id) { + * this.id = id + * } + * + * [SERIALIZE_TO_IPC_FN]() { + * return { Number: this.id } + * } + * } + * + * type UserId = UserIdString | UserIdNumber + * ``` + * + */ +// if this value changes, make sure to update it in: +// 1. ipc.js +// 2. process-ipc-message-fn.js +const SERIALIZE_TO_IPC_FN = '__TAURI_TO_IPC_KEY__'; +/** + * Stores the callback in a known location, and returns an identifier that can be passed to the backend. + * The backend uses the identifier to `eval()` the callback. + * + * @return An unique identifier associated with the callback function. + * + * @since 1.0.0 + */ +function transformCallback( +// TODO: Make this not optional in v3 +callback, once = false) { + return window.__TAURI_INTERNALS__.transformCallback(callback, once); +} +class Channel { + constructor(onmessage) { + _Channel_onmessage.set(this, void 0); + // the index is used as a mechanism to preserve message order + _Channel_nextMessageIndex.set(this, 0); + _Channel_pendingMessages.set(this, []); + _Channel_messageEndIndex.set(this, void 0); + tslib_es6.__classPrivateFieldSet(this, _Channel_onmessage, onmessage || (() => { }), "f"); + this.id = transformCallback((rawMessage) => { + const index = rawMessage.index; + if ('end' in rawMessage) { + if (index == tslib_es6.__classPrivateFieldGet(this, _Channel_nextMessageIndex, "f")) { + this.cleanupCallback(); + } + else { + tslib_es6.__classPrivateFieldSet(this, _Channel_messageEndIndex, index, "f"); + } + return; + } + const message = rawMessage.message; + // Process the message if we're at the right order + if (index == tslib_es6.__classPrivateFieldGet(this, _Channel_nextMessageIndex, "f")) { + tslib_es6.__classPrivateFieldGet(this, _Channel_onmessage, "f").call(this, message); + tslib_es6.__classPrivateFieldSet(this, _Channel_nextMessageIndex, tslib_es6.__classPrivateFieldGet(this, _Channel_nextMessageIndex, "f") + 1, "f"); + // process pending messages + while (tslib_es6.__classPrivateFieldGet(this, _Channel_nextMessageIndex, "f") in tslib_es6.__classPrivateFieldGet(this, _Channel_pendingMessages, "f")) { + const message = tslib_es6.__classPrivateFieldGet(this, _Channel_pendingMessages, "f")[tslib_es6.__classPrivateFieldGet(this, _Channel_nextMessageIndex, "f")]; + tslib_es6.__classPrivateFieldGet(this, _Channel_onmessage, "f").call(this, message); + // eslint-disable-next-line @typescript-eslint/no-array-delete + delete tslib_es6.__classPrivateFieldGet(this, _Channel_pendingMessages, "f")[tslib_es6.__classPrivateFieldGet(this, _Channel_nextMessageIndex, "f")]; + tslib_es6.__classPrivateFieldSet(this, _Channel_nextMessageIndex, tslib_es6.__classPrivateFieldGet(this, _Channel_nextMessageIndex, "f") + 1, "f"); + } + if (tslib_es6.__classPrivateFieldGet(this, _Channel_nextMessageIndex, "f") === tslib_es6.__classPrivateFieldGet(this, _Channel_messageEndIndex, "f")) { + this.cleanupCallback(); + } + } + // Queue the message if we're not + else { + // eslint-disable-next-line security/detect-object-injection + tslib_es6.__classPrivateFieldGet(this, _Channel_pendingMessages, "f")[index] = message; + } + }); + } + cleanupCallback() { + window.__TAURI_INTERNALS__.unregisterCallback(this.id); + } + set onmessage(handler) { + tslib_es6.__classPrivateFieldSet(this, _Channel_onmessage, handler, "f"); + } + get onmessage() { + return tslib_es6.__classPrivateFieldGet(this, _Channel_onmessage, "f"); + } + [(_Channel_onmessage = new WeakMap(), _Channel_nextMessageIndex = new WeakMap(), _Channel_pendingMessages = new WeakMap(), _Channel_messageEndIndex = new WeakMap(), SERIALIZE_TO_IPC_FN)]() { + return `__CHANNEL__:${this.id}`; + } + toJSON() { + // eslint-disable-next-line security/detect-object-injection + return this[SERIALIZE_TO_IPC_FN](); + } +} +class PluginListener { + constructor(plugin, event, channelId) { + this.plugin = plugin; + this.event = event; + this.channelId = channelId; + } + async unregister() { + return invoke(`plugin:${this.plugin}|remove_listener`, { + event: this.event, + channelId: this.channelId + }); + } +} +/** + * Adds a listener to a plugin event. + * + * @returns The listener object to stop listening to the events. + * + * @since 2.0.0 + */ +async function addPluginListener(plugin, event, cb) { + const handler = new Channel(cb); + try { + await invoke(`plugin:${plugin}|register_listener`, { + event, + handler + }); + return new PluginListener(plugin, event, handler.id); + } + catch { + // TODO(v3): remove this fallback + // note: we must try with camelCase here for backwards compatibility + await invoke(`plugin:${plugin}|registerListener`, { event, handler }); + return new PluginListener(plugin, event, handler.id); + } +} +/** + * Get permission state for a plugin. + * + * This should be used by plugin authors to wrap their actual implementation. + */ +async function checkPermissions(plugin) { + return invoke(`plugin:${plugin}|check_permissions`); +} +/** + * Request permissions. + * + * This should be used by plugin authors to wrap their actual implementation. + */ +async function requestPermissions(plugin) { + return invoke(`plugin:${plugin}|request_permissions`); +} +/** + * Sends a message to the backend. + * @example + * ```typescript + * import { invoke } from '@tauri-apps/api/core'; + * await invoke('login', { user: 'tauri', password: 'poiwe3h4r5ip3yrhtew9ty' }); + * ``` + * + * @param cmd The command name. + * @param args The optional arguments to pass to the command. + * @param options The request options. + * @return A promise resolving or rejecting to the backend response. + * + * @since 1.0.0 + */ +async function invoke(cmd, args = {}, options) { + return window.__TAURI_INTERNALS__.invoke(cmd, args, options); +} +/** + * Convert a device file path to an URL that can be loaded by the webview. + * Note that `asset:` and `http://asset.localhost` must be added to [`app.security.csp`](https://v2.tauri.app/reference/config/#csp-1) in `tauri.conf.json`. + * Example CSP value: `"csp": "default-src 'self' ipc: http://ipc.localhost; img-src 'self' asset: http://asset.localhost"` to use the asset protocol on image sources. + * + * Additionally, `"enable" : "true"` must be added to [`app.security.assetProtocol`](https://v2.tauri.app/reference/config/#assetprotocolconfig) + * in `tauri.conf.json` and its access scope must be defined on the `scope` array on the same `assetProtocol` object. + * + * @param filePath The file path. + * @param protocol The protocol to use. Defaults to `asset`. You only need to set this when using a custom protocol. + * @example + * ```typescript + * import { appDataDir, join } from '@tauri-apps/api/path'; + * import { convertFileSrc } from '@tauri-apps/api/core'; + * const appDataDirPath = await appDataDir(); + * const filePath = await join(appDataDirPath, 'assets/video.mp4'); + * const assetUrl = convertFileSrc(filePath); + * + * const video = document.getElementById('my-video'); + * const source = document.createElement('source'); + * source.type = 'video/mp4'; + * source.src = assetUrl; + * video.appendChild(source); + * video.load(); + * ``` + * + * @return the URL that can be used as source on the webview. + * + * @since 1.0.0 + */ +function convertFileSrc(filePath, protocol = 'asset') { + return window.__TAURI_INTERNALS__.convertFileSrc(filePath, protocol); +} +/** + * A rust-backed resource stored through `tauri::Manager::resources_table` API. + * + * The resource lives in the main process and does not exist + * in the Javascript world, and thus will not be cleaned up automatically + * except on application exit. If you want to clean it up early, call {@linkcode Resource.close} + * + * @example + * ```typescript + * import { Resource, invoke } from '@tauri-apps/api/core'; + * export class DatabaseHandle extends Resource { + * static async open(path: string): Promise { + * const rid: number = await invoke('open_db', { path }); + * return new DatabaseHandle(rid); + * } + * + * async execute(sql: string): Promise { + * await invoke('execute_sql', { rid: this.rid, sql }); + * } + * } + * ``` + */ +class Resource { + get rid() { + return tslib_es6.__classPrivateFieldGet(this, _Resource_rid, "f"); + } + constructor(rid) { + _Resource_rid.set(this, void 0); + tslib_es6.__classPrivateFieldSet(this, _Resource_rid, rid, "f"); + } + /** + * Destroys and cleans up this resource from memory. + * **You should not call any method on this object anymore and should drop any reference to it.** + */ + async close() { + return invoke('plugin:resources|close', { + rid: this.rid + }); + } +} +_Resource_rid = new WeakMap(); +function isTauri() { + // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access + return !!(globalThis || window).isTauri; +} + +exports.Channel = Channel; +exports.PluginListener = PluginListener; +exports.Resource = Resource; +exports.SERIALIZE_TO_IPC_FN = SERIALIZE_TO_IPC_FN; +exports.addPluginListener = addPluginListener; +exports.checkPermissions = checkPermissions; +exports.convertFileSrc = convertFileSrc; +exports.invoke = invoke; +exports.isTauri = isTauri; +exports.requestPermissions = requestPermissions; +exports.transformCallback = transformCallback; diff --git a/scripts/node_modules/@tauri-apps/api/core.d.ts b/scripts/node_modules/@tauri-apps/api/core.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7e126b960b83dd9796780ccccba2d7b1a080ff79 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/core.d.ts @@ -0,0 +1,193 @@ +/** + * Invoke your custom commands. + * + * This package is also accessible with `window.__TAURI__.core` when [`app.withGlobalTauri`](https://v2.tauri.app/reference/config/#withglobaltauri) in `tauri.conf.json` is set to `true`. + * @module + */ +/** + * A key to be used to implement a special function + * on your types that define how your type should be serialized + * when passing across the IPC. + * @example + * Given a type in Rust that looks like this + * ```rs + * #[derive(serde::Serialize, serde::Deserialize) + * enum UserId { + * String(String), + * Number(u32), + * } + * ``` + * `UserId::String("id")` would be serialized into `{ String: "id" }` + * and so we need to pass the same structure back to Rust + * ```ts + * import { SERIALIZE_TO_IPC_FN } from "@tauri-apps/api/core" + * + * class UserIdString { + * id + * constructor(id) { + * this.id = id + * } + * + * [SERIALIZE_TO_IPC_FN]() { + * return { String: this.id } + * } + * } + * + * class UserIdNumber { + * id + * constructor(id) { + * this.id = id + * } + * + * [SERIALIZE_TO_IPC_FN]() { + * return { Number: this.id } + * } + * } + * + * type UserId = UserIdString | UserIdNumber + * ``` + * + */ +export declare const SERIALIZE_TO_IPC_FN = "__TAURI_TO_IPC_KEY__"; +/** + * Stores the callback in a known location, and returns an identifier that can be passed to the backend. + * The backend uses the identifier to `eval()` the callback. + * + * @return An unique identifier associated with the callback function. + * + * @since 1.0.0 + */ +declare function transformCallback(callback?: (response: T) => void, once?: boolean): number; +declare class Channel { + #private; + /** The callback id returned from {@linkcode transformCallback} */ + id: number; + constructor(onmessage?: (response: T) => void); + private cleanupCallback; + set onmessage(handler: (response: T) => void); + get onmessage(): (response: T) => void; + [SERIALIZE_TO_IPC_FN](): string; + toJSON(): string; +} +declare class PluginListener { + plugin: string; + event: string; + channelId: number; + constructor(plugin: string, event: string, channelId: number); + unregister(): Promise; +} +/** + * Adds a listener to a plugin event. + * + * @returns The listener object to stop listening to the events. + * + * @since 2.0.0 + */ +declare function addPluginListener(plugin: string, event: string, cb: (payload: T) => void): Promise; +type PermissionState = 'granted' | 'denied' | 'prompt' | 'prompt-with-rationale'; +/** + * Get permission state for a plugin. + * + * This should be used by plugin authors to wrap their actual implementation. + */ +declare function checkPermissions(plugin: string): Promise; +/** + * Request permissions. + * + * This should be used by plugin authors to wrap their actual implementation. + */ +declare function requestPermissions(plugin: string): Promise; +/** + * Command arguments. + * + * @since 1.0.0 + */ +type InvokeArgs = Record | number[] | ArrayBuffer | Uint8Array; +/** + * @since 2.0.0 + */ +interface InvokeOptions { + headers: HeadersInit; +} +/** + * Sends a message to the backend. + * @example + * ```typescript + * import { invoke } from '@tauri-apps/api/core'; + * await invoke('login', { user: 'tauri', password: 'poiwe3h4r5ip3yrhtew9ty' }); + * ``` + * + * @param cmd The command name. + * @param args The optional arguments to pass to the command. + * @param options The request options. + * @return A promise resolving or rejecting to the backend response. + * + * @since 1.0.0 + */ +declare function invoke(cmd: string, args?: InvokeArgs, options?: InvokeOptions): Promise; +/** + * Convert a device file path to an URL that can be loaded by the webview. + * Note that `asset:` and `http://asset.localhost` must be added to [`app.security.csp`](https://v2.tauri.app/reference/config/#csp-1) in `tauri.conf.json`. + * Example CSP value: `"csp": "default-src 'self' ipc: http://ipc.localhost; img-src 'self' asset: http://asset.localhost"` to use the asset protocol on image sources. + * + * Additionally, `"enable" : "true"` must be added to [`app.security.assetProtocol`](https://v2.tauri.app/reference/config/#assetprotocolconfig) + * in `tauri.conf.json` and its access scope must be defined on the `scope` array on the same `assetProtocol` object. + * + * @param filePath The file path. + * @param protocol The protocol to use. Defaults to `asset`. You only need to set this when using a custom protocol. + * @example + * ```typescript + * import { appDataDir, join } from '@tauri-apps/api/path'; + * import { convertFileSrc } from '@tauri-apps/api/core'; + * const appDataDirPath = await appDataDir(); + * const filePath = await join(appDataDirPath, 'assets/video.mp4'); + * const assetUrl = convertFileSrc(filePath); + * + * const video = document.getElementById('my-video'); + * const source = document.createElement('source'); + * source.type = 'video/mp4'; + * source.src = assetUrl; + * video.appendChild(source); + * video.load(); + * ``` + * + * @return the URL that can be used as source on the webview. + * + * @since 1.0.0 + */ +declare function convertFileSrc(filePath: string, protocol?: string): string; +/** + * A rust-backed resource stored through `tauri::Manager::resources_table` API. + * + * The resource lives in the main process and does not exist + * in the Javascript world, and thus will not be cleaned up automatically + * except on application exit. If you want to clean it up early, call {@linkcode Resource.close} + * + * @example + * ```typescript + * import { Resource, invoke } from '@tauri-apps/api/core'; + * export class DatabaseHandle extends Resource { + * static async open(path: string): Promise { + * const rid: number = await invoke('open_db', { path }); + * return new DatabaseHandle(rid); + * } + * + * async execute(sql: string): Promise { + * await invoke('execute_sql', { rid: this.rid, sql }); + * } + * } + * ``` + */ +export declare class Resource { + #private; + get rid(): number; + constructor(rid: number); + /** + * Destroys and cleans up this resource from memory. + * **You should not call any method on this object anymore and should drop any reference to it.** + */ + close(): Promise; +} +declare function isTauri(): boolean; +export type { InvokeArgs, InvokeOptions }; +export { transformCallback, Channel, PluginListener, addPluginListener, PermissionState, checkPermissions, requestPermissions, invoke, convertFileSrc, isTauri }; diff --git a/scripts/node_modules/@tauri-apps/api/core.js b/scripts/node_modules/@tauri-apps/api/core.js new file mode 100644 index 0000000000000000000000000000000000000000..ad03e61b2d17174ca2cecf281b03665079630c23 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/core.js @@ -0,0 +1,283 @@ +import { __classPrivateFieldSet, __classPrivateFieldGet } from './external/tslib/tslib.es6.js'; + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +var _Channel_onmessage, _Channel_nextMessageIndex, _Channel_pendingMessages, _Channel_messageEndIndex, _Resource_rid; +/** + * Invoke your custom commands. + * + * This package is also accessible with `window.__TAURI__.core` when [`app.withGlobalTauri`](https://v2.tauri.app/reference/config/#withglobaltauri) in `tauri.conf.json` is set to `true`. + * @module + */ +/** + * A key to be used to implement a special function + * on your types that define how your type should be serialized + * when passing across the IPC. + * @example + * Given a type in Rust that looks like this + * ```rs + * #[derive(serde::Serialize, serde::Deserialize) + * enum UserId { + * String(String), + * Number(u32), + * } + * ``` + * `UserId::String("id")` would be serialized into `{ String: "id" }` + * and so we need to pass the same structure back to Rust + * ```ts + * import { SERIALIZE_TO_IPC_FN } from "@tauri-apps/api/core" + * + * class UserIdString { + * id + * constructor(id) { + * this.id = id + * } + * + * [SERIALIZE_TO_IPC_FN]() { + * return { String: this.id } + * } + * } + * + * class UserIdNumber { + * id + * constructor(id) { + * this.id = id + * } + * + * [SERIALIZE_TO_IPC_FN]() { + * return { Number: this.id } + * } + * } + * + * type UserId = UserIdString | UserIdNumber + * ``` + * + */ +// if this value changes, make sure to update it in: +// 1. ipc.js +// 2. process-ipc-message-fn.js +const SERIALIZE_TO_IPC_FN = '__TAURI_TO_IPC_KEY__'; +/** + * Stores the callback in a known location, and returns an identifier that can be passed to the backend. + * The backend uses the identifier to `eval()` the callback. + * + * @return An unique identifier associated with the callback function. + * + * @since 1.0.0 + */ +function transformCallback( +// TODO: Make this not optional in v3 +callback, once = false) { + return window.__TAURI_INTERNALS__.transformCallback(callback, once); +} +class Channel { + constructor(onmessage) { + _Channel_onmessage.set(this, void 0); + // the index is used as a mechanism to preserve message order + _Channel_nextMessageIndex.set(this, 0); + _Channel_pendingMessages.set(this, []); + _Channel_messageEndIndex.set(this, void 0); + __classPrivateFieldSet(this, _Channel_onmessage, onmessage || (() => { }), "f"); + this.id = transformCallback((rawMessage) => { + const index = rawMessage.index; + if ('end' in rawMessage) { + if (index == __classPrivateFieldGet(this, _Channel_nextMessageIndex, "f")) { + this.cleanupCallback(); + } + else { + __classPrivateFieldSet(this, _Channel_messageEndIndex, index, "f"); + } + return; + } + const message = rawMessage.message; + // Process the message if we're at the right order + if (index == __classPrivateFieldGet(this, _Channel_nextMessageIndex, "f")) { + __classPrivateFieldGet(this, _Channel_onmessage, "f").call(this, message); + __classPrivateFieldSet(this, _Channel_nextMessageIndex, __classPrivateFieldGet(this, _Channel_nextMessageIndex, "f") + 1, "f"); + // process pending messages + while (__classPrivateFieldGet(this, _Channel_nextMessageIndex, "f") in __classPrivateFieldGet(this, _Channel_pendingMessages, "f")) { + const message = __classPrivateFieldGet(this, _Channel_pendingMessages, "f")[__classPrivateFieldGet(this, _Channel_nextMessageIndex, "f")]; + __classPrivateFieldGet(this, _Channel_onmessage, "f").call(this, message); + // eslint-disable-next-line @typescript-eslint/no-array-delete + delete __classPrivateFieldGet(this, _Channel_pendingMessages, "f")[__classPrivateFieldGet(this, _Channel_nextMessageIndex, "f")]; + __classPrivateFieldSet(this, _Channel_nextMessageIndex, __classPrivateFieldGet(this, _Channel_nextMessageIndex, "f") + 1, "f"); + } + if (__classPrivateFieldGet(this, _Channel_nextMessageIndex, "f") === __classPrivateFieldGet(this, _Channel_messageEndIndex, "f")) { + this.cleanupCallback(); + } + } + // Queue the message if we're not + else { + // eslint-disable-next-line security/detect-object-injection + __classPrivateFieldGet(this, _Channel_pendingMessages, "f")[index] = message; + } + }); + } + cleanupCallback() { + window.__TAURI_INTERNALS__.unregisterCallback(this.id); + } + set onmessage(handler) { + __classPrivateFieldSet(this, _Channel_onmessage, handler, "f"); + } + get onmessage() { + return __classPrivateFieldGet(this, _Channel_onmessage, "f"); + } + [(_Channel_onmessage = new WeakMap(), _Channel_nextMessageIndex = new WeakMap(), _Channel_pendingMessages = new WeakMap(), _Channel_messageEndIndex = new WeakMap(), SERIALIZE_TO_IPC_FN)]() { + return `__CHANNEL__:${this.id}`; + } + toJSON() { + // eslint-disable-next-line security/detect-object-injection + return this[SERIALIZE_TO_IPC_FN](); + } +} +class PluginListener { + constructor(plugin, event, channelId) { + this.plugin = plugin; + this.event = event; + this.channelId = channelId; + } + async unregister() { + return invoke(`plugin:${this.plugin}|remove_listener`, { + event: this.event, + channelId: this.channelId + }); + } +} +/** + * Adds a listener to a plugin event. + * + * @returns The listener object to stop listening to the events. + * + * @since 2.0.0 + */ +async function addPluginListener(plugin, event, cb) { + const handler = new Channel(cb); + try { + await invoke(`plugin:${plugin}|register_listener`, { + event, + handler + }); + return new PluginListener(plugin, event, handler.id); + } + catch { + // TODO(v3): remove this fallback + // note: we must try with camelCase here for backwards compatibility + await invoke(`plugin:${plugin}|registerListener`, { event, handler }); + return new PluginListener(plugin, event, handler.id); + } +} +/** + * Get permission state for a plugin. + * + * This should be used by plugin authors to wrap their actual implementation. + */ +async function checkPermissions(plugin) { + return invoke(`plugin:${plugin}|check_permissions`); +} +/** + * Request permissions. + * + * This should be used by plugin authors to wrap their actual implementation. + */ +async function requestPermissions(plugin) { + return invoke(`plugin:${plugin}|request_permissions`); +} +/** + * Sends a message to the backend. + * @example + * ```typescript + * import { invoke } from '@tauri-apps/api/core'; + * await invoke('login', { user: 'tauri', password: 'poiwe3h4r5ip3yrhtew9ty' }); + * ``` + * + * @param cmd The command name. + * @param args The optional arguments to pass to the command. + * @param options The request options. + * @return A promise resolving or rejecting to the backend response. + * + * @since 1.0.0 + */ +async function invoke(cmd, args = {}, options) { + return window.__TAURI_INTERNALS__.invoke(cmd, args, options); +} +/** + * Convert a device file path to an URL that can be loaded by the webview. + * Note that `asset:` and `http://asset.localhost` must be added to [`app.security.csp`](https://v2.tauri.app/reference/config/#csp-1) in `tauri.conf.json`. + * Example CSP value: `"csp": "default-src 'self' ipc: http://ipc.localhost; img-src 'self' asset: http://asset.localhost"` to use the asset protocol on image sources. + * + * Additionally, `"enable" : "true"` must be added to [`app.security.assetProtocol`](https://v2.tauri.app/reference/config/#assetprotocolconfig) + * in `tauri.conf.json` and its access scope must be defined on the `scope` array on the same `assetProtocol` object. + * + * @param filePath The file path. + * @param protocol The protocol to use. Defaults to `asset`. You only need to set this when using a custom protocol. + * @example + * ```typescript + * import { appDataDir, join } from '@tauri-apps/api/path'; + * import { convertFileSrc } from '@tauri-apps/api/core'; + * const appDataDirPath = await appDataDir(); + * const filePath = await join(appDataDirPath, 'assets/video.mp4'); + * const assetUrl = convertFileSrc(filePath); + * + * const video = document.getElementById('my-video'); + * const source = document.createElement('source'); + * source.type = 'video/mp4'; + * source.src = assetUrl; + * video.appendChild(source); + * video.load(); + * ``` + * + * @return the URL that can be used as source on the webview. + * + * @since 1.0.0 + */ +function convertFileSrc(filePath, protocol = 'asset') { + return window.__TAURI_INTERNALS__.convertFileSrc(filePath, protocol); +} +/** + * A rust-backed resource stored through `tauri::Manager::resources_table` API. + * + * The resource lives in the main process and does not exist + * in the Javascript world, and thus will not be cleaned up automatically + * except on application exit. If you want to clean it up early, call {@linkcode Resource.close} + * + * @example + * ```typescript + * import { Resource, invoke } from '@tauri-apps/api/core'; + * export class DatabaseHandle extends Resource { + * static async open(path: string): Promise { + * const rid: number = await invoke('open_db', { path }); + * return new DatabaseHandle(rid); + * } + * + * async execute(sql: string): Promise { + * await invoke('execute_sql', { rid: this.rid, sql }); + * } + * } + * ``` + */ +class Resource { + get rid() { + return __classPrivateFieldGet(this, _Resource_rid, "f"); + } + constructor(rid) { + _Resource_rid.set(this, void 0); + __classPrivateFieldSet(this, _Resource_rid, rid, "f"); + } + /** + * Destroys and cleans up this resource from memory. + * **You should not call any method on this object anymore and should drop any reference to it.** + */ + async close() { + return invoke('plugin:resources|close', { + rid: this.rid + }); + } +} +_Resource_rid = new WeakMap(); +function isTauri() { + // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access + return !!(globalThis || window).isTauri; +} + +export { Channel, PluginListener, Resource, SERIALIZE_TO_IPC_FN, addPluginListener, checkPermissions, convertFileSrc, invoke, isTauri, requestPermissions, transformCallback }; diff --git a/scripts/node_modules/@tauri-apps/api/dpi.cjs b/scripts/node_modules/@tauri-apps/api/dpi.cjs new file mode 100644 index 0000000000000000000000000000000000000000..972617f0ad992da0099cce2feed1adca278dcb8f --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/dpi.cjs @@ -0,0 +1,347 @@ +'use strict'; + +var core = require('./core.cjs'); + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * A size represented in logical pixels. + * Logical pixels are scaled according to the window's DPI scale. + * Most browser APIs (i.e. `MouseEvent`'s `clientX`) will return logical pixels. + * + * For logical-pixel-based position, see {@linkcode LogicalPosition}. + * + * @since 2.0.0 + */ +class LogicalSize { + constructor(...args) { + this.type = 'Logical'; + if (args.length === 1) { + if ('Logical' in args[0]) { + this.width = args[0].Logical.width; + this.height = args[0].Logical.height; + } + else { + this.width = args[0].width; + this.height = args[0].height; + } + } + else { + this.width = args[0]; + this.height = args[1]; + } + } + /** + * Converts the logical size to a physical one. + * @example + * ```typescript + * import { LogicalSize } from '@tauri-apps/api/dpi'; + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * + * const appWindow = getCurrentWindow(); + * const factor = await appWindow.scaleFactor(); + * const size = new LogicalSize(400, 500); + * const physical = size.toPhysical(factor); + * ``` + * + * @since 2.0.0 + */ + toPhysical(scaleFactor) { + return new PhysicalSize(this.width * scaleFactor, this.height * scaleFactor); + } + [core.SERIALIZE_TO_IPC_FN]() { + return { + width: this.width, + height: this.height + }; + } + toJSON() { + // eslint-disable-next-line security/detect-object-injection + return this[core.SERIALIZE_TO_IPC_FN](); + } +} +/** + * A size represented in physical pixels. + * + * Physical pixels represent actual screen pixels, and are DPI-independent. + * For high-DPI windows, this means that any point in the window on the screen + * will have a different position in logical pixels {@linkcode LogicalSize}. + * + * For physical-pixel-based position, see {@linkcode PhysicalPosition}. + * + * @since 2.0.0 + */ +class PhysicalSize { + constructor(...args) { + this.type = 'Physical'; + if (args.length === 1) { + if ('Physical' in args[0]) { + this.width = args[0].Physical.width; + this.height = args[0].Physical.height; + } + else { + this.width = args[0].width; + this.height = args[0].height; + } + } + else { + this.width = args[0]; + this.height = args[1]; + } + } + /** + * Converts the physical size to a logical one. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const appWindow = getCurrentWindow(); + * const factor = await appWindow.scaleFactor(); + * const size = await appWindow.innerSize(); // PhysicalSize + * const logical = size.toLogical(factor); + * ``` + */ + toLogical(scaleFactor) { + return new LogicalSize(this.width / scaleFactor, this.height / scaleFactor); + } + [core.SERIALIZE_TO_IPC_FN]() { + return { + width: this.width, + height: this.height + }; + } + toJSON() { + // eslint-disable-next-line security/detect-object-injection + return this[core.SERIALIZE_TO_IPC_FN](); + } +} +/** + * A size represented either in physical or in logical pixels. + * + * This type is basically a union type of {@linkcode LogicalSize} and {@linkcode PhysicalSize} + * but comes in handy when using `tauri::Size` in Rust as an argument to a command, as this class + * automatically serializes into a valid format so it can be deserialized correctly into `tauri::Size` + * + * So instead of + * ```typescript + * import { invoke } from '@tauri-apps/api/core'; + * import { LogicalSize, PhysicalSize } from '@tauri-apps/api/dpi'; + * + * const size: LogicalSize | PhysicalSize = someFunction(); // where someFunction returns either LogicalSize or PhysicalSize + * const validSize = size instanceof LogicalSize + * ? { Logical: { width: size.width, height: size.height } } + * : { Physical: { width: size.width, height: size.height } } + * await invoke("do_something_with_size", { size: validSize }); + * ``` + * + * You can just use {@linkcode Size} + * ```typescript + * import { invoke } from '@tauri-apps/api/core'; + * import { LogicalSize, PhysicalSize, Size } from '@tauri-apps/api/dpi'; + * + * const size: LogicalSize | PhysicalSize = someFunction(); // where someFunction returns either LogicalSize or PhysicalSize + * const validSize = new Size(size); + * await invoke("do_something_with_size", { size: validSize }); + * ``` + * + * @since 2.1.0 + */ +class Size { + constructor(size) { + this.size = size; + } + toLogical(scaleFactor) { + return this.size instanceof LogicalSize + ? this.size + : this.size.toLogical(scaleFactor); + } + toPhysical(scaleFactor) { + return this.size instanceof PhysicalSize + ? this.size + : this.size.toPhysical(scaleFactor); + } + [core.SERIALIZE_TO_IPC_FN]() { + return { + [`${this.size.type}`]: { + width: this.size.width, + height: this.size.height + } + }; + } + toJSON() { + // eslint-disable-next-line security/detect-object-injection + return this[core.SERIALIZE_TO_IPC_FN](); + } +} +/** + * A position represented in logical pixels. + * For an explanation of what logical pixels are, see description of {@linkcode LogicalSize}. + * + * @since 2.0.0 + */ +class LogicalPosition { + constructor(...args) { + this.type = 'Logical'; + if (args.length === 1) { + if ('Logical' in args[0]) { + this.x = args[0].Logical.x; + this.y = args[0].Logical.y; + } + else { + this.x = args[0].x; + this.y = args[0].y; + } + } + else { + this.x = args[0]; + this.y = args[1]; + } + } + /** + * Converts the logical position to a physical one. + * @example + * ```typescript + * import { LogicalPosition } from '@tauri-apps/api/dpi'; + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * + * const appWindow = getCurrentWindow(); + * const factor = await appWindow.scaleFactor(); + * const position = new LogicalPosition(400, 500); + * const physical = position.toPhysical(factor); + * ``` + * + * @since 2.0.0 + */ + toPhysical(scaleFactor) { + return new PhysicalPosition(this.x * scaleFactor, this.y * scaleFactor); + } + [core.SERIALIZE_TO_IPC_FN]() { + return { + x: this.x, + y: this.y + }; + } + toJSON() { + // eslint-disable-next-line security/detect-object-injection + return this[core.SERIALIZE_TO_IPC_FN](); + } +} +/** + * A position represented in physical pixels. + * + * For an explanation of what physical pixels are, see description of {@linkcode PhysicalSize}. + * + * @since 2.0.0 + */ +class PhysicalPosition { + constructor(...args) { + this.type = 'Physical'; + if (args.length === 1) { + if ('Physical' in args[0]) { + this.x = args[0].Physical.x; + this.y = args[0].Physical.y; + } + else { + this.x = args[0].x; + this.y = args[0].y; + } + } + else { + this.x = args[0]; + this.y = args[1]; + } + } + /** + * Converts the physical position to a logical one. + * @example + * ```typescript + * import { PhysicalPosition } from '@tauri-apps/api/dpi'; + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * + * const appWindow = getCurrentWindow(); + * const factor = await appWindow.scaleFactor(); + * const position = new PhysicalPosition(400, 500); + * const physical = position.toLogical(factor); + * ``` + * + * @since 2.0.0 + */ + toLogical(scaleFactor) { + return new LogicalPosition(this.x / scaleFactor, this.y / scaleFactor); + } + [core.SERIALIZE_TO_IPC_FN]() { + return { + x: this.x, + y: this.y + }; + } + toJSON() { + // eslint-disable-next-line security/detect-object-injection + return this[core.SERIALIZE_TO_IPC_FN](); + } +} +/** + * A position represented either in physical or in logical pixels. + * + * This type is basically a union type of {@linkcode LogicalSize} and {@linkcode PhysicalSize} + * but comes in handy when using `tauri::Position` in Rust as an argument to a command, as this class + * automatically serializes into a valid format so it can be deserialized correctly into `tauri::Position` + * + * So instead of + * ```typescript + * import { invoke } from '@tauri-apps/api/core'; + * import { LogicalPosition, PhysicalPosition } from '@tauri-apps/api/dpi'; + * + * const position: LogicalPosition | PhysicalPosition = someFunction(); // where someFunction returns either LogicalPosition or PhysicalPosition + * const validPosition = position instanceof LogicalPosition + * ? { Logical: { x: position.x, y: position.y } } + * : { Physical: { x: position.x, y: position.y } } + * await invoke("do_something_with_position", { position: validPosition }); + * ``` + * + * You can just use {@linkcode Position} + * ```typescript + * import { invoke } from '@tauri-apps/api/core'; + * import { LogicalPosition, PhysicalPosition, Position } from '@tauri-apps/api/dpi'; + * + * const position: LogicalPosition | PhysicalPosition = someFunction(); // where someFunction returns either LogicalPosition or PhysicalPosition + * const validPosition = new Position(position); + * await invoke("do_something_with_position", { position: validPosition }); + * ``` + * + * @since 2.1.0 + */ +class Position { + constructor(position) { + this.position = position; + } + toLogical(scaleFactor) { + return this.position instanceof LogicalPosition + ? this.position + : this.position.toLogical(scaleFactor); + } + toPhysical(scaleFactor) { + return this.position instanceof PhysicalPosition + ? this.position + : this.position.toPhysical(scaleFactor); + } + [core.SERIALIZE_TO_IPC_FN]() { + return { + [`${this.position.type}`]: { + x: this.position.x, + y: this.position.y + } + }; + } + toJSON() { + // eslint-disable-next-line security/detect-object-injection + return this[core.SERIALIZE_TO_IPC_FN](); + } +} + +exports.LogicalPosition = LogicalPosition; +exports.LogicalSize = LogicalSize; +exports.PhysicalPosition = PhysicalPosition; +exports.PhysicalSize = PhysicalSize; +exports.Position = Position; +exports.Size = Size; diff --git a/scripts/node_modules/@tauri-apps/api/dpi.d.ts b/scripts/node_modules/@tauri-apps/api/dpi.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7e6c1dadb59ab896824195e69d3e2ac72c562f1b --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/dpi.d.ts @@ -0,0 +1,289 @@ +import { SERIALIZE_TO_IPC_FN } from './core'; +/** + * A size represented in logical pixels. + * Logical pixels are scaled according to the window's DPI scale. + * Most browser APIs (i.e. `MouseEvent`'s `clientX`) will return logical pixels. + * + * For logical-pixel-based position, see {@linkcode LogicalPosition}. + * + * @since 2.0.0 + */ +declare class LogicalSize { + readonly type = "Logical"; + width: number; + height: number; + constructor(width: number, height: number); + constructor(object: { + Logical: { + width: number; + height: number; + }; + }); + constructor(object: { + width: number; + height: number; + }); + /** + * Converts the logical size to a physical one. + * @example + * ```typescript + * import { LogicalSize } from '@tauri-apps/api/dpi'; + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * + * const appWindow = getCurrentWindow(); + * const factor = await appWindow.scaleFactor(); + * const size = new LogicalSize(400, 500); + * const physical = size.toPhysical(factor); + * ``` + * + * @since 2.0.0 + */ + toPhysical(scaleFactor: number): PhysicalSize; + [SERIALIZE_TO_IPC_FN](): { + width: number; + height: number; + }; + toJSON(): { + width: number; + height: number; + }; +} +/** + * A size represented in physical pixels. + * + * Physical pixels represent actual screen pixels, and are DPI-independent. + * For high-DPI windows, this means that any point in the window on the screen + * will have a different position in logical pixels {@linkcode LogicalSize}. + * + * For physical-pixel-based position, see {@linkcode PhysicalPosition}. + * + * @since 2.0.0 + */ +declare class PhysicalSize { + readonly type = "Physical"; + width: number; + height: number; + constructor(width: number, height: number); + constructor(object: { + Physical: { + width: number; + height: number; + }; + }); + constructor(object: { + width: number; + height: number; + }); + /** + * Converts the physical size to a logical one. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const appWindow = getCurrentWindow(); + * const factor = await appWindow.scaleFactor(); + * const size = await appWindow.innerSize(); // PhysicalSize + * const logical = size.toLogical(factor); + * ``` + */ + toLogical(scaleFactor: number): LogicalSize; + [SERIALIZE_TO_IPC_FN](): { + width: number; + height: number; + }; + toJSON(): { + width: number; + height: number; + }; +} +/** + * A size represented either in physical or in logical pixels. + * + * This type is basically a union type of {@linkcode LogicalSize} and {@linkcode PhysicalSize} + * but comes in handy when using `tauri::Size` in Rust as an argument to a command, as this class + * automatically serializes into a valid format so it can be deserialized correctly into `tauri::Size` + * + * So instead of + * ```typescript + * import { invoke } from '@tauri-apps/api/core'; + * import { LogicalSize, PhysicalSize } from '@tauri-apps/api/dpi'; + * + * const size: LogicalSize | PhysicalSize = someFunction(); // where someFunction returns either LogicalSize or PhysicalSize + * const validSize = size instanceof LogicalSize + * ? { Logical: { width: size.width, height: size.height } } + * : { Physical: { width: size.width, height: size.height } } + * await invoke("do_something_with_size", { size: validSize }); + * ``` + * + * You can just use {@linkcode Size} + * ```typescript + * import { invoke } from '@tauri-apps/api/core'; + * import { LogicalSize, PhysicalSize, Size } from '@tauri-apps/api/dpi'; + * + * const size: LogicalSize | PhysicalSize = someFunction(); // where someFunction returns either LogicalSize or PhysicalSize + * const validSize = new Size(size); + * await invoke("do_something_with_size", { size: validSize }); + * ``` + * + * @since 2.1.0 + */ +declare class Size { + size: LogicalSize | PhysicalSize; + constructor(size: LogicalSize | PhysicalSize); + toLogical(scaleFactor: number): LogicalSize; + toPhysical(scaleFactor: number): PhysicalSize; + [SERIALIZE_TO_IPC_FN](): { + [x: string]: { + width: number; + height: number; + }; + }; + toJSON(): { + [x: string]: { + width: number; + height: number; + }; + }; +} +/** + * A position represented in logical pixels. + * For an explanation of what logical pixels are, see description of {@linkcode LogicalSize}. + * + * @since 2.0.0 + */ +declare class LogicalPosition { + readonly type = "Logical"; + x: number; + y: number; + constructor(x: number, y: number); + constructor(object: { + Logical: { + x: number; + y: number; + }; + }); + constructor(object: { + x: number; + y: number; + }); + /** + * Converts the logical position to a physical one. + * @example + * ```typescript + * import { LogicalPosition } from '@tauri-apps/api/dpi'; + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * + * const appWindow = getCurrentWindow(); + * const factor = await appWindow.scaleFactor(); + * const position = new LogicalPosition(400, 500); + * const physical = position.toPhysical(factor); + * ``` + * + * @since 2.0.0 + */ + toPhysical(scaleFactor: number): PhysicalPosition; + [SERIALIZE_TO_IPC_FN](): { + x: number; + y: number; + }; + toJSON(): { + x: number; + y: number; + }; +} +/** + * A position represented in physical pixels. + * + * For an explanation of what physical pixels are, see description of {@linkcode PhysicalSize}. + * + * @since 2.0.0 + */ +declare class PhysicalPosition { + readonly type = "Physical"; + x: number; + y: number; + constructor(x: number, y: number); + constructor(object: { + Physical: { + x: number; + y: number; + }; + }); + constructor(object: { + x: number; + y: number; + }); + /** + * Converts the physical position to a logical one. + * @example + * ```typescript + * import { PhysicalPosition } from '@tauri-apps/api/dpi'; + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * + * const appWindow = getCurrentWindow(); + * const factor = await appWindow.scaleFactor(); + * const position = new PhysicalPosition(400, 500); + * const physical = position.toLogical(factor); + * ``` + * + * @since 2.0.0 + */ + toLogical(scaleFactor: number): LogicalPosition; + [SERIALIZE_TO_IPC_FN](): { + x: number; + y: number; + }; + toJSON(): { + x: number; + y: number; + }; +} +/** + * A position represented either in physical or in logical pixels. + * + * This type is basically a union type of {@linkcode LogicalSize} and {@linkcode PhysicalSize} + * but comes in handy when using `tauri::Position` in Rust as an argument to a command, as this class + * automatically serializes into a valid format so it can be deserialized correctly into `tauri::Position` + * + * So instead of + * ```typescript + * import { invoke } from '@tauri-apps/api/core'; + * import { LogicalPosition, PhysicalPosition } from '@tauri-apps/api/dpi'; + * + * const position: LogicalPosition | PhysicalPosition = someFunction(); // where someFunction returns either LogicalPosition or PhysicalPosition + * const validPosition = position instanceof LogicalPosition + * ? { Logical: { x: position.x, y: position.y } } + * : { Physical: { x: position.x, y: position.y } } + * await invoke("do_something_with_position", { position: validPosition }); + * ``` + * + * You can just use {@linkcode Position} + * ```typescript + * import { invoke } from '@tauri-apps/api/core'; + * import { LogicalPosition, PhysicalPosition, Position } from '@tauri-apps/api/dpi'; + * + * const position: LogicalPosition | PhysicalPosition = someFunction(); // where someFunction returns either LogicalPosition or PhysicalPosition + * const validPosition = new Position(position); + * await invoke("do_something_with_position", { position: validPosition }); + * ``` + * + * @since 2.1.0 + */ +declare class Position { + position: LogicalPosition | PhysicalPosition; + constructor(position: LogicalPosition | PhysicalPosition); + toLogical(scaleFactor: number): LogicalPosition; + toPhysical(scaleFactor: number): PhysicalPosition; + [SERIALIZE_TO_IPC_FN](): { + [x: string]: { + x: number; + y: number; + }; + }; + toJSON(): { + [x: string]: { + x: number; + y: number; + }; + }; +} +export { LogicalPosition, LogicalSize, Size, PhysicalPosition, PhysicalSize, Position }; diff --git a/scripts/node_modules/@tauri-apps/api/dpi.js b/scripts/node_modules/@tauri-apps/api/dpi.js new file mode 100644 index 0000000000000000000000000000000000000000..f7fb4852a9001183c26cde3eba63c1f8168be26b --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/dpi.js @@ -0,0 +1,340 @@ +import { SERIALIZE_TO_IPC_FN } from './core.js'; + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * A size represented in logical pixels. + * Logical pixels are scaled according to the window's DPI scale. + * Most browser APIs (i.e. `MouseEvent`'s `clientX`) will return logical pixels. + * + * For logical-pixel-based position, see {@linkcode LogicalPosition}. + * + * @since 2.0.0 + */ +class LogicalSize { + constructor(...args) { + this.type = 'Logical'; + if (args.length === 1) { + if ('Logical' in args[0]) { + this.width = args[0].Logical.width; + this.height = args[0].Logical.height; + } + else { + this.width = args[0].width; + this.height = args[0].height; + } + } + else { + this.width = args[0]; + this.height = args[1]; + } + } + /** + * Converts the logical size to a physical one. + * @example + * ```typescript + * import { LogicalSize } from '@tauri-apps/api/dpi'; + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * + * const appWindow = getCurrentWindow(); + * const factor = await appWindow.scaleFactor(); + * const size = new LogicalSize(400, 500); + * const physical = size.toPhysical(factor); + * ``` + * + * @since 2.0.0 + */ + toPhysical(scaleFactor) { + return new PhysicalSize(this.width * scaleFactor, this.height * scaleFactor); + } + [SERIALIZE_TO_IPC_FN]() { + return { + width: this.width, + height: this.height + }; + } + toJSON() { + // eslint-disable-next-line security/detect-object-injection + return this[SERIALIZE_TO_IPC_FN](); + } +} +/** + * A size represented in physical pixels. + * + * Physical pixels represent actual screen pixels, and are DPI-independent. + * For high-DPI windows, this means that any point in the window on the screen + * will have a different position in logical pixels {@linkcode LogicalSize}. + * + * For physical-pixel-based position, see {@linkcode PhysicalPosition}. + * + * @since 2.0.0 + */ +class PhysicalSize { + constructor(...args) { + this.type = 'Physical'; + if (args.length === 1) { + if ('Physical' in args[0]) { + this.width = args[0].Physical.width; + this.height = args[0].Physical.height; + } + else { + this.width = args[0].width; + this.height = args[0].height; + } + } + else { + this.width = args[0]; + this.height = args[1]; + } + } + /** + * Converts the physical size to a logical one. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const appWindow = getCurrentWindow(); + * const factor = await appWindow.scaleFactor(); + * const size = await appWindow.innerSize(); // PhysicalSize + * const logical = size.toLogical(factor); + * ``` + */ + toLogical(scaleFactor) { + return new LogicalSize(this.width / scaleFactor, this.height / scaleFactor); + } + [SERIALIZE_TO_IPC_FN]() { + return { + width: this.width, + height: this.height + }; + } + toJSON() { + // eslint-disable-next-line security/detect-object-injection + return this[SERIALIZE_TO_IPC_FN](); + } +} +/** + * A size represented either in physical or in logical pixels. + * + * This type is basically a union type of {@linkcode LogicalSize} and {@linkcode PhysicalSize} + * but comes in handy when using `tauri::Size` in Rust as an argument to a command, as this class + * automatically serializes into a valid format so it can be deserialized correctly into `tauri::Size` + * + * So instead of + * ```typescript + * import { invoke } from '@tauri-apps/api/core'; + * import { LogicalSize, PhysicalSize } from '@tauri-apps/api/dpi'; + * + * const size: LogicalSize | PhysicalSize = someFunction(); // where someFunction returns either LogicalSize or PhysicalSize + * const validSize = size instanceof LogicalSize + * ? { Logical: { width: size.width, height: size.height } } + * : { Physical: { width: size.width, height: size.height } } + * await invoke("do_something_with_size", { size: validSize }); + * ``` + * + * You can just use {@linkcode Size} + * ```typescript + * import { invoke } from '@tauri-apps/api/core'; + * import { LogicalSize, PhysicalSize, Size } from '@tauri-apps/api/dpi'; + * + * const size: LogicalSize | PhysicalSize = someFunction(); // where someFunction returns either LogicalSize or PhysicalSize + * const validSize = new Size(size); + * await invoke("do_something_with_size", { size: validSize }); + * ``` + * + * @since 2.1.0 + */ +class Size { + constructor(size) { + this.size = size; + } + toLogical(scaleFactor) { + return this.size instanceof LogicalSize + ? this.size + : this.size.toLogical(scaleFactor); + } + toPhysical(scaleFactor) { + return this.size instanceof PhysicalSize + ? this.size + : this.size.toPhysical(scaleFactor); + } + [SERIALIZE_TO_IPC_FN]() { + return { + [`${this.size.type}`]: { + width: this.size.width, + height: this.size.height + } + }; + } + toJSON() { + // eslint-disable-next-line security/detect-object-injection + return this[SERIALIZE_TO_IPC_FN](); + } +} +/** + * A position represented in logical pixels. + * For an explanation of what logical pixels are, see description of {@linkcode LogicalSize}. + * + * @since 2.0.0 + */ +class LogicalPosition { + constructor(...args) { + this.type = 'Logical'; + if (args.length === 1) { + if ('Logical' in args[0]) { + this.x = args[0].Logical.x; + this.y = args[0].Logical.y; + } + else { + this.x = args[0].x; + this.y = args[0].y; + } + } + else { + this.x = args[0]; + this.y = args[1]; + } + } + /** + * Converts the logical position to a physical one. + * @example + * ```typescript + * import { LogicalPosition } from '@tauri-apps/api/dpi'; + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * + * const appWindow = getCurrentWindow(); + * const factor = await appWindow.scaleFactor(); + * const position = new LogicalPosition(400, 500); + * const physical = position.toPhysical(factor); + * ``` + * + * @since 2.0.0 + */ + toPhysical(scaleFactor) { + return new PhysicalPosition(this.x * scaleFactor, this.y * scaleFactor); + } + [SERIALIZE_TO_IPC_FN]() { + return { + x: this.x, + y: this.y + }; + } + toJSON() { + // eslint-disable-next-line security/detect-object-injection + return this[SERIALIZE_TO_IPC_FN](); + } +} +/** + * A position represented in physical pixels. + * + * For an explanation of what physical pixels are, see description of {@linkcode PhysicalSize}. + * + * @since 2.0.0 + */ +class PhysicalPosition { + constructor(...args) { + this.type = 'Physical'; + if (args.length === 1) { + if ('Physical' in args[0]) { + this.x = args[0].Physical.x; + this.y = args[0].Physical.y; + } + else { + this.x = args[0].x; + this.y = args[0].y; + } + } + else { + this.x = args[0]; + this.y = args[1]; + } + } + /** + * Converts the physical position to a logical one. + * @example + * ```typescript + * import { PhysicalPosition } from '@tauri-apps/api/dpi'; + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * + * const appWindow = getCurrentWindow(); + * const factor = await appWindow.scaleFactor(); + * const position = new PhysicalPosition(400, 500); + * const physical = position.toLogical(factor); + * ``` + * + * @since 2.0.0 + */ + toLogical(scaleFactor) { + return new LogicalPosition(this.x / scaleFactor, this.y / scaleFactor); + } + [SERIALIZE_TO_IPC_FN]() { + return { + x: this.x, + y: this.y + }; + } + toJSON() { + // eslint-disable-next-line security/detect-object-injection + return this[SERIALIZE_TO_IPC_FN](); + } +} +/** + * A position represented either in physical or in logical pixels. + * + * This type is basically a union type of {@linkcode LogicalSize} and {@linkcode PhysicalSize} + * but comes in handy when using `tauri::Position` in Rust as an argument to a command, as this class + * automatically serializes into a valid format so it can be deserialized correctly into `tauri::Position` + * + * So instead of + * ```typescript + * import { invoke } from '@tauri-apps/api/core'; + * import { LogicalPosition, PhysicalPosition } from '@tauri-apps/api/dpi'; + * + * const position: LogicalPosition | PhysicalPosition = someFunction(); // where someFunction returns either LogicalPosition or PhysicalPosition + * const validPosition = position instanceof LogicalPosition + * ? { Logical: { x: position.x, y: position.y } } + * : { Physical: { x: position.x, y: position.y } } + * await invoke("do_something_with_position", { position: validPosition }); + * ``` + * + * You can just use {@linkcode Position} + * ```typescript + * import { invoke } from '@tauri-apps/api/core'; + * import { LogicalPosition, PhysicalPosition, Position } from '@tauri-apps/api/dpi'; + * + * const position: LogicalPosition | PhysicalPosition = someFunction(); // where someFunction returns either LogicalPosition or PhysicalPosition + * const validPosition = new Position(position); + * await invoke("do_something_with_position", { position: validPosition }); + * ``` + * + * @since 2.1.0 + */ +class Position { + constructor(position) { + this.position = position; + } + toLogical(scaleFactor) { + return this.position instanceof LogicalPosition + ? this.position + : this.position.toLogical(scaleFactor); + } + toPhysical(scaleFactor) { + return this.position instanceof PhysicalPosition + ? this.position + : this.position.toPhysical(scaleFactor); + } + [SERIALIZE_TO_IPC_FN]() { + return { + [`${this.position.type}`]: { + x: this.position.x, + y: this.position.y + } + }; + } + toJSON() { + // eslint-disable-next-line security/detect-object-injection + return this[SERIALIZE_TO_IPC_FN](); + } +} + +export { LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize, Position, Size }; diff --git a/scripts/node_modules/@tauri-apps/api/event.cjs b/scripts/node_modules/@tauri-apps/api/event.cjs new file mode 100644 index 0000000000000000000000000000000000000000..33ee0123530aade4c8481dea476821b0ef6ff8bc --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/event.cjs @@ -0,0 +1,163 @@ +'use strict'; + +var core = require('./core.cjs'); + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * The event system allows you to emit events to the backend and listen to events from it. + * + * This package is also accessible with `window.__TAURI__.event` when [`app.withGlobalTauri`](https://v2.tauri.app/reference/config/#withglobaltauri) in `tauri.conf.json` is set to `true`. + * @module + */ +/** + * @since 1.1.0 + */ +exports.TauriEvent = void 0; +(function (TauriEvent) { + TauriEvent["WINDOW_RESIZED"] = "tauri://resize"; + TauriEvent["WINDOW_MOVED"] = "tauri://move"; + TauriEvent["WINDOW_CLOSE_REQUESTED"] = "tauri://close-requested"; + TauriEvent["WINDOW_DESTROYED"] = "tauri://destroyed"; + TauriEvent["WINDOW_FOCUS"] = "tauri://focus"; + TauriEvent["WINDOW_BLUR"] = "tauri://blur"; + TauriEvent["WINDOW_SCALE_FACTOR_CHANGED"] = "tauri://scale-change"; + TauriEvent["WINDOW_THEME_CHANGED"] = "tauri://theme-changed"; + TauriEvent["WINDOW_CREATED"] = "tauri://window-created"; + TauriEvent["WEBVIEW_CREATED"] = "tauri://webview-created"; + TauriEvent["DRAG_ENTER"] = "tauri://drag-enter"; + TauriEvent["DRAG_OVER"] = "tauri://drag-over"; + TauriEvent["DRAG_DROP"] = "tauri://drag-drop"; + TauriEvent["DRAG_LEAVE"] = "tauri://drag-leave"; +})(exports.TauriEvent || (exports.TauriEvent = {})); +/** + * Unregister the event listener associated with the given name and id. + * + * @ignore + * @param event The event name + * @param eventId Event identifier + * @returns + */ +async function _unlisten(event, eventId) { + window.__TAURI_EVENT_PLUGIN_INTERNALS__.unregisterListener(event, eventId); + await core.invoke('plugin:event|unlisten', { + event, + eventId + }); +} +/** + * Listen to an emitted event to any {@link EventTarget|target}. + * + * @example + * ```typescript + * import { listen } from '@tauri-apps/api/event'; + * const unlisten = await listen('error', (event) => { + * console.log(`Got error, payload: ${event.payload}`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler callback. + * @param options Event listening options. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + * + * @since 1.0.0 + */ +async function listen(event, handler, options) { + var _a; + const target = typeof (options === null || options === void 0 ? void 0 : options.target) === 'string' + ? { kind: 'AnyLabel', label: options.target } + : ((_a = options === null || options === void 0 ? void 0 : options.target) !== null && _a !== void 0 ? _a : { kind: 'Any' }); + return core.invoke('plugin:event|listen', { + event, + target, + handler: core.transformCallback(handler) + }).then((eventId) => { + return async () => _unlisten(event, eventId); + }); +} +/** + * Listens once to an emitted event to any {@link EventTarget|target}. + * + * @example + * ```typescript + * import { once } from '@tauri-apps/api/event'; + * interface LoadedPayload { + * loggedIn: boolean, + * token: string + * } + * const unlisten = await once('loaded', (event) => { + * console.log(`App is loaded, loggedIn: ${event.payload.loggedIn}, token: ${event.payload.token}`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler callback. + * @param options Event listening options. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + * + * @since 1.0.0 + */ +async function once(event, handler, options) { + return listen(event, (eventData) => { + void _unlisten(event, eventData.id); + handler(eventData); + }, options); +} +/** + * Emits an event to all {@link EventTarget|targets}. + * + * @example + * ```typescript + * import { emit } from '@tauri-apps/api/event'; + * await emit('frontend-loaded', { loggedIn: true, token: 'authToken' }); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param payload Event payload. + * + * @since 1.0.0 + */ +async function emit(event, payload) { + await core.invoke('plugin:event|emit', { + event, + payload + }); +} +/** + * Emits an event to all {@link EventTarget|targets} matching the given target. + * + * @example + * ```typescript + * import { emitTo } from '@tauri-apps/api/event'; + * await emitTo('main', 'frontend-loaded', { loggedIn: true, token: 'authToken' }); + * ``` + * + * @param target Label of the target Window/Webview/WebviewWindow or raw {@link EventTarget} object. + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param payload Event payload. + * + * @since 2.0.0 + */ +async function emitTo(target, event, payload) { + const eventTarget = typeof target === 'string' ? { kind: 'AnyLabel', label: target } : target; + await core.invoke('plugin:event|emit_to', { + target: eventTarget, + event, + payload + }); +} + +exports.emit = emit; +exports.emitTo = emitTo; +exports.listen = listen; +exports.once = once; diff --git a/scripts/node_modules/@tauri-apps/api/event.d.ts b/scripts/node_modules/@tauri-apps/api/event.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c110f7bb0b71dbc9a20de02a08728670fee3d237 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/event.d.ts @@ -0,0 +1,145 @@ +declare global { + interface Window { + __TAURI_EVENT_PLUGIN_INTERNALS__: { + unregisterListener: (event: string, eventId: number) => void; + }; + } +} +type EventTarget = { + kind: 'Any'; +} | { + kind: 'AnyLabel'; + label: string; +} | { + kind: 'App'; +} | { + kind: 'Window'; + label: string; +} | { + kind: 'Webview'; + label: string; +} | { + kind: 'WebviewWindow'; + label: string; +}; +interface Event { + /** Event name */ + event: EventName; + /** Event identifier used to unlisten */ + id: number; + /** Event payload */ + payload: T; +} +type EventCallback = (event: Event) => void; +type UnlistenFn = () => void; +type EventName = `${TauriEvent}` | (string & Record); +interface Options { + /** + * The event target to listen to, defaults to `{ kind: 'Any' }`, see {@link EventTarget}. + * + * If a string is provided, {@link EventTarget.AnyLabel} is used. + */ + target?: string | EventTarget; +} +/** + * @since 1.1.0 + */ +declare enum TauriEvent { + WINDOW_RESIZED = "tauri://resize", + WINDOW_MOVED = "tauri://move", + WINDOW_CLOSE_REQUESTED = "tauri://close-requested", + WINDOW_DESTROYED = "tauri://destroyed", + WINDOW_FOCUS = "tauri://focus", + WINDOW_BLUR = "tauri://blur", + WINDOW_SCALE_FACTOR_CHANGED = "tauri://scale-change", + WINDOW_THEME_CHANGED = "tauri://theme-changed", + WINDOW_CREATED = "tauri://window-created", + WEBVIEW_CREATED = "tauri://webview-created", + DRAG_ENTER = "tauri://drag-enter", + DRAG_OVER = "tauri://drag-over", + DRAG_DROP = "tauri://drag-drop", + DRAG_LEAVE = "tauri://drag-leave" +} +/** + * Listen to an emitted event to any {@link EventTarget|target}. + * + * @example + * ```typescript + * import { listen } from '@tauri-apps/api/event'; + * const unlisten = await listen('error', (event) => { + * console.log(`Got error, payload: ${event.payload}`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler callback. + * @param options Event listening options. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + * + * @since 1.0.0 + */ +declare function listen(event: EventName, handler: EventCallback, options?: Options): Promise; +/** + * Listens once to an emitted event to any {@link EventTarget|target}. + * + * @example + * ```typescript + * import { once } from '@tauri-apps/api/event'; + * interface LoadedPayload { + * loggedIn: boolean, + * token: string + * } + * const unlisten = await once('loaded', (event) => { + * console.log(`App is loaded, loggedIn: ${event.payload.loggedIn}, token: ${event.payload.token}`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler callback. + * @param options Event listening options. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + * + * @since 1.0.0 + */ +declare function once(event: EventName, handler: EventCallback, options?: Options): Promise; +/** + * Emits an event to all {@link EventTarget|targets}. + * + * @example + * ```typescript + * import { emit } from '@tauri-apps/api/event'; + * await emit('frontend-loaded', { loggedIn: true, token: 'authToken' }); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param payload Event payload. + * + * @since 1.0.0 + */ +declare function emit(event: string, payload?: T): Promise; +/** + * Emits an event to all {@link EventTarget|targets} matching the given target. + * + * @example + * ```typescript + * import { emitTo } from '@tauri-apps/api/event'; + * await emitTo('main', 'frontend-loaded', { loggedIn: true, token: 'authToken' }); + * ``` + * + * @param target Label of the target Window/Webview/WebviewWindow or raw {@link EventTarget} object. + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param payload Event payload. + * + * @since 2.0.0 + */ +declare function emitTo(target: EventTarget | string, event: string, payload?: T): Promise; +export type { Event, EventTarget, EventCallback, UnlistenFn, EventName, Options }; +export { listen, once, emit, emitTo, TauriEvent }; diff --git a/scripts/node_modules/@tauri-apps/api/event.js b/scripts/node_modules/@tauri-apps/api/event.js new file mode 100644 index 0000000000000000000000000000000000000000..5ef61bc00bf48ad8d9e72a0a6a40ffcb4d469598 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/event.js @@ -0,0 +1,158 @@ +import { invoke, transformCallback } from './core.js'; + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * The event system allows you to emit events to the backend and listen to events from it. + * + * This package is also accessible with `window.__TAURI__.event` when [`app.withGlobalTauri`](https://v2.tauri.app/reference/config/#withglobaltauri) in `tauri.conf.json` is set to `true`. + * @module + */ +/** + * @since 1.1.0 + */ +var TauriEvent; +(function (TauriEvent) { + TauriEvent["WINDOW_RESIZED"] = "tauri://resize"; + TauriEvent["WINDOW_MOVED"] = "tauri://move"; + TauriEvent["WINDOW_CLOSE_REQUESTED"] = "tauri://close-requested"; + TauriEvent["WINDOW_DESTROYED"] = "tauri://destroyed"; + TauriEvent["WINDOW_FOCUS"] = "tauri://focus"; + TauriEvent["WINDOW_BLUR"] = "tauri://blur"; + TauriEvent["WINDOW_SCALE_FACTOR_CHANGED"] = "tauri://scale-change"; + TauriEvent["WINDOW_THEME_CHANGED"] = "tauri://theme-changed"; + TauriEvent["WINDOW_CREATED"] = "tauri://window-created"; + TauriEvent["WEBVIEW_CREATED"] = "tauri://webview-created"; + TauriEvent["DRAG_ENTER"] = "tauri://drag-enter"; + TauriEvent["DRAG_OVER"] = "tauri://drag-over"; + TauriEvent["DRAG_DROP"] = "tauri://drag-drop"; + TauriEvent["DRAG_LEAVE"] = "tauri://drag-leave"; +})(TauriEvent || (TauriEvent = {})); +/** + * Unregister the event listener associated with the given name and id. + * + * @ignore + * @param event The event name + * @param eventId Event identifier + * @returns + */ +async function _unlisten(event, eventId) { + window.__TAURI_EVENT_PLUGIN_INTERNALS__.unregisterListener(event, eventId); + await invoke('plugin:event|unlisten', { + event, + eventId + }); +} +/** + * Listen to an emitted event to any {@link EventTarget|target}. + * + * @example + * ```typescript + * import { listen } from '@tauri-apps/api/event'; + * const unlisten = await listen('error', (event) => { + * console.log(`Got error, payload: ${event.payload}`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler callback. + * @param options Event listening options. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + * + * @since 1.0.0 + */ +async function listen(event, handler, options) { + var _a; + const target = typeof (options === null || options === void 0 ? void 0 : options.target) === 'string' + ? { kind: 'AnyLabel', label: options.target } + : ((_a = options === null || options === void 0 ? void 0 : options.target) !== null && _a !== void 0 ? _a : { kind: 'Any' }); + return invoke('plugin:event|listen', { + event, + target, + handler: transformCallback(handler) + }).then((eventId) => { + return async () => _unlisten(event, eventId); + }); +} +/** + * Listens once to an emitted event to any {@link EventTarget|target}. + * + * @example + * ```typescript + * import { once } from '@tauri-apps/api/event'; + * interface LoadedPayload { + * loggedIn: boolean, + * token: string + * } + * const unlisten = await once('loaded', (event) => { + * console.log(`App is loaded, loggedIn: ${event.payload.loggedIn}, token: ${event.payload.token}`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler callback. + * @param options Event listening options. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + * + * @since 1.0.0 + */ +async function once(event, handler, options) { + return listen(event, (eventData) => { + void _unlisten(event, eventData.id); + handler(eventData); + }, options); +} +/** + * Emits an event to all {@link EventTarget|targets}. + * + * @example + * ```typescript + * import { emit } from '@tauri-apps/api/event'; + * await emit('frontend-loaded', { loggedIn: true, token: 'authToken' }); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param payload Event payload. + * + * @since 1.0.0 + */ +async function emit(event, payload) { + await invoke('plugin:event|emit', { + event, + payload + }); +} +/** + * Emits an event to all {@link EventTarget|targets} matching the given target. + * + * @example + * ```typescript + * import { emitTo } from '@tauri-apps/api/event'; + * await emitTo('main', 'frontend-loaded', { loggedIn: true, token: 'authToken' }); + * ``` + * + * @param target Label of the target Window/Webview/WebviewWindow or raw {@link EventTarget} object. + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param payload Event payload. + * + * @since 2.0.0 + */ +async function emitTo(target, event, payload) { + const eventTarget = typeof target === 'string' ? { kind: 'AnyLabel', label: target } : target; + await invoke('plugin:event|emit_to', { + target: eventTarget, + event, + payload + }); +} + +export { TauriEvent, emit, emitTo, listen, once }; diff --git a/scripts/node_modules/@tauri-apps/api/external/tslib/tslib.es6.cjs b/scripts/node_modules/@tauri-apps/api/external/tslib/tslib.es6.cjs new file mode 100644 index 0000000000000000000000000000000000000000..9146d1b61c944e71f8a1fdc48fbc7c431da206cc --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/external/tslib/tslib.es6.cjs @@ -0,0 +1,39 @@ +'use strict'; + +/****************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ +/* global Reflect, Promise, SuppressedError, Symbol, Iterator */ + + +function __classPrivateFieldGet(receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +} + +function __classPrivateFieldSet(receiver, state, value, kind, f) { + if (kind === "m") throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; +} + +typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}; + +exports.__classPrivateFieldGet = __classPrivateFieldGet; +exports.__classPrivateFieldSet = __classPrivateFieldSet; diff --git a/scripts/node_modules/@tauri-apps/api/external/tslib/tslib.es6.js b/scripts/node_modules/@tauri-apps/api/external/tslib/tslib.es6.js new file mode 100644 index 0000000000000000000000000000000000000000..1dd2e1f7639a990141a515b283214b6cc836f70a --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/external/tslib/tslib.es6.js @@ -0,0 +1,36 @@ +/****************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ +/* global Reflect, Promise, SuppressedError, Symbol, Iterator */ + + +function __classPrivateFieldGet(receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +} + +function __classPrivateFieldSet(receiver, state, value, kind, f) { + if (kind === "m") throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; +} + +typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}; + +export { __classPrivateFieldGet, __classPrivateFieldSet }; diff --git a/scripts/node_modules/@tauri-apps/api/image.cjs b/scripts/node_modules/@tauri-apps/api/image.cjs new file mode 100644 index 0000000000000000000000000000000000000000..160bfc13a0cb0d428f8b056ca92527998931b198 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/image.cjs @@ -0,0 +1,88 @@ +'use strict'; + +var core = require('./core.cjs'); + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** An RGBA Image in row-major order from top to bottom. */ +class Image extends core.Resource { + /** + * Creates an Image from a resource ID. For internal use only. + * + * @ignore + */ + constructor(rid) { + super(rid); + } + /** Creates a new Image using RGBA data, in row-major order from top to bottom, and with specified width and height. */ + static async new(rgba, width, height) { + return core.invoke('plugin:image|new', { + rgba: transformImage(rgba), + width, + height + }).then((rid) => new Image(rid)); + } + /** + * Creates a new image using the provided bytes by inferring the file format. + * If the format is known, prefer [@link Image.fromPngBytes] or [@link Image.fromIcoBytes]. + * + * Only `ico` and `png` are supported (based on activated feature flag). + * + * Note that you need the `image-ico` or `image-png` Cargo features to use this API. + * To enable it, change your Cargo.toml file: + * ```toml + * [dependencies] + * tauri = { version = "...", features = ["...", "image-png"] } + * ``` + */ + static async fromBytes(bytes) { + return core.invoke('plugin:image|from_bytes', { + bytes: transformImage(bytes) + }).then((rid) => new Image(rid)); + } + /** + * Creates a new image using the provided path. + * + * Only `ico` and `png` are supported (based on activated feature flag). + * + * Note that you need the `image-ico` or `image-png` Cargo features to use this API. + * To enable it, change your Cargo.toml file: + * ```toml + * [dependencies] + * tauri = { version = "...", features = ["...", "image-png"] } + * ``` + */ + static async fromPath(path) { + return core.invoke('plugin:image|from_path', { path }).then((rid) => new Image(rid)); + } + /** Returns the RGBA data for this image, in row-major order from top to bottom. */ + async rgba() { + return core.invoke('plugin:image|rgba', { + rid: this.rid + }).then((buffer) => new Uint8Array(buffer)); + } + /** Returns the size of this image. */ + async size() { + return core.invoke('plugin:image|size', { rid: this.rid }); + } +} +/** + * Transforms image from various types into a type acceptable by Rust. + * + * See [tauri::image::JsImage](https://docs.rs/tauri/2/tauri/image/enum.JsImage.html) for more information. + * Note the API signature is not stable and might change. + */ +function transformImage(image) { + const ret = image == null + ? null + : typeof image === 'string' + ? image + : image instanceof Image + ? image.rid + : image; + return ret; +} + +exports.Image = Image; +exports.transformImage = transformImage; diff --git a/scripts/node_modules/@tauri-apps/api/image.d.ts b/scripts/node_modules/@tauri-apps/api/image.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..82f31c46c3e3094822aaea9ba39cea0ded1b7c03 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/image.d.ts @@ -0,0 +1,57 @@ +import { Resource } from './core'; +import { NativeIcon } from './menu/iconMenuItem'; +export interface ImageSize { + width: number; + height: number; +} +/** A type that represents an icon that can be used in menu items. */ +export type MenuIcon = NativeIcon | string | Image | Uint8Array | ArrayBuffer | number[]; +/** An RGBA Image in row-major order from top to bottom. */ +export declare class Image extends Resource { + /** + * Creates an Image from a resource ID. For internal use only. + * + * @ignore + */ + constructor(rid: number); + /** Creates a new Image using RGBA data, in row-major order from top to bottom, and with specified width and height. */ + static new(rgba: number[] | Uint8Array | ArrayBuffer, width: number, height: number): Promise; + /** + * Creates a new image using the provided bytes by inferring the file format. + * If the format is known, prefer [@link Image.fromPngBytes] or [@link Image.fromIcoBytes]. + * + * Only `ico` and `png` are supported (based on activated feature flag). + * + * Note that you need the `image-ico` or `image-png` Cargo features to use this API. + * To enable it, change your Cargo.toml file: + * ```toml + * [dependencies] + * tauri = { version = "...", features = ["...", "image-png"] } + * ``` + */ + static fromBytes(bytes: number[] | Uint8Array | ArrayBuffer): Promise; + /** + * Creates a new image using the provided path. + * + * Only `ico` and `png` are supported (based on activated feature flag). + * + * Note that you need the `image-ico` or `image-png` Cargo features to use this API. + * To enable it, change your Cargo.toml file: + * ```toml + * [dependencies] + * tauri = { version = "...", features = ["...", "image-png"] } + * ``` + */ + static fromPath(path: string): Promise; + /** Returns the RGBA data for this image, in row-major order from top to bottom. */ + rgba(): Promise; + /** Returns the size of this image. */ + size(): Promise; +} +/** + * Transforms image from various types into a type acceptable by Rust. + * + * See [tauri::image::JsImage](https://docs.rs/tauri/2/tauri/image/enum.JsImage.html) for more information. + * Note the API signature is not stable and might change. + */ +export declare function transformImage(image: string | Image | Uint8Array | ArrayBuffer | number[] | null): T; diff --git a/scripts/node_modules/@tauri-apps/api/image.js b/scripts/node_modules/@tauri-apps/api/image.js new file mode 100644 index 0000000000000000000000000000000000000000..66e7e84653bf0abd1670748c358d4656102c9a53 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/image.js @@ -0,0 +1,85 @@ +import { Resource, invoke } from './core.js'; + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** An RGBA Image in row-major order from top to bottom. */ +class Image extends Resource { + /** + * Creates an Image from a resource ID. For internal use only. + * + * @ignore + */ + constructor(rid) { + super(rid); + } + /** Creates a new Image using RGBA data, in row-major order from top to bottom, and with specified width and height. */ + static async new(rgba, width, height) { + return invoke('plugin:image|new', { + rgba: transformImage(rgba), + width, + height + }).then((rid) => new Image(rid)); + } + /** + * Creates a new image using the provided bytes by inferring the file format. + * If the format is known, prefer [@link Image.fromPngBytes] or [@link Image.fromIcoBytes]. + * + * Only `ico` and `png` are supported (based on activated feature flag). + * + * Note that you need the `image-ico` or `image-png` Cargo features to use this API. + * To enable it, change your Cargo.toml file: + * ```toml + * [dependencies] + * tauri = { version = "...", features = ["...", "image-png"] } + * ``` + */ + static async fromBytes(bytes) { + return invoke('plugin:image|from_bytes', { + bytes: transformImage(bytes) + }).then((rid) => new Image(rid)); + } + /** + * Creates a new image using the provided path. + * + * Only `ico` and `png` are supported (based on activated feature flag). + * + * Note that you need the `image-ico` or `image-png` Cargo features to use this API. + * To enable it, change your Cargo.toml file: + * ```toml + * [dependencies] + * tauri = { version = "...", features = ["...", "image-png"] } + * ``` + */ + static async fromPath(path) { + return invoke('plugin:image|from_path', { path }).then((rid) => new Image(rid)); + } + /** Returns the RGBA data for this image, in row-major order from top to bottom. */ + async rgba() { + return invoke('plugin:image|rgba', { + rid: this.rid + }).then((buffer) => new Uint8Array(buffer)); + } + /** Returns the size of this image. */ + async size() { + return invoke('plugin:image|size', { rid: this.rid }); + } +} +/** + * Transforms image from various types into a type acceptable by Rust. + * + * See [tauri::image::JsImage](https://docs.rs/tauri/2/tauri/image/enum.JsImage.html) for more information. + * Note the API signature is not stable and might change. + */ +function transformImage(image) { + const ret = image == null + ? null + : typeof image === 'string' + ? image + : image instanceof Image + ? image.rid + : image; + return ret; +} + +export { Image, transformImage }; diff --git a/scripts/node_modules/@tauri-apps/api/index.cjs b/scripts/node_modules/@tauri-apps/api/index.cjs new file mode 100644 index 0000000000000000000000000000000000000000..05c2266f1fbccdecd767de603877a575a3bfa6d5 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/index.cjs @@ -0,0 +1,29 @@ +'use strict'; + +var app = require('./app.cjs'); +var core = require('./core.cjs'); +var dpi = require('./dpi.cjs'); +var event = require('./event.cjs'); +var image = require('./image.cjs'); +var menu = require('./menu.cjs'); +var mocks = require('./mocks.cjs'); +var path = require('./path.cjs'); +var tray = require('./tray.cjs'); +var webview = require('./webview.cjs'); +var webviewWindow = require('./webviewWindow.cjs'); +var window = require('./window.cjs'); + + + +exports.app = app; +exports.core = core; +exports.dpi = dpi; +exports.event = event; +exports.image = image; +exports.menu = menu; +exports.mocks = mocks; +exports.path = path; +exports.tray = tray; +exports.webview = webview; +exports.webviewWindow = webviewWindow; +exports.window = window; diff --git a/scripts/node_modules/@tauri-apps/api/index.d.ts b/scripts/node_modules/@tauri-apps/api/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6111f0e200e804bb08302271e9442c9b2638264d --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/index.d.ts @@ -0,0 +1,33 @@ +/** + * The Tauri API allows you to interface with the backend layer. + * + * This module exposes all other modules as an object where the key is the module name, and the value is the module exports. + * @example + * ```typescript + * import { event, window, path } from '@tauri-apps/api' + * ``` + * + * ### Vanilla JS API + * + * The above import syntax is for JavaScript/TypeScript with a bundler. If you're using vanilla JavaScript, you can use the global `window.__TAURI__` object instead. It requires `app.withGlobalTauri` configuration option enabled. + * + * @example + * ```js + * const { event, window: tauriWindow, path } = window.__TAURI__; + * ``` + * + * @module + */ +import * as app from './app'; +import * as core from './core'; +import * as dpi from './dpi'; +import * as event from './event'; +import * as image from './image'; +import * as menu from './menu'; +import * as mocks from './mocks'; +import * as path from './path'; +import * as tray from './tray'; +import * as webview from './webview'; +import * as webviewWindow from './webviewWindow'; +import * as window from './window'; +export { app, core, dpi, event, image, menu, mocks, path, tray, webview, webviewWindow, window }; diff --git a/scripts/node_modules/@tauri-apps/api/index.js b/scripts/node_modules/@tauri-apps/api/index.js new file mode 100644 index 0000000000000000000000000000000000000000..8518a5519aff9ef61a5f4684f53c4194c7e8fb0f --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/index.js @@ -0,0 +1,24 @@ +import * as app from './app.js'; +export { app }; +import * as core from './core.js'; +export { core }; +import * as dpi from './dpi.js'; +export { dpi }; +import * as event from './event.js'; +export { event }; +import * as image from './image.js'; +export { image }; +import * as menu from './menu.js'; +export { menu }; +import * as mocks from './mocks.js'; +export { mocks }; +import * as path from './path.js'; +export { path }; +import * as tray from './tray.js'; +export { tray }; +import * as webview from './webview.js'; +export { webview }; +import * as webviewWindow from './webviewWindow.js'; +export { webviewWindow }; +import * as window from './window.js'; +export { window }; diff --git a/scripts/node_modules/@tauri-apps/api/menu.cjs b/scripts/node_modules/@tauri-apps/api/menu.cjs new file mode 100644 index 0000000000000000000000000000000000000000..13ae499163ba65efed5c1d260c0077614457cdda --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu.cjs @@ -0,0 +1,30 @@ +'use strict'; + +var submenu = require('./menu/submenu.cjs'); +var menuItem = require('./menu/menuItem.cjs'); +var menu = require('./menu/menu.cjs'); +var checkMenuItem = require('./menu/checkMenuItem.cjs'); +var iconMenuItem = require('./menu/iconMenuItem.cjs'); +var predefinedMenuItem = require('./menu/predefinedMenuItem.cjs'); + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * Menu types and utilities. + * + * This package is also accessible with `window.__TAURI__.menu` when [`app.withGlobalTauri`](https://v2.tauri.app/reference/config/#withglobaltauri) in `tauri.conf.json` is set to `true`. + * @module + */ + +exports.Submenu = submenu.Submenu; +exports.itemFromKind = submenu.itemFromKind; +exports.MenuItem = menuItem.MenuItem; +exports.Menu = menu.Menu; +exports.CheckMenuItem = checkMenuItem.CheckMenuItem; +exports.IconMenuItem = iconMenuItem.IconMenuItem; +Object.defineProperty(exports, "NativeIcon", { + enumerable: true, + get: function () { return iconMenuItem.NativeIcon; } +}); +exports.PredefinedMenuItem = predefinedMenuItem.PredefinedMenuItem; diff --git a/scripts/node_modules/@tauri-apps/api/menu.d.ts b/scripts/node_modules/@tauri-apps/api/menu.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0aacba4d3a529ad6655381b96cdd6579b359d550 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu.d.ts @@ -0,0 +1,12 @@ +export * from './menu/submenu'; +export * from './menu/menuItem'; +export * from './menu/menu'; +export * from './menu/checkMenuItem'; +export * from './menu/iconMenuItem'; +export * from './menu/predefinedMenuItem'; +/** + * Menu types and utilities. + * + * This package is also accessible with `window.__TAURI__.menu` when [`app.withGlobalTauri`](https://v2.tauri.app/reference/config/#withglobaltauri) in `tauri.conf.json` is set to `true`. + * @module + */ diff --git a/scripts/node_modules/@tauri-apps/api/menu.js b/scripts/node_modules/@tauri-apps/api/menu.js new file mode 100644 index 0000000000000000000000000000000000000000..8d1248c51a2226d2de740127bbcbabeebd738da7 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu.js @@ -0,0 +1,16 @@ +export { Submenu, itemFromKind } from './menu/submenu.js'; +export { MenuItem } from './menu/menuItem.js'; +export { Menu } from './menu/menu.js'; +export { CheckMenuItem } from './menu/checkMenuItem.js'; +export { IconMenuItem, NativeIcon } from './menu/iconMenuItem.js'; +export { PredefinedMenuItem } from './menu/predefinedMenuItem.js'; + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * Menu types and utilities. + * + * This package is also accessible with `window.__TAURI__.menu` when [`app.withGlobalTauri`](https://v2.tauri.app/reference/config/#withglobaltauri) in `tauri.conf.json` is set to `true`. + * @module + */ diff --git a/scripts/node_modules/@tauri-apps/api/menu/base.cjs b/scripts/node_modules/@tauri-apps/api/menu/base.cjs new file mode 100644 index 0000000000000000000000000000000000000000..17608e303a13159b122438f50f0f69b246ce3cf4 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu/base.cjs @@ -0,0 +1,100 @@ +'use strict'; + +var tslib_es6 = require('../external/tslib/tslib.es6.cjs'); +var core = require('../core.cjs'); +var image = require('../image.cjs'); + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +var _MenuItemBase_id, _MenuItemBase_kind; +function injectChannel(i) { + var _a; + if ('items' in i) { + i.items = (_a = i.items) === null || _a === void 0 ? void 0 : _a.map((item) => 'rid' in item ? item : injectChannel(item)); + } + else if ('action' in i && i.action) { + const handler = new core.Channel(); + handler.onmessage = i.action; + delete i.action; + return { ...i, handler }; + } + return i; +} +async function newMenu(kind, opts) { + const handler = new core.Channel(); + if (opts && typeof opts === 'object') { + if ('action' in opts && opts.action) { + handler.onmessage = opts.action; + delete opts.action; + } + // about predefined menu item icon + if ('item' in opts + && opts.item + && typeof opts.item === 'object' + && 'About' in opts.item + && opts.item.About + && typeof opts.item.About === 'object' + && 'icon' in opts.item.About + && opts.item.About.icon) { + opts.item.About.icon = image.transformImage(opts.item.About.icon); + } + // icon menu item icon + if ('icon' in opts && opts.icon) { + opts.icon = image.transformImage(opts.icon); + } + // submenu items + if ('items' in opts && opts.items) { + function prepareItem(i) { + var _a; + if ('rid' in i) { + return [i.rid, i.kind]; + } + if ('item' in i && typeof i.item === 'object' && ((_a = i.item.About) === null || _a === void 0 ? void 0 : _a.icon)) { + i.item.About.icon = image.transformImage(i.item.About.icon); + } + if ('icon' in i && i.icon) { + i.icon = image.transformImage(i.icon); + } + if ('items' in i && i.items) { + // @ts-expect-error the `prepareItem` return doesn't exactly match + // this is fine, because the difference is in `[number, string]` variant + i.items = i.items.map(prepareItem); + } + return injectChannel(i); + } + // @ts-expect-error the `prepareItem` return doesn't exactly match + // this is fine, because the difference is in `[number, string]` variant + opts.items = opts.items.map(prepareItem); + } + } + return core.invoke('plugin:menu|new', { + kind, + options: opts, + handler + }); +} +class MenuItemBase extends core.Resource { + /** The id of this item. */ + get id() { + return tslib_es6.__classPrivateFieldGet(this, _MenuItemBase_id, "f"); + } + /** @ignore */ + get kind() { + return tslib_es6.__classPrivateFieldGet(this, _MenuItemBase_kind, "f"); + } + /** @ignore */ + constructor(rid, id, kind) { + super(rid); + /** @ignore */ + _MenuItemBase_id.set(this, void 0); + /** @ignore */ + _MenuItemBase_kind.set(this, void 0); + tslib_es6.__classPrivateFieldSet(this, _MenuItemBase_id, id, "f"); + tslib_es6.__classPrivateFieldSet(this, _MenuItemBase_kind, kind, "f"); + } +} +_MenuItemBase_id = new WeakMap(), _MenuItemBase_kind = new WeakMap(); + +exports.MenuItemBase = MenuItemBase; +exports.newMenu = newMenu; diff --git a/scripts/node_modules/@tauri-apps/api/menu/base.d.ts b/scripts/node_modules/@tauri-apps/api/menu/base.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ce3a985fa4a104000468bd7cb3422d9b7192a08c --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu/base.d.ts @@ -0,0 +1,18 @@ +import { Resource } from '../core'; +import { CheckMenuItemOptions } from './checkMenuItem'; +import { IconMenuItemOptions } from './iconMenuItem'; +import { MenuOptions } from './menu'; +import { MenuItemOptions } from './menuItem'; +import { PredefinedMenuItemOptions } from './predefinedMenuItem'; +import { SubmenuOptions } from './submenu'; +export type ItemKind = 'MenuItem' | 'Predefined' | 'Check' | 'Icon' | 'Submenu' | 'Menu'; +export declare function newMenu(kind: ItemKind, opts?: MenuOptions | MenuItemOptions | SubmenuOptions | PredefinedMenuItemOptions | CheckMenuItemOptions | IconMenuItemOptions): Promise<[number, string]>; +export declare class MenuItemBase extends Resource { + #private; + /** The id of this item. */ + get id(): string; + /** @ignore */ + get kind(): string; + /** @ignore */ + protected constructor(rid: number, id: string, kind: ItemKind); +} diff --git a/scripts/node_modules/@tauri-apps/api/menu/base.js b/scripts/node_modules/@tauri-apps/api/menu/base.js new file mode 100644 index 0000000000000000000000000000000000000000..d59637aeab1c0f0a2922959e7af38d69cdc773fe --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu/base.js @@ -0,0 +1,97 @@ +import { __classPrivateFieldGet, __classPrivateFieldSet } from '../external/tslib/tslib.es6.js'; +import { Resource, Channel, invoke } from '../core.js'; +import { transformImage } from '../image.js'; + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +var _MenuItemBase_id, _MenuItemBase_kind; +function injectChannel(i) { + var _a; + if ('items' in i) { + i.items = (_a = i.items) === null || _a === void 0 ? void 0 : _a.map((item) => 'rid' in item ? item : injectChannel(item)); + } + else if ('action' in i && i.action) { + const handler = new Channel(); + handler.onmessage = i.action; + delete i.action; + return { ...i, handler }; + } + return i; +} +async function newMenu(kind, opts) { + const handler = new Channel(); + if (opts && typeof opts === 'object') { + if ('action' in opts && opts.action) { + handler.onmessage = opts.action; + delete opts.action; + } + // about predefined menu item icon + if ('item' in opts + && opts.item + && typeof opts.item === 'object' + && 'About' in opts.item + && opts.item.About + && typeof opts.item.About === 'object' + && 'icon' in opts.item.About + && opts.item.About.icon) { + opts.item.About.icon = transformImage(opts.item.About.icon); + } + // icon menu item icon + if ('icon' in opts && opts.icon) { + opts.icon = transformImage(opts.icon); + } + // submenu items + if ('items' in opts && opts.items) { + function prepareItem(i) { + var _a; + if ('rid' in i) { + return [i.rid, i.kind]; + } + if ('item' in i && typeof i.item === 'object' && ((_a = i.item.About) === null || _a === void 0 ? void 0 : _a.icon)) { + i.item.About.icon = transformImage(i.item.About.icon); + } + if ('icon' in i && i.icon) { + i.icon = transformImage(i.icon); + } + if ('items' in i && i.items) { + // @ts-expect-error the `prepareItem` return doesn't exactly match + // this is fine, because the difference is in `[number, string]` variant + i.items = i.items.map(prepareItem); + } + return injectChannel(i); + } + // @ts-expect-error the `prepareItem` return doesn't exactly match + // this is fine, because the difference is in `[number, string]` variant + opts.items = opts.items.map(prepareItem); + } + } + return invoke('plugin:menu|new', { + kind, + options: opts, + handler + }); +} +class MenuItemBase extends Resource { + /** The id of this item. */ + get id() { + return __classPrivateFieldGet(this, _MenuItemBase_id, "f"); + } + /** @ignore */ + get kind() { + return __classPrivateFieldGet(this, _MenuItemBase_kind, "f"); + } + /** @ignore */ + constructor(rid, id, kind) { + super(rid); + /** @ignore */ + _MenuItemBase_id.set(this, void 0); + /** @ignore */ + _MenuItemBase_kind.set(this, void 0); + __classPrivateFieldSet(this, _MenuItemBase_id, id, "f"); + __classPrivateFieldSet(this, _MenuItemBase_kind, kind, "f"); + } +} +_MenuItemBase_id = new WeakMap(), _MenuItemBase_kind = new WeakMap(); + +export { MenuItemBase, newMenu }; diff --git a/scripts/node_modules/@tauri-apps/api/menu/checkMenuItem.cjs b/scripts/node_modules/@tauri-apps/api/menu/checkMenuItem.cjs new file mode 100644 index 0000000000000000000000000000000000000000..469b53fdb9509f743f5a16405566a4743c91246c --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu/checkMenuItem.cjs @@ -0,0 +1,68 @@ +'use strict'; + +var base = require('./base.cjs'); +var core = require('../core.cjs'); + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * A check menu item inside a {@linkcode Menu} or {@linkcode Submenu} + * and usually contains a text and a check mark or a similar toggle + * that corresponds to a checked and unchecked states. + */ +class CheckMenuItem extends base.MenuItemBase { + /** @ignore */ + constructor(rid, id) { + super(rid, id, 'Check'); + } + /** Create a new check menu item. */ + static async new(opts) { + return base.newMenu('Check', opts).then(([rid, id]) => new CheckMenuItem(rid, id)); + } + /** Returns the text of this check menu item. */ + async text() { + return core.invoke('plugin:menu|text', { rid: this.rid, kind: this.kind }); + } + /** Sets the text for this check menu item. */ + async setText(text) { + return core.invoke('plugin:menu|set_text', { + rid: this.rid, + kind: this.kind, + text + }); + } + /** Returns whether this check menu item is enabled or not. */ + async isEnabled() { + return core.invoke('plugin:menu|is_enabled', { rid: this.rid, kind: this.kind }); + } + /** Sets whether this check menu item is enabled or not. */ + async setEnabled(enabled) { + return core.invoke('plugin:menu|set_enabled', { + rid: this.rid, + kind: this.kind, + enabled + }); + } + /** Sets the accelerator for this check menu item. */ + async setAccelerator(accelerator) { + return core.invoke('plugin:menu|set_accelerator', { + rid: this.rid, + kind: this.kind, + accelerator + }); + } + /** Returns whether this check menu item is checked or not. */ + async isChecked() { + return core.invoke('plugin:menu|is_checked', { rid: this.rid }); + } + /** Sets whether this check menu item is checked or not. */ + async setChecked(checked) { + return core.invoke('plugin:menu|set_checked', { + rid: this.rid, + checked + }); + } +} + +exports.CheckMenuItem = CheckMenuItem; diff --git a/scripts/node_modules/@tauri-apps/api/menu/checkMenuItem.d.ts b/scripts/node_modules/@tauri-apps/api/menu/checkMenuItem.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ec4aa4b714b163fe656d8a5db9cc0afe7d5a1e05 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu/checkMenuItem.d.ts @@ -0,0 +1,32 @@ +import { MenuItemBase } from './base'; +import { type MenuItemOptions } from '../menu'; +/** Options for creating a new check menu item. */ +export interface CheckMenuItemOptions extends MenuItemOptions { + /** Whether the new check menu item is enabled or not. */ + checked?: boolean; +} +/** + * A check menu item inside a {@linkcode Menu} or {@linkcode Submenu} + * and usually contains a text and a check mark or a similar toggle + * that corresponds to a checked and unchecked states. + */ +export declare class CheckMenuItem extends MenuItemBase { + /** @ignore */ + protected constructor(rid: number, id: string); + /** Create a new check menu item. */ + static new(opts: CheckMenuItemOptions): Promise; + /** Returns the text of this check menu item. */ + text(): Promise; + /** Sets the text for this check menu item. */ + setText(text: string): Promise; + /** Returns whether this check menu item is enabled or not. */ + isEnabled(): Promise; + /** Sets whether this check menu item is enabled or not. */ + setEnabled(enabled: boolean): Promise; + /** Sets the accelerator for this check menu item. */ + setAccelerator(accelerator: string | null): Promise; + /** Returns whether this check menu item is checked or not. */ + isChecked(): Promise; + /** Sets whether this check menu item is checked or not. */ + setChecked(checked: boolean): Promise; +} diff --git a/scripts/node_modules/@tauri-apps/api/menu/checkMenuItem.js b/scripts/node_modules/@tauri-apps/api/menu/checkMenuItem.js new file mode 100644 index 0000000000000000000000000000000000000000..84c4774226cace1c107f59969a673a58ce7bbe65 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu/checkMenuItem.js @@ -0,0 +1,66 @@ +import { MenuItemBase, newMenu } from './base.js'; +import { invoke } from '../core.js'; + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * A check menu item inside a {@linkcode Menu} or {@linkcode Submenu} + * and usually contains a text and a check mark or a similar toggle + * that corresponds to a checked and unchecked states. + */ +class CheckMenuItem extends MenuItemBase { + /** @ignore */ + constructor(rid, id) { + super(rid, id, 'Check'); + } + /** Create a new check menu item. */ + static async new(opts) { + return newMenu('Check', opts).then(([rid, id]) => new CheckMenuItem(rid, id)); + } + /** Returns the text of this check menu item. */ + async text() { + return invoke('plugin:menu|text', { rid: this.rid, kind: this.kind }); + } + /** Sets the text for this check menu item. */ + async setText(text) { + return invoke('plugin:menu|set_text', { + rid: this.rid, + kind: this.kind, + text + }); + } + /** Returns whether this check menu item is enabled or not. */ + async isEnabled() { + return invoke('plugin:menu|is_enabled', { rid: this.rid, kind: this.kind }); + } + /** Sets whether this check menu item is enabled or not. */ + async setEnabled(enabled) { + return invoke('plugin:menu|set_enabled', { + rid: this.rid, + kind: this.kind, + enabled + }); + } + /** Sets the accelerator for this check menu item. */ + async setAccelerator(accelerator) { + return invoke('plugin:menu|set_accelerator', { + rid: this.rid, + kind: this.kind, + accelerator + }); + } + /** Returns whether this check menu item is checked or not. */ + async isChecked() { + return invoke('plugin:menu|is_checked', { rid: this.rid }); + } + /** Sets whether this check menu item is checked or not. */ + async setChecked(checked) { + return invoke('plugin:menu|set_checked', { + rid: this.rid, + checked + }); + } +} + +export { CheckMenuItem }; diff --git a/scripts/node_modules/@tauri-apps/api/menu/iconMenuItem.cjs b/scripts/node_modules/@tauri-apps/api/menu/iconMenuItem.cjs new file mode 100644 index 0000000000000000000000000000000000000000..5a6a34b33abe8d223c91cdb32a0f67e70cbd9196 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu/iconMenuItem.cjs @@ -0,0 +1,187 @@ +'use strict'; + +var base = require('./base.cjs'); +var core = require('../core.cjs'); +var image = require('../image.cjs'); + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * A native Icon to be used for the menu item + * + * #### Platform-specific: + * + * - **Windows / Linux**: Unsupported. + */ +exports.NativeIcon = void 0; +(function (NativeIcon) { + /** An add item template image. */ + NativeIcon["Add"] = "Add"; + /** Advanced preferences toolbar icon for the preferences window. */ + NativeIcon["Advanced"] = "Advanced"; + /** A Bluetooth template image. */ + NativeIcon["Bluetooth"] = "Bluetooth"; + /** Bookmarks image suitable for a template. */ + NativeIcon["Bookmarks"] = "Bookmarks"; + /** A caution image. */ + NativeIcon["Caution"] = "Caution"; + /** A color panel toolbar icon. */ + NativeIcon["ColorPanel"] = "ColorPanel"; + /** A column view mode template image. */ + NativeIcon["ColumnView"] = "ColumnView"; + /** A computer icon. */ + NativeIcon["Computer"] = "Computer"; + /** An enter full-screen mode template image. */ + NativeIcon["EnterFullScreen"] = "EnterFullScreen"; + /** Permissions for all users. */ + NativeIcon["Everyone"] = "Everyone"; + /** An exit full-screen mode template image. */ + NativeIcon["ExitFullScreen"] = "ExitFullScreen"; + /** A cover flow view mode template image. */ + NativeIcon["FlowView"] = "FlowView"; + /** A folder image. */ + NativeIcon["Folder"] = "Folder"; + /** A burnable folder icon. */ + NativeIcon["FolderBurnable"] = "FolderBurnable"; + /** A smart folder icon. */ + NativeIcon["FolderSmart"] = "FolderSmart"; + /** A link template image. */ + NativeIcon["FollowLinkFreestanding"] = "FollowLinkFreestanding"; + /** A font panel toolbar icon. */ + NativeIcon["FontPanel"] = "FontPanel"; + /** A `go back` template image. */ + NativeIcon["GoLeft"] = "GoLeft"; + /** A `go forward` template image. */ + NativeIcon["GoRight"] = "GoRight"; + /** Home image suitable for a template. */ + NativeIcon["Home"] = "Home"; + /** An iChat Theater template image. */ + NativeIcon["IChatTheater"] = "IChatTheater"; + /** An icon view mode template image. */ + NativeIcon["IconView"] = "IconView"; + /** An information toolbar icon. */ + NativeIcon["Info"] = "Info"; + /** A template image used to denote invalid data. */ + NativeIcon["InvalidDataFreestanding"] = "InvalidDataFreestanding"; + /** A generic left-facing triangle template image. */ + NativeIcon["LeftFacingTriangle"] = "LeftFacingTriangle"; + /** A list view mode template image. */ + NativeIcon["ListView"] = "ListView"; + /** A locked padlock template image. */ + NativeIcon["LockLocked"] = "LockLocked"; + /** An unlocked padlock template image. */ + NativeIcon["LockUnlocked"] = "LockUnlocked"; + /** A horizontal dash, for use in menus. */ + NativeIcon["MenuMixedState"] = "MenuMixedState"; + /** A check mark template image, for use in menus. */ + NativeIcon["MenuOnState"] = "MenuOnState"; + /** A MobileMe icon. */ + NativeIcon["MobileMe"] = "MobileMe"; + /** A drag image for multiple items. */ + NativeIcon["MultipleDocuments"] = "MultipleDocuments"; + /** A network icon. */ + NativeIcon["Network"] = "Network"; + /** A path button template image. */ + NativeIcon["Path"] = "Path"; + /** General preferences toolbar icon for the preferences window. */ + NativeIcon["PreferencesGeneral"] = "PreferencesGeneral"; + /** A Quick Look template image. */ + NativeIcon["QuickLook"] = "QuickLook"; + /** A refresh template image. */ + NativeIcon["RefreshFreestanding"] = "RefreshFreestanding"; + /** A refresh template image. */ + NativeIcon["Refresh"] = "Refresh"; + /** A remove item template image. */ + NativeIcon["Remove"] = "Remove"; + /** A reveal contents template image. */ + NativeIcon["RevealFreestanding"] = "RevealFreestanding"; + /** A generic right-facing triangle template image. */ + NativeIcon["RightFacingTriangle"] = "RightFacingTriangle"; + /** A share view template image. */ + NativeIcon["Share"] = "Share"; + /** A slideshow template image. */ + NativeIcon["Slideshow"] = "Slideshow"; + /** A badge for a `smart` item. */ + NativeIcon["SmartBadge"] = "SmartBadge"; + /** Small green indicator, similar to iChat's available image. */ + NativeIcon["StatusAvailable"] = "StatusAvailable"; + /** Small clear indicator. */ + NativeIcon["StatusNone"] = "StatusNone"; + /** Small yellow indicator, similar to iChat's idle image. */ + NativeIcon["StatusPartiallyAvailable"] = "StatusPartiallyAvailable"; + /** Small red indicator, similar to iChat's unavailable image. */ + NativeIcon["StatusUnavailable"] = "StatusUnavailable"; + /** A stop progress template image. */ + NativeIcon["StopProgressFreestanding"] = "StopProgressFreestanding"; + /** A stop progress button template image. */ + NativeIcon["StopProgress"] = "StopProgress"; + /** An image of the empty trash can. */ + NativeIcon["TrashEmpty"] = "TrashEmpty"; + /** An image of the full trash can. */ + NativeIcon["TrashFull"] = "TrashFull"; + /** Permissions for a single user. */ + NativeIcon["User"] = "User"; + /** User account toolbar icon for the preferences window. */ + NativeIcon["UserAccounts"] = "UserAccounts"; + /** Permissions for a group of users. */ + NativeIcon["UserGroup"] = "UserGroup"; + /** Permissions for guests. */ + NativeIcon["UserGuest"] = "UserGuest"; +})(exports.NativeIcon || (exports.NativeIcon = {})); +/** + * An icon menu item inside a {@linkcode Menu} or {@linkcode Submenu} + * and usually contains an icon and a text. + */ +class IconMenuItem extends base.MenuItemBase { + /** @ignore */ + constructor(rid, id) { + super(rid, id, 'Icon'); + } + /** Create a new icon menu item. */ + static async new(opts) { + return base.newMenu('Icon', opts).then(([rid, id]) => new IconMenuItem(rid, id)); + } + /** Returns the text of this icon menu item. */ + async text() { + return core.invoke('plugin:menu|text', { rid: this.rid, kind: this.kind }); + } + /** Sets the text for this icon menu item. */ + async setText(text) { + return core.invoke('plugin:menu|set_text', { + rid: this.rid, + kind: this.kind, + text + }); + } + /** Returns whether this icon menu item is enabled or not. */ + async isEnabled() { + return core.invoke('plugin:menu|is_enabled', { rid: this.rid, kind: this.kind }); + } + /** Sets whether this icon menu item is enabled or not. */ + async setEnabled(enabled) { + return core.invoke('plugin:menu|set_enabled', { + rid: this.rid, + kind: this.kind, + enabled + }); + } + /** Sets the accelerator for this icon menu item. */ + async setAccelerator(accelerator) { + return core.invoke('plugin:menu|set_accelerator', { + rid: this.rid, + kind: this.kind, + accelerator + }); + } + /** Sets an icon for this icon menu item */ + async setIcon(icon) { + return core.invoke('plugin:menu|set_icon', { + rid: this.rid, + kind: this.kind, + icon: image.transformImage(icon) + }); + } +} + +exports.IconMenuItem = IconMenuItem; diff --git a/scripts/node_modules/@tauri-apps/api/menu/iconMenuItem.d.ts b/scripts/node_modules/@tauri-apps/api/menu/iconMenuItem.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..10ae6b9548803fee3275032e15ce1b46cae82d9d --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu/iconMenuItem.d.ts @@ -0,0 +1,160 @@ +import { MenuItemBase } from './base'; +import { type MenuItemOptions } from '../menu'; +import { MenuIcon } from '../image'; +/** + * A native Icon to be used for the menu item + * + * #### Platform-specific: + * + * - **Windows / Linux**: Unsupported. + */ +export declare enum NativeIcon { + /** An add item template image. */ + Add = "Add", + /** Advanced preferences toolbar icon for the preferences window. */ + Advanced = "Advanced", + /** A Bluetooth template image. */ + Bluetooth = "Bluetooth", + /** Bookmarks image suitable for a template. */ + Bookmarks = "Bookmarks", + /** A caution image. */ + Caution = "Caution", + /** A color panel toolbar icon. */ + ColorPanel = "ColorPanel", + /** A column view mode template image. */ + ColumnView = "ColumnView", + /** A computer icon. */ + Computer = "Computer", + /** An enter full-screen mode template image. */ + EnterFullScreen = "EnterFullScreen", + /** Permissions for all users. */ + Everyone = "Everyone", + /** An exit full-screen mode template image. */ + ExitFullScreen = "ExitFullScreen", + /** A cover flow view mode template image. */ + FlowView = "FlowView", + /** A folder image. */ + Folder = "Folder", + /** A burnable folder icon. */ + FolderBurnable = "FolderBurnable", + /** A smart folder icon. */ + FolderSmart = "FolderSmart", + /** A link template image. */ + FollowLinkFreestanding = "FollowLinkFreestanding", + /** A font panel toolbar icon. */ + FontPanel = "FontPanel", + /** A `go back` template image. */ + GoLeft = "GoLeft", + /** A `go forward` template image. */ + GoRight = "GoRight", + /** Home image suitable for a template. */ + Home = "Home", + /** An iChat Theater template image. */ + IChatTheater = "IChatTheater", + /** An icon view mode template image. */ + IconView = "IconView", + /** An information toolbar icon. */ + Info = "Info", + /** A template image used to denote invalid data. */ + InvalidDataFreestanding = "InvalidDataFreestanding", + /** A generic left-facing triangle template image. */ + LeftFacingTriangle = "LeftFacingTriangle", + /** A list view mode template image. */ + ListView = "ListView", + /** A locked padlock template image. */ + LockLocked = "LockLocked", + /** An unlocked padlock template image. */ + LockUnlocked = "LockUnlocked", + /** A horizontal dash, for use in menus. */ + MenuMixedState = "MenuMixedState", + /** A check mark template image, for use in menus. */ + MenuOnState = "MenuOnState", + /** A MobileMe icon. */ + MobileMe = "MobileMe", + /** A drag image for multiple items. */ + MultipleDocuments = "MultipleDocuments", + /** A network icon. */ + Network = "Network", + /** A path button template image. */ + Path = "Path", + /** General preferences toolbar icon for the preferences window. */ + PreferencesGeneral = "PreferencesGeneral", + /** A Quick Look template image. */ + QuickLook = "QuickLook", + /** A refresh template image. */ + RefreshFreestanding = "RefreshFreestanding", + /** A refresh template image. */ + Refresh = "Refresh", + /** A remove item template image. */ + Remove = "Remove", + /** A reveal contents template image. */ + RevealFreestanding = "RevealFreestanding", + /** A generic right-facing triangle template image. */ + RightFacingTriangle = "RightFacingTriangle", + /** A share view template image. */ + Share = "Share", + /** A slideshow template image. */ + Slideshow = "Slideshow", + /** A badge for a `smart` item. */ + SmartBadge = "SmartBadge", + /** Small green indicator, similar to iChat's available image. */ + StatusAvailable = "StatusAvailable", + /** Small clear indicator. */ + StatusNone = "StatusNone", + /** Small yellow indicator, similar to iChat's idle image. */ + StatusPartiallyAvailable = "StatusPartiallyAvailable", + /** Small red indicator, similar to iChat's unavailable image. */ + StatusUnavailable = "StatusUnavailable", + /** A stop progress template image. */ + StopProgressFreestanding = "StopProgressFreestanding", + /** A stop progress button template image. */ + StopProgress = "StopProgress", + /** An image of the empty trash can. */ + TrashEmpty = "TrashEmpty", + /** An image of the full trash can. */ + TrashFull = "TrashFull", + /** Permissions for a single user. */ + User = "User", + /** User account toolbar icon for the preferences window. */ + UserAccounts = "UserAccounts", + /** Permissions for a group of users. */ + UserGroup = "UserGroup", + /** Permissions for guests. */ + UserGuest = "UserGuest" +} +/** Options for creating a new icon menu item. */ +export interface IconMenuItemOptions extends MenuItemOptions { + /** + * Icon to be used for the new icon menu item. + * + * Note that you may need the `image-ico` or `image-png` Cargo features to use this API. + * To enable it, change your Cargo.toml file: + * ```toml + * [dependencies] + * tauri = { version = "...", features = ["...", "image-png"] } + * ``` + */ + icon?: MenuIcon; +} +/** + * An icon menu item inside a {@linkcode Menu} or {@linkcode Submenu} + * and usually contains an icon and a text. + */ +export declare class IconMenuItem extends MenuItemBase { + /** @ignore */ + protected constructor(rid: number, id: string); + /** Create a new icon menu item. */ + static new(opts: IconMenuItemOptions): Promise; + /** Returns the text of this icon menu item. */ + text(): Promise; + /** Sets the text for this icon menu item. */ + setText(text: string): Promise; + /** Returns whether this icon menu item is enabled or not. */ + isEnabled(): Promise; + /** Sets whether this icon menu item is enabled or not. */ + setEnabled(enabled: boolean): Promise; + /** Sets the accelerator for this icon menu item. */ + setAccelerator(accelerator: string | null): Promise; + /** Sets an icon for this icon menu item */ + setIcon(icon: MenuIcon | null): Promise; +} diff --git a/scripts/node_modules/@tauri-apps/api/menu/iconMenuItem.js b/scripts/node_modules/@tauri-apps/api/menu/iconMenuItem.js new file mode 100644 index 0000000000000000000000000000000000000000..6719bb0a6e159861279be31e13a5560d002f7c37 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu/iconMenuItem.js @@ -0,0 +1,185 @@ +import { MenuItemBase, newMenu } from './base.js'; +import { invoke } from '../core.js'; +import { transformImage } from '../image.js'; + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * A native Icon to be used for the menu item + * + * #### Platform-specific: + * + * - **Windows / Linux**: Unsupported. + */ +var NativeIcon; +(function (NativeIcon) { + /** An add item template image. */ + NativeIcon["Add"] = "Add"; + /** Advanced preferences toolbar icon for the preferences window. */ + NativeIcon["Advanced"] = "Advanced"; + /** A Bluetooth template image. */ + NativeIcon["Bluetooth"] = "Bluetooth"; + /** Bookmarks image suitable for a template. */ + NativeIcon["Bookmarks"] = "Bookmarks"; + /** A caution image. */ + NativeIcon["Caution"] = "Caution"; + /** A color panel toolbar icon. */ + NativeIcon["ColorPanel"] = "ColorPanel"; + /** A column view mode template image. */ + NativeIcon["ColumnView"] = "ColumnView"; + /** A computer icon. */ + NativeIcon["Computer"] = "Computer"; + /** An enter full-screen mode template image. */ + NativeIcon["EnterFullScreen"] = "EnterFullScreen"; + /** Permissions for all users. */ + NativeIcon["Everyone"] = "Everyone"; + /** An exit full-screen mode template image. */ + NativeIcon["ExitFullScreen"] = "ExitFullScreen"; + /** A cover flow view mode template image. */ + NativeIcon["FlowView"] = "FlowView"; + /** A folder image. */ + NativeIcon["Folder"] = "Folder"; + /** A burnable folder icon. */ + NativeIcon["FolderBurnable"] = "FolderBurnable"; + /** A smart folder icon. */ + NativeIcon["FolderSmart"] = "FolderSmart"; + /** A link template image. */ + NativeIcon["FollowLinkFreestanding"] = "FollowLinkFreestanding"; + /** A font panel toolbar icon. */ + NativeIcon["FontPanel"] = "FontPanel"; + /** A `go back` template image. */ + NativeIcon["GoLeft"] = "GoLeft"; + /** A `go forward` template image. */ + NativeIcon["GoRight"] = "GoRight"; + /** Home image suitable for a template. */ + NativeIcon["Home"] = "Home"; + /** An iChat Theater template image. */ + NativeIcon["IChatTheater"] = "IChatTheater"; + /** An icon view mode template image. */ + NativeIcon["IconView"] = "IconView"; + /** An information toolbar icon. */ + NativeIcon["Info"] = "Info"; + /** A template image used to denote invalid data. */ + NativeIcon["InvalidDataFreestanding"] = "InvalidDataFreestanding"; + /** A generic left-facing triangle template image. */ + NativeIcon["LeftFacingTriangle"] = "LeftFacingTriangle"; + /** A list view mode template image. */ + NativeIcon["ListView"] = "ListView"; + /** A locked padlock template image. */ + NativeIcon["LockLocked"] = "LockLocked"; + /** An unlocked padlock template image. */ + NativeIcon["LockUnlocked"] = "LockUnlocked"; + /** A horizontal dash, for use in menus. */ + NativeIcon["MenuMixedState"] = "MenuMixedState"; + /** A check mark template image, for use in menus. */ + NativeIcon["MenuOnState"] = "MenuOnState"; + /** A MobileMe icon. */ + NativeIcon["MobileMe"] = "MobileMe"; + /** A drag image for multiple items. */ + NativeIcon["MultipleDocuments"] = "MultipleDocuments"; + /** A network icon. */ + NativeIcon["Network"] = "Network"; + /** A path button template image. */ + NativeIcon["Path"] = "Path"; + /** General preferences toolbar icon for the preferences window. */ + NativeIcon["PreferencesGeneral"] = "PreferencesGeneral"; + /** A Quick Look template image. */ + NativeIcon["QuickLook"] = "QuickLook"; + /** A refresh template image. */ + NativeIcon["RefreshFreestanding"] = "RefreshFreestanding"; + /** A refresh template image. */ + NativeIcon["Refresh"] = "Refresh"; + /** A remove item template image. */ + NativeIcon["Remove"] = "Remove"; + /** A reveal contents template image. */ + NativeIcon["RevealFreestanding"] = "RevealFreestanding"; + /** A generic right-facing triangle template image. */ + NativeIcon["RightFacingTriangle"] = "RightFacingTriangle"; + /** A share view template image. */ + NativeIcon["Share"] = "Share"; + /** A slideshow template image. */ + NativeIcon["Slideshow"] = "Slideshow"; + /** A badge for a `smart` item. */ + NativeIcon["SmartBadge"] = "SmartBadge"; + /** Small green indicator, similar to iChat's available image. */ + NativeIcon["StatusAvailable"] = "StatusAvailable"; + /** Small clear indicator. */ + NativeIcon["StatusNone"] = "StatusNone"; + /** Small yellow indicator, similar to iChat's idle image. */ + NativeIcon["StatusPartiallyAvailable"] = "StatusPartiallyAvailable"; + /** Small red indicator, similar to iChat's unavailable image. */ + NativeIcon["StatusUnavailable"] = "StatusUnavailable"; + /** A stop progress template image. */ + NativeIcon["StopProgressFreestanding"] = "StopProgressFreestanding"; + /** A stop progress button template image. */ + NativeIcon["StopProgress"] = "StopProgress"; + /** An image of the empty trash can. */ + NativeIcon["TrashEmpty"] = "TrashEmpty"; + /** An image of the full trash can. */ + NativeIcon["TrashFull"] = "TrashFull"; + /** Permissions for a single user. */ + NativeIcon["User"] = "User"; + /** User account toolbar icon for the preferences window. */ + NativeIcon["UserAccounts"] = "UserAccounts"; + /** Permissions for a group of users. */ + NativeIcon["UserGroup"] = "UserGroup"; + /** Permissions for guests. */ + NativeIcon["UserGuest"] = "UserGuest"; +})(NativeIcon || (NativeIcon = {})); +/** + * An icon menu item inside a {@linkcode Menu} or {@linkcode Submenu} + * and usually contains an icon and a text. + */ +class IconMenuItem extends MenuItemBase { + /** @ignore */ + constructor(rid, id) { + super(rid, id, 'Icon'); + } + /** Create a new icon menu item. */ + static async new(opts) { + return newMenu('Icon', opts).then(([rid, id]) => new IconMenuItem(rid, id)); + } + /** Returns the text of this icon menu item. */ + async text() { + return invoke('plugin:menu|text', { rid: this.rid, kind: this.kind }); + } + /** Sets the text for this icon menu item. */ + async setText(text) { + return invoke('plugin:menu|set_text', { + rid: this.rid, + kind: this.kind, + text + }); + } + /** Returns whether this icon menu item is enabled or not. */ + async isEnabled() { + return invoke('plugin:menu|is_enabled', { rid: this.rid, kind: this.kind }); + } + /** Sets whether this icon menu item is enabled or not. */ + async setEnabled(enabled) { + return invoke('plugin:menu|set_enabled', { + rid: this.rid, + kind: this.kind, + enabled + }); + } + /** Sets the accelerator for this icon menu item. */ + async setAccelerator(accelerator) { + return invoke('plugin:menu|set_accelerator', { + rid: this.rid, + kind: this.kind, + accelerator + }); + } + /** Sets an icon for this icon menu item */ + async setIcon(icon) { + return invoke('plugin:menu|set_icon', { + rid: this.rid, + kind: this.kind, + icon: transformImage(icon) + }); + } +} + +export { IconMenuItem, NativeIcon }; diff --git a/scripts/node_modules/@tauri-apps/api/menu/menu.cjs b/scripts/node_modules/@tauri-apps/api/menu/menu.cjs new file mode 100644 index 0000000000000000000000000000000000000000..f7eb3b6c0627b960d0b76fe826dd29dc9c9e927d --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu/menu.cjs @@ -0,0 +1,148 @@ +'use strict'; + +var submenu = require('./submenu.cjs'); +var dpi = require('../dpi.cjs'); +var core = require('../core.cjs'); +var base = require('./base.cjs'); + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** A type that is either a menu bar on the window + * on Windows and Linux or as a global menu in the menubar on macOS. + * + * #### Platform-specific: + * + * - **macOS**: if using {@linkcode Menu} for the global menubar, it can only contain {@linkcode Submenu}s. + */ +class Menu extends base.MenuItemBase { + /** @ignore */ + constructor(rid, id) { + super(rid, id, 'Menu'); + } + /** Create a new menu. */ + static async new(opts) { + return base.newMenu('Menu', opts).then(([rid, id]) => new Menu(rid, id)); + } + /** Create a default menu. */ + static async default() { + return core.invoke('plugin:menu|create_default').then(([rid, id]) => new Menu(rid, id)); + } + /** + * Add a menu item to the end of this menu. + * + * #### Platform-specific: + * + * - **macOS:** Only {@linkcode Submenu}s can be added to a {@linkcode Menu}. + */ + async append(items) { + return core.invoke('plugin:menu|append', { + rid: this.rid, + kind: this.kind, + items: (Array.isArray(items) ? items : [items]).map((i) => 'rid' in i ? [i.rid, i.kind] : i) + }); + } + /** + * Add a menu item to the beginning of this menu. + * + * #### Platform-specific: + * + * - **macOS:** Only {@linkcode Submenu}s can be added to a {@linkcode Menu}. + */ + async prepend(items) { + return core.invoke('plugin:menu|prepend', { + rid: this.rid, + kind: this.kind, + items: (Array.isArray(items) ? items : [items]).map((i) => 'rid' in i ? [i.rid, i.kind] : i) + }); + } + /** + * Add a menu item to the specified position in this menu. + * + * #### Platform-specific: + * + * - **macOS:** Only {@linkcode Submenu}s can be added to a {@linkcode Menu}. + */ + async insert(items, position) { + return core.invoke('plugin:menu|insert', { + rid: this.rid, + kind: this.kind, + items: (Array.isArray(items) ? items : [items]).map((i) => 'rid' in i ? [i.rid, i.kind] : i), + position + }); + } + /** Remove a menu item from this menu. */ + async remove(item) { + return core.invoke('plugin:menu|remove', { + rid: this.rid, + kind: this.kind, + item: [item.rid, item.kind] + }); + } + /** Remove a menu item from this menu at the specified position. */ + async removeAt(position) { + return core.invoke('plugin:menu|remove_at', { + rid: this.rid, + kind: this.kind, + position + }).then(submenu.itemFromKind); + } + /** Returns a list of menu items that has been added to this menu. */ + async items() { + return core.invoke('plugin:menu|items', { + rid: this.rid, + kind: this.kind + }).then((i) => i.map(submenu.itemFromKind)); + } + /** Retrieves the menu item matching the given identifier. */ + async get(id) { + return core.invoke('plugin:menu|get', { + rid: this.rid, + kind: this.kind, + id + }).then((r) => (r ? submenu.itemFromKind(r) : null)); + } + /** + * Popup this menu as a context menu on the specified window. + * + * @param at If a position is provided, it is relative to the window's top-left corner. + * If there isn't one provided, the menu will pop up at the current location of the mouse. + */ + async popup(at, window) { + var _a; + return core.invoke('plugin:menu|popup', { + rid: this.rid, + kind: this.kind, + window: (_a = window === null || window === void 0 ? void 0 : window.label) !== null && _a !== void 0 ? _a : null, + at: at instanceof dpi.Position ? at : at ? new dpi.Position(at) : null + }); + } + /** + * Sets the app-wide menu and returns the previous one. + * + * If a window was not created with an explicit menu or had one set explicitly, + * this menu will be assigned to it. + */ + async setAsAppMenu() { + return core.invoke('plugin:menu|set_as_app_menu', { + rid: this.rid + }).then((r) => (r ? new Menu(r[0], r[1]) : null)); + } + /** + * Sets the window menu and returns the previous one. + * + * #### Platform-specific: + * + * - **macOS:** Unsupported. The menu on macOS is app-wide and not specific to one + * window, if you need to set it, use {@linkcode Menu.setAsAppMenu} instead. + */ + async setAsWindowMenu(window) { + var _a; + return core.invoke('plugin:menu|set_as_window_menu', { + rid: this.rid, + window: (_a = window === null || window === void 0 ? void 0 : window.label) !== null && _a !== void 0 ? _a : null + }).then((r) => (r ? new Menu(r[0], r[1]) : null)); + } +} + +exports.Menu = Menu; diff --git a/scripts/node_modules/@tauri-apps/api/menu/menu.d.ts b/scripts/node_modules/@tauri-apps/api/menu/menu.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..194673cdb8e786ba854111562a0735baabe7d6a6 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu/menu.d.ts @@ -0,0 +1,86 @@ +import { MenuItemOptions, SubmenuOptions, IconMenuItemOptions, PredefinedMenuItemOptions, CheckMenuItemOptions } from '../menu'; +import { MenuItem } from './menuItem'; +import { CheckMenuItem } from './checkMenuItem'; +import { IconMenuItem } from './iconMenuItem'; +import { PredefinedMenuItem } from './predefinedMenuItem'; +import { Submenu } from './submenu'; +import { type LogicalPosition, PhysicalPosition, Position } from '../dpi'; +import { type Window } from '../window'; +import { MenuItemBase } from './base'; +/** Options for creating a new menu. */ +export interface MenuOptions { + /** Specify an id to use for the new menu. */ + id?: string; + /** List of items to add to the new menu. */ + items?: Array; +} +/** A type that is either a menu bar on the window + * on Windows and Linux or as a global menu in the menubar on macOS. + * + * #### Platform-specific: + * + * - **macOS**: if using {@linkcode Menu} for the global menubar, it can only contain {@linkcode Submenu}s. + */ +export declare class Menu extends MenuItemBase { + /** @ignore */ + protected constructor(rid: number, id: string); + /** Create a new menu. */ + static new(opts?: MenuOptions): Promise; + /** Create a default menu. */ + static default(): Promise; + /** + * Add a menu item to the end of this menu. + * + * #### Platform-specific: + * + * - **macOS:** Only {@linkcode Submenu}s can be added to a {@linkcode Menu}. + */ + append(items: T | T[]): Promise; + /** + * Add a menu item to the beginning of this menu. + * + * #### Platform-specific: + * + * - **macOS:** Only {@linkcode Submenu}s can be added to a {@linkcode Menu}. + */ + prepend(items: T | T[]): Promise; + /** + * Add a menu item to the specified position in this menu. + * + * #### Platform-specific: + * + * - **macOS:** Only {@linkcode Submenu}s can be added to a {@linkcode Menu}. + */ + insert(items: T | T[], position: number): Promise; + /** Remove a menu item from this menu. */ + remove(item: Submenu | MenuItem | PredefinedMenuItem | CheckMenuItem | IconMenuItem): Promise; + /** Remove a menu item from this menu at the specified position. */ + removeAt(position: number): Promise; + /** Returns a list of menu items that has been added to this menu. */ + items(): Promise>; + /** Retrieves the menu item matching the given identifier. */ + get(id: string): Promise; + /** + * Popup this menu as a context menu on the specified window. + * + * @param at If a position is provided, it is relative to the window's top-left corner. + * If there isn't one provided, the menu will pop up at the current location of the mouse. + */ + popup(at?: PhysicalPosition | LogicalPosition | Position, window?: Window): Promise; + /** + * Sets the app-wide menu and returns the previous one. + * + * If a window was not created with an explicit menu or had one set explicitly, + * this menu will be assigned to it. + */ + setAsAppMenu(): Promise; + /** + * Sets the window menu and returns the previous one. + * + * #### Platform-specific: + * + * - **macOS:** Unsupported. The menu on macOS is app-wide and not specific to one + * window, if you need to set it, use {@linkcode Menu.setAsAppMenu} instead. + */ + setAsWindowMenu(window?: Window): Promise; +} diff --git a/scripts/node_modules/@tauri-apps/api/menu/menu.js b/scripts/node_modules/@tauri-apps/api/menu/menu.js new file mode 100644 index 0000000000000000000000000000000000000000..91532831205d0eb18bdae9f943bc9c109ba20a36 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu/menu.js @@ -0,0 +1,146 @@ +import { itemFromKind } from './submenu.js'; +import { Position } from '../dpi.js'; +import { invoke } from '../core.js'; +import { MenuItemBase, newMenu } from './base.js'; + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** A type that is either a menu bar on the window + * on Windows and Linux or as a global menu in the menubar on macOS. + * + * #### Platform-specific: + * + * - **macOS**: if using {@linkcode Menu} for the global menubar, it can only contain {@linkcode Submenu}s. + */ +class Menu extends MenuItemBase { + /** @ignore */ + constructor(rid, id) { + super(rid, id, 'Menu'); + } + /** Create a new menu. */ + static async new(opts) { + return newMenu('Menu', opts).then(([rid, id]) => new Menu(rid, id)); + } + /** Create a default menu. */ + static async default() { + return invoke('plugin:menu|create_default').then(([rid, id]) => new Menu(rid, id)); + } + /** + * Add a menu item to the end of this menu. + * + * #### Platform-specific: + * + * - **macOS:** Only {@linkcode Submenu}s can be added to a {@linkcode Menu}. + */ + async append(items) { + return invoke('plugin:menu|append', { + rid: this.rid, + kind: this.kind, + items: (Array.isArray(items) ? items : [items]).map((i) => 'rid' in i ? [i.rid, i.kind] : i) + }); + } + /** + * Add a menu item to the beginning of this menu. + * + * #### Platform-specific: + * + * - **macOS:** Only {@linkcode Submenu}s can be added to a {@linkcode Menu}. + */ + async prepend(items) { + return invoke('plugin:menu|prepend', { + rid: this.rid, + kind: this.kind, + items: (Array.isArray(items) ? items : [items]).map((i) => 'rid' in i ? [i.rid, i.kind] : i) + }); + } + /** + * Add a menu item to the specified position in this menu. + * + * #### Platform-specific: + * + * - **macOS:** Only {@linkcode Submenu}s can be added to a {@linkcode Menu}. + */ + async insert(items, position) { + return invoke('plugin:menu|insert', { + rid: this.rid, + kind: this.kind, + items: (Array.isArray(items) ? items : [items]).map((i) => 'rid' in i ? [i.rid, i.kind] : i), + position + }); + } + /** Remove a menu item from this menu. */ + async remove(item) { + return invoke('plugin:menu|remove', { + rid: this.rid, + kind: this.kind, + item: [item.rid, item.kind] + }); + } + /** Remove a menu item from this menu at the specified position. */ + async removeAt(position) { + return invoke('plugin:menu|remove_at', { + rid: this.rid, + kind: this.kind, + position + }).then(itemFromKind); + } + /** Returns a list of menu items that has been added to this menu. */ + async items() { + return invoke('plugin:menu|items', { + rid: this.rid, + kind: this.kind + }).then((i) => i.map(itemFromKind)); + } + /** Retrieves the menu item matching the given identifier. */ + async get(id) { + return invoke('plugin:menu|get', { + rid: this.rid, + kind: this.kind, + id + }).then((r) => (r ? itemFromKind(r) : null)); + } + /** + * Popup this menu as a context menu on the specified window. + * + * @param at If a position is provided, it is relative to the window's top-left corner. + * If there isn't one provided, the menu will pop up at the current location of the mouse. + */ + async popup(at, window) { + var _a; + return invoke('plugin:menu|popup', { + rid: this.rid, + kind: this.kind, + window: (_a = window === null || window === void 0 ? void 0 : window.label) !== null && _a !== void 0 ? _a : null, + at: at instanceof Position ? at : at ? new Position(at) : null + }); + } + /** + * Sets the app-wide menu and returns the previous one. + * + * If a window was not created with an explicit menu or had one set explicitly, + * this menu will be assigned to it. + */ + async setAsAppMenu() { + return invoke('plugin:menu|set_as_app_menu', { + rid: this.rid + }).then((r) => (r ? new Menu(r[0], r[1]) : null)); + } + /** + * Sets the window menu and returns the previous one. + * + * #### Platform-specific: + * + * - **macOS:** Unsupported. The menu on macOS is app-wide and not specific to one + * window, if you need to set it, use {@linkcode Menu.setAsAppMenu} instead. + */ + async setAsWindowMenu(window) { + var _a; + return invoke('plugin:menu|set_as_window_menu', { + rid: this.rid, + window: (_a = window === null || window === void 0 ? void 0 : window.label) !== null && _a !== void 0 ? _a : null + }).then((r) => (r ? new Menu(r[0], r[1]) : null)); + } +} + +export { Menu }; diff --git a/scripts/node_modules/@tauri-apps/api/menu/menuItem.cjs b/scripts/node_modules/@tauri-apps/api/menu/menuItem.cjs new file mode 100644 index 0000000000000000000000000000000000000000..c16526f83f14635672e392733c03306562df5f16 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu/menuItem.cjs @@ -0,0 +1,53 @@ +'use strict'; + +var base = require('./base.cjs'); +var core = require('../core.cjs'); + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** A menu item inside a {@linkcode Menu} or {@linkcode Submenu} and contains only text. */ +class MenuItem extends base.MenuItemBase { + /** @ignore */ + constructor(rid, id) { + super(rid, id, 'MenuItem'); + } + /** Create a new menu item. */ + static async new(opts) { + return base.newMenu('MenuItem', opts).then(([rid, id]) => new MenuItem(rid, id)); + } + /** Returns the text of this menu item. */ + async text() { + return core.invoke('plugin:menu|text', { rid: this.rid, kind: this.kind }); + } + /** Sets the text for this menu item. */ + async setText(text) { + return core.invoke('plugin:menu|set_text', { + rid: this.rid, + kind: this.kind, + text + }); + } + /** Returns whether this menu item is enabled or not. */ + async isEnabled() { + return core.invoke('plugin:menu|is_enabled', { rid: this.rid, kind: this.kind }); + } + /** Sets whether this menu item is enabled or not. */ + async setEnabled(enabled) { + return core.invoke('plugin:menu|set_enabled', { + rid: this.rid, + kind: this.kind, + enabled + }); + } + /** Sets the accelerator for this menu item. */ + async setAccelerator(accelerator) { + return core.invoke('plugin:menu|set_accelerator', { + rid: this.rid, + kind: this.kind, + accelerator + }); + } +} + +exports.MenuItem = MenuItem; diff --git a/scripts/node_modules/@tauri-apps/api/menu/menuItem.d.ts b/scripts/node_modules/@tauri-apps/api/menu/menuItem.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b57093a80119fc2e663351f9c1ced21cc47c2dbc --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu/menuItem.d.ts @@ -0,0 +1,31 @@ +import { MenuItemBase } from './base'; +/** Options for creating a new menu item. */ +export interface MenuItemOptions { + /** Specify an id to use for the new menu item. */ + id?: string; + /** The text of the new menu item. */ + text: string; + /** Whether the new menu item is enabled or not. */ + enabled?: boolean; + /** Specify an accelerator for the new menu item. */ + accelerator?: string; + /** Specify a handler to be called when this menu item is activated. */ + action?: (id: string) => void; +} +/** A menu item inside a {@linkcode Menu} or {@linkcode Submenu} and contains only text. */ +export declare class MenuItem extends MenuItemBase { + /** @ignore */ + protected constructor(rid: number, id: string); + /** Create a new menu item. */ + static new(opts: MenuItemOptions): Promise; + /** Returns the text of this menu item. */ + text(): Promise; + /** Sets the text for this menu item. */ + setText(text: string): Promise; + /** Returns whether this menu item is enabled or not. */ + isEnabled(): Promise; + /** Sets whether this menu item is enabled or not. */ + setEnabled(enabled: boolean): Promise; + /** Sets the accelerator for this menu item. */ + setAccelerator(accelerator: string | null): Promise; +} diff --git a/scripts/node_modules/@tauri-apps/api/menu/menuItem.js b/scripts/node_modules/@tauri-apps/api/menu/menuItem.js new file mode 100644 index 0000000000000000000000000000000000000000..098101ccd8b4dd30e5271acf45cab16b1e26ed25 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu/menuItem.js @@ -0,0 +1,51 @@ +import { MenuItemBase, newMenu } from './base.js'; +import { invoke } from '../core.js'; + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** A menu item inside a {@linkcode Menu} or {@linkcode Submenu} and contains only text. */ +class MenuItem extends MenuItemBase { + /** @ignore */ + constructor(rid, id) { + super(rid, id, 'MenuItem'); + } + /** Create a new menu item. */ + static async new(opts) { + return newMenu('MenuItem', opts).then(([rid, id]) => new MenuItem(rid, id)); + } + /** Returns the text of this menu item. */ + async text() { + return invoke('plugin:menu|text', { rid: this.rid, kind: this.kind }); + } + /** Sets the text for this menu item. */ + async setText(text) { + return invoke('plugin:menu|set_text', { + rid: this.rid, + kind: this.kind, + text + }); + } + /** Returns whether this menu item is enabled or not. */ + async isEnabled() { + return invoke('plugin:menu|is_enabled', { rid: this.rid, kind: this.kind }); + } + /** Sets whether this menu item is enabled or not. */ + async setEnabled(enabled) { + return invoke('plugin:menu|set_enabled', { + rid: this.rid, + kind: this.kind, + enabled + }); + } + /** Sets the accelerator for this menu item. */ + async setAccelerator(accelerator) { + return invoke('plugin:menu|set_accelerator', { + rid: this.rid, + kind: this.kind, + accelerator + }); + } +} + +export { MenuItem }; diff --git a/scripts/node_modules/@tauri-apps/api/menu/predefinedMenuItem.cjs b/scripts/node_modules/@tauri-apps/api/menu/predefinedMenuItem.cjs new file mode 100644 index 0000000000000000000000000000000000000000..a6930739c41c3d468d81d317bd4dc367a56ac0d9 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu/predefinedMenuItem.cjs @@ -0,0 +1,33 @@ +'use strict'; + +var base = require('./base.cjs'); +var core = require('../core.cjs'); + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** A predefined (native) menu item which has a predefined behavior by the OS or by tauri. */ +class PredefinedMenuItem extends base.MenuItemBase { + /** @ignore */ + constructor(rid, id) { + super(rid, id, 'Predefined'); + } + /** Create a new predefined menu item. */ + static async new(opts) { + return base.newMenu('Predefined', opts).then(([rid, id]) => new PredefinedMenuItem(rid, id)); + } + /** Returns the text of this predefined menu item. */ + async text() { + return core.invoke('plugin:menu|text', { rid: this.rid, kind: this.kind }); + } + /** Sets the text for this predefined menu item. */ + async setText(text) { + return core.invoke('plugin:menu|set_text', { + rid: this.rid, + kind: this.kind, + text + }); + } +} + +exports.PredefinedMenuItem = PredefinedMenuItem; diff --git a/scripts/node_modules/@tauri-apps/api/menu/predefinedMenuItem.d.ts b/scripts/node_modules/@tauri-apps/api/menu/predefinedMenuItem.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b41a7cd908f2a4db1856e1aee99fb4263422bec6 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu/predefinedMenuItem.d.ts @@ -0,0 +1,95 @@ +import { MenuItemBase } from './base'; +import { Image } from '../image'; +/** A metadata for the about predefined menu item. */ +export interface AboutMetadata { + /** Sets the application name. */ + name?: string; + /** The application version. */ + version?: string; + /** + * The short version, e.g. "1.0". + * + * #### Platform-specific + * + * - **Windows / Linux:** Appended to the end of `version` in parentheses. + */ + shortVersion?: string; + /** + * The authors of the application. + * + * #### Platform-specific + * + * - **macOS:** Unsupported. + */ + authors?: string[]; + /** + * Application comments. + * + * #### Platform-specific + * + * - **macOS:** Unsupported. + */ + comments?: string; + /** The copyright of the application. */ + copyright?: string; + /** + * The license of the application. + * + * #### Platform-specific + * + * - **macOS:** Unsupported. + */ + license?: string; + /** + * The application website. + * + * #### Platform-specific + * + * - **macOS:** Unsupported. + */ + website?: string; + /** + * The website label. + * + * #### Platform-specific + * + * - **macOS:** Unsupported. + */ + websiteLabel?: string; + /** + * The credits. + * + * #### Platform-specific + * + * - **Windows / Linux:** Unsupported. + */ + credits?: string; + /** + * The application icon. + * + * #### Platform-specific + * + * - **Windows:** Unsupported. + */ + icon?: string | Uint8Array | ArrayBuffer | number[] | Image; +} +/** Options for creating a new predefined menu item. */ +export interface PredefinedMenuItemOptions { + /** The text of the new predefined menu item. */ + text?: string; + /** The predefined item type */ + item: 'Separator' | 'Copy' | 'Cut' | 'Paste' | 'SelectAll' | 'Undo' | 'Redo' | 'Minimize' | 'Maximize' | 'Fullscreen' | 'Hide' | 'HideOthers' | 'ShowAll' | 'CloseWindow' | 'Quit' | 'Services' | { + About: AboutMetadata | null; + }; +} +/** A predefined (native) menu item which has a predefined behavior by the OS or by tauri. */ +export declare class PredefinedMenuItem extends MenuItemBase { + /** @ignore */ + protected constructor(rid: number, id: string); + /** Create a new predefined menu item. */ + static new(opts?: PredefinedMenuItemOptions): Promise; + /** Returns the text of this predefined menu item. */ + text(): Promise; + /** Sets the text for this predefined menu item. */ + setText(text: string): Promise; +} diff --git a/scripts/node_modules/@tauri-apps/api/menu/predefinedMenuItem.js b/scripts/node_modules/@tauri-apps/api/menu/predefinedMenuItem.js new file mode 100644 index 0000000000000000000000000000000000000000..2e8625449ac1a2c72297c4a36cfeea2088e4ee81 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu/predefinedMenuItem.js @@ -0,0 +1,31 @@ +import { MenuItemBase, newMenu } from './base.js'; +import { invoke } from '../core.js'; + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** A predefined (native) menu item which has a predefined behavior by the OS or by tauri. */ +class PredefinedMenuItem extends MenuItemBase { + /** @ignore */ + constructor(rid, id) { + super(rid, id, 'Predefined'); + } + /** Create a new predefined menu item. */ + static async new(opts) { + return newMenu('Predefined', opts).then(([rid, id]) => new PredefinedMenuItem(rid, id)); + } + /** Returns the text of this predefined menu item. */ + async text() { + return invoke('plugin:menu|text', { rid: this.rid, kind: this.kind }); + } + /** Sets the text for this predefined menu item. */ + async setText(text) { + return invoke('plugin:menu|set_text', { + rid: this.rid, + kind: this.kind, + text + }); + } +} + +export { PredefinedMenuItem }; diff --git a/scripts/node_modules/@tauri-apps/api/menu/submenu.cjs b/scripts/node_modules/@tauri-apps/api/menu/submenu.cjs new file mode 100644 index 0000000000000000000000000000000000000000..aab25a2cf72d04dffe33525e879b6f443db084c3 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu/submenu.cjs @@ -0,0 +1,203 @@ +'use strict'; + +var menuItem = require('./menuItem.cjs'); +var checkMenuItem = require('./checkMenuItem.cjs'); +var iconMenuItem = require('./iconMenuItem.cjs'); +var predefinedMenuItem = require('./predefinedMenuItem.cjs'); +var core = require('../core.cjs'); +var base = require('./base.cjs'); +var dpi = require('../dpi.cjs'); +var image = require('../image.cjs'); + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** @ignore */ +function itemFromKind([rid, id, kind]) { + /* eslint-disable @typescript-eslint/no-unsafe-return */ + switch (kind) { + case 'Submenu': + // @ts-expect-error constructor is protected for external usage only, safe for us to use + return new Submenu(rid, id); + case 'Predefined': + // @ts-expect-error constructor is protected for external usage only, safe for us to use + return new predefinedMenuItem.PredefinedMenuItem(rid, id); + case 'Check': + // @ts-expect-error constructor is protected for external usage only, safe for us to use + return new checkMenuItem.CheckMenuItem(rid, id); + case 'Icon': + // @ts-expect-error constructor is protected for external usage only, safe for us to use + return new iconMenuItem.IconMenuItem(rid, id); + case 'MenuItem': + default: + // @ts-expect-error constructor is protected for external usage only, safe for us to use + return new menuItem.MenuItem(rid, id); + } + /* eslint-enable @typescript-eslint/no-unsafe-return */ +} +/** A type that is a submenu inside a {@linkcode Menu} or {@linkcode Submenu}. */ +class Submenu extends base.MenuItemBase { + /** @ignore */ + constructor(rid, id) { + super(rid, id, 'Submenu'); + } + /** Create a new submenu. */ + static async new(opts) { + return base.newMenu('Submenu', opts).then(([rid, id]) => new Submenu(rid, id)); + } + /** Returns the text of this submenu. */ + async text() { + return core.invoke('plugin:menu|text', { rid: this.rid, kind: this.kind }); + } + /** Sets the text for this submenu. */ + async setText(text) { + return core.invoke('plugin:menu|set_text', { + rid: this.rid, + kind: this.kind, + text + }); + } + /** Returns whether this submenu is enabled or not. */ + async isEnabled() { + return core.invoke('plugin:menu|is_enabled', { rid: this.rid, kind: this.kind }); + } + /** Sets whether this submenu is enabled or not. */ + async setEnabled(enabled) { + return core.invoke('plugin:menu|set_enabled', { + rid: this.rid, + kind: this.kind, + enabled + }); + } + /** + * Add a menu item to the end of this submenu. + * + * #### Platform-specific: + * + * - **macOS:** Only {@linkcode Submenu}s can be added to a {@linkcode Menu}. + */ + async append(items) { + return core.invoke('plugin:menu|append', { + rid: this.rid, + kind: this.kind, + items: (Array.isArray(items) ? items : [items]).map((i) => 'rid' in i ? [i.rid, i.kind] : i) + }); + } + /** + * Add a menu item to the beginning of this submenu. + * + * #### Platform-specific: + * + * - **macOS:** Only {@linkcode Submenu}s can be added to a {@linkcode Menu}. + */ + async prepend(items) { + return core.invoke('plugin:menu|prepend', { + rid: this.rid, + kind: this.kind, + items: (Array.isArray(items) ? items : [items]).map((i) => 'rid' in i ? [i.rid, i.kind] : i) + }); + } + /** + * Add a menu item to the specified position in this submenu. + * + * #### Platform-specific: + * + * - **macOS:** Only {@linkcode Submenu}s can be added to a {@linkcode Menu}. + */ + async insert(items, position) { + return core.invoke('plugin:menu|insert', { + rid: this.rid, + kind: this.kind, + items: (Array.isArray(items) ? items : [items]).map((i) => 'rid' in i ? [i.rid, i.kind] : i), + position + }); + } + /** Remove a menu item from this submenu. */ + async remove(item) { + return core.invoke('plugin:menu|remove', { + rid: this.rid, + kind: this.kind, + item: [item.rid, item.kind] + }); + } + /** Remove a menu item from this submenu at the specified position. */ + async removeAt(position) { + return core.invoke('plugin:menu|remove_at', { + rid: this.rid, + kind: this.kind, + position + }).then(itemFromKind); + } + /** Returns a list of menu items that has been added to this submenu. */ + async items() { + return core.invoke('plugin:menu|items', { + rid: this.rid, + kind: this.kind + }).then((i) => i.map(itemFromKind)); + } + /** Retrieves the menu item matching the given identifier. */ + async get(id) { + return core.invoke('plugin:menu|get', { + rid: this.rid, + kind: this.kind, + id + }).then((r) => (r ? itemFromKind(r) : null)); + } + /** + * Popup this submenu as a context menu on the specified window. + * + * If the position, is provided, it is relative to the window's top-left corner. + */ + async popup(at, window) { + var _a; + return core.invoke('plugin:menu|popup', { + rid: this.rid, + kind: this.kind, + window: (_a = window === null || window === void 0 ? void 0 : window.label) !== null && _a !== void 0 ? _a : null, + at: at instanceof dpi.Position ? at : at ? new dpi.Position(at) : null + }); + } + /** + * Set this submenu as the Window menu for the application on macOS. + * + * This will cause macOS to automatically add window-switching items and + * certain other items to the menu. + * + * #### Platform-specific: + * + * - **Windows / Linux**: Unsupported. + */ + async setAsWindowsMenuForNSApp() { + return core.invoke('plugin:menu|set_as_windows_menu_for_nsapp', { + rid: this.rid + }); + } + /** + * Set this submenu as the Help menu for the application on macOS. + * + * This will cause macOS to automatically add a search box to the menu. + * + * If no menu is set as the Help menu, macOS will automatically use any menu + * which has a title matching the localized word "Help". + * + * #### Platform-specific: + * + * - **Windows / Linux**: Unsupported. + */ + async setAsHelpMenuForNSApp() { + return core.invoke('plugin:menu|set_as_help_menu_for_nsapp', { + rid: this.rid + }); + } + /** Sets an icon for this submenu */ + async setIcon(icon) { + return core.invoke('plugin:menu|set_icon', { + rid: this.rid, + kind: this.kind, + icon: image.transformImage(icon) + }); + } +} + +exports.Submenu = Submenu; +exports.itemFromKind = itemFromKind; diff --git a/scripts/node_modules/@tauri-apps/api/menu/submenu.d.ts b/scripts/node_modules/@tauri-apps/api/menu/submenu.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6e5ee8b3b9157657e864edad02cd319cdfe382ef --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu/submenu.d.ts @@ -0,0 +1,97 @@ +import { IconMenuItemOptions, PredefinedMenuItemOptions, CheckMenuItemOptions } from '../menu'; +import { MenuItem, type MenuItemOptions } from './menuItem'; +import { CheckMenuItem } from './checkMenuItem'; +import { IconMenuItem } from './iconMenuItem'; +import { PredefinedMenuItem } from './predefinedMenuItem'; +import { type LogicalPosition, PhysicalPosition, type Window } from '../window'; +import { type ItemKind, MenuItemBase } from './base'; +import { type MenuOptions } from './menu'; +import { MenuIcon } from '../image'; +/** @ignore */ +export declare function itemFromKind([rid, id, kind]: [number, string, ItemKind]): Submenu | MenuItem | PredefinedMenuItem | CheckMenuItem | IconMenuItem; +export type SubmenuOptions = (Omit & MenuOptions) & { + /** + * Icon to be used for the submenu. + * Note: you may need the `image-ico` or `image-png` Cargo features to use this API. + */ + icon?: MenuIcon; +}; +/** A type that is a submenu inside a {@linkcode Menu} or {@linkcode Submenu}. */ +export declare class Submenu extends MenuItemBase { + /** @ignore */ + protected constructor(rid: number, id: string); + /** Create a new submenu. */ + static new(opts: SubmenuOptions): Promise; + /** Returns the text of this submenu. */ + text(): Promise; + /** Sets the text for this submenu. */ + setText(text: string): Promise; + /** Returns whether this submenu is enabled or not. */ + isEnabled(): Promise; + /** Sets whether this submenu is enabled or not. */ + setEnabled(enabled: boolean): Promise; + /** + * Add a menu item to the end of this submenu. + * + * #### Platform-specific: + * + * - **macOS:** Only {@linkcode Submenu}s can be added to a {@linkcode Menu}. + */ + append(items: T | T[]): Promise; + /** + * Add a menu item to the beginning of this submenu. + * + * #### Platform-specific: + * + * - **macOS:** Only {@linkcode Submenu}s can be added to a {@linkcode Menu}. + */ + prepend(items: T | T[]): Promise; + /** + * Add a menu item to the specified position in this submenu. + * + * #### Platform-specific: + * + * - **macOS:** Only {@linkcode Submenu}s can be added to a {@linkcode Menu}. + */ + insert(items: T | T[], position: number): Promise; + /** Remove a menu item from this submenu. */ + remove(item: Submenu | MenuItem | PredefinedMenuItem | CheckMenuItem | IconMenuItem): Promise; + /** Remove a menu item from this submenu at the specified position. */ + removeAt(position: number): Promise; + /** Returns a list of menu items that has been added to this submenu. */ + items(): Promise>; + /** Retrieves the menu item matching the given identifier. */ + get(id: string): Promise; + /** + * Popup this submenu as a context menu on the specified window. + * + * If the position, is provided, it is relative to the window's top-left corner. + */ + popup(at?: PhysicalPosition | LogicalPosition, window?: Window): Promise; + /** + * Set this submenu as the Window menu for the application on macOS. + * + * This will cause macOS to automatically add window-switching items and + * certain other items to the menu. + * + * #### Platform-specific: + * + * - **Windows / Linux**: Unsupported. + */ + setAsWindowsMenuForNSApp(): Promise; + /** + * Set this submenu as the Help menu for the application on macOS. + * + * This will cause macOS to automatically add a search box to the menu. + * + * If no menu is set as the Help menu, macOS will automatically use any menu + * which has a title matching the localized word "Help". + * + * #### Platform-specific: + * + * - **Windows / Linux**: Unsupported. + */ + setAsHelpMenuForNSApp(): Promise; + /** Sets an icon for this submenu */ + setIcon(icon: MenuIcon | null): Promise; +} diff --git a/scripts/node_modules/@tauri-apps/api/menu/submenu.js b/scripts/node_modules/@tauri-apps/api/menu/submenu.js new file mode 100644 index 0000000000000000000000000000000000000000..83facef9de9e75f70ee3982acb34628c50ac24df --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/menu/submenu.js @@ -0,0 +1,200 @@ +import { MenuItem } from './menuItem.js'; +import { CheckMenuItem } from './checkMenuItem.js'; +import { IconMenuItem } from './iconMenuItem.js'; +import { PredefinedMenuItem } from './predefinedMenuItem.js'; +import { invoke } from '../core.js'; +import { MenuItemBase, newMenu } from './base.js'; +import { Position } from '../dpi.js'; +import { transformImage } from '../image.js'; + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** @ignore */ +function itemFromKind([rid, id, kind]) { + /* eslint-disable @typescript-eslint/no-unsafe-return */ + switch (kind) { + case 'Submenu': + // @ts-expect-error constructor is protected for external usage only, safe for us to use + return new Submenu(rid, id); + case 'Predefined': + // @ts-expect-error constructor is protected for external usage only, safe for us to use + return new PredefinedMenuItem(rid, id); + case 'Check': + // @ts-expect-error constructor is protected for external usage only, safe for us to use + return new CheckMenuItem(rid, id); + case 'Icon': + // @ts-expect-error constructor is protected for external usage only, safe for us to use + return new IconMenuItem(rid, id); + case 'MenuItem': + default: + // @ts-expect-error constructor is protected for external usage only, safe for us to use + return new MenuItem(rid, id); + } + /* eslint-enable @typescript-eslint/no-unsafe-return */ +} +/** A type that is a submenu inside a {@linkcode Menu} or {@linkcode Submenu}. */ +class Submenu extends MenuItemBase { + /** @ignore */ + constructor(rid, id) { + super(rid, id, 'Submenu'); + } + /** Create a new submenu. */ + static async new(opts) { + return newMenu('Submenu', opts).then(([rid, id]) => new Submenu(rid, id)); + } + /** Returns the text of this submenu. */ + async text() { + return invoke('plugin:menu|text', { rid: this.rid, kind: this.kind }); + } + /** Sets the text for this submenu. */ + async setText(text) { + return invoke('plugin:menu|set_text', { + rid: this.rid, + kind: this.kind, + text + }); + } + /** Returns whether this submenu is enabled or not. */ + async isEnabled() { + return invoke('plugin:menu|is_enabled', { rid: this.rid, kind: this.kind }); + } + /** Sets whether this submenu is enabled or not. */ + async setEnabled(enabled) { + return invoke('plugin:menu|set_enabled', { + rid: this.rid, + kind: this.kind, + enabled + }); + } + /** + * Add a menu item to the end of this submenu. + * + * #### Platform-specific: + * + * - **macOS:** Only {@linkcode Submenu}s can be added to a {@linkcode Menu}. + */ + async append(items) { + return invoke('plugin:menu|append', { + rid: this.rid, + kind: this.kind, + items: (Array.isArray(items) ? items : [items]).map((i) => 'rid' in i ? [i.rid, i.kind] : i) + }); + } + /** + * Add a menu item to the beginning of this submenu. + * + * #### Platform-specific: + * + * - **macOS:** Only {@linkcode Submenu}s can be added to a {@linkcode Menu}. + */ + async prepend(items) { + return invoke('plugin:menu|prepend', { + rid: this.rid, + kind: this.kind, + items: (Array.isArray(items) ? items : [items]).map((i) => 'rid' in i ? [i.rid, i.kind] : i) + }); + } + /** + * Add a menu item to the specified position in this submenu. + * + * #### Platform-specific: + * + * - **macOS:** Only {@linkcode Submenu}s can be added to a {@linkcode Menu}. + */ + async insert(items, position) { + return invoke('plugin:menu|insert', { + rid: this.rid, + kind: this.kind, + items: (Array.isArray(items) ? items : [items]).map((i) => 'rid' in i ? [i.rid, i.kind] : i), + position + }); + } + /** Remove a menu item from this submenu. */ + async remove(item) { + return invoke('plugin:menu|remove', { + rid: this.rid, + kind: this.kind, + item: [item.rid, item.kind] + }); + } + /** Remove a menu item from this submenu at the specified position. */ + async removeAt(position) { + return invoke('plugin:menu|remove_at', { + rid: this.rid, + kind: this.kind, + position + }).then(itemFromKind); + } + /** Returns a list of menu items that has been added to this submenu. */ + async items() { + return invoke('plugin:menu|items', { + rid: this.rid, + kind: this.kind + }).then((i) => i.map(itemFromKind)); + } + /** Retrieves the menu item matching the given identifier. */ + async get(id) { + return invoke('plugin:menu|get', { + rid: this.rid, + kind: this.kind, + id + }).then((r) => (r ? itemFromKind(r) : null)); + } + /** + * Popup this submenu as a context menu on the specified window. + * + * If the position, is provided, it is relative to the window's top-left corner. + */ + async popup(at, window) { + var _a; + return invoke('plugin:menu|popup', { + rid: this.rid, + kind: this.kind, + window: (_a = window === null || window === void 0 ? void 0 : window.label) !== null && _a !== void 0 ? _a : null, + at: at instanceof Position ? at : at ? new Position(at) : null + }); + } + /** + * Set this submenu as the Window menu for the application on macOS. + * + * This will cause macOS to automatically add window-switching items and + * certain other items to the menu. + * + * #### Platform-specific: + * + * - **Windows / Linux**: Unsupported. + */ + async setAsWindowsMenuForNSApp() { + return invoke('plugin:menu|set_as_windows_menu_for_nsapp', { + rid: this.rid + }); + } + /** + * Set this submenu as the Help menu for the application on macOS. + * + * This will cause macOS to automatically add a search box to the menu. + * + * If no menu is set as the Help menu, macOS will automatically use any menu + * which has a title matching the localized word "Help". + * + * #### Platform-specific: + * + * - **Windows / Linux**: Unsupported. + */ + async setAsHelpMenuForNSApp() { + return invoke('plugin:menu|set_as_help_menu_for_nsapp', { + rid: this.rid + }); + } + /** Sets an icon for this submenu */ + async setIcon(icon) { + return invoke('plugin:menu|set_icon', { + rid: this.rid, + kind: this.kind, + icon: transformImage(icon) + }); + } +} + +export { Submenu, itemFromKind }; diff --git a/scripts/node_modules/@tauri-apps/api/mocks.cjs b/scripts/node_modules/@tauri-apps/api/mocks.cjs new file mode 100644 index 0000000000000000000000000000000000000000..96d9e3ba6f4cad07b2f8fc3c8bfd41c807a0b0a9 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/mocks.cjs @@ -0,0 +1,297 @@ +'use strict'; + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +function mockInternals() { + var _a, _b; + window.__TAURI_INTERNALS__ = (_a = window.__TAURI_INTERNALS__) !== null && _a !== void 0 ? _a : {}; + window.__TAURI_EVENT_PLUGIN_INTERNALS__ = + (_b = window.__TAURI_EVENT_PLUGIN_INTERNALS__) !== null && _b !== void 0 ? _b : {}; +} +/** + * Intercepts all IPC requests with the given mock handler. + * + * This function can be used when testing tauri frontend applications or when running the frontend in a Node.js context during static site generation. + * + * # Examples + * + * Testing setup using Vitest: + * ```ts + * import { mockIPC, clearMocks } from "@tauri-apps/api/mocks" + * import { invoke } from "@tauri-apps/api/core" + * + * afterEach(() => { + * clearMocks() + * }) + * + * test("mocked command", () => { + * mockIPC((cmd, payload) => { + * switch (cmd) { + * case "add": + * return (payload.a as number) + (payload.b as number); + * default: + * break; + * } + * }); + * + * expect(invoke('add', { a: 12, b: 15 })).resolves.toBe(27); + * }) + * ``` + * + * The callback function can also return a Promise: + * ```js + * import { mockIPC, clearMocks } from "@tauri-apps/api/mocks" + * import { invoke } from "@tauri-apps/api/core" + * + * afterEach(() => { + * clearMocks() + * }) + * + * test("mocked command", () => { + * mockIPC((cmd, payload) => { + * if(cmd === "get_data") { + * return fetch("https://example.com/data.json") + * .then((response) => response.json()) + * } + * }); + * + * expect(invoke('get_data')).resolves.toBe({ foo: 'bar' }); + * }) + * ``` + * + * `listen` can also be mocked with direct calls to the `emit` function. This functionality is opt-in via the `shouldMockEvents` option: + * ```js + * import { mockIPC, clearMocks } from "@tauri-apps/api/mocks" + * import { emit, listen } from "@tauri-apps/api/event" + * + * afterEach(() => { + * clearMocks() + * }) + * + * test("mocked event", () => { + * mockIPC(() => {}, { shouldMockEvents: true }); // enable event mocking + * + * const eventHandler = vi.fn(); + * listen('test-event', eventHandler); // typically in component setup or similar + * + * emit('test-event', { foo: 'bar' }); + * expect(eventHandler).toHaveBeenCalledWith({ + * event: 'test-event', + * payload: { foo: 'bar' } + * }); + * }) + * ``` + * `emitTo` is currently **not** supported by this mock implementation. + * + * @since 1.0.0 + */ +function mockIPC(cb, options) { + mockInternals(); + function isEventPluginInvoke(cmd) { + return cmd.startsWith('plugin:event|'); + } + function handleEventPlugin(cmd, args) { + switch (cmd) { + case 'plugin:event|listen': + return handleListen(args); + case 'plugin:event|emit': + return handleEmit(args); + case 'plugin:event|unlisten': + return handleRemoveListener(args); + } + } + const listeners = new Map(); + function handleListen(args) { + if (!listeners.has(args.event)) { + listeners.set(args.event, []); + } + listeners.get(args.event).push(args.handler); + return args.handler; + } + function handleEmit(args) { + const eventListeners = listeners.get(args.event) || []; + for (const handler of eventListeners) { + runCallback(handler, args); + } + return null; + } + function handleRemoveListener(args) { + const eventListeners = listeners.get(args.event); + if (eventListeners) { + const index = eventListeners.indexOf(args.id); + if (index !== -1) { + eventListeners.splice(index, 1); + } + } + } + // eslint-disable-next-line @typescript-eslint/require-await + async function invoke(cmd, args, _options) { + if ((options === null || options === void 0 ? void 0 : options.shouldMockEvents) && isEventPluginInvoke(cmd)) { + return handleEventPlugin(cmd, args); + } + return cb(cmd, args); + } + const callbacks = new Map(); + function registerCallback(callback, once = false) { + const identifier = window.crypto.getRandomValues(new Uint32Array(1))[0]; + callbacks.set(identifier, (data) => { + if (once) { + unregisterCallback(identifier); + } + return callback && callback(data); + }); + return identifier; + } + function unregisterCallback(id) { + callbacks.delete(id); + } + function runCallback(id, data) { + const callback = callbacks.get(id); + if (callback) { + callback(data); + } + else { + // eslint-disable-next-line no-console + console.warn(`[TAURI] Couldn't find callback id ${id}. This might happen when the app is reloaded while Rust is running an asynchronous operation.`); + } + } + function unregisterListener(event, id) { + unregisterCallback(id); + } + window.__TAURI_INTERNALS__.invoke = invoke; + window.__TAURI_INTERNALS__.transformCallback = registerCallback; + window.__TAURI_INTERNALS__.unregisterCallback = unregisterCallback; + window.__TAURI_INTERNALS__.runCallback = runCallback; + window.__TAURI_INTERNALS__.callbacks = callbacks; + window.__TAURI_EVENT_PLUGIN_INTERNALS__.unregisterListener = + unregisterListener; +} +/** + * Mocks one or many window labels. + * In non-tauri context it is required to call this function *before* using the `@tauri-apps/api/window` module. + * + * This function only mocks the *presence* of windows, + * window properties (e.g. width and height) can be mocked like regular IPC calls using the `mockIPC` function. + * + * # Examples + * + * ```js + * import { mockWindows } from "@tauri-apps/api/mocks"; + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * + * mockWindows("main", "second", "third"); + * + * const win = getCurrentWindow(); + * + * win.label // "main" + * ``` + * + * ```js + * import { mockWindows } from "@tauri-apps/api/mocks"; + * + * mockWindows("main", "second", "third"); + * + * mockIPC((cmd, args) => { + * if (cmd === "plugin:event|emit") { + * console.log('emit event', args?.event, args?.payload); + * } + * }); + * + * const { emit } = await import("@tauri-apps/api/event"); + * await emit('loaded'); // this will cause the mocked IPC handler to log to the console. + * ``` + * + * @param current Label of window this JavaScript context is running in. + * + * @since 1.0.0 + */ +function mockWindows(current, ..._additionalWindows) { + mockInternals(); + window.__TAURI_INTERNALS__.metadata = { + currentWindow: { label: current }, + currentWebview: { windowLabel: current, label: current } + }; +} +/** + * Mock `convertFileSrc` function + * + * + * @example + * ```js + * import { mockConvertFileSrc } from "@tauri-apps/api/mocks"; + * import { convertFileSrc } from "@tauri-apps/api/core"; + * + * mockConvertFileSrc("windows") + * + * const url = convertFileSrc("C:\\Users\\user\\file.txt") + * ``` + * + * @param osName The operating system to mock, can be one of linux, macos, or windows + * + * @since 1.6.0 + */ +function mockConvertFileSrc(osName) { + mockInternals(); + window.__TAURI_INTERNALS__.convertFileSrc = function (filePath, protocol = 'asset') { + const path = encodeURIComponent(filePath); + return osName === 'windows' + ? `http://${protocol}.localhost/${path}` + : `${protocol}://localhost/${path}`; + }; +} +/** + * Clears mocked functions/data injected by the other functions in this module. + * When using a test runner that doesn't provide a fresh window object for each test, calling this function will reset tauri specific properties. + * + * # Example + * + * ```js + * import { mockWindows, clearMocks } from "@tauri-apps/api/mocks" + * + * afterEach(() => { + * clearMocks() + * }) + * + * test("mocked windows", () => { + * mockWindows("main", "second", "third"); + * + * expect(window.__TAURI_INTERNALS__).toHaveProperty("metadata") + * }) + * + * test("no mocked windows", () => { + * expect(window.__TAURI_INTERNALS__).not.toHaveProperty("metadata") + * }) + * ``` + * + * @since 1.0.0 + */ +function clearMocks() { + if (typeof window.__TAURI_INTERNALS__ !== 'object') { + return; + } + // @ts-expect-error "The operand of a 'delete' operator must be optional." does not matter in this case + delete window.__TAURI_INTERNALS__.invoke; + // @ts-expect-error "The operand of a 'delete' operator must be optional." does not matter in this case + delete window.__TAURI_INTERNALS__.transformCallback; + // @ts-expect-error "The operand of a 'delete' operator must be optional." does not matter in this case + delete window.__TAURI_INTERNALS__.unregisterCallback; + // @ts-expect-error "The operand of a 'delete' operator must be optional." does not matter in this case + delete window.__TAURI_INTERNALS__.runCallback; + // @ts-expect-error "The operand of a 'delete' operator must be optional." does not matter in this case + delete window.__TAURI_INTERNALS__.callbacks; + // @ts-expect-error "The operand of a 'delete' operator must be optional." does not matter in this case + delete window.__TAURI_INTERNALS__.convertFileSrc; + // @ts-expect-error "The operand of a 'delete' operator must be optional." does not matter in this case + delete window.__TAURI_INTERNALS__.metadata; + if (typeof window.__TAURI_EVENT_PLUGIN_INTERNALS__ !== 'object') { + return; + } + // @ts-expect-error "The operand of a 'delete' operator must be optional." does not matter in this case + delete window.__TAURI_EVENT_PLUGIN_INTERNALS__.unregisterListener; +} + +exports.clearMocks = clearMocks; +exports.mockConvertFileSrc = mockConvertFileSrc; +exports.mockIPC = mockIPC; +exports.mockWindows = mockWindows; diff --git a/scripts/node_modules/@tauri-apps/api/mocks.d.ts b/scripts/node_modules/@tauri-apps/api/mocks.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8eeb818dbc5b88bdf256ed6c7ad3be4c810ad7f0 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/mocks.d.ts @@ -0,0 +1,177 @@ +import type { InvokeArgs } from './core'; +/** + * Options for `mockIPC`. + * + * # Options + * `shouldMockEvents`: If true, the `listen` and `emit` functions will be mocked, allowing you to test event handling without a real backend. + * **This will consume any events emitted with the `plugin:event` prefix.** + * + * @since 2.7.0 + */ +export interface MockIPCOptions { + shouldMockEvents?: boolean; +} +/** + * Intercepts all IPC requests with the given mock handler. + * + * This function can be used when testing tauri frontend applications or when running the frontend in a Node.js context during static site generation. + * + * # Examples + * + * Testing setup using Vitest: + * ```ts + * import { mockIPC, clearMocks } from "@tauri-apps/api/mocks" + * import { invoke } from "@tauri-apps/api/core" + * + * afterEach(() => { + * clearMocks() + * }) + * + * test("mocked command", () => { + * mockIPC((cmd, payload) => { + * switch (cmd) { + * case "add": + * return (payload.a as number) + (payload.b as number); + * default: + * break; + * } + * }); + * + * expect(invoke('add', { a: 12, b: 15 })).resolves.toBe(27); + * }) + * ``` + * + * The callback function can also return a Promise: + * ```js + * import { mockIPC, clearMocks } from "@tauri-apps/api/mocks" + * import { invoke } from "@tauri-apps/api/core" + * + * afterEach(() => { + * clearMocks() + * }) + * + * test("mocked command", () => { + * mockIPC((cmd, payload) => { + * if(cmd === "get_data") { + * return fetch("https://example.com/data.json") + * .then((response) => response.json()) + * } + * }); + * + * expect(invoke('get_data')).resolves.toBe({ foo: 'bar' }); + * }) + * ``` + * + * `listen` can also be mocked with direct calls to the `emit` function. This functionality is opt-in via the `shouldMockEvents` option: + * ```js + * import { mockIPC, clearMocks } from "@tauri-apps/api/mocks" + * import { emit, listen } from "@tauri-apps/api/event" + * + * afterEach(() => { + * clearMocks() + * }) + * + * test("mocked event", () => { + * mockIPC(() => {}, { shouldMockEvents: true }); // enable event mocking + * + * const eventHandler = vi.fn(); + * listen('test-event', eventHandler); // typically in component setup or similar + * + * emit('test-event', { foo: 'bar' }); + * expect(eventHandler).toHaveBeenCalledWith({ + * event: 'test-event', + * payload: { foo: 'bar' } + * }); + * }) + * ``` + * `emitTo` is currently **not** supported by this mock implementation. + * + * @since 1.0.0 + */ +export declare function mockIPC(cb: (cmd: string, payload?: InvokeArgs) => unknown, options?: MockIPCOptions): void; +/** + * Mocks one or many window labels. + * In non-tauri context it is required to call this function *before* using the `@tauri-apps/api/window` module. + * + * This function only mocks the *presence* of windows, + * window properties (e.g. width and height) can be mocked like regular IPC calls using the `mockIPC` function. + * + * # Examples + * + * ```js + * import { mockWindows } from "@tauri-apps/api/mocks"; + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * + * mockWindows("main", "second", "third"); + * + * const win = getCurrentWindow(); + * + * win.label // "main" + * ``` + * + * ```js + * import { mockWindows } from "@tauri-apps/api/mocks"; + * + * mockWindows("main", "second", "third"); + * + * mockIPC((cmd, args) => { + * if (cmd === "plugin:event|emit") { + * console.log('emit event', args?.event, args?.payload); + * } + * }); + * + * const { emit } = await import("@tauri-apps/api/event"); + * await emit('loaded'); // this will cause the mocked IPC handler to log to the console. + * ``` + * + * @param current Label of window this JavaScript context is running in. + * + * @since 1.0.0 + */ +export declare function mockWindows(current: string, ..._additionalWindows: string[]): void; +/** + * Mock `convertFileSrc` function + * + * + * @example + * ```js + * import { mockConvertFileSrc } from "@tauri-apps/api/mocks"; + * import { convertFileSrc } from "@tauri-apps/api/core"; + * + * mockConvertFileSrc("windows") + * + * const url = convertFileSrc("C:\\Users\\user\\file.txt") + * ``` + * + * @param osName The operating system to mock, can be one of linux, macos, or windows + * + * @since 1.6.0 + */ +export declare function mockConvertFileSrc(osName: string): void; +/** + * Clears mocked functions/data injected by the other functions in this module. + * When using a test runner that doesn't provide a fresh window object for each test, calling this function will reset tauri specific properties. + * + * # Example + * + * ```js + * import { mockWindows, clearMocks } from "@tauri-apps/api/mocks" + * + * afterEach(() => { + * clearMocks() + * }) + * + * test("mocked windows", () => { + * mockWindows("main", "second", "third"); + * + * expect(window.__TAURI_INTERNALS__).toHaveProperty("metadata") + * }) + * + * test("no mocked windows", () => { + * expect(window.__TAURI_INTERNALS__).not.toHaveProperty("metadata") + * }) + * ``` + * + * @since 1.0.0 + */ +export declare function clearMocks(): void; diff --git a/scripts/node_modules/@tauri-apps/api/mocks.js b/scripts/node_modules/@tauri-apps/api/mocks.js new file mode 100644 index 0000000000000000000000000000000000000000..a08c0b2370acacb14e3f9b2b0cc91b39f5f20d4c --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/mocks.js @@ -0,0 +1,292 @@ +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +function mockInternals() { + var _a, _b; + window.__TAURI_INTERNALS__ = (_a = window.__TAURI_INTERNALS__) !== null && _a !== void 0 ? _a : {}; + window.__TAURI_EVENT_PLUGIN_INTERNALS__ = + (_b = window.__TAURI_EVENT_PLUGIN_INTERNALS__) !== null && _b !== void 0 ? _b : {}; +} +/** + * Intercepts all IPC requests with the given mock handler. + * + * This function can be used when testing tauri frontend applications or when running the frontend in a Node.js context during static site generation. + * + * # Examples + * + * Testing setup using Vitest: + * ```ts + * import { mockIPC, clearMocks } from "@tauri-apps/api/mocks" + * import { invoke } from "@tauri-apps/api/core" + * + * afterEach(() => { + * clearMocks() + * }) + * + * test("mocked command", () => { + * mockIPC((cmd, payload) => { + * switch (cmd) { + * case "add": + * return (payload.a as number) + (payload.b as number); + * default: + * break; + * } + * }); + * + * expect(invoke('add', { a: 12, b: 15 })).resolves.toBe(27); + * }) + * ``` + * + * The callback function can also return a Promise: + * ```js + * import { mockIPC, clearMocks } from "@tauri-apps/api/mocks" + * import { invoke } from "@tauri-apps/api/core" + * + * afterEach(() => { + * clearMocks() + * }) + * + * test("mocked command", () => { + * mockIPC((cmd, payload) => { + * if(cmd === "get_data") { + * return fetch("https://example.com/data.json") + * .then((response) => response.json()) + * } + * }); + * + * expect(invoke('get_data')).resolves.toBe({ foo: 'bar' }); + * }) + * ``` + * + * `listen` can also be mocked with direct calls to the `emit` function. This functionality is opt-in via the `shouldMockEvents` option: + * ```js + * import { mockIPC, clearMocks } from "@tauri-apps/api/mocks" + * import { emit, listen } from "@tauri-apps/api/event" + * + * afterEach(() => { + * clearMocks() + * }) + * + * test("mocked event", () => { + * mockIPC(() => {}, { shouldMockEvents: true }); // enable event mocking + * + * const eventHandler = vi.fn(); + * listen('test-event', eventHandler); // typically in component setup or similar + * + * emit('test-event', { foo: 'bar' }); + * expect(eventHandler).toHaveBeenCalledWith({ + * event: 'test-event', + * payload: { foo: 'bar' } + * }); + * }) + * ``` + * `emitTo` is currently **not** supported by this mock implementation. + * + * @since 1.0.0 + */ +function mockIPC(cb, options) { + mockInternals(); + function isEventPluginInvoke(cmd) { + return cmd.startsWith('plugin:event|'); + } + function handleEventPlugin(cmd, args) { + switch (cmd) { + case 'plugin:event|listen': + return handleListen(args); + case 'plugin:event|emit': + return handleEmit(args); + case 'plugin:event|unlisten': + return handleRemoveListener(args); + } + } + const listeners = new Map(); + function handleListen(args) { + if (!listeners.has(args.event)) { + listeners.set(args.event, []); + } + listeners.get(args.event).push(args.handler); + return args.handler; + } + function handleEmit(args) { + const eventListeners = listeners.get(args.event) || []; + for (const handler of eventListeners) { + runCallback(handler, args); + } + return null; + } + function handleRemoveListener(args) { + const eventListeners = listeners.get(args.event); + if (eventListeners) { + const index = eventListeners.indexOf(args.id); + if (index !== -1) { + eventListeners.splice(index, 1); + } + } + } + // eslint-disable-next-line @typescript-eslint/require-await + async function invoke(cmd, args, _options) { + if ((options === null || options === void 0 ? void 0 : options.shouldMockEvents) && isEventPluginInvoke(cmd)) { + return handleEventPlugin(cmd, args); + } + return cb(cmd, args); + } + const callbacks = new Map(); + function registerCallback(callback, once = false) { + const identifier = window.crypto.getRandomValues(new Uint32Array(1))[0]; + callbacks.set(identifier, (data) => { + if (once) { + unregisterCallback(identifier); + } + return callback && callback(data); + }); + return identifier; + } + function unregisterCallback(id) { + callbacks.delete(id); + } + function runCallback(id, data) { + const callback = callbacks.get(id); + if (callback) { + callback(data); + } + else { + // eslint-disable-next-line no-console + console.warn(`[TAURI] Couldn't find callback id ${id}. This might happen when the app is reloaded while Rust is running an asynchronous operation.`); + } + } + function unregisterListener(event, id) { + unregisterCallback(id); + } + window.__TAURI_INTERNALS__.invoke = invoke; + window.__TAURI_INTERNALS__.transformCallback = registerCallback; + window.__TAURI_INTERNALS__.unregisterCallback = unregisterCallback; + window.__TAURI_INTERNALS__.runCallback = runCallback; + window.__TAURI_INTERNALS__.callbacks = callbacks; + window.__TAURI_EVENT_PLUGIN_INTERNALS__.unregisterListener = + unregisterListener; +} +/** + * Mocks one or many window labels. + * In non-tauri context it is required to call this function *before* using the `@tauri-apps/api/window` module. + * + * This function only mocks the *presence* of windows, + * window properties (e.g. width and height) can be mocked like regular IPC calls using the `mockIPC` function. + * + * # Examples + * + * ```js + * import { mockWindows } from "@tauri-apps/api/mocks"; + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * + * mockWindows("main", "second", "third"); + * + * const win = getCurrentWindow(); + * + * win.label // "main" + * ``` + * + * ```js + * import { mockWindows } from "@tauri-apps/api/mocks"; + * + * mockWindows("main", "second", "third"); + * + * mockIPC((cmd, args) => { + * if (cmd === "plugin:event|emit") { + * console.log('emit event', args?.event, args?.payload); + * } + * }); + * + * const { emit } = await import("@tauri-apps/api/event"); + * await emit('loaded'); // this will cause the mocked IPC handler to log to the console. + * ``` + * + * @param current Label of window this JavaScript context is running in. + * + * @since 1.0.0 + */ +function mockWindows(current, ..._additionalWindows) { + mockInternals(); + window.__TAURI_INTERNALS__.metadata = { + currentWindow: { label: current }, + currentWebview: { windowLabel: current, label: current } + }; +} +/** + * Mock `convertFileSrc` function + * + * + * @example + * ```js + * import { mockConvertFileSrc } from "@tauri-apps/api/mocks"; + * import { convertFileSrc } from "@tauri-apps/api/core"; + * + * mockConvertFileSrc("windows") + * + * const url = convertFileSrc("C:\\Users\\user\\file.txt") + * ``` + * + * @param osName The operating system to mock, can be one of linux, macos, or windows + * + * @since 1.6.0 + */ +function mockConvertFileSrc(osName) { + mockInternals(); + window.__TAURI_INTERNALS__.convertFileSrc = function (filePath, protocol = 'asset') { + const path = encodeURIComponent(filePath); + return osName === 'windows' + ? `http://${protocol}.localhost/${path}` + : `${protocol}://localhost/${path}`; + }; +} +/** + * Clears mocked functions/data injected by the other functions in this module. + * When using a test runner that doesn't provide a fresh window object for each test, calling this function will reset tauri specific properties. + * + * # Example + * + * ```js + * import { mockWindows, clearMocks } from "@tauri-apps/api/mocks" + * + * afterEach(() => { + * clearMocks() + * }) + * + * test("mocked windows", () => { + * mockWindows("main", "second", "third"); + * + * expect(window.__TAURI_INTERNALS__).toHaveProperty("metadata") + * }) + * + * test("no mocked windows", () => { + * expect(window.__TAURI_INTERNALS__).not.toHaveProperty("metadata") + * }) + * ``` + * + * @since 1.0.0 + */ +function clearMocks() { + if (typeof window.__TAURI_INTERNALS__ !== 'object') { + return; + } + // @ts-expect-error "The operand of a 'delete' operator must be optional." does not matter in this case + delete window.__TAURI_INTERNALS__.invoke; + // @ts-expect-error "The operand of a 'delete' operator must be optional." does not matter in this case + delete window.__TAURI_INTERNALS__.transformCallback; + // @ts-expect-error "The operand of a 'delete' operator must be optional." does not matter in this case + delete window.__TAURI_INTERNALS__.unregisterCallback; + // @ts-expect-error "The operand of a 'delete' operator must be optional." does not matter in this case + delete window.__TAURI_INTERNALS__.runCallback; + // @ts-expect-error "The operand of a 'delete' operator must be optional." does not matter in this case + delete window.__TAURI_INTERNALS__.callbacks; + // @ts-expect-error "The operand of a 'delete' operator must be optional." does not matter in this case + delete window.__TAURI_INTERNALS__.convertFileSrc; + // @ts-expect-error "The operand of a 'delete' operator must be optional." does not matter in this case + delete window.__TAURI_INTERNALS__.metadata; + if (typeof window.__TAURI_EVENT_PLUGIN_INTERNALS__ !== 'object') { + return; + } + // @ts-expect-error "The operand of a 'delete' operator must be optional." does not matter in this case + delete window.__TAURI_EVENT_PLUGIN_INTERNALS__.unregisterListener; +} + +export { clearMocks, mockConvertFileSrc, mockIPC, mockWindows }; diff --git a/scripts/node_modules/@tauri-apps/api/package.json b/scripts/node_modules/@tauri-apps/api/package.json new file mode 100644 index 0000000000000000000000000000000000000000..f5ac01a0607be4ec9d6aeda240426b3798ffe2c8 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/package.json @@ -0,0 +1,63 @@ +{ + "name": "@tauri-apps/api", + "version": "2.10.1", + "description": "Tauri API definitions", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/tauri" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/tauri-apps/tauri.git" + }, + "contributors": [ + "Tauri Programme within The Commons Conservancy" + ], + "license": "Apache-2.0 OR MIT", + "bugs": { + "url": "https://github.com/tauri-apps/tauri/issues" + }, + "homepage": "https://github.com/tauri-apps/tauri#readme", + "type": "module", + "main": "./index.cjs", + "module": "./index.js", + "types": "./index.d.ts", + "exports": { + ".": { + "import": "./index.js", + "require": "./index.cjs", + "types": "./index.d.ts" + }, + "./*": { + "import": "./*.js", + "require": "./*.cjs", + "types": "./*.d.ts" + }, + "./package.json": "./package.json" + }, + "devDependencies": { + "@eslint/js": "^9.29.0", + "@rollup/plugin-terser": "0.4.4", + "@rollup/plugin-typescript": "12.3.0", + "@types/eslint": "^9.6.1", + "@types/node": "^24.0.0", + "eslint": "^9.29.0", + "eslint-config-prettier": "10.1.8", + "eslint-plugin-security": "3.0.1", + "fast-glob": "3.3.3", + "globals": "^17.0.0", + "rollup": "4.57.0", + "tslib": "^2.8.1", + "typescript": "^5.8.3", + "typescript-eslint": "^8.34.1" + }, + "scripts": { + "build": "rollup -c --configPlugin typescript", + "build:debug": "rollup -c --configPlugin typescript", + "npm-pack": "pnpm build && cd ./dist && npm pack", + "npm-publish": "pnpm build && cd ./dist && pnpm publish --access public --loglevel silly --no-git-checks", + "ts:check": "tsc --noEmit", + "eslint:check": "eslint src/**/*.ts", + "eslint:fix": "eslint src/**/*.ts --fix" + } +} \ No newline at end of file diff --git a/scripts/node_modules/@tauri-apps/api/path.cjs b/scripts/node_modules/@tauri-apps/api/path.cjs new file mode 100644 index 0000000000000000000000000000000000000000..15f16c234abd2e3f68b79ff97f09037e0790e2db --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/path.cjs @@ -0,0 +1,753 @@ +'use strict'; + +var core = require('./core.cjs'); + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * The path module provides utilities for working with file and directory paths. + * + * This package is also accessible with `window.__TAURI__.path` when [`app.withGlobalTauri`](https://v2.tauri.app/reference/config/#withglobaltauri) in `tauri.conf.json` is set to `true`. + * + * It is recommended to allowlist only the APIs you use for optimal bundle size and security. + * @module + */ +/** + * @since 2.0.0 + */ +exports.BaseDirectory = void 0; +(function (BaseDirectory) { + /** + * @see {@link audioDir} for more information. + */ + BaseDirectory[BaseDirectory["Audio"] = 1] = "Audio"; + /** + * @see {@link cacheDir} for more information. + */ + BaseDirectory[BaseDirectory["Cache"] = 2] = "Cache"; + /** + * @see {@link configDir} for more information. + */ + BaseDirectory[BaseDirectory["Config"] = 3] = "Config"; + /** + * @see {@link dataDir} for more information. + */ + BaseDirectory[BaseDirectory["Data"] = 4] = "Data"; + /** + * @see {@link localDataDir} for more information. + */ + BaseDirectory[BaseDirectory["LocalData"] = 5] = "LocalData"; + /** + * @see {@link documentDir} for more information. + */ + BaseDirectory[BaseDirectory["Document"] = 6] = "Document"; + /** + * @see {@link downloadDir} for more information. + */ + BaseDirectory[BaseDirectory["Download"] = 7] = "Download"; + /** + * @see {@link pictureDir} for more information. + */ + BaseDirectory[BaseDirectory["Picture"] = 8] = "Picture"; + /** + * @see {@link publicDir} for more information. + */ + BaseDirectory[BaseDirectory["Public"] = 9] = "Public"; + /** + * @see {@link videoDir} for more information. + */ + BaseDirectory[BaseDirectory["Video"] = 10] = "Video"; + /** + * @see {@link resourceDir} for more information. + */ + BaseDirectory[BaseDirectory["Resource"] = 11] = "Resource"; + /** + * @see {@link tempDir} for more information. + */ + BaseDirectory[BaseDirectory["Temp"] = 12] = "Temp"; + /** + * @see {@link appConfigDir} for more information. + */ + BaseDirectory[BaseDirectory["AppConfig"] = 13] = "AppConfig"; + /** + * @see {@link appDataDir} for more information. + */ + BaseDirectory[BaseDirectory["AppData"] = 14] = "AppData"; + /** + * @see {@link appLocalDataDir} for more information. + */ + BaseDirectory[BaseDirectory["AppLocalData"] = 15] = "AppLocalData"; + /** + * @see {@link appCacheDir} for more information. + */ + BaseDirectory[BaseDirectory["AppCache"] = 16] = "AppCache"; + /** + * @see {@link appLogDir} for more information. + */ + BaseDirectory[BaseDirectory["AppLog"] = 17] = "AppLog"; + /** + * @see {@link desktopDir} for more information. + */ + BaseDirectory[BaseDirectory["Desktop"] = 18] = "Desktop"; + /** + * @see {@link executableDir} for more information. + */ + BaseDirectory[BaseDirectory["Executable"] = 19] = "Executable"; + /** + * @see {@link fontDir} for more information. + */ + BaseDirectory[BaseDirectory["Font"] = 20] = "Font"; + /** + * @see {@link homeDir} for more information. + */ + BaseDirectory[BaseDirectory["Home"] = 21] = "Home"; + /** + * @see {@link runtimeDir} for more information. + */ + BaseDirectory[BaseDirectory["Runtime"] = 22] = "Runtime"; + /** + * @see {@link templateDir} for more information. + */ + BaseDirectory[BaseDirectory["Template"] = 23] = "Template"; +})(exports.BaseDirectory || (exports.BaseDirectory = {})); +/** + * Returns the path to the suggested directory for your app's config files. + * Resolves to `${configDir}/${bundleIdentifier}`, where `bundleIdentifier` is the [`identifier`](https://v2.tauri.app/reference/config/#identifier) value configured in `tauri.conf.json`. + * @example + * ```typescript + * import { appConfigDir } from '@tauri-apps/api/path'; + * const appConfigDirPath = await appConfigDir(); + * ``` + * + * @since 1.2.0 + */ +async function appConfigDir() { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.AppConfig + }); +} +/** + * Returns the path to the suggested directory for your app's data files. + * Resolves to `${dataDir}/${bundleIdentifier}`, where `bundleIdentifier` is the [`identifier`](https://v2.tauri.app/reference/config/#identifier) value configured in `tauri.conf.json`. + * @example + * ```typescript + * import { appDataDir } from '@tauri-apps/api/path'; + * const appDataDirPath = await appDataDir(); + * ``` + * + * @since 1.2.0 + */ +async function appDataDir() { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.AppData + }); +} +/** + * Returns the path to the suggested directory for your app's local data files. + * Resolves to `${localDataDir}/${bundleIdentifier}`, where `bundleIdentifier` is the [`identifier`](https://v2.tauri.app/reference/config/#identifier) value configured in `tauri.conf.json`. + * @example + * ```typescript + * import { appLocalDataDir } from '@tauri-apps/api/path'; + * const appLocalDataDirPath = await appLocalDataDir(); + * ``` + * + * @since 1.2.0 + */ +async function appLocalDataDir() { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.AppLocalData + }); +} +/** + * Returns the path to the suggested directory for your app's cache files. + * Resolves to `${cacheDir}/${bundleIdentifier}`, where `bundleIdentifier` is the [`identifier`](https://v2.tauri.app/reference/config/#identifier) value configured in `tauri.conf.json`. + * @example + * ```typescript + * import { appCacheDir } from '@tauri-apps/api/path'; + * const appCacheDirPath = await appCacheDir(); + * ``` + * + * @since 1.2.0 + */ +async function appCacheDir() { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.AppCache + }); +} +/** + * Returns the path to the user's audio directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_MUSIC_DIR`. + * - **macOS:** Resolves to `$HOME/Music`. + * - **Windows:** Resolves to `{FOLDERID_Music}`. + * @example + * ```typescript + * import { audioDir } from '@tauri-apps/api/path'; + * const audioDirPath = await audioDir(); + * ``` + * + * @since 1.0.0 + */ +async function audioDir() { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.Audio + }); +} +/** + * Returns the path to the user's cache directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$XDG_CACHE_HOME` or `$HOME/.cache`. + * - **macOS:** Resolves to `$HOME/Library/Caches`. + * - **Windows:** Resolves to `{FOLDERID_LocalAppData}`. + * @example + * ```typescript + * import { cacheDir } from '@tauri-apps/api/path'; + * const cacheDirPath = await cacheDir(); + * ``` + * + * @since 1.0.0 + */ +async function cacheDir() { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.Cache + }); +} +/** + * Returns the path to the user's config directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$XDG_CONFIG_HOME` or `$HOME/.config`. + * - **macOS:** Resolves to `$HOME/Library/Application Support`. + * - **Windows:** Resolves to `{FOLDERID_RoamingAppData}`. + * @example + * ```typescript + * import { configDir } from '@tauri-apps/api/path'; + * const configDirPath = await configDir(); + * ``` + * + * @since 1.0.0 + */ +async function configDir() { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.Config + }); +} +/** + * Returns the path to the user's data directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$XDG_DATA_HOME` or `$HOME/.local/share`. + * - **macOS:** Resolves to `$HOME/Library/Application Support`. + * - **Windows:** Resolves to `{FOLDERID_RoamingAppData}`. + * @example + * ```typescript + * import { dataDir } from '@tauri-apps/api/path'; + * const dataDirPath = await dataDir(); + * ``` + * + * @since 1.0.0 + */ +async function dataDir() { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.Data + }); +} +/** + * Returns the path to the user's desktop directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_DESKTOP_DIR`. + * - **macOS:** Resolves to `$HOME/Desktop`. + * - **Windows:** Resolves to `{FOLDERID_Desktop}`. + * @example + * ```typescript + * import { desktopDir } from '@tauri-apps/api/path'; + * const desktopPath = await desktopDir(); + * ``` + * + * @since 1.0.0 + */ +async function desktopDir() { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.Desktop + }); +} +/** + * Returns the path to the user's document directory. + * @example + * ```typescript + * import { documentDir } from '@tauri-apps/api/path'; + * const documentDirPath = await documentDir(); + * ``` + * + * #### Platform-specific + * + * - **Linux:** Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_DOCUMENTS_DIR`. + * - **macOS:** Resolves to `$HOME/Documents`. + * - **Windows:** Resolves to `{FOLDERID_Documents}`. + * + * @since 1.0.0 + */ +async function documentDir() { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.Document + }); +} +/** + * Returns the path to the user's download directory. + * + * #### Platform-specific + * + * - **Linux**: Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_DOWNLOAD_DIR`. + * - **macOS**: Resolves to `$HOME/Downloads`. + * - **Windows**: Resolves to `{FOLDERID_Downloads}`. + * @example + * ```typescript + * import { downloadDir } from '@tauri-apps/api/path'; + * const downloadDirPath = await downloadDir(); + * ``` + * + * @since 1.0.0 + */ +async function downloadDir() { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.Download + }); +} +/** + * Returns the path to the user's executable directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$XDG_BIN_HOME/../bin` or `$XDG_DATA_HOME/../bin` or `$HOME/.local/bin`. + * - **macOS:** Not supported. + * - **Windows:** Not supported. + * @example + * ```typescript + * import { executableDir } from '@tauri-apps/api/path'; + * const executableDirPath = await executableDir(); + * ``` + * + * @since 1.0.0 + */ +async function executableDir() { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.Executable + }); +} +/** + * Returns the path to the user's font directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$XDG_DATA_HOME/fonts` or `$HOME/.local/share/fonts`. + * - **macOS:** Resolves to `$HOME/Library/Fonts`. + * - **Windows:** Not supported. + * @example + * ```typescript + * import { fontDir } from '@tauri-apps/api/path'; + * const fontDirPath = await fontDir(); + * ``` + * + * @since 1.0.0 + */ +async function fontDir() { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.Font + }); +} +/** + * Returns the path to the user's home directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$HOME`. + * - **macOS:** Resolves to `$HOME`. + * - **Windows:** Resolves to `{FOLDERID_Profile}`. + * @example + * ```typescript + * import { homeDir } from '@tauri-apps/api/path'; + * const homeDirPath = await homeDir(); + * ``` + * + * @since 1.0.0 + */ +async function homeDir() { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.Home + }); +} +/** + * Returns the path to the user's local data directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$XDG_DATA_HOME` or `$HOME/.local/share`. + * - **macOS:** Resolves to `$HOME/Library/Application Support`. + * - **Windows:** Resolves to `{FOLDERID_LocalAppData}`. + * @example + * ```typescript + * import { localDataDir } from '@tauri-apps/api/path'; + * const localDataDirPath = await localDataDir(); + * ``` + * + * @since 1.0.0 + */ +async function localDataDir() { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.LocalData + }); +} +/** + * Returns the path to the user's picture directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_PICTURES_DIR`. + * - **macOS:** Resolves to `$HOME/Pictures`. + * - **Windows:** Resolves to `{FOLDERID_Pictures}`. + * @example + * ```typescript + * import { pictureDir } from '@tauri-apps/api/path'; + * const pictureDirPath = await pictureDir(); + * ``` + * + * @since 1.0.0 + */ +async function pictureDir() { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.Picture + }); +} +/** + * Returns the path to the user's public directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_PUBLICSHARE_DIR`. + * - **macOS:** Resolves to `$HOME/Public`. + * - **Windows:** Resolves to `{FOLDERID_Public}`. + * @example + * ```typescript + * import { publicDir } from '@tauri-apps/api/path'; + * const publicDirPath = await publicDir(); + * ``` + * + * @since 1.0.0 + */ +async function publicDir() { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.Public + }); +} +/** + * Returns the path to the application's resource directory. + * To resolve a resource path, see {@linkcode resolveResource}. + * + * ## Platform-specific + * + * Although we provide the exact path where this function resolves to, + * this is not a contract and things might change in the future + * + * - **Windows:** Resolves to the directory that contains the main executable. + * - **Linux:** When running in an AppImage, the `APPDIR` variable will be set to + * the mounted location of the app, and the resource dir will be `${APPDIR}/usr/lib/${exe_name}`. + * If not running in an AppImage, the path is `/usr/lib/${exe_name}`. + * When running the app from `src-tauri/target/(debug|release)/`, the path is `${exe_dir}/../lib/${exe_name}`. + * - **macOS:** Resolves to `${exe_dir}/../Resources` (inside .app). + * - **iOS:** Resolves to `${exe_dir}/assets`. + * - **Android:** Currently the resources are stored in the APK as assets so it's not a normal file system path, + * we return a special URI prefix `asset://localhost/` here that can be used with the [file system plugin](https://tauri.app/plugin/file-system/), + * + * @example + * ```typescript + * import { resourceDir } from '@tauri-apps/api/path'; + * const resourceDirPath = await resourceDir(); + * ``` + * + * @since 1.0.0 + */ +async function resourceDir() { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.Resource + }); +} +/** + * Resolve the path to a resource file. + * @example + * ```typescript + * import { resolveResource } from '@tauri-apps/api/path'; + * const resourcePath = await resolveResource('script.sh'); + * ``` + * + * @param resourcePath The path to the resource. + * Must follow the same syntax as defined in `tauri.conf.json > bundle > resources`, i.e. keeping subfolders and parent dir components (`../`). + * @returns The full path to the resource. + * + * @since 1.0.0 + */ +async function resolveResource(resourcePath) { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.Resource, + path: resourcePath + }); +} +/** + * Returns the path to the user's runtime directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$XDG_RUNTIME_DIR`. + * - **macOS:** Not supported. + * - **Windows:** Not supported. + * @example + * ```typescript + * import { runtimeDir } from '@tauri-apps/api/path'; + * const runtimeDirPath = await runtimeDir(); + * ``` + * + * @since 1.0.0 + */ +async function runtimeDir() { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.Runtime + }); +} +/** + * Returns the path to the user's template directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_TEMPLATES_DIR`. + * - **macOS:** Not supported. + * - **Windows:** Resolves to `{FOLDERID_Templates}`. + * @example + * ```typescript + * import { templateDir } from '@tauri-apps/api/path'; + * const templateDirPath = await templateDir(); + * ``` + * + * @since 1.0.0 + */ +async function templateDir() { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.Template + }); +} +/** + * Returns the path to the user's video directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_VIDEOS_DIR`. + * - **macOS:** Resolves to `$HOME/Movies`. + * - **Windows:** Resolves to `{FOLDERID_Videos}`. + * @example + * ```typescript + * import { videoDir } from '@tauri-apps/api/path'; + * const videoDirPath = await videoDir(); + * ``` + * + * @since 1.0.0 + */ +async function videoDir() { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.Video + }); +} +/** + * Returns the path to the suggested directory for your app's log files. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `${configDir}/${bundleIdentifier}/logs`. + * - **macOS:** Resolves to `${homeDir}/Library/Logs/{bundleIdentifier}` + * - **Windows:** Resolves to `${configDir}/${bundleIdentifier}/logs`. + * @example + * ```typescript + * import { appLogDir } from '@tauri-apps/api/path'; + * const appLogDirPath = await appLogDir(); + * ``` + * + * @since 1.2.0 + */ +async function appLogDir() { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.AppLog + }); +} +/** + * Returns a temporary directory. + * @example + * ```typescript + * import { tempDir } from '@tauri-apps/api/path'; + * const temp = await tempDir(); + * ``` + * + * @since 2.0.0 + */ +async function tempDir() { + return core.invoke('plugin:path|resolve_directory', { + directory: exports.BaseDirectory.Temp + }); +} +/** + * Returns the platform-specific path segment separator: + * - `\` on Windows + * - `/` on POSIX + * + * @since 2.0.0 + */ +function sep() { + return window.__TAURI_INTERNALS__.plugins.path.sep; +} +/** + * Returns the platform-specific path segment delimiter: + * - `;` on Windows + * - `:` on POSIX + * + * @since 2.0.0 + */ +function delimiter() { + return window.__TAURI_INTERNALS__.plugins.path.delimiter; +} +/** + * Resolves a sequence of `paths` or `path` segments into an absolute path. + * @example + * ```typescript + * import { resolve, appDataDir } from '@tauri-apps/api/path'; + * const appDataDirPath = await appDataDir(); + * const path = await resolve(appDataDirPath, '..', 'users', 'tauri', 'avatar.png'); + * ``` + * + * @since 1.0.0 + */ +async function resolve(...paths) { + return core.invoke('plugin:path|resolve', { paths }); +} +/** + * Normalizes the given `path`, resolving `'..'` and `'.'` segments and resolve symbolic links. + * @example + * ```typescript + * import { normalize, appDataDir } from '@tauri-apps/api/path'; + * const appDataDirPath = await appDataDir(); + * const path = await normalize(`${appDataDirPath}/../users/tauri/avatar.png`); + * ``` + * + * @since 1.0.0 + */ +async function normalize(path) { + return core.invoke('plugin:path|normalize', { path }); +} +/** + * Joins all given `path` segments together using the platform-specific separator as a delimiter, then normalizes the resulting path. + * @example + * ```typescript + * import { join, appDataDir } from '@tauri-apps/api/path'; + * const appDataDirPath = await appDataDir(); + * const path = await join(appDataDirPath, 'users', 'tauri', 'avatar.png'); + * ``` + * + * @since 1.0.0 + */ +async function join(...paths) { + return core.invoke('plugin:path|join', { paths }); +} +/** + * Returns the parent directory of a given `path`. Trailing directory separators are ignored. + * @example + * ```typescript + * import { dirname } from '@tauri-apps/api/path'; + * const dir = await dirname('/path/to/somedir/'); + * assert(dir === '/path/to'); + * ``` + * + * @since 1.0.0 + */ +async function dirname(path) { + return core.invoke('plugin:path|dirname', { path }); +} +/** + * Returns the extension of the `path`. + * @example + * ```typescript + * import { extname } from '@tauri-apps/api/path'; + * const ext = await extname('/path/to/file.html'); + * assert(ext === 'html'); + * ``` + * + * @since 1.0.0 + */ +async function extname(path) { + return core.invoke('plugin:path|extname', { path }); +} +/** + * Returns the last portion of a `path`. Trailing directory separators are ignored. + * @example + * ```typescript + * import { basename } from '@tauri-apps/api/path'; + * const base = await basename('path/to/app.conf'); + * assert(base === 'app.conf'); + * ``` + * @param ext An optional file extension to be removed from the returned path. + * + * @since 1.0.0 + */ +async function basename(path, ext) { + return core.invoke('plugin:path|basename', { path, ext }); +} +/** + * Returns whether the path is absolute or not. + * @example + * ```typescript + * import { isAbsolute } from '@tauri-apps/api/path'; + * assert(await isAbsolute('/home/tauri')); + * ``` + * + * @since 1.0.0 + */ +async function isAbsolute(path) { + return core.invoke('plugin:path|is_absolute', { path }); +} + +exports.appCacheDir = appCacheDir; +exports.appConfigDir = appConfigDir; +exports.appDataDir = appDataDir; +exports.appLocalDataDir = appLocalDataDir; +exports.appLogDir = appLogDir; +exports.audioDir = audioDir; +exports.basename = basename; +exports.cacheDir = cacheDir; +exports.configDir = configDir; +exports.dataDir = dataDir; +exports.delimiter = delimiter; +exports.desktopDir = desktopDir; +exports.dirname = dirname; +exports.documentDir = documentDir; +exports.downloadDir = downloadDir; +exports.executableDir = executableDir; +exports.extname = extname; +exports.fontDir = fontDir; +exports.homeDir = homeDir; +exports.isAbsolute = isAbsolute; +exports.join = join; +exports.localDataDir = localDataDir; +exports.normalize = normalize; +exports.pictureDir = pictureDir; +exports.publicDir = publicDir; +exports.resolve = resolve; +exports.resolveResource = resolveResource; +exports.resourceDir = resourceDir; +exports.runtimeDir = runtimeDir; +exports.sep = sep; +exports.tempDir = tempDir; +exports.templateDir = templateDir; +exports.videoDir = videoDir; diff --git a/scripts/node_modules/@tauri-apps/api/path.d.ts b/scripts/node_modules/@tauri-apps/api/path.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1808f68a7b2a18827e1a5d71047d076cb04af119 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/path.d.ts @@ -0,0 +1,589 @@ +/** + * @since 2.0.0 + */ +declare enum BaseDirectory { + /** + * @see {@link audioDir} for more information. + */ + Audio = 1, + /** + * @see {@link cacheDir} for more information. + */ + Cache = 2, + /** + * @see {@link configDir} for more information. + */ + Config = 3, + /** + * @see {@link dataDir} for more information. + */ + Data = 4, + /** + * @see {@link localDataDir} for more information. + */ + LocalData = 5, + /** + * @see {@link documentDir} for more information. + */ + Document = 6, + /** + * @see {@link downloadDir} for more information. + */ + Download = 7, + /** + * @see {@link pictureDir} for more information. + */ + Picture = 8, + /** + * @see {@link publicDir} for more information. + */ + Public = 9, + /** + * @see {@link videoDir} for more information. + */ + Video = 10, + /** + * @see {@link resourceDir} for more information. + */ + Resource = 11, + /** + * @see {@link tempDir} for more information. + */ + Temp = 12, + /** + * @see {@link appConfigDir} for more information. + */ + AppConfig = 13, + /** + * @see {@link appDataDir} for more information. + */ + AppData = 14, + /** + * @see {@link appLocalDataDir} for more information. + */ + AppLocalData = 15, + /** + * @see {@link appCacheDir} for more information. + */ + AppCache = 16, + /** + * @see {@link appLogDir} for more information. + */ + AppLog = 17, + /** + * @see {@link desktopDir} for more information. + */ + Desktop = 18, + /** + * @see {@link executableDir} for more information. + */ + Executable = 19, + /** + * @see {@link fontDir} for more information. + */ + Font = 20, + /** + * @see {@link homeDir} for more information. + */ + Home = 21, + /** + * @see {@link runtimeDir} for more information. + */ + Runtime = 22, + /** + * @see {@link templateDir} for more information. + */ + Template = 23 +} +/** + * Returns the path to the suggested directory for your app's config files. + * Resolves to `${configDir}/${bundleIdentifier}`, where `bundleIdentifier` is the [`identifier`](https://v2.tauri.app/reference/config/#identifier) value configured in `tauri.conf.json`. + * @example + * ```typescript + * import { appConfigDir } from '@tauri-apps/api/path'; + * const appConfigDirPath = await appConfigDir(); + * ``` + * + * @since 1.2.0 + */ +declare function appConfigDir(): Promise; +/** + * Returns the path to the suggested directory for your app's data files. + * Resolves to `${dataDir}/${bundleIdentifier}`, where `bundleIdentifier` is the [`identifier`](https://v2.tauri.app/reference/config/#identifier) value configured in `tauri.conf.json`. + * @example + * ```typescript + * import { appDataDir } from '@tauri-apps/api/path'; + * const appDataDirPath = await appDataDir(); + * ``` + * + * @since 1.2.0 + */ +declare function appDataDir(): Promise; +/** + * Returns the path to the suggested directory for your app's local data files. + * Resolves to `${localDataDir}/${bundleIdentifier}`, where `bundleIdentifier` is the [`identifier`](https://v2.tauri.app/reference/config/#identifier) value configured in `tauri.conf.json`. + * @example + * ```typescript + * import { appLocalDataDir } from '@tauri-apps/api/path'; + * const appLocalDataDirPath = await appLocalDataDir(); + * ``` + * + * @since 1.2.0 + */ +declare function appLocalDataDir(): Promise; +/** + * Returns the path to the suggested directory for your app's cache files. + * Resolves to `${cacheDir}/${bundleIdentifier}`, where `bundleIdentifier` is the [`identifier`](https://v2.tauri.app/reference/config/#identifier) value configured in `tauri.conf.json`. + * @example + * ```typescript + * import { appCacheDir } from '@tauri-apps/api/path'; + * const appCacheDirPath = await appCacheDir(); + * ``` + * + * @since 1.2.0 + */ +declare function appCacheDir(): Promise; +/** + * Returns the path to the user's audio directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_MUSIC_DIR`. + * - **macOS:** Resolves to `$HOME/Music`. + * - **Windows:** Resolves to `{FOLDERID_Music}`. + * @example + * ```typescript + * import { audioDir } from '@tauri-apps/api/path'; + * const audioDirPath = await audioDir(); + * ``` + * + * @since 1.0.0 + */ +declare function audioDir(): Promise; +/** + * Returns the path to the user's cache directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$XDG_CACHE_HOME` or `$HOME/.cache`. + * - **macOS:** Resolves to `$HOME/Library/Caches`. + * - **Windows:** Resolves to `{FOLDERID_LocalAppData}`. + * @example + * ```typescript + * import { cacheDir } from '@tauri-apps/api/path'; + * const cacheDirPath = await cacheDir(); + * ``` + * + * @since 1.0.0 + */ +declare function cacheDir(): Promise; +/** + * Returns the path to the user's config directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$XDG_CONFIG_HOME` or `$HOME/.config`. + * - **macOS:** Resolves to `$HOME/Library/Application Support`. + * - **Windows:** Resolves to `{FOLDERID_RoamingAppData}`. + * @example + * ```typescript + * import { configDir } from '@tauri-apps/api/path'; + * const configDirPath = await configDir(); + * ``` + * + * @since 1.0.0 + */ +declare function configDir(): Promise; +/** + * Returns the path to the user's data directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$XDG_DATA_HOME` or `$HOME/.local/share`. + * - **macOS:** Resolves to `$HOME/Library/Application Support`. + * - **Windows:** Resolves to `{FOLDERID_RoamingAppData}`. + * @example + * ```typescript + * import { dataDir } from '@tauri-apps/api/path'; + * const dataDirPath = await dataDir(); + * ``` + * + * @since 1.0.0 + */ +declare function dataDir(): Promise; +/** + * Returns the path to the user's desktop directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_DESKTOP_DIR`. + * - **macOS:** Resolves to `$HOME/Desktop`. + * - **Windows:** Resolves to `{FOLDERID_Desktop}`. + * @example + * ```typescript + * import { desktopDir } from '@tauri-apps/api/path'; + * const desktopPath = await desktopDir(); + * ``` + * + * @since 1.0.0 + */ +declare function desktopDir(): Promise; +/** + * Returns the path to the user's document directory. + * @example + * ```typescript + * import { documentDir } from '@tauri-apps/api/path'; + * const documentDirPath = await documentDir(); + * ``` + * + * #### Platform-specific + * + * - **Linux:** Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_DOCUMENTS_DIR`. + * - **macOS:** Resolves to `$HOME/Documents`. + * - **Windows:** Resolves to `{FOLDERID_Documents}`. + * + * @since 1.0.0 + */ +declare function documentDir(): Promise; +/** + * Returns the path to the user's download directory. + * + * #### Platform-specific + * + * - **Linux**: Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_DOWNLOAD_DIR`. + * - **macOS**: Resolves to `$HOME/Downloads`. + * - **Windows**: Resolves to `{FOLDERID_Downloads}`. + * @example + * ```typescript + * import { downloadDir } from '@tauri-apps/api/path'; + * const downloadDirPath = await downloadDir(); + * ``` + * + * @since 1.0.0 + */ +declare function downloadDir(): Promise; +/** + * Returns the path to the user's executable directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$XDG_BIN_HOME/../bin` or `$XDG_DATA_HOME/../bin` or `$HOME/.local/bin`. + * - **macOS:** Not supported. + * - **Windows:** Not supported. + * @example + * ```typescript + * import { executableDir } from '@tauri-apps/api/path'; + * const executableDirPath = await executableDir(); + * ``` + * + * @since 1.0.0 + */ +declare function executableDir(): Promise; +/** + * Returns the path to the user's font directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$XDG_DATA_HOME/fonts` or `$HOME/.local/share/fonts`. + * - **macOS:** Resolves to `$HOME/Library/Fonts`. + * - **Windows:** Not supported. + * @example + * ```typescript + * import { fontDir } from '@tauri-apps/api/path'; + * const fontDirPath = await fontDir(); + * ``` + * + * @since 1.0.0 + */ +declare function fontDir(): Promise; +/** + * Returns the path to the user's home directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$HOME`. + * - **macOS:** Resolves to `$HOME`. + * - **Windows:** Resolves to `{FOLDERID_Profile}`. + * @example + * ```typescript + * import { homeDir } from '@tauri-apps/api/path'; + * const homeDirPath = await homeDir(); + * ``` + * + * @since 1.0.0 + */ +declare function homeDir(): Promise; +/** + * Returns the path to the user's local data directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$XDG_DATA_HOME` or `$HOME/.local/share`. + * - **macOS:** Resolves to `$HOME/Library/Application Support`. + * - **Windows:** Resolves to `{FOLDERID_LocalAppData}`. + * @example + * ```typescript + * import { localDataDir } from '@tauri-apps/api/path'; + * const localDataDirPath = await localDataDir(); + * ``` + * + * @since 1.0.0 + */ +declare function localDataDir(): Promise; +/** + * Returns the path to the user's picture directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_PICTURES_DIR`. + * - **macOS:** Resolves to `$HOME/Pictures`. + * - **Windows:** Resolves to `{FOLDERID_Pictures}`. + * @example + * ```typescript + * import { pictureDir } from '@tauri-apps/api/path'; + * const pictureDirPath = await pictureDir(); + * ``` + * + * @since 1.0.0 + */ +declare function pictureDir(): Promise; +/** + * Returns the path to the user's public directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_PUBLICSHARE_DIR`. + * - **macOS:** Resolves to `$HOME/Public`. + * - **Windows:** Resolves to `{FOLDERID_Public}`. + * @example + * ```typescript + * import { publicDir } from '@tauri-apps/api/path'; + * const publicDirPath = await publicDir(); + * ``` + * + * @since 1.0.0 + */ +declare function publicDir(): Promise; +/** + * Returns the path to the application's resource directory. + * To resolve a resource path, see {@linkcode resolveResource}. + * + * ## Platform-specific + * + * Although we provide the exact path where this function resolves to, + * this is not a contract and things might change in the future + * + * - **Windows:** Resolves to the directory that contains the main executable. + * - **Linux:** When running in an AppImage, the `APPDIR` variable will be set to + * the mounted location of the app, and the resource dir will be `${APPDIR}/usr/lib/${exe_name}`. + * If not running in an AppImage, the path is `/usr/lib/${exe_name}`. + * When running the app from `src-tauri/target/(debug|release)/`, the path is `${exe_dir}/../lib/${exe_name}`. + * - **macOS:** Resolves to `${exe_dir}/../Resources` (inside .app). + * - **iOS:** Resolves to `${exe_dir}/assets`. + * - **Android:** Currently the resources are stored in the APK as assets so it's not a normal file system path, + * we return a special URI prefix `asset://localhost/` here that can be used with the [file system plugin](https://tauri.app/plugin/file-system/), + * + * @example + * ```typescript + * import { resourceDir } from '@tauri-apps/api/path'; + * const resourceDirPath = await resourceDir(); + * ``` + * + * @since 1.0.0 + */ +declare function resourceDir(): Promise; +/** + * Resolve the path to a resource file. + * @example + * ```typescript + * import { resolveResource } from '@tauri-apps/api/path'; + * const resourcePath = await resolveResource('script.sh'); + * ``` + * + * @param resourcePath The path to the resource. + * Must follow the same syntax as defined in `tauri.conf.json > bundle > resources`, i.e. keeping subfolders and parent dir components (`../`). + * @returns The full path to the resource. + * + * @since 1.0.0 + */ +declare function resolveResource(resourcePath: string): Promise; +/** + * Returns the path to the user's runtime directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$XDG_RUNTIME_DIR`. + * - **macOS:** Not supported. + * - **Windows:** Not supported. + * @example + * ```typescript + * import { runtimeDir } from '@tauri-apps/api/path'; + * const runtimeDirPath = await runtimeDir(); + * ``` + * + * @since 1.0.0 + */ +declare function runtimeDir(): Promise; +/** + * Returns the path to the user's template directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_TEMPLATES_DIR`. + * - **macOS:** Not supported. + * - **Windows:** Resolves to `{FOLDERID_Templates}`. + * @example + * ```typescript + * import { templateDir } from '@tauri-apps/api/path'; + * const templateDirPath = await templateDir(); + * ``` + * + * @since 1.0.0 + */ +declare function templateDir(): Promise; +/** + * Returns the path to the user's video directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_VIDEOS_DIR`. + * - **macOS:** Resolves to `$HOME/Movies`. + * - **Windows:** Resolves to `{FOLDERID_Videos}`. + * @example + * ```typescript + * import { videoDir } from '@tauri-apps/api/path'; + * const videoDirPath = await videoDir(); + * ``` + * + * @since 1.0.0 + */ +declare function videoDir(): Promise; +/** + * Returns the path to the suggested directory for your app's log files. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `${configDir}/${bundleIdentifier}/logs`. + * - **macOS:** Resolves to `${homeDir}/Library/Logs/{bundleIdentifier}` + * - **Windows:** Resolves to `${configDir}/${bundleIdentifier}/logs`. + * @example + * ```typescript + * import { appLogDir } from '@tauri-apps/api/path'; + * const appLogDirPath = await appLogDir(); + * ``` + * + * @since 1.2.0 + */ +declare function appLogDir(): Promise; +/** + * Returns a temporary directory. + * @example + * ```typescript + * import { tempDir } from '@tauri-apps/api/path'; + * const temp = await tempDir(); + * ``` + * + * @since 2.0.0 + */ +declare function tempDir(): Promise; +/** + * Returns the platform-specific path segment separator: + * - `\` on Windows + * - `/` on POSIX + * + * @since 2.0.0 + */ +declare function sep(): string; +/** + * Returns the platform-specific path segment delimiter: + * - `;` on Windows + * - `:` on POSIX + * + * @since 2.0.0 + */ +declare function delimiter(): string; +/** + * Resolves a sequence of `paths` or `path` segments into an absolute path. + * @example + * ```typescript + * import { resolve, appDataDir } from '@tauri-apps/api/path'; + * const appDataDirPath = await appDataDir(); + * const path = await resolve(appDataDirPath, '..', 'users', 'tauri', 'avatar.png'); + * ``` + * + * @since 1.0.0 + */ +declare function resolve(...paths: string[]): Promise; +/** + * Normalizes the given `path`, resolving `'..'` and `'.'` segments and resolve symbolic links. + * @example + * ```typescript + * import { normalize, appDataDir } from '@tauri-apps/api/path'; + * const appDataDirPath = await appDataDir(); + * const path = await normalize(`${appDataDirPath}/../users/tauri/avatar.png`); + * ``` + * + * @since 1.0.0 + */ +declare function normalize(path: string): Promise; +/** + * Joins all given `path` segments together using the platform-specific separator as a delimiter, then normalizes the resulting path. + * @example + * ```typescript + * import { join, appDataDir } from '@tauri-apps/api/path'; + * const appDataDirPath = await appDataDir(); + * const path = await join(appDataDirPath, 'users', 'tauri', 'avatar.png'); + * ``` + * + * @since 1.0.0 + */ +declare function join(...paths: string[]): Promise; +/** + * Returns the parent directory of a given `path`. Trailing directory separators are ignored. + * @example + * ```typescript + * import { dirname } from '@tauri-apps/api/path'; + * const dir = await dirname('/path/to/somedir/'); + * assert(dir === '/path/to'); + * ``` + * + * @since 1.0.0 + */ +declare function dirname(path: string): Promise; +/** + * Returns the extension of the `path`. + * @example + * ```typescript + * import { extname } from '@tauri-apps/api/path'; + * const ext = await extname('/path/to/file.html'); + * assert(ext === 'html'); + * ``` + * + * @since 1.0.0 + */ +declare function extname(path: string): Promise; +/** + * Returns the last portion of a `path`. Trailing directory separators are ignored. + * @example + * ```typescript + * import { basename } from '@tauri-apps/api/path'; + * const base = await basename('path/to/app.conf'); + * assert(base === 'app.conf'); + * ``` + * @param ext An optional file extension to be removed from the returned path. + * + * @since 1.0.0 + */ +declare function basename(path: string, ext?: string): Promise; +/** + * Returns whether the path is absolute or not. + * @example + * ```typescript + * import { isAbsolute } from '@tauri-apps/api/path'; + * assert(await isAbsolute('/home/tauri')); + * ``` + * + * @since 1.0.0 + */ +declare function isAbsolute(path: string): Promise; +export { BaseDirectory, appConfigDir, appDataDir, appLocalDataDir, appCacheDir, appLogDir, audioDir, cacheDir, configDir, dataDir, desktopDir, documentDir, downloadDir, executableDir, fontDir, homeDir, localDataDir, pictureDir, publicDir, resourceDir, resolveResource, runtimeDir, templateDir, videoDir, sep, delimiter, resolve, normalize, join, dirname, extname, basename, isAbsolute, tempDir }; diff --git a/scripts/node_modules/@tauri-apps/api/path.js b/scripts/node_modules/@tauri-apps/api/path.js new file mode 100644 index 0000000000000000000000000000000000000000..76d0ae666c54f8270c89f529b6a4a80959b8126b --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/path.js @@ -0,0 +1,719 @@ +import { invoke } from './core.js'; + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * The path module provides utilities for working with file and directory paths. + * + * This package is also accessible with `window.__TAURI__.path` when [`app.withGlobalTauri`](https://v2.tauri.app/reference/config/#withglobaltauri) in `tauri.conf.json` is set to `true`. + * + * It is recommended to allowlist only the APIs you use for optimal bundle size and security. + * @module + */ +/** + * @since 2.0.0 + */ +var BaseDirectory; +(function (BaseDirectory) { + /** + * @see {@link audioDir} for more information. + */ + BaseDirectory[BaseDirectory["Audio"] = 1] = "Audio"; + /** + * @see {@link cacheDir} for more information. + */ + BaseDirectory[BaseDirectory["Cache"] = 2] = "Cache"; + /** + * @see {@link configDir} for more information. + */ + BaseDirectory[BaseDirectory["Config"] = 3] = "Config"; + /** + * @see {@link dataDir} for more information. + */ + BaseDirectory[BaseDirectory["Data"] = 4] = "Data"; + /** + * @see {@link localDataDir} for more information. + */ + BaseDirectory[BaseDirectory["LocalData"] = 5] = "LocalData"; + /** + * @see {@link documentDir} for more information. + */ + BaseDirectory[BaseDirectory["Document"] = 6] = "Document"; + /** + * @see {@link downloadDir} for more information. + */ + BaseDirectory[BaseDirectory["Download"] = 7] = "Download"; + /** + * @see {@link pictureDir} for more information. + */ + BaseDirectory[BaseDirectory["Picture"] = 8] = "Picture"; + /** + * @see {@link publicDir} for more information. + */ + BaseDirectory[BaseDirectory["Public"] = 9] = "Public"; + /** + * @see {@link videoDir} for more information. + */ + BaseDirectory[BaseDirectory["Video"] = 10] = "Video"; + /** + * @see {@link resourceDir} for more information. + */ + BaseDirectory[BaseDirectory["Resource"] = 11] = "Resource"; + /** + * @see {@link tempDir} for more information. + */ + BaseDirectory[BaseDirectory["Temp"] = 12] = "Temp"; + /** + * @see {@link appConfigDir} for more information. + */ + BaseDirectory[BaseDirectory["AppConfig"] = 13] = "AppConfig"; + /** + * @see {@link appDataDir} for more information. + */ + BaseDirectory[BaseDirectory["AppData"] = 14] = "AppData"; + /** + * @see {@link appLocalDataDir} for more information. + */ + BaseDirectory[BaseDirectory["AppLocalData"] = 15] = "AppLocalData"; + /** + * @see {@link appCacheDir} for more information. + */ + BaseDirectory[BaseDirectory["AppCache"] = 16] = "AppCache"; + /** + * @see {@link appLogDir} for more information. + */ + BaseDirectory[BaseDirectory["AppLog"] = 17] = "AppLog"; + /** + * @see {@link desktopDir} for more information. + */ + BaseDirectory[BaseDirectory["Desktop"] = 18] = "Desktop"; + /** + * @see {@link executableDir} for more information. + */ + BaseDirectory[BaseDirectory["Executable"] = 19] = "Executable"; + /** + * @see {@link fontDir} for more information. + */ + BaseDirectory[BaseDirectory["Font"] = 20] = "Font"; + /** + * @see {@link homeDir} for more information. + */ + BaseDirectory[BaseDirectory["Home"] = 21] = "Home"; + /** + * @see {@link runtimeDir} for more information. + */ + BaseDirectory[BaseDirectory["Runtime"] = 22] = "Runtime"; + /** + * @see {@link templateDir} for more information. + */ + BaseDirectory[BaseDirectory["Template"] = 23] = "Template"; +})(BaseDirectory || (BaseDirectory = {})); +/** + * Returns the path to the suggested directory for your app's config files. + * Resolves to `${configDir}/${bundleIdentifier}`, where `bundleIdentifier` is the [`identifier`](https://v2.tauri.app/reference/config/#identifier) value configured in `tauri.conf.json`. + * @example + * ```typescript + * import { appConfigDir } from '@tauri-apps/api/path'; + * const appConfigDirPath = await appConfigDir(); + * ``` + * + * @since 1.2.0 + */ +async function appConfigDir() { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.AppConfig + }); +} +/** + * Returns the path to the suggested directory for your app's data files. + * Resolves to `${dataDir}/${bundleIdentifier}`, where `bundleIdentifier` is the [`identifier`](https://v2.tauri.app/reference/config/#identifier) value configured in `tauri.conf.json`. + * @example + * ```typescript + * import { appDataDir } from '@tauri-apps/api/path'; + * const appDataDirPath = await appDataDir(); + * ``` + * + * @since 1.2.0 + */ +async function appDataDir() { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.AppData + }); +} +/** + * Returns the path to the suggested directory for your app's local data files. + * Resolves to `${localDataDir}/${bundleIdentifier}`, where `bundleIdentifier` is the [`identifier`](https://v2.tauri.app/reference/config/#identifier) value configured in `tauri.conf.json`. + * @example + * ```typescript + * import { appLocalDataDir } from '@tauri-apps/api/path'; + * const appLocalDataDirPath = await appLocalDataDir(); + * ``` + * + * @since 1.2.0 + */ +async function appLocalDataDir() { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.AppLocalData + }); +} +/** + * Returns the path to the suggested directory for your app's cache files. + * Resolves to `${cacheDir}/${bundleIdentifier}`, where `bundleIdentifier` is the [`identifier`](https://v2.tauri.app/reference/config/#identifier) value configured in `tauri.conf.json`. + * @example + * ```typescript + * import { appCacheDir } from '@tauri-apps/api/path'; + * const appCacheDirPath = await appCacheDir(); + * ``` + * + * @since 1.2.0 + */ +async function appCacheDir() { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.AppCache + }); +} +/** + * Returns the path to the user's audio directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_MUSIC_DIR`. + * - **macOS:** Resolves to `$HOME/Music`. + * - **Windows:** Resolves to `{FOLDERID_Music}`. + * @example + * ```typescript + * import { audioDir } from '@tauri-apps/api/path'; + * const audioDirPath = await audioDir(); + * ``` + * + * @since 1.0.0 + */ +async function audioDir() { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.Audio + }); +} +/** + * Returns the path to the user's cache directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$XDG_CACHE_HOME` or `$HOME/.cache`. + * - **macOS:** Resolves to `$HOME/Library/Caches`. + * - **Windows:** Resolves to `{FOLDERID_LocalAppData}`. + * @example + * ```typescript + * import { cacheDir } from '@tauri-apps/api/path'; + * const cacheDirPath = await cacheDir(); + * ``` + * + * @since 1.0.0 + */ +async function cacheDir() { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.Cache + }); +} +/** + * Returns the path to the user's config directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$XDG_CONFIG_HOME` or `$HOME/.config`. + * - **macOS:** Resolves to `$HOME/Library/Application Support`. + * - **Windows:** Resolves to `{FOLDERID_RoamingAppData}`. + * @example + * ```typescript + * import { configDir } from '@tauri-apps/api/path'; + * const configDirPath = await configDir(); + * ``` + * + * @since 1.0.0 + */ +async function configDir() { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.Config + }); +} +/** + * Returns the path to the user's data directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$XDG_DATA_HOME` or `$HOME/.local/share`. + * - **macOS:** Resolves to `$HOME/Library/Application Support`. + * - **Windows:** Resolves to `{FOLDERID_RoamingAppData}`. + * @example + * ```typescript + * import { dataDir } from '@tauri-apps/api/path'; + * const dataDirPath = await dataDir(); + * ``` + * + * @since 1.0.0 + */ +async function dataDir() { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.Data + }); +} +/** + * Returns the path to the user's desktop directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_DESKTOP_DIR`. + * - **macOS:** Resolves to `$HOME/Desktop`. + * - **Windows:** Resolves to `{FOLDERID_Desktop}`. + * @example + * ```typescript + * import { desktopDir } from '@tauri-apps/api/path'; + * const desktopPath = await desktopDir(); + * ``` + * + * @since 1.0.0 + */ +async function desktopDir() { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.Desktop + }); +} +/** + * Returns the path to the user's document directory. + * @example + * ```typescript + * import { documentDir } from '@tauri-apps/api/path'; + * const documentDirPath = await documentDir(); + * ``` + * + * #### Platform-specific + * + * - **Linux:** Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_DOCUMENTS_DIR`. + * - **macOS:** Resolves to `$HOME/Documents`. + * - **Windows:** Resolves to `{FOLDERID_Documents}`. + * + * @since 1.0.0 + */ +async function documentDir() { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.Document + }); +} +/** + * Returns the path to the user's download directory. + * + * #### Platform-specific + * + * - **Linux**: Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_DOWNLOAD_DIR`. + * - **macOS**: Resolves to `$HOME/Downloads`. + * - **Windows**: Resolves to `{FOLDERID_Downloads}`. + * @example + * ```typescript + * import { downloadDir } from '@tauri-apps/api/path'; + * const downloadDirPath = await downloadDir(); + * ``` + * + * @since 1.0.0 + */ +async function downloadDir() { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.Download + }); +} +/** + * Returns the path to the user's executable directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$XDG_BIN_HOME/../bin` or `$XDG_DATA_HOME/../bin` or `$HOME/.local/bin`. + * - **macOS:** Not supported. + * - **Windows:** Not supported. + * @example + * ```typescript + * import { executableDir } from '@tauri-apps/api/path'; + * const executableDirPath = await executableDir(); + * ``` + * + * @since 1.0.0 + */ +async function executableDir() { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.Executable + }); +} +/** + * Returns the path to the user's font directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$XDG_DATA_HOME/fonts` or `$HOME/.local/share/fonts`. + * - **macOS:** Resolves to `$HOME/Library/Fonts`. + * - **Windows:** Not supported. + * @example + * ```typescript + * import { fontDir } from '@tauri-apps/api/path'; + * const fontDirPath = await fontDir(); + * ``` + * + * @since 1.0.0 + */ +async function fontDir() { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.Font + }); +} +/** + * Returns the path to the user's home directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$HOME`. + * - **macOS:** Resolves to `$HOME`. + * - **Windows:** Resolves to `{FOLDERID_Profile}`. + * @example + * ```typescript + * import { homeDir } from '@tauri-apps/api/path'; + * const homeDirPath = await homeDir(); + * ``` + * + * @since 1.0.0 + */ +async function homeDir() { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.Home + }); +} +/** + * Returns the path to the user's local data directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$XDG_DATA_HOME` or `$HOME/.local/share`. + * - **macOS:** Resolves to `$HOME/Library/Application Support`. + * - **Windows:** Resolves to `{FOLDERID_LocalAppData}`. + * @example + * ```typescript + * import { localDataDir } from '@tauri-apps/api/path'; + * const localDataDirPath = await localDataDir(); + * ``` + * + * @since 1.0.0 + */ +async function localDataDir() { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.LocalData + }); +} +/** + * Returns the path to the user's picture directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_PICTURES_DIR`. + * - **macOS:** Resolves to `$HOME/Pictures`. + * - **Windows:** Resolves to `{FOLDERID_Pictures}`. + * @example + * ```typescript + * import { pictureDir } from '@tauri-apps/api/path'; + * const pictureDirPath = await pictureDir(); + * ``` + * + * @since 1.0.0 + */ +async function pictureDir() { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.Picture + }); +} +/** + * Returns the path to the user's public directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_PUBLICSHARE_DIR`. + * - **macOS:** Resolves to `$HOME/Public`. + * - **Windows:** Resolves to `{FOLDERID_Public}`. + * @example + * ```typescript + * import { publicDir } from '@tauri-apps/api/path'; + * const publicDirPath = await publicDir(); + * ``` + * + * @since 1.0.0 + */ +async function publicDir() { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.Public + }); +} +/** + * Returns the path to the application's resource directory. + * To resolve a resource path, see {@linkcode resolveResource}. + * + * ## Platform-specific + * + * Although we provide the exact path where this function resolves to, + * this is not a contract and things might change in the future + * + * - **Windows:** Resolves to the directory that contains the main executable. + * - **Linux:** When running in an AppImage, the `APPDIR` variable will be set to + * the mounted location of the app, and the resource dir will be `${APPDIR}/usr/lib/${exe_name}`. + * If not running in an AppImage, the path is `/usr/lib/${exe_name}`. + * When running the app from `src-tauri/target/(debug|release)/`, the path is `${exe_dir}/../lib/${exe_name}`. + * - **macOS:** Resolves to `${exe_dir}/../Resources` (inside .app). + * - **iOS:** Resolves to `${exe_dir}/assets`. + * - **Android:** Currently the resources are stored in the APK as assets so it's not a normal file system path, + * we return a special URI prefix `asset://localhost/` here that can be used with the [file system plugin](https://tauri.app/plugin/file-system/), + * + * @example + * ```typescript + * import { resourceDir } from '@tauri-apps/api/path'; + * const resourceDirPath = await resourceDir(); + * ``` + * + * @since 1.0.0 + */ +async function resourceDir() { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.Resource + }); +} +/** + * Resolve the path to a resource file. + * @example + * ```typescript + * import { resolveResource } from '@tauri-apps/api/path'; + * const resourcePath = await resolveResource('script.sh'); + * ``` + * + * @param resourcePath The path to the resource. + * Must follow the same syntax as defined in `tauri.conf.json > bundle > resources`, i.e. keeping subfolders and parent dir components (`../`). + * @returns The full path to the resource. + * + * @since 1.0.0 + */ +async function resolveResource(resourcePath) { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.Resource, + path: resourcePath + }); +} +/** + * Returns the path to the user's runtime directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `$XDG_RUNTIME_DIR`. + * - **macOS:** Not supported. + * - **Windows:** Not supported. + * @example + * ```typescript + * import { runtimeDir } from '@tauri-apps/api/path'; + * const runtimeDirPath = await runtimeDir(); + * ``` + * + * @since 1.0.0 + */ +async function runtimeDir() { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.Runtime + }); +} +/** + * Returns the path to the user's template directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_TEMPLATES_DIR`. + * - **macOS:** Not supported. + * - **Windows:** Resolves to `{FOLDERID_Templates}`. + * @example + * ```typescript + * import { templateDir } from '@tauri-apps/api/path'; + * const templateDirPath = await templateDir(); + * ``` + * + * @since 1.0.0 + */ +async function templateDir() { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.Template + }); +} +/** + * Returns the path to the user's video directory. + * + * #### Platform-specific + * + * - **Linux:** Resolves to [`xdg-user-dirs`](https://www.freedesktop.org/wiki/Software/xdg-user-dirs/)' `XDG_VIDEOS_DIR`. + * - **macOS:** Resolves to `$HOME/Movies`. + * - **Windows:** Resolves to `{FOLDERID_Videos}`. + * @example + * ```typescript + * import { videoDir } from '@tauri-apps/api/path'; + * const videoDirPath = await videoDir(); + * ``` + * + * @since 1.0.0 + */ +async function videoDir() { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.Video + }); +} +/** + * Returns the path to the suggested directory for your app's log files. + * + * #### Platform-specific + * + * - **Linux:** Resolves to `${configDir}/${bundleIdentifier}/logs`. + * - **macOS:** Resolves to `${homeDir}/Library/Logs/{bundleIdentifier}` + * - **Windows:** Resolves to `${configDir}/${bundleIdentifier}/logs`. + * @example + * ```typescript + * import { appLogDir } from '@tauri-apps/api/path'; + * const appLogDirPath = await appLogDir(); + * ``` + * + * @since 1.2.0 + */ +async function appLogDir() { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.AppLog + }); +} +/** + * Returns a temporary directory. + * @example + * ```typescript + * import { tempDir } from '@tauri-apps/api/path'; + * const temp = await tempDir(); + * ``` + * + * @since 2.0.0 + */ +async function tempDir() { + return invoke('plugin:path|resolve_directory', { + directory: BaseDirectory.Temp + }); +} +/** + * Returns the platform-specific path segment separator: + * - `\` on Windows + * - `/` on POSIX + * + * @since 2.0.0 + */ +function sep() { + return window.__TAURI_INTERNALS__.plugins.path.sep; +} +/** + * Returns the platform-specific path segment delimiter: + * - `;` on Windows + * - `:` on POSIX + * + * @since 2.0.0 + */ +function delimiter() { + return window.__TAURI_INTERNALS__.plugins.path.delimiter; +} +/** + * Resolves a sequence of `paths` or `path` segments into an absolute path. + * @example + * ```typescript + * import { resolve, appDataDir } from '@tauri-apps/api/path'; + * const appDataDirPath = await appDataDir(); + * const path = await resolve(appDataDirPath, '..', 'users', 'tauri', 'avatar.png'); + * ``` + * + * @since 1.0.0 + */ +async function resolve(...paths) { + return invoke('plugin:path|resolve', { paths }); +} +/** + * Normalizes the given `path`, resolving `'..'` and `'.'` segments and resolve symbolic links. + * @example + * ```typescript + * import { normalize, appDataDir } from '@tauri-apps/api/path'; + * const appDataDirPath = await appDataDir(); + * const path = await normalize(`${appDataDirPath}/../users/tauri/avatar.png`); + * ``` + * + * @since 1.0.0 + */ +async function normalize(path) { + return invoke('plugin:path|normalize', { path }); +} +/** + * Joins all given `path` segments together using the platform-specific separator as a delimiter, then normalizes the resulting path. + * @example + * ```typescript + * import { join, appDataDir } from '@tauri-apps/api/path'; + * const appDataDirPath = await appDataDir(); + * const path = await join(appDataDirPath, 'users', 'tauri', 'avatar.png'); + * ``` + * + * @since 1.0.0 + */ +async function join(...paths) { + return invoke('plugin:path|join', { paths }); +} +/** + * Returns the parent directory of a given `path`. Trailing directory separators are ignored. + * @example + * ```typescript + * import { dirname } from '@tauri-apps/api/path'; + * const dir = await dirname('/path/to/somedir/'); + * assert(dir === '/path/to'); + * ``` + * + * @since 1.0.0 + */ +async function dirname(path) { + return invoke('plugin:path|dirname', { path }); +} +/** + * Returns the extension of the `path`. + * @example + * ```typescript + * import { extname } from '@tauri-apps/api/path'; + * const ext = await extname('/path/to/file.html'); + * assert(ext === 'html'); + * ``` + * + * @since 1.0.0 + */ +async function extname(path) { + return invoke('plugin:path|extname', { path }); +} +/** + * Returns the last portion of a `path`. Trailing directory separators are ignored. + * @example + * ```typescript + * import { basename } from '@tauri-apps/api/path'; + * const base = await basename('path/to/app.conf'); + * assert(base === 'app.conf'); + * ``` + * @param ext An optional file extension to be removed from the returned path. + * + * @since 1.0.0 + */ +async function basename(path, ext) { + return invoke('plugin:path|basename', { path, ext }); +} +/** + * Returns whether the path is absolute or not. + * @example + * ```typescript + * import { isAbsolute } from '@tauri-apps/api/path'; + * assert(await isAbsolute('/home/tauri')); + * ``` + * + * @since 1.0.0 + */ +async function isAbsolute(path) { + return invoke('plugin:path|is_absolute', { path }); +} + +export { BaseDirectory, appCacheDir, appConfigDir, appDataDir, appLocalDataDir, appLogDir, audioDir, basename, cacheDir, configDir, dataDir, delimiter, desktopDir, dirname, documentDir, downloadDir, executableDir, extname, fontDir, homeDir, isAbsolute, join, localDataDir, normalize, pictureDir, publicDir, resolve, resolveResource, resourceDir, runtimeDir, sep, tempDir, templateDir, videoDir }; diff --git a/scripts/node_modules/@tauri-apps/api/tray.cjs b/scripts/node_modules/@tauri-apps/api/tray.cjs new file mode 100644 index 0000000000000000000000000000000000000000..e6d881760615bddea8b6983c1abce57d17f4c609 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/tray.cjs @@ -0,0 +1,188 @@ +'use strict'; + +var core = require('./core.cjs'); +var image = require('./image.cjs'); +var dpi = require('./dpi.cjs'); + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * Tray icon class and associated methods. This type constructor is private, + * instead, you should use the static method {@linkcode TrayIcon.new}. + * + * #### Warning + * + * Unlike Rust, javascript does not have any way to run cleanup code + * when an object is being removed by garbage collection, but this tray icon + * will be cleaned up when the tauri app exists, however if you want to cleanup + * this object early, you need to call {@linkcode TrayIcon.close}. + * + * @example + * ```ts + * import { TrayIcon } from '@tauri-apps/api/tray'; + * const tray = await TrayIcon.new({ tooltip: 'awesome tray tooltip' }); + * tray.set_tooltip('new tooltip'); + * ``` + */ +class TrayIcon extends core.Resource { + constructor(rid, id) { + super(rid); + this.id = id; + } + /** Gets a tray icon using the provided id. */ + static async getById(id) { + return core.invoke('plugin:tray|get_by_id', { id }).then((rid) => rid ? new TrayIcon(rid, id) : null); + } + /** + * Removes a tray icon using the provided id from tauri's internal state. + * + * Note that this may cause the tray icon to disappear + * if it wasn't cloned somewhere else or referenced by JS. + */ + static async removeById(id) { + return core.invoke('plugin:tray|remove_by_id', { id }); + } + /** + * Creates a new {@linkcode TrayIcon} + * + * #### Platform-specific: + * + * - **Linux:** Sometimes the icon won't be visible unless a menu is set. + * Setting an empty {@linkcode Menu} is enough. + */ + static async new(options) { + if (options === null || options === void 0 ? void 0 : options.menu) { + // @ts-expect-error we only need the rid and kind + options.menu = [options.menu.rid, options.menu.kind]; + } + if (options === null || options === void 0 ? void 0 : options.icon) { + options.icon = image.transformImage(options.icon); + } + const handler = new core.Channel(); + if (options === null || options === void 0 ? void 0 : options.action) { + const action = options.action; + handler.onmessage = (e) => action(mapEvent(e)); + delete options.action; + } + return core.invoke('plugin:tray|new', { + options: options !== null && options !== void 0 ? options : {}, + handler + }).then(([rid, id]) => new TrayIcon(rid, id)); + } + /** + * Sets a new tray icon. If `null` is provided, it will remove the icon. + * + * Note that you may need the `image-ico` or `image-png` Cargo features to use this API. + * To enable it, change your Cargo.toml file: + * ```toml + * [dependencies] + * tauri = { version = "...", features = ["...", "image-png"] } + * ``` + */ + async setIcon(icon) { + let trayIcon = null; + if (icon) { + trayIcon = image.transformImage(icon); + } + return core.invoke('plugin:tray|set_icon', { rid: this.rid, icon: trayIcon }); + } + /** + * Sets a new tray menu. + * + * #### Platform-specific: + * + * - **Linux**: once a menu is set it cannot be removed so `null` has no effect + */ + async setMenu(menu) { + if (menu) { + // @ts-expect-error we only need the rid and kind + menu = [menu.rid, menu.kind]; + } + return core.invoke('plugin:tray|set_menu', { rid: this.rid, menu }); + } + /** + * Sets the tooltip for this tray icon. + * + * #### Platform-specific: + * + * - **Linux:** Unsupported + */ + async setTooltip(tooltip) { + return core.invoke('plugin:tray|set_tooltip', { rid: this.rid, tooltip }); + } + /** + * Sets the tooltip for this tray icon. + * + * #### Platform-specific: + * + * - **Linux:** The title will not be shown unless there is an icon + * as well. The title is useful for numerical and other frequently + * updated information. In general, it shouldn't be shown unless a + * user requests it as it can take up a significant amount of space + * on the user's panel. This may not be shown in all visualizations. + * - **Windows:** Unsupported + */ + async setTitle(title) { + return core.invoke('plugin:tray|set_title', { rid: this.rid, title }); + } + /** Show or hide this tray icon. */ + async setVisible(visible) { + return core.invoke('plugin:tray|set_visible', { rid: this.rid, visible }); + } + /** + * Sets the tray icon temp dir path. **Linux only**. + * + * On Linux, we need to write the icon to the disk and usually it will + * be `$XDG_RUNTIME_DIR/tray-icon` or `$TEMP/tray-icon`. + */ + async setTempDirPath(path) { + return core.invoke('plugin:tray|set_temp_dir_path', { rid: this.rid, path }); + } + /** Sets the current icon as a [template](https://developer.apple.com/documentation/appkit/nsimage/1520017-template?language=objc). **macOS only** */ + async setIconAsTemplate(asTemplate) { + return core.invoke('plugin:tray|set_icon_as_template', { + rid: this.rid, + asTemplate + }); + } + /** + * Disable or enable showing the tray menu on left click. + * + * #### Platform-specific: + * + * - **Linux**: Unsupported. + * + * @deprecated use {@linkcode TrayIcon.setShowMenuOnLeftClick} instead. + */ + async setMenuOnLeftClick(onLeft) { + return core.invoke('plugin:tray|set_show_menu_on_left_click', { + rid: this.rid, + onLeft + }); + } + /** + * Disable or enable showing the tray menu on left click. + * + * #### Platform-specific: + * + * - **Linux**: Unsupported. + * + * @since 2.2.0 + */ + async setShowMenuOnLeftClick(onLeft) { + return core.invoke('plugin:tray|set_show_menu_on_left_click', { + rid: this.rid, + onLeft + }); + } +} +function mapEvent(e) { + const out = e; + out.position = new dpi.PhysicalPosition(e.position); + out.rect.position = new dpi.PhysicalPosition(e.rect.position); + out.rect.size = new dpi.PhysicalSize(e.rect.size); + return out; +} + +exports.TrayIcon = TrayIcon; diff --git a/scripts/node_modules/@tauri-apps/api/tray.d.ts b/scripts/node_modules/@tauri-apps/api/tray.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d3ee8edcf484f51a934dd898cb6ba2bd66c9043e --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/tray.d.ts @@ -0,0 +1,219 @@ +import type { Menu, Submenu } from './menu'; +import { Resource } from './core'; +import { Image } from './image'; +import { PhysicalPosition, PhysicalSize } from './dpi'; +export type MouseButtonState = 'Up' | 'Down'; +export type MouseButton = 'Left' | 'Right' | 'Middle'; +export type TrayIconEventType = 'Click' | 'DoubleClick' | 'Enter' | 'Move' | 'Leave'; +export type TrayIconEventBase = { + /** The tray icon event type */ + type: T; + /** Id of the tray icon which triggered this event. */ + id: string; + /** Physical position of the click the triggered this event. */ + position: PhysicalPosition; + /** Position and size of the tray icon. */ + rect: { + position: PhysicalPosition; + size: PhysicalSize; + }; +}; +export type TrayIconClickEvent = { + /** Mouse button that triggered this event. */ + button: MouseButton; + /** Mouse button state when this event was triggered. */ + buttonState: MouseButtonState; +}; +/** + * Describes a tray icon event. + * + * #### Platform-specific: + * + * - **Linux**: Unsupported. The event is not emitted even though the icon is shown, + * the icon will still show a context menu on right click. + */ +export type TrayIconEvent = (TrayIconEventBase<'Click'> & TrayIconClickEvent) | (TrayIconEventBase<'DoubleClick'> & Omit) | TrayIconEventBase<'Enter'> | TrayIconEventBase<'Move'> | TrayIconEventBase<'Leave'>; +/** + * Tray icon types and utilities. + * + * This package is also accessible with `window.__TAURI__.tray` when [`app.withGlobalTauri`](https://v2.tauri.app/reference/config/#withglobaltauri) in `tauri.conf.json` is set to `true`. + * @module + */ +/** {@link TrayIcon.new|`TrayIcon`} creation options */ +export interface TrayIconOptions { + /** The tray icon id. If undefined, a random one will be assigned */ + id?: string; + /** The tray icon menu */ + menu?: Menu | Submenu; + /** + * The tray icon which could be icon bytes or path to the icon file. + * + * Note that you may need the `image-ico` or `image-png` Cargo features to use this API. + * To enable it, change your Cargo.toml file: + * ```toml + * [dependencies] + * tauri = { version = "...", features = ["...", "image-png"] } + * ``` + */ + icon?: string | Uint8Array | ArrayBuffer | number[] | Image; + /** The tray icon tooltip */ + tooltip?: string; + /** + * The tray title + * + * #### Platform-specific + * + * - **Linux:** The title will not be shown unless there is an icon + * as well. The title is useful for numerical and other frequently + * updated information. In general, it shouldn't be shown unless a + * user requests it as it can take up a significant amount of space + * on the user's panel. This may not be shown in all visualizations. + * - **Windows:** Unsupported. + */ + title?: string; + /** + * The tray icon temp dir path. **Linux only**. + * + * On Linux, we need to write the icon to the disk and usually it will + * be `$XDG_RUNTIME_DIR/tray-icon` or `$TEMP/tray-icon`. + */ + tempDirPath?: string; + /** + * Use the icon as a [template](https://developer.apple.com/documentation/appkit/nsimage/1520017-template?language=objc). **macOS only**. + */ + iconAsTemplate?: boolean; + /** + * Whether to show the tray menu on left click or not, default is `true`. + * + * #### Platform-specific: + * + * - **Linux**: Unsupported. + * + * @deprecated use {@linkcode TrayIconOptions.showMenuOnLeftClick} instead. + */ + menuOnLeftClick?: boolean; + /** + * Whether to show the tray menu on left click or not, default is `true`. + * + * #### Platform-specific: + * + * - **Linux**: Unsupported. + * + * @since 2.2.0 + */ + showMenuOnLeftClick?: boolean; + /** A handler for an event on the tray icon. */ + action?: (event: TrayIconEvent) => void; +} +/** + * Tray icon class and associated methods. This type constructor is private, + * instead, you should use the static method {@linkcode TrayIcon.new}. + * + * #### Warning + * + * Unlike Rust, javascript does not have any way to run cleanup code + * when an object is being removed by garbage collection, but this tray icon + * will be cleaned up when the tauri app exists, however if you want to cleanup + * this object early, you need to call {@linkcode TrayIcon.close}. + * + * @example + * ```ts + * import { TrayIcon } from '@tauri-apps/api/tray'; + * const tray = await TrayIcon.new({ tooltip: 'awesome tray tooltip' }); + * tray.set_tooltip('new tooltip'); + * ``` + */ +export declare class TrayIcon extends Resource { + /** The id associated with this tray icon. */ + id: string; + private constructor(); + /** Gets a tray icon using the provided id. */ + static getById(id: string): Promise; + /** + * Removes a tray icon using the provided id from tauri's internal state. + * + * Note that this may cause the tray icon to disappear + * if it wasn't cloned somewhere else or referenced by JS. + */ + static removeById(id: string): Promise; + /** + * Creates a new {@linkcode TrayIcon} + * + * #### Platform-specific: + * + * - **Linux:** Sometimes the icon won't be visible unless a menu is set. + * Setting an empty {@linkcode Menu} is enough. + */ + static new(options?: TrayIconOptions): Promise; + /** + * Sets a new tray icon. If `null` is provided, it will remove the icon. + * + * Note that you may need the `image-ico` or `image-png` Cargo features to use this API. + * To enable it, change your Cargo.toml file: + * ```toml + * [dependencies] + * tauri = { version = "...", features = ["...", "image-png"] } + * ``` + */ + setIcon(icon: string | Image | Uint8Array | ArrayBuffer | number[] | null): Promise; + /** + * Sets a new tray menu. + * + * #### Platform-specific: + * + * - **Linux**: once a menu is set it cannot be removed so `null` has no effect + */ + setMenu(menu: Menu | Submenu | null): Promise; + /** + * Sets the tooltip for this tray icon. + * + * #### Platform-specific: + * + * - **Linux:** Unsupported + */ + setTooltip(tooltip: string | null): Promise; + /** + * Sets the tooltip for this tray icon. + * + * #### Platform-specific: + * + * - **Linux:** The title will not be shown unless there is an icon + * as well. The title is useful for numerical and other frequently + * updated information. In general, it shouldn't be shown unless a + * user requests it as it can take up a significant amount of space + * on the user's panel. This may not be shown in all visualizations. + * - **Windows:** Unsupported + */ + setTitle(title: string | null): Promise; + /** Show or hide this tray icon. */ + setVisible(visible: boolean): Promise; + /** + * Sets the tray icon temp dir path. **Linux only**. + * + * On Linux, we need to write the icon to the disk and usually it will + * be `$XDG_RUNTIME_DIR/tray-icon` or `$TEMP/tray-icon`. + */ + setTempDirPath(path: string | null): Promise; + /** Sets the current icon as a [template](https://developer.apple.com/documentation/appkit/nsimage/1520017-template?language=objc). **macOS only** */ + setIconAsTemplate(asTemplate: boolean): Promise; + /** + * Disable or enable showing the tray menu on left click. + * + * #### Platform-specific: + * + * - **Linux**: Unsupported. + * + * @deprecated use {@linkcode TrayIcon.setShowMenuOnLeftClick} instead. + */ + setMenuOnLeftClick(onLeft: boolean): Promise; + /** + * Disable or enable showing the tray menu on left click. + * + * #### Platform-specific: + * + * - **Linux**: Unsupported. + * + * @since 2.2.0 + */ + setShowMenuOnLeftClick(onLeft: boolean): Promise; +} diff --git a/scripts/node_modules/@tauri-apps/api/tray.js b/scripts/node_modules/@tauri-apps/api/tray.js new file mode 100644 index 0000000000000000000000000000000000000000..dceda439679afee9733d12f6eeafedf5112bb34c --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/tray.js @@ -0,0 +1,186 @@ +import { Resource, invoke, Channel } from './core.js'; +import { transformImage } from './image.js'; +import { PhysicalPosition, PhysicalSize } from './dpi.js'; + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * Tray icon class and associated methods. This type constructor is private, + * instead, you should use the static method {@linkcode TrayIcon.new}. + * + * #### Warning + * + * Unlike Rust, javascript does not have any way to run cleanup code + * when an object is being removed by garbage collection, but this tray icon + * will be cleaned up when the tauri app exists, however if you want to cleanup + * this object early, you need to call {@linkcode TrayIcon.close}. + * + * @example + * ```ts + * import { TrayIcon } from '@tauri-apps/api/tray'; + * const tray = await TrayIcon.new({ tooltip: 'awesome tray tooltip' }); + * tray.set_tooltip('new tooltip'); + * ``` + */ +class TrayIcon extends Resource { + constructor(rid, id) { + super(rid); + this.id = id; + } + /** Gets a tray icon using the provided id. */ + static async getById(id) { + return invoke('plugin:tray|get_by_id', { id }).then((rid) => rid ? new TrayIcon(rid, id) : null); + } + /** + * Removes a tray icon using the provided id from tauri's internal state. + * + * Note that this may cause the tray icon to disappear + * if it wasn't cloned somewhere else or referenced by JS. + */ + static async removeById(id) { + return invoke('plugin:tray|remove_by_id', { id }); + } + /** + * Creates a new {@linkcode TrayIcon} + * + * #### Platform-specific: + * + * - **Linux:** Sometimes the icon won't be visible unless a menu is set. + * Setting an empty {@linkcode Menu} is enough. + */ + static async new(options) { + if (options === null || options === void 0 ? void 0 : options.menu) { + // @ts-expect-error we only need the rid and kind + options.menu = [options.menu.rid, options.menu.kind]; + } + if (options === null || options === void 0 ? void 0 : options.icon) { + options.icon = transformImage(options.icon); + } + const handler = new Channel(); + if (options === null || options === void 0 ? void 0 : options.action) { + const action = options.action; + handler.onmessage = (e) => action(mapEvent(e)); + delete options.action; + } + return invoke('plugin:tray|new', { + options: options !== null && options !== void 0 ? options : {}, + handler + }).then(([rid, id]) => new TrayIcon(rid, id)); + } + /** + * Sets a new tray icon. If `null` is provided, it will remove the icon. + * + * Note that you may need the `image-ico` or `image-png` Cargo features to use this API. + * To enable it, change your Cargo.toml file: + * ```toml + * [dependencies] + * tauri = { version = "...", features = ["...", "image-png"] } + * ``` + */ + async setIcon(icon) { + let trayIcon = null; + if (icon) { + trayIcon = transformImage(icon); + } + return invoke('plugin:tray|set_icon', { rid: this.rid, icon: trayIcon }); + } + /** + * Sets a new tray menu. + * + * #### Platform-specific: + * + * - **Linux**: once a menu is set it cannot be removed so `null` has no effect + */ + async setMenu(menu) { + if (menu) { + // @ts-expect-error we only need the rid and kind + menu = [menu.rid, menu.kind]; + } + return invoke('plugin:tray|set_menu', { rid: this.rid, menu }); + } + /** + * Sets the tooltip for this tray icon. + * + * #### Platform-specific: + * + * - **Linux:** Unsupported + */ + async setTooltip(tooltip) { + return invoke('plugin:tray|set_tooltip', { rid: this.rid, tooltip }); + } + /** + * Sets the tooltip for this tray icon. + * + * #### Platform-specific: + * + * - **Linux:** The title will not be shown unless there is an icon + * as well. The title is useful for numerical and other frequently + * updated information. In general, it shouldn't be shown unless a + * user requests it as it can take up a significant amount of space + * on the user's panel. This may not be shown in all visualizations. + * - **Windows:** Unsupported + */ + async setTitle(title) { + return invoke('plugin:tray|set_title', { rid: this.rid, title }); + } + /** Show or hide this tray icon. */ + async setVisible(visible) { + return invoke('plugin:tray|set_visible', { rid: this.rid, visible }); + } + /** + * Sets the tray icon temp dir path. **Linux only**. + * + * On Linux, we need to write the icon to the disk and usually it will + * be `$XDG_RUNTIME_DIR/tray-icon` or `$TEMP/tray-icon`. + */ + async setTempDirPath(path) { + return invoke('plugin:tray|set_temp_dir_path', { rid: this.rid, path }); + } + /** Sets the current icon as a [template](https://developer.apple.com/documentation/appkit/nsimage/1520017-template?language=objc). **macOS only** */ + async setIconAsTemplate(asTemplate) { + return invoke('plugin:tray|set_icon_as_template', { + rid: this.rid, + asTemplate + }); + } + /** + * Disable or enable showing the tray menu on left click. + * + * #### Platform-specific: + * + * - **Linux**: Unsupported. + * + * @deprecated use {@linkcode TrayIcon.setShowMenuOnLeftClick} instead. + */ + async setMenuOnLeftClick(onLeft) { + return invoke('plugin:tray|set_show_menu_on_left_click', { + rid: this.rid, + onLeft + }); + } + /** + * Disable or enable showing the tray menu on left click. + * + * #### Platform-specific: + * + * - **Linux**: Unsupported. + * + * @since 2.2.0 + */ + async setShowMenuOnLeftClick(onLeft) { + return invoke('plugin:tray|set_show_menu_on_left_click', { + rid: this.rid, + onLeft + }); + } +} +function mapEvent(e) { + const out = e; + out.position = new PhysicalPosition(e.position); + out.rect.position = new PhysicalPosition(e.rect.position); + out.rect.size = new PhysicalSize(e.rect.size); + return out; +} + +export { TrayIcon }; diff --git a/scripts/node_modules/@tauri-apps/api/webview.cjs b/scripts/node_modules/@tauri-apps/api/webview.cjs new file mode 100644 index 0000000000000000000000000000000000000000..6feee333e5d590479a1fbbc8a40b930954435475 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/webview.cjs @@ -0,0 +1,594 @@ +'use strict'; + +var dpi = require('./dpi.cjs'); +var event = require('./event.cjs'); +var core = require('./core.cjs'); +var window$1 = require('./window.cjs'); + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * Provides APIs to create webviews, communicate with other webviews and manipulate the current webview. + * + * #### Webview events + * + * Events can be listened to using {@link Webview.listen}: + * ```typescript + * import { getCurrentWebview } from "@tauri-apps/api/webview"; + * getCurrentWebview().listen("my-webview-event", ({ event, payload }) => { }); + * ``` + * + * @module + */ +/** + * Get an instance of `Webview` for the current webview. + * + * @since 2.0.0 + */ +function getCurrentWebview() { + return new Webview(window$1.getCurrentWindow(), window.__TAURI_INTERNALS__.metadata.currentWebview.label, { + // @ts-expect-error `skip` is not defined in the public API but it is handled by the constructor + skip: true + }); +} +/** + * Gets a list of instances of `Webview` for all available webviews. + * + * @since 2.0.0 + */ +async function getAllWebviews() { + return core.invoke('plugin:webview|get_all_webviews').then((webviews) => webviews.map((w) => new Webview(new window$1.Window(w.windowLabel, { + // @ts-expect-error `skip` is not defined in the public API but it is handled by the constructor + skip: true + }), w.label, { + // @ts-expect-error `skip` is not defined in the public API but it is handled by the constructor + skip: true + }))); +} +/** @ignore */ +// events that are emitted right here instead of by the created webview +const localTauriEvents = ['tauri://created', 'tauri://error']; +/** + * Create new webview or get a handle to an existing one. + * + * Webviews are identified by a *label* a unique identifier that can be used to reference it later. + * It may only contain alphanumeric characters `a-zA-Z` plus the following special characters `-`, `/`, `:` and `_`. + * + * @example + * ```typescript + * import { Window } from "@tauri-apps/api/window" + * import { Webview } from "@tauri-apps/api/webview" + * + * const appWindow = new Window('uniqueLabel'); + * + * appWindow.once('tauri://created', async function () { + * // `new Webview` Should be called after the window is successfully created, + * // or webview may not be attached to the window since window is not created yet. + * + * // loading embedded asset: + * const webview = new Webview(appWindow, 'theUniqueLabel', { + * url: 'path/to/page.html', + * + * // create a webview with specific logical position and size + * x: 0, + * y: 0, + * width: 800, + * height: 600, + * }); + * // alternatively, load a remote URL: + * const webview = new Webview(appWindow, 'theUniqueLabel', { + * url: 'https://github.com/tauri-apps/tauri', + * + * // create a webview with specific logical position and size + * x: 0, + * y: 0, + * width: 800, + * height: 600, + * }); + * + * webview.once('tauri://created', function () { + * // webview successfully created + * }); + * webview.once('tauri://error', function (e) { + * // an error happened creating the webview + * }); + * + * + * // emit an event to the backend + * await webview.emit("some-event", "data"); + * // listen to an event from the backend + * const unlisten = await webview.listen("event-name", e => { }); + * unlisten(); + * }); + * ``` + * + * @since 2.0.0 + */ +class Webview { + /** + * Creates a new Webview. + * @example + * ```typescript + * import { Window } from '@tauri-apps/api/window' + * import { Webview } from '@tauri-apps/api/webview' + * const appWindow = new Window('my-label') + * + * appWindow.once('tauri://created', async function() { + * const webview = new Webview(appWindow, 'my-label', { + * url: 'https://github.com/tauri-apps/tauri', + * + * // create a webview with specific logical position and size + * x: 0, + * y: 0, + * width: 800, + * height: 600, + * }); + * + * webview.once('tauri://created', function () { + * // webview successfully created + * }); + * webview.once('tauri://error', function (e) { + * // an error happened creating the webview + * }); + * }); + * ``` + * + * @param window the window to add this webview to. + * @param label The unique webview label. Must be alphanumeric: `a-zA-Z-/:_`. + * @returns The {@link Webview} instance to communicate with the webview. + */ + constructor(window, label, options) { + this.window = window; + this.label = label; + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + this.listeners = Object.create(null); + // @ts-expect-error `skip` is not a public API so it is not defined in WebviewOptions + if (!(options === null || options === void 0 ? void 0 : options.skip)) { + core.invoke('plugin:webview|create_webview', { + windowLabel: window.label, + options: { + ...options, + label + } + }) + .then(async () => this.emit('tauri://created')) + .catch(async (e) => this.emit('tauri://error', e)); + } + } + /** + * Gets the Webview for the webview associated with the given label. + * @example + * ```typescript + * import { Webview } from '@tauri-apps/api/webview'; + * const mainWebview = Webview.getByLabel('main'); + * ``` + * + * @param label The webview label. + * @returns The Webview instance to communicate with the webview or null if the webview doesn't exist. + */ + static async getByLabel(label) { + var _a; + return (_a = (await getAllWebviews()).find((w) => w.label === label)) !== null && _a !== void 0 ? _a : null; + } + /** + * Get an instance of `Webview` for the current webview. + */ + static getCurrent() { + return getCurrentWebview(); + } + /** + * Gets a list of instances of `Webview` for all available webviews. + */ + static async getAll() { + return getAllWebviews(); + } + /** + * Listen to an emitted event on this webview. + * + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * const unlisten = await getCurrentWebview().listen('state-changed', (event) => { + * console.log(`Got error: ${payload}`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async listen(event$1, handler) { + if (this._handleTauriEvent(event$1, handler)) { + return () => { + // eslint-disable-next-line security/detect-object-injection + const listeners = this.listeners[event$1]; + listeners.splice(listeners.indexOf(handler), 1); + }; + } + return event.listen(event$1, handler, { + target: { kind: 'Webview', label: this.label } + }); + } + /** + * Listen to an emitted event on this webview only once. + * + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * const unlisten = await getCurrent().once('initialized', (event) => { + * console.log(`Webview initialized!`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async once(event$1, handler) { + if (this._handleTauriEvent(event$1, handler)) { + return () => { + // eslint-disable-next-line security/detect-object-injection + const listeners = this.listeners[event$1]; + listeners.splice(listeners.indexOf(handler), 1); + }; + } + return event.once(event$1, handler, { + target: { kind: 'Webview', label: this.label } + }); + } + /** + * Emits an event to all {@link EventTarget|targets}. + * + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().emit('webview-loaded', { loggedIn: true, token: 'authToken' }); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param payload Event payload. + */ + async emit(event$1, payload) { + if (localTauriEvents.includes(event$1)) { + // eslint-disable-next-line + for (const handler of this.listeners[event$1] || []) { + handler({ + event: event$1, + id: -1, + payload + }); + } + return; + } + return event.emit(event$1, payload); + } + /** + * Emits an event to all {@link EventTarget|targets} matching the given target. + * + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().emitTo('main', 'webview-loaded', { loggedIn: true, token: 'authToken' }); + * ``` + * + * @param target Label of the target Window/Webview/WebviewWindow or raw {@link EventTarget} object. + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param payload Event payload. + */ + async emitTo(target, event$1, payload) { + if (localTauriEvents.includes(event$1)) { + // eslint-disable-next-line + for (const handler of this.listeners[event$1] || []) { + handler({ + event: event$1, + id: -1, + payload + }); + } + return; + } + return event.emitTo(target, event$1, payload); + } + /** @ignore */ + _handleTauriEvent(event, handler) { + if (localTauriEvents.includes(event)) { + if (!(event in this.listeners)) { + // eslint-disable-next-line security/detect-object-injection + this.listeners[event] = [handler]; + } + else { + // eslint-disable-next-line security/detect-object-injection + this.listeners[event].push(handler); + } + return true; + } + return false; + } + // Getters + /** + * The position of the top-left hand corner of the webview's client area relative to the top-left hand corner of the desktop. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * const position = await getCurrentWebview().position(); + * ``` + * + * @returns The webview's position. + */ + async position() { + return core.invoke('plugin:webview|webview_position', { + label: this.label + }).then((p) => new dpi.PhysicalPosition(p)); + } + /** + * The physical size of the webview's client area. + * The client area is the content of the webview, excluding the title bar and borders. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * const size = await getCurrentWebview().size(); + * ``` + * + * @returns The webview's size. + */ + async size() { + return core.invoke('plugin:webview|webview_size', { + label: this.label + }).then((s) => new dpi.PhysicalSize(s)); + } + // Setters + /** + * Closes the webview. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().close(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async close() { + return core.invoke('plugin:webview|webview_close', { + label: this.label + }); + } + /** + * Resizes the webview. + * @example + * ```typescript + * import { getCurrent, LogicalSize } from '@tauri-apps/api/webview'; + * await getCurrentWebview().setSize(new LogicalSize(600, 500)); + * ``` + * + * @param size The logical or physical size. + * @returns A promise indicating the success or failure of the operation. + */ + async setSize(size) { + return core.invoke('plugin:webview|set_webview_size', { + label: this.label, + value: size instanceof dpi.Size ? size : new dpi.Size(size) + }); + } + /** + * Sets the webview position. + * @example + * ```typescript + * import { getCurrent, LogicalPosition } from '@tauri-apps/api/webview'; + * await getCurrentWebview().setPosition(new LogicalPosition(600, 500)); + * ``` + * + * @param position The new position, in logical or physical pixels. + * @returns A promise indicating the success or failure of the operation. + */ + async setPosition(position) { + return core.invoke('plugin:webview|set_webview_position', { + label: this.label, + value: position instanceof dpi.Position ? position : new dpi.Position(position) + }); + } + /** + * Bring the webview to front and focus. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().setFocus(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async setFocus() { + return core.invoke('plugin:webview|set_webview_focus', { + label: this.label + }); + } + /** + * Sets whether the webview should automatically grow and shrink its size and position when the parent window resizes. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().setAutoResize(true); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async setAutoResize(autoResize) { + return core.invoke('plugin:webview|set_webview_auto_resize', { + label: this.label, + value: autoResize + }); + } + /** + * Hide the webview. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().hide(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async hide() { + return core.invoke('plugin:webview|webview_hide', { + label: this.label + }); + } + /** + * Show the webview. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().show(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async show() { + return core.invoke('plugin:webview|webview_show', { + label: this.label + }); + } + /** + * Set webview zoom level. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().setZoom(1.5); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async setZoom(scaleFactor) { + return core.invoke('plugin:webview|set_webview_zoom', { + label: this.label, + value: scaleFactor + }); + } + /** + * Moves this webview to the given label. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().reparent('other-window'); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async reparent(window) { + return core.invoke('plugin:webview|reparent', { + label: this.label, + window: typeof window === 'string' ? window : window.label + }); + } + /** + * Clears all browsing data for this webview. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().clearAllBrowsingData(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async clearAllBrowsingData() { + return core.invoke('plugin:webview|clear_all_browsing_data'); + } + /** + * Specify the webview background color. + * + * #### Platfrom-specific: + * + * - **macOS / iOS**: Not implemented. + * - **Windows**: + * - On Windows 7, transparency is not supported and the alpha value will be ignored. + * - On Windows higher than 7: translucent colors are not supported so any alpha value other than `0` will be replaced by `255` + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.1.0 + */ + async setBackgroundColor(color) { + return core.invoke('plugin:webview|set_webview_background_color', { color }); + } + // Listeners + /** + * Listen to a file drop event. + * The listener is triggered when the user hovers the selected files on the webview, + * drops the files or cancels the operation. + * + * @example + * ```typescript + * import { getCurrentWebview } from "@tauri-apps/api/webview"; + * const unlisten = await getCurrentWebview().onDragDropEvent((event) => { + * if (event.payload.type === 'over') { + * console.log('User hovering', event.payload.position); + * } else if (event.payload.type === 'drop') { + * console.log('User dropped', event.payload.paths); + * } else { + * console.log('File drop cancelled'); + * } + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * When the debugger panel is open, the drop position of this event may be inaccurate due to a known limitation. + * To retrieve the correct drop position, please detach the debugger. + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async onDragDropEvent(handler) { + const unlistenDragEnter = await this.listen(event.TauriEvent.DRAG_ENTER, (event) => { + handler({ + ...event, + payload: { + type: 'enter', + paths: event.payload.paths, + position: new dpi.PhysicalPosition(event.payload.position) + } + }); + }); + const unlistenDragOver = await this.listen(event.TauriEvent.DRAG_OVER, (event) => { + handler({ + ...event, + payload: { + type: 'over', + position: new dpi.PhysicalPosition(event.payload.position) + } + }); + }); + const unlistenDragDrop = await this.listen(event.TauriEvent.DRAG_DROP, (event) => { + handler({ + ...event, + payload: { + type: 'drop', + paths: event.payload.paths, + position: new dpi.PhysicalPosition(event.payload.position) + } + }); + }); + const unlistenDragLeave = await this.listen(event.TauriEvent.DRAG_LEAVE, (event) => { + handler({ ...event, payload: { type: 'leave' } }); + }); + return () => { + unlistenDragEnter(); + unlistenDragDrop(); + unlistenDragOver(); + unlistenDragLeave(); + }; + } +} + +exports.Webview = Webview; +exports.getAllWebviews = getAllWebviews; +exports.getCurrentWebview = getCurrentWebview; diff --git a/scripts/node_modules/@tauri-apps/api/webview.d.ts b/scripts/node_modules/@tauri-apps/api/webview.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c3048c1e8408e32c8086f9adb4f4ddab8c020098 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/webview.d.ts @@ -0,0 +1,612 @@ +/** + * Provides APIs to create webviews, communicate with other webviews and manipulate the current webview. + * + * #### Webview events + * + * Events can be listened to using {@link Webview.listen}: + * ```typescript + * import { getCurrentWebview } from "@tauri-apps/api/webview"; + * getCurrentWebview().listen("my-webview-event", ({ event, payload }) => { }); + * ``` + * + * @module + */ +import { PhysicalPosition, PhysicalSize } from './dpi'; +import type { LogicalPosition, LogicalSize } from './dpi'; +import { Position, Size } from './dpi'; +import type { EventName, EventCallback, UnlistenFn } from './event'; +import { type EventTarget } from './event'; +import { BackgroundThrottlingPolicy, ScrollBarStyle, Color, Window } from './window'; +import { WebviewWindow } from './webviewWindow'; +/** The drag and drop event types. */ +type DragDropEvent = { + type: 'enter'; + paths: string[]; + position: PhysicalPosition; +} | { + type: 'over'; + position: PhysicalPosition; +} | { + type: 'drop'; + paths: string[]; + position: PhysicalPosition; +} | { + type: 'leave'; +}; +/** + * Get an instance of `Webview` for the current webview. + * + * @since 2.0.0 + */ +declare function getCurrentWebview(): Webview; +/** + * Gets a list of instances of `Webview` for all available webviews. + * + * @since 2.0.0 + */ +declare function getAllWebviews(): Promise; +/** @ignore */ +export type WebviewLabel = string; +/** + * Create new webview or get a handle to an existing one. + * + * Webviews are identified by a *label* a unique identifier that can be used to reference it later. + * It may only contain alphanumeric characters `a-zA-Z` plus the following special characters `-`, `/`, `:` and `_`. + * + * @example + * ```typescript + * import { Window } from "@tauri-apps/api/window" + * import { Webview } from "@tauri-apps/api/webview" + * + * const appWindow = new Window('uniqueLabel'); + * + * appWindow.once('tauri://created', async function () { + * // `new Webview` Should be called after the window is successfully created, + * // or webview may not be attached to the window since window is not created yet. + * + * // loading embedded asset: + * const webview = new Webview(appWindow, 'theUniqueLabel', { + * url: 'path/to/page.html', + * + * // create a webview with specific logical position and size + * x: 0, + * y: 0, + * width: 800, + * height: 600, + * }); + * // alternatively, load a remote URL: + * const webview = new Webview(appWindow, 'theUniqueLabel', { + * url: 'https://github.com/tauri-apps/tauri', + * + * // create a webview with specific logical position and size + * x: 0, + * y: 0, + * width: 800, + * height: 600, + * }); + * + * webview.once('tauri://created', function () { + * // webview successfully created + * }); + * webview.once('tauri://error', function (e) { + * // an error happened creating the webview + * }); + * + * + * // emit an event to the backend + * await webview.emit("some-event", "data"); + * // listen to an event from the backend + * const unlisten = await webview.listen("event-name", e => { }); + * unlisten(); + * }); + * ``` + * + * @since 2.0.0 + */ +declare class Webview { + /** The webview label. It is a unique identifier for the webview, can be used to reference it later. */ + label: WebviewLabel; + /** The window hosting this webview. */ + window: Window; + /** Local event listeners. */ + listeners: Record>>; + /** + * Creates a new Webview. + * @example + * ```typescript + * import { Window } from '@tauri-apps/api/window' + * import { Webview } from '@tauri-apps/api/webview' + * const appWindow = new Window('my-label') + * + * appWindow.once('tauri://created', async function() { + * const webview = new Webview(appWindow, 'my-label', { + * url: 'https://github.com/tauri-apps/tauri', + * + * // create a webview with specific logical position and size + * x: 0, + * y: 0, + * width: 800, + * height: 600, + * }); + * + * webview.once('tauri://created', function () { + * // webview successfully created + * }); + * webview.once('tauri://error', function (e) { + * // an error happened creating the webview + * }); + * }); + * ``` + * + * @param window the window to add this webview to. + * @param label The unique webview label. Must be alphanumeric: `a-zA-Z-/:_`. + * @returns The {@link Webview} instance to communicate with the webview. + */ + constructor(window: Window, label: WebviewLabel, options: WebviewOptions); + /** + * Gets the Webview for the webview associated with the given label. + * @example + * ```typescript + * import { Webview } from '@tauri-apps/api/webview'; + * const mainWebview = Webview.getByLabel('main'); + * ``` + * + * @param label The webview label. + * @returns The Webview instance to communicate with the webview or null if the webview doesn't exist. + */ + static getByLabel(label: string): Promise; + /** + * Get an instance of `Webview` for the current webview. + */ + static getCurrent(): Webview; + /** + * Gets a list of instances of `Webview` for all available webviews. + */ + static getAll(): Promise; + /** + * Listen to an emitted event on this webview. + * + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * const unlisten = await getCurrentWebview().listen('state-changed', (event) => { + * console.log(`Got error: ${payload}`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + listen(event: EventName, handler: EventCallback): Promise; + /** + * Listen to an emitted event on this webview only once. + * + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * const unlisten = await getCurrent().once('initialized', (event) => { + * console.log(`Webview initialized!`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + once(event: EventName, handler: EventCallback): Promise; + /** + * Emits an event to all {@link EventTarget|targets}. + * + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().emit('webview-loaded', { loggedIn: true, token: 'authToken' }); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param payload Event payload. + */ + emit(event: string, payload?: T): Promise; + /** + * Emits an event to all {@link EventTarget|targets} matching the given target. + * + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().emitTo('main', 'webview-loaded', { loggedIn: true, token: 'authToken' }); + * ``` + * + * @param target Label of the target Window/Webview/WebviewWindow or raw {@link EventTarget} object. + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param payload Event payload. + */ + emitTo(target: string | EventTarget, event: string, payload?: T): Promise; + /** @ignore */ + _handleTauriEvent(event: string, handler: EventCallback): boolean; + /** + * The position of the top-left hand corner of the webview's client area relative to the top-left hand corner of the desktop. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * const position = await getCurrentWebview().position(); + * ``` + * + * @returns The webview's position. + */ + position(): Promise; + /** + * The physical size of the webview's client area. + * The client area is the content of the webview, excluding the title bar and borders. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * const size = await getCurrentWebview().size(); + * ``` + * + * @returns The webview's size. + */ + size(): Promise; + /** + * Closes the webview. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().close(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + close(): Promise; + /** + * Resizes the webview. + * @example + * ```typescript + * import { getCurrent, LogicalSize } from '@tauri-apps/api/webview'; + * await getCurrentWebview().setSize(new LogicalSize(600, 500)); + * ``` + * + * @param size The logical or physical size. + * @returns A promise indicating the success or failure of the operation. + */ + setSize(size: LogicalSize | PhysicalSize | Size): Promise; + /** + * Sets the webview position. + * @example + * ```typescript + * import { getCurrent, LogicalPosition } from '@tauri-apps/api/webview'; + * await getCurrentWebview().setPosition(new LogicalPosition(600, 500)); + * ``` + * + * @param position The new position, in logical or physical pixels. + * @returns A promise indicating the success or failure of the operation. + */ + setPosition(position: LogicalPosition | PhysicalPosition | Position): Promise; + /** + * Bring the webview to front and focus. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().setFocus(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + setFocus(): Promise; + /** + * Sets whether the webview should automatically grow and shrink its size and position when the parent window resizes. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().setAutoResize(true); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + setAutoResize(autoResize: boolean): Promise; + /** + * Hide the webview. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().hide(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + hide(): Promise; + /** + * Show the webview. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().show(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + show(): Promise; + /** + * Set webview zoom level. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().setZoom(1.5); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + setZoom(scaleFactor: number): Promise; + /** + * Moves this webview to the given label. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().reparent('other-window'); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + reparent(window: Window | WebviewWindow | string): Promise; + /** + * Clears all browsing data for this webview. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().clearAllBrowsingData(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + clearAllBrowsingData(): Promise; + /** + * Specify the webview background color. + * + * #### Platfrom-specific: + * + * - **macOS / iOS**: Not implemented. + * - **Windows**: + * - On Windows 7, transparency is not supported and the alpha value will be ignored. + * - On Windows higher than 7: translucent colors are not supported so any alpha value other than `0` will be replaced by `255` + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.1.0 + */ + setBackgroundColor(color: Color | null): Promise; + /** + * Listen to a file drop event. + * The listener is triggered when the user hovers the selected files on the webview, + * drops the files or cancels the operation. + * + * @example + * ```typescript + * import { getCurrentWebview } from "@tauri-apps/api/webview"; + * const unlisten = await getCurrentWebview().onDragDropEvent((event) => { + * if (event.payload.type === 'over') { + * console.log('User hovering', event.payload.position); + * } else if (event.payload.type === 'drop') { + * console.log('User dropped', event.payload.paths); + * } else { + * console.log('File drop cancelled'); + * } + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * When the debugger panel is open, the drop position of this event may be inaccurate due to a known limitation. + * To retrieve the correct drop position, please detach the debugger. + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + onDragDropEvent(handler: EventCallback): Promise; +} +/** + * Configuration for the webview to create. + * + * @since 2.0.0 + */ +interface WebviewOptions { + /** + * Remote URL or local file path to open. + * + * - URL such as `https://github.com/tauri-apps` is opened directly on a Tauri webview. + * - data: URL such as `data:text/html,...` is only supported with the `webview-data-url` Cargo feature for the `tauri` dependency. + * - local file path or route such as `/path/to/page.html` or `/users` is appended to the application URL (the devServer URL on development, or `tauri://localhost/` and `https://tauri.localhost/` on production). + */ + url?: string; + /** The initial vertical position in logical pixels. */ + x: number; + /** The initial horizontal position in logical pixels. */ + y: number; + /** The initial width in logical pixels. */ + width: number; + /** The initial height in logical pixels. */ + height: number; + /** + * Whether the webview is transparent or not. + * Note that on `macOS` this requires the `macos-private-api` feature flag, enabled under `tauri.conf.json > app > macOSPrivateApi`. + * WARNING: Using private APIs on `macOS` prevents your application from being accepted to the `App Store`. + */ + transparent?: boolean; + /** + * Whether the webview should have focus or not + * + * @since 2.1.0 + */ + focus?: boolean; + /** + * Whether the drag and drop is enabled or not on the webview. By default it is enabled. + * + * Disabling it is required to use HTML5 drag and drop on the frontend on Windows. + */ + dragDropEnabled?: boolean; + /** + * Whether clicking an inactive webview also clicks through to the webview on macOS. + */ + acceptFirstMouse?: boolean; + /** + * The user agent for the webview. + */ + userAgent?: string; + /** + * Whether or not the webview should be launched in incognito mode. + * + * #### Platform-specific + * + * - **Android:** Unsupported. + */ + incognito?: boolean; + /** + * The proxy URL for the WebView for all network requests. + * + * Must be either a `http://` or a `socks5://` URL. + * + * #### Platform-specific + * + * - **macOS**: Requires the `macos-proxy` feature flag and only compiles for macOS 14+. + * */ + proxyUrl?: string; + /** + * Whether page zooming by hotkeys is enabled + * + * #### Platform-specific: + * + * - **Windows**: Controls WebView2's [`IsZoomControlEnabled`](https://learn.microsoft.com/en-us/microsoft-edge/webview2/reference/winrt/microsoft_web_webview2_core/corewebview2settings?view=webview2-winrt-1.0.2420.47#iszoomcontrolenabled) setting. + * - **MacOS / Linux**: Injects a polyfill that zooms in and out with `ctrl/command` + `-/=`, + * 20% in each step, ranging from 20% to 1000%. Requires `webview:allow-set-webview-zoom` permission + * + * - **Android / iOS**: Unsupported. + */ + zoomHotkeysEnabled?: boolean; + /** + * Sets whether the custom protocols should use `https://.localhost` instead of the default `http://.localhost` on Windows and Android. Defaults to `false`. + * + * #### Note + * + * Using a `https` scheme will NOT allow mixed content when trying to fetch `http` endpoints and therefore will not match the behavior of the `://localhost` protocols used on macOS and Linux. + * + * #### Warning + * + * Changing this value between releases will change the IndexedDB, cookies and localstorage location and your app will not be able to access them. + * + * @since 2.1.0 + */ + useHttpsScheme?: boolean; + /** + * Whether web inspector, which is usually called browser devtools, is enabled or not. Enabled by default. + * + * This API works in **debug** builds, but requires `devtools` feature flag to enable it in **release** builds. + * + * #### Platform-specific + * + * - macOS: This will call private functions on **macOS**. + * - Android: Open `chrome://inspect/#devices` in Chrome to get the devtools window. Wry's `WebView` devtools API isn't supported on Android. + * - iOS: Open Safari > Develop > [Your Device Name] > [Your WebView] to get the devtools window. + * + * @since 2.1.0 + */ + devtools?: boolean; + /** + * Set the window and webview background color. + * + * #### Platform-specific: + * + * - **macOS / iOS**: Not implemented. + * - **Windows**: + * - On Windows 7, alpha channel is ignored. + * - On Windows 8 and newer, if alpha channel is not `0`, it will be ignored. + * + * @since 2.1.0 + */ + backgroundColor?: Color; + /** Change the default background throttling behaviour. + * + * By default, browsers use a suspend policy that will throttle timers and even unload + * the whole tab (view) to free resources after roughly 5 minutes when a view became + * minimized or hidden. This will pause all tasks until the documents visibility state + * changes back from hidden to visible by bringing the view back to the foreground. + * + * ## Platform-specific + * + * - **Linux / Windows / Android**: Unsupported. Workarounds like a pending WebLock transaction might suffice. + * - **iOS**: Supported since version 17.0+. + * - **macOS**: Supported since version 14.0+. + * + * see https://github.com/tauri-apps/tauri/issues/5250#issuecomment-2569380578 + * + * @since 2.3.0 + */ + backgroundThrottling?: BackgroundThrottlingPolicy; + /** + * Whether we should disable JavaScript code execution on the webview or not. + */ + javascriptDisabled?: boolean; + /** + * on macOS and iOS there is a link preview on long pressing links, this is enabled by default. + * see https://docs.rs/objc2-web-kit/latest/objc2_web_kit/struct.WKWebView.html#method.allowsLinkPreview + */ + allowLinkPreview?: boolean; + /** + * Allows disabling the input accessory view on iOS. + * + * The accessory view is the view that appears above the keyboard when a text input element is focused. + * It usually displays a view with "Done", "Next" buttons. + */ + disableInputAccessoryView?: boolean; + /** + * Set a custom path for the webview's data directory (localStorage, cache, etc.) **relative to [`appDataDir()`]/${label}**. + * For security reasons, paths outside of that location can only be configured on the Rust side. + * + * #### Platform-specific: + * + * - **Windows**: WebViews with different values for settings like `additionalBrowserArgs`, `browserExtensionsEnabled` or `scrollBarStyle` must have different data directories. + * - **macOS / iOS**: Unsupported, use `dataStoreIdentifier` instead. + * - **Android**: Unsupported. + * + * @since 2.9.0 + */ + dataDirectory?: string; + /** + * Initialize the WebView with a custom data store identifier. This can be seen as a replacement for `dataDirectory` which is unavailable in WKWebView. + * See https://developer.apple.com/documentation/webkit/wkwebsitedatastore/init(foridentifier:)?language=objc + * + * The array must contain 16 u8 numbers. + * + * #### Platform-specific: + * + * - **macOS / iOS**: Available on macOS >= 14 and iOS >= 17 + * - **Windows / Linux / Android**: Unsupported. + * + * @since 2.9.0 + */ + dataStoreIdentifier?: number[]; + /** + * Specifies the native scrollbar style to use with the webview. + * CSS styles that modify the scrollbar are applied on top of the native appearance configured here. + * + * Defaults to `default`, which is the browser default. + * + * ## Platform-specific + * + * - **Windows**: + * - `fluentOverlay` requires WebView2 Runtime version 125.0.2535.41 or higher, and does nothing + * on older versions. + * - This option must be given the same value for all webviews. + * - **Linux / Android / iOS / macOS**: Unsupported. Only supports `Default` and performs no operation. + */ + scrollBarStyle?: ScrollBarStyle; +} +export { Webview, getCurrentWebview, getAllWebviews }; +export type { DragDropEvent, WebviewOptions, Color }; diff --git a/scripts/node_modules/@tauri-apps/api/webview.js b/scripts/node_modules/@tauri-apps/api/webview.js new file mode 100644 index 0000000000000000000000000000000000000000..703a556c6920f4e30df746997c003a1488516a7f --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/webview.js @@ -0,0 +1,590 @@ +import { PhysicalPosition, PhysicalSize, Size, Position } from './dpi.js'; +import { listen, once, emit, emitTo, TauriEvent } from './event.js'; +import { invoke } from './core.js'; +import { Window, getCurrentWindow } from './window.js'; + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * Provides APIs to create webviews, communicate with other webviews and manipulate the current webview. + * + * #### Webview events + * + * Events can be listened to using {@link Webview.listen}: + * ```typescript + * import { getCurrentWebview } from "@tauri-apps/api/webview"; + * getCurrentWebview().listen("my-webview-event", ({ event, payload }) => { }); + * ``` + * + * @module + */ +/** + * Get an instance of `Webview` for the current webview. + * + * @since 2.0.0 + */ +function getCurrentWebview() { + return new Webview(getCurrentWindow(), window.__TAURI_INTERNALS__.metadata.currentWebview.label, { + // @ts-expect-error `skip` is not defined in the public API but it is handled by the constructor + skip: true + }); +} +/** + * Gets a list of instances of `Webview` for all available webviews. + * + * @since 2.0.0 + */ +async function getAllWebviews() { + return invoke('plugin:webview|get_all_webviews').then((webviews) => webviews.map((w) => new Webview(new Window(w.windowLabel, { + // @ts-expect-error `skip` is not defined in the public API but it is handled by the constructor + skip: true + }), w.label, { + // @ts-expect-error `skip` is not defined in the public API but it is handled by the constructor + skip: true + }))); +} +/** @ignore */ +// events that are emitted right here instead of by the created webview +const localTauriEvents = ['tauri://created', 'tauri://error']; +/** + * Create new webview or get a handle to an existing one. + * + * Webviews are identified by a *label* a unique identifier that can be used to reference it later. + * It may only contain alphanumeric characters `a-zA-Z` plus the following special characters `-`, `/`, `:` and `_`. + * + * @example + * ```typescript + * import { Window } from "@tauri-apps/api/window" + * import { Webview } from "@tauri-apps/api/webview" + * + * const appWindow = new Window('uniqueLabel'); + * + * appWindow.once('tauri://created', async function () { + * // `new Webview` Should be called after the window is successfully created, + * // or webview may not be attached to the window since window is not created yet. + * + * // loading embedded asset: + * const webview = new Webview(appWindow, 'theUniqueLabel', { + * url: 'path/to/page.html', + * + * // create a webview with specific logical position and size + * x: 0, + * y: 0, + * width: 800, + * height: 600, + * }); + * // alternatively, load a remote URL: + * const webview = new Webview(appWindow, 'theUniqueLabel', { + * url: 'https://github.com/tauri-apps/tauri', + * + * // create a webview with specific logical position and size + * x: 0, + * y: 0, + * width: 800, + * height: 600, + * }); + * + * webview.once('tauri://created', function () { + * // webview successfully created + * }); + * webview.once('tauri://error', function (e) { + * // an error happened creating the webview + * }); + * + * + * // emit an event to the backend + * await webview.emit("some-event", "data"); + * // listen to an event from the backend + * const unlisten = await webview.listen("event-name", e => { }); + * unlisten(); + * }); + * ``` + * + * @since 2.0.0 + */ +class Webview { + /** + * Creates a new Webview. + * @example + * ```typescript + * import { Window } from '@tauri-apps/api/window' + * import { Webview } from '@tauri-apps/api/webview' + * const appWindow = new Window('my-label') + * + * appWindow.once('tauri://created', async function() { + * const webview = new Webview(appWindow, 'my-label', { + * url: 'https://github.com/tauri-apps/tauri', + * + * // create a webview with specific logical position and size + * x: 0, + * y: 0, + * width: 800, + * height: 600, + * }); + * + * webview.once('tauri://created', function () { + * // webview successfully created + * }); + * webview.once('tauri://error', function (e) { + * // an error happened creating the webview + * }); + * }); + * ``` + * + * @param window the window to add this webview to. + * @param label The unique webview label. Must be alphanumeric: `a-zA-Z-/:_`. + * @returns The {@link Webview} instance to communicate with the webview. + */ + constructor(window, label, options) { + this.window = window; + this.label = label; + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + this.listeners = Object.create(null); + // @ts-expect-error `skip` is not a public API so it is not defined in WebviewOptions + if (!(options === null || options === void 0 ? void 0 : options.skip)) { + invoke('plugin:webview|create_webview', { + windowLabel: window.label, + options: { + ...options, + label + } + }) + .then(async () => this.emit('tauri://created')) + .catch(async (e) => this.emit('tauri://error', e)); + } + } + /** + * Gets the Webview for the webview associated with the given label. + * @example + * ```typescript + * import { Webview } from '@tauri-apps/api/webview'; + * const mainWebview = Webview.getByLabel('main'); + * ``` + * + * @param label The webview label. + * @returns The Webview instance to communicate with the webview or null if the webview doesn't exist. + */ + static async getByLabel(label) { + var _a; + return (_a = (await getAllWebviews()).find((w) => w.label === label)) !== null && _a !== void 0 ? _a : null; + } + /** + * Get an instance of `Webview` for the current webview. + */ + static getCurrent() { + return getCurrentWebview(); + } + /** + * Gets a list of instances of `Webview` for all available webviews. + */ + static async getAll() { + return getAllWebviews(); + } + /** + * Listen to an emitted event on this webview. + * + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * const unlisten = await getCurrentWebview().listen('state-changed', (event) => { + * console.log(`Got error: ${payload}`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async listen(event, handler) { + if (this._handleTauriEvent(event, handler)) { + return () => { + // eslint-disable-next-line security/detect-object-injection + const listeners = this.listeners[event]; + listeners.splice(listeners.indexOf(handler), 1); + }; + } + return listen(event, handler, { + target: { kind: 'Webview', label: this.label } + }); + } + /** + * Listen to an emitted event on this webview only once. + * + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * const unlisten = await getCurrent().once('initialized', (event) => { + * console.log(`Webview initialized!`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async once(event, handler) { + if (this._handleTauriEvent(event, handler)) { + return () => { + // eslint-disable-next-line security/detect-object-injection + const listeners = this.listeners[event]; + listeners.splice(listeners.indexOf(handler), 1); + }; + } + return once(event, handler, { + target: { kind: 'Webview', label: this.label } + }); + } + /** + * Emits an event to all {@link EventTarget|targets}. + * + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().emit('webview-loaded', { loggedIn: true, token: 'authToken' }); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param payload Event payload. + */ + async emit(event, payload) { + if (localTauriEvents.includes(event)) { + // eslint-disable-next-line + for (const handler of this.listeners[event] || []) { + handler({ + event, + id: -1, + payload + }); + } + return; + } + return emit(event, payload); + } + /** + * Emits an event to all {@link EventTarget|targets} matching the given target. + * + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().emitTo('main', 'webview-loaded', { loggedIn: true, token: 'authToken' }); + * ``` + * + * @param target Label of the target Window/Webview/WebviewWindow or raw {@link EventTarget} object. + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param payload Event payload. + */ + async emitTo(target, event, payload) { + if (localTauriEvents.includes(event)) { + // eslint-disable-next-line + for (const handler of this.listeners[event] || []) { + handler({ + event, + id: -1, + payload + }); + } + return; + } + return emitTo(target, event, payload); + } + /** @ignore */ + _handleTauriEvent(event, handler) { + if (localTauriEvents.includes(event)) { + if (!(event in this.listeners)) { + // eslint-disable-next-line security/detect-object-injection + this.listeners[event] = [handler]; + } + else { + // eslint-disable-next-line security/detect-object-injection + this.listeners[event].push(handler); + } + return true; + } + return false; + } + // Getters + /** + * The position of the top-left hand corner of the webview's client area relative to the top-left hand corner of the desktop. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * const position = await getCurrentWebview().position(); + * ``` + * + * @returns The webview's position. + */ + async position() { + return invoke('plugin:webview|webview_position', { + label: this.label + }).then((p) => new PhysicalPosition(p)); + } + /** + * The physical size of the webview's client area. + * The client area is the content of the webview, excluding the title bar and borders. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * const size = await getCurrentWebview().size(); + * ``` + * + * @returns The webview's size. + */ + async size() { + return invoke('plugin:webview|webview_size', { + label: this.label + }).then((s) => new PhysicalSize(s)); + } + // Setters + /** + * Closes the webview. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().close(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async close() { + return invoke('plugin:webview|webview_close', { + label: this.label + }); + } + /** + * Resizes the webview. + * @example + * ```typescript + * import { getCurrent, LogicalSize } from '@tauri-apps/api/webview'; + * await getCurrentWebview().setSize(new LogicalSize(600, 500)); + * ``` + * + * @param size The logical or physical size. + * @returns A promise indicating the success or failure of the operation. + */ + async setSize(size) { + return invoke('plugin:webview|set_webview_size', { + label: this.label, + value: size instanceof Size ? size : new Size(size) + }); + } + /** + * Sets the webview position. + * @example + * ```typescript + * import { getCurrent, LogicalPosition } from '@tauri-apps/api/webview'; + * await getCurrentWebview().setPosition(new LogicalPosition(600, 500)); + * ``` + * + * @param position The new position, in logical or physical pixels. + * @returns A promise indicating the success or failure of the operation. + */ + async setPosition(position) { + return invoke('plugin:webview|set_webview_position', { + label: this.label, + value: position instanceof Position ? position : new Position(position) + }); + } + /** + * Bring the webview to front and focus. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().setFocus(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async setFocus() { + return invoke('plugin:webview|set_webview_focus', { + label: this.label + }); + } + /** + * Sets whether the webview should automatically grow and shrink its size and position when the parent window resizes. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().setAutoResize(true); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async setAutoResize(autoResize) { + return invoke('plugin:webview|set_webview_auto_resize', { + label: this.label, + value: autoResize + }); + } + /** + * Hide the webview. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().hide(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async hide() { + return invoke('plugin:webview|webview_hide', { + label: this.label + }); + } + /** + * Show the webview. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().show(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async show() { + return invoke('plugin:webview|webview_show', { + label: this.label + }); + } + /** + * Set webview zoom level. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().setZoom(1.5); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async setZoom(scaleFactor) { + return invoke('plugin:webview|set_webview_zoom', { + label: this.label, + value: scaleFactor + }); + } + /** + * Moves this webview to the given label. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().reparent('other-window'); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async reparent(window) { + return invoke('plugin:webview|reparent', { + label: this.label, + window: typeof window === 'string' ? window : window.label + }); + } + /** + * Clears all browsing data for this webview. + * @example + * ```typescript + * import { getCurrentWebview } from '@tauri-apps/api/webview'; + * await getCurrentWebview().clearAllBrowsingData(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async clearAllBrowsingData() { + return invoke('plugin:webview|clear_all_browsing_data'); + } + /** + * Specify the webview background color. + * + * #### Platfrom-specific: + * + * - **macOS / iOS**: Not implemented. + * - **Windows**: + * - On Windows 7, transparency is not supported and the alpha value will be ignored. + * - On Windows higher than 7: translucent colors are not supported so any alpha value other than `0` will be replaced by `255` + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.1.0 + */ + async setBackgroundColor(color) { + return invoke('plugin:webview|set_webview_background_color', { color }); + } + // Listeners + /** + * Listen to a file drop event. + * The listener is triggered when the user hovers the selected files on the webview, + * drops the files or cancels the operation. + * + * @example + * ```typescript + * import { getCurrentWebview } from "@tauri-apps/api/webview"; + * const unlisten = await getCurrentWebview().onDragDropEvent((event) => { + * if (event.payload.type === 'over') { + * console.log('User hovering', event.payload.position); + * } else if (event.payload.type === 'drop') { + * console.log('User dropped', event.payload.paths); + * } else { + * console.log('File drop cancelled'); + * } + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * When the debugger panel is open, the drop position of this event may be inaccurate due to a known limitation. + * To retrieve the correct drop position, please detach the debugger. + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async onDragDropEvent(handler) { + const unlistenDragEnter = await this.listen(TauriEvent.DRAG_ENTER, (event) => { + handler({ + ...event, + payload: { + type: 'enter', + paths: event.payload.paths, + position: new PhysicalPosition(event.payload.position) + } + }); + }); + const unlistenDragOver = await this.listen(TauriEvent.DRAG_OVER, (event) => { + handler({ + ...event, + payload: { + type: 'over', + position: new PhysicalPosition(event.payload.position) + } + }); + }); + const unlistenDragDrop = await this.listen(TauriEvent.DRAG_DROP, (event) => { + handler({ + ...event, + payload: { + type: 'drop', + paths: event.payload.paths, + position: new PhysicalPosition(event.payload.position) + } + }); + }); + const unlistenDragLeave = await this.listen(TauriEvent.DRAG_LEAVE, (event) => { + handler({ ...event, payload: { type: 'leave' } }); + }); + return () => { + unlistenDragEnter(); + unlistenDragDrop(); + unlistenDragOver(); + unlistenDragLeave(); + }; + } +} + +export { Webview, getAllWebviews, getCurrentWebview }; diff --git a/scripts/node_modules/@tauri-apps/api/webviewWindow.cjs b/scripts/node_modules/@tauri-apps/api/webviewWindow.cjs new file mode 100644 index 0000000000000000000000000000000000000000..37406333e34ab94f98bcdc89b55deaa4ae465454 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/webviewWindow.cjs @@ -0,0 +1,211 @@ +'use strict'; + +var webview = require('./webview.cjs'); +var window = require('./window.cjs'); +var event = require('./event.cjs'); +var core = require('./core.cjs'); + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * Get an instance of `Webview` for the current webview window. + * + * @since 2.0.0 + */ +function getCurrentWebviewWindow() { + const webview$1 = webview.getCurrentWebview(); + // @ts-expect-error `skip` is not defined in the public API but it is handled by the constructor + return new WebviewWindow(webview$1.label, { skip: true }); +} +/** + * Gets a list of instances of `Webview` for all available webview windows. + * + * @since 2.0.0 + */ +async function getAllWebviewWindows() { + return core.invoke('plugin:window|get_all_windows').then((windows) => windows.map((w) => new WebviewWindow(w, { + // @ts-expect-error `skip` is not defined in the public API but it is handled by the constructor + skip: true + }))); +} +// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging +class WebviewWindow { + /** + * Creates a new {@link Window} hosting a {@link Webview}. + * @example + * ```typescript + * import { WebviewWindow } from '@tauri-apps/api/webviewWindow' + * const webview = new WebviewWindow('my-label', { + * url: 'https://github.com/tauri-apps/tauri' + * }); + * webview.once('tauri://created', function () { + * // webview successfully created + * }); + * webview.once('tauri://error', function (e) { + * // an error happened creating the webview + * }); + * ``` + * + * @param label The unique webview label. Must be alphanumeric: `a-zA-Z-/:_`. + * @returns The {@link WebviewWindow} instance to communicate with the window and webview. + */ + constructor(label, options = {}) { + var _a; + this.label = label; + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + this.listeners = Object.create(null); + // @ts-expect-error `skip` is not a public API so it is not defined in WebviewOptions + if (!(options === null || options === void 0 ? void 0 : options.skip)) { + core.invoke('plugin:webview|create_webview_window', { + options: { + ...options, + parent: typeof options.parent === 'string' + ? options.parent + : (_a = options.parent) === null || _a === void 0 ? void 0 : _a.label, + label + } + }) + .then(async () => this.emit('tauri://created')) + .catch(async (e) => this.emit('tauri://error', e)); + } + } + /** + * Gets the Webview for the webview associated with the given label. + * @example + * ```typescript + * import { WebviewWindow } from '@tauri-apps/api/webviewWindow'; + * const mainWebview = WebviewWindow.getByLabel('main'); + * ``` + * + * @param label The webview label. + * @returns The Webview instance to communicate with the webview or null if the webview doesn't exist. + */ + static async getByLabel(label) { + var _a; + const webview = (_a = (await getAllWebviewWindows()).find((w) => w.label === label)) !== null && _a !== void 0 ? _a : null; + if (webview) { + // @ts-expect-error `skip` is not defined in the public API but it is handled by the constructor + return new WebviewWindow(webview.label, { skip: true }); + } + return null; + } + /** + * Get an instance of `Webview` for the current webview. + */ + static getCurrent() { + return getCurrentWebviewWindow(); + } + /** + * Gets a list of instances of `Webview` for all available webviews. + */ + static async getAll() { + return getAllWebviewWindows(); + } + /** + * Listen to an emitted event on this webview window. + * + * @example + * ```typescript + * import { WebviewWindow } from '@tauri-apps/api/webviewWindow'; + * const unlisten = await WebviewWindow.getCurrent().listen('state-changed', (event) => { + * console.log(`Got error: ${payload}`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async listen(event$1, handler) { + if (this._handleTauriEvent(event$1, handler)) { + return () => { + // eslint-disable-next-line security/detect-object-injection + const listeners = this.listeners[event$1]; + listeners.splice(listeners.indexOf(handler), 1); + }; + } + return event.listen(event$1, handler, { + target: { kind: 'WebviewWindow', label: this.label } + }); + } + /** + * Listen to an emitted event on this webview window only once. + * + * @example + * ```typescript + * import { WebviewWindow } from '@tauri-apps/api/webviewWindow'; + * const unlisten = await WebviewWindow.getCurrent().once('initialized', (event) => { + * console.log(`Webview initialized!`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async once(event$1, handler) { + if (this._handleTauriEvent(event$1, handler)) { + return () => { + // eslint-disable-next-line security/detect-object-injection + const listeners = this.listeners[event$1]; + listeners.splice(listeners.indexOf(handler), 1); + }; + } + return event.once(event$1, handler, { + target: { kind: 'WebviewWindow', label: this.label } + }); + } + /** + * Set the window and webview background color. + * + * #### Platform-specific: + * + * - **Android / iOS:** Unsupported for the window layer. + * - **macOS / iOS**: Not implemented for the webview layer. + * - **Windows**: + * - alpha channel is ignored for the window layer. + * - On Windows 7, alpha channel is ignored for the webview layer. + * - On Windows 8 and newer, if alpha channel is not `0`, it will be ignored. + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.1.0 + */ + async setBackgroundColor(color) { + return core.invoke('plugin:window|set_background_color', { color }).then(() => { + return core.invoke('plugin:webview|set_webview_background_color', { color }); + }); + } +} +// Order matters, we use window APIs by default +applyMixins(WebviewWindow, [window.Window, webview.Webview]); +/** Extends a base class by other specified classes, without overriding existing properties */ +function applyMixins(baseClass, extendedClasses) { + (Array.isArray(extendedClasses) + ? extendedClasses + : [extendedClasses]).forEach((extendedClass) => { + Object.getOwnPropertyNames(extendedClass.prototype).forEach((name) => { + var _a; + if (typeof baseClass.prototype === 'object' + && baseClass.prototype + && name in baseClass.prototype) + return; + Object.defineProperty(baseClass.prototype, name, + // eslint-disable-next-line + (_a = Object.getOwnPropertyDescriptor(extendedClass.prototype, name)) !== null && _a !== void 0 ? _a : Object.create(null)); + }); + }); +} + +exports.WebviewWindow = WebviewWindow; +exports.getAllWebviewWindows = getAllWebviewWindows; +exports.getCurrentWebviewWindow = getCurrentWebviewWindow; diff --git a/scripts/node_modules/@tauri-apps/api/webviewWindow.d.ts b/scripts/node_modules/@tauri-apps/api/webviewWindow.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f5ae32c6d406d26bd340dcd4c81b81c25266af67 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/webviewWindow.d.ts @@ -0,0 +1,123 @@ +import { Webview, WebviewLabel, WebviewOptions } from './webview'; +import type { WindowOptions } from './window'; +import { Window } from './window'; +import type { EventName, EventCallback, UnlistenFn } from './event'; +import type { Color, DragDropEvent } from './webview'; +/** + * Get an instance of `Webview` for the current webview window. + * + * @since 2.0.0 + */ +declare function getCurrentWebviewWindow(): WebviewWindow; +/** + * Gets a list of instances of `Webview` for all available webview windows. + * + * @since 2.0.0 + */ +declare function getAllWebviewWindows(): Promise; +interface WebviewWindow extends Webview, Window { +} +declare class WebviewWindow { + label: string; + /** Local event listeners. */ + listeners: Record>>; + /** + * Creates a new {@link Window} hosting a {@link Webview}. + * @example + * ```typescript + * import { WebviewWindow } from '@tauri-apps/api/webviewWindow' + * const webview = new WebviewWindow('my-label', { + * url: 'https://github.com/tauri-apps/tauri' + * }); + * webview.once('tauri://created', function () { + * // webview successfully created + * }); + * webview.once('tauri://error', function (e) { + * // an error happened creating the webview + * }); + * ``` + * + * @param label The unique webview label. Must be alphanumeric: `a-zA-Z-/:_`. + * @returns The {@link WebviewWindow} instance to communicate with the window and webview. + */ + constructor(label: WebviewLabel, options?: Omit & WindowOptions); + /** + * Gets the Webview for the webview associated with the given label. + * @example + * ```typescript + * import { WebviewWindow } from '@tauri-apps/api/webviewWindow'; + * const mainWebview = WebviewWindow.getByLabel('main'); + * ``` + * + * @param label The webview label. + * @returns The Webview instance to communicate with the webview or null if the webview doesn't exist. + */ + static getByLabel(label: string): Promise; + /** + * Get an instance of `Webview` for the current webview. + */ + static getCurrent(): WebviewWindow; + /** + * Gets a list of instances of `Webview` for all available webviews. + */ + static getAll(): Promise; + /** + * Listen to an emitted event on this webview window. + * + * @example + * ```typescript + * import { WebviewWindow } from '@tauri-apps/api/webviewWindow'; + * const unlisten = await WebviewWindow.getCurrent().listen('state-changed', (event) => { + * console.log(`Got error: ${payload}`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + listen(event: EventName, handler: EventCallback): Promise; + /** + * Listen to an emitted event on this webview window only once. + * + * @example + * ```typescript + * import { WebviewWindow } from '@tauri-apps/api/webviewWindow'; + * const unlisten = await WebviewWindow.getCurrent().once('initialized', (event) => { + * console.log(`Webview initialized!`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + once(event: EventName, handler: EventCallback): Promise; + /** + * Set the window and webview background color. + * + * #### Platform-specific: + * + * - **Android / iOS:** Unsupported for the window layer. + * - **macOS / iOS**: Not implemented for the webview layer. + * - **Windows**: + * - alpha channel is ignored for the window layer. + * - On Windows 7, alpha channel is ignored for the webview layer. + * - On Windows 8 and newer, if alpha channel is not `0`, it will be ignored. + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.1.0 + */ + setBackgroundColor(color: Color): Promise; +} +export { WebviewWindow, getCurrentWebviewWindow, getAllWebviewWindows }; +export type { DragDropEvent, Color }; diff --git a/scripts/node_modules/@tauri-apps/api/webviewWindow.js b/scripts/node_modules/@tauri-apps/api/webviewWindow.js new file mode 100644 index 0000000000000000000000000000000000000000..38a6a4c8f148f6419852a1d569967355a7b8caa5 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/webviewWindow.js @@ -0,0 +1,207 @@ +import { getCurrentWebview, Webview } from './webview.js'; +import { Window } from './window.js'; +import { listen, once } from './event.js'; +import { invoke } from './core.js'; + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * Get an instance of `Webview` for the current webview window. + * + * @since 2.0.0 + */ +function getCurrentWebviewWindow() { + const webview = getCurrentWebview(); + // @ts-expect-error `skip` is not defined in the public API but it is handled by the constructor + return new WebviewWindow(webview.label, { skip: true }); +} +/** + * Gets a list of instances of `Webview` for all available webview windows. + * + * @since 2.0.0 + */ +async function getAllWebviewWindows() { + return invoke('plugin:window|get_all_windows').then((windows) => windows.map((w) => new WebviewWindow(w, { + // @ts-expect-error `skip` is not defined in the public API but it is handled by the constructor + skip: true + }))); +} +// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging +class WebviewWindow { + /** + * Creates a new {@link Window} hosting a {@link Webview}. + * @example + * ```typescript + * import { WebviewWindow } from '@tauri-apps/api/webviewWindow' + * const webview = new WebviewWindow('my-label', { + * url: 'https://github.com/tauri-apps/tauri' + * }); + * webview.once('tauri://created', function () { + * // webview successfully created + * }); + * webview.once('tauri://error', function (e) { + * // an error happened creating the webview + * }); + * ``` + * + * @param label The unique webview label. Must be alphanumeric: `a-zA-Z-/:_`. + * @returns The {@link WebviewWindow} instance to communicate with the window and webview. + */ + constructor(label, options = {}) { + var _a; + this.label = label; + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + this.listeners = Object.create(null); + // @ts-expect-error `skip` is not a public API so it is not defined in WebviewOptions + if (!(options === null || options === void 0 ? void 0 : options.skip)) { + invoke('plugin:webview|create_webview_window', { + options: { + ...options, + parent: typeof options.parent === 'string' + ? options.parent + : (_a = options.parent) === null || _a === void 0 ? void 0 : _a.label, + label + } + }) + .then(async () => this.emit('tauri://created')) + .catch(async (e) => this.emit('tauri://error', e)); + } + } + /** + * Gets the Webview for the webview associated with the given label. + * @example + * ```typescript + * import { WebviewWindow } from '@tauri-apps/api/webviewWindow'; + * const mainWebview = WebviewWindow.getByLabel('main'); + * ``` + * + * @param label The webview label. + * @returns The Webview instance to communicate with the webview or null if the webview doesn't exist. + */ + static async getByLabel(label) { + var _a; + const webview = (_a = (await getAllWebviewWindows()).find((w) => w.label === label)) !== null && _a !== void 0 ? _a : null; + if (webview) { + // @ts-expect-error `skip` is not defined in the public API but it is handled by the constructor + return new WebviewWindow(webview.label, { skip: true }); + } + return null; + } + /** + * Get an instance of `Webview` for the current webview. + */ + static getCurrent() { + return getCurrentWebviewWindow(); + } + /** + * Gets a list of instances of `Webview` for all available webviews. + */ + static async getAll() { + return getAllWebviewWindows(); + } + /** + * Listen to an emitted event on this webview window. + * + * @example + * ```typescript + * import { WebviewWindow } from '@tauri-apps/api/webviewWindow'; + * const unlisten = await WebviewWindow.getCurrent().listen('state-changed', (event) => { + * console.log(`Got error: ${payload}`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async listen(event, handler) { + if (this._handleTauriEvent(event, handler)) { + return () => { + // eslint-disable-next-line security/detect-object-injection + const listeners = this.listeners[event]; + listeners.splice(listeners.indexOf(handler), 1); + }; + } + return listen(event, handler, { + target: { kind: 'WebviewWindow', label: this.label } + }); + } + /** + * Listen to an emitted event on this webview window only once. + * + * @example + * ```typescript + * import { WebviewWindow } from '@tauri-apps/api/webviewWindow'; + * const unlisten = await WebviewWindow.getCurrent().once('initialized', (event) => { + * console.log(`Webview initialized!`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async once(event, handler) { + if (this._handleTauriEvent(event, handler)) { + return () => { + // eslint-disable-next-line security/detect-object-injection + const listeners = this.listeners[event]; + listeners.splice(listeners.indexOf(handler), 1); + }; + } + return once(event, handler, { + target: { kind: 'WebviewWindow', label: this.label } + }); + } + /** + * Set the window and webview background color. + * + * #### Platform-specific: + * + * - **Android / iOS:** Unsupported for the window layer. + * - **macOS / iOS**: Not implemented for the webview layer. + * - **Windows**: + * - alpha channel is ignored for the window layer. + * - On Windows 7, alpha channel is ignored for the webview layer. + * - On Windows 8 and newer, if alpha channel is not `0`, it will be ignored. + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.1.0 + */ + async setBackgroundColor(color) { + return invoke('plugin:window|set_background_color', { color }).then(() => { + return invoke('plugin:webview|set_webview_background_color', { color }); + }); + } +} +// Order matters, we use window APIs by default +applyMixins(WebviewWindow, [Window, Webview]); +/** Extends a base class by other specified classes, without overriding existing properties */ +function applyMixins(baseClass, extendedClasses) { + (Array.isArray(extendedClasses) + ? extendedClasses + : [extendedClasses]).forEach((extendedClass) => { + Object.getOwnPropertyNames(extendedClass.prototype).forEach((name) => { + var _a; + if (typeof baseClass.prototype === 'object' + && baseClass.prototype + && name in baseClass.prototype) + return; + Object.defineProperty(baseClass.prototype, name, + // eslint-disable-next-line + (_a = Object.getOwnPropertyDescriptor(extendedClass.prototype, name)) !== null && _a !== void 0 ? _a : Object.create(null)); + }); + }); +} + +export { WebviewWindow, getAllWebviewWindows, getCurrentWebviewWindow }; diff --git a/scripts/node_modules/@tauri-apps/api/window.cjs b/scripts/node_modules/@tauri-apps/api/window.cjs new file mode 100644 index 0000000000000000000000000000000000000000..d49d1c66558804db0a6119d5c07438fe5a79030b --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/window.cjs @@ -0,0 +1,2051 @@ +'use strict'; + +var dpi = require('./dpi.cjs'); +var event = require('./event.cjs'); +var core = require('./core.cjs'); +var image = require('./image.cjs'); + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * Provides APIs to create windows, communicate with other windows and manipulate the current window. + * + * #### Window events + * + * Events can be listened to using {@link Window.listen}: + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * getCurrentWindow().listen("my-window-event", ({ event, payload }) => { }); + * ``` + * + * @module + */ +/** + * Attention type to request on a window. + * + * @since 1.0.0 + */ +exports.UserAttentionType = void 0; +(function (UserAttentionType) { + /** + * #### Platform-specific + * - **macOS:** Bounces the dock icon until the application is in focus. + * - **Windows:** Flashes both the window and the taskbar button until the application is in focus. + */ + UserAttentionType[UserAttentionType["Critical"] = 1] = "Critical"; + /** + * #### Platform-specific + * - **macOS:** Bounces the dock icon once. + * - **Windows:** Flashes the taskbar button until the application is in focus. + */ + UserAttentionType[UserAttentionType["Informational"] = 2] = "Informational"; +})(exports.UserAttentionType || (exports.UserAttentionType = {})); +class CloseRequestedEvent { + constructor(event) { + this._preventDefault = false; + this.event = event.event; + this.id = event.id; + } + preventDefault() { + this._preventDefault = true; + } + isPreventDefault() { + return this._preventDefault; + } +} +exports.ProgressBarStatus = void 0; +(function (ProgressBarStatus) { + /** + * Hide progress bar. + */ + ProgressBarStatus["None"] = "none"; + /** + * Normal state. + */ + ProgressBarStatus["Normal"] = "normal"; + /** + * Indeterminate state. **Treated as Normal on Linux and macOS** + */ + ProgressBarStatus["Indeterminate"] = "indeterminate"; + /** + * Paused state. **Treated as Normal on Linux** + */ + ProgressBarStatus["Paused"] = "paused"; + /** + * Error state. **Treated as Normal on linux** + */ + ProgressBarStatus["Error"] = "error"; +})(exports.ProgressBarStatus || (exports.ProgressBarStatus = {})); +/** + * Get an instance of `Window` for the current window. + * + * @since 1.0.0 + */ +function getCurrentWindow() { + return new Window(window.__TAURI_INTERNALS__.metadata.currentWindow.label, { + // @ts-expect-error `skip` is not defined in the public API but it is handled by the constructor + skip: true + }); +} +/** + * Gets a list of instances of `Window` for all available windows. + * + * @since 1.0.0 + */ +async function getAllWindows() { + return core.invoke('plugin:window|get_all_windows').then((windows) => windows.map((w) => new Window(w, { + // @ts-expect-error `skip` is not defined in the public API but it is handled by the constructor + skip: true + }))); +} +/** @ignore */ +// events that are emitted right here instead of by the created window +const localTauriEvents = ['tauri://created', 'tauri://error']; +/** + * Create new window or get a handle to an existing one. + * + * Windows are identified by a *label* a unique identifier that can be used to reference it later. + * It may only contain alphanumeric characters `a-zA-Z` plus the following special characters `-`, `/`, `:` and `_`. + * + * @example + * ```typescript + * import { Window } from "@tauri-apps/api/window" + * + * const appWindow = new Window('theUniqueLabel'); + * + * appWindow.once('tauri://created', function () { + * // window successfully created + * }); + * appWindow.once('tauri://error', function (e) { + * // an error happened creating the window + * }); + * + * // emit an event to the backend + * await appWindow.emit("some-event", "data"); + * // listen to an event from the backend + * const unlisten = await appWindow.listen("event-name", e => {}); + * unlisten(); + * ``` + * + * @since 2.0.0 + */ +class Window { + /** + * Creates a new Window. + * @example + * ```typescript + * import { Window } from '@tauri-apps/api/window'; + * const appWindow = new Window('my-label'); + * appWindow.once('tauri://created', function () { + * // window successfully created + * }); + * appWindow.once('tauri://error', function (e) { + * // an error happened creating the window + * }); + * ``` + * + * @param label The unique window label. Must be alphanumeric: `a-zA-Z-/:_`. + * @returns The {@link Window} instance to communicate with the window. + */ + constructor(label, options = {}) { + var _a; + this.label = label; + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + this.listeners = Object.create(null); + // @ts-expect-error `skip` is not a public API so it is not defined in WindowOptions + if (!(options === null || options === void 0 ? void 0 : options.skip)) { + core.invoke('plugin:window|create', { + options: { + ...options, + parent: typeof options.parent === 'string' + ? options.parent + : (_a = options.parent) === null || _a === void 0 ? void 0 : _a.label, + label + } + }) + .then(async () => this.emit('tauri://created')) + .catch(async (e) => this.emit('tauri://error', e)); + } + } + /** + * Gets the Window associated with the given label. + * @example + * ```typescript + * import { Window } from '@tauri-apps/api/window'; + * const mainWindow = Window.getByLabel('main'); + * ``` + * + * @param label The window label. + * @returns The Window instance to communicate with the window or null if the window doesn't exist. + */ + static async getByLabel(label) { + var _a; + return (_a = (await getAllWindows()).find((w) => w.label === label)) !== null && _a !== void 0 ? _a : null; + } + /** + * Get an instance of `Window` for the current window. + */ + static getCurrent() { + return getCurrentWindow(); + } + /** + * Gets a list of instances of `Window` for all available windows. + */ + static async getAll() { + return getAllWindows(); + } + /** + * Gets the focused window. + * @example + * ```typescript + * import { Window } from '@tauri-apps/api/window'; + * const focusedWindow = Window.getFocusedWindow(); + * ``` + * + * @returns The Window instance or `undefined` if there is not any focused window. + */ + static async getFocusedWindow() { + for (const w of await getAllWindows()) { + if (await w.isFocused()) { + return w; + } + } + return null; + } + /** + * Listen to an emitted event on this window. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const unlisten = await getCurrentWindow().listen('state-changed', (event) => { + * console.log(`Got error: ${payload}`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async listen(event$1, handler) { + if (this._handleTauriEvent(event$1, handler)) { + return () => { + // eslint-disable-next-line security/detect-object-injection + const listeners = this.listeners[event$1]; + listeners.splice(listeners.indexOf(handler), 1); + }; + } + return event.listen(event$1, handler, { + target: { kind: 'Window', label: this.label } + }); + } + /** + * Listen to an emitted event on this window only once. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const unlisten = await getCurrentWindow().once('initialized', (event) => { + * console.log(`Window initialized!`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async once(event$1, handler) { + if (this._handleTauriEvent(event$1, handler)) { + return () => { + // eslint-disable-next-line security/detect-object-injection + const listeners = this.listeners[event$1]; + listeners.splice(listeners.indexOf(handler), 1); + }; + } + return event.once(event$1, handler, { + target: { kind: 'Window', label: this.label } + }); + } + /** + * Emits an event to all {@link EventTarget|targets}. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().emit('window-loaded', { loggedIn: true, token: 'authToken' }); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param payload Event payload. + */ + async emit(event$1, payload) { + if (localTauriEvents.includes(event$1)) { + // eslint-disable-next-line + for (const handler of this.listeners[event$1] || []) { + handler({ + event: event$1, + id: -1, + payload + }); + } + return; + } + return event.emit(event$1, payload); + } + /** + * Emits an event to all {@link EventTarget|targets} matching the given target. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().emit('main', 'window-loaded', { loggedIn: true, token: 'authToken' }); + * ``` + * @param target Label of the target Window/Webview/WebviewWindow or raw {@link EventTarget} object. + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param payload Event payload. + */ + async emitTo(target, event$1, payload) { + if (localTauriEvents.includes(event$1)) { + // eslint-disable-next-line security/detect-object-injection + for (const handler of this.listeners[event$1] || []) { + handler({ + event: event$1, + id: -1, + payload + }); + } + return; + } + return event.emitTo(target, event$1, payload); + } + /** @ignore */ + _handleTauriEvent(event, handler) { + if (localTauriEvents.includes(event)) { + if (!(event in this.listeners)) { + // eslint-disable-next-line + this.listeners[event] = [handler]; + } + else { + // eslint-disable-next-line + this.listeners[event].push(handler); + } + return true; + } + return false; + } + // Getters + /** + * The scale factor that can be used to map physical pixels to logical pixels. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const factor = await getCurrentWindow().scaleFactor(); + * ``` + * + * @returns The window's monitor scale factor. + */ + async scaleFactor() { + return core.invoke('plugin:window|scale_factor', { + label: this.label + }); + } + /** + * The position of the top-left hand corner of the window's client area relative to the top-left hand corner of the desktop. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const position = await getCurrentWindow().innerPosition(); + * ``` + * + * @returns The window's inner position. + */ + async innerPosition() { + return core.invoke('plugin:window|inner_position', { + label: this.label + }).then((p) => new dpi.PhysicalPosition(p)); + } + /** + * The position of the top-left hand corner of the window relative to the top-left hand corner of the desktop. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const position = await getCurrentWindow().outerPosition(); + * ``` + * + * @returns The window's outer position. + */ + async outerPosition() { + return core.invoke('plugin:window|outer_position', { + label: this.label + }).then((p) => new dpi.PhysicalPosition(p)); + } + /** + * The physical size of the window's client area. + * The client area is the content of the window, excluding the title bar and borders. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const size = await getCurrentWindow().innerSize(); + * ``` + * + * @returns The window's inner size. + */ + async innerSize() { + return core.invoke('plugin:window|inner_size', { + label: this.label + }).then((s) => new dpi.PhysicalSize(s)); + } + /** + * The physical size of the entire window. + * These dimensions include the title bar and borders. If you don't want that (and you usually don't), use inner_size instead. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const size = await getCurrentWindow().outerSize(); + * ``` + * + * @returns The window's outer size. + */ + async outerSize() { + return core.invoke('plugin:window|outer_size', { + label: this.label + }).then((s) => new dpi.PhysicalSize(s)); + } + /** + * Gets the window's current fullscreen state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const fullscreen = await getCurrentWindow().isFullscreen(); + * ``` + * + * @returns Whether the window is in fullscreen mode or not. + */ + async isFullscreen() { + return core.invoke('plugin:window|is_fullscreen', { + label: this.label + }); + } + /** + * Gets the window's current minimized state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const minimized = await getCurrentWindow().isMinimized(); + * ``` + */ + async isMinimized() { + return core.invoke('plugin:window|is_minimized', { + label: this.label + }); + } + /** + * Gets the window's current maximized state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const maximized = await getCurrentWindow().isMaximized(); + * ``` + * + * @returns Whether the window is maximized or not. + */ + async isMaximized() { + return core.invoke('plugin:window|is_maximized', { + label: this.label + }); + } + /** + * Gets the window's current focus state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const focused = await getCurrentWindow().isFocused(); + * ``` + * + * @returns Whether the window is focused or not. + */ + async isFocused() { + return core.invoke('plugin:window|is_focused', { + label: this.label + }); + } + /** + * Gets the window's current decorated state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const decorated = await getCurrentWindow().isDecorated(); + * ``` + * + * @returns Whether the window is decorated or not. + */ + async isDecorated() { + return core.invoke('plugin:window|is_decorated', { + label: this.label + }); + } + /** + * Gets the window's current resizable state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const resizable = await getCurrentWindow().isResizable(); + * ``` + * + * @returns Whether the window is resizable or not. + */ + async isResizable() { + return core.invoke('plugin:window|is_resizable', { + label: this.label + }); + } + /** + * Gets the window's native maximize button state. + * + * #### Platform-specific + * + * - **Linux / iOS / Android:** Unsupported. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const maximizable = await getCurrentWindow().isMaximizable(); + * ``` + * + * @returns Whether the window's native maximize button is enabled or not. + */ + async isMaximizable() { + return core.invoke('plugin:window|is_maximizable', { + label: this.label + }); + } + /** + * Gets the window's native minimize button state. + * + * #### Platform-specific + * + * - **Linux / iOS / Android:** Unsupported. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const minimizable = await getCurrentWindow().isMinimizable(); + * ``` + * + * @returns Whether the window's native minimize button is enabled or not. + */ + async isMinimizable() { + return core.invoke('plugin:window|is_minimizable', { + label: this.label + }); + } + /** + * Gets the window's native close button state. + * + * #### Platform-specific + * + * - **iOS / Android:** Unsupported. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const closable = await getCurrentWindow().isClosable(); + * ``` + * + * @returns Whether the window's native close button is enabled or not. + */ + async isClosable() { + return core.invoke('plugin:window|is_closable', { + label: this.label + }); + } + /** + * Gets the window's current visible state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const visible = await getCurrentWindow().isVisible(); + * ``` + * + * @returns Whether the window is visible or not. + */ + async isVisible() { + return core.invoke('plugin:window|is_visible', { + label: this.label + }); + } + /** + * Gets the window's current title. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const title = await getCurrentWindow().title(); + * ``` + */ + async title() { + return core.invoke('plugin:window|title', { + label: this.label + }); + } + /** + * Gets the window's current theme. + * + * #### Platform-specific + * + * - **macOS:** Theme was introduced on macOS 10.14. Returns `light` on macOS 10.13 and below. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const theme = await getCurrentWindow().theme(); + * ``` + * + * @returns The window theme. + */ + async theme() { + return core.invoke('plugin:window|theme', { + label: this.label + }); + } + /** + * Whether the window is configured to be always on top of other windows or not. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const alwaysOnTop = await getCurrentWindow().isAlwaysOnTop(); + * ``` + * + * @returns Whether the window is visible or not. + */ + async isAlwaysOnTop() { + return core.invoke('plugin:window|is_always_on_top', { + label: this.label + }); + } + // Setters + /** + * Centers the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().center(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async center() { + return core.invoke('plugin:window|center', { + label: this.label + }); + } + /** + * Requests user attention to the window, this has no effect if the application + * is already focused. How requesting for user attention manifests is platform dependent, + * see `UserAttentionType` for details. + * + * Providing `null` will unset the request for user attention. Unsetting the request for + * user attention might not be done automatically by the WM when the window receives input. + * + * #### Platform-specific + * + * - **macOS:** `null` has no effect. + * - **Linux:** Urgency levels have the same effect. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().requestUserAttention(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async requestUserAttention(requestType) { + let requestType_ = null; + if (requestType) { + if (requestType === exports.UserAttentionType.Critical) { + requestType_ = { type: 'Critical' }; + } + else { + requestType_ = { type: 'Informational' }; + } + } + return core.invoke('plugin:window|request_user_attention', { + label: this.label, + value: requestType_ + }); + } + /** + * Updates the window resizable flag. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setResizable(false); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async setResizable(resizable) { + return core.invoke('plugin:window|set_resizable', { + label: this.label, + value: resizable + }); + } + /** + * Enable or disable the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setEnabled(false); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.0.0 + */ + async setEnabled(enabled) { + return core.invoke('plugin:window|set_enabled', { + label: this.label, + value: enabled + }); + } + /** + * Whether the window is enabled or disabled. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setEnabled(false); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.0.0 + */ + async isEnabled() { + return core.invoke('plugin:window|is_enabled', { + label: this.label + }); + } + /** + * Sets whether the window's native maximize button is enabled or not. + * If resizable is set to false, this setting is ignored. + * + * #### Platform-specific + * + * - **macOS:** Disables the "zoom" button in the window titlebar, which is also used to enter fullscreen mode. + * - **Linux / iOS / Android:** Unsupported. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setMaximizable(false); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async setMaximizable(maximizable) { + return core.invoke('plugin:window|set_maximizable', { + label: this.label, + value: maximizable + }); + } + /** + * Sets whether the window's native minimize button is enabled or not. + * + * #### Platform-specific + * + * - **Linux / iOS / Android:** Unsupported. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setMinimizable(false); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async setMinimizable(minimizable) { + return core.invoke('plugin:window|set_minimizable', { + label: this.label, + value: minimizable + }); + } + /** + * Sets whether the window's native close button is enabled or not. + * + * #### Platform-specific + * + * - **Linux:** GTK+ will do its best to convince the window manager not to show a close button. Depending on the system, this function may not have any effect when called on a window that is already visible + * - **iOS / Android:** Unsupported. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setClosable(false); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async setClosable(closable) { + return core.invoke('plugin:window|set_closable', { + label: this.label, + value: closable + }); + } + /** + * Sets the window title. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setTitle('Tauri'); + * ``` + * + * @param title The new title + * @returns A promise indicating the success or failure of the operation. + */ + async setTitle(title) { + return core.invoke('plugin:window|set_title', { + label: this.label, + value: title + }); + } + /** + * Maximizes the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().maximize(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async maximize() { + return core.invoke('plugin:window|maximize', { + label: this.label + }); + } + /** + * Unmaximizes the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().unmaximize(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async unmaximize() { + return core.invoke('plugin:window|unmaximize', { + label: this.label + }); + } + /** + * Toggles the window maximized state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().toggleMaximize(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async toggleMaximize() { + return core.invoke('plugin:window|toggle_maximize', { + label: this.label + }); + } + /** + * Minimizes the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().minimize(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async minimize() { + return core.invoke('plugin:window|minimize', { + label: this.label + }); + } + /** + * Unminimizes the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().unminimize(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async unminimize() { + return core.invoke('plugin:window|unminimize', { + label: this.label + }); + } + /** + * Sets the window visibility to true. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().show(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async show() { + return core.invoke('plugin:window|show', { + label: this.label + }); + } + /** + * Sets the window visibility to false. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().hide(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async hide() { + return core.invoke('plugin:window|hide', { + label: this.label + }); + } + /** + * Closes the window. + * + * Note this emits a closeRequested event so you can intercept it. To force window close, use {@link Window.destroy}. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().close(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async close() { + return core.invoke('plugin:window|close', { + label: this.label + }); + } + /** + * Destroys the window. Behaves like {@link Window.close} but forces the window close instead of emitting a closeRequested event. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().destroy(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async destroy() { + return core.invoke('plugin:window|destroy', { + label: this.label + }); + } + /** + * Whether the window should have borders and bars. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setDecorations(false); + * ``` + * + * @param decorations Whether the window should have borders and bars. + * @returns A promise indicating the success or failure of the operation. + */ + async setDecorations(decorations) { + return core.invoke('plugin:window|set_decorations', { + label: this.label, + value: decorations + }); + } + /** + * Whether or not the window should have shadow. + * + * #### Platform-specific + * + * - **Windows:** + * - `false` has no effect on decorated window, shadows are always ON. + * - `true` will make undecorated window have a 1px white border, + * and on Windows 11, it will have a rounded corners. + * - **Linux:** Unsupported. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setShadow(false); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async setShadow(enable) { + return core.invoke('plugin:window|set_shadow', { + label: this.label, + value: enable + }); + } + /** + * Set window effects. + */ + async setEffects(effects) { + return core.invoke('plugin:window|set_effects', { + label: this.label, + value: effects + }); + } + /** + * Clear any applied effects if possible. + */ + async clearEffects() { + return core.invoke('plugin:window|set_effects', { + label: this.label, + value: null + }); + } + /** + * Whether the window should always be on top of other windows. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setAlwaysOnTop(true); + * ``` + * + * @param alwaysOnTop Whether the window should always be on top of other windows or not. + * @returns A promise indicating the success or failure of the operation. + */ + async setAlwaysOnTop(alwaysOnTop) { + return core.invoke('plugin:window|set_always_on_top', { + label: this.label, + value: alwaysOnTop + }); + } + /** + * Whether the window should always be below other windows. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setAlwaysOnBottom(true); + * ``` + * + * @param alwaysOnBottom Whether the window should always be below other windows or not. + * @returns A promise indicating the success or failure of the operation. + */ + async setAlwaysOnBottom(alwaysOnBottom) { + return core.invoke('plugin:window|set_always_on_bottom', { + label: this.label, + value: alwaysOnBottom + }); + } + /** + * Prevents the window contents from being captured by other apps. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setContentProtected(true); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async setContentProtected(protected_) { + return core.invoke('plugin:window|set_content_protected', { + label: this.label, + value: protected_ + }); + } + /** + * Resizes the window with a new inner size. + * @example + * ```typescript + * import { getCurrentWindow, LogicalSize } from '@tauri-apps/api/window'; + * await getCurrentWindow().setSize(new LogicalSize(600, 500)); + * ``` + * + * @param size The logical or physical inner size. + * @returns A promise indicating the success or failure of the operation. + */ + async setSize(size) { + return core.invoke('plugin:window|set_size', { + label: this.label, + value: size instanceof dpi.Size ? size : new dpi.Size(size) + }); + } + /** + * Sets the window minimum inner size. If the `size` argument is not provided, the constraint is unset. + * @example + * ```typescript + * import { getCurrentWindow, PhysicalSize } from '@tauri-apps/api/window'; + * await getCurrentWindow().setMinSize(new PhysicalSize(600, 500)); + * ``` + * + * @param size The logical or physical inner size, or `null` to unset the constraint. + * @returns A promise indicating the success or failure of the operation. + */ + async setMinSize(size) { + return core.invoke('plugin:window|set_min_size', { + label: this.label, + value: size instanceof dpi.Size ? size : size ? new dpi.Size(size) : null + }); + } + /** + * Sets the window maximum inner size. If the `size` argument is undefined, the constraint is unset. + * @example + * ```typescript + * import { getCurrentWindow, LogicalSize } from '@tauri-apps/api/window'; + * await getCurrentWindow().setMaxSize(new LogicalSize(600, 500)); + * ``` + * + * @param size The logical or physical inner size, or `null` to unset the constraint. + * @returns A promise indicating the success or failure of the operation. + */ + async setMaxSize(size) { + return core.invoke('plugin:window|set_max_size', { + label: this.label, + value: size instanceof dpi.Size ? size : size ? new dpi.Size(size) : null + }); + } + /** + * Sets the window inner size constraints. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setSizeConstraints({ minWidth: 300 }); + * ``` + * + * @param constraints The logical or physical inner size, or `null` to unset the constraint. + * @returns A promise indicating the success or failure of the operation. + */ + async setSizeConstraints(constraints) { + function logical(pixel) { + return pixel ? { Logical: pixel } : null; + } + return core.invoke('plugin:window|set_size_constraints', { + label: this.label, + value: { + minWidth: logical(constraints === null || constraints === void 0 ? void 0 : constraints.minWidth), + minHeight: logical(constraints === null || constraints === void 0 ? void 0 : constraints.minHeight), + maxWidth: logical(constraints === null || constraints === void 0 ? void 0 : constraints.maxWidth), + maxHeight: logical(constraints === null || constraints === void 0 ? void 0 : constraints.maxHeight) + } + }); + } + /** + * Sets the window outer position. + * @example + * ```typescript + * import { getCurrentWindow, LogicalPosition } from '@tauri-apps/api/window'; + * await getCurrentWindow().setPosition(new LogicalPosition(600, 500)); + * ``` + * + * @param position The new position, in logical or physical pixels. + * @returns A promise indicating the success or failure of the operation. + */ + async setPosition(position) { + return core.invoke('plugin:window|set_position', { + label: this.label, + value: position instanceof dpi.Position ? position : new dpi.Position(position) + }); + } + /** + * Sets the window fullscreen state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setFullscreen(true); + * ``` + * + * @param fullscreen Whether the window should go to fullscreen or not. + * @returns A promise indicating the success or failure of the operation. + */ + async setFullscreen(fullscreen) { + return core.invoke('plugin:window|set_fullscreen', { + label: this.label, + value: fullscreen + }); + } + /** + * On macOS, Toggles a fullscreen mode that doesn’t require a new macOS space. Returns a boolean indicating whether the transition was successful (this won’t work if the window was already in the native fullscreen). + * This is how fullscreen used to work on macOS in versions before Lion. And allows the user to have a fullscreen window without using another space or taking control over the entire monitor. + * + * On other platforms, this is the same as {@link Window.setFullscreen}. + * + * @param fullscreen Whether the window should go to simple fullscreen or not. + * @returns A promise indicating the success or failure of the operation. + */ + async setSimpleFullscreen(fullscreen) { + return core.invoke('plugin:window|set_simple_fullscreen', { + label: this.label, + value: fullscreen + }); + } + /** + * Bring the window to front and focus. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setFocus(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async setFocus() { + return core.invoke('plugin:window|set_focus', { + label: this.label + }); + } + /** + * Sets whether the window can be focused. + * + * #### Platform-specific + * + * - **macOS**: If the window is already focused, it is not possible to unfocus it after calling `set_focusable(false)`. + * In this case, you might consider calling {@link Window.setFocus} but it will move the window to the back i.e. at the bottom in terms of z-order. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setFocusable(true); + * ``` + * + * @param focusable Whether the window can be focused. + * @returns A promise indicating the success or failure of the operation. + */ + async setFocusable(focusable) { + return core.invoke('plugin:window|set_focusable', { + label: this.label, + value: focusable + }); + } + /** + * Sets the window icon. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setIcon('/tauri/awesome.png'); + * ``` + * + * Note that you may need the `image-ico` or `image-png` Cargo features to use this API. + * To enable it, change your Cargo.toml file: + * ```toml + * [dependencies] + * tauri = { version = "...", features = ["...", "image-png"] } + * ``` + * + * @param icon Icon bytes or path to the icon file. + * @returns A promise indicating the success or failure of the operation. + */ + async setIcon(icon) { + return core.invoke('plugin:window|set_icon', { + label: this.label, + value: image.transformImage(icon) + }); + } + /** + * Whether the window icon should be hidden from the taskbar or not. + * + * #### Platform-specific + * + * - **macOS:** Unsupported. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setSkipTaskbar(true); + * ``` + * + * @param skip true to hide window icon, false to show it. + * @returns A promise indicating the success or failure of the operation. + */ + async setSkipTaskbar(skip) { + return core.invoke('plugin:window|set_skip_taskbar', { + label: this.label, + value: skip + }); + } + /** + * Grabs the cursor, preventing it from leaving the window. + * + * There's no guarantee that the cursor will be hidden. You should + * hide it by yourself if you want so. + * + * #### Platform-specific + * + * - **Linux:** Unsupported. + * - **macOS:** This locks the cursor in a fixed location, which looks visually awkward. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setCursorGrab(true); + * ``` + * + * @param grab `true` to grab the cursor icon, `false` to release it. + * @returns A promise indicating the success or failure of the operation. + */ + async setCursorGrab(grab) { + return core.invoke('plugin:window|set_cursor_grab', { + label: this.label, + value: grab + }); + } + /** + * Modifies the cursor's visibility. + * + * #### Platform-specific + * + * - **Windows:** The cursor is only hidden within the confines of the window. + * - **macOS:** The cursor is hidden as long as the window has input focus, even if the cursor is + * outside of the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setCursorVisible(false); + * ``` + * + * @param visible If `false`, this will hide the cursor. If `true`, this will show the cursor. + * @returns A promise indicating the success or failure of the operation. + */ + async setCursorVisible(visible) { + return core.invoke('plugin:window|set_cursor_visible', { + label: this.label, + value: visible + }); + } + /** + * Modifies the cursor icon of the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setCursorIcon('help'); + * ``` + * + * @param icon The new cursor icon. + * @returns A promise indicating the success or failure of the operation. + */ + async setCursorIcon(icon) { + return core.invoke('plugin:window|set_cursor_icon', { + label: this.label, + value: icon + }); + } + /** + * Sets the window background color. + * + * #### Platform-specific: + * + * - **Windows:** alpha channel is ignored. + * - **iOS / Android:** Unsupported. + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.1.0 + */ + async setBackgroundColor(color) { + return core.invoke('plugin:window|set_background_color', { color }); + } + /** + * Changes the position of the cursor in window coordinates. + * @example + * ```typescript + * import { getCurrentWindow, LogicalPosition } from '@tauri-apps/api/window'; + * await getCurrentWindow().setCursorPosition(new LogicalPosition(600, 300)); + * ``` + * + * @param position The new cursor position. + * @returns A promise indicating the success or failure of the operation. + */ + async setCursorPosition(position) { + return core.invoke('plugin:window|set_cursor_position', { + label: this.label, + value: position instanceof dpi.Position ? position : new dpi.Position(position) + }); + } + /** + * Changes the cursor events behavior. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setIgnoreCursorEvents(true); + * ``` + * + * @param ignore `true` to ignore the cursor events; `false` to process them as usual. + * @returns A promise indicating the success or failure of the operation. + */ + async setIgnoreCursorEvents(ignore) { + return core.invoke('plugin:window|set_ignore_cursor_events', { + label: this.label, + value: ignore + }); + } + /** + * Starts dragging the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().startDragging(); + * ``` + * + * @return A promise indicating the success or failure of the operation. + */ + async startDragging() { + return core.invoke('plugin:window|start_dragging', { + label: this.label + }); + } + /** + * Starts resize-dragging the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().startResizeDragging(); + * ``` + * + * @return A promise indicating the success or failure of the operation. + */ + async startResizeDragging(direction) { + return core.invoke('plugin:window|start_resize_dragging', { + label: this.label, + value: direction + }); + } + /** + * Sets the badge count. It is app wide and not specific to this window. + * + * #### Platform-specific + * + * - **Windows**: Unsupported. Use @{linkcode Window.setOverlayIcon} instead. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setBadgeCount(5); + * ``` + * + * @param count The badge count. Use `undefined` to remove the badge. + * @return A promise indicating the success or failure of the operation. + */ + async setBadgeCount(count) { + return core.invoke('plugin:window|set_badge_count', { + label: this.label, + value: count + }); + } + /** + * Sets the badge cont **macOS only**. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setBadgeLabel("Hello"); + * ``` + * + * @param label The badge label. Use `undefined` to remove the badge. + * @return A promise indicating the success or failure of the operation. + */ + async setBadgeLabel(label) { + return core.invoke('plugin:window|set_badge_label', { + label: this.label, + value: label + }); + } + /** + * Sets the overlay icon. **Windows only** + * The overlay icon can be set for every window. + * + * + * Note that you may need the `image-ico` or `image-png` Cargo features to use this API. + * To enable it, change your Cargo.toml file: + * + * ```toml + * [dependencies] + * tauri = { version = "...", features = ["...", "image-png"] } + * ``` + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setOverlayIcon("/tauri/awesome.png"); + * ``` + * + * @param icon Icon bytes or path to the icon file. Use `undefined` to remove the overlay icon. + * @return A promise indicating the success or failure of the operation. + */ + async setOverlayIcon(icon) { + return core.invoke('plugin:window|set_overlay_icon', { + label: this.label, + value: icon ? image.transformImage(icon) : undefined + }); + } + /** + * Sets the taskbar progress state. + * + * #### Platform-specific + * + * - **Linux / macOS**: Progress bar is app-wide and not specific to this window. + * - **Linux**: Only supported desktop environments with `libunity` (e.g. GNOME). + * + * @example + * ```typescript + * import { getCurrentWindow, ProgressBarStatus } from '@tauri-apps/api/window'; + * await getCurrentWindow().setProgressBar({ + * status: ProgressBarStatus.Normal, + * progress: 50, + * }); + * ``` + * + * @return A promise indicating the success or failure of the operation. + */ + async setProgressBar(state) { + return core.invoke('plugin:window|set_progress_bar', { + label: this.label, + value: state + }); + } + /** + * Sets whether the window should be visible on all workspaces or virtual desktops. + * + * #### Platform-specific + * + * - **Windows / iOS / Android:** Unsupported. + * + * @since 2.0.0 + */ + async setVisibleOnAllWorkspaces(visible) { + return core.invoke('plugin:window|set_visible_on_all_workspaces', { + label: this.label, + value: visible + }); + } + /** + * Sets the title bar style. **macOS only**. + * + * @since 2.0.0 + */ + async setTitleBarStyle(style) { + return core.invoke('plugin:window|set_title_bar_style', { + label: this.label, + value: style + }); + } + /** + * Set window theme, pass in `null` or `undefined` to follow system theme + * + * #### Platform-specific + * + * - **Linux / macOS**: Theme is app-wide and not specific to this window. + * - **iOS / Android:** Unsupported. + * + * @since 2.0.0 + */ + async setTheme(theme) { + return core.invoke('plugin:window|set_theme', { + label: this.label, + value: theme + }); + } + // Listeners + /** + * Listen to window resize. + * + * @example + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * const unlisten = await getCurrentWindow().onResized(({ payload: size }) => { + * console.log('Window resized', size); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async onResized(handler) { + return this.listen(event.TauriEvent.WINDOW_RESIZED, (e) => { + e.payload = new dpi.PhysicalSize(e.payload); + handler(e); + }); + } + /** + * Listen to window move. + * + * @example + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * const unlisten = await getCurrentWindow().onMoved(({ payload: position }) => { + * console.log('Window moved', position); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async onMoved(handler) { + return this.listen(event.TauriEvent.WINDOW_MOVED, (e) => { + e.payload = new dpi.PhysicalPosition(e.payload); + handler(e); + }); + } + /** + * Listen to window close requested. Emitted when the user requests to closes the window. + * + * @example + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * import { confirm } from '@tauri-apps/api/dialog'; + * const unlisten = await getCurrentWindow().onCloseRequested(async (event) => { + * const confirmed = await confirm('Are you sure?'); + * if (!confirmed) { + * // user did not confirm closing the window; let's prevent it + * event.preventDefault(); + * } + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async onCloseRequested(handler) { + // eslint-disable-next-line @typescript-eslint/no-misused-promises + return this.listen(event.TauriEvent.WINDOW_CLOSE_REQUESTED, async (event) => { + const evt = new CloseRequestedEvent(event); + await handler(evt); + if (!evt.isPreventDefault()) { + await this.destroy(); + } + }); + } + /** + * Listen to a file drop event. + * The listener is triggered when the user hovers the selected files on the webview, + * drops the files or cancels the operation. + * + * @example + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/webview"; + * const unlisten = await getCurrentWindow().onDragDropEvent((event) => { + * if (event.payload.type === 'over') { + * console.log('User hovering', event.payload.position); + * } else if (event.payload.type === 'drop') { + * console.log('User dropped', event.payload.paths); + * } else { + * console.log('File drop cancelled'); + * } + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async onDragDropEvent(handler) { + const unlistenDrag = await this.listen(event.TauriEvent.DRAG_ENTER, (event) => { + handler({ + ...event, + payload: { + type: 'enter', + paths: event.payload.paths, + position: new dpi.PhysicalPosition(event.payload.position) + } + }); + }); + const unlistenDragOver = await this.listen(event.TauriEvent.DRAG_OVER, (event) => { + handler({ + ...event, + payload: { + type: 'over', + position: new dpi.PhysicalPosition(event.payload.position) + } + }); + }); + const unlistenDrop = await this.listen(event.TauriEvent.DRAG_DROP, (event) => { + handler({ + ...event, + payload: { + type: 'drop', + paths: event.payload.paths, + position: new dpi.PhysicalPosition(event.payload.position) + } + }); + }); + const unlistenCancel = await this.listen(event.TauriEvent.DRAG_LEAVE, (event) => { + handler({ ...event, payload: { type: 'leave' } }); + }); + return () => { + unlistenDrag(); + unlistenDrop(); + unlistenDragOver(); + unlistenCancel(); + }; + } + /** + * Listen to window focus change. + * + * @example + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * const unlisten = await getCurrentWindow().onFocusChanged(({ payload: focused }) => { + * console.log('Focus changed, window is focused? ' + focused); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async onFocusChanged(handler) { + const unlistenFocus = await this.listen(event.TauriEvent.WINDOW_FOCUS, (event) => { + handler({ ...event, payload: true }); + }); + const unlistenBlur = await this.listen(event.TauriEvent.WINDOW_BLUR, (event) => { + handler({ ...event, payload: false }); + }); + return () => { + unlistenFocus(); + unlistenBlur(); + }; + } + /** + * Listen to window scale change. Emitted when the window's scale factor has changed. + * The following user actions can cause DPI changes: + * - Changing the display's resolution. + * - Changing the display's scale factor (e.g. in Control Panel on Windows). + * - Moving the window to a display with a different scale factor. + * + * @example + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * const unlisten = await getCurrentWindow().onScaleChanged(({ payload }) => { + * console.log('Scale changed', payload.scaleFactor, payload.size); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async onScaleChanged(handler) { + return this.listen(event.TauriEvent.WINDOW_SCALE_FACTOR_CHANGED, handler); + } + /** + * Listen to the system theme change. + * + * @example + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * const unlisten = await getCurrentWindow().onThemeChanged(({ payload: theme }) => { + * console.log('New theme: ' + theme); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async onThemeChanged(handler) { + return this.listen(event.TauriEvent.WINDOW_THEME_CHANGED, handler); + } +} +/** + * Background throttling policy + * + * @since 2.0.0 + */ +var BackgroundThrottlingPolicy; +(function (BackgroundThrottlingPolicy) { + BackgroundThrottlingPolicy["Disabled"] = "disabled"; + BackgroundThrottlingPolicy["Throttle"] = "throttle"; + BackgroundThrottlingPolicy["Suspend"] = "suspend"; +})(BackgroundThrottlingPolicy || (BackgroundThrottlingPolicy = {})); +/** + * The scrollbar style to use in the webview. + * + * ## Platform-specific + * + * **Windows**: This option must be given the same value for all webviews. + * + * @since 2.8.0 + */ +var ScrollBarStyle; +(function (ScrollBarStyle) { + /** + * The default scrollbar style for the webview. + */ + ScrollBarStyle["Default"] = "default"; + /** + * Fluent UI style overlay scrollbars. **Windows Only** + * + * Requires WebView2 Runtime version 125.0.2535.41 or higher, does nothing on older versions, + * see https://learn.microsoft.com/en-us/microsoft-edge/webview2/release-notes/?tabs=dotnetcsharp#10253541 + */ + ScrollBarStyle["FluentOverlay"] = "fluentOverlay"; +})(ScrollBarStyle || (ScrollBarStyle = {})); +/** + * Platform-specific window effects + * + * @since 2.0.0 + */ +exports.Effect = void 0; +(function (Effect) { + /** + * A default material appropriate for the view's effectiveAppearance. **macOS 10.14-** + * + * @deprecated since macOS 10.14. You should instead choose an appropriate semantic material. + */ + Effect["AppearanceBased"] = "appearanceBased"; + /** + * **macOS 10.14-** + * + * @deprecated since macOS 10.14. Use a semantic material instead. + */ + Effect["Light"] = "light"; + /** + * **macOS 10.14-** + * + * @deprecated since macOS 10.14. Use a semantic material instead. + */ + Effect["Dark"] = "dark"; + /** + * **macOS 10.14-** + * + * @deprecated since macOS 10.14. Use a semantic material instead. + */ + Effect["MediumLight"] = "mediumLight"; + /** + * **macOS 10.14-** + * + * @deprecated since macOS 10.14. Use a semantic material instead. + */ + Effect["UltraDark"] = "ultraDark"; + /** + * **macOS 10.10+** + */ + Effect["Titlebar"] = "titlebar"; + /** + * **macOS 10.10+** + */ + Effect["Selection"] = "selection"; + /** + * **macOS 10.11+** + */ + Effect["Menu"] = "menu"; + /** + * **macOS 10.11+** + */ + Effect["Popover"] = "popover"; + /** + * **macOS 10.11+** + */ + Effect["Sidebar"] = "sidebar"; + /** + * **macOS 10.14+** + */ + Effect["HeaderView"] = "headerView"; + /** + * **macOS 10.14+** + */ + Effect["Sheet"] = "sheet"; + /** + * **macOS 10.14+** + */ + Effect["WindowBackground"] = "windowBackground"; + /** + * **macOS 10.14+** + */ + Effect["HudWindow"] = "hudWindow"; + /** + * **macOS 10.14+** + */ + Effect["FullScreenUI"] = "fullScreenUI"; + /** + * **macOS 10.14+** + */ + Effect["Tooltip"] = "tooltip"; + /** + * **macOS 10.14+** + */ + Effect["ContentBackground"] = "contentBackground"; + /** + * **macOS 10.14+** + */ + Effect["UnderWindowBackground"] = "underWindowBackground"; + /** + * **macOS 10.14+** + */ + Effect["UnderPageBackground"] = "underPageBackground"; + /** + * **Windows 11 Only** + */ + Effect["Mica"] = "mica"; + /** + * **Windows 7/10/11(22H1) Only** + * + * #### Notes + * + * This effect has bad performance when resizing/dragging the window on Windows 11 build 22621. + */ + Effect["Blur"] = "blur"; + /** + * **Windows 10/11** + * + * #### Notes + * + * This effect has bad performance when resizing/dragging the window on Windows 10 v1903+ and Windows 11 build 22000. + */ + Effect["Acrylic"] = "acrylic"; + /** + * Tabbed effect that matches the system dark preference **Windows 11 Only** + */ + Effect["Tabbed"] = "tabbed"; + /** + * Tabbed effect with dark mode but only if dark mode is enabled on the system **Windows 11 Only** + */ + Effect["TabbedDark"] = "tabbedDark"; + /** + * Tabbed effect with light mode **Windows 11 Only** + */ + Effect["TabbedLight"] = "tabbedLight"; +})(exports.Effect || (exports.Effect = {})); +/** + * Window effect state **macOS only** + * + * @see https://developer.apple.com/documentation/appkit/nsvisualeffectview/state + * + * @since 2.0.0 + */ +exports.EffectState = void 0; +(function (EffectState) { + /** + * Make window effect state follow the window's active state **macOS only** + */ + EffectState["FollowsWindowActiveState"] = "followsWindowActiveState"; + /** + * Make window effect state always active **macOS only** + */ + EffectState["Active"] = "active"; + /** + * Make window effect state always inactive **macOS only** + */ + EffectState["Inactive"] = "inactive"; +})(exports.EffectState || (exports.EffectState = {})); +function mapMonitor(m) { + return m === null + ? null + : { + name: m.name, + scaleFactor: m.scaleFactor, + position: new dpi.PhysicalPosition(m.position), + size: new dpi.PhysicalSize(m.size), + workArea: { + position: new dpi.PhysicalPosition(m.workArea.position), + size: new dpi.PhysicalSize(m.workArea.size) + } + }; +} +/** + * Returns the monitor on which the window currently resides. + * Returns `null` if current monitor can't be detected. + * @example + * ```typescript + * import { currentMonitor } from '@tauri-apps/api/window'; + * const monitor = await currentMonitor(); + * ``` + * + * @since 1.0.0 + */ +async function currentMonitor() { + return core.invoke('plugin:window|current_monitor').then(mapMonitor); +} +/** + * Returns the primary monitor of the system. + * Returns `null` if it can't identify any monitor as a primary one. + * @example + * ```typescript + * import { primaryMonitor } from '@tauri-apps/api/window'; + * const monitor = await primaryMonitor(); + * ``` + * + * @since 1.0.0 + */ +async function primaryMonitor() { + return core.invoke('plugin:window|primary_monitor').then(mapMonitor); +} +/** + * Returns the monitor that contains the given point. Returns `null` if can't find any. + * @example + * ```typescript + * import { monitorFromPoint } from '@tauri-apps/api/window'; + * const monitor = await monitorFromPoint(100.0, 200.0); + * ``` + * + * @since 1.0.0 + */ +async function monitorFromPoint(x, y) { + return core.invoke('plugin:window|monitor_from_point', { + x, + y + }).then(mapMonitor); +} +/** + * Returns the list of all the monitors available on the system. + * @example + * ```typescript + * import { availableMonitors } from '@tauri-apps/api/window'; + * const monitors = await availableMonitors(); + * ``` + * + * @since 1.0.0 + */ +async function availableMonitors() { + return core.invoke('plugin:window|available_monitors').then((ms) => ms.map(mapMonitor)); +} +/** + * Get the cursor position relative to the top-left hand corner of the desktop. + * + * Note that the top-left hand corner of the desktop is not necessarily the same as the screen. + * If the user uses a desktop with multiple monitors, + * the top-left hand corner of the desktop is the top-left hand corner of the main monitor on Windows and macOS + * or the top-left of the leftmost monitor on X11. + * + * The coordinates can be negative if the top-left hand corner of the window is outside of the visible screen region. + */ +async function cursorPosition() { + return core.invoke('plugin:window|cursor_position').then((v) => new dpi.PhysicalPosition(v)); +} + +exports.LogicalPosition = dpi.LogicalPosition; +exports.LogicalSize = dpi.LogicalSize; +exports.PhysicalPosition = dpi.PhysicalPosition; +exports.PhysicalSize = dpi.PhysicalSize; +exports.CloseRequestedEvent = CloseRequestedEvent; +exports.Window = Window; +exports.availableMonitors = availableMonitors; +exports.currentMonitor = currentMonitor; +exports.cursorPosition = cursorPosition; +exports.getAllWindows = getAllWindows; +exports.getCurrentWindow = getCurrentWindow; +exports.monitorFromPoint = monitorFromPoint; +exports.primaryMonitor = primaryMonitor; diff --git a/scripts/node_modules/@tauri-apps/api/window.d.ts b/scripts/node_modules/@tauri-apps/api/window.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7aa8184b8b4125d6be93455eda3de72c06157443 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/window.d.ts @@ -0,0 +1,1803 @@ +/** + * Provides APIs to create windows, communicate with other windows and manipulate the current window. + * + * #### Window events + * + * Events can be listened to using {@link Window.listen}: + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * getCurrentWindow().listen("my-window-event", ({ event, payload }) => { }); + * ``` + * + * @module + */ +import { LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize, Position, Size } from './dpi'; +import type { Event, EventName, EventCallback, UnlistenFn } from './event'; +import { type EventTarget } from './event'; +import { WebviewWindow } from './webviewWindow'; +import type { DragDropEvent } from './webview'; +import { Image } from './image'; +/** + * Allows you to retrieve information about a given monitor. + * + * @since 1.0.0 + */ +export interface Monitor { + /** Human-readable name of the monitor */ + name: string | null; + /** The monitor's resolution. */ + size: PhysicalSize; + /** the Top-left corner position of the monitor relative to the larger full screen area. */ + position: PhysicalPosition; + /** The monitor's work area. */ + workArea: { + position: PhysicalPosition; + size: PhysicalSize; + }; + /** The scale factor that can be used to map physical pixels to logical pixels. */ + scaleFactor: number; +} +type Theme = 'light' | 'dark'; +type TitleBarStyle = 'visible' | 'transparent' | 'overlay'; +type ResizeDirection = 'East' | 'North' | 'NorthEast' | 'NorthWest' | 'South' | 'SouthEast' | 'SouthWest' | 'West'; +/** + * The payload for the `scaleChange` event. + * + * @since 1.0.2 + */ +interface ScaleFactorChanged { + /** The new window scale factor. */ + scaleFactor: number; + /** The new window size */ + size: PhysicalSize; +} +/** + * Attention type to request on a window. + * + * @since 1.0.0 + */ +declare enum UserAttentionType { + /** + * #### Platform-specific + * - **macOS:** Bounces the dock icon until the application is in focus. + * - **Windows:** Flashes both the window and the taskbar button until the application is in focus. + */ + Critical = 1, + /** + * #### Platform-specific + * - **macOS:** Bounces the dock icon once. + * - **Windows:** Flashes the taskbar button until the application is in focus. + */ + Informational = 2 +} +declare class CloseRequestedEvent { + /** Event name */ + event: EventName; + /** Event identifier used to unlisten */ + id: number; + private _preventDefault; + constructor(event: Event); + preventDefault(): void; + isPreventDefault(): boolean; +} +export type CursorIcon = 'default' | 'crosshair' | 'hand' | 'arrow' | 'move' | 'text' | 'wait' | 'help' | 'progress' | 'notAllowed' | 'contextMenu' | 'cell' | 'verticalText' | 'alias' | 'copy' | 'noDrop' | 'grab' | 'grabbing' | 'allScroll' | 'zoomIn' | 'zoomOut' | 'eResize' | 'nResize' | 'neResize' | 'nwResize' | 'sResize' | 'seResize' | 'swResize' | 'wResize' | 'ewResize' | 'nsResize' | 'neswResize' | 'nwseResize' | 'colResize' | 'rowResize'; +export declare enum ProgressBarStatus { + /** + * Hide progress bar. + */ + None = "none", + /** + * Normal state. + */ + Normal = "normal", + /** + * Indeterminate state. **Treated as Normal on Linux and macOS** + */ + Indeterminate = "indeterminate", + /** + * Paused state. **Treated as Normal on Linux** + */ + Paused = "paused", + /** + * Error state. **Treated as Normal on linux** + */ + Error = "error" +} +export interface WindowSizeConstraints { + minWidth?: number; + minHeight?: number; + maxWidth?: number; + maxHeight?: number; +} +export interface ProgressBarState { + /** + * The progress bar status. + */ + status?: ProgressBarStatus; + /** + * The progress bar progress. This can be a value ranging from `0` to `100` + */ + progress?: number; +} +/** + * Get an instance of `Window` for the current window. + * + * @since 1.0.0 + */ +declare function getCurrentWindow(): Window; +/** + * Gets a list of instances of `Window` for all available windows. + * + * @since 1.0.0 + */ +declare function getAllWindows(): Promise; +/** @ignore */ +export type WindowLabel = string; +/** + * Create new window or get a handle to an existing one. + * + * Windows are identified by a *label* a unique identifier that can be used to reference it later. + * It may only contain alphanumeric characters `a-zA-Z` plus the following special characters `-`, `/`, `:` and `_`. + * + * @example + * ```typescript + * import { Window } from "@tauri-apps/api/window" + * + * const appWindow = new Window('theUniqueLabel'); + * + * appWindow.once('tauri://created', function () { + * // window successfully created + * }); + * appWindow.once('tauri://error', function (e) { + * // an error happened creating the window + * }); + * + * // emit an event to the backend + * await appWindow.emit("some-event", "data"); + * // listen to an event from the backend + * const unlisten = await appWindow.listen("event-name", e => {}); + * unlisten(); + * ``` + * + * @since 2.0.0 + */ +declare class Window { + /** The window label. It is a unique identifier for the window, can be used to reference it later. */ + label: WindowLabel; + /** Local event listeners. */ + listeners: Record>>; + /** + * Creates a new Window. + * @example + * ```typescript + * import { Window } from '@tauri-apps/api/window'; + * const appWindow = new Window('my-label'); + * appWindow.once('tauri://created', function () { + * // window successfully created + * }); + * appWindow.once('tauri://error', function (e) { + * // an error happened creating the window + * }); + * ``` + * + * @param label The unique window label. Must be alphanumeric: `a-zA-Z-/:_`. + * @returns The {@link Window} instance to communicate with the window. + */ + constructor(label: WindowLabel, options?: WindowOptions); + /** + * Gets the Window associated with the given label. + * @example + * ```typescript + * import { Window } from '@tauri-apps/api/window'; + * const mainWindow = Window.getByLabel('main'); + * ``` + * + * @param label The window label. + * @returns The Window instance to communicate with the window or null if the window doesn't exist. + */ + static getByLabel(label: string): Promise; + /** + * Get an instance of `Window` for the current window. + */ + static getCurrent(): Window; + /** + * Gets a list of instances of `Window` for all available windows. + */ + static getAll(): Promise; + /** + * Gets the focused window. + * @example + * ```typescript + * import { Window } from '@tauri-apps/api/window'; + * const focusedWindow = Window.getFocusedWindow(); + * ``` + * + * @returns The Window instance or `undefined` if there is not any focused window. + */ + static getFocusedWindow(): Promise; + /** + * Listen to an emitted event on this window. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const unlisten = await getCurrentWindow().listen('state-changed', (event) => { + * console.log(`Got error: ${payload}`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + listen(event: EventName, handler: EventCallback): Promise; + /** + * Listen to an emitted event on this window only once. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const unlisten = await getCurrentWindow().once('initialized', (event) => { + * console.log(`Window initialized!`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + once(event: EventName, handler: EventCallback): Promise; + /** + * Emits an event to all {@link EventTarget|targets}. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().emit('window-loaded', { loggedIn: true, token: 'authToken' }); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param payload Event payload. + */ + emit(event: string, payload?: T): Promise; + /** + * Emits an event to all {@link EventTarget|targets} matching the given target. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().emit('main', 'window-loaded', { loggedIn: true, token: 'authToken' }); + * ``` + * @param target Label of the target Window/Webview/WebviewWindow or raw {@link EventTarget} object. + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param payload Event payload. + */ + emitTo(target: string | EventTarget, event: string, payload?: T): Promise; + /** @ignore */ + _handleTauriEvent(event: string, handler: EventCallback): boolean; + /** + * The scale factor that can be used to map physical pixels to logical pixels. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const factor = await getCurrentWindow().scaleFactor(); + * ``` + * + * @returns The window's monitor scale factor. + */ + scaleFactor(): Promise; + /** + * The position of the top-left hand corner of the window's client area relative to the top-left hand corner of the desktop. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const position = await getCurrentWindow().innerPosition(); + * ``` + * + * @returns The window's inner position. + */ + innerPosition(): Promise; + /** + * The position of the top-left hand corner of the window relative to the top-left hand corner of the desktop. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const position = await getCurrentWindow().outerPosition(); + * ``` + * + * @returns The window's outer position. + */ + outerPosition(): Promise; + /** + * The physical size of the window's client area. + * The client area is the content of the window, excluding the title bar and borders. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const size = await getCurrentWindow().innerSize(); + * ``` + * + * @returns The window's inner size. + */ + innerSize(): Promise; + /** + * The physical size of the entire window. + * These dimensions include the title bar and borders. If you don't want that (and you usually don't), use inner_size instead. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const size = await getCurrentWindow().outerSize(); + * ``` + * + * @returns The window's outer size. + */ + outerSize(): Promise; + /** + * Gets the window's current fullscreen state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const fullscreen = await getCurrentWindow().isFullscreen(); + * ``` + * + * @returns Whether the window is in fullscreen mode or not. + */ + isFullscreen(): Promise; + /** + * Gets the window's current minimized state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const minimized = await getCurrentWindow().isMinimized(); + * ``` + */ + isMinimized(): Promise; + /** + * Gets the window's current maximized state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const maximized = await getCurrentWindow().isMaximized(); + * ``` + * + * @returns Whether the window is maximized or not. + */ + isMaximized(): Promise; + /** + * Gets the window's current focus state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const focused = await getCurrentWindow().isFocused(); + * ``` + * + * @returns Whether the window is focused or not. + */ + isFocused(): Promise; + /** + * Gets the window's current decorated state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const decorated = await getCurrentWindow().isDecorated(); + * ``` + * + * @returns Whether the window is decorated or not. + */ + isDecorated(): Promise; + /** + * Gets the window's current resizable state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const resizable = await getCurrentWindow().isResizable(); + * ``` + * + * @returns Whether the window is resizable or not. + */ + isResizable(): Promise; + /** + * Gets the window's native maximize button state. + * + * #### Platform-specific + * + * - **Linux / iOS / Android:** Unsupported. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const maximizable = await getCurrentWindow().isMaximizable(); + * ``` + * + * @returns Whether the window's native maximize button is enabled or not. + */ + isMaximizable(): Promise; + /** + * Gets the window's native minimize button state. + * + * #### Platform-specific + * + * - **Linux / iOS / Android:** Unsupported. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const minimizable = await getCurrentWindow().isMinimizable(); + * ``` + * + * @returns Whether the window's native minimize button is enabled or not. + */ + isMinimizable(): Promise; + /** + * Gets the window's native close button state. + * + * #### Platform-specific + * + * - **iOS / Android:** Unsupported. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const closable = await getCurrentWindow().isClosable(); + * ``` + * + * @returns Whether the window's native close button is enabled or not. + */ + isClosable(): Promise; + /** + * Gets the window's current visible state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const visible = await getCurrentWindow().isVisible(); + * ``` + * + * @returns Whether the window is visible or not. + */ + isVisible(): Promise; + /** + * Gets the window's current title. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const title = await getCurrentWindow().title(); + * ``` + */ + title(): Promise; + /** + * Gets the window's current theme. + * + * #### Platform-specific + * + * - **macOS:** Theme was introduced on macOS 10.14. Returns `light` on macOS 10.13 and below. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const theme = await getCurrentWindow().theme(); + * ``` + * + * @returns The window theme. + */ + theme(): Promise; + /** + * Whether the window is configured to be always on top of other windows or not. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const alwaysOnTop = await getCurrentWindow().isAlwaysOnTop(); + * ``` + * + * @returns Whether the window is visible or not. + */ + isAlwaysOnTop(): Promise; + /** + * Centers the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().center(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + center(): Promise; + /** + * Requests user attention to the window, this has no effect if the application + * is already focused. How requesting for user attention manifests is platform dependent, + * see `UserAttentionType` for details. + * + * Providing `null` will unset the request for user attention. Unsetting the request for + * user attention might not be done automatically by the WM when the window receives input. + * + * #### Platform-specific + * + * - **macOS:** `null` has no effect. + * - **Linux:** Urgency levels have the same effect. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().requestUserAttention(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + requestUserAttention(requestType: UserAttentionType | null): Promise; + /** + * Updates the window resizable flag. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setResizable(false); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + setResizable(resizable: boolean): Promise; + /** + * Enable or disable the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setEnabled(false); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.0.0 + */ + setEnabled(enabled: boolean): Promise; + /** + * Whether the window is enabled or disabled. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setEnabled(false); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.0.0 + */ + isEnabled(): Promise; + /** + * Sets whether the window's native maximize button is enabled or not. + * If resizable is set to false, this setting is ignored. + * + * #### Platform-specific + * + * - **macOS:** Disables the "zoom" button in the window titlebar, which is also used to enter fullscreen mode. + * - **Linux / iOS / Android:** Unsupported. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setMaximizable(false); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + setMaximizable(maximizable: boolean): Promise; + /** + * Sets whether the window's native minimize button is enabled or not. + * + * #### Platform-specific + * + * - **Linux / iOS / Android:** Unsupported. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setMinimizable(false); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + setMinimizable(minimizable: boolean): Promise; + /** + * Sets whether the window's native close button is enabled or not. + * + * #### Platform-specific + * + * - **Linux:** GTK+ will do its best to convince the window manager not to show a close button. Depending on the system, this function may not have any effect when called on a window that is already visible + * - **iOS / Android:** Unsupported. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setClosable(false); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + setClosable(closable: boolean): Promise; + /** + * Sets the window title. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setTitle('Tauri'); + * ``` + * + * @param title The new title + * @returns A promise indicating the success or failure of the operation. + */ + setTitle(title: string): Promise; + /** + * Maximizes the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().maximize(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + maximize(): Promise; + /** + * Unmaximizes the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().unmaximize(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + unmaximize(): Promise; + /** + * Toggles the window maximized state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().toggleMaximize(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + toggleMaximize(): Promise; + /** + * Minimizes the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().minimize(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + minimize(): Promise; + /** + * Unminimizes the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().unminimize(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + unminimize(): Promise; + /** + * Sets the window visibility to true. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().show(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + show(): Promise; + /** + * Sets the window visibility to false. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().hide(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + hide(): Promise; + /** + * Closes the window. + * + * Note this emits a closeRequested event so you can intercept it. To force window close, use {@link Window.destroy}. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().close(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + close(): Promise; + /** + * Destroys the window. Behaves like {@link Window.close} but forces the window close instead of emitting a closeRequested event. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().destroy(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + destroy(): Promise; + /** + * Whether the window should have borders and bars. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setDecorations(false); + * ``` + * + * @param decorations Whether the window should have borders and bars. + * @returns A promise indicating the success or failure of the operation. + */ + setDecorations(decorations: boolean): Promise; + /** + * Whether or not the window should have shadow. + * + * #### Platform-specific + * + * - **Windows:** + * - `false` has no effect on decorated window, shadows are always ON. + * - `true` will make undecorated window have a 1px white border, + * and on Windows 11, it will have a rounded corners. + * - **Linux:** Unsupported. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setShadow(false); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + setShadow(enable: boolean): Promise; + /** + * Set window effects. + */ + setEffects(effects: Effects): Promise; + /** + * Clear any applied effects if possible. + */ + clearEffects(): Promise; + /** + * Whether the window should always be on top of other windows. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setAlwaysOnTop(true); + * ``` + * + * @param alwaysOnTop Whether the window should always be on top of other windows or not. + * @returns A promise indicating the success or failure of the operation. + */ + setAlwaysOnTop(alwaysOnTop: boolean): Promise; + /** + * Whether the window should always be below other windows. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setAlwaysOnBottom(true); + * ``` + * + * @param alwaysOnBottom Whether the window should always be below other windows or not. + * @returns A promise indicating the success or failure of the operation. + */ + setAlwaysOnBottom(alwaysOnBottom: boolean): Promise; + /** + * Prevents the window contents from being captured by other apps. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setContentProtected(true); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + setContentProtected(protected_: boolean): Promise; + /** + * Resizes the window with a new inner size. + * @example + * ```typescript + * import { getCurrentWindow, LogicalSize } from '@tauri-apps/api/window'; + * await getCurrentWindow().setSize(new LogicalSize(600, 500)); + * ``` + * + * @param size The logical or physical inner size. + * @returns A promise indicating the success or failure of the operation. + */ + setSize(size: LogicalSize | PhysicalSize | Size): Promise; + /** + * Sets the window minimum inner size. If the `size` argument is not provided, the constraint is unset. + * @example + * ```typescript + * import { getCurrentWindow, PhysicalSize } from '@tauri-apps/api/window'; + * await getCurrentWindow().setMinSize(new PhysicalSize(600, 500)); + * ``` + * + * @param size The logical or physical inner size, or `null` to unset the constraint. + * @returns A promise indicating the success or failure of the operation. + */ + setMinSize(size: LogicalSize | PhysicalSize | Size | null | undefined): Promise; + /** + * Sets the window maximum inner size. If the `size` argument is undefined, the constraint is unset. + * @example + * ```typescript + * import { getCurrentWindow, LogicalSize } from '@tauri-apps/api/window'; + * await getCurrentWindow().setMaxSize(new LogicalSize(600, 500)); + * ``` + * + * @param size The logical or physical inner size, or `null` to unset the constraint. + * @returns A promise indicating the success or failure of the operation. + */ + setMaxSize(size: LogicalSize | PhysicalSize | Size | null | undefined): Promise; + /** + * Sets the window inner size constraints. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setSizeConstraints({ minWidth: 300 }); + * ``` + * + * @param constraints The logical or physical inner size, or `null` to unset the constraint. + * @returns A promise indicating the success or failure of the operation. + */ + setSizeConstraints(constraints: WindowSizeConstraints | null | undefined): Promise; + /** + * Sets the window outer position. + * @example + * ```typescript + * import { getCurrentWindow, LogicalPosition } from '@tauri-apps/api/window'; + * await getCurrentWindow().setPosition(new LogicalPosition(600, 500)); + * ``` + * + * @param position The new position, in logical or physical pixels. + * @returns A promise indicating the success or failure of the operation. + */ + setPosition(position: LogicalPosition | PhysicalPosition | Position): Promise; + /** + * Sets the window fullscreen state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setFullscreen(true); + * ``` + * + * @param fullscreen Whether the window should go to fullscreen or not. + * @returns A promise indicating the success or failure of the operation. + */ + setFullscreen(fullscreen: boolean): Promise; + /** + * On macOS, Toggles a fullscreen mode that doesn’t require a new macOS space. Returns a boolean indicating whether the transition was successful (this won’t work if the window was already in the native fullscreen). + * This is how fullscreen used to work on macOS in versions before Lion. And allows the user to have a fullscreen window without using another space or taking control over the entire monitor. + * + * On other platforms, this is the same as {@link Window.setFullscreen}. + * + * @param fullscreen Whether the window should go to simple fullscreen or not. + * @returns A promise indicating the success or failure of the operation. + */ + setSimpleFullscreen(fullscreen: boolean): Promise; + /** + * Bring the window to front and focus. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setFocus(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + setFocus(): Promise; + /** + * Sets whether the window can be focused. + * + * #### Platform-specific + * + * - **macOS**: If the window is already focused, it is not possible to unfocus it after calling `set_focusable(false)`. + * In this case, you might consider calling {@link Window.setFocus} but it will move the window to the back i.e. at the bottom in terms of z-order. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setFocusable(true); + * ``` + * + * @param focusable Whether the window can be focused. + * @returns A promise indicating the success or failure of the operation. + */ + setFocusable(focusable: boolean): Promise; + /** + * Sets the window icon. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setIcon('/tauri/awesome.png'); + * ``` + * + * Note that you may need the `image-ico` or `image-png` Cargo features to use this API. + * To enable it, change your Cargo.toml file: + * ```toml + * [dependencies] + * tauri = { version = "...", features = ["...", "image-png"] } + * ``` + * + * @param icon Icon bytes or path to the icon file. + * @returns A promise indicating the success or failure of the operation. + */ + setIcon(icon: string | Image | Uint8Array | ArrayBuffer | number[]): Promise; + /** + * Whether the window icon should be hidden from the taskbar or not. + * + * #### Platform-specific + * + * - **macOS:** Unsupported. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setSkipTaskbar(true); + * ``` + * + * @param skip true to hide window icon, false to show it. + * @returns A promise indicating the success or failure of the operation. + */ + setSkipTaskbar(skip: boolean): Promise; + /** + * Grabs the cursor, preventing it from leaving the window. + * + * There's no guarantee that the cursor will be hidden. You should + * hide it by yourself if you want so. + * + * #### Platform-specific + * + * - **Linux:** Unsupported. + * - **macOS:** This locks the cursor in a fixed location, which looks visually awkward. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setCursorGrab(true); + * ``` + * + * @param grab `true` to grab the cursor icon, `false` to release it. + * @returns A promise indicating the success or failure of the operation. + */ + setCursorGrab(grab: boolean): Promise; + /** + * Modifies the cursor's visibility. + * + * #### Platform-specific + * + * - **Windows:** The cursor is only hidden within the confines of the window. + * - **macOS:** The cursor is hidden as long as the window has input focus, even if the cursor is + * outside of the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setCursorVisible(false); + * ``` + * + * @param visible If `false`, this will hide the cursor. If `true`, this will show the cursor. + * @returns A promise indicating the success or failure of the operation. + */ + setCursorVisible(visible: boolean): Promise; + /** + * Modifies the cursor icon of the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setCursorIcon('help'); + * ``` + * + * @param icon The new cursor icon. + * @returns A promise indicating the success or failure of the operation. + */ + setCursorIcon(icon: CursorIcon): Promise; + /** + * Sets the window background color. + * + * #### Platform-specific: + * + * - **Windows:** alpha channel is ignored. + * - **iOS / Android:** Unsupported. + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.1.0 + */ + setBackgroundColor(color: Color): Promise; + /** + * Changes the position of the cursor in window coordinates. + * @example + * ```typescript + * import { getCurrentWindow, LogicalPosition } from '@tauri-apps/api/window'; + * await getCurrentWindow().setCursorPosition(new LogicalPosition(600, 300)); + * ``` + * + * @param position The new cursor position. + * @returns A promise indicating the success or failure of the operation. + */ + setCursorPosition(position: LogicalPosition | PhysicalPosition | Position): Promise; + /** + * Changes the cursor events behavior. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setIgnoreCursorEvents(true); + * ``` + * + * @param ignore `true` to ignore the cursor events; `false` to process them as usual. + * @returns A promise indicating the success or failure of the operation. + */ + setIgnoreCursorEvents(ignore: boolean): Promise; + /** + * Starts dragging the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().startDragging(); + * ``` + * + * @return A promise indicating the success or failure of the operation. + */ + startDragging(): Promise; + /** + * Starts resize-dragging the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().startResizeDragging(); + * ``` + * + * @return A promise indicating the success or failure of the operation. + */ + startResizeDragging(direction: ResizeDirection): Promise; + /** + * Sets the badge count. It is app wide and not specific to this window. + * + * #### Platform-specific + * + * - **Windows**: Unsupported. Use @{linkcode Window.setOverlayIcon} instead. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setBadgeCount(5); + * ``` + * + * @param count The badge count. Use `undefined` to remove the badge. + * @return A promise indicating the success or failure of the operation. + */ + setBadgeCount(count?: number): Promise; + /** + * Sets the badge cont **macOS only**. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setBadgeLabel("Hello"); + * ``` + * + * @param label The badge label. Use `undefined` to remove the badge. + * @return A promise indicating the success or failure of the operation. + */ + setBadgeLabel(label?: string): Promise; + /** + * Sets the overlay icon. **Windows only** + * The overlay icon can be set for every window. + * + * + * Note that you may need the `image-ico` or `image-png` Cargo features to use this API. + * To enable it, change your Cargo.toml file: + * + * ```toml + * [dependencies] + * tauri = { version = "...", features = ["...", "image-png"] } + * ``` + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setOverlayIcon("/tauri/awesome.png"); + * ``` + * + * @param icon Icon bytes or path to the icon file. Use `undefined` to remove the overlay icon. + * @return A promise indicating the success or failure of the operation. + */ + setOverlayIcon(icon?: string | Image | Uint8Array | ArrayBuffer | number[]): Promise; + /** + * Sets the taskbar progress state. + * + * #### Platform-specific + * + * - **Linux / macOS**: Progress bar is app-wide and not specific to this window. + * - **Linux**: Only supported desktop environments with `libunity` (e.g. GNOME). + * + * @example + * ```typescript + * import { getCurrentWindow, ProgressBarStatus } from '@tauri-apps/api/window'; + * await getCurrentWindow().setProgressBar({ + * status: ProgressBarStatus.Normal, + * progress: 50, + * }); + * ``` + * + * @return A promise indicating the success or failure of the operation. + */ + setProgressBar(state: ProgressBarState): Promise; + /** + * Sets whether the window should be visible on all workspaces or virtual desktops. + * + * #### Platform-specific + * + * - **Windows / iOS / Android:** Unsupported. + * + * @since 2.0.0 + */ + setVisibleOnAllWorkspaces(visible: boolean): Promise; + /** + * Sets the title bar style. **macOS only**. + * + * @since 2.0.0 + */ + setTitleBarStyle(style: TitleBarStyle): Promise; + /** + * Set window theme, pass in `null` or `undefined` to follow system theme + * + * #### Platform-specific + * + * - **Linux / macOS**: Theme is app-wide and not specific to this window. + * - **iOS / Android:** Unsupported. + * + * @since 2.0.0 + */ + setTheme(theme?: Theme | null): Promise; + /** + * Listen to window resize. + * + * @example + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * const unlisten = await getCurrentWindow().onResized(({ payload: size }) => { + * console.log('Window resized', size); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + onResized(handler: EventCallback): Promise; + /** + * Listen to window move. + * + * @example + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * const unlisten = await getCurrentWindow().onMoved(({ payload: position }) => { + * console.log('Window moved', position); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + onMoved(handler: EventCallback): Promise; + /** + * Listen to window close requested. Emitted when the user requests to closes the window. + * + * @example + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * import { confirm } from '@tauri-apps/api/dialog'; + * const unlisten = await getCurrentWindow().onCloseRequested(async (event) => { + * const confirmed = await confirm('Are you sure?'); + * if (!confirmed) { + * // user did not confirm closing the window; let's prevent it + * event.preventDefault(); + * } + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + onCloseRequested(handler: (event: CloseRequestedEvent) => void | Promise): Promise; + /** + * Listen to a file drop event. + * The listener is triggered when the user hovers the selected files on the webview, + * drops the files or cancels the operation. + * + * @example + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/webview"; + * const unlisten = await getCurrentWindow().onDragDropEvent((event) => { + * if (event.payload.type === 'over') { + * console.log('User hovering', event.payload.position); + * } else if (event.payload.type === 'drop') { + * console.log('User dropped', event.payload.paths); + * } else { + * console.log('File drop cancelled'); + * } + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + onDragDropEvent(handler: EventCallback): Promise; + /** + * Listen to window focus change. + * + * @example + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * const unlisten = await getCurrentWindow().onFocusChanged(({ payload: focused }) => { + * console.log('Focus changed, window is focused? ' + focused); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + onFocusChanged(handler: EventCallback): Promise; + /** + * Listen to window scale change. Emitted when the window's scale factor has changed. + * The following user actions can cause DPI changes: + * - Changing the display's resolution. + * - Changing the display's scale factor (e.g. in Control Panel on Windows). + * - Moving the window to a display with a different scale factor. + * + * @example + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * const unlisten = await getCurrentWindow().onScaleChanged(({ payload }) => { + * console.log('Scale changed', payload.scaleFactor, payload.size); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + onScaleChanged(handler: EventCallback): Promise; + /** + * Listen to the system theme change. + * + * @example + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * const unlisten = await getCurrentWindow().onThemeChanged(({ payload: theme }) => { + * console.log('New theme: ' + theme); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + onThemeChanged(handler: EventCallback): Promise; +} +/** + * An RGBA color. Each value has minimum of 0 and maximum of 255. + * + * It can be either a string `#ffffff`, an array of 3 or 4 elements or an object. + * + * @since 2.0.0 + */ +type Color = [number, number, number] | [number, number, number, number] | { + red: number; + green: number; + blue: number; + alpha: number; +} | string; +/** + * Background throttling policy + * + * @since 2.0.0 + */ +declare enum BackgroundThrottlingPolicy { + Disabled = "disabled", + Throttle = "throttle", + Suspend = "suspend" +} +/** + * The scrollbar style to use in the webview. + * + * ## Platform-specific + * + * **Windows**: This option must be given the same value for all webviews. + * + * @since 2.8.0 + */ +declare enum ScrollBarStyle { + /** + * The default scrollbar style for the webview. + */ + Default = "default", + /** + * Fluent UI style overlay scrollbars. **Windows Only** + * + * Requires WebView2 Runtime version 125.0.2535.41 or higher, does nothing on older versions, + * see https://learn.microsoft.com/en-us/microsoft-edge/webview2/release-notes/?tabs=dotnetcsharp#10253541 + */ + FluentOverlay = "fluentOverlay" +} +/** + * Platform-specific window effects + * + * @since 2.0.0 + */ +declare enum Effect { + /** + * A default material appropriate for the view's effectiveAppearance. **macOS 10.14-** + * + * @deprecated since macOS 10.14. You should instead choose an appropriate semantic material. + */ + AppearanceBased = "appearanceBased", + /** + * **macOS 10.14-** + * + * @deprecated since macOS 10.14. Use a semantic material instead. + */ + Light = "light", + /** + * **macOS 10.14-** + * + * @deprecated since macOS 10.14. Use a semantic material instead. + */ + Dark = "dark", + /** + * **macOS 10.14-** + * + * @deprecated since macOS 10.14. Use a semantic material instead. + */ + MediumLight = "mediumLight", + /** + * **macOS 10.14-** + * + * @deprecated since macOS 10.14. Use a semantic material instead. + */ + UltraDark = "ultraDark", + /** + * **macOS 10.10+** + */ + Titlebar = "titlebar", + /** + * **macOS 10.10+** + */ + Selection = "selection", + /** + * **macOS 10.11+** + */ + Menu = "menu", + /** + * **macOS 10.11+** + */ + Popover = "popover", + /** + * **macOS 10.11+** + */ + Sidebar = "sidebar", + /** + * **macOS 10.14+** + */ + HeaderView = "headerView", + /** + * **macOS 10.14+** + */ + Sheet = "sheet", + /** + * **macOS 10.14+** + */ + WindowBackground = "windowBackground", + /** + * **macOS 10.14+** + */ + HudWindow = "hudWindow", + /** + * **macOS 10.14+** + */ + FullScreenUI = "fullScreenUI", + /** + * **macOS 10.14+** + */ + Tooltip = "tooltip", + /** + * **macOS 10.14+** + */ + ContentBackground = "contentBackground", + /** + * **macOS 10.14+** + */ + UnderWindowBackground = "underWindowBackground", + /** + * **macOS 10.14+** + */ + UnderPageBackground = "underPageBackground", + /** + * **Windows 11 Only** + */ + Mica = "mica", + /** + * **Windows 7/10/11(22H1) Only** + * + * #### Notes + * + * This effect has bad performance when resizing/dragging the window on Windows 11 build 22621. + */ + Blur = "blur", + /** + * **Windows 10/11** + * + * #### Notes + * + * This effect has bad performance when resizing/dragging the window on Windows 10 v1903+ and Windows 11 build 22000. + */ + Acrylic = "acrylic", + /** + * Tabbed effect that matches the system dark preference **Windows 11 Only** + */ + Tabbed = "tabbed", + /** + * Tabbed effect with dark mode but only if dark mode is enabled on the system **Windows 11 Only** + */ + TabbedDark = "tabbedDark", + /** + * Tabbed effect with light mode **Windows 11 Only** + */ + TabbedLight = "tabbedLight" +} +/** + * Window effect state **macOS only** + * + * @see https://developer.apple.com/documentation/appkit/nsvisualeffectview/state + * + * @since 2.0.0 + */ +declare enum EffectState { + /** + * Make window effect state follow the window's active state **macOS only** + */ + FollowsWindowActiveState = "followsWindowActiveState", + /** + * Make window effect state always active **macOS only** + */ + Active = "active", + /** + * Make window effect state always inactive **macOS only** + */ + Inactive = "inactive" +} +/** The window effects configuration object + * + * @since 2.0.0 + */ +interface Effects { + /** + * List of Window effects to apply to the Window. + * Conflicting effects will apply the first one and ignore the rest. + */ + effects: Effect[]; + /** + * Window effect state **macOS Only** + */ + state?: EffectState; + /** + * Window effect corner radius **macOS Only** + */ + radius?: number; + /** + * Window effect color. Affects {@link Effect.Blur} and {@link Effect.Acrylic} only + * on Windows 10 v1903+. Doesn't have any effect on Windows 7 or Windows 11. + */ + color?: Color; +} +/** + * Minimum margin to work area + */ +interface PreventOverflowMargin { + width: number; + height: number; +} +/** + * Configuration for the window to create. + * + * @since 1.0.0 + */ +interface WindowOptions { + /** Show window in the center of the screen.. */ + center?: boolean; + /** The initial vertical position in logical pixels. Only applies if `y` is also set. */ + x?: number; + /** The initial horizontal position in logical pixels. Only applies if `x` is also set. */ + y?: number; + /** The initial width in logical pixels. */ + width?: number; + /** The initial height in logical pixels. */ + height?: number; + /** The minimum width in logical pixels. Only applies if `minHeight` is also set. */ + minWidth?: number; + /** The minimum height in logical pixels. Only applies if `minWidth` is also set. */ + minHeight?: number; + /** The maximum width in logical pixels. Only applies if `maxHeight` is also set. */ + maxWidth?: number; + /** The maximum height in logical pixels. Only applies if `maxWidth` is also set. */ + maxHeight?: number; + /** + * Prevent the window from overflowing the working area (e.g. monitor size - taskbar size) + * on creation, which means the window size will be limited to `monitor size - taskbar size` + * + * Can either be set to `true` or to a {@link PreventOverflowMargin} object to set an additional margin + * that should be considered to determine the working area + * (in this case the window size will be limited to `monitor size - taskbar size - margin`) + * + * **NOTE**: The overflow check is only performed on window creation, resizes can still overflow + * + * #### Platform-specific + * + * - **iOS / Android:** Unsupported. + */ + preventOverflow?: boolean | PreventOverflowMargin; + /** Whether the window is resizable or not. */ + resizable?: boolean; + /** Window title. */ + title?: string; + /** Whether the window is in fullscreen mode or not. */ + fullscreen?: boolean; + /** Whether the window will be initially focused or not. */ + focus?: boolean; + /** Whether the window can be focused or not. */ + focusable?: boolean; + /** + * Whether the window is transparent or not. + * Note that on `macOS` this requires the `macos-private-api` feature flag, enabled under `tauri.conf.json > app > macOSPrivateApi`. + * WARNING: Using private APIs on `macOS` prevents your application from being accepted to the `App Store`. + */ + transparent?: boolean; + /** Whether the window should be maximized upon creation or not. */ + maximized?: boolean; + /** Whether the window should be immediately visible upon creation or not. */ + visible?: boolean; + /** Whether the window should have borders and bars or not. */ + decorations?: boolean; + /** Whether the window should always be on top of other windows or not. */ + alwaysOnTop?: boolean; + /** Whether the window should always be below other windows. */ + alwaysOnBottom?: boolean; + /** Prevents the window contents from being captured by other apps. */ + contentProtected?: boolean; + /** Whether or not the window icon should be added to the taskbar. */ + skipTaskbar?: boolean; + /** + * Whether or not the window has shadow. + * + * #### Platform-specific + * + * - **Windows:** + * - `false` has no effect on decorated window, shadows are always ON. + * - `true` will make undecorated window have a 1px white border, + * and on Windows 11, it will have a rounded corners. + * - **Linux:** Unsupported. + * + * @since 2.0.0 + */ + shadow?: boolean; + /** + * The initial window theme. Defaults to the system theme. + * + * Only implemented on Windows and macOS 10.14+. + */ + theme?: Theme; + /** + * The style of the macOS title bar. + */ + titleBarStyle?: TitleBarStyle; + /** + * The position of the window controls on macOS. + * + * Requires `titleBarStyle: 'overlay'` and `decorations: true`. + * + * @since 2.4.0 + */ + trafficLightPosition?: LogicalPosition; + /** + * If `true`, sets the window title to be hidden on macOS. + */ + hiddenTitle?: boolean; + /** + * Defines the window [tabbing identifier](https://developer.apple.com/documentation/appkit/nswindow/1644704-tabbingidentifier) on macOS. + * + * Windows with the same tabbing identifier will be grouped together. + * If the tabbing identifier is not set, automatic tabbing will be disabled. + */ + tabbingIdentifier?: string; + /** + * Whether the window's native maximize button is enabled or not. Defaults to `true`. + */ + maximizable?: boolean; + /** + * Whether the window's native minimize button is enabled or not. Defaults to `true`. + */ + minimizable?: boolean; + /** + * Whether the window's native close button is enabled or not. Defaults to `true`. + */ + closable?: boolean; + /** + * Sets a parent to the window to be created. Can be either a {@linkcode Window} or a label of the window. + * + * #### Platform-specific + * + * - **Windows**: This sets the passed parent as an owner window to the window to be created. + * From [MSDN owned windows docs](https://docs.microsoft.com/en-us/windows/win32/winmsg/window-features#owned-windows): + * - An owned window is always above its owner in the z-order. + * - The system automatically destroys an owned window when its owner is destroyed. + * - An owned window is hidden when its owner is minimized. + * - **Linux**: This makes the new window transient for parent, see + * - **macOS**: This adds the window as a child of parent, see + */ + parent?: Window | WebviewWindow | string; + /** Whether the window should be visible on all workspaces or virtual desktops. + * + * #### Platform-specific + * + * - **Windows / iOS / Android:** Unsupported. + * + * @since 2.0.0 + */ + visibleOnAllWorkspaces?: boolean; + /** + * Window effects. + * + * Requires the window to be transparent. + * + * #### Platform-specific: + * + * - **Windows**: If using decorations or shadows, you may want to try this workaround + * - **Linux**: Unsupported + */ + windowEffects?: Effects; + /** + * Set the window background color. + * + * #### Platform-specific: + * + * - **Android / iOS:** Unsupported. + * - **Windows**: alpha channel is ignored. + * + * @since 2.1.0 + */ + backgroundColor?: Color; + /** Change the default background throttling behaviour. + * + * ## Platform-specific + * + * - **Linux / Windows / Android**: Unsupported. Workarounds like a pending WebLock transaction might suffice. + * - **iOS**: Supported since version 17.0+. + * - **macOS**: Supported since version 14.0+. + * + * see https://github.com/tauri-apps/tauri/issues/5250#issuecomment-2569380578 + * + * @since 2.3.0 + */ + backgroundThrottling?: BackgroundThrottlingPolicy; + /** + * Whether we should disable JavaScript code execution on the webview or not. + */ + javascriptDisabled?: boolean; + /** + * on macOS and iOS there is a link preview on long pressing links, this is enabled by default. + * see https://docs.rs/objc2-web-kit/latest/objc2_web_kit/struct.WKWebView.html#method.allowsLinkPreview + */ + allowLinkPreview?: boolean; + /** + * Allows disabling the input accessory view on iOS. + * + * The accessory view is the view that appears above the keyboard when a text input element is focused. + * It usually displays a view with "Done", "Next" buttons. + */ + disableInputAccessoryView?: boolean; + /** + * Specifies the native scrollbar style to use with the webview. + * CSS styles that modify the scrollbar are applied on top of the native appearance configured here. + * + * Defaults to `default`, which is the browser default. + * + * ## Platform-specific + * + * - **Windows**: + * - `fluentOverlay` requires WebView2 Runtime version 125.0.2535.41 or higher, and does nothing + * on older versions. + * - This option must be given the same value for all webviews. + * - **Linux / Android / iOS / macOS**: Unsupported. Only supports `Default` and performs no operation. + */ + scrollBarStyle?: ScrollBarStyle; +} +/** + * Returns the monitor on which the window currently resides. + * Returns `null` if current monitor can't be detected. + * @example + * ```typescript + * import { currentMonitor } from '@tauri-apps/api/window'; + * const monitor = await currentMonitor(); + * ``` + * + * @since 1.0.0 + */ +declare function currentMonitor(): Promise; +/** + * Returns the primary monitor of the system. + * Returns `null` if it can't identify any monitor as a primary one. + * @example + * ```typescript + * import { primaryMonitor } from '@tauri-apps/api/window'; + * const monitor = await primaryMonitor(); + * ``` + * + * @since 1.0.0 + */ +declare function primaryMonitor(): Promise; +/** + * Returns the monitor that contains the given point. Returns `null` if can't find any. + * @example + * ```typescript + * import { monitorFromPoint } from '@tauri-apps/api/window'; + * const monitor = await monitorFromPoint(100.0, 200.0); + * ``` + * + * @since 1.0.0 + */ +declare function monitorFromPoint(x: number, y: number): Promise; +/** + * Returns the list of all the monitors available on the system. + * @example + * ```typescript + * import { availableMonitors } from '@tauri-apps/api/window'; + * const monitors = await availableMonitors(); + * ``` + * + * @since 1.0.0 + */ +declare function availableMonitors(): Promise; +/** + * Get the cursor position relative to the top-left hand corner of the desktop. + * + * Note that the top-left hand corner of the desktop is not necessarily the same as the screen. + * If the user uses a desktop with multiple monitors, + * the top-left hand corner of the desktop is the top-left hand corner of the main monitor on Windows and macOS + * or the top-left of the leftmost monitor on X11. + * + * The coordinates can be negative if the top-left hand corner of the window is outside of the visible screen region. + */ +declare function cursorPosition(): Promise; +export { Window, CloseRequestedEvent, getCurrentWindow, getAllWindows, LogicalSize, PhysicalSize, LogicalPosition, PhysicalPosition, UserAttentionType, Effect, EffectState, currentMonitor, monitorFromPoint, primaryMonitor, availableMonitors, cursorPosition }; +export type { Effects, Theme, TitleBarStyle, ScaleFactorChanged, WindowOptions, Color, BackgroundThrottlingPolicy, DragDropEvent, ScrollBarStyle }; diff --git a/scripts/node_modules/@tauri-apps/api/window.js b/scripts/node_modules/@tauri-apps/api/window.js new file mode 100644 index 0000000000000000000000000000000000000000..d775577c57a3ba787b20f09862cd0600f80c3ad1 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/api/window.js @@ -0,0 +1,2038 @@ +import { PhysicalPosition, PhysicalSize, Size, Position } from './dpi.js'; +export { LogicalPosition, LogicalSize } from './dpi.js'; +import { listen, once, emit, emitTo, TauriEvent } from './event.js'; +import { invoke } from './core.js'; +import { transformImage } from './image.js'; + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * Provides APIs to create windows, communicate with other windows and manipulate the current window. + * + * #### Window events + * + * Events can be listened to using {@link Window.listen}: + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * getCurrentWindow().listen("my-window-event", ({ event, payload }) => { }); + * ``` + * + * @module + */ +/** + * Attention type to request on a window. + * + * @since 1.0.0 + */ +var UserAttentionType; +(function (UserAttentionType) { + /** + * #### Platform-specific + * - **macOS:** Bounces the dock icon until the application is in focus. + * - **Windows:** Flashes both the window and the taskbar button until the application is in focus. + */ + UserAttentionType[UserAttentionType["Critical"] = 1] = "Critical"; + /** + * #### Platform-specific + * - **macOS:** Bounces the dock icon once. + * - **Windows:** Flashes the taskbar button until the application is in focus. + */ + UserAttentionType[UserAttentionType["Informational"] = 2] = "Informational"; +})(UserAttentionType || (UserAttentionType = {})); +class CloseRequestedEvent { + constructor(event) { + this._preventDefault = false; + this.event = event.event; + this.id = event.id; + } + preventDefault() { + this._preventDefault = true; + } + isPreventDefault() { + return this._preventDefault; + } +} +var ProgressBarStatus; +(function (ProgressBarStatus) { + /** + * Hide progress bar. + */ + ProgressBarStatus["None"] = "none"; + /** + * Normal state. + */ + ProgressBarStatus["Normal"] = "normal"; + /** + * Indeterminate state. **Treated as Normal on Linux and macOS** + */ + ProgressBarStatus["Indeterminate"] = "indeterminate"; + /** + * Paused state. **Treated as Normal on Linux** + */ + ProgressBarStatus["Paused"] = "paused"; + /** + * Error state. **Treated as Normal on linux** + */ + ProgressBarStatus["Error"] = "error"; +})(ProgressBarStatus || (ProgressBarStatus = {})); +/** + * Get an instance of `Window` for the current window. + * + * @since 1.0.0 + */ +function getCurrentWindow() { + return new Window(window.__TAURI_INTERNALS__.metadata.currentWindow.label, { + // @ts-expect-error `skip` is not defined in the public API but it is handled by the constructor + skip: true + }); +} +/** + * Gets a list of instances of `Window` for all available windows. + * + * @since 1.0.0 + */ +async function getAllWindows() { + return invoke('plugin:window|get_all_windows').then((windows) => windows.map((w) => new Window(w, { + // @ts-expect-error `skip` is not defined in the public API but it is handled by the constructor + skip: true + }))); +} +/** @ignore */ +// events that are emitted right here instead of by the created window +const localTauriEvents = ['tauri://created', 'tauri://error']; +/** + * Create new window or get a handle to an existing one. + * + * Windows are identified by a *label* a unique identifier that can be used to reference it later. + * It may only contain alphanumeric characters `a-zA-Z` plus the following special characters `-`, `/`, `:` and `_`. + * + * @example + * ```typescript + * import { Window } from "@tauri-apps/api/window" + * + * const appWindow = new Window('theUniqueLabel'); + * + * appWindow.once('tauri://created', function () { + * // window successfully created + * }); + * appWindow.once('tauri://error', function (e) { + * // an error happened creating the window + * }); + * + * // emit an event to the backend + * await appWindow.emit("some-event", "data"); + * // listen to an event from the backend + * const unlisten = await appWindow.listen("event-name", e => {}); + * unlisten(); + * ``` + * + * @since 2.0.0 + */ +class Window { + /** + * Creates a new Window. + * @example + * ```typescript + * import { Window } from '@tauri-apps/api/window'; + * const appWindow = new Window('my-label'); + * appWindow.once('tauri://created', function () { + * // window successfully created + * }); + * appWindow.once('tauri://error', function (e) { + * // an error happened creating the window + * }); + * ``` + * + * @param label The unique window label. Must be alphanumeric: `a-zA-Z-/:_`. + * @returns The {@link Window} instance to communicate with the window. + */ + constructor(label, options = {}) { + var _a; + this.label = label; + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + this.listeners = Object.create(null); + // @ts-expect-error `skip` is not a public API so it is not defined in WindowOptions + if (!(options === null || options === void 0 ? void 0 : options.skip)) { + invoke('plugin:window|create', { + options: { + ...options, + parent: typeof options.parent === 'string' + ? options.parent + : (_a = options.parent) === null || _a === void 0 ? void 0 : _a.label, + label + } + }) + .then(async () => this.emit('tauri://created')) + .catch(async (e) => this.emit('tauri://error', e)); + } + } + /** + * Gets the Window associated with the given label. + * @example + * ```typescript + * import { Window } from '@tauri-apps/api/window'; + * const mainWindow = Window.getByLabel('main'); + * ``` + * + * @param label The window label. + * @returns The Window instance to communicate with the window or null if the window doesn't exist. + */ + static async getByLabel(label) { + var _a; + return (_a = (await getAllWindows()).find((w) => w.label === label)) !== null && _a !== void 0 ? _a : null; + } + /** + * Get an instance of `Window` for the current window. + */ + static getCurrent() { + return getCurrentWindow(); + } + /** + * Gets a list of instances of `Window` for all available windows. + */ + static async getAll() { + return getAllWindows(); + } + /** + * Gets the focused window. + * @example + * ```typescript + * import { Window } from '@tauri-apps/api/window'; + * const focusedWindow = Window.getFocusedWindow(); + * ``` + * + * @returns The Window instance or `undefined` if there is not any focused window. + */ + static async getFocusedWindow() { + for (const w of await getAllWindows()) { + if (await w.isFocused()) { + return w; + } + } + return null; + } + /** + * Listen to an emitted event on this window. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const unlisten = await getCurrentWindow().listen('state-changed', (event) => { + * console.log(`Got error: ${payload}`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async listen(event, handler) { + if (this._handleTauriEvent(event, handler)) { + return () => { + // eslint-disable-next-line security/detect-object-injection + const listeners = this.listeners[event]; + listeners.splice(listeners.indexOf(handler), 1); + }; + } + return listen(event, handler, { + target: { kind: 'Window', label: this.label } + }); + } + /** + * Listen to an emitted event on this window only once. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const unlisten = await getCurrentWindow().once('initialized', (event) => { + * console.log(`Window initialized!`); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param handler Event handler. + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async once(event, handler) { + if (this._handleTauriEvent(event, handler)) { + return () => { + // eslint-disable-next-line security/detect-object-injection + const listeners = this.listeners[event]; + listeners.splice(listeners.indexOf(handler), 1); + }; + } + return once(event, handler, { + target: { kind: 'Window', label: this.label } + }); + } + /** + * Emits an event to all {@link EventTarget|targets}. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().emit('window-loaded', { loggedIn: true, token: 'authToken' }); + * ``` + * + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param payload Event payload. + */ + async emit(event, payload) { + if (localTauriEvents.includes(event)) { + // eslint-disable-next-line + for (const handler of this.listeners[event] || []) { + handler({ + event, + id: -1, + payload + }); + } + return; + } + return emit(event, payload); + } + /** + * Emits an event to all {@link EventTarget|targets} matching the given target. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().emit('main', 'window-loaded', { loggedIn: true, token: 'authToken' }); + * ``` + * @param target Label of the target Window/Webview/WebviewWindow or raw {@link EventTarget} object. + * @param event Event name. Must include only alphanumeric characters, `-`, `/`, `:` and `_`. + * @param payload Event payload. + */ + async emitTo(target, event, payload) { + if (localTauriEvents.includes(event)) { + // eslint-disable-next-line security/detect-object-injection + for (const handler of this.listeners[event] || []) { + handler({ + event, + id: -1, + payload + }); + } + return; + } + return emitTo(target, event, payload); + } + /** @ignore */ + _handleTauriEvent(event, handler) { + if (localTauriEvents.includes(event)) { + if (!(event in this.listeners)) { + // eslint-disable-next-line + this.listeners[event] = [handler]; + } + else { + // eslint-disable-next-line + this.listeners[event].push(handler); + } + return true; + } + return false; + } + // Getters + /** + * The scale factor that can be used to map physical pixels to logical pixels. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const factor = await getCurrentWindow().scaleFactor(); + * ``` + * + * @returns The window's monitor scale factor. + */ + async scaleFactor() { + return invoke('plugin:window|scale_factor', { + label: this.label + }); + } + /** + * The position of the top-left hand corner of the window's client area relative to the top-left hand corner of the desktop. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const position = await getCurrentWindow().innerPosition(); + * ``` + * + * @returns The window's inner position. + */ + async innerPosition() { + return invoke('plugin:window|inner_position', { + label: this.label + }).then((p) => new PhysicalPosition(p)); + } + /** + * The position of the top-left hand corner of the window relative to the top-left hand corner of the desktop. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const position = await getCurrentWindow().outerPosition(); + * ``` + * + * @returns The window's outer position. + */ + async outerPosition() { + return invoke('plugin:window|outer_position', { + label: this.label + }).then((p) => new PhysicalPosition(p)); + } + /** + * The physical size of the window's client area. + * The client area is the content of the window, excluding the title bar and borders. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const size = await getCurrentWindow().innerSize(); + * ``` + * + * @returns The window's inner size. + */ + async innerSize() { + return invoke('plugin:window|inner_size', { + label: this.label + }).then((s) => new PhysicalSize(s)); + } + /** + * The physical size of the entire window. + * These dimensions include the title bar and borders. If you don't want that (and you usually don't), use inner_size instead. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const size = await getCurrentWindow().outerSize(); + * ``` + * + * @returns The window's outer size. + */ + async outerSize() { + return invoke('plugin:window|outer_size', { + label: this.label + }).then((s) => new PhysicalSize(s)); + } + /** + * Gets the window's current fullscreen state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const fullscreen = await getCurrentWindow().isFullscreen(); + * ``` + * + * @returns Whether the window is in fullscreen mode or not. + */ + async isFullscreen() { + return invoke('plugin:window|is_fullscreen', { + label: this.label + }); + } + /** + * Gets the window's current minimized state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const minimized = await getCurrentWindow().isMinimized(); + * ``` + */ + async isMinimized() { + return invoke('plugin:window|is_minimized', { + label: this.label + }); + } + /** + * Gets the window's current maximized state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const maximized = await getCurrentWindow().isMaximized(); + * ``` + * + * @returns Whether the window is maximized or not. + */ + async isMaximized() { + return invoke('plugin:window|is_maximized', { + label: this.label + }); + } + /** + * Gets the window's current focus state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const focused = await getCurrentWindow().isFocused(); + * ``` + * + * @returns Whether the window is focused or not. + */ + async isFocused() { + return invoke('plugin:window|is_focused', { + label: this.label + }); + } + /** + * Gets the window's current decorated state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const decorated = await getCurrentWindow().isDecorated(); + * ``` + * + * @returns Whether the window is decorated or not. + */ + async isDecorated() { + return invoke('plugin:window|is_decorated', { + label: this.label + }); + } + /** + * Gets the window's current resizable state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const resizable = await getCurrentWindow().isResizable(); + * ``` + * + * @returns Whether the window is resizable or not. + */ + async isResizable() { + return invoke('plugin:window|is_resizable', { + label: this.label + }); + } + /** + * Gets the window's native maximize button state. + * + * #### Platform-specific + * + * - **Linux / iOS / Android:** Unsupported. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const maximizable = await getCurrentWindow().isMaximizable(); + * ``` + * + * @returns Whether the window's native maximize button is enabled or not. + */ + async isMaximizable() { + return invoke('plugin:window|is_maximizable', { + label: this.label + }); + } + /** + * Gets the window's native minimize button state. + * + * #### Platform-specific + * + * - **Linux / iOS / Android:** Unsupported. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const minimizable = await getCurrentWindow().isMinimizable(); + * ``` + * + * @returns Whether the window's native minimize button is enabled or not. + */ + async isMinimizable() { + return invoke('plugin:window|is_minimizable', { + label: this.label + }); + } + /** + * Gets the window's native close button state. + * + * #### Platform-specific + * + * - **iOS / Android:** Unsupported. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const closable = await getCurrentWindow().isClosable(); + * ``` + * + * @returns Whether the window's native close button is enabled or not. + */ + async isClosable() { + return invoke('plugin:window|is_closable', { + label: this.label + }); + } + /** + * Gets the window's current visible state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const visible = await getCurrentWindow().isVisible(); + * ``` + * + * @returns Whether the window is visible or not. + */ + async isVisible() { + return invoke('plugin:window|is_visible', { + label: this.label + }); + } + /** + * Gets the window's current title. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const title = await getCurrentWindow().title(); + * ``` + */ + async title() { + return invoke('plugin:window|title', { + label: this.label + }); + } + /** + * Gets the window's current theme. + * + * #### Platform-specific + * + * - **macOS:** Theme was introduced on macOS 10.14. Returns `light` on macOS 10.13 and below. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const theme = await getCurrentWindow().theme(); + * ``` + * + * @returns The window theme. + */ + async theme() { + return invoke('plugin:window|theme', { + label: this.label + }); + } + /** + * Whether the window is configured to be always on top of other windows or not. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * const alwaysOnTop = await getCurrentWindow().isAlwaysOnTop(); + * ``` + * + * @returns Whether the window is visible or not. + */ + async isAlwaysOnTop() { + return invoke('plugin:window|is_always_on_top', { + label: this.label + }); + } + // Setters + /** + * Centers the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().center(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async center() { + return invoke('plugin:window|center', { + label: this.label + }); + } + /** + * Requests user attention to the window, this has no effect if the application + * is already focused. How requesting for user attention manifests is platform dependent, + * see `UserAttentionType` for details. + * + * Providing `null` will unset the request for user attention. Unsetting the request for + * user attention might not be done automatically by the WM when the window receives input. + * + * #### Platform-specific + * + * - **macOS:** `null` has no effect. + * - **Linux:** Urgency levels have the same effect. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().requestUserAttention(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async requestUserAttention(requestType) { + let requestType_ = null; + if (requestType) { + if (requestType === UserAttentionType.Critical) { + requestType_ = { type: 'Critical' }; + } + else { + requestType_ = { type: 'Informational' }; + } + } + return invoke('plugin:window|request_user_attention', { + label: this.label, + value: requestType_ + }); + } + /** + * Updates the window resizable flag. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setResizable(false); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async setResizable(resizable) { + return invoke('plugin:window|set_resizable', { + label: this.label, + value: resizable + }); + } + /** + * Enable or disable the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setEnabled(false); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.0.0 + */ + async setEnabled(enabled) { + return invoke('plugin:window|set_enabled', { + label: this.label, + value: enabled + }); + } + /** + * Whether the window is enabled or disabled. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setEnabled(false); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.0.0 + */ + async isEnabled() { + return invoke('plugin:window|is_enabled', { + label: this.label + }); + } + /** + * Sets whether the window's native maximize button is enabled or not. + * If resizable is set to false, this setting is ignored. + * + * #### Platform-specific + * + * - **macOS:** Disables the "zoom" button in the window titlebar, which is also used to enter fullscreen mode. + * - **Linux / iOS / Android:** Unsupported. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setMaximizable(false); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async setMaximizable(maximizable) { + return invoke('plugin:window|set_maximizable', { + label: this.label, + value: maximizable + }); + } + /** + * Sets whether the window's native minimize button is enabled or not. + * + * #### Platform-specific + * + * - **Linux / iOS / Android:** Unsupported. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setMinimizable(false); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async setMinimizable(minimizable) { + return invoke('plugin:window|set_minimizable', { + label: this.label, + value: minimizable + }); + } + /** + * Sets whether the window's native close button is enabled or not. + * + * #### Platform-specific + * + * - **Linux:** GTK+ will do its best to convince the window manager not to show a close button. Depending on the system, this function may not have any effect when called on a window that is already visible + * - **iOS / Android:** Unsupported. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setClosable(false); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async setClosable(closable) { + return invoke('plugin:window|set_closable', { + label: this.label, + value: closable + }); + } + /** + * Sets the window title. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setTitle('Tauri'); + * ``` + * + * @param title The new title + * @returns A promise indicating the success or failure of the operation. + */ + async setTitle(title) { + return invoke('plugin:window|set_title', { + label: this.label, + value: title + }); + } + /** + * Maximizes the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().maximize(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async maximize() { + return invoke('plugin:window|maximize', { + label: this.label + }); + } + /** + * Unmaximizes the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().unmaximize(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async unmaximize() { + return invoke('plugin:window|unmaximize', { + label: this.label + }); + } + /** + * Toggles the window maximized state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().toggleMaximize(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async toggleMaximize() { + return invoke('plugin:window|toggle_maximize', { + label: this.label + }); + } + /** + * Minimizes the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().minimize(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async minimize() { + return invoke('plugin:window|minimize', { + label: this.label + }); + } + /** + * Unminimizes the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().unminimize(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async unminimize() { + return invoke('plugin:window|unminimize', { + label: this.label + }); + } + /** + * Sets the window visibility to true. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().show(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async show() { + return invoke('plugin:window|show', { + label: this.label + }); + } + /** + * Sets the window visibility to false. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().hide(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async hide() { + return invoke('plugin:window|hide', { + label: this.label + }); + } + /** + * Closes the window. + * + * Note this emits a closeRequested event so you can intercept it. To force window close, use {@link Window.destroy}. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().close(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async close() { + return invoke('plugin:window|close', { + label: this.label + }); + } + /** + * Destroys the window. Behaves like {@link Window.close} but forces the window close instead of emitting a closeRequested event. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().destroy(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async destroy() { + return invoke('plugin:window|destroy', { + label: this.label + }); + } + /** + * Whether the window should have borders and bars. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setDecorations(false); + * ``` + * + * @param decorations Whether the window should have borders and bars. + * @returns A promise indicating the success or failure of the operation. + */ + async setDecorations(decorations) { + return invoke('plugin:window|set_decorations', { + label: this.label, + value: decorations + }); + } + /** + * Whether or not the window should have shadow. + * + * #### Platform-specific + * + * - **Windows:** + * - `false` has no effect on decorated window, shadows are always ON. + * - `true` will make undecorated window have a 1px white border, + * and on Windows 11, it will have a rounded corners. + * - **Linux:** Unsupported. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setShadow(false); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async setShadow(enable) { + return invoke('plugin:window|set_shadow', { + label: this.label, + value: enable + }); + } + /** + * Set window effects. + */ + async setEffects(effects) { + return invoke('plugin:window|set_effects', { + label: this.label, + value: effects + }); + } + /** + * Clear any applied effects if possible. + */ + async clearEffects() { + return invoke('plugin:window|set_effects', { + label: this.label, + value: null + }); + } + /** + * Whether the window should always be on top of other windows. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setAlwaysOnTop(true); + * ``` + * + * @param alwaysOnTop Whether the window should always be on top of other windows or not. + * @returns A promise indicating the success or failure of the operation. + */ + async setAlwaysOnTop(alwaysOnTop) { + return invoke('plugin:window|set_always_on_top', { + label: this.label, + value: alwaysOnTop + }); + } + /** + * Whether the window should always be below other windows. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setAlwaysOnBottom(true); + * ``` + * + * @param alwaysOnBottom Whether the window should always be below other windows or not. + * @returns A promise indicating the success or failure of the operation. + */ + async setAlwaysOnBottom(alwaysOnBottom) { + return invoke('plugin:window|set_always_on_bottom', { + label: this.label, + value: alwaysOnBottom + }); + } + /** + * Prevents the window contents from being captured by other apps. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setContentProtected(true); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async setContentProtected(protected_) { + return invoke('plugin:window|set_content_protected', { + label: this.label, + value: protected_ + }); + } + /** + * Resizes the window with a new inner size. + * @example + * ```typescript + * import { getCurrentWindow, LogicalSize } from '@tauri-apps/api/window'; + * await getCurrentWindow().setSize(new LogicalSize(600, 500)); + * ``` + * + * @param size The logical or physical inner size. + * @returns A promise indicating the success or failure of the operation. + */ + async setSize(size) { + return invoke('plugin:window|set_size', { + label: this.label, + value: size instanceof Size ? size : new Size(size) + }); + } + /** + * Sets the window minimum inner size. If the `size` argument is not provided, the constraint is unset. + * @example + * ```typescript + * import { getCurrentWindow, PhysicalSize } from '@tauri-apps/api/window'; + * await getCurrentWindow().setMinSize(new PhysicalSize(600, 500)); + * ``` + * + * @param size The logical or physical inner size, or `null` to unset the constraint. + * @returns A promise indicating the success or failure of the operation. + */ + async setMinSize(size) { + return invoke('plugin:window|set_min_size', { + label: this.label, + value: size instanceof Size ? size : size ? new Size(size) : null + }); + } + /** + * Sets the window maximum inner size. If the `size` argument is undefined, the constraint is unset. + * @example + * ```typescript + * import { getCurrentWindow, LogicalSize } from '@tauri-apps/api/window'; + * await getCurrentWindow().setMaxSize(new LogicalSize(600, 500)); + * ``` + * + * @param size The logical or physical inner size, or `null` to unset the constraint. + * @returns A promise indicating the success or failure of the operation. + */ + async setMaxSize(size) { + return invoke('plugin:window|set_max_size', { + label: this.label, + value: size instanceof Size ? size : size ? new Size(size) : null + }); + } + /** + * Sets the window inner size constraints. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setSizeConstraints({ minWidth: 300 }); + * ``` + * + * @param constraints The logical or physical inner size, or `null` to unset the constraint. + * @returns A promise indicating the success or failure of the operation. + */ + async setSizeConstraints(constraints) { + function logical(pixel) { + return pixel ? { Logical: pixel } : null; + } + return invoke('plugin:window|set_size_constraints', { + label: this.label, + value: { + minWidth: logical(constraints === null || constraints === void 0 ? void 0 : constraints.minWidth), + minHeight: logical(constraints === null || constraints === void 0 ? void 0 : constraints.minHeight), + maxWidth: logical(constraints === null || constraints === void 0 ? void 0 : constraints.maxWidth), + maxHeight: logical(constraints === null || constraints === void 0 ? void 0 : constraints.maxHeight) + } + }); + } + /** + * Sets the window outer position. + * @example + * ```typescript + * import { getCurrentWindow, LogicalPosition } from '@tauri-apps/api/window'; + * await getCurrentWindow().setPosition(new LogicalPosition(600, 500)); + * ``` + * + * @param position The new position, in logical or physical pixels. + * @returns A promise indicating the success or failure of the operation. + */ + async setPosition(position) { + return invoke('plugin:window|set_position', { + label: this.label, + value: position instanceof Position ? position : new Position(position) + }); + } + /** + * Sets the window fullscreen state. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setFullscreen(true); + * ``` + * + * @param fullscreen Whether the window should go to fullscreen or not. + * @returns A promise indicating the success or failure of the operation. + */ + async setFullscreen(fullscreen) { + return invoke('plugin:window|set_fullscreen', { + label: this.label, + value: fullscreen + }); + } + /** + * On macOS, Toggles a fullscreen mode that doesn’t require a new macOS space. Returns a boolean indicating whether the transition was successful (this won’t work if the window was already in the native fullscreen). + * This is how fullscreen used to work on macOS in versions before Lion. And allows the user to have a fullscreen window without using another space or taking control over the entire monitor. + * + * On other platforms, this is the same as {@link Window.setFullscreen}. + * + * @param fullscreen Whether the window should go to simple fullscreen or not. + * @returns A promise indicating the success or failure of the operation. + */ + async setSimpleFullscreen(fullscreen) { + return invoke('plugin:window|set_simple_fullscreen', { + label: this.label, + value: fullscreen + }); + } + /** + * Bring the window to front and focus. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setFocus(); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + */ + async setFocus() { + return invoke('plugin:window|set_focus', { + label: this.label + }); + } + /** + * Sets whether the window can be focused. + * + * #### Platform-specific + * + * - **macOS**: If the window is already focused, it is not possible to unfocus it after calling `set_focusable(false)`. + * In this case, you might consider calling {@link Window.setFocus} but it will move the window to the back i.e. at the bottom in terms of z-order. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setFocusable(true); + * ``` + * + * @param focusable Whether the window can be focused. + * @returns A promise indicating the success or failure of the operation. + */ + async setFocusable(focusable) { + return invoke('plugin:window|set_focusable', { + label: this.label, + value: focusable + }); + } + /** + * Sets the window icon. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setIcon('/tauri/awesome.png'); + * ``` + * + * Note that you may need the `image-ico` or `image-png` Cargo features to use this API. + * To enable it, change your Cargo.toml file: + * ```toml + * [dependencies] + * tauri = { version = "...", features = ["...", "image-png"] } + * ``` + * + * @param icon Icon bytes or path to the icon file. + * @returns A promise indicating the success or failure of the operation. + */ + async setIcon(icon) { + return invoke('plugin:window|set_icon', { + label: this.label, + value: transformImage(icon) + }); + } + /** + * Whether the window icon should be hidden from the taskbar or not. + * + * #### Platform-specific + * + * - **macOS:** Unsupported. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setSkipTaskbar(true); + * ``` + * + * @param skip true to hide window icon, false to show it. + * @returns A promise indicating the success or failure of the operation. + */ + async setSkipTaskbar(skip) { + return invoke('plugin:window|set_skip_taskbar', { + label: this.label, + value: skip + }); + } + /** + * Grabs the cursor, preventing it from leaving the window. + * + * There's no guarantee that the cursor will be hidden. You should + * hide it by yourself if you want so. + * + * #### Platform-specific + * + * - **Linux:** Unsupported. + * - **macOS:** This locks the cursor in a fixed location, which looks visually awkward. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setCursorGrab(true); + * ``` + * + * @param grab `true` to grab the cursor icon, `false` to release it. + * @returns A promise indicating the success or failure of the operation. + */ + async setCursorGrab(grab) { + return invoke('plugin:window|set_cursor_grab', { + label: this.label, + value: grab + }); + } + /** + * Modifies the cursor's visibility. + * + * #### Platform-specific + * + * - **Windows:** The cursor is only hidden within the confines of the window. + * - **macOS:** The cursor is hidden as long as the window has input focus, even if the cursor is + * outside of the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setCursorVisible(false); + * ``` + * + * @param visible If `false`, this will hide the cursor. If `true`, this will show the cursor. + * @returns A promise indicating the success or failure of the operation. + */ + async setCursorVisible(visible) { + return invoke('plugin:window|set_cursor_visible', { + label: this.label, + value: visible + }); + } + /** + * Modifies the cursor icon of the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setCursorIcon('help'); + * ``` + * + * @param icon The new cursor icon. + * @returns A promise indicating the success or failure of the operation. + */ + async setCursorIcon(icon) { + return invoke('plugin:window|set_cursor_icon', { + label: this.label, + value: icon + }); + } + /** + * Sets the window background color. + * + * #### Platform-specific: + * + * - **Windows:** alpha channel is ignored. + * - **iOS / Android:** Unsupported. + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.1.0 + */ + async setBackgroundColor(color) { + return invoke('plugin:window|set_background_color', { color }); + } + /** + * Changes the position of the cursor in window coordinates. + * @example + * ```typescript + * import { getCurrentWindow, LogicalPosition } from '@tauri-apps/api/window'; + * await getCurrentWindow().setCursorPosition(new LogicalPosition(600, 300)); + * ``` + * + * @param position The new cursor position. + * @returns A promise indicating the success or failure of the operation. + */ + async setCursorPosition(position) { + return invoke('plugin:window|set_cursor_position', { + label: this.label, + value: position instanceof Position ? position : new Position(position) + }); + } + /** + * Changes the cursor events behavior. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setIgnoreCursorEvents(true); + * ``` + * + * @param ignore `true` to ignore the cursor events; `false` to process them as usual. + * @returns A promise indicating the success or failure of the operation. + */ + async setIgnoreCursorEvents(ignore) { + return invoke('plugin:window|set_ignore_cursor_events', { + label: this.label, + value: ignore + }); + } + /** + * Starts dragging the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().startDragging(); + * ``` + * + * @return A promise indicating the success or failure of the operation. + */ + async startDragging() { + return invoke('plugin:window|start_dragging', { + label: this.label + }); + } + /** + * Starts resize-dragging the window. + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().startResizeDragging(); + * ``` + * + * @return A promise indicating the success or failure of the operation. + */ + async startResizeDragging(direction) { + return invoke('plugin:window|start_resize_dragging', { + label: this.label, + value: direction + }); + } + /** + * Sets the badge count. It is app wide and not specific to this window. + * + * #### Platform-specific + * + * - **Windows**: Unsupported. Use @{linkcode Window.setOverlayIcon} instead. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setBadgeCount(5); + * ``` + * + * @param count The badge count. Use `undefined` to remove the badge. + * @return A promise indicating the success or failure of the operation. + */ + async setBadgeCount(count) { + return invoke('plugin:window|set_badge_count', { + label: this.label, + value: count + }); + } + /** + * Sets the badge cont **macOS only**. + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setBadgeLabel("Hello"); + * ``` + * + * @param label The badge label. Use `undefined` to remove the badge. + * @return A promise indicating the success or failure of the operation. + */ + async setBadgeLabel(label) { + return invoke('plugin:window|set_badge_label', { + label: this.label, + value: label + }); + } + /** + * Sets the overlay icon. **Windows only** + * The overlay icon can be set for every window. + * + * + * Note that you may need the `image-ico` or `image-png` Cargo features to use this API. + * To enable it, change your Cargo.toml file: + * + * ```toml + * [dependencies] + * tauri = { version = "...", features = ["...", "image-png"] } + * ``` + * + * @example + * ```typescript + * import { getCurrentWindow } from '@tauri-apps/api/window'; + * await getCurrentWindow().setOverlayIcon("/tauri/awesome.png"); + * ``` + * + * @param icon Icon bytes or path to the icon file. Use `undefined` to remove the overlay icon. + * @return A promise indicating the success or failure of the operation. + */ + async setOverlayIcon(icon) { + return invoke('plugin:window|set_overlay_icon', { + label: this.label, + value: icon ? transformImage(icon) : undefined + }); + } + /** + * Sets the taskbar progress state. + * + * #### Platform-specific + * + * - **Linux / macOS**: Progress bar is app-wide and not specific to this window. + * - **Linux**: Only supported desktop environments with `libunity` (e.g. GNOME). + * + * @example + * ```typescript + * import { getCurrentWindow, ProgressBarStatus } from '@tauri-apps/api/window'; + * await getCurrentWindow().setProgressBar({ + * status: ProgressBarStatus.Normal, + * progress: 50, + * }); + * ``` + * + * @return A promise indicating the success or failure of the operation. + */ + async setProgressBar(state) { + return invoke('plugin:window|set_progress_bar', { + label: this.label, + value: state + }); + } + /** + * Sets whether the window should be visible on all workspaces or virtual desktops. + * + * #### Platform-specific + * + * - **Windows / iOS / Android:** Unsupported. + * + * @since 2.0.0 + */ + async setVisibleOnAllWorkspaces(visible) { + return invoke('plugin:window|set_visible_on_all_workspaces', { + label: this.label, + value: visible + }); + } + /** + * Sets the title bar style. **macOS only**. + * + * @since 2.0.0 + */ + async setTitleBarStyle(style) { + return invoke('plugin:window|set_title_bar_style', { + label: this.label, + value: style + }); + } + /** + * Set window theme, pass in `null` or `undefined` to follow system theme + * + * #### Platform-specific + * + * - **Linux / macOS**: Theme is app-wide and not specific to this window. + * - **iOS / Android:** Unsupported. + * + * @since 2.0.0 + */ + async setTheme(theme) { + return invoke('plugin:window|set_theme', { + label: this.label, + value: theme + }); + } + // Listeners + /** + * Listen to window resize. + * + * @example + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * const unlisten = await getCurrentWindow().onResized(({ payload: size }) => { + * console.log('Window resized', size); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async onResized(handler) { + return this.listen(TauriEvent.WINDOW_RESIZED, (e) => { + e.payload = new PhysicalSize(e.payload); + handler(e); + }); + } + /** + * Listen to window move. + * + * @example + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * const unlisten = await getCurrentWindow().onMoved(({ payload: position }) => { + * console.log('Window moved', position); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async onMoved(handler) { + return this.listen(TauriEvent.WINDOW_MOVED, (e) => { + e.payload = new PhysicalPosition(e.payload); + handler(e); + }); + } + /** + * Listen to window close requested. Emitted when the user requests to closes the window. + * + * @example + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * import { confirm } from '@tauri-apps/api/dialog'; + * const unlisten = await getCurrentWindow().onCloseRequested(async (event) => { + * const confirmed = await confirm('Are you sure?'); + * if (!confirmed) { + * // user did not confirm closing the window; let's prevent it + * event.preventDefault(); + * } + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async onCloseRequested(handler) { + // eslint-disable-next-line @typescript-eslint/no-misused-promises + return this.listen(TauriEvent.WINDOW_CLOSE_REQUESTED, async (event) => { + const evt = new CloseRequestedEvent(event); + await handler(evt); + if (!evt.isPreventDefault()) { + await this.destroy(); + } + }); + } + /** + * Listen to a file drop event. + * The listener is triggered when the user hovers the selected files on the webview, + * drops the files or cancels the operation. + * + * @example + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/webview"; + * const unlisten = await getCurrentWindow().onDragDropEvent((event) => { + * if (event.payload.type === 'over') { + * console.log('User hovering', event.payload.position); + * } else if (event.payload.type === 'drop') { + * console.log('User dropped', event.payload.paths); + * } else { + * console.log('File drop cancelled'); + * } + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async onDragDropEvent(handler) { + const unlistenDrag = await this.listen(TauriEvent.DRAG_ENTER, (event) => { + handler({ + ...event, + payload: { + type: 'enter', + paths: event.payload.paths, + position: new PhysicalPosition(event.payload.position) + } + }); + }); + const unlistenDragOver = await this.listen(TauriEvent.DRAG_OVER, (event) => { + handler({ + ...event, + payload: { + type: 'over', + position: new PhysicalPosition(event.payload.position) + } + }); + }); + const unlistenDrop = await this.listen(TauriEvent.DRAG_DROP, (event) => { + handler({ + ...event, + payload: { + type: 'drop', + paths: event.payload.paths, + position: new PhysicalPosition(event.payload.position) + } + }); + }); + const unlistenCancel = await this.listen(TauriEvent.DRAG_LEAVE, (event) => { + handler({ ...event, payload: { type: 'leave' } }); + }); + return () => { + unlistenDrag(); + unlistenDrop(); + unlistenDragOver(); + unlistenCancel(); + }; + } + /** + * Listen to window focus change. + * + * @example + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * const unlisten = await getCurrentWindow().onFocusChanged(({ payload: focused }) => { + * console.log('Focus changed, window is focused? ' + focused); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async onFocusChanged(handler) { + const unlistenFocus = await this.listen(TauriEvent.WINDOW_FOCUS, (event) => { + handler({ ...event, payload: true }); + }); + const unlistenBlur = await this.listen(TauriEvent.WINDOW_BLUR, (event) => { + handler({ ...event, payload: false }); + }); + return () => { + unlistenFocus(); + unlistenBlur(); + }; + } + /** + * Listen to window scale change. Emitted when the window's scale factor has changed. + * The following user actions can cause DPI changes: + * - Changing the display's resolution. + * - Changing the display's scale factor (e.g. in Control Panel on Windows). + * - Moving the window to a display with a different scale factor. + * + * @example + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * const unlisten = await getCurrentWindow().onScaleChanged(({ payload }) => { + * console.log('Scale changed', payload.scaleFactor, payload.size); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async onScaleChanged(handler) { + return this.listen(TauriEvent.WINDOW_SCALE_FACTOR_CHANGED, handler); + } + /** + * Listen to the system theme change. + * + * @example + * ```typescript + * import { getCurrentWindow } from "@tauri-apps/api/window"; + * const unlisten = await getCurrentWindow().onThemeChanged(({ payload: theme }) => { + * console.log('New theme: ' + theme); + * }); + * + * // you need to call unlisten if your handler goes out of scope e.g. the component is unmounted + * unlisten(); + * ``` + * + * @returns A promise resolving to a function to unlisten to the event. + * Note that removing the listener is required if your listener goes out of scope e.g. the component is unmounted. + */ + async onThemeChanged(handler) { + return this.listen(TauriEvent.WINDOW_THEME_CHANGED, handler); + } +} +/** + * Background throttling policy + * + * @since 2.0.0 + */ +var BackgroundThrottlingPolicy; +(function (BackgroundThrottlingPolicy) { + BackgroundThrottlingPolicy["Disabled"] = "disabled"; + BackgroundThrottlingPolicy["Throttle"] = "throttle"; + BackgroundThrottlingPolicy["Suspend"] = "suspend"; +})(BackgroundThrottlingPolicy || (BackgroundThrottlingPolicy = {})); +/** + * The scrollbar style to use in the webview. + * + * ## Platform-specific + * + * **Windows**: This option must be given the same value for all webviews. + * + * @since 2.8.0 + */ +var ScrollBarStyle; +(function (ScrollBarStyle) { + /** + * The default scrollbar style for the webview. + */ + ScrollBarStyle["Default"] = "default"; + /** + * Fluent UI style overlay scrollbars. **Windows Only** + * + * Requires WebView2 Runtime version 125.0.2535.41 or higher, does nothing on older versions, + * see https://learn.microsoft.com/en-us/microsoft-edge/webview2/release-notes/?tabs=dotnetcsharp#10253541 + */ + ScrollBarStyle["FluentOverlay"] = "fluentOverlay"; +})(ScrollBarStyle || (ScrollBarStyle = {})); +/** + * Platform-specific window effects + * + * @since 2.0.0 + */ +var Effect; +(function (Effect) { + /** + * A default material appropriate for the view's effectiveAppearance. **macOS 10.14-** + * + * @deprecated since macOS 10.14. You should instead choose an appropriate semantic material. + */ + Effect["AppearanceBased"] = "appearanceBased"; + /** + * **macOS 10.14-** + * + * @deprecated since macOS 10.14. Use a semantic material instead. + */ + Effect["Light"] = "light"; + /** + * **macOS 10.14-** + * + * @deprecated since macOS 10.14. Use a semantic material instead. + */ + Effect["Dark"] = "dark"; + /** + * **macOS 10.14-** + * + * @deprecated since macOS 10.14. Use a semantic material instead. + */ + Effect["MediumLight"] = "mediumLight"; + /** + * **macOS 10.14-** + * + * @deprecated since macOS 10.14. Use a semantic material instead. + */ + Effect["UltraDark"] = "ultraDark"; + /** + * **macOS 10.10+** + */ + Effect["Titlebar"] = "titlebar"; + /** + * **macOS 10.10+** + */ + Effect["Selection"] = "selection"; + /** + * **macOS 10.11+** + */ + Effect["Menu"] = "menu"; + /** + * **macOS 10.11+** + */ + Effect["Popover"] = "popover"; + /** + * **macOS 10.11+** + */ + Effect["Sidebar"] = "sidebar"; + /** + * **macOS 10.14+** + */ + Effect["HeaderView"] = "headerView"; + /** + * **macOS 10.14+** + */ + Effect["Sheet"] = "sheet"; + /** + * **macOS 10.14+** + */ + Effect["WindowBackground"] = "windowBackground"; + /** + * **macOS 10.14+** + */ + Effect["HudWindow"] = "hudWindow"; + /** + * **macOS 10.14+** + */ + Effect["FullScreenUI"] = "fullScreenUI"; + /** + * **macOS 10.14+** + */ + Effect["Tooltip"] = "tooltip"; + /** + * **macOS 10.14+** + */ + Effect["ContentBackground"] = "contentBackground"; + /** + * **macOS 10.14+** + */ + Effect["UnderWindowBackground"] = "underWindowBackground"; + /** + * **macOS 10.14+** + */ + Effect["UnderPageBackground"] = "underPageBackground"; + /** + * **Windows 11 Only** + */ + Effect["Mica"] = "mica"; + /** + * **Windows 7/10/11(22H1) Only** + * + * #### Notes + * + * This effect has bad performance when resizing/dragging the window on Windows 11 build 22621. + */ + Effect["Blur"] = "blur"; + /** + * **Windows 10/11** + * + * #### Notes + * + * This effect has bad performance when resizing/dragging the window on Windows 10 v1903+ and Windows 11 build 22000. + */ + Effect["Acrylic"] = "acrylic"; + /** + * Tabbed effect that matches the system dark preference **Windows 11 Only** + */ + Effect["Tabbed"] = "tabbed"; + /** + * Tabbed effect with dark mode but only if dark mode is enabled on the system **Windows 11 Only** + */ + Effect["TabbedDark"] = "tabbedDark"; + /** + * Tabbed effect with light mode **Windows 11 Only** + */ + Effect["TabbedLight"] = "tabbedLight"; +})(Effect || (Effect = {})); +/** + * Window effect state **macOS only** + * + * @see https://developer.apple.com/documentation/appkit/nsvisualeffectview/state + * + * @since 2.0.0 + */ +var EffectState; +(function (EffectState) { + /** + * Make window effect state follow the window's active state **macOS only** + */ + EffectState["FollowsWindowActiveState"] = "followsWindowActiveState"; + /** + * Make window effect state always active **macOS only** + */ + EffectState["Active"] = "active"; + /** + * Make window effect state always inactive **macOS only** + */ + EffectState["Inactive"] = "inactive"; +})(EffectState || (EffectState = {})); +function mapMonitor(m) { + return m === null + ? null + : { + name: m.name, + scaleFactor: m.scaleFactor, + position: new PhysicalPosition(m.position), + size: new PhysicalSize(m.size), + workArea: { + position: new PhysicalPosition(m.workArea.position), + size: new PhysicalSize(m.workArea.size) + } + }; +} +/** + * Returns the monitor on which the window currently resides. + * Returns `null` if current monitor can't be detected. + * @example + * ```typescript + * import { currentMonitor } from '@tauri-apps/api/window'; + * const monitor = await currentMonitor(); + * ``` + * + * @since 1.0.0 + */ +async function currentMonitor() { + return invoke('plugin:window|current_monitor').then(mapMonitor); +} +/** + * Returns the primary monitor of the system. + * Returns `null` if it can't identify any monitor as a primary one. + * @example + * ```typescript + * import { primaryMonitor } from '@tauri-apps/api/window'; + * const monitor = await primaryMonitor(); + * ``` + * + * @since 1.0.0 + */ +async function primaryMonitor() { + return invoke('plugin:window|primary_monitor').then(mapMonitor); +} +/** + * Returns the monitor that contains the given point. Returns `null` if can't find any. + * @example + * ```typescript + * import { monitorFromPoint } from '@tauri-apps/api/window'; + * const monitor = await monitorFromPoint(100.0, 200.0); + * ``` + * + * @since 1.0.0 + */ +async function monitorFromPoint(x, y) { + return invoke('plugin:window|monitor_from_point', { + x, + y + }).then(mapMonitor); +} +/** + * Returns the list of all the monitors available on the system. + * @example + * ```typescript + * import { availableMonitors } from '@tauri-apps/api/window'; + * const monitors = await availableMonitors(); + * ``` + * + * @since 1.0.0 + */ +async function availableMonitors() { + return invoke('plugin:window|available_monitors').then((ms) => ms.map(mapMonitor)); +} +/** + * Get the cursor position relative to the top-left hand corner of the desktop. + * + * Note that the top-left hand corner of the desktop is not necessarily the same as the screen. + * If the user uses a desktop with multiple monitors, + * the top-left hand corner of the desktop is the top-left hand corner of the main monitor on Windows and macOS + * or the top-left of the leftmost monitor on X11. + * + * The coordinates can be negative if the top-left hand corner of the window is outside of the visible screen region. + */ +async function cursorPosition() { + return invoke('plugin:window|cursor_position').then((v) => new PhysicalPosition(v)); +} + +export { CloseRequestedEvent, Effect, EffectState, PhysicalPosition, PhysicalSize, ProgressBarStatus, UserAttentionType, Window, availableMonitors, currentMonitor, cursorPosition, getAllWindows, getCurrentWindow, monitorFromPoint, primaryMonitor }; diff --git a/scripts/node_modules/@tauri-apps/cli-win32-x64-msvc/README.md b/scripts/node_modules/@tauri-apps/cli-win32-x64-msvc/README.md new file mode 100644 index 0000000000000000000000000000000000000000..c22490ba757cd63c1e0bc23a7b6580e0d1f58502 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/cli-win32-x64-msvc/README.md @@ -0,0 +1,3 @@ +# `@tauri-apps/cli-win32-x64-msvc` + +This is the **x86_64-pc-windows-msvc** binary for `@tauri-apps/cli` diff --git a/scripts/node_modules/@tauri-apps/cli-win32-x64-msvc/cli.win32-x64-msvc.node b/scripts/node_modules/@tauri-apps/cli-win32-x64-msvc/cli.win32-x64-msvc.node new file mode 100644 index 0000000000000000000000000000000000000000..c261af01a2e88d7ee9a6e8e25563fbe55dbe5760 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/cli-win32-x64-msvc/cli.win32-x64-msvc.node @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f7289148fdf4ce6ce527d34c63a0055c87de4ffe0a98475f3998d527225b1443 +size 15267328 diff --git a/scripts/node_modules/@tauri-apps/cli-win32-x64-msvc/package.json b/scripts/node_modules/@tauri-apps/cli-win32-x64-msvc/package.json new file mode 100644 index 0000000000000000000000000000000000000000..7617bfaf70a1fedea06a2a6da816d2fe27356fbe --- /dev/null +++ b/scripts/node_modules/@tauri-apps/cli-win32-x64-msvc/package.json @@ -0,0 +1,33 @@ +{ + "name": "@tauri-apps/cli-win32-x64-msvc", + "version": "2.10.1", + "cpu": [ + "x64" + ], + "main": "cli.win32-x64-msvc.node", + "files": [ + "cli.win32-x64-msvc.node" + ], + "description": "Command line interface for building Tauri apps", + "homepage": "https://github.com/tauri-apps/tauri#readme", + "contributors": [ + "Tauri Programme within The Commons Conservancy" + ], + "license": "Apache-2.0 OR MIT", + "engines": { + "node": ">= 10" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/tauri-apps/tauri.git" + }, + "bugs": { + "url": "https://github.com/tauri-apps/tauri/issues" + }, + "publishConfig": { + "access": "public" + }, + "os": [ + "win32" + ] +} \ No newline at end of file diff --git a/scripts/node_modules/@tauri-apps/cli/CHANGELOG.md b/scripts/node_modules/@tauri-apps/cli/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..236ecc1d3e691d1d9f85de99b2133ed292471dfa --- /dev/null +++ b/scripts/node_modules/@tauri-apps/cli/CHANGELOG.md @@ -0,0 +1,2032 @@ +# Changelog + +## \[2.10.1] + +### Bug Fixes + +- [`35c35f27a`](https://www.github.com/tauri-apps/tauri/commit/35c35f27aedc430b602ec74059b271128c15ad36) ([#14931](https://www.github.com/tauri-apps/tauri/pull/14931) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Support comma-separated list of Cargo features on all commands. +- [`0d1cb83ba`](https://www.github.com/tauri-apps/tauri/commit/0d1cb83bab2aa482c7d73116893fd7ff6aa56283) ([#14932](https://www.github.com/tauri-apps/tauri/pull/14932) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fix missing Cargo args when running mobile dev and build commands. +- [`33754ae5e`](https://www.github.com/tauri-apps/tauri/commit/33754ae5e3740d022483b6164511c5c001a3c24b) ([#15022](https://www.github.com/tauri-apps/tauri/pull/15022) by [@Legend-Master](https://www.github.com/tauri-apps/tauri/../../Legend-Master)) Fix updater signing private keys generated using `tauri signer generate` with empty password can't be used (The keys generated during tauri were broken between v2.9.3 and v2.10.0, you'll need to regenerate them) + +### What's Changed + +- [`7be58a1c6`](https://www.github.com/tauri-apps/tauri/commit/7be58a1c643a7ed6d0f484a7e1134022618eb2b2) ([#14894](https://www.github.com/tauri-apps/tauri/pull/14894) by [@Legend-Master](https://www.github.com/tauri-apps/tauri/../../Legend-Master)) Log patching bundle type information again + +### Dependencies + +- Upgraded to `tauri-cli@2.10.1` + +## \[2.10.0] + +### Enhancements + +- [`f82594410`](https://www.github.com/tauri-apps/tauri/commit/f82594410cd57d6f794f58d4afea0ed335aa796f) ([#13253](https://www.github.com/tauri-apps/tauri/pull/13253) by [@Armaldio](https://www.github.com/tauri-apps/tauri/../../Armaldio)) Allow electron to run the CLI directly +- [`a2abe2e6b`](https://www.github.com/tauri-apps/tauri/commit/a2abe2e6bcb9e1eed8484240dfdb76a5bc28ae58) ([#14607](https://www.github.com/tauri-apps/tauri/pull/14607) by [@sftse](https://www.github.com/tauri-apps/tauri/../../sftse)) Simplified internal representation of `features: Option>` with `Vec`, no user facing changes +- [`84b04c4a8`](https://www.github.com/tauri-apps/tauri/commit/84b04c4a8d3310b7a7091d10e36244bf94996e51) ([#14759](https://www.github.com/tauri-apps/tauri/pull/14759) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Added new environment variables for `tauri signer sign` command, to align with existing environment variables used in `tauri build`, `tauri bundle` and `tauri signer generate` + + - `TAURI_SIGNING_PRIVATE_KEY` + - `TAURI_SIGNING_PRIVATE_KEY_PATH` + - `TAURI_SIGNING_PRIVATE_KEY_PASSWORD` + + The old environment variables are deprecated and will be removed in a future release. + + - `TAURI_PRIVATE_KEY` + - `TAURI_PRIVATE_KEY_PATH` + - `TAURI_PRIVATE_KEY_PASSWORD` + +### Bug Fixes + +- [`62aa13a12`](https://www.github.com/tauri-apps/tauri/commit/62aa13a124ef46bb5ce9887a2a574dd35ef86d4f) ([#14629](https://www.github.com/tauri-apps/tauri/pull/14629) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fix `android build`'s `--aab` and `--apk` flags requiring a value to be provided. +- [`eccff9758`](https://www.github.com/tauri-apps/tauri/commit/eccff97588232055bd0cafd83e6ee03d11a501fb) ([#14779](https://www.github.com/tauri-apps/tauri/pull/14779) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fix empty associated-domains entitlements when domains are not configured for deep links. +- [`ea31b07f1`](https://www.github.com/tauri-apps/tauri/commit/ea31b07f19e0aa467ed0f921f60575cfe09809c8) ([#14789](https://www.github.com/tauri-apps/tauri/pull/14789) by [@Legend-Master](https://www.github.com/tauri-apps/tauri/../../Legend-Master)) Fixed the command description for `tauri inspect` +- [`7fca58230`](https://www.github.com/tauri-apps/tauri/commit/7fca58230f97c3e6834134419514a0c7dbbe784b) ([#14830](https://www.github.com/tauri-apps/tauri/pull/14830) by [@Legend-Master](https://www.github.com/tauri-apps/tauri/../../Legend-Master)) Updated `nsis_tauri_utils` to 0.5.3: + + - Use an alternative method `CreateProcessWithTokenW` to run programs as user, this fixed a problem that the program launched with the previous method can't query its own handle +- [`53611c4d7`](https://www.github.com/tauri-apps/tauri/commit/53611c4d7bdaf89b9a5d7c46a9c4bf4e34216148) ([#14747](https://www.github.com/tauri-apps/tauri/pull/14747) by [@Legend-Master](https://www.github.com/tauri-apps/tauri/../../Legend-Master)) Only watch dependent workspace members when running `tauri dev` instead of watching on all members +- [`1b0e335d3`](https://www.github.com/tauri-apps/tauri/commit/1b0e335d3f3445948d6590f7e074275d97cd9859) ([#14713](https://www.github.com/tauri-apps/tauri/pull/14713) by [@wasuaje](https://www.github.com/tauri-apps/tauri/../../wasuaje)) `tauri signer sign` doesn't work for files without an extension + +### What's Changed + +- [`e3fdcb500`](https://www.github.com/tauri-apps/tauri/commit/e3fdcb5002b362b46cde2a1971e4e7f2a1161208) ([#14836](https://www.github.com/tauri-apps/tauri/pull/14836) by [@sftse](https://www.github.com/tauri-apps/tauri/../../sftse)) Continued refactors of tauri-cli, fix too weak atomics. +- [`0575dd287`](https://www.github.com/tauri-apps/tauri/commit/0575dd287e021b61d2aedf64d62ae84a2c925fb4) ([#14521](https://www.github.com/tauri-apps/tauri/pull/14521) by [@kandrelczyk](https://www.github.com/tauri-apps/tauri/../../kandrelczyk)) Change the way bundle type information is added to binary files. Instead of looking up the value of a variable we simply look for the default value. +- [`7f7d9aac2`](https://www.github.com/tauri-apps/tauri/commit/7f7d9aac214e22d9492490543f7a9bcae0a6659e) ([#14668](https://www.github.com/tauri-apps/tauri/pull/14668) by [@sftse](https://www.github.com/tauri-apps/tauri/../../sftse)) Refactored internal use of static on config and directory resolvings, no user facing changes, please report any regressions if you encounter any + +### Dependencies + +- Upgraded to `tauri-cli@2.10.0` + +## \[2.9.6] + +### Dependencies + +- Upgraded to `tauri-cli@2.9.6` + +## \[2.9.5] + +### Bug Fixes + +- [`f855caf8a`](https://www.github.com/tauri-apps/tauri/commit/f855caf8a3830aa5dd6d0b039312866a5d9c3606) ([#14481](https://www.github.com/tauri-apps/tauri/pull/14481) by [@Legend-Master](https://www.github.com/tauri-apps/tauri/../../Legend-Master)) Fixed the mismatched tauri package versions check didn't work for pnpm + +### Performance Improvements + +- [`ce98d87ce`](https://www.github.com/tauri-apps/tauri/commit/ce98d87ce0aaa907285852eb80691197424e03c3) ([#14474](https://www.github.com/tauri-apps/tauri/pull/14474) by [@Tunglies](https://www.github.com/tauri-apps/tauri/../../Tunglies)) refactor: remove needless collect. No user facing changes. + +### Dependencies + +- Upgraded to `tauri-cli@2.9.5` + +## \[2.9.4] + +### Bug Fixes + +- [`b586ecf1f`](https://www.github.com/tauri-apps/tauri/commit/b586ecf1f4b3b087f9aa6c4668c2c18b1b7925f4) ([#14416](https://www.github.com/tauri-apps/tauri/pull/14416) by [@Legend-Master](https://www.github.com/tauri-apps/tauri/../../Legend-Master)) Premultiply Alpha before Resizing which gets rid of the gray fringe around the icons for svg images. + +### Dependencies + +- Upgraded to `tauri-cli@2.9.4` + +## \[2.9.3] + +### Bug Fixes + +- [`fd8c30b4f`](https://www.github.com/tauri-apps/tauri/commit/fd8c30b4f1bca8dd7165c5c0ebe7fbfd17662153) ([#14353](https://www.github.com/tauri-apps/tauri/pull/14353) by [@ChaseKnowlden](https://www.github.com/tauri-apps/tauri/../../ChaseKnowlden)) Premultiply Alpha before Resizing which gets rid of the gray fringe around the icons. + +### Dependencies + +- Upgraded to `tauri-cli@2.9.3` + +## \[2.9.2] + +### Dependencies + +- Upgraded to `tauri-cli@2.9.2` + +## \[2.9.1] + +### Dependencies + +- Upgraded to `tauri-cli@2.9.1` + +## \[2.9.0] + +### New Features + +- [`3b4fac201`](https://www.github.com/tauri-apps/tauri/commit/3b4fac2017832d426dd07c5e24e26684eda57f7b) ([#14194](https://www.github.com/tauri-apps/tauri/pull/14194)) Add `tauri.conf.json > bundle > android > autoIncrementVersionCode` config option to automatically increment the Android version code. +- [`673867aa0`](https://www.github.com/tauri-apps/tauri/commit/673867aa0e1ccd766ee879ffe96aba58c758613c) ([#14094](https://www.github.com/tauri-apps/tauri/pull/14094)) Try to detect ANDROID_HOME and NDK_HOME environment variables from default system locations and install them if needed using the Android Studio command line tools. +- [`3d6868d09`](https://www.github.com/tauri-apps/tauri/commit/3d6868d09c323d68a152f3c3f8c7256311bd020a) ([#14128](https://www.github.com/tauri-apps/tauri/pull/14128)) Added support to defining the content type of the declared file association on macOS (maps to LSItemContentTypes property). +- [`3d6868d09`](https://www.github.com/tauri-apps/tauri/commit/3d6868d09c323d68a152f3c3f8c7256311bd020a) ([#14128](https://www.github.com/tauri-apps/tauri/pull/14128)) Added support to defining the metadata for custom types declared in `tauri.conf.json > bundle > fileAssociations > exportedType` via the `UTExportedTypeDeclarations` Info.plist property. +- [`ed7c9a410`](https://www.github.com/tauri-apps/tauri/commit/ed7c9a4100e08c002212265549d12130d021ad1e) ([#14108](https://www.github.com/tauri-apps/tauri/pull/14108)) Added `bundle > macOS > infoPlist` and `bundle > iOS > infoPlist` configurations to allow defining custom Info.plist extensions. +- [`75082cc5b`](https://www.github.com/tauri-apps/tauri/commit/75082cc5b340e30e2c4b4cd4bd6a1fe5382164aa) ([#14120](https://www.github.com/tauri-apps/tauri/pull/14120)) Added `ios run` and `android run` commands to run the app in production mode. +- [`cc8c0b531`](https://www.github.com/tauri-apps/tauri/commit/cc8c0b53171173dbd1d01781a50de1a3ea159031) ([#14031](https://www.github.com/tauri-apps/tauri/pull/14031)) Added support to universal app links on macOS with the `plugins > deep-link > desktop > domains` configuration. + +### Enhancements + +- [`b5aa01870`](https://www.github.com/tauri-apps/tauri/commit/b5aa018702bf45dc98297698f9b7d238705865a6) ([#14268](https://www.github.com/tauri-apps/tauri/pull/14268)) Update cargo-mobile2 to 0.21, enhancing error messages and opening Xcode when multiple apps are installed. +- [`55453e845`](https://www.github.com/tauri-apps/tauri/commit/55453e8453d927b8197f1ba9f26fd944482938f7) ([#14262](https://www.github.com/tauri-apps/tauri/pull/14262)) Check mismatched versions in `tauri info` +- [`1a6627ee7`](https://www.github.com/tauri-apps/tauri/commit/1a6627ee7d085a4e66784e2705254714d68c7244) ([#14122](https://www.github.com/tauri-apps/tauri/pull/14122)) Set a default log level filter when running `tauri add log`. +- [`b06b3bd09`](https://www.github.com/tauri-apps/tauri/commit/b06b3bd091b0fed26cdcfb23cacb0462a7a9cc2d) ([#14126](https://www.github.com/tauri-apps/tauri/pull/14126)) Improve error messages with more context. +- [`f6622a3e3`](https://www.github.com/tauri-apps/tauri/commit/f6622a3e342f5dd5fb3cf6e0f79fb309a10e9b3d) ([#14129](https://www.github.com/tauri-apps/tauri/pull/14129)) Prompt to install the iOS platform if it isn't installed yet. +- [`6bbb530fd`](https://www.github.com/tauri-apps/tauri/commit/6bbb530fd5edfc07b180a4f3782b8566872ca3b1) ([#14105](https://www.github.com/tauri-apps/tauri/pull/14105)) Warn if productName is empty when initializing mobile project. + +### Bug Fixes + +- [`19fb6f7cb`](https://www.github.com/tauri-apps/tauri/commit/19fb6f7cb0d702cb2f25f6f2d1e11014d9dada5d) ([#14146](https://www.github.com/tauri-apps/tauri/pull/14146)) Strip Windows-only extensions from the binary path so an Android project initialized on Windows can be used on UNIX systems. +- [`19fb6f7cb`](https://www.github.com/tauri-apps/tauri/commit/19fb6f7cb0d702cb2f25f6f2d1e11014d9dada5d) ([#14146](https://www.github.com/tauri-apps/tauri/pull/14146)) Enhance Android build script usage on Windows by attempting to run cmd, bat and exe formats. +- [`28a2f9bc5`](https://www.github.com/tauri-apps/tauri/commit/28a2f9bc55f658eb71ef1a970ff9f791346f7682) ([#14101](https://www.github.com/tauri-apps/tauri/pull/14101)) Fix iOS CLI usage after modifying the package name. +- [`d2938486e`](https://www.github.com/tauri-apps/tauri/commit/d2938486e9d974debd90c15d7160b8a17bf4d763) ([#14261](https://www.github.com/tauri-apps/tauri/pull/14261)) Replaced the non-standard nerd font character with ` ⱼₛ ` in `tarui info` +- [`25e920e16`](https://www.github.com/tauri-apps/tauri/commit/25e920e169db900ca4f07c2bb9eb290e9f9f2c7d) ([#14298](https://www.github.com/tauri-apps/tauri/pull/14298)) Wait for dev server to exit before exiting the CLI when the app is closed on `tauri dev --no-watch`. +- [`b0012424c`](https://www.github.com/tauri-apps/tauri/commit/b0012424c5f432debfa42ba145e2672966d5f6d5) ([#14115](https://www.github.com/tauri-apps/tauri/pull/14115)) Resolve local IP address when `tauri.conf.json > build > devUrl` host is `0.0.0.0`. +- [`abf7e8850`](https://www.github.com/tauri-apps/tauri/commit/abf7e8850ba41e7173e9e9a3fdd6dfb8f357d72d) ([#14118](https://www.github.com/tauri-apps/tauri/pull/14118)) Fixes mobile project initialization when using `pnpx` or `pnpm dlx`. + +### Dependencies + +- Upgraded to `tauri-cli@2.9.0` + +## \[2.8.4] + +### Enhancements + +- [`f70b28529`](https://www.github.com/tauri-apps/tauri/commit/f70b28529d226a2dec2f41709d8934f8f5adab25) ([#14093](https://www.github.com/tauri-apps/tauri/pull/14093) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Ensure Rust targets for mobile are installed when running the dev and build commands (previously only checked on init). +- [`a9b342125`](https://www.github.com/tauri-apps/tauri/commit/a9b342125d5ac1bc9a4b2e8b5f73e8ca3cbcb8b2) ([#14114](https://www.github.com/tauri-apps/tauri/pull/14114) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fix iOS dev and build targeting the simulator on Intel machines. +- [`61b9b681e`](https://www.github.com/tauri-apps/tauri/commit/61b9b681e88067a53b79d2318ae005dc25addcd6) ([#14111](https://www.github.com/tauri-apps/tauri/pull/14111) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Retain `RUST_*` environment variables when running the mobile commands. +- [`c23bec62d`](https://www.github.com/tauri-apps/tauri/commit/c23bec62d6d5724798869681aa1534423aae28e2) ([#14083](https://www.github.com/tauri-apps/tauri/pull/14083) by [@FabianLars](https://www.github.com/tauri-apps/tauri/../../FabianLars)) Tauri now ignores `macOS.minimumSystemVersion` in `tauri dev` to prevent forced rebuilds of macOS specific dependencies when using something like `rust-analyzer` at the same time as `tauri dev`. + +### Bug Fixes + +- [`c37a29833`](https://www.github.com/tauri-apps/tauri/commit/c37a298331d6d744b15d32d55a2db83c884a3d6a) ([#14112](https://www.github.com/tauri-apps/tauri/pull/14112) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fix usage with Deno failing with `ReferenceError: require is not defined`. +- [`bcf000c0a`](https://www.github.com/tauri-apps/tauri/commit/bcf000c0a8607eedf488fb949b982f519abda43d) ([#14110](https://www.github.com/tauri-apps/tauri/pull/14110) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fixes running `ios` commands with `deno` crashing due to incorrect current working directory resolution. +- [`7db7142f9`](https://www.github.com/tauri-apps/tauri/commit/7db7142f9ff7dc2f5719602e199b77129ceb19d3) ([#14119](https://www.github.com/tauri-apps/tauri/pull/14119) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fixes empty device name when using an Android emulator causing the emulator to never be detected as running. +- [`956b4fd6f`](https://www.github.com/tauri-apps/tauri/commit/956b4fd6ffbb4312123b107ca96c87a001359b9d) ([#14106](https://www.github.com/tauri-apps/tauri/pull/14106) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Use the correct export method on Xcode < 15.4. + +### Dependencies + +- Upgraded to `tauri-cli@2.8.4` + +## \[2.8.3] + +### Bug Fixes + +- [`0ac89d3b6`](https://www.github.com/tauri-apps/tauri/commit/0ac89d3b6c8c4a4826a4c42726e4f4a8941b3fde) ([#14078](https://www.github.com/tauri-apps/tauri/pull/14078) by [@FabianLars](https://www.github.com/tauri-apps/tauri/../../FabianLars)) Updated `cargo-mobile2` to allow running on iOS simulators that have a higher version than the XCode SDK. This fixes compatiblity issues with Apple's recent "iOS 18.5 + iOS 18.6 Simulator" platform support component. + +### Dependencies + +- Upgraded to `tauri-cli@2.8.3` + +## \[2.8.2] + +### Dependencies + +- Upgraded to `tauri-cli@2.8.1` + +## \[2.8.1] + +### Bug Fixes + +- [`f0172a454`](https://www.github.com/tauri-apps/tauri/commit/f0172a454aea101cb699233be3d73dbf86e64a31) ([#14038](https://www.github.com/tauri-apps/tauri/pull/14038) by [@KushalMeghani1644](https://www.github.com/tauri-apps/tauri/../../KushalMeghani1644)) Fixes `removeDataStore` return type. + +## \[2.8.0] + +### New Features + +- [`91508c0b8`](https://www.github.com/tauri-apps/tauri/commit/91508c0b8d16ec61c7706e93b711c5a85aaffb4a) ([#13881](https://www.github.com/tauri-apps/tauri/pull/13881) by [@pepperoni505](https://www.github.com/tauri-apps/tauri/../../pepperoni505)) Introduces a new configuration option that allows you to specify custom folders to watch for changes when running `tauri dev`. +- [`bc4afe7dd`](https://www.github.com/tauri-apps/tauri/commit/bc4afe7dd4780f02c2d4b1f07d97185fbc5d2bba) ([#13993](https://www.github.com/tauri-apps/tauri/pull/13993) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Check installed plugin NPM/crate versions for incompatible releases. +- [`0c402bfb6`](https://www.github.com/tauri-apps/tauri/commit/0c402bfb6bd0bec24d928fcabe2ffef1f5cff19a) ([#13997](https://www.github.com/tauri-apps/tauri/pull/13997) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Increase default iOS deployment target iOS to 14.0. +- [`d6d5f3707`](https://www.github.com/tauri-apps/tauri/commit/d6d5f3707768a094ff7e961ae75ba0398d772655) ([#13358](https://www.github.com/tauri-apps/tauri/pull/13358) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Added `--root-certificate-path` option to `android dev` and `ios dev` to be able to connect to HTTPS dev servers. + +### Enhancements + +- [`8b465a12b`](https://www.github.com/tauri-apps/tauri/commit/8b465a12ba73e94d7a3995defd9cc362d15eeebe) ([#13913](https://www.github.com/tauri-apps/tauri/pull/13913) by [@FabianLars](https://www.github.com/tauri-apps/tauri/../../FabianLars)) The bundler now pulls the latest AppImage linuxdeploy plugin instead of using the built-in one. This should remove the libfuse requirement. +- [`390cb9c36`](https://www.github.com/tauri-apps/tauri/commit/390cb9c36a4e2416891b64514e7ad5fc0a85ccf2) ([#13953](https://www.github.com/tauri-apps/tauri/pull/13953) by [@FabianLars](https://www.github.com/tauri-apps/tauri/../../FabianLars)) Reduced the log level of the binary patcher crate `goblin` to only show its debug logs in `-vv` and above. +- [`4475e93e1`](https://www.github.com/tauri-apps/tauri/commit/4475e93e136e9e2bd5f3c7817fa2040924f630f6) ([#13824](https://www.github.com/tauri-apps/tauri/pull/13824) by [@FabianLars](https://www.github.com/tauri-apps/tauri/../../FabianLars)) The bundler and cli will now read TLS Certificates installed on the system when downloading tools and checking versions. + +### Bug Fixes + +- [`f0dcf9637`](https://www.github.com/tauri-apps/tauri/commit/f0dcf9637cc0d42eda05fed7dd6c5ff98bbf19ae) ([#13980](https://www.github.com/tauri-apps/tauri/pull/13980) by [@Legend-Master](https://www.github.com/tauri-apps/tauri/../../Legend-Master)) Fix the generated plugin init code of `tauri add` for `tauri-plugin-autostart` and `tauri-plugin-single-instance` +- [`4d270a96a`](https://www.github.com/tauri-apps/tauri/commit/4d270a96a891ae83f7df751abcbe12b7072212d5) ([#13943](https://www.github.com/tauri-apps/tauri/pull/13943) by [@acx0](https://www.github.com/tauri-apps/tauri/../../acx0)) Fix codesigning verification failures caused by binary-patching during bundling +- [`b21d86a8a`](https://www.github.com/tauri-apps/tauri/commit/b21d86a8a3ef29f16628b7d4de17ce1214e9bf49) ([#13981](https://www.github.com/tauri-apps/tauri/pull/13981) by [@Legend-Master](https://www.github.com/tauri-apps/tauri/../../Legend-Master)) Fix `tauri permission add` could add duplicated permissions to the capability files +- [`9c938be45`](https://www.github.com/tauri-apps/tauri/commit/9c938be4520fce9204361f3b59439844bc5c91e8) ([#13912](https://www.github.com/tauri-apps/tauri/pull/13912) by [@takecchi](https://www.github.com/tauri-apps/tauri/../../takecchi)) Properly migrate svelte to v5 in the plugin example template + +### Dependencies + +- Upgraded to `tauri-cli@2.8.0` + +## \[2.7.1] + +### Dependencies + +- Upgraded to `tauri-cli@2.7.1` + +## \[2.7.0] + +### New Features + +- [`33d079392`](https://www.github.com/tauri-apps/tauri/commit/33d079392ac4a5a153b7d8a6d82fefd6f54a2bdf) ([#13811](https://www.github.com/tauri-apps/tauri/pull/13811) by [@mhbagheri-99](https://www.github.com/tauri-apps/tauri/../../mhbagheri-99)) Allow runner configuration to be an object with cmd, cwd, and args properties. The runner can now be configured as `{ "cmd": "my_runner", "cwd": "/path", "args": ["--quiet"] }` while maintaining backwards compatibility with the existing string format. + +### Enhancements + +- [`232265c70`](https://www.github.com/tauri-apps/tauri/commit/232265c70e1c213bbb3f84b5541ddc07d330fce1) ([#13209](https://www.github.com/tauri-apps/tauri/pull/13209) by [@kandrelczyk](https://www.github.com/tauri-apps/tauri/../../kandrelczyk)) Binaries are patched before bundling to add the type of a bundle they will placed in. This information will be used during update process to select the correct target. + +### Bug Fixes + +- [`916aeaa48`](https://www.github.com/tauri-apps/tauri/commit/916aeaa48646a483a78e51cfe1633800ee62c37c) ([#13781](https://www.github.com/tauri-apps/tauri/pull/13781) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fixes Android dev and build commands reading `tauri.ios.conf.json` instead of `tauri.android.conf.json` to merge platform-specific configuration. +- [`0f248b111`](https://www.github.com/tauri-apps/tauri/commit/0f248b111ffb8af934eaf64bd8f4591e628da786) ([#13799](https://www.github.com/tauri-apps/tauri/pull/13799) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Install iOS dependencies when needed. +- [`7a6fd5b75`](https://www.github.com/tauri-apps/tauri/commit/7a6fd5b75d61071e2771f6277c0376ec206d302a) ([#13863](https://www.github.com/tauri-apps/tauri/pull/13863) by [@FabianLars](https://www.github.com/tauri-apps/tauri/../../FabianLars)) The AppImage bundler now pulls the AppRun binaries from our GitHub mirror, fixing 404 errors. +- [`bda830410`](https://www.github.com/tauri-apps/tauri/commit/bda8304107da7ca60caaba5674faa793491898c6) ([#13833](https://www.github.com/tauri-apps/tauri/pull/13833) by [@Legend-Master](https://www.github.com/tauri-apps/tauri/../../Legend-Master)) Fail with an error when trying to migrate from v2 alpha +- [`bda830410`](https://www.github.com/tauri-apps/tauri/commit/bda8304107da7ca60caaba5674faa793491898c6) ([#13833](https://www.github.com/tauri-apps/tauri/pull/13833) by [@Legend-Master](https://www.github.com/tauri-apps/tauri/../../Legend-Master)) Use v2 stable instead of v2-rc when migrating from v2-beta + +### Dependencies + +- Upgraded to `tauri-cli@2.7.0` + +## \[2.6.2] + +### Bug Fixes + +- [`cbd962972`](https://www.github.com/tauri-apps/tauri/commit/cbd9629729ed6eb208ba2234d014c11c4e9f1c8c) ([#13730](https://www.github.com/tauri-apps/tauri/pull/13730) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Load `--config` arguments when running the Xcode and Android Studio build scripts. + +### Dependencies + +- Upgraded to `tauri-cli@2.6.2` + +## \[2.6.1] + +### Dependencies + +- Upgraded to `tauri-cli@2.6.1` + +## \[2.6.0] + +### New Features + +- [`414619c36`](https://www.github.com/tauri-apps/tauri/commit/414619c36e94e21939534dd72c0438b93da75546) ([#13536](https://www.github.com/tauri-apps/tauri/pull/13536) by [@Tunglies](https://www.github.com/tauri-apps/tauri/../../Tunglies)) Added support for the `bundleName` property in the macOS bundler configuration. This allows specifying the `CFBundleName` value for generated macOS bundles. +- [`3242e1c94`](https://www.github.com/tauri-apps/tauri/commit/3242e1c946c441b58665ba5d612f3a3f1eafe0b6) ([#13659](https://www.github.com/tauri-apps/tauri/pull/13659) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Allow passing Cargo arguments to mobile dev and build commands. +- [`d1ce9af62`](https://www.github.com/tauri-apps/tauri/commit/d1ce9af62881e3f7d86a495c9c40df5b7f9d1c04) ([#13660](https://www.github.com/tauri-apps/tauri/pull/13660) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Allow passing `--config` arguments to the `ios init` and `android init` commands to tweak the configuration used to initialize the mobile projects. +- [`7322f0579`](https://www.github.com/tauri-apps/tauri/commit/7322f057923aaec88960ad5556776774b745762f) ([#13502](https://www.github.com/tauri-apps/tauri/pull/13502) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Allow using `CheckIfAppIsRunning` macro inside NSIS hooks, for example `!insertmacro CheckIfAppIsRunning "another-executable.exe" "Another Executable"`. +- [`4a880ca69`](https://www.github.com/tauri-apps/tauri/commit/4a880ca697bab6d63a2a51ea94e1988cc8c4ea4a) ([#13658](https://www.github.com/tauri-apps/tauri/pull/13658) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Synchronize Tauri config productName changes with the iOS Xcode project. +- [`8ee14a864`](https://www.github.com/tauri-apps/tauri/commit/8ee14a86480510c15823586cf28084e615cb7a9c) ([#13618](https://www.github.com/tauri-apps/tauri/pull/13618) by [@Sky-walkerX](https://www.github.com/tauri-apps/tauri/../../Sky-walkerX)) Warn the user that the app id shouldn't end in `.app` because it conflicts with the application bundle extension on macOS + +### Bug Fixes + +- [`35aa7e121`](https://www.github.com/tauri-apps/tauri/commit/35aa7e1218f34d0805e280e3ec32529d0cb0d733) ([#13294](https://www.github.com/tauri-apps/tauri/pull/13294) by [@kingsword09](https://www.github.com/tauri-apps/tauri/../../kingsword09)) fix: allow the target directory to be inside frontendDir as long as it is not the Rust target directory inside frontendDir. +- [`ec6065fa4`](https://www.github.com/tauri-apps/tauri/commit/ec6065fa4a6427266ecfb0c0f62f008574bb7880) ([#13625](https://www.github.com/tauri-apps/tauri/pull/13625) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fixes Android and iOS dev/build commands not working when the app identifier is being modified by the `--config` option. +- [`5a5291d66`](https://www.github.com/tauri-apps/tauri/commit/5a5291d66cb8a955c9d4f8e975782646ac0cc6e7) ([#13483](https://www.github.com/tauri-apps/tauri/pull/13483) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fix simulator build detection on Xcode. + +### Dependencies + +- Upgraded to `tauri-cli@2.6.0` +- [`9c16eefa3`](https://www.github.com/tauri-apps/tauri/commit/9c16eefa319b4697bac1d1019bbb5f93eca63173) ([#13629](https://www.github.com/tauri-apps/tauri/pull/13629) by [@sftse](https://www.github.com/tauri-apps/tauri/../../sftse)) Update html5ever to 0.29 and kuchikiki to version 0.8.8-speedreader. + +## \[2.5.0] + +### New Features + +- [`0aa48fb9e`](https://www.github.com/tauri-apps/tauri/commit/0aa48fb9e4b9d7b5bf3522000a76ebc1836394ed) ([#13030](https://www.github.com/tauri-apps/tauri/pull/13030)) Added `bundleVersion` to iOS and macOS configuration to support specifying a `CFBundleVersion`. + +### Enhancements + +- [`ad3fd3890`](https://www.github.com/tauri-apps/tauri/commit/ad3fd3890f1fa26a9f9be04ff1bc156d6dd2a8bc) ([#13152](https://www.github.com/tauri-apps/tauri/pull/13152)) Detect package manager from environment variable `npm_config_user_agent` first +- [`82406c61e`](https://www.github.com/tauri-apps/tauri/commit/82406c61e0fbb775ef00791ccab45349325bdd45) ([#13231](https://www.github.com/tauri-apps/tauri/pull/13231)) Improve iOS simulator usage, checking if Xcode iOS SDK is installed and allowing usage of Simulator for older iOS releases (previously only supported when running on Xcode via `ios dev --open`). + +### Bug Fixes + +- [`2dccfab53`](https://www.github.com/tauri-apps/tauri/commit/2dccfab5321fef55d45f3a4c674b6151b1c4424a) ([#13236](https://www.github.com/tauri-apps/tauri/pull/13236)) Fix `fileAssociations` missing `LSHandlerRank` on macOS. +- [`080252903`](https://www.github.com/tauri-apps/tauri/commit/0802529031c4fd309edff374a8694e93ddec161d) ([#13210](https://www.github.com/tauri-apps/tauri/pull/13210)) Fixes iOS dev not working on Xcode 16.3 simulators. To apply the fix, either regenerate the Xcode project with `rm -r src-tauri/gen/apple && tauri ios init` or remove the `arm64-sim` architecture from the Xcode project. + +### Dependencies + +- Upgraded to `tauri-cli@2.5.0` + +## \[2.4.1] + +### Enhancements + +- [`f805061d1`](https://www.github.com/tauri-apps/tauri/commit/f805061d1152bc4790dbdb9475a506afcdd1de75) ([#13079](https://www.github.com/tauri-apps/tauri/pull/13079) by [@Pietagorh](https://www.github.com/tauri-apps/tauri/../../Pietagorh)) Add support for passing TOML and JSON5 config files to `--config` arg + +### Bug Fixes + +- [`794af778e`](https://www.github.com/tauri-apps/tauri/commit/794af778e4915ffb6a4fe9bae8fba04bc880503d) ([#13117](https://www.github.com/tauri-apps/tauri/pull/13117) by [@Legend-Master](https://www.github.com/tauri-apps/tauri/../../Legend-Master)) Fix setting merge config value to null with `--config` arg no longer works + +### Dependencies + +- Upgraded to `tauri-cli@2.4.1` + +## \[2.4.0] + +### New Features + +- [`d91bfa5cb`](https://www.github.com/tauri-apps/tauri/commit/d91bfa5cb921a078758edd45ef3eaff71358d1eb) ([#12970](https://www.github.com/tauri-apps/tauri/pull/12970) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Allow merging multiple configuration values on `tauri dev`, `tauri build`, `tauri bundle`, `tauri android dev`, `tauri android build`, `tauri ios dev` and `tauri ios build`. +- [`30f5a1553`](https://www.github.com/tauri-apps/tauri/commit/30f5a1553d3c0ce460c9006764200a9210915a44) ([#12366](https://www.github.com/tauri-apps/tauri/pull/12366) by [@FabianLars](https://www.github.com/tauri-apps/tauri/../../FabianLars)) Added `trafficLightPosition` window configuration to set the traffic light buttons position on macOS. + +### Enhancements + +- [`f981a5ee8`](https://www.github.com/tauri-apps/tauri/commit/f981a5ee8b292b9ea09329f60cecc7f688dda734) ([#12602](https://www.github.com/tauri-apps/tauri/pull/12602) by [@kxxt](https://www.github.com/tauri-apps/tauri/../../kxxt)) Add basic support for linux riscv64 platform. + +### Bug Fixes + +- [`0c4700e99`](https://www.github.com/tauri-apps/tauri/commit/0c4700e9907f242eabe579eb6149a1d75174185c) ([#12985](https://www.github.com/tauri-apps/tauri/pull/12985) by [@FabianLars](https://www.github.com/tauri-apps/tauri/../../FabianLars)) The cli will now accept `--bundles updater` again. It's still no-op as it has been for all v2 versions. If you want to build updater artifacts, enable `createUpdaterArtifacts` in `tauri.conf.json`. +- [`b83921226`](https://www.github.com/tauri-apps/tauri/commit/b83921226cb3084992bb5357e7e39a09ea97843e) ([#12977](https://www.github.com/tauri-apps/tauri/pull/12977) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fix `tauri ios` commands using the wrong working directory with `bun@>1.2`. +- [`f268b3dbd`](https://www.github.com/tauri-apps/tauri/commit/f268b3dbdf313484c85b4a1f69cd7cec63049f35) ([#12871](https://www.github.com/tauri-apps/tauri/pull/12871) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Ignore parent .gitignore files on the Tauri project path detection. + +### Dependencies + +- Upgraded to `tauri-cli@2.4.0` + +## \[2.3.1] + +### Dependencies + +- Upgraded to `tauri-cli@2.3.1` + +## \[2.3.0] + +### Enhancements + +- [`a2d36b8c3`](https://www.github.com/tauri-apps/tauri/commit/a2d36b8c34a8dcfc6736797ca5cd4665faf75e7e) ([#12181](https://www.github.com/tauri-apps/tauri/pull/12181) by [@bastiankistner](https://www.github.com/tauri-apps/tauri/../../bastiankistner)) Add an option to change the default background throttling policy (currently for WebKit only). + +### Dependencies + +- Upgraded to `tauri-cli@2.3.0` + +## \[2.2.7] + +### Bug Fixes + +- [`8e9134c4a`](https://www.github.com/tauri-apps/tauri/commit/8e9134c4a2047329be0dbb868b7ae061a9d3f190) ([#12511](https://www.github.com/tauri-apps/tauri/pull/12511) by [@FabianLars](https://www.github.com/tauri-apps/tauri/../../FabianLars)) Fixed an issue that caused `tauri dev` to fail because of an incorrect `--bins` flag. + +### Dependencies + +- Upgraded to `tauri-cli@2.2.7` + +## \[2.2.6] + +### Enhancements + +- [`1a86974aa`](https://www.github.com/tauri-apps/tauri/commit/1a86974aa3d09957c6b1142a17bbfed9998798fd) ([#12406](https://www.github.com/tauri-apps/tauri/pull/12406) by [@bradleat](https://www.github.com/tauri-apps/tauri/../../bradleat)) `ios build --open` will now let xcode start the rust build process. +- [`0b79af711`](https://www.github.com/tauri-apps/tauri/commit/0b79af711430934362602fb950c3e4cb5b59cf9c) ([#12438](https://www.github.com/tauri-apps/tauri/pull/12438) by [@3lpsy](https://www.github.com/tauri-apps/tauri/../../3lpsy)) Log the command used to start the rust app in development. + +### Dependencies + +- Upgraded to `tauri-cli@2.2.6` + +## \[2.2.5] + +### Dependencies + +- Upgraded to `tauri-cli@2.2.5` + +## \[2.2.4] + +### Bug Fixes + +- [`cad550445`](https://www.github.com/tauri-apps/tauri/commit/cad5504455ffa53e297cebff473c113b1afa5d29) ([#12354](https://www.github.com/tauri-apps/tauri/pull/12354) by [@FabianLars](https://www.github.com/tauri-apps/tauri/../../FabianLars)) Fixed and issue that caused `tauri add` to try to install incorrect npm packages. + +### Dependencies + +- Upgraded to `tauri-cli@2.2.4` + +## \[2.2.3] + +### Enhancements + +- [`a0f2c84d5`](https://www.github.com/tauri-apps/tauri/commit/a0f2c84d51f5086c5055867d6f61ea90c463a26c) ([#12204](https://www.github.com/tauri-apps/tauri/pull/12204) by [@pjf-dev](https://www.github.com/tauri-apps/tauri/../../pjf-dev)) Enhance `tauri icon` command by including 64x64 png size in default icon sizes. + +### Bug Fixes + +- [`98f62e65a`](https://www.github.com/tauri-apps/tauri/commit/98f62e65a27a375272c6b4d9f34c23e142b9d3a6) ([#12246](https://www.github.com/tauri-apps/tauri/pull/12246) by [@marcomq](https://www.github.com/tauri-apps/tauri/../../marcomq)) Properly add NPM packages for community plugins when using the `tauri add` command. +- [`b9a99a5c6`](https://www.github.com/tauri-apps/tauri/commit/b9a99a5c69d8a2a1a3ff30e500b46872258dca15) ([#12297](https://www.github.com/tauri-apps/tauri/pull/12297) by [@FabianLars](https://www.github.com/tauri-apps/tauri/../../FabianLars)) Fixed an issue that caused the built-in dev server to constantly refresh on Linux. This only affected users who do not have `devUrl` point to a URL. +- [`ef21ed9ac`](https://www.github.com/tauri-apps/tauri/commit/ef21ed9ac1c045c38b0c04e3d71a441694abc257) ([#12290](https://www.github.com/tauri-apps/tauri/pull/12290) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fix iOS build failing when the development team contains spaces. + +### Dependencies + +- Upgraded to `tauri-cli@2.2.3` + +## \[2.2.2] + +### Bug Fixes + +- [`26fc9558f`](https://www.github.com/tauri-apps/tauri/commit/26fc9558fe7b2fe649f61926da88f36110dd5707) ([#12178](https://www.github.com/tauri-apps/tauri/pull/12178) by [@FabianLars](https://www.github.com/tauri-apps/tauri/../../FabianLars)) Fixed an issue that caused the `tauri dev` file watcher to exit after detecting file changes. + +### Dependencies + +- Upgraded to `tauri-cli@2.2.2` + +## \[2.2.1] + +### Bug Fixes + +- [`881729448`](https://www.github.com/tauri-apps/tauri/commit/881729448c9abd0d0c7941a8a31c94119ce827af) ([#12164](https://www.github.com/tauri-apps/tauri/pull/12164) by [@FabianLars](https://www.github.com/tauri-apps/tauri/../../FabianLars)) Fixed an issue that caused `tauri dev` to crash before showing the app on Linux. + +### Dependencies + +- Upgraded to `tauri-cli@2.2.1` + +## \[2.2.0] + +### New Features + +- [`cccb308c7`](https://www.github.com/tauri-apps/tauri/commit/cccb308c7b559b0838138d6cea280665f060c925) ([#11562](https://www.github.com/tauri-apps/tauri/pull/11562) by [@jLynx](https://www.github.com/tauri-apps/tauri/../../jLynx)) Generate signature for `.deb` packages when `createUpdaterArtifacts` option is enabled. +- [`74212d40d`](https://www.github.com/tauri-apps/tauri/commit/74212d40d80dba4501b3d4ae30104fa3d447bdf9) ([#11653](https://www.github.com/tauri-apps/tauri/pull/11653) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Include Linux destkop environment and session type in `tauri info` command. + +### Enhancements + +- [`93a3a043d`](https://www.github.com/tauri-apps/tauri/commit/93a3a043d39cc96515d51d98beeb14261d3a246b) ([#11727](https://www.github.com/tauri-apps/tauri/pull/11727) by [@Kiyozz](https://www.github.com/tauri-apps/tauri/../../Kiyozz)) Add support for `Portuguese` language for NSIS windows installer. + +### Bug Fixes + +- [`c8700656b`](https://www.github.com/tauri-apps/tauri/commit/c8700656be3001a0cc6e087f23aebd482430a85b) ([#11985](https://www.github.com/tauri-apps/tauri/pull/11985) by [@ShaunSHamilton](https://www.github.com/tauri-apps/tauri/../../ShaunSHamilton)) Fix `tauri remove` from removing object type (`{}`) permissions. +- [`0ae06c5ca`](https://www.github.com/tauri-apps/tauri/commit/0ae06c5ca89cecd24154affdc69668f5e1e67d85) ([#11914](https://www.github.com/tauri-apps/tauri/pull/11914) by [@wtto00](https://www.github.com/tauri-apps/tauri/../../wtto00)) Fix the exclude path in file `Cargo.toml` of plugin template generated by cli. Path changed in [#9346](https://github.com/tauri-apps/tauri/pull/9346) + +### Dependencies + +- Upgraded to `tauri-cli@2.2.0` + +## \[2.1.0] + +### New Features + +- [`6bf917941`](https://www.github.com/tauri-apps/tauri/commit/6bf917941ff0fcc49e86b3ba427340b75f3ce49c) ([#11322](https://www.github.com/tauri-apps/tauri/pull/11322) by [@ShaunSHamilton](https://www.github.com/tauri-apps/tauri/../../ShaunSHamilton)) Add `tauri remove` to remove plugins from projects. +- [`058c0db72`](https://www.github.com/tauri-apps/tauri/commit/058c0db72f43fbe1574d0db654560e693755cd7e) ([#11584](https://www.github.com/tauri-apps/tauri/pull/11584) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Add `bundle > linux > rpm > compression` config option to control RPM bundle compression type and level. + +### Enhancements + +- [`1f311832a`](https://www.github.com/tauri-apps/tauri/commit/1f311832ab5b2d62a533dfcf9b1d78bddf249ae8) ([#11405](https://www.github.com/tauri-apps/tauri/pull/11405) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Add more context for errors when decoding secret and public keys for signing updater artifacts. +- [`e0d1307d3`](https://www.github.com/tauri-apps/tauri/commit/e0d1307d3f78987d0059921a5ab01ea4b26e0ef1) ([#11414](https://www.github.com/tauri-apps/tauri/pull/11414) by [@Czxck001](https://www.github.com/tauri-apps/tauri/../../Czxck001)) Migrate the `$schema` Tauri configuration to the v2 format. +- [`c43d5df15`](https://www.github.com/tauri-apps/tauri/commit/c43d5df15828ecffa606482ea2b60350c488c981) ([#11512](https://www.github.com/tauri-apps/tauri/pull/11512) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Associate a newly created capability file with the `main` window on the `tauri add` and `tauri permission add` commands. + +### Bug Fixes + +- [`7af01ff2c`](https://www.github.com/tauri-apps/tauri/commit/7af01ff2ce623d727cd13a4c8a549c1c80031882) ([#11523](https://www.github.com/tauri-apps/tauri/pull/11523) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Fix `tauri migrate` failing to install NPM depenencies when running from Deno. +- [`100a4455a`](https://www.github.com/tauri-apps/tauri/commit/100a4455aa48df508510bbc08273215bdf70c012) ([#11529](https://www.github.com/tauri-apps/tauri/pull/11529) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Fix detecting yarn berry (v2 and higher) in various tauri cli commands. +- [`60e86d5f6`](https://www.github.com/tauri-apps/tauri/commit/60e86d5f6e0f0c769d34ef368cd8801a918d796d) ([#11624](https://www.github.com/tauri-apps/tauri/pull/11624) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Use the public network IP address on `android dev` by default on Windows. + +### Dependencies + +- Upgraded to `tauri-cli@2.1.0` + +## \[2.0.4] + +### Enhancements + +- [`e4c9268b1`](https://www.github.com/tauri-apps/tauri/commit/e4c9268b19c614dc9ebb0895448fd16de7efee80) ([#11258](https://www.github.com/tauri-apps/tauri/pull/11258) by [@regexident](https://www.github.com/tauri-apps/tauri/../../regexident)) Support custom project directory structure where the Tauri app folder is not a subfolder of the frontend project. + The frontend and Tauri app project paths can be set with the `TAURI_FRONTEND_PATH` and the `TAURI_APP_PATH` environment variables respectively. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.4` + +## \[2.0.3] + +### New Features + +- [`eda5713ea`](https://www.github.com/tauri-apps/tauri/commit/eda5713eab78d28182071ea25ceca5f1994f37ea) ([#11242](https://www.github.com/tauri-apps/tauri/pull/11242) by [@alex-sandri](https://www.github.com/tauri-apps/tauri/../../alex-sandri)) Add `Italian` to supported NSIS installer languages +- [`b3563e3d6`](https://www.github.com/tauri-apps/tauri/commit/b3563e3d6ae8dc90ee68f25f575cd5538ab1915b) ([#11304](https://www.github.com/tauri-apps/tauri/pull/11304) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Add Deno support in tauri-cli operations. + +### Bug Fixes + +- [`d609bef9f`](https://www.github.com/tauri-apps/tauri/commit/d609bef9fd7cd6eeb2bd701558100bd9cfb6e6f6) ([#11314](https://www.github.com/tauri-apps/tauri/pull/11314) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Fix android invalid proguard file when using an `identifier` that contains a component that is a reserved kotlin keyword, like `in`, `class`, etc +- [`069c05e44`](https://www.github.com/tauri-apps/tauri/commit/069c05e44fd6f30083fdc00dd6c0001278898592) ([#11315](https://www.github.com/tauri-apps/tauri/pull/11315) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Fix CLI crashing and failing to find a `.ico` file when `bundle > icon` option is using globs and doesn't have a string that ends with `.ico`. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.3` + +## \[2.0.2] + +### What's Changed + +- [`4475fbb50`](https://www.github.com/tauri-apps/tauri/commit/4475fbb502c5ffb3cea4de6bef1c7869be39bed6) ([#11208](https://www.github.com/tauri-apps/tauri/pull/11208) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Update cargo-mobile2 to 0.17.3, fixing lib name validation. +- [`a49a19ffa`](https://www.github.com/tauri-apps/tauri/commit/a49a19ffa304f031fb1a04d31a567cc7f42a380a) ([#11218](https://www.github.com/tauri-apps/tauri/pull/11218)) Fix bundling `appimage`, `deb` and `rpm` bundles failing to open when using `mainBinaryName` with spaces. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.2` + +## \[2.0.1] + +### Dependencies + +- Upgraded to `tauri-cli@2.0.1` + +## \[2.0.0] + +### What's Changed + +- [`637285790`](https://www.github.com/tauri-apps/tauri/commit/6372857905ae9c0aedb7f482ddf6cf9f9836c9f2) Promote to v2 stable! + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0` + +## \[2.0.0-rc.18] + +### Enhancements + +- [`a08e6ffa6`](https://www.github.com/tauri-apps/tauri/commit/a08e6ffa6fe499553be3c4c620726d6031cd6dd3) ([#11185](https://www.github.com/tauri-apps/tauri/pull/11185) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Enhance port forwarding on `android dev` to be more resilient and tolerate delays when booting up devices. +- [`6cfe7edf6`](https://www.github.com/tauri-apps/tauri/commit/6cfe7edf63636fdf66c429efdeb7bc9a0f404e9f) ([#11186](https://www.github.com/tauri-apps/tauri/pull/11186) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Retain logger verbosity on the `android-studio-script` and `xcode-script` commands. +- [`60a5aea53`](https://www.github.com/tauri-apps/tauri/commit/60a5aea53db02ae6af325812ab97555f2c013d70) ([#11181](https://www.github.com/tauri-apps/tauri/pull/11181) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Set the `TRUNK_SERVE_ADDRESS` environment variable when running on iOS physical devices to support Trunk. + +### Bug Fixes + +- [`f5d61822b`](https://www.github.com/tauri-apps/tauri/commit/f5d61822bf5988827776dd58bed75c19364e86bd) ([#11184](https://www.github.com/tauri-apps/tauri/pull/11184) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fix iOS application not including the provided capabilities (entitlements). + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-rc.18` + +## \[2.0.0-rc.17] + +### New Features + +- [`a944b9b05`](https://www.github.com/tauri-apps/tauri/commit/a944b9b05bc5ae6125ff451e86c5b207c511f3d7) ([#11118](https://www.github.com/tauri-apps/tauri/pull/11118) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Add `--github-workflows` flag for `tauri plugin new/init`. +- [`f57a729cd`](https://www.github.com/tauri-apps/tauri/commit/f57a729cd8f7e10d8daf0b9d5b85f9c7ad530496) ([#11039](https://www.github.com/tauri-apps/tauri/pull/11039) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Add `tauri inspect wix-upgrade-code` to print default Upgrade Code for your MSI installer derived from `productName`. + +### Bug Fixes + +- [`62b52f60a`](https://www.github.com/tauri-apps/tauri/commit/62b52f60a22ef84c4a2a2d9e662038b49f58e16c) ([#11064](https://www.github.com/tauri-apps/tauri/pull/11064) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Fix `tauri add` failing to add NPM depenency with `npm` package manager. +- [`56e087471`](https://www.github.com/tauri-apps/tauri/commit/56e087471a347f6bee7422221a956925c60b17e3) ([#11100](https://www.github.com/tauri-apps/tauri/pull/11100) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fix iOS xcode-script usage with `bun`. +- [`b88e22a5f`](https://www.github.com/tauri-apps/tauri/commit/b88e22a5fe4e2e4376d6cad64d1e74d104ca8927) ([#11063](https://www.github.com/tauri-apps/tauri/pull/11063) by [@FabianLars](https://www.github.com/tauri-apps/tauri/../../FabianLars)) The cli now only sets the iOS deployment target environment variable when building for iOS. +- [`8d22c0c81`](https://www.github.com/tauri-apps/tauri/commit/8d22c0c814e7227d5e56ce9a08929045ccea1a1b) ([#11101](https://www.github.com/tauri-apps/tauri/pull/11101) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Only modify the iOS Xcode project "sign style" if we need to enforce manual signing. +- [`df24cb944`](https://www.github.com/tauri-apps/tauri/commit/df24cb944249ee398f6c8ba8c19757b398eec701) ([#11168](https://www.github.com/tauri-apps/tauri/pull/11168) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fixes Xcode pbxproj file parsing not expecting `_` in build configuration IDs. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-rc.17` + +### Breaking Changes + +- [`a944b9b05`](https://www.github.com/tauri-apps/tauri/commit/a944b9b05bc5ae6125ff451e86c5b207c511f3d7) ([#11118](https://www.github.com/tauri-apps/tauri/pull/11118) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) `tauri plugin init/new` will no longer generate a `.github` directory with workflows by default, instead use the new `--github-workflows` flag. + +## \[2.0.0-rc.16] + +### New Features + +- [`9bb8fc618`](https://www.github.com/tauri-apps/tauri/commit/9bb8fc6189a93bcb811588b36e710d0f7818a1f9) ([#11030](https://www.github.com/tauri-apps/tauri/pull/11030) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Add `--no-example` flag for `tauri plugin new` and `tauri plugin init` to disable creation of an example project. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-rc.16` + +## \[2.0.0-rc.15] + +### Enhancements + +- [`5a0e922d4`](https://www.github.com/tauri-apps/tauri/commit/5a0e922d40dc3b7d9a8e3a65ccaf76d09f026cb8) ([#11007](https://www.github.com/tauri-apps/tauri/pull/11007) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Automatically discover the `src-tauri/src/main.rs` binary when it is not explicitly defined in the Cargo manifest bin array. + +### Bug Fixes + +- [`94e9d476e`](https://www.github.com/tauri-apps/tauri/commit/94e9d476ef506b1b8c09f55b81620c7839f98086) ([#11011](https://www.github.com/tauri-apps/tauri/pull/11011) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Fix `main_binary_name` in custom wix and nsis templates including `.exe` + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-rc.15` + +## \[2.0.0-rc.14] + +### Enhancements + +- [`6c5340f8b`](https://www.github.com/tauri-apps/tauri/commit/6c5340f8b2549dfe89f19656304e65cd670afc92) ([#11004](https://www.github.com/tauri-apps/tauri/pull/11004) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Added the `log` plugin to the app template, which is required to visualize logs on Android and iOS. +- [`3ad2427dc`](https://www.github.com/tauri-apps/tauri/commit/3ad2427dc08f12c61edc726b587acce32eca1080) ([#10961](https://www.github.com/tauri-apps/tauri/pull/10961) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Only render app logs on iOS unless `-vv` is provided to the `ios dev` command. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-rc.13` + +## \[2.0.0-rc.13] + +### Bug Fixes + +- [`a5848af65`](https://www.github.com/tauri-apps/tauri/commit/a5848af65b10d89686314cf737b7fd9d91f99dd8) ([#10944](https://www.github.com/tauri-apps/tauri/pull/10944) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Synchronize app version (`tauri.conf.json > version` or `Cargo.toml > package > version`) with the `CFBundleVersion` and `CFBundleShortVersionString` Info.plist values. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-rc.12` + +## \[2.0.0-rc.12] + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-rc.11` + +## \[2.0.0-rc.11] + +### Enhancements + +- [`9c9644d15`](https://www.github.com/tauri-apps/tauri/commit/9c9644d155818d9efcad65b60aa985a59e767922) ([#10845](https://www.github.com/tauri-apps/tauri/pull/10845) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Enhance iOS library validation, checking libs built with link time optimization. + +### Bug Fixes + +- [`b42683592`](https://www.github.com/tauri-apps/tauri/commit/b42683592d446f25c2005b59e9e3ec551175906d) ([#10847](https://www.github.com/tauri-apps/tauri/pull/10847) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fixes `ios build --target [aarch64-sim | x86_64]` failing to generate the app bundle for the iOS simulator. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-rc.10` + +## \[2.0.0-rc.10] + +### Bug Fixes + +- [`6faa03276`](https://www.github.com/tauri-apps/tauri/commit/6faa032766b23cd161503905d4c79365ff6c50d1) ([#10854](https://www.github.com/tauri-apps/tauri/pull/10854) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fixes iOS code signing failing on CI due to a missing development certificate. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-rc.9` + +## \[2.0.0-rc.9] + +### Bug Fixes + +- [`5af1f5dec`](https://www.github.com/tauri-apps/tauri/commit/5af1f5dec1bb98f335169df8c5e30c19a24cae07) ([#10851](https://www.github.com/tauri-apps/tauri/pull/10851) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fixes `ios build` failing to build iOS app in CI when using an API key for automatic signing. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-rc.9` + +## \[2.0.0-rc.8] + +### New Features + +- [`91e9e784a`](https://www.github.com/tauri-apps/tauri/commit/91e9e784aa59634e3fe6359f8b78d071d76a9e42) ([#10729](https://www.github.com/tauri-apps/tauri/pull/10729) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Add plugins information in `tauri info` output +- [`09e9dc1aa`](https://www.github.com/tauri-apps/tauri/commit/09e9dc1aab1b66aa6a3a009d5873db586abe76a0) ([#10752](https://www.github.com/tauri-apps/tauri/pull/10752) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Allow Xcode to manage iOS code sign and provisioning profiles by default. + On CI, the `APPLE_API_KEY`, `APPLE_API_ISSUER` and `APPLE_API_KEY_PATH` environment variables must be provided for authentication. + +### Enhancements + +- [`3a4972b39`](https://www.github.com/tauri-apps/tauri/commit/3a4972b394c65c32eefebfb2181ba56b0cfc08f7) ([#10793](https://www.github.com/tauri-apps/tauri/pull/10793) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Include architecture in the `tauri info` output. +- [`fd68b7fde`](https://www.github.com/tauri-apps/tauri/commit/fd68b7fdea3890d9f0a373a252a3682bd9d04138) ([#10785](https://www.github.com/tauri-apps/tauri/pull/10785) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Remove the `.cargo/config` file creation that used to fix mobile build caches. +- [`f67a9eb6d`](https://www.github.com/tauri-apps/tauri/commit/f67a9eb6de4567c2374b8cdbabadcf0ca44d28fb) ([#10802](https://www.github.com/tauri-apps/tauri/pull/10802) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Synchronize identifier, development team and lib name with the iOS Xcode project. + +### Bug Fixes + +- [`83ed090bf`](https://www.github.com/tauri-apps/tauri/commit/83ed090bfa58a1784495f474d93b16a568be513f) ([#10790](https://www.github.com/tauri-apps/tauri/pull/10790) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Do not quit `ios dev` and `android dev` process when we fail to attach the logger. +- [`2d31aef75`](https://www.github.com/tauri-apps/tauri/commit/2d31aef759f496f3afe46b7697176e61a8570511) ([#10751](https://www.github.com/tauri-apps/tauri/pull/10751) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Ensure gradlew is executable and does not use CRLF so it can be used on UNIX systems. +- [`02b2f964a`](https://www.github.com/tauri-apps/tauri/commit/02b2f964a70c61ff08b5052bd9fcde472d706d9c) ([#10795](https://www.github.com/tauri-apps/tauri/pull/10795) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fix the `add` command NPM version specifier for known plugins from `2.0.0-rc` (unknown version requirement) to `^2.0.0-rc`. +- [`84070bae9`](https://www.github.com/tauri-apps/tauri/commit/84070bae92d234bc3630e795cfaf79f869f3a751) ([#10792](https://www.github.com/tauri-apps/tauri/pull/10792) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fix `tauri plugin ios init` not generating the iOS folder. +- [`edb2ca31f`](https://www.github.com/tauri-apps/tauri/commit/edb2ca31f70a39004b6a09ae53425f22e243318e) ([#10794](https://www.github.com/tauri-apps/tauri/pull/10794) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Migrate v1 plugins NPM packages. +- [`9718dc9e8`](https://www.github.com/tauri-apps/tauri/commit/9718dc9e8c9bc91d9a5d9e0e06a7afab62492152) ([#10791](https://www.github.com/tauri-apps/tauri/pull/10791) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Reintroduce the `targetSdk` value in the Android application template. + +### What's Changed + +- [`fb6bf3142`](https://www.github.com/tauri-apps/tauri/commit/fb6bf314252c88dd49af74bdbb8499df370836ae) ([#10763](https://www.github.com/tauri-apps/tauri/pull/10763) by [@rdlabo](https://www.github.com/tauri-apps/tauri/../../rdlabo)) Update plugin template Android code to match documentation on Android package ID usage. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-rc.8` + +### Breaking Changes + +- [`073bb4f45`](https://www.github.com/tauri-apps/tauri/commit/073bb4f459a923541b94970dfa7e087bccaa2cfd) ([#10772](https://www.github.com/tauri-apps/tauri/pull/10772) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Removed the deprecated `webview_fixed_runtime_path` config option, use the `webview_install_mode` instead. + +## \[2.0.0-rc.7] + +### Enhancements + +- [`da8c9a7d3`](https://www.github.com/tauri-apps/tauri/commit/da8c9a7d3069398c26826aeb082caa44b7c92809) ([#10669](https://www.github.com/tauri-apps/tauri/pull/10669) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Modify both ExportOptions.plist and project.pbxproj to reflect changes for the `IOS_CERTIFICATE`, `IOS_CERTIFICATE_PASSWORD` and `IOS_MOBILE_PROVISION` environment variables. + +### Bug Fixes + +- [`793ee0531`](https://www.github.com/tauri-apps/tauri/commit/793ee0531730597e6008c9c0dedabbab7a2bef53) ([#10700](https://www.github.com/tauri-apps/tauri/pull/10700) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Allow hyphens and underscores on app identifiers. +- [`da8c9a7d3`](https://www.github.com/tauri-apps/tauri/commit/da8c9a7d3069398c26826aeb082caa44b7c92809) ([#10669](https://www.github.com/tauri-apps/tauri/pull/10669) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Synchronize Xcode project changes with the ExportOptions.plist file so `ios build` calls can work with code signing changes made in Xcode. + +### What's Changed + +- [`f4d5241b3`](https://www.github.com/tauri-apps/tauri/commit/f4d5241b377d0f7a1b58100ee19f7843384634ac) ([#10731](https://www.github.com/tauri-apps/tauri/pull/10731) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Update documentation icon path. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-rc.7` + +### Breaking Changes + +- [`da8c9a7d3`](https://www.github.com/tauri-apps/tauri/commit/da8c9a7d3069398c26826aeb082caa44b7c92809) ([#10669](https://www.github.com/tauri-apps/tauri/pull/10669) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) The `IOS_CERTIFICATE`, `IOS_CERTIFICATE_PASSWORD` and `IOS_MOBILE_PROVISION` environment variables are now read by the `ios build` command instead of `ios init`. + +## \[2.0.0-rc.6] + +### New Features + +- [`da381e07f`](https://www.github.com/tauri-apps/tauri/commit/da381e07f3770988fe6d0859a02331b87cc6723f) ([#10696](https://www.github.com/tauri-apps/tauri/pull/10696) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Inject configured resources on mobile apps. + +### Bug Fixes + +- [`1a60822a4`](https://www.github.com/tauri-apps/tauri/commit/1a60822a4220b6dbb1ad7295a2e37d6c3004edad) ([#10699](https://www.github.com/tauri-apps/tauri/pull/10699) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Changed the `add` command to use a version requirement that matches the CLI's stable and prerelease numbers. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-rc.6` + +## \[2.0.0-rc.5] + +### New Features + +- [`8d148a9e2`](https://www.github.com/tauri-apps/tauri/commit/8d148a9e2566edebfea2d75f32df7c9396d765a4) ([#10634](https://www.github.com/tauri-apps/tauri/pull/10634) by [@anatawa12](https://www.github.com/tauri-apps/tauri/../../anatawa12)) Custom sign command with object notation for whitespaces in the command path and arguments. + +### Bug Fixes + +- [`8ae52a615`](https://www.github.com/tauri-apps/tauri/commit/8ae52a615a11d934930001da63ce6ac8442c7efc) ([#10676](https://www.github.com/tauri-apps/tauri/pull/10676) by [@rdlabo](https://www.github.com/tauri-apps/tauri/../../rdlabo)) Change plugin template call to `register_ios_plugin` params to snake case +- [`7796a8fc6`](https://www.github.com/tauri-apps/tauri/commit/7796a8fc649cd7397a67048c71f8d1fbf822122a) ([#10687](https://www.github.com/tauri-apps/tauri/pull/10687) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fix Swift plugin compilation on older versions. +- [`9b99ebab1`](https://www.github.com/tauri-apps/tauri/commit/9b99ebab17d6a043d82a7aeecfb76c56a995c287) ([#10431](https://www.github.com/tauri-apps/tauri/pull/10431) by [@mrguiman](https://www.github.com/tauri-apps/tauri/../../mrguiman)) Do not include the target arch when building and archiving the iOS application, + which makes Xcode project modifications more flexible. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-rc.5` + +## \[2.0.0-rc.4] + +### New Features + +- [`78e22bedc`](https://www.github.com/tauri-apps/tauri/commit/78e22bedcab5096f1a4e667321fc8b2817b79214) ([#10602](https://www.github.com/tauri-apps/tauri/pull/10602) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Add necessary options to `AndroidManifest.xml` in android template to support AndroidTV. +- [`3bec7b159`](https://www.github.com/tauri-apps/tauri/commit/3bec7b1595e28630a22b9fb16540beafd5eb7969) ([#10544](https://www.github.com/tauri-apps/tauri/pull/10544) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) v1 migrate script now migrates Svelte and Vue.js code. + +### Enhancements + +- [`bba1a4419`](https://www.github.com/tauri-apps/tauri/commit/bba1a441917defcdf9e88221e9b0e1cdd744e77a) ([#10457](https://www.github.com/tauri-apps/tauri/pull/10457) by [@mmvanheusden](https://www.github.com/tauri-apps/tauri/../../mmvanheusden)) Added `--no-fmt` option to the `add` command to skip formatting the code after applying changes. +- [`71d00646a`](https://www.github.com/tauri-apps/tauri/commit/71d00646a9b7c52311ba087820e52fd19861b3d8) ([#10504](https://www.github.com/tauri-apps/tauri/pull/10504) by [@fu050409](https://www.github.com/tauri-apps/tauri/../../fu050409)) Improve the `init` command behavior by detecting the project NPM package manager. +- [`8deb1966a`](https://www.github.com/tauri-apps/tauri/commit/8deb1966ace93d1350f271d525a878ba4b0879ce) ([#10652](https://www.github.com/tauri-apps/tauri/pull/10652) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Infer macOS codesign identity from the `APPLE_CERTIFICATE` environment variable when provided, meaning the identity no longer needs to be provided when signing on CI using that option. If the imported certificate name does not match a provided signingIdentity configuration, an error is returned. +- [`f35bcda28`](https://www.github.com/tauri-apps/tauri/commit/f35bcda2895a1350df31853da76a051783b9fd3f) ([#10598](https://www.github.com/tauri-apps/tauri/pull/10598) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) `permission add` and `add` commands now check if the plugin is known and if it is either desktop or mobile only + we add the permission to a target-specific capability. + +### Bug Fixes + +- [`f712f31d1`](https://www.github.com/tauri-apps/tauri/commit/f712f31d1d21e85fab99194530702c70e45c63fc) ([#10639](https://www.github.com/tauri-apps/tauri/pull/10639) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Include notarization error output in the error message if it fails. +- [`9f75d0622`](https://www.github.com/tauri-apps/tauri/commit/9f75d06228fcb7036cf7a4e215abc7bc8d1a0a56) ([#10604](https://www.github.com/tauri-apps/tauri/pull/10604) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fixes `android dev` port forward failing under some conditions, add better logging and error handling. +- [`2d47352a0`](https://www.github.com/tauri-apps/tauri/commit/2d47352a07a7d742e62291a5e6810aed79fc8b50) ([#10418](https://www.github.com/tauri-apps/tauri/pull/10418) by [@samkearney](https://www.github.com/tauri-apps/tauri/../../samkearney)) CLI commands will now consistently search for the `app_dir` (the directory containing `package.json`) from the current working directory of the command invocation. +- [`f4cd68f04`](https://www.github.com/tauri-apps/tauri/commit/f4cd68f040635f019ff989667289cfe9061c7dfb) ([#10600](https://www.github.com/tauri-apps/tauri/pull/10600) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fixes `android dev` not working when using the builtin dev server. +- [`41c7a6646`](https://www.github.com/tauri-apps/tauri/commit/41c7a6646ba9afbb2322986fb39054a43a88e604) ([#10572](https://www.github.com/tauri-apps/tauri/pull/10572) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Exit with code 1 if a panic occurs when running the CLI with `bun`. +- [`9089d9763`](https://www.github.com/tauri-apps/tauri/commit/9089d97637e49bebbe7dba8adc6351e04b53a44d) ([#10605](https://www.github.com/tauri-apps/tauri/pull/10605) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fixes `[android|ios] build --config ` failing to resolve. +- [`712f1049f`](https://www.github.com/tauri-apps/tauri/commit/712f1049fae74bfda5f360adcee7210cea92fe63) ([#10569](https://www.github.com/tauri-apps/tauri/pull/10569) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fixes running `ios dev` and `ios build` using `bun`. +- [`3998570fd`](https://www.github.com/tauri-apps/tauri/commit/3998570fd3d03c1bb282bd060a4aafb4ab5437f9) ([#10540](https://www.github.com/tauri-apps/tauri/pull/10540) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fixes v1 migration of Cargo.toml dependencies and features. +- [`3beba92b5`](https://www.github.com/tauri-apps/tauri/commit/3beba92b5bdc62ed00c9f6a9b8f8c05cfa78f8dc) ([#10542](https://www.github.com/tauri-apps/tauri/pull/10542) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fixes v1 frontend code migration when using plugin default imports. +- [`10fb027b7`](https://www.github.com/tauri-apps/tauri/commit/10fb027b7590cf2c020b5c220328b9051c05adca) ([#10656](https://www.github.com/tauri-apps/tauri/pull/10656) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Migrate v1 plugins to their v2 releases. +- [`10fb027b7`](https://www.github.com/tauri-apps/tauri/commit/10fb027b7590cf2c020b5c220328b9051c05adca) ([#10656](https://www.github.com/tauri-apps/tauri/pull/10656) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Prevent duplicate permissions on v1 migration. +- [`b160f9359`](https://www.github.com/tauri-apps/tauri/commit/b160f9359d6f661d280185d2a2a4bdf280b8e72c) ([#10638](https://www.github.com/tauri-apps/tauri/pull/10638) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Only validate the output iOS library on debug builds. +- [`4bfe4880f`](https://www.github.com/tauri-apps/tauri/commit/4bfe4880fbef42d1a115f840e712d4a2f59c8ab3) ([#10550](https://www.github.com/tauri-apps/tauri/pull/10550) by [@anatawa12](https://www.github.com/tauri-apps/tauri/../../anatawa12)) fails to build universal fat binary if main bin is renamed to another name in `Cargo.toml` +- [`f3837d5b9`](https://www.github.com/tauri-apps/tauri/commit/f3837d5b98f0caebc3337f9a9e8127e7b96c3fc5) ([#10539](https://www.github.com/tauri-apps/tauri/pull/10539) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Improve migration tooling by supporting TOML configs, handle nulls and properly check for updater migration. + +### What's Changed + +- [`794cf8234`](https://www.github.com/tauri-apps/tauri/commit/794cf8234f8b620c74cbd23cc4b81be9b2edc386) ([#10571](https://www.github.com/tauri-apps/tauri/pull/10571) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Change iOS template default export method from deprecated `development` to `debugging`. +- [`bfc49cc7a`](https://www.github.com/tauri-apps/tauri/commit/bfc49cc7a1d43e3378e93865b9b37ce4bddfa6e6) ([#10558](https://www.github.com/tauri-apps/tauri/pull/10558) by [@ahqsoftwares](https://www.github.com/tauri-apps/tauri/../../ahqsoftwares)) Remove targetSdk from gradle files + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-rc.4` + +## \[2.0.0-rc.3] + +### Enhancements + +- [`5f56cb0a8`](https://www.github.com/tauri-apps/tauri/commit/5f56cb0a8b9c6f695bc6439a8db997c98b3a3997) ([#10507](https://www.github.com/tauri-apps/tauri/pull/10507) by [@FabianLars](https://www.github.com/tauri-apps/tauri/../../FabianLars)) Update gradle to 8.9 and the gradle android plugin to 8.5.1 in the android templates (requires latest Android Studio). This should add support for Java 21 but Java 17 keeps being the recommended version. + +### Bug Fixes + +- [`f5dfc0280`](https://www.github.com/tauri-apps/tauri/commit/f5dfc02800dbd3bdee671b032454c49ac7102fb4) ([#10533](https://www.github.com/tauri-apps/tauri/pull/10533) by [@FabianLars](https://www.github.com/tauri-apps/tauri/../../FabianLars)) Fixed an issue causing `tauri ios init` to fail if `iOS.minimumSystemVersion` was not configured explicitly. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-rc.3` + +## \[2.0.0-rc.2] + +### New Features + +- [`8dc81b6cc`](https://www.github.com/tauri-apps/tauri/commit/8dc81b6cc2b8235b11f74a971d6aa3a5df5e9f68) ([#10496](https://www.github.com/tauri-apps/tauri/pull/10496) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Added `bundle > ios > template` configuration option for custom Xcode project YML Handlebars template using XcodeGen. +- [`02c00abc6`](https://www.github.com/tauri-apps/tauri/commit/02c00abc63cf86e9bf9179cbb143d5145a9397b6) ([#10495](https://www.github.com/tauri-apps/tauri/pull/10495) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Added `bundle > ios > minimumSystemVersion` configuration option. + +### Enhancements + +- [`8e1e15304`](https://www.github.com/tauri-apps/tauri/commit/8e1e15304e9dc98d7f875fc8dceb7d4ce19adc47) ([#10483](https://www.github.com/tauri-apps/tauri/pull/10483) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Check if the Rust library contains the symbols required at runtime for Android and iOS apps. +- [`ca6868956`](https://www.github.com/tauri-apps/tauri/commit/ca68689564cbc8dfa9a5220d3daf81a44ef81fcc) ([#10479](https://www.github.com/tauri-apps/tauri/pull/10479) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Check if identifier or lib name changed when running mobile commands. + +### Bug Fixes + +- [`2e8ab7bac`](https://www.github.com/tauri-apps/tauri/commit/2e8ab7bac12046d734fb07a1b4fe5e03004b305e) ([#10481](https://www.github.com/tauri-apps/tauri/pull/10481) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Migration from v1 to v2 now adds the updater plugin when it is active. + +### What's Changed + +- [`a3cd9779a`](https://www.github.com/tauri-apps/tauri/commit/a3cd9779a47428e306a628d658740669faf69ccd) ([#10480](https://www.github.com/tauri-apps/tauri/pull/10480) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Removed the `[android|ios] open` command. It is recommended to use `[android|ios] dev --open` or `[android|ios] build --open` instead. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-rc.2` + +## \[2.0.0-rc.1] + +### Bug Fixes + +- [`fb1933f17`](https://www.github.com/tauri-apps/tauri/commit/fb1933f17442674e53374578e57a8cad241ac3c6) ([#10467](https://www.github.com/tauri-apps/tauri/pull/10467) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fixes running `android dev --open`. +- [`206914fe8`](https://www.github.com/tauri-apps/tauri/commit/206914fe8d97eb61a2ff2a80e94e65e7a42bcea5) ([#10466](https://www.github.com/tauri-apps/tauri/pull/10466) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Fixes running `adb reverse` in Node.js context. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-rc.1` + +## \[2.0.0-rc.0] + +### New Features + +- [`d5511c311`](https://www.github.com/tauri-apps/tauri/commit/d5511c3117b1a117cb0b7359c5fa09aa4795122b) ([#10395](https://www.github.com/tauri-apps/tauri/pull/10395)) Added migration from `2.0.0-beta` to `2.0.0-rc`. +- [`a5bfbaa62`](https://www.github.com/tauri-apps/tauri/commit/a5bfbaa62b8cd0aacbb33f730d4e30b43c461fe1)([#9962](https://www.github.com/tauri-apps/tauri/pull/9962)) Added `bundle > iOS > frameworks` configuration to define a list of frameworks that are linked to the Xcode project when it is generated. + +### Enhancements + +- [`a0841d509`](https://www.github.com/tauri-apps/tauri/commit/a0841d509abc43b62bb7c755e8727f3f461862d1) ([#10421](https://www.github.com/tauri-apps/tauri/pull/10421)) Changes the default behavior of the `dev` command to only expose to localhost (`127.0.0.1`) instead of the default system interface. + +### Security fixes + +- [`289ae5555`](https://www.github.com/tauri-apps/tauri/commit/289ae5555da3802741018015bfe4927729a2eb33) ([#10386](https://www.github.com/tauri-apps/tauri/pull/10386)) Re-enable TLS checks that were previously disabled to support an insecure HTTPS custom protocol on Android which is no longer used. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-rc.0` + +### Breaking Changes + +- [`758d28c8a`](https://www.github.com/tauri-apps/tauri/commit/758d28c8a2d5c9567158e339326b765f72da983e) ([#10390](https://www.github.com/tauri-apps/tauri/pull/10390)) Core plugin permissions are now prefixed with `core:`, the `core:default` permission set can now be used and the `core` plugin name is reserved. + The `tauri migrate` tool will automate the migration process, which involves prefixing all `app`, `event`, `image`, `menu`, `path`, `resources`, `tray`, `webview` and `window` permissions with `core:`. +- [`7ba67b4ac`](https://www.github.com/tauri-apps/tauri/commit/7ba67b4aca8d3f3b1aa5ad08819605029d36e6b4)([#10437](https://www.github.com/tauri-apps/tauri/pull/10437)) `ios dev` and `android dev` now uses localhost for the development server unless running on an iOS device, + which still requires connecting to the public network address. To conditionally check this on your frontend + framework's configuration you can check for the existence of the `TAURI_DEV_HOST` + environment variable instead of checking if the target is iOS or Android (previous recommendation). + +## \[2.0.0-beta.23] + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.23` + +## \[2.0.0-beta.22] + +### New Features + +- [`7c7fa0964`](https://www.github.com/tauri-apps/tauri/commit/7c7fa0964db3403037fdb9a34de2b877ddb8df1c) ([#9963](https://www.github.com/tauri-apps/tauri/pull/9963) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Added `--method` argument for `ios build` to select the export options' method. +- [`7c7fa0964`](https://www.github.com/tauri-apps/tauri/commit/7c7fa0964db3403037fdb9a34de2b877ddb8df1c) ([#9963](https://www.github.com/tauri-apps/tauri/pull/9963) by [@lucasfernog](https://www.github.com/tauri-apps/tauri/../../lucasfernog)) Setup iOS signing by reading `IOS_CERTIFICATE`, `IOS_CERTIFICATE_PASSWORD` and `IOS_MOBILE_PROVISION` environment variables. + +### Enhancements + +- [`c01e87ad4`](https://www.github.com/tauri-apps/tauri/commit/c01e87ad46e2a5b3fb8d018739e724ef932008d7) ([#10198](https://www.github.com/tauri-apps/tauri/pull/10198) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Enhance `tauri migrate` to also migrate variables like `appWindow`: + + ```ts + import { appWindow } from '@tauri-apps/api/window' + ``` + + will become: + + ```ts + import { getCurrentWebviewWindow } from '@tauri-apps/api/webviewWindow' + const appWindow = getCurrentWebviewWindow() + ``` + +### Bug Fixes + +- [`94136578b`](https://www.github.com/tauri-apps/tauri/commit/94136578bc89e4b973c471050ae9c2d83ffcb7c6) ([#10186](https://www.github.com/tauri-apps/tauri/pull/10186) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Fix `migrate` command, migrating incorrect permissions for `clipboard`. +- [`c01e87ad4`](https://www.github.com/tauri-apps/tauri/commit/c01e87ad46e2a5b3fb8d018739e724ef932008d7) ([#10198](https://www.github.com/tauri-apps/tauri/pull/10198) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Fix `tauri migrate` incorrectly migrating `@tauri-apps/api/tauri` module to just `core` and `@tauri-apps/api/window` to just `webviewWindow`. +- [`15e125996`](https://www.github.com/tauri-apps/tauri/commit/15e12599667b749c3d7cd2259e6cf7c7b5c6e2be) ([#10234](https://www.github.com/tauri-apps/tauri/pull/10234) by [@amrbashir](https://www.github.com/tauri-apps/tauri/../../amrbashir)) Fix cli failing to detect the correct cargo target directory when using cargo `--target-dir` flag with `tauri build` or `tauri dev` + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.22` + +## \[2.0.0-beta.21] + +### New Features + +- [`656a64974`](https://www.github.com/tauri-apps/tauri/commit/656a64974468bc207bf39537e02ae179bdee9b83) ([#9318](https://www.github.com/tauri-apps/tauri/pull/9318)) Added a configuration option to disable hardened runtime on macOS codesign. + +### Enhancements + +- [`f44a2ec47`](https://www.github.com/tauri-apps/tauri/commit/f44a2ec47c13243d472fa08a9df8b20d8490d79f) ([#10030](https://www.github.com/tauri-apps/tauri/pull/10030)) Enhance the plugin template to include `permissions/default.toml` and default capabilities file for the example application. + +### Bug Fixes + +- [`019a74e97`](https://www.github.com/tauri-apps/tauri/commit/019a74e970958d29cf69a6f24669d603399dcbb3) ([#9931](https://www.github.com/tauri-apps/tauri/pull/9931)) Fix wrong migration of `clipboard` and `globalShortcut` modules +- [`27838365a`](https://www.github.com/tauri-apps/tauri/commit/27838365a6841b0d3fa645ba2528221d23d4aeb2) ([#10135](https://www.github.com/tauri-apps/tauri/pull/10135)) Fix parsing of cargo profile when using `--profile=` syntax. +- [`79542f4d4`](https://www.github.com/tauri-apps/tauri/commit/79542f4d4542bd97451da7605de16e8464d6a06c) ([#10039](https://www.github.com/tauri-apps/tauri/pull/10039)) Fixed an issue that prevented `tauri icon` from rendering `` nodes in SVG files. +- [`40c0f44e1`](https://www.github.com/tauri-apps/tauri/commit/40c0f44e1c74c18ed0d6c645724d650637725456) ([#9971](https://www.github.com/tauri-apps/tauri/pull/9971)) Changed the deployment target of plugin iOS Xcode project to 13.0 so it works on older iOS releases. +- [`f56cdc9e3`](https://www.github.com/tauri-apps/tauri/commit/f56cdc9e391c4d55e4d7e935203d0f891864f22d) ([#10016](https://www.github.com/tauri-apps/tauri/pull/10016)) Add missing dependency `libayatana-appindicator3.so.1` for rpm package. +- [`1601da5b5`](https://www.github.com/tauri-apps/tauri/commit/1601da5b525de05cb813002d611f22ea4217a4fb) ([#10114](https://www.github.com/tauri-apps/tauri/pull/10114)) Removed alpha channel from default icons in iOS template to comply with Apple's human interface guideline + (https://developer.apple.com/design/human-interface-guidelines/app-icons), because + transparent icons with alpha channel are not allowed, and will be rejected + upon upload to Apple appstore. + +### What's Changed + +- [`3cca5c2be`](https://www.github.com/tauri-apps/tauri/commit/3cca5c2be88bbd52139e7dda371e88510d28bc8e) ([#9924](https://www.github.com/tauri-apps/tauri/pull/9924)) Migrate to new Android buildFeatures.buildConfig format. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.21` +- [`f955f7b49`](https://www.github.com/tauri-apps/tauri/commit/f955f7b4903bcea376c0a8b430736f66c8cebf56) ([#9929](https://www.github.com/tauri-apps/tauri/pull/9929)) Switch from `dirs_next` to `dirs` as `dirs_next` is now unmaintained while `dirs` is + +### Breaking Changes + +- [`911242f09`](https://www.github.com/tauri-apps/tauri/commit/911242f0928e0a2add3595fa9de27850fb875fa6) ([#9883](https://www.github.com/tauri-apps/tauri/pull/9883)) Move updater target from `bundle > targets` to a separate field `bundle > createUpdaterArtifacts` + +## \[2.0.0-beta.20] + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.20` + +## \[2.0.0-beta.19] + +### New Features + +- [`8a1ae2dea`](https://www.github.com/tauri-apps/tauri/commit/8a1ae2deaf3086e531ada25b1627f900e2e421fb)([#9843](https://www.github.com/tauri-apps/tauri/pull/9843)) Added an option to use a Xcode project for the iOS plugin instead of a plain SwiftPM project. +- [`9e4b2253f`](https://www.github.com/tauri-apps/tauri/commit/9e4b2253f6ddaccd0f5c88734287bd5c84d4936a)([#9734](https://www.github.com/tauri-apps/tauri/pull/9734)) Add `tauri bundle` subcommand which runs the bundle phase only, best paired with `tauri build --no-bundle` + +### Enhancements + +- [`8b032c3cf`](https://www.github.com/tauri-apps/tauri/commit/8b032c3cf638e64e50df9d9cf8bc789c7e285987)([#9896](https://www.github.com/tauri-apps/tauri/pull/9896)) Add a blank LaunchScreen.storyboard to the iOS project init template to pass the App Store validation. +- [`9970d88be`](https://www.github.com/tauri-apps/tauri/commit/9970d88becee1560a4b2a7ffc1fe65991a42a8c9)([#9892](https://www.github.com/tauri-apps/tauri/pull/9892)) Update to latest gradle. + +### What's Changed + +- [`80aa50498`](https://www.github.com/tauri-apps/tauri/commit/80aa504987dd9cfa59aa5848c4d7960e1d58d0e6)([#9870](https://www.github.com/tauri-apps/tauri/pull/9870)) Updated Android target SDK to 34. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.19` + +### Breaking Changes + +- [`265c23886`](https://www.github.com/tauri-apps/tauri/commit/265c23886ee5efbcc6d7188ff5c84cb32fa82aea)([#9375](https://www.github.com/tauri-apps/tauri/pull/9375)) Avoid renaming main binary to product name and perserve the name generated by cargo. +- [`1df5cdeb0`](https://www.github.com/tauri-apps/tauri/commit/1df5cdeb06f5464e0eec4055e21b7b7bc8739eed)([#9858](https://www.github.com/tauri-apps/tauri/pull/9858)) Use `tauri.conf.json > identifier` to set the `PackageName` in Android and `BundleId` in iOS. + +## \[2.0.0-beta.18] + +### Bug Fixes + +- [`beda18bce`](https://www.github.com/tauri-apps/tauri/commit/beda18bce95fd6e10543b2d8f1eca5fb7ca0655b)([#9855](https://www.github.com/tauri-apps/tauri/pull/9855)) Fixed an issue that caused `tauri add` to fail for multiple rust-only and platform-specific plugins. +- [`4a33bc6a6`](https://www.github.com/tauri-apps/tauri/commit/4a33bc6a62d2ed9371191c8a7f78ff3f33930455)([#9553](https://www.github.com/tauri-apps/tauri/pull/9553)) Fixes `pnpm` detection when initializing and running a mobile project. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.18` + +## \[2.0.0-beta.17] + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.17` + +## \[2.0.0-beta.16] + +### Bug Fixes + +- [`97ec422f2`](https://www.github.com/tauri-apps/tauri/commit/97ec422f22d069b9570931834241c7e47bc68cc3)([#9638](https://www.github.com/tauri-apps/tauri/pull/9638)) Exit `tauri icon` with non-zero code when it fails. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.16` + +## \[2.0.0-beta.15] + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.15` + +## \[2.0.0-beta.14] + +### Enhancements + +- [`8a63ceb4f`](https://www.github.com/tauri-apps/tauri/commit/8a63ceb4f31c422311b0f7dff173a9c8c0e1a604)([#9473](https://www.github.com/tauri-apps/tauri/pull/9473)) Ignore `.DS_Store` by default for `tauri dev` hot reloads. + +### Bug Fixes + +- [`e64b8f1dc`](https://www.github.com/tauri-apps/tauri/commit/e64b8f1dcedad3222f46755bf6f30392a7ec2f90)([#9479](https://www.github.com/tauri-apps/tauri/pull/9479)) Upgrade `heck` to v0.5 to better support Chinese and Japanese product name, because Chinese do not have word separation. +- [`aaa332c6e`](https://www.github.com/tauri-apps/tauri/commit/aaa332c6e78c956debd11efda021a0406621a01d)([#9540](https://www.github.com/tauri-apps/tauri/pull/9540)) Fix `tauri migrate` trying to migrate to a non-existing plugin. +- [`e64b8f1dc`](https://www.github.com/tauri-apps/tauri/commit/e64b8f1dcedad3222f46755bf6f30392a7ec2f90)([#9479](https://www.github.com/tauri-apps/tauri/pull/9479)) Fixed an issue causing the `build.runner` and `build.features` configs to not take effect. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.14` + +## \[2.0.0-beta.13] + +### Bug Fixes + +- [`73c1c2d33`](https://www.github.com/tauri-apps/tauri/commit/73c1c2d33872651c32c761c838714b684980c668)([#9457](https://www.github.com/tauri-apps/tauri/pull/9457)) Gracefully handle Non-UTF8 files when using `tauri migrate` +- [`9331435a5`](https://www.github.com/tauri-apps/tauri/commit/9331435a50cc3769720bd2671da8510699d28671)([#9412](https://www.github.com/tauri-apps/tauri/pull/9412)) Fix `tauri info` crashing when Node.js is not installed. + +### What's Changed + +- [`8f4b1050c`](https://www.github.com/tauri-apps/tauri/commit/8f4b1050c4de0e9194680408ff3a6902b67045f8)([#9459](https://www.github.com/tauri-apps/tauri/pull/9459)) Show full expected path of `frontendDist` when if can't be found. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.13` + +## \[2.0.0-beta.12] + +### New Features + +- [`93e0e1392`](https://www.github.com/tauri-apps/tauri/commit/93e0e1392ec341fcadf696c03e78f0ca1e73c941) Support specifying a version for `tauri add` subcommand, for example: `tauri add window-state@2.0.0-beta.2` + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.12` + +## \[2.0.0-beta.11] + +### Enhancements + +- [`ac76a22f3`](https://www.github.com/tauri-apps/tauri/commit/ac76a22f383028d9bacdedebeb41d3fca5ec9dac)([#9183](https://www.github.com/tauri-apps/tauri/pull/9183)) Allow empty responses for `devUrl`, `beforeDevCommand` and `beforeBuildCommands` questions in `tauri init`. +- [`b525ddadf`](https://www.github.com/tauri-apps/tauri/commit/b525ddadf7e7588c3e195cf0f821c9862c545d06)([#9237](https://www.github.com/tauri-apps/tauri/pull/9237)) `openssl` is no longer a required dependency on macOS. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.11` + +## \[2.0.0-beta.10] + +### New Features + +- [`7213b9e47`](https://www.github.com/tauri-apps/tauri/commit/7213b9e47242bef814aa7257e0bf84631bf5fe7e)([#9124](https://www.github.com/tauri-apps/tauri/pull/9124)) Add default permission for a plugin to capabilities when using `tauri add `. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.10` + +## \[2.0.0-beta.9] + +### Bug Fixes + +- [`c3ea3a2b7`](https://www.github.com/tauri-apps/tauri/commit/c3ea3a2b7d2fe3085f05b63dd1feb962beb4b7b3)([#9126](https://www.github.com/tauri-apps/tauri/pull/9126)) Fix bundling when `plugins > updater > windows > installerArgs` are set in `tauri.conf.json` + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.9` + +## \[2.0.0-beta.8] + +### Enhancements + +- [`3e472d0af`](https://www.github.com/tauri-apps/tauri/commit/3e472d0afcd67545dd6d9f18d304580a3b2759a8)([#9115](https://www.github.com/tauri-apps/tauri/pull/9115)) Changed the permission and capability platforms to be optional. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.8` + +## \[2.0.0-beta.7] + +### Enhancements + +- [`c68218b36`](https://www.github.com/tauri-apps/tauri/commit/c68218b362c417b62e56c7a2b5b32c13fe035a83)([#8990](https://www.github.com/tauri-apps/tauri/pull/8990)) Add `--no-bundle` flag for `tauri build` command to skip bundling. Previously `none` was used to skip bundling, it will now be treated as invalid format and a warning will be emitted instead. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.7` + +## \[2.0.0-beta.6] + +### Bug Fixes + +- [`f5f3ed5f`](https://www.github.com/tauri-apps/tauri/commit/f5f3ed5f6faa0b51e83244acc15e9006299a03ba)([#9009](https://www.github.com/tauri-apps/tauri/pull/9009)) Fixes Android and iOS project initialization when the Tauri CLI is on a different disk partition. +- [`d7d03c71`](https://www.github.com/tauri-apps/tauri/commit/d7d03c7197212f3a5bebe08c929417d60927eb89)([#9017](https://www.github.com/tauri-apps/tauri/pull/9017)) Fixes dev watcher on mobile dev. +- [`b658ded6`](https://www.github.com/tauri-apps/tauri/commit/b658ded614cfc169228cb22ad5bfc64478dfe161)([#9015](https://www.github.com/tauri-apps/tauri/pull/9015)) Fixes truncation of existing BuildTask.kt when running `tauri android init`. + +### What's Changed + +- [`3657ad82`](https://www.github.com/tauri-apps/tauri/commit/3657ad82f88ce528551d032d521c52eed3f396b4)([#9008](https://www.github.com/tauri-apps/tauri/pull/9008)) Updates to new ACL manifest path. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.6` + +## \[2.0.0-beta.5] + +### New Features + +- [`06d63d67`](https://www.github.com/tauri-apps/tauri/commit/06d63d67a061459dd533ddcae755922427a6dfc5)([#8827](https://www.github.com/tauri-apps/tauri/pull/8827)) Add new subcommands for managing permissions and cababilities: + + - `tauri permission new` + - `tauri permission add` + - `tauri permission rm` + - `tauri permission ls` + - `tauri capability new` + +### Breaking Changes + +- [`b9e6a018`](https://www.github.com/tauri-apps/tauri/commit/b9e6a01879d9233040f3d3fab11c59e70563da7e)([#8937](https://www.github.com/tauri-apps/tauri/pull/8937)) The `custom-protocol` Cargo feature is no longer required on your application and is now ignored. To check if running on production, use `#[cfg(not(dev))]` instead of `#[cfg(feature = "custom-protocol")]`. + +### Enhancements + +- [`9be314f0`](https://www.github.com/tauri-apps/tauri/commit/9be314f07a4ca5d14433d41919492f3e91b5536a)([#8951](https://www.github.com/tauri-apps/tauri/pull/8951)) Add plugins to `Cargo.toml` when using `tauri migrate` + +### Bug Fixes + +- [`cbd9755e`](https://www.github.com/tauri-apps/tauri/commit/cbd9755e0926a7e47e59deb50f4bb93d621791a5)([#8977](https://www.github.com/tauri-apps/tauri/pull/8977)) Fixes process logs not showing on `ios dev`. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.5` + +## \[2.0.0-beta.4] + +### Bug Fixes + +- [`e538ba58`](https://www.github.com/tauri-apps/tauri/commit/e538ba586c5b8b50955586c8ef2704adb5d7cc43)([#8949](https://www.github.com/tauri-apps/tauri/pull/8949)) Fixes android and iOS process spawning not working on Node.js. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.4` + +### Breaking Changes + +- [`a76fb118`](https://www.github.com/tauri-apps/tauri/commit/a76fb118ce2de22e1bdb4216bf0ac01dfc3e5799)([#8950](https://www.github.com/tauri-apps/tauri/pull/8950)) Changed the capability format to allow configuring both `remote: { urls: Vec }` and `local: bool (default: true)` instead of choosing one on the `context` field. + +## \[2.0.0-beta.3] + +### Enhancements + +- [`a029b9f7`](https://www.github.com/tauri-apps/tauri/commit/a029b9f77e432533a403c292940fa3efba68692c)([#8910](https://www.github.com/tauri-apps/tauri/pull/8910)) Setting up code signing is no longer required on iOS when using the simulator. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.3` + +## \[2.0.0-beta.2] + +### Enhancements + +- [`83a68deb`](https://www.github.com/tauri-apps/tauri/commit/83a68deb5676d39cd4728d2e140f6b46d5f787ed)([#8797](https://www.github.com/tauri-apps/tauri/pull/8797)) Update app template following capabilities configuration change. + +### Bug Fixes + +- [`aa06a053`](https://www.github.com/tauri-apps/tauri/commit/aa06a0534cf224038866e0ddd6910ea873b2574d)([#8810](https://www.github.com/tauri-apps/tauri/pull/8810)) Fix `tauri plugin android init` printing invalid code that has a missing closing `"`. +- [`3cee26a5`](https://www.github.com/tauri-apps/tauri/commit/3cee26a58ab44639a12c7816f4096655daa327a4)([#8865](https://www.github.com/tauri-apps/tauri/pull/8865)) On Windows, fixed `tauri info` fails to detect the build tool when the system language is CJK. +- [`052e8b43`](https://www.github.com/tauri-apps/tauri/commit/052e8b4311d9f0f963a2866163be27bfd8f70c60)([#8838](https://www.github.com/tauri-apps/tauri/pull/8838)) Downgrade minisign dependency fixing updater signing key bug and prevent it from happening in the future. +- [`fb0d9971`](https://www.github.com/tauri-apps/tauri/commit/fb0d997117367e3387896bcd0fba004579475c40)([#8783](https://www.github.com/tauri-apps/tauri/pull/8783)) Fixes a regression on the `--config` argument not accepting file paths. +- [`baca704d`](https://www.github.com/tauri-apps/tauri/commit/baca704d4b5fae239fc320d10140f35bd705bfbb)([#8768](https://www.github.com/tauri-apps/tauri/pull/8768)) Do not migrate updater configuration if the active flag is set to false. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.2` + +## \[2.0.0-beta.1] + +### Enhancements + +- [`4e101f80`](https://www.github.com/tauri-apps/tauri/commit/4e101f801657e7d01ce8c22f9c6468067d0caab2)([#8756](https://www.github.com/tauri-apps/tauri/pull/8756)) Moved the capability JSON schema to the `src-tauri/gen` folder so it's easier to track changes on the `capabilities` folder. +- [`4e101f80`](https://www.github.com/tauri-apps/tauri/commit/4e101f801657e7d01ce8c22f9c6468067d0caab2)([#8756](https://www.github.com/tauri-apps/tauri/pull/8756)) Update app and plugin templates following generated files change from tauri-build and tauri-plugin. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.1` + +## \[2.0.0-beta.0] + +### New Features + +- [`7fcc0bcd`](https://www.github.com/tauri-apps/tauri/commit/7fcc0bcd3482bbc8771e330942ef6cd78cc8ec35)([#8490](https://www.github.com/tauri-apps/tauri/pull/8490)) Add plugin initialization rust code when using `tauri add` +- [`1878766f`](https://www.github.com/tauri-apps/tauri/commit/1878766f7f81a03b0f0b87ec33ee113d7aa7a902)([#8667](https://www.github.com/tauri-apps/tauri/pull/8667)) Migrate the allowlist config to the new capability file format. + +### Enhancements + +- [`d6c7568c`](https://www.github.com/tauri-apps/tauri/commit/d6c7568c27445653edf570f3969163bc358ba2ba)([#8720](https://www.github.com/tauri-apps/tauri/pull/8720)) Add `files` option to the AppImage Configuration. +- [`b3209bb2`](https://www.github.com/tauri-apps/tauri/commit/b3209bb28bb379d5046d577c7e42319d6e76ced0)([#8688](https://www.github.com/tauri-apps/tauri/pull/8688)) Ignore global `.gitignore` when searching for tauri directory. +- [`e691208e`](https://www.github.com/tauri-apps/tauri/commit/e691208e7b39bb8e3ffc9bf66cff731a5025ef16)([#7837](https://www.github.com/tauri-apps/tauri/pull/7837)) Prevent unneeded double Cargo.toml rewrite on `dev` and `build`. +- [`f492efd7`](https://www.github.com/tauri-apps/tauri/commit/f492efd7144fdd8d25cac0c4d2389a95ab75fb02)([#8666](https://www.github.com/tauri-apps/tauri/pull/8666)) Update app and plugin template following the new access control permission model. + +### Bug Fixes + +- [`9cb9aa79`](https://www.github.com/tauri-apps/tauri/commit/9cb9aa7978f231f7da238b33d6ab33fdd2d2c842)([#8672](https://www.github.com/tauri-apps/tauri/pull/8672)) Allow license field in Cargo.toml to be `{ workspace = true }` + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-beta.0` + +### Breaking Changes + +- [`8de308d1`](https://www.github.com/tauri-apps/tauri/commit/8de308d1bf6a855d7a26af58bd0e744938ba47d8)([#8723](https://www.github.com/tauri-apps/tauri/pull/8723)) Restructured Tauri config per [RFC#5](https://github.com/tauri-apps/rfcs/blob/f3e82a6b0c5390401e855850d47dc7b7d9afd684/texts/0005-tauri-config-restructure.md): + + - Moved `package.productName`, `package.version` and `tauri.bundle.identifier` fields to the top-level. + - Removed `package` object. + - Renamed `tauri` object to `app`. + - Moved `tauri.bundle` object to the top-level. + - Renamed `build.distDir` field to `frontendDist`. + - Renamed `build.devPath` field to `devUrl` and will no longer accepts paths, it will only accept URLs. + - Moved `tauri.pattern` to `app.security.pattern`. + - Removed `tauri.bundle.updater` object, and its fields have been moved to the updater plugin under `plugins.updater` object. + - Moved `build.withGlobalTauri` to `app.withGlobalTauri`. + - Moved `tauri.bundle.dmg` object to `bundle.macOS.dmg`. + - Moved `tauri.bundle.deb` object to `bundle.linux.deb`. + - Moved `tauri.bundle.appimage` object to `bundle.linux.appimage`. + - Removed all license fields from each bundle configuration object and instead added `bundle.license` and `bundle.licenseFile`. + - Renamed `AppUrl` to `FrontendDist` and refactored its variants to be more explicit. + +## \[2.0.0-alpha.21] + +### New Features + +- [`27bad32d`](https://www.github.com/tauri-apps/tauri/commit/27bad32d4d4acca8155b20225d529d540fb9aaf4)([#7798](https://www.github.com/tauri-apps/tauri/pull/7798)) Add `files` object on the `tauri > bundle > macOS` configuration option. +- [`0ec28c39`](https://www.github.com/tauri-apps/tauri/commit/0ec28c39f478de7199a66dd75e8642e1aa1344e6)([#8529](https://www.github.com/tauri-apps/tauri/pull/8529)) Include tauri-build on the migration script. + +### Enhancements + +- [`091100ac`](https://www.github.com/tauri-apps/tauri/commit/091100acbb507b51de39fb1446f685926f888fd2)([#5202](https://www.github.com/tauri-apps/tauri/pull/5202)) Add RPM packaging + +### Bug Fixes + +- [`4f73057e`](https://www.github.com/tauri-apps/tauri/commit/4f73057e6fd4c137bc112367fb91f5fc0c8a39f6)([#8486](https://www.github.com/tauri-apps/tauri/pull/8486)) Prevent `Invalid target triple` warnings and correctly set `TAURI_ENV_` vars when target triple contains 4 components. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-alpha.21` + +### Breaking Changes + +- [`4f73057e`](https://www.github.com/tauri-apps/tauri/commit/4f73057e6fd4c137bc112367fb91f5fc0c8a39f6)([#8486](https://www.github.com/tauri-apps/tauri/pull/8486)) Removed `TAURI_ENV_PLATFORM_TYPE` which will not be set for CLI hook commands anymore, use `TAURI_ENV_PLATFORM` instead. Also Changed value of `TAURI_ENV_PLATFORM` and `TAURI_ENV_ARCH` values to match the target triple more accurately: + + - `darwin` and `androideabi` are no longer replaced with `macos` and `android` in `TAURI_ENV_PLATFORM`. + - `i686` and `i586` are no longer replaced with `x86` in `TAURI_ENV_ARCH`. + +## \[2.0.0-alpha.20] + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-alpha.20` + +## \[2.0.0-alpha.19] + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-alpha.19` + +## \[2.0.0-alpha.18] + +### New Features + +- [`50f7ccbb`](https://www.github.com/tauri-apps/tauri/commit/50f7ccbbf3467f33cc7dd1cca53125fec6eda1c6)([#6444](https://www.github.com/tauri-apps/tauri/pull/6444)) Add suport to SVG input image for the `tauri icon` command. +- [`25e5f91d`](https://www.github.com/tauri-apps/tauri/commit/25e5f91dae7fe2bbc1ba4317d5d829402bfd1d50)([#8200](https://www.github.com/tauri-apps/tauri/pull/8200)) Merge `src-tauri/Info.plist` and `src-tauri/Info.ios.plist` with the iOS project plist file. + +### Enhancements + +- [`01a7a983`](https://www.github.com/tauri-apps/tauri/commit/01a7a983aba2946b455a608b8a6a4b08cb25fc11)([#8128](https://www.github.com/tauri-apps/tauri/pull/8128)) Transform paths to relative to the mobile project for the IDE script runner script. + +### Bug Fixes + +- [`88dac86f`](https://www.github.com/tauri-apps/tauri/commit/88dac86f3b301d1919df6473a9e20f46b560f29b)([#8149](https://www.github.com/tauri-apps/tauri/pull/8149)) Ensure `tauri add` prints `rust_code` with plugin name in snake case. +- [`977d0e52`](https://www.github.com/tauri-apps/tauri/commit/977d0e52f14b1ad01c86371765ef25b36572459e)([#8202](https://www.github.com/tauri-apps/tauri/pull/8202)) Fixes `android build --open` and `ios build --open` IDE failing to read CLI options. +- [`bfbbefdb`](https://www.github.com/tauri-apps/tauri/commit/bfbbefdb9e13ed1f42f6db7fa9ceaa84db1267e9)([#8161](https://www.github.com/tauri-apps/tauri/pull/8161)) Fix invalid plugin template. +- [`92b50a3a`](https://www.github.com/tauri-apps/tauri/commit/92b50a3a398c9d55b6992a8f5c2571e4d72bdaaf)([#8209](https://www.github.com/tauri-apps/tauri/pull/8209)) Added support to Xcode's archive. This requires regenerating the Xcode project. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-alpha.18` + +## \[2.0.0-alpha.17] + +### Enhancements + +- [`c6c59cf2`](https://www.github.com/tauri-apps/tauri/commit/c6c59cf2373258b626b00a26f4de4331765dd487) Pull changes from Tauri 1.5 release. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-alpha.17` + +### Breaking Changes + +- [`198abe3c`](https://www.github.com/tauri-apps/tauri/commit/198abe3c2cae06dacab860b3a93f715dcf529a95)([#8076](https://www.github.com/tauri-apps/tauri/pull/8076)) Updated the mobile plugin templates following the tauri v2.0.0-alpha.17 changes. + +## \[2.0.0-alpha.16] + +### New Features + +- [`8b166e9b`](https://www.github.com/tauri-apps/tauri/commit/8b166e9bf82e69ddb3200a3a825614980bd8d433)([#7949](https://www.github.com/tauri-apps/tauri/pull/7949)) Add `--no-dev-server-wait` option to skip waiting for the dev server to start when using `tauri dev`. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-alpha.16` + +### Breaking Changes + +- [`8b166e9b`](https://www.github.com/tauri-apps/tauri/commit/8b166e9bf82e69ddb3200a3a825614980bd8d433)([#7949](https://www.github.com/tauri-apps/tauri/pull/7949)) Changed a number of environment variables used by tauri CLI for consistency and clarity: + + - `TAURI_PRIVATE_KEY` -> `TAURI_SIGNING_PRIVATE_KEY` + - `TAURI_KEY_PASSWORD` -> `TAURI_SIGNING_PRIVATE_KEY_PASSWORD` + - `TAURI_SKIP_DEVSERVER_CHECK` -> `TAURI_CLI_NO_DEV_SERVER_WAIT` + - `TAURI_DEV_SERVER_PORT` -> `TAURI_CLI_PORT` + - `TAURI_PATH_DEPTH` -> `TAURI_CLI_CONFIG_DEPTH` + - `TAURI_FIPS_COMPLIANT` -> `TAURI_BUNDLER_WIX_FIPS_COMPLIANT` + - `TAURI_DEV_WATCHER_IGNORE_FILE` -> `TAURI_CLI_WATCHER_IGNORE_FILENAME` + - `TAURI_TRAY` -> `TAURI_LINUX_AYATANA_APPINDICATOR` + - `TAURI_APPLE_DEVELOPMENT_TEAM` -> `APPLE_DEVELOPMENT_TEAM` +- [`4caa1cca`](https://www.github.com/tauri-apps/tauri/commit/4caa1cca990806f2c2ef32d5dabaf56e82f349e6)([#7990](https://www.github.com/tauri-apps/tauri/pull/7990)) The `tauri plugin` subcommand is receving a couple of consitency and quality of life improvements: + + - Renamed `tauri plugin android/ios add` command to `tauri plugin android/ios init` to match the `tauri plugin init` command. + - Removed the `-n/--name` argument from the `tauri plugin init`, `tauri plugin android/ios init`, and is now parsed from the first positional argument. + - Added `tauri plugin new` to create a plugin in a new directory. + - Changed `tauri plugin init` to initalize a plugin in an existing directory (defaults to current directory) instead of creating a new one. + - Changed `tauri plugin init` to NOT generate mobile projects by default, you can opt-in to generate them using `--android` and `--ios` flags or `--mobile` flag or initalize them later using `tauri plugin android/ios init`. +- [`8b166e9b`](https://www.github.com/tauri-apps/tauri/commit/8b166e9bf82e69ddb3200a3a825614980bd8d433)([#7949](https://www.github.com/tauri-apps/tauri/pull/7949)) Removed checking for a new version of the CLI. +- [`ebcc21e4`](https://www.github.com/tauri-apps/tauri/commit/ebcc21e4b95f4e8c27639fb1bca545b432f52d5e)([#8057](https://www.github.com/tauri-apps/tauri/pull/8057)) Renamed the beforeDevCommand, beforeBuildCommand and beforeBundleCommand hooks environment variables from `TAURI_PLATFORM, TAURI_ARCH, TAURI_FAMILY, TAURI_PLATFORM_VERSION, TAURI_PLATFORM_TYPE and TAURI_DEBUG` to `TAURI_ENV_PLATFORM, TAURI_ENV_ARCH, TAURI_ENV_FAMILY, TAURI_ENV_PLATFORM_VERSION, TAURI_ENV_PLATFORM_TYPE and TAURI_ENV_DEBUG` to differentiate the prefix with other CLI environment variables. + +## \[2.0.0-alpha.15] + +### New Features + +- [`b2f17723`](https://www.github.com/tauri-apps/tauri/commit/b2f17723a415f04c2620132a6305eb138d7cb47f)([#7971](https://www.github.com/tauri-apps/tauri/pull/7971)) Use `devicectl` to connect to iOS 17+ devices on macOS 14+. + +### Bug Fixes + +- [`100d9ede`](https://www.github.com/tauri-apps/tauri/commit/100d9ede35995d9db21d2087dd5606adfafb89a5)([#7802](https://www.github.com/tauri-apps/tauri/pull/7802)) Properly read platform-specific configuration files for mobile targets. +- [`228e5a4c`](https://www.github.com/tauri-apps/tauri/commit/228e5a4c76ad5f97409c912d07699b49ba4bb162)([#7902](https://www.github.com/tauri-apps/tauri/pull/7902)) Fixes `icon` command not writing files to the correct Android project folders. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-alpha.15` + +## \[2.0.0-alpha.14] + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-alpha.14` + +### Breaking Changes + +- [`d5074af5`](https://www.github.com/tauri-apps/tauri/commit/d5074af562b2b5cb6c5711442097c4058af32db6)([#7801](https://www.github.com/tauri-apps/tauri/pull/7801)) The custom protocol on Android now uses the `http` scheme instead of `https`. + +## \[2.0.0-alpha.13] + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-alpha.13` + +### Breaking Changes + +- [`4cb51a2d`](https://www.github.com/tauri-apps/tauri/commit/4cb51a2d56cfcae0749062c79ede5236bd8c02c2)([#7779](https://www.github.com/tauri-apps/tauri/pull/7779)) The custom protocol on Windows now uses the `http` scheme instead of `https`. +- [`974e38b4`](https://www.github.com/tauri-apps/tauri/commit/974e38b4ddc198530aa977ec77d513b76013b9f3)([#7744](https://www.github.com/tauri-apps/tauri/pull/7744)) Renamed the `plugin add` command to `add`. + +## \[2.0.0-alpha.12] + +### Bug Fixes + +- [`b75a1210`](https://www.github.com/tauri-apps/tauri/commit/b75a1210bed589187678861d7314ae6279bf7c87)([#7762](https://www.github.com/tauri-apps/tauri/pull/7762)) Fixes a regression on alpha.11 where iOS logs aren't being displayed when using `ios dev` with a real device. +- [`8faa5a4a`](https://www.github.com/tauri-apps/tauri/commit/8faa5a4a1238a44ca7b54d2084aaed553ac2a1ba)([#7765](https://www.github.com/tauri-apps/tauri/pull/7765)) Ensure asset directory exists on the iOS project. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-alpha.12` + +## \[2.0.0-alpha.11] + +### New Features + +- [`522de0e7`](https://www.github.com/tauri-apps/tauri/commit/522de0e78891d0bdf6387a5118985fc41a11baeb)([#7447](https://www.github.com/tauri-apps/tauri/pull/7447)) Expose an environment variable `TAURI_${PLUGIN_NAME}_PLUGIN_CONFIG` for each defined plugin configuration object. +- [`c7dacca4`](https://www.github.com/tauri-apps/tauri/commit/c7dacca4661c6ddf937c1a3dd3ace896d5baf40c)([#7446](https://www.github.com/tauri-apps/tauri/pull/7446)) Expose the `TAURI_IOS_PROJECT_PATH` and `TAURI_IOS_APP_NAME` environment variables when using `ios` commands. +- [`aa94f719`](https://www.github.com/tauri-apps/tauri/commit/aa94f7197e4345a7cab1617272b10895859674f9)([#7445](https://www.github.com/tauri-apps/tauri/pull/7445)) Generate empty entitlements file for the iOS project. +- [`d010bc07`](https://www.github.com/tauri-apps/tauri/commit/d010bc07b81116bef769b64cdc19b23dff762d48)([#7554](https://www.github.com/tauri-apps/tauri/pull/7554)) Set the iOS project PRODUCT_NAME value to the string under `tauri.conf.json > package > productName` if it is set. +- [`8af24974`](https://www.github.com/tauri-apps/tauri/commit/8af2497496f11ee481472dfdc3125757346c1a3e)([#7561](https://www.github.com/tauri-apps/tauri/pull/7561)) The `migrate` command now automatically reads all JavaScript files and updates `@tauri-apps/api` import paths and install the missing plugins. + +### Enhancements + +- [`fbeb5b91`](https://www.github.com/tauri-apps/tauri/commit/fbeb5b9185baeda19e865228179e3e44c165f1d9)([#7170](https://www.github.com/tauri-apps/tauri/pull/7170)) Update migrate command to update the configuration CSP to include `ipc:` on the `connect-src` directive, needed by the new IPC using custom protocols. + +### Dependencies + +- Upgraded to `tauri-cli@2.0.0-alpha.11` + +## \[2.0.0-alpha.10] + +### New Features + +- [`7e5905ae`](https://www.github.com/tauri-apps/tauri/commit/7e5905ae1d56b920de0e821be28036cbbe302518)([#7023](https://www.github.com/tauri-apps/tauri/pull/7023)) Added `tauri plugin add` command to add a plugin to the Tauri project. +- [`b0f94775`](https://www.github.com/tauri-apps/tauri/commit/b0f947752a315b7b89c5979de50157f997f1dd6e)([#7008](https://www.github.com/tauri-apps/tauri/pull/7008)) Added `migrate` command. + +### Enhancements + +- [`aa6c9164`](https://www.github.com/tauri-apps/tauri/commit/aa6c9164e63b5316d690f25b1c118f1b12310570)([#7007](https://www.github.com/tauri-apps/tauri/pull/7007)) Don't build library files when building desktop targets. +- [`a28fdf7e`](https://www.github.com/tauri-apps/tauri/commit/a28fdf7ec71bf6db2498569004de83318b6d25ac)([#7044](https://www.github.com/tauri-apps/tauri/pull/7044)) Skip Rust target installation if they are already installed. +- [`735db1ce`](https://www.github.com/tauri-apps/tauri/commit/735db1ce839a16ba998c9e6786c441e3bf6c90b3)([#7044](https://www.github.com/tauri-apps/tauri/pull/7044)) Add `--skip-targets-install` flag for `tauri android init` and `tauri ios init` to skip installing needed rust targets vie rustup. + +### Bug Fixes + +- [`1ed2600d`](https://www.github.com/tauri-apps/tauri/commit/1ed2600da67715908af857255305eaeb293d8791)([#6771](https://www.github.com/tauri-apps/tauri/pull/6771)) Set current directory to tauri directory before reading config file. +- [`4847b87b`](https://www.github.com/tauri-apps/tauri/commit/4847b87b1067dd8c6e73986059f51e6eee1f1121)([#7209](https://www.github.com/tauri-apps/tauri/pull/7209)) Fix `tauri (android|ios) (dev|build)` failing when using `npx tauri` +- [`655c714e`](https://www.github.com/tauri-apps/tauri/commit/655c714e4100f69d4265c5ea3f08f5bc11709446)([#7240](https://www.github.com/tauri-apps/tauri/pull/7240)) Fixes panic when exiting the `ios dev` command with Ctrl + C. +- [`6252380f`](https://www.github.com/tauri-apps/tauri/commit/6252380f4447c66913b0f06611e5949005b1eec2)([#7241](https://www.github.com/tauri-apps/tauri/pull/7241)) Exit `beforeDevCommand` process if the android or iOS `dev` command fails. + +## \[2.0.0-alpha.9] + +- [`19cd0e49`](https://www.github.com/tauri-apps/tauri/commit/19cd0e49603ad3500cd2180bfa16e1649e3a771a)([#6811](https://www.github.com/tauri-apps/tauri/pull/6811)) Add `key.properties` file to android's `.gitignore`. +- [`124d5c5a`](https://www.github.com/tauri-apps/tauri/commit/124d5c5adf67f0b68d2e41c7ddb07d9cb63f1996)([#6788](https://www.github.com/tauri-apps/tauri/pull/6788)) On mobile, fix regression introduced in `tauri-cli` version `2.0.0-alpha.3` where library not found error was thrown. +- [`31444ac1`](https://www.github.com/tauri-apps/tauri/commit/31444ac196add770f2ad18012d7c18bce7538f22)([#6725](https://www.github.com/tauri-apps/tauri/pull/6725)) Update mobile template to `wry@0.28` +- [`41f49aea`](https://www.github.com/tauri-apps/tauri/commit/41f49aeae646f2cb70b42002bb1371c79e592243)([#6659](https://www.github.com/tauri-apps/tauri/pull/6659)) Update tauri-mobile to fix running ADB scripts. +- [`6d1fa49f`](https://www.github.com/tauri-apps/tauri/commit/6d1fa49fce3a03965ce7c656390e682ce5b776e3)([#6881](https://www.github.com/tauri-apps/tauri/pull/6881)) Clear Android plugin JSON file before building Rust library to ensure removed plugins are propagated to the Android project. +- [`5a9307d1`](https://www.github.com/tauri-apps/tauri/commit/5a9307d11c1643221bc2a280feb00024f8fa6030)([#6890](https://www.github.com/tauri-apps/tauri/pull/6890)) Update android template to gradle 8.0 +- [`73c803a5`](https://www.github.com/tauri-apps/tauri/commit/73c803a561181137f20366f5d52511392a619f2b)([#6837](https://www.github.com/tauri-apps/tauri/pull/6837)) Inject Tauri configuration in the Android assets. +- [`e1e85dc2`](https://www.github.com/tauri-apps/tauri/commit/e1e85dc2a5f656fc37867e278cae8042037740ac)([#6925](https://www.github.com/tauri-apps/tauri/pull/6925)) Moved the updater configuration to the `BundleConfig`. +- [`d48aaa15`](https://www.github.com/tauri-apps/tauri/commit/d48aaa150a1ceeb65ec0ba18f1e3795f70c838e3)([#6894](https://www.github.com/tauri-apps/tauri/pull/6894)) Add Cargo manifest files for the plugin example templates. +- [`e1e85dc2`](https://www.github.com/tauri-apps/tauri/commit/e1e85dc2a5f656fc37867e278cae8042037740ac)([#6925](https://www.github.com/tauri-apps/tauri/pull/6925)) Removed the allowlist configuration. + +## \[2.0.0-alpha.8] + +- Do not gitignore the Android project's `buildSrc` folder by default since we removed absolute paths from it. + - [ee2d3b97](https://www.github.com/tauri-apps/tauri/commit/ee2d3b971df6d3630b8d935394fb4febcfa3a909) fix(cli): remove buildSrc from Android project gitignored paths ([#6702](https://www.github.com/tauri-apps/tauri/pull/6702)) on 2023-04-13 +- Fixes iOS build script using the wrong path for the app library file. + - [abc5f91f](https://www.github.com/tauri-apps/tauri/commit/abc5f91fa3569efc9dfdee46d1c501eda8755944) fix(cli): iOS Xcode script using incorrect library path ([#6699](https://www.github.com/tauri-apps/tauri/pull/6699)) on 2023-04-13 + +## \[2.0.0-alpha.7] + +- Add `--release` flag for `tauri android dev` however you will need to sign your Android app, see https://next--tauri.netlify.app/next/guides/distribution/sign-android + - [63f088e5](https://www.github.com/tauri-apps/tauri/commit/63f088e5fc9701fd7fb329dad7ffb27a2d8fd5aa) feat(cli): add `--release` for `android dev` ([#6638](https://www.github.com/tauri-apps/tauri/pull/6638)) on 2023-04-05 +- Build only specified rust targets for `tauri android build` instead of all. + - [d03e47d1](https://www.github.com/tauri-apps/tauri/commit/d03e47d141c3917520975be9081775dbc4e9d4fd) fix: only build specified rust targets for aab/apk build ([#6625](https://www.github.com/tauri-apps/tauri/pull/6625)) on 2023-04-05 +- Use local ip address for built-in dev server on mobile. + - [7fec0f08](https://www.github.com/tauri-apps/tauri/commit/7fec0f083c932dc63ccb8716080d97e2ab985b25) fix(cli): use local ip addr for built-in server on mobile, closes [#6454](https://www.github.com/tauri-apps/tauri/pull/6454) ([#6631](https://www.github.com/tauri-apps/tauri/pull/6631)) on 2023-04-04 +- Readd the Cargo.toml file to the plugin template. + - [5288a386](https://www.github.com/tauri-apps/tauri/commit/5288a386f1bf8ac11f991350463c3f5c20983f43) fix(cli): readd Cargo.toml to the plugin template ([#6637](https://www.github.com/tauri-apps/tauri/pull/6637)) on 2023-04-04 + +## \[2.0.0-alpha.6] + +- Use Ubuntu 20.04 to compile the CLI, increasing the minimum libc version required. +- Automatically enable the `rustls-tls` tauri feature on mobile and `native-tls` on desktop if `rustls-tls` is not enabled. + - [cfdee00f](https://www.github.com/tauri-apps/tauri/commit/cfdee00f2b1455a9719bc44823fdaeabbe4c1cb2) refactor(core): fix tls features, use rustls on mobile ([#6591](https://www.github.com/tauri-apps/tauri/pull/6591)) on 2023-03-30 + +## \[2.0.0-alpha.5] + +- Fixes the iOS project script to build the Rust library. + - [6e3e4c22](https://www.github.com/tauri-apps/tauri/commit/6e3e4c22be51500bec7856d90dcb2e40ef7fe1b4) fix(cli): use correct variable on script to build Rust iOS code ([#6581](https://www.github.com/tauri-apps/tauri/pull/6581)) on 2023-03-29 +- Fix `tauri android build/dev` crashing when used with standalone `pnpm` executable on Windows. + - [39df2c98](https://www.github.com/tauri-apps/tauri/commit/39df2c982e5e2ee8617b40f829a2f2e4abfce412) fix(cli/android): fallback to `${program}.cmd` ([#6576](https://www.github.com/tauri-apps/tauri/pull/6576)) on 2023-03-29 + - [6b469c40](https://www.github.com/tauri-apps/tauri/commit/6b469c40c6244ba773d7478adbb41db6fdc72822) chore(changes): adjust change file for Android script execution fix on 2023-03-29 + +## \[2.0.0-alpha.4] + +- Fix android project build crashing when using `pnpm` caused by extra `--`. + - [c787f749](https://www.github.com/tauri-apps/tauri/commit/c787f749de01b79d891615aad8c37b23037fff4c) fix(cli): only add `--` to generated android template for npm ([#6508](https://www.github.com/tauri-apps/tauri/pull/6508)) on 2023-03-21 +- Fixes the Android build gradle plugin implementation on Windows. + - [00241fa9](https://www.github.com/tauri-apps/tauri/commit/00241fa92d104870068a701519340633cc35b716) fix(cli): append .cmd on the gradle plugin binary on Windows, fix [#6502](https://www.github.com/tauri-apps/tauri/pull/6502) ([#6503](https://www.github.com/tauri-apps/tauri/pull/6503)) on 2023-03-21 +- Update `napi-rs` dependencies to latest to fix CLI hanging up forever. + - [d5ac76b5](https://www.github.com/tauri-apps/tauri/commit/d5ac76b53c7f35253db84ddfbf4ecf975ff6307d) chore(deps): update napi-rs, closes [#6502](https://www.github.com/tauri-apps/tauri/pull/6502) ([#6513](https://www.github.com/tauri-apps/tauri/pull/6513)) on 2023-03-21 + +## \[2.0.0-alpha.3] + +- Added `plugin android add` and `plugin ios add` commands to add mobile plugin functionality to existing projects. + - [14d03d42](https://www.github.com/tauri-apps/tauri/commit/14d03d426e86d966950a790926c04560c76203b3) refactor(cli): enhance plugin commands for mobile ([#6289](https://www.github.com/tauri-apps/tauri/pull/6289)) on 2023-02-16 +- Add commands to add native Android and iOS functionality to plugins. + - [05dad087](https://www.github.com/tauri-apps/tauri/commit/05dad0876842e2a7334431247d49365cee835d3e) feat: initial work for iOS plugins ([#6205](https://www.github.com/tauri-apps/tauri/pull/6205)) on 2023-02-11 +- Use temp file instead of environment variable to pass CLI IPC websocket address to the IDE. + - [894a8d06](https://www.github.com/tauri-apps/tauri/commit/894a8d060c12a482a0fc5b3714f3848189b809de) refactor(cli): use temp file to communicate IPC websocket address ([#6219](https://www.github.com/tauri-apps/tauri/pull/6219)) on 2023-02-08 +- Change the Android template to enable minification on release and pull ProGuard rules from proguard-tauri.pro. + - [bef4ef51](https://www.github.com/tauri-apps/tauri/commit/bef4ef51bc2c633b88db121c2087a38dddb7d6bf) feat(android): enable minify on release, add proguard rules ([#6257](https://www.github.com/tauri-apps/tauri/pull/6257)) on 2023-02-13 +- Print an error if the Android project was generated with an older bundle identifier or package name. + - [79eb0542](https://www.github.com/tauri-apps/tauri/commit/79eb054292b04bb089a0e4df401a5986b33b691e) feat(cli): handle Android package identifier change ([#6314](https://www.github.com/tauri-apps/tauri/pull/6314)) on 2023-02-19 +- Fixes the generated mobile build script when using an NPM runner. + - [62f15265](https://www.github.com/tauri-apps/tauri/commit/62f152659204ce1218178596f463f0bcfbd4e6dc) fix(cli): generate build script using NPM runner if it was used ([#6233](https://www.github.com/tauri-apps/tauri/pull/6233)) on 2023-02-10 +- Resolve Android package name from single word bundle identifiers. + - [60a8b07d](https://www.github.com/tauri-apps/tauri/commit/60a8b07dc7c56c9c45331cb57d9afb410e7eadf3) fix: handle single word bundle identifier when resolving Android domain ([#6313](https://www.github.com/tauri-apps/tauri/pull/6313)) on 2023-02-19 +- Update Android project template with fix to crash on orientation change. + - [947eb391](https://www.github.com/tauri-apps/tauri/commit/947eb391ca41cebdb11abd9ffaec642baffbf44a) fix(android): crash on orientation change due to activity recreation ([#6261](https://www.github.com/tauri-apps/tauri/pull/6261)) on 2023-02-13 +- Added `--ios-color` option to the `tauri icon` command. + - [67755425](https://www.github.com/tauri-apps/tauri/commit/677554257e40e05b1af0dd61c982d6be8a8a033c) feat(cli): add `--ios-color` option to set iOS icon background color ([#6247](https://www.github.com/tauri-apps/tauri/pull/6247)) on 2023-02-12 +- Fixes HMR on mobile when devPath is configured to load a filesystem path. + - [4a82da29](https://www.github.com/tauri-apps/tauri/commit/4a82da2919e0564ec993b2005dc65b5b49407b36) fix(cli): use local ip address for reload ([#6285](https://www.github.com/tauri-apps/tauri/pull/6285)) on 2023-02-16 +- Ignore the `gen` folder on the dev watcher. + - [cab4ff95](https://www.github.com/tauri-apps/tauri/commit/cab4ff95b98aeac88401c1fed2d8b8940e4180cb) fix(cli): ignore the `gen` folder on the dev watcher ([#6232](https://www.github.com/tauri-apps/tauri/pull/6232)) on 2023-02-09 +- Correctly pass arguments from `npm run` to `tauri`. + - [1b343bd1](https://www.github.com/tauri-apps/tauri/commit/1b343bd11686f47f24a87298d8192097c66250f6) fix(cli): use `npm run tauri -- foo` for correctly passing args to tauri ([#6448](https://www.github.com/tauri-apps/tauri/pull/6448)) on 2023-03-16 +- Changed the `--api` flag on `plugin init` to `--no-api`. + - [14d03d42](https://www.github.com/tauri-apps/tauri/commit/14d03d426e86d966950a790926c04560c76203b3) refactor(cli): enhance plugin commands for mobile ([#6289](https://www.github.com/tauri-apps/tauri/pull/6289)) on 2023-02-16 + +## \[2.0.0-alpha.2] + +- Fixes `TAURI_*` environment variables for hook scripts on mobile commands. + - [1af9be90](https://www.github.com/tauri-apps/tauri/commit/1af9be904a309138b9f79dc741391000b1652c75) feat(cli): properly fill target for TAURI\_ env vars on mobile ([#6116](https://www.github.com/tauri-apps/tauri/pull/6116)) on 2023-01-23 +- Force colored logs on mobile commands. + - [2c4a0bbd](https://www.github.com/tauri-apps/tauri/commit/2c4a0bbd1fbe15d7500264e6490772397e1917ed) feat(cli): force colored logs on mobile commands ([#5934](https://www.github.com/tauri-apps/tauri/pull/5934)) on 2022-12-28 +- Keep the process alive even when the iOS application is closed. + - [dee9460f](https://www.github.com/tauri-apps/tauri/commit/dee9460f9c9bc92e9c638e7691e616849ac2085b) feat: keep CLI alive when iOS app exits, show logs, closes [#5855](https://www.github.com/tauri-apps/tauri/pull/5855) ([#5902](https://www.github.com/tauri-apps/tauri/pull/5902)) on 2022-12-27 +- Show all application logs on iOS. + - [dee9460f](https://www.github.com/tauri-apps/tauri/commit/dee9460f9c9bc92e9c638e7691e616849ac2085b) feat: keep CLI alive when iOS app exits, show logs, closes [#5855](https://www.github.com/tauri-apps/tauri/pull/5855) ([#5902](https://www.github.com/tauri-apps/tauri/pull/5902)) on 2022-12-27 +- Print log output for all tags on Android development. + - [8cc11149](https://www.github.com/tauri-apps/tauri/commit/8cc111494d74161e489152e52191e1442dd99759) fix(cli): print Android logs for all tags on 2023-01-17 +- Add support to custom and kebab case library names for mobile apps. + - [50f6dd87](https://www.github.com/tauri-apps/tauri/commit/50f6dd87b1ac2c99f8794b055f1acba4ef7d34d3) feat: improvements to support hyphens in crate name ([#5989](https://www.github.com/tauri-apps/tauri/pull/5989)) on 2023-01-06 +- Fix target directory detection when compiling for Android. + - [e873bae0](https://www.github.com/tauri-apps/tauri/commit/e873bae09f0f27517f720a753f51c1dcb903f883) fix(cli): Cargo target dir detection on Android, closes [#5865](https://www.github.com/tauri-apps/tauri/pull/5865) ([#5932](https://www.github.com/tauri-apps/tauri/pull/5932)) on 2022-12-28 + +## \[2.0.0-alpha.1] + +- Fixes running on device using Xcode 14. + - [1e4a6758](https://www.github.com/tauri-apps/tauri/commit/1e4a675843c486bddc11292d09fb766e98758514) fix(cli): run on iOS device on Xcode 14 ([#5807](https://www.github.com/tauri-apps/tauri/pull/5807)) on 2022-12-12 +- Improve local IP address detection with user selection. + - [76204b89](https://www.github.com/tauri-apps/tauri/commit/76204b893846a04552f8f8b87ad2c9b55e1b417f) feat(cli): improve local IP detection ([#5817](https://www.github.com/tauri-apps/tauri/pull/5817)) on 2022-12-12 + +## \[2.0.0-alpha.0] + +- Added `android build` command. + - [4c9ea450](https://www.github.com/tauri-apps/tauri/commit/4c9ea450c3b47c6b8c825ba32e9837909945ccd7) feat(cli): add `android build` command ([#4999](https://www.github.com/tauri-apps/tauri/pull/4999)) on 2022-08-22 +- Added `ios build` command. + - [403859d4](https://www.github.com/tauri-apps/tauri/commit/403859d47e1a9bf978b353fa58e4b971e66337a3) feat(cli): add `ios build` command ([#5002](https://www.github.com/tauri-apps/tauri/pull/5002)) on 2022-08-22 +- Added `android dev` and `ios dev` commands. + - [6f061504](https://www.github.com/tauri-apps/tauri/commit/6f0615044d09ec58393a7ebca5e45bb175e20db3) feat(cli): add `android dev` and `ios dev` commands ([#4982](https://www.github.com/tauri-apps/tauri/pull/4982)) on 2022-08-20 +- Added `android init` and `ios init` commands. + - [d44f67f7](https://www.github.com/tauri-apps/tauri/commit/d44f67f7afd30a81d53a973ec603b2a253150bde) feat: add `android init` and `ios init` commands ([#4942](https://www.github.com/tauri-apps/tauri/pull/4942)) on 2022-08-15 +- Added `android open` and `ios open` commands. + - [a9c8e565](https://www.github.com/tauri-apps/tauri/commit/a9c8e565c6495961940877df7090f307be16b554) feat: add `android open` and `ios open` commands ([#4946](https://www.github.com/tauri-apps/tauri/pull/4946)) on 2022-08-15 +- First mobile alpha release! + - [fa3a1098](https://www.github.com/tauri-apps/tauri/commit/fa3a10988a03aed1b66fb17d893b1a9adb90f7cd) feat(ci): prepare 2.0.0-alpha.0 ([#5786](https://www.github.com/tauri-apps/tauri/pull/5786)) on 2022-12-08 + +## \[1.5.11] + +### Bug Fixes + +- [`b15948b11`](https://www.github.com/tauri-apps/tauri/commit/b15948b11c0e362eea7ef57a4606f15f7dbd886b)([#8903](https://www.github.com/tauri-apps/tauri/pull/8903)) Fix `.taurignore` failing to ignore in some cases. + +### Dependencies + +- Upgraded to `tauri-cli@1.5.11` + +## \[1.5.10] + +### Bug Fixes + +- [`b0f27814`](https://www.github.com/tauri-apps/tauri/commit/b0f27814b90ded2f1ed44b7852080eedbff0d9e4)([#8776](https://www.github.com/tauri-apps/tauri/pull/8776)) Fix `fail to rename app` when using `--profile dev`. +- [`0bff8c32`](https://www.github.com/tauri-apps/tauri/commit/0bff8c325d004fdead2023f58e0f5fd73a9c22ba)([#8697](https://www.github.com/tauri-apps/tauri/pull/8697)) Fix the built-in dev server failing to serve files when URL had queries `?` and other url components. +- [`67d7877f`](https://www.github.com/tauri-apps/tauri/commit/67d7877f27f265c133a70d48a46c83ffff31d571)([#8520](https://www.github.com/tauri-apps/tauri/pull/8520)) The cli now also watches cargo workspace members if the tauri folder is the workspace root. + +### Dependencies + +- Upgraded to `tauri-cli@1.5.10` + +## \[1.5.9] + +### Bug Fixes + +- [`0a2175ea`](https://www.github.com/tauri-apps/tauri/commit/0a2175eabb736b2a4cd01ab682e08be0b5ebb2b9)([#8439](https://www.github.com/tauri-apps/tauri/pull/8439)) Expand glob patterns in workspace member paths so the CLI would watch all matching pathhs. + +### Dependencies + +- Upgraded to `tauri-cli@1.5.9` + +## \[1.5.8] + +### Dependencies + +- Upgraded to `tauri-cli@1.5.8` + +## \[1.5.7] + +### Bug Fixes + +- [`1d5aa38a`](https://www.github.com/tauri-apps/tauri/commit/1d5aa38ae418ea31f593590b6d32cf04d3bfd8c1)([#8162](https://www.github.com/tauri-apps/tauri/pull/8162)) Fixes errors on command output, occuring when the output stream contains an invalid UTF-8 character, or ends with a multi-bytes UTF-8 character. +- [`f26d9f08`](https://www.github.com/tauri-apps/tauri/commit/f26d9f0884f63f61b9f4d4fac15e6b251163793e)([#8263](https://www.github.com/tauri-apps/tauri/pull/8263)) Fixes an issue in the NSIS installer which caused the uninstallation to leave empty folders on the system if the `resources` feature was used. +- [`92bc7d0e`](https://www.github.com/tauri-apps/tauri/commit/92bc7d0e16157434330a1bcf1eefda6f0f1e5f85)([#8233](https://www.github.com/tauri-apps/tauri/pull/8233)) Fixes an issue in the NSIS installer which caused the installation to take much longer than expected when many `resources` were added to the bundle. + +### Dependencies + +- Upgraded to `tauri-cli@1.5.7` + +## \[1.5.6] + +### Bug Fixes + +- [`5264e41d`](https://www.github.com/tauri-apps/tauri/commit/5264e41db3763e4c2eb0c3c21bd423fb7bece3e2)([#8082](https://www.github.com/tauri-apps/tauri/pull/8082)) Downgraded `rust-minisign` to `0.7.3` to fix signing updater bundles with empty passwords. + +### Dependencies + +- Upgraded to `tauri-cli@1.5.6` + +## \[1.5.5] + +### Enhancements + +- [`9bead42d`](https://www.github.com/tauri-apps/tauri/commit/9bead42dbca0fb6dd7ea0b6bfb2f2308a5c5f992)([#8059](https://www.github.com/tauri-apps/tauri/pull/8059)) Allow rotating the updater private key. + +### Bug Fixes + +- [`be8e5aa3`](https://www.github.com/tauri-apps/tauri/commit/be8e5aa3071d9bc5d0bd24647e8168f312d11c8d)([#8042](https://www.github.com/tauri-apps/tauri/pull/8042)) Fixes duplicated newlines on command outputs. + +### Dependencies + +- Upgraded to `tauri-cli@1.5.5` + +## \[1.5.4] + +### Dependencies + +- Upgraded to `tauri-cli@1.5.4` + +## \[1.5.3] + +### Dependencies + +- Upgraded to `tauri-cli@1.5.3` + +## \[1.5.2] + +### Dependencies + +- Upgraded to `tauri-cli@1.5.2` + +## \[1.5.1] + +### Bug Fixes + +- [`d6eb46cf`](https://www.github.com/tauri-apps/tauri/commit/d6eb46cf1116d147121f6b6db9d390b5e2fb238d)([#7934](https://www.github.com/tauri-apps/tauri/pull/7934)) On macOS, fix the `apple-id` option name when using `notarytools submit`. + +### Dependencies + +- Upgraded to `tauri-cli@1.5.1` + +## \[1.5.0] + +### New Features + +- [`e1526626`](https://www.github.com/tauri-apps/tauri/commit/e152662687ece7a62d383923a50751cc0dd34331)([#7723](https://www.github.com/tauri-apps/tauri/pull/7723)) Support Bun package manager in CLI + +### Enhancements + +- [`13279917`](https://www.github.com/tauri-apps/tauri/commit/13279917d4cae071d0ce3a686184d48af079f58a)([#7713](https://www.github.com/tauri-apps/tauri/pull/7713)) Add version of Rust Tauri CLI installed with Cargo to `tauri info` command. + +### Bug Fixes + +- [`dad4f54e`](https://www.github.com/tauri-apps/tauri/commit/dad4f54eec9773d2ea6233a7d9fd218741173823)([#7277](https://www.github.com/tauri-apps/tauri/pull/7277)) Removed the automatic version check of the CLI that ran after `tauri` commands which caused various issues. + +### Dependencies + +- Upgraded to `tauri-cli@1.5.0` + +## \[1.4.0] + +### New Features + +- [`0ddbb3a1`](https://www.github.com/tauri-apps/tauri/commit/0ddbb3a1dc1961ba5c6c1a60081513c1380c8af1)([#7015](https://www.github.com/tauri-apps/tauri/pull/7015)) Provide prebuilt CLIs for Windows ARM64 targets. +- [`35cd751a`](https://www.github.com/tauri-apps/tauri/commit/35cd751adc6fef1f792696fa0cfb471b0bf99374)([#5176](https://www.github.com/tauri-apps/tauri/pull/5176)) Added the `desktop_template` option on `tauri.conf.json > tauri > bundle > deb`. +- [`6c5ade08`](https://www.github.com/tauri-apps/tauri/commit/6c5ade08d97844bb685789d30e589400bbe3e04c)([#4537](https://www.github.com/tauri-apps/tauri/pull/4537)) Added `tauri completions` to generate shell completions scripts. +- [`e092f799`](https://www.github.com/tauri-apps/tauri/commit/e092f799469ff32c7d1595d0f07d06fd2dab5c29)([#6887](https://www.github.com/tauri-apps/tauri/pull/6887)) Add `nsis > template` option to specify custom NSIS installer template. + +### Enhancements + +- [`d75c1b82`](https://www.github.com/tauri-apps/tauri/commit/d75c1b829bd96d9e3a672bcc79120597d5ada4a0)([#7181](https://www.github.com/tauri-apps/tauri/pull/7181)) Print a useful error when `updater` bundle target is specified without an updater-enabled target. +- [`52474e47`](https://www.github.com/tauri-apps/tauri/commit/52474e479d695865299d8c8d868fb98b99731020)([#7141](https://www.github.com/tauri-apps/tauri/pull/7141)) Enhance injection of Cargo features. +- [`2659ca1a`](https://www.github.com/tauri-apps/tauri/commit/2659ca1ab4799a5bda65c229c149e98bd01eb1ee)([#6900](https://www.github.com/tauri-apps/tauri/pull/6900)) Add `rustls` as default Cargo feature. + +### Bug Fixes + +- [`3cb7a3e6`](https://www.github.com/tauri-apps/tauri/commit/3cb7a3e642bb10ee90dc1d24daa48b8c8c15c9ce)([#6997](https://www.github.com/tauri-apps/tauri/pull/6997)) Fix built-in devserver adding hot-reload code to non-html files. +- [`fb7ef8da`](https://www.github.com/tauri-apps/tauri/commit/fb7ef8dacd9ade96976c84d22507782cdaf38acf)([#6667](https://www.github.com/tauri-apps/tauri/pull/6667)) Fix nodejs binary regex when `0` is in the version name, for example `node-20` +- [`1253bbf7`](https://www.github.com/tauri-apps/tauri/commit/1253bbf7ae11a87887e0b3bd98cc26dbb98c8130)([#7013](https://www.github.com/tauri-apps/tauri/pull/7013)) Fixes Cargo.toml feature rewriting. + +## \[1.3.1] + +- Correctly escape XML for resource files in WiX bundler. + - Bumped due to a bump in tauri-bundler. + - Bumped due to a bump in cli.rs. + - [6a6b1388](https://www.github.com/tauri-apps/tauri/commit/6a6b1388ea5787aea4c0e0b0701a4772087bbc0f) fix(bundler): correctly escape resource xml, fixes [#6853](https://www.github.com/tauri-apps/tauri/pull/6853) ([#6855](https://www.github.com/tauri-apps/tauri/pull/6855)) on 2023-05-04 + +- Added the following languages to the NSIS bundler: + +- `Spanish` + +- `SpanishInternational` + +- Bumped due to a bump in tauri-bundler. + - Bumped due to a bump in cli.rs. + +- [422b4817](https://www.github.com/tauri-apps/tauri/commit/422b48179856504e980a156500afa8e22c44d357) Add Spanish and SpanishInternational languages ([#6871](https://www.github.com/tauri-apps/tauri/pull/6871)) on 2023-05-06 + +- Correctly escape arguments in NSIS script to fix bundling apps that use non-default WebView2 install modes. + - Bumped due to a bump in tauri-bundler. + - Bumped due to a bump in cli.rs. + - [2915bd06](https://www.github.com/tauri-apps/tauri/commit/2915bd068ed40dc01a363b69212c6b6f2d3ec01e) fix(bundler): Fix webview install modes in NSIS bundler ([#6854](https://www.github.com/tauri-apps/tauri/pull/6854)) on 2023-05-04 + +## \[1.3.0] + +- Add `--ci` flag and respect the `CI` environment variable on the `signer generate` command. In this case the default password will be an empty string and the CLI will not prompt for a value. + - [8fb1df8a](https://www.github.com/tauri-apps/tauri/commit/8fb1df8aa65a52cdb4a7e1bb9dda9b912a7a2895) feat(cli): add `--ci` flag to `signer generate`, closes [#6089](https://www.github.com/tauri-apps/tauri/pull/6089) ([#6097](https://www.github.com/tauri-apps/tauri/pull/6097)) on 2023-01-19 +- Fix Outdated Github Actions in the Plugin Templates `with-api` and `backend` + - [a926b49a](https://www.github.com/tauri-apps/tauri/commit/a926b49a01925ca757d391994bfac3beea29599b) Fix Github Actions of Tauri Plugin with-api template ([#6603](https://www.github.com/tauri-apps/tauri/pull/6603)) on 2023-04-03 +- Do not crash on Cargo.toml watcher. + - [e8014a7f](https://www.github.com/tauri-apps/tauri/commit/e8014a7f612a1094461ddad63aacc498a2682ff5) fix(cli): do not crash on watcher ([#6303](https://www.github.com/tauri-apps/tauri/pull/6303)) on 2023-02-17 +- Fix crash when nodejs binary has the version in its name, for example `node-18` + - [1c8229fb](https://www.github.com/tauri-apps/tauri/commit/1c8229fbe273554c0c97cccee45d5967f5df1b9f) fix(cli.js): detect `node-` binary, closes [#6427](https://www.github.com/tauri-apps/tauri/pull/6427) ([#6432](https://www.github.com/tauri-apps/tauri/pull/6432)) on 2023-03-16 +- Add `--png` option for the `icon` command to generate custom icon sizes. + - [9d214412](https://www.github.com/tauri-apps/tauri/commit/9d2144128fc5fad67d8404bce95f82297ebb0e4a) feat(cli): add option to make custom icon sizes, closes [#5121](https://www.github.com/tauri-apps/tauri/pull/5121) ([#5246](https://www.github.com/tauri-apps/tauri/pull/5246)) on 2022-12-27 +- Skip the password prompt on the build command when `TAURI_KEY_PASSWORD` environment variable is empty and the `--ci` argument is provided or the `CI` environment variable is set. + - [d4f89af1](https://www.github.com/tauri-apps/tauri/commit/d4f89af18d69fd95a4d8a1ede8442547c6a6d0ee) feat: skip password prompt on the build command if CI is set fixes [#6089](https://www.github.com/tauri-apps/tauri/pull/6089) on 2023-01-18 +- Fix `default-run` not deserialized. + - [57c6bf07](https://www.github.com/tauri-apps/tauri/commit/57c6bf07bb380847abdf27c3fff9891d99c1c98c) fix(cli): fix default-run not deserialized ([#6584](https://www.github.com/tauri-apps/tauri/pull/6584)) on 2023-03-30 +- Fixes HTML serialization removing template tags on the dev server. + - [314f0e21](https://www.github.com/tauri-apps/tauri/commit/314f0e212fd2b9e452bfe3424cdce2b0bf37b5d7) fix(cli): web_dev_server html template serialization (fix [#6165](https://www.github.com/tauri-apps/tauri/pull/6165)) ([#6166](https://www.github.com/tauri-apps/tauri/pull/6166)) on 2023-01-29 +- Use escaping on Handlebars templates. + - [6d6b6e65](https://www.github.com/tauri-apps/tauri/commit/6d6b6e653ea70fc02794f723092cdc860995c259) feat: configure escaping on handlebars templates ([#6678](https://www.github.com/tauri-apps/tauri/pull/6678)) on 2023-05-02 +- Add initial support for building `nsis` bundles on non-Windows platforms. + - [60e6f6c3](https://www.github.com/tauri-apps/tauri/commit/60e6f6c3f1605f3064b5bb177992530ff788ccf0) feat(bundler): Add support for creating NSIS bundles on unix hosts ([#5788](https://www.github.com/tauri-apps/tauri/pull/5788)) on 2023-01-19 +- Add `nsis` bundle target + - [c94e1326](https://www.github.com/tauri-apps/tauri/commit/c94e1326a7c0767a13128a8b1d327a00156ece12) feat(bundler): add `nsis`, closes [#4450](https://www.github.com/tauri-apps/tauri/pull/4450), closes [#2319](https://www.github.com/tauri-apps/tauri/pull/2319) ([#4674](https://www.github.com/tauri-apps/tauri/pull/4674)) on 2023-01-03 +- Remove default features from Cargo.toml template. + - [b08ae637](https://www.github.com/tauri-apps/tauri/commit/b08ae637a0f58b38cbce9b8a1fa0b6c5dc0cfd05) fix(cli): remove default features from template ([#6074](https://www.github.com/tauri-apps/tauri/pull/6074)) on 2023-01-17 +- Use Ubuntu 20.04 to compile the CLI, increasing the minimum libc version required. + +## \[1.2.3] + +- Pin `ignore` to `=0.4.18`. + - [adcb082b](https://www.github.com/tauri-apps/tauri/commit/adcb082b1651ecb2a6208b093e12f4185aa3fc98) chore(deps): pin `ignore` to =0.4.18 on 2023-01-17 + +## \[1.2.2] + +- Detect SvelteKit and Vite for the init and info commands. + - [9d872ab8](https://www.github.com/tauri-apps/tauri/commit/9d872ab8728b1b121909af434adcd5936e5afb7d) feat(cli): detect SvelteKit and Vite ([#5742](https://www.github.com/tauri-apps/tauri/pull/5742)) on 2022-12-02 +- Detect SolidJS and SolidStart for the init and info commands. + - [9e7ce0a8](https://www.github.com/tauri-apps/tauri/commit/9e7ce0a8eef4bf3536645976e3e09162fbf772ab) feat(cli): detect SolidJS and SolidStart ([#5758](https://www.github.com/tauri-apps/tauri/pull/5758)) on 2022-12-08 +- Use older icon types to work around a macOS bug resulting in corrupted 16x16px and 32x32px icons in bundled apps. + - [2d545eff](https://www.github.com/tauri-apps/tauri/commit/2d545eff58734ec70f23f11a429d35435cdf090e) fix(cli): corrupted icons in bundled macOS icons ([#5698](https://www.github.com/tauri-apps/tauri/pull/5698)) on 2022-11-28 + +## \[1.2.1] + +- Fixes injection of Cargo features defined in the configuration file. + - [1ecaeb29](https://www.github.com/tauri-apps/tauri/commit/1ecaeb29aa798f591f6488dc6c3a7a8d22f6073e) fix(cli): inject config feature flags when features arg is not provided on 2022-11-18 + +## \[1.2.0] + +- Detect JSON5 and TOML configuration files in the dev watcher. + - [e7ccbd85](https://www.github.com/tauri-apps/tauri/commit/e7ccbd8573f6b9124e80c0b67fa2365729c3c196) feat(cli): detect JSON5 and TOML configuration files in the dev watcher ([#5439](https://www.github.com/tauri-apps/tauri/pull/5439)) on 2022-10-19 +- Log dev watcher file change detection. + - [9076d5d2](https://www.github.com/tauri-apps/tauri/commit/9076d5d2e76d432aef475ba403e9ab5bd3b9d2b0) feat(cli): add prompt information when file changing detected, closes [#5417](https://www.github.com/tauri-apps/tauri/pull/5417) ([#5428](https://www.github.com/tauri-apps/tauri/pull/5428)) on 2022-10-19 +- Fix crash when nodejs binary has the version in its name, for example `node18` or when running through deno. + - [7a231cd1](https://www.github.com/tauri-apps/tauri/commit/7a231cd1c99101f63354b13bb36223568d2f0a11) fix(cli): detect deno ([#5475](https://www.github.com/tauri-apps/tauri/pull/5475)) on 2022-10-28 +- Changed the project template to not enable all APIs by default. + - [582c25a0](https://www.github.com/tauri-apps/tauri/commit/582c25a0f0fa2725d786ec4edd0defe7811ad6e8) refactor(cli): disable api-all on templates ([#5538](https://www.github.com/tauri-apps/tauri/pull/5538)) on 2022-11-03 + +## \[1.1.1] + +- Fix wrong cli metadata that caused new projects (created through `tauri init`) fail to build + - [db26aaf2](https://www.github.com/tauri-apps/tauri/commit/db26aaf2b44ce5335c9223c571ef2b2175e0cd6d) fix: fix wrong cli metadata ([#5214](https://www.github.com/tauri-apps/tauri/pull/5214)) on 2022-09-16 + +## \[1.1.0] + +- Allow adding `build > beforeBundleCommand` in tauri.conf.json to run a shell command before the bundling phase. + - [57ab9847](https://www.github.com/tauri-apps/tauri/commit/57ab9847eb2d8c9a5da584b873b7c072e9ee26bf) feat(cli): add `beforeBundleCommand`, closes [#4879](https://www.github.com/tauri-apps/tauri/pull/4879) ([#4893](https://www.github.com/tauri-apps/tauri/pull/4893)) on 2022-08-09 +- Change `before_dev_command` and `before_build_command` config value to allow configuring the current working directory. + - [d6f7d3cf](https://www.github.com/tauri-apps/tauri/commit/d6f7d3cfe8a7ec8d68c8341016c4e0a3103da587) Add cwd option to `before` commands, add wait option to dev [#4740](https://www.github.com/tauri-apps/tauri/pull/4740) [#3551](https://www.github.com/tauri-apps/tauri/pull/3551) ([#4834](https://www.github.com/tauri-apps/tauri/pull/4834)) on 2022-08-02 +- Allow configuring the `before_dev_command` to force the CLI to wait for the command to finish before proceeding. + - [d6f7d3cf](https://www.github.com/tauri-apps/tauri/commit/d6f7d3cfe8a7ec8d68c8341016c4e0a3103da587) Add cwd option to `before` commands, add wait option to dev [#4740](https://www.github.com/tauri-apps/tauri/pull/4740) [#3551](https://www.github.com/tauri-apps/tauri/pull/3551) ([#4834](https://www.github.com/tauri-apps/tauri/pull/4834)) on 2022-08-02 +- Check if the default build target is set in the Cargo configuration. + - [436f3d8d](https://www.github.com/tauri-apps/tauri/commit/436f3d8d66727f5b64165522f0b55f4ab54bd1ae) feat(cli): load Cargo configuration to check default build target ([#4990](https://www.github.com/tauri-apps/tauri/pull/4990)) on 2022-08-21 +- Use `cargo metadata` to detect the workspace root and target directory. + - [fea70eff](https://www.github.com/tauri-apps/tauri/commit/fea70effad219c0794d919f8834fa1a1ffd204c7) refactor(cli): Use `cargo metadata` to detect the workspace root and target directory, closes [#4632](https://www.github.com/tauri-apps/tauri/pull/4632), [#4928](https://www.github.com/tauri-apps/tauri/pull/4928). ([#4932](https://www.github.com/tauri-apps/tauri/pull/4932)) on 2022-08-21 +- Prompt for `beforeDevCommand` and `beforeBuildCommand` in `tauri init`. + - [6d4945c9](https://www.github.com/tauri-apps/tauri/commit/6d4945c9f06cd1f7018e1c48686ba682aae817df) feat(cli): prompt for before\*Command, closes [#4691](https://www.github.com/tauri-apps/tauri/pull/4691) ([#4721](https://www.github.com/tauri-apps/tauri/pull/4721)) on 2022-07-25 +- Added support to configuration files in TOML format (Tauri.toml file). + - [ae83d008](https://www.github.com/tauri-apps/tauri/commit/ae83d008f9e1b89bfc8dddaca42aa5c1fbc36f6d) feat: add support to TOML config file `Tauri.toml`, closes [#4806](https://www.github.com/tauri-apps/tauri/pull/4806) ([#4813](https://www.github.com/tauri-apps/tauri/pull/4813)) on 2022-08-02 +- Automatically use any `.taurignore` file as ignore rules for dev watcher and app path finder. + - [596fa08d](https://www.github.com/tauri-apps/tauri/commit/596fa08d48e371c7bd29e1ef799119ac8fca0d0b) feat(cli): automatically use `.taurignore`, ref [#4617](https://www.github.com/tauri-apps/tauri/pull/4617) ([#4623](https://www.github.com/tauri-apps/tauri/pull/4623)) on 2022-07-28 +- Enable WiX FIPS compliance when the `TAURI_FIPS_COMPLIANT` environment variable is set to `true`. + - [d88b9de7](https://www.github.com/tauri-apps/tauri/commit/d88b9de7aaeaaa2e42e4795dbc2b8642b5ae7a50) feat(core): add `fips_compliant` wix config option, closes [#4541](https://www.github.com/tauri-apps/tauri/pull/4541) ([#4843](https://www.github.com/tauri-apps/tauri/pull/4843)) on 2022-08-04 +- Fixes dev watcher incorrectly exiting the CLI when sequential file updates are detected. + - [47fab680](https://www.github.com/tauri-apps/tauri/commit/47fab6809a1e23b3b9a84695e2d91ff0826ba79a) fix(cli): dev watcher incorrectly killing process on multiple file write ([#4684](https://www.github.com/tauri-apps/tauri/pull/4684)) on 2022-07-25 +- Add `libc` field to Node packages. + - [f7d2dfc7](https://www.github.com/tauri-apps/tauri/commit/f7d2dfc7a6d086dd1a218d6c1492b3fef8a64f03) chore: add libc field to node packages ([#4856](https://www.github.com/tauri-apps/tauri/pull/4856)) on 2022-08-04 +- Set the `MACOSX_DEPLOYMENT_TARGET` environment variable with the configuration `minimum_system_version` value. + - [fa23310f](https://www.github.com/tauri-apps/tauri/commit/fa23310f23cb9e6a02ec2524f1ef394a5b42990e) fix(cli): set MACOSX_DEPLOYMENT_TARGET env var, closes [#4704](https://www.github.com/tauri-apps/tauri/pull/4704) ([#4842](https://www.github.com/tauri-apps/tauri/pull/4842)) on 2022-08-02 +- Added `--no-watch` argument to the `dev` command to disable the file watcher. + - [0983d7ce](https://www.github.com/tauri-apps/tauri/commit/0983d7ce7f24ab43f9ae7b5e1177ff244d8885a8) feat(cli): add `--no-watch` argument to the dev command, closes [#4617](https://www.github.com/tauri-apps/tauri/pull/4617) ([#4793](https://www.github.com/tauri-apps/tauri/pull/4793)) on 2022-07-29 +- Validate updater signature matches configured public key. + - [b2a8930b](https://www.github.com/tauri-apps/tauri/commit/b2a8930b3c4b72c50ce72e73575f42c9cbe91bad) feat(cli): validate updater private key when signing ([#4754](https://www.github.com/tauri-apps/tauri/pull/4754)) on 2022-07-25 + +## \[1.0.5] + +- Correctly fill the architecture when building Debian packages targeting ARM64 (aarch64). + - Bumped due to a bump in cli.rs. + - [635f23b8](https://www.github.com/tauri-apps/tauri/commit/635f23b88adbb8726d628f67840709cd870836dc) fix(bundler): correctly set debian architecture for aarch64 ([#4700](https://www.github.com/tauri-apps/tauri/pull/4700)) on 2022-07-17 + +## \[1.0.4] + +- Do not capture and force colors of `cargo build` output. + - [c635a0da](https://www.github.com/tauri-apps/tauri/commit/c635a0dad437860d54109adffaf245b7c21bc684) refactor(cli): do not capture and force colors of cargo build output ([#4627](https://www.github.com/tauri-apps/tauri/pull/4627)) on 2022-07-12 +- Reduce the amount of allocations when converting cases. + - [bc370e32](https://www.github.com/tauri-apps/tauri/commit/bc370e326810446e15b1f50fb962b980114ba16b) feat: reduce the amount of `heck`-related allocations ([#4634](https://www.github.com/tauri-apps/tauri/pull/4634)) on 2022-07-11 + +## \[1.0.3] + +- Changed the app template to not set the default app menu as it is now set automatically on macOS which is the platform that needs a menu to function properly. + - [91055883](https://www.github.com/tauri-apps/tauri/commit/9105588373cc8401bd9ad79bdef26f509b2d76b7) feat: add implicit default menu for macOS only, closes [#4551](https://www.github.com/tauri-apps/tauri/pull/4551) ([#4570](https://www.github.com/tauri-apps/tauri/pull/4570)) on 2022-07-04 +- Improved bundle identifier validation showing the exact source of the configuration value. + - [8e3e7fc6](https://www.github.com/tauri-apps/tauri/commit/8e3e7fc64641afc7a6833bc93205e6f525562545) feat(cli): improve bundle identifier validation, closes [#4589](https://www.github.com/tauri-apps/tauri/pull/4589) ([#4596](https://www.github.com/tauri-apps/tauri/pull/4596)) on 2022-07-05 +- Improve configuration deserialization error messages. + - [9170c920](https://www.github.com/tauri-apps/tauri/commit/9170c9207044fa561535f624916dfdbaa41ff79d) feat(core): improve config deserialization error messages ([#4607](https://www.github.com/tauri-apps/tauri/pull/4607)) on 2022-07-06 +- Revert the `run` command to run in a separate thread. + - [f65eb4f8](https://www.github.com/tauri-apps/tauri/commit/f65eb4f84d8e511cd30d01d20a8223a297f7e584) fix(cli.js): revert `run` command to be nonblocking on 2022-07-04 +- Skip the static link of the `vcruntime140.dll` if the `STATIC_VCRUNTIME` environment variable is set to `false`. + - [2e61abaa](https://www.github.com/tauri-apps/tauri/commit/2e61abaa9ae5d7a41ca1fa6505b5d6c368625ce5) feat(cli): allow dynamic link vcruntime, closes [#4565](https://www.github.com/tauri-apps/tauri/pull/4565) ([#4601](https://www.github.com/tauri-apps/tauri/pull/4601)) on 2022-07-06 +- The `TAURI_CONFIG` environment variable now represents the configuration to be merged instead of the entire JSON. + - [fa028ebf](https://www.github.com/tauri-apps/tauri/commit/fa028ebf3c8ca7b43a70d283a01dbea86217594f) refactor: do not pass entire config from CLI to core, send patch instead ([#4598](https://www.github.com/tauri-apps/tauri/pull/4598)) on 2022-07-06 +- Watch for Cargo workspace members in the `dev` file watcher. + - [dbb8c87b](https://www.github.com/tauri-apps/tauri/commit/dbb8c87b96dec9942b1bf877b29bafb8246514d4) feat(cli): watch Cargo workspaces in the dev command, closes [#4222](https://www.github.com/tauri-apps/tauri/pull/4222) ([#4572](https://www.github.com/tauri-apps/tauri/pull/4572)) on 2022-07-03 + +## \[1.0.2] + +- Fixes a crash on the `signer sign` command. + - [8e808fec](https://www.github.com/tauri-apps/tauri/commit/8e808fece95f2e506acf2c446d37b9913fd67d50) fix(cli.rs): conflicts_with arg doesn't exist closes ([#4538](https://www.github.com/tauri-apps/tauri/pull/4538)) on 2022-06-30 + +## \[1.0.1] + +- No longer adds the `pkg-config` dependency to `.deb` packages when the `systemTray` is used. + This only works with recent versions of `libappindicator-sys` (including https://github.com/tauri-apps/libappindicator-rs/pull/38), + so a `cargo update` may be necessary if you create `.deb` bundles and use the tray feature. + - [0e6edeb1](https://www.github.com/tauri-apps/tauri/commit/0e6edeb14f379af1e02a7cebb4e3a5c9e87ebf7f) fix(cli): Don't add `pkg-config` to `deb` ([#4508](https://www.github.com/tauri-apps/tauri/pull/4508)) on 2022-06-29 +- AppImage bundling will now prefer bundling correctly named appindicator library (including `.1` version suffix). With a symlink for compatibility with the old naming. + - [bf45ca1d](https://www.github.com/tauri-apps/tauri/commit/bf45ca1df6691c05bdf72c5716cc01e89a7791d4) fix(cli,bundler): prefer AppImage libraries with ABI version ([#4505](https://www.github.com/tauri-apps/tauri/pull/4505)) on 2022-06-29 +- Improve error message when `cargo` is not installed. + - [e0e5f772](https://www.github.com/tauri-apps/tauri/commit/e0e5f772430f6349ec99ba891e601331e376e3c7) feat(cli): improve `cargo not found` error message, closes [#4428](https://www.github.com/tauri-apps/tauri/pull/4428) ([#4430](https://www.github.com/tauri-apps/tauri/pull/4430)) on 2022-06-21 +- The app template now only sets the default menu on macOS. + - [5105b428](https://www.github.com/tauri-apps/tauri/commit/5105b428c4726b2179cd4b3244350d1a1ee73734) feat(cli): change app template to only set default menu on macOS ([#4518](https://www.github.com/tauri-apps/tauri/pull/4518)) on 2022-06-29 +- Warn if updater is enabled but not in the bundle target list. + - [31c15cd2](https://www.github.com/tauri-apps/tauri/commit/31c15cd2bd94dbe39fb94982a15cbe02ac5d8925) docs(config): enhance documentation for bundle targets, closes [#3251](https://www.github.com/tauri-apps/tauri/pull/3251) ([#4418](https://www.github.com/tauri-apps/tauri/pull/4418)) on 2022-06-21 +- Check if target exists and is installed on dev and build commands. + - [13b8a240](https://www.github.com/tauri-apps/tauri/commit/13b8a2403d1353a8c3a643fbc6b6e862af68376e) feat(cli): validate target argument ([#4458](https://www.github.com/tauri-apps/tauri/pull/4458)) on 2022-06-24 +- Fixes the covector configuration on the plugin templates. + - [b8a64d01](https://www.github.com/tauri-apps/tauri/commit/b8a64d01bab11f955b7bbdf323d0afa1a3db4b64) fix(cli): add prepublish scripts to the plugin templates on 2022-06-19 +- Set the binary name to the product name in development. + - [b025b9f5](https://www.github.com/tauri-apps/tauri/commit/b025b9f581ac1a6ae0a26789c2be1e9928fb0282) refactor(cli): set binary name on dev ([#4447](https://www.github.com/tauri-apps/tauri/pull/4447)) on 2022-06-23 +- Allow registering a `.gitignore` file to skip watching some project files and directories via the `TAURI_DEV_WATCHER_IGNORE_FILE` environment variable. + - [83186dd8](https://www.github.com/tauri-apps/tauri/commit/83186dd89768407984db35fb67c3cc51f50ea8f5) Read extra ignore file for dev watcher, closes [#4406](https://www.github.com/tauri-apps/tauri/pull/4406) ([#4409](https://www.github.com/tauri-apps/tauri/pull/4409)) on 2022-06-20 +- Fix shebang for `kill-children.sh`. + - [35dd51db](https://www.github.com/tauri-apps/tauri/commit/35dd51db6826ec1eed7b90082b9eb6b2a699b627) fix(cli): add shebang for kill-children.sh, closes [#4262](https://www.github.com/tauri-apps/tauri/pull/4262) ([#4416](https://www.github.com/tauri-apps/tauri/pull/4416)) on 2022-06-22 +- Update plugin templates to use newer `tauri-apps/create-pull-request` GitHub action. + - [07f90795](https://www.github.com/tauri-apps/tauri/commit/07f9079532a42f3517d96faeaf46cad6176b31ac) chore(cli): update plugin template tauri-apps/create-pull-request on 2022-06-19 +- Use UNIX path separator on the init `$schema` field. + - [01053045](https://www.github.com/tauri-apps/tauri/commit/010530459ef62c48eed68ca965f2688accabcf69) chore(cli): use unix path separator on $schema ([#4384](https://www.github.com/tauri-apps/tauri/pull/4384)) on 2022-06-19 +- The `info` command now can check the Cargo lockfile on workspaces. + - [12f65219](https://www.github.com/tauri-apps/tauri/commit/12f65219ea75a51ebd38659ddce1563e015a036c) fix(cli): read lockfile from workspace on the info command, closes [#4232](https://www.github.com/tauri-apps/tauri/pull/4232) ([#4423](https://www.github.com/tauri-apps/tauri/pull/4423)) on 2022-06-21 +- Preserve the `Cargo.toml` formatting when the features array is not changed. + - [6650e5d6](https://www.github.com/tauri-apps/tauri/commit/6650e5d6720c215530ca1fdccd19bd2948dd6ca3) fix(cli): preserve Cargo manifest formatting when possible ([#4431](https://www.github.com/tauri-apps/tauri/pull/4431)) on 2022-06-21 +- Change the updater signature metadata to include the file name instead of its full path. + - [094b3eb3](https://www.github.com/tauri-apps/tauri/commit/094b3eb352bcf5de28414015e7c44290d619ea8c) fix(cli): file name instead of path on updater sig comment, closes [#4467](https://www.github.com/tauri-apps/tauri/pull/4467) ([#4484](https://www.github.com/tauri-apps/tauri/pull/4484)) on 2022-06-27 +- Validate bundle identifier as it must only contain alphanumeric characters, hyphens and periods. + - [0674a801](https://www.github.com/tauri-apps/tauri/commit/0674a80129d7c31bc93257849afc0a5069129fed) fix: assert config.bundle.identifier to be only alphanumeric, hyphens or dots. closes [#4359](https://www.github.com/tauri-apps/tauri/pull/4359) ([#4363](https://www.github.com/tauri-apps/tauri/pull/4363)) on 2022-06-17 + +## \[1.0.0] + +- Upgrade to `stable`! + - [f4bb30cc](https://www.github.com/tauri-apps/tauri/commit/f4bb30cc73d6ba9b9ef19ef004dc5e8e6bb901d3) feat(covector): prepare for v1 ([#4351](https://www.github.com/tauri-apps/tauri/pull/4351)) on 2022-06-15 + +## \[1.0.0-rc.16] + +- Use the default window menu in the app template. + - [4c4acc30](https://www.github.com/tauri-apps/tauri/commit/4c4acc3094218dd9cee0f1ad61810c979e0b41fa) feat: implement `Default` for `Menu`, closes [#2398](https://www.github.com/tauri-apps/tauri/pull/2398) ([#4291](https://www.github.com/tauri-apps/tauri/pull/4291)) on 2022-06-15 + +## \[1.0.0-rc.15] + +- Removed the tray icon from the Debian and AppImage bundles since they are embedded in the binary now. + - [4ce8e228](https://www.github.com/tauri-apps/tauri/commit/4ce8e228134cd3f22973b74ef26ca0d165fbbbd9) refactor(core): use `Icon` for tray icons ([#4342](https://www.github.com/tauri-apps/tauri/pull/4342)) on 2022-06-14 + +## \[1.0.0-rc.14] + +- Set the `TRAY_LIBRARY_PATH` environment variable to make the bundle copy the appindicator library to the AppImage. + - [34552444](https://www.github.com/tauri-apps/tauri/commit/3455244436578003a5fbb447b039e5c8971152ec) feat(cli): bundle appindicator library in the AppImage, closes [#3859](https://www.github.com/tauri-apps/tauri/pull/3859) ([#4267](https://www.github.com/tauri-apps/tauri/pull/4267)) on 2022-06-07 +- Set the `APPIMAGE_BUNDLE_GSTREAMER` environment variable to make the bundler copy additional gstreamer files to the AppImage. + - [d335fae9](https://www.github.com/tauri-apps/tauri/commit/d335fae92cdcbb0ee18aad4e54558914afa3e778) feat(bundler): bundle additional gstreamer files, closes [#4092](https://www.github.com/tauri-apps/tauri/pull/4092) ([#4271](https://www.github.com/tauri-apps/tauri/pull/4271)) on 2022-06-10 +- Configure the AppImage bundler to copy the `/usr/bin/xdg-open` binary if it exists and the shell `open` API is enabled. + - [2322ac11](https://www.github.com/tauri-apps/tauri/commit/2322ac11cf6290c6bf65413048a049c8072f863b) fix(bundler): bundle `/usr/bin/xdg-open` in appimage if open API enabled ([#4265](https://www.github.com/tauri-apps/tauri/pull/4265)) on 2022-06-04 +- Fixes multiple occurrences handling of the `bundles` and `features` arguments. + - [f685df39](https://www.github.com/tauri-apps/tauri/commit/f685df399a5a05480b6e4f5d92da71f3b87895ef) fix(cli): parsing of arguments with multiple values, closes [#4231](https://www.github.com/tauri-apps/tauri/pull/4231) ([#4233](https://www.github.com/tauri-apps/tauri/pull/4233)) on 2022-05-29 +- Log command output in real time instead of waiting for it to finish. + - [76d1eaae](https://www.github.com/tauri-apps/tauri/commit/76d1eaaebda5c8f6b0d41bf6587945e98cd441f3) feat(cli): debug command output in real time ([#4318](https://www.github.com/tauri-apps/tauri/pull/4318)) on 2022-06-12 +- Configure the `STATIC_VCRUNTIME` environment variable so `tauri-build` statically links it on the build command. + - [d703d27a](https://www.github.com/tauri-apps/tauri/commit/d703d27a707edc028f13b35603205da1133fcc2b) fix(build): statically link VC runtime only on `tauri build` ([#4292](https://www.github.com/tauri-apps/tauri/pull/4292)) on 2022-06-07 +- Use the `TAURI_TRAY` environment variable to determine which package should be added to the Debian `depends` section. Possible values are `ayatana` and `gtk`. + - [6216eb49](https://www.github.com/tauri-apps/tauri/commit/6216eb49e72863bfb6d4c9edb8827b21406ac393) refactor(core): drop `ayatana-tray` and `gtk-tray` Cargo features ([#4247](https://www.github.com/tauri-apps/tauri/pull/4247)) on 2022-06-02 + +## \[1.0.0-rc.13] + +- Check if `$CWD/src-tauri/tauri.conf.json` exists before walking through the file tree to find the tauri dir in case the whole project is gitignored. + - [bd8f3e29](https://www.github.com/tauri-apps/tauri/commit/bd8f3e298a0cb71809f2e93cc3ebc8e6e5b6a626) fix(cli): manual config lookup to handle gitignored folders, fixes [#3527](https://www.github.com/tauri-apps/tauri/pull/3527) ([#4224](https://www.github.com/tauri-apps/tauri/pull/4224)) on 2022-05-26 +- Statically link the Visual C++ runtime instead of using a merge module on the installer. + - [bb061509](https://www.github.com/tauri-apps/tauri/commit/bb061509fb674bef86ecbc1de3aa8f3e367a9907) refactor(core): statically link vcruntime, closes [#4122](https://www.github.com/tauri-apps/tauri/pull/4122) ([#4227](https://www.github.com/tauri-apps/tauri/pull/4227)) on 2022-05-27 + +## \[1.0.0-rc.12] + +- Properly fetch the NPM dependency information when using Yarn 2+. + - [cdfa6255](https://www.github.com/tauri-apps/tauri/commit/cdfa62551115586725bd3e4c04f12c5256f20790) fix(cli): properly read info when using yarn 2+, closes [#4106](https://www.github.com/tauri-apps/tauri/pull/4106) ([#4193](https://www.github.com/tauri-apps/tauri/pull/4193)) on 2022-05-23 + +## \[1.0.0-rc.11] + +- Allow configuring the display options for the MSI execution allowing quieter updates. + - [9f2c3413](https://www.github.com/tauri-apps/tauri/commit/9f2c34131952ea83c3f8e383bc3cec7e1450429f) feat(core): configure msiexec display options, closes [#3951](https://www.github.com/tauri-apps/tauri/pull/3951) ([#4061](https://www.github.com/tauri-apps/tauri/pull/4061)) on 2022-05-15 + +## \[1.0.0-rc.10] + +- Resolve binary file extension from target triple instead of compile-time checks to allow cross compilation. + - [4562e671](https://www.github.com/tauri-apps/tauri/commit/4562e671e4795e9386429348bf738f7078706945) fix(build): append .exe binary based on target triple instead of running OS, closes [#3870](https://www.github.com/tauri-apps/tauri/pull/3870) ([#4032](https://www.github.com/tauri-apps/tauri/pull/4032)) on 2022-05-03 +- Fixes text overflow on `tauri dev` on Windows. + - [094534d1](https://www.github.com/tauri-apps/tauri/commit/094534d138a9286e4746b61adff2da616e3b6a61) fix(cli): dev command stderr text overflow on Windows, closes [#3995](https://www.github.com/tauri-apps/tauri/pull/3995) ([#4000](https://www.github.com/tauri-apps/tauri/pull/4000)) on 2022-04-29 +- Improve CLI's logging output, making use of the standard rust `log` system. + - [35f21471](https://www.github.com/tauri-apps/tauri/commit/35f2147161e6697cbd2824681eeaf870b5a991c2) feat(cli): Improve CLI logging ([#4060](https://www.github.com/tauri-apps/tauri/pull/4060)) on 2022-05-07 +- Don't override the default keychain on macOS while code signing. + - [a4fcaf1d](https://www.github.com/tauri-apps/tauri/commit/a4fcaf1d04aafc3b4d42186f0fb386797d959a9d) fix: don't override default keychain, closes [#4008](https://www.github.com/tauri-apps/tauri/pull/4008) ([#4053](https://www.github.com/tauri-apps/tauri/pull/4053)) on 2022-05-05 +- - Remove startup delay in `tauri dev` caused by checking for a newer cli version. The check is now done upon process exit. +- Add `TAURI_SKIP_UPDATE_CHECK` env variable to skip checking for a newer CLI version. +- [bbabc8cd](https://www.github.com/tauri-apps/tauri/commit/bbabc8cd1ea2c1f6806610fd2d533c99305d320c) fix(cli.rs): remove startup delay in `tauri dev` ([#3999](https://www.github.com/tauri-apps/tauri/pull/3999)) on 2022-04-29 +- Fix `tauri info` panic when a package isn't installed. + - [4f0f3187](https://www.github.com/tauri-apps/tauri/commit/4f0f3187c9e69262ef28350331b368c831ab930a) fix(cli.rs): fix `tauri info` panic when a package isn't installed, closes [#3985](https://www.github.com/tauri-apps/tauri/pull/3985) ([#3996](https://www.github.com/tauri-apps/tauri/pull/3996)) on 2022-04-29 +- Added `$schema` support to `tauri.conf.json`. + - [715cbde3](https://www.github.com/tauri-apps/tauri/commit/715cbde3842a916c4ebeab2cab348e1774b5c192) feat(config): add `$schema` to `tauri.conf.json`, closes [#3464](https://www.github.com/tauri-apps/tauri/pull/3464) ([#4031](https://www.github.com/tauri-apps/tauri/pull/4031)) on 2022-05-03 +- **Breaking change:** The `dev` command now reads the custom config file from CWD instead of the Tauri folder. + - [a1929c6d](https://www.github.com/tauri-apps/tauri/commit/a1929c6dacccd00af4cdbcc4d29cfb98d8428f55) fix(cli): always read custom config file from CWD, closes [#4067](https://www.github.com/tauri-apps/tauri/pull/4067) ([#4074](https://www.github.com/tauri-apps/tauri/pull/4074)) on 2022-05-07 +- Fixes a Powershell crash when sending SIGINT to the dev command. + - [32048486](https://www.github.com/tauri-apps/tauri/commit/320484866b83ecabb01eb58d158e0fedd9dd08be) fix(cli): powershell crashing on SIGINT, closes [#3997](https://www.github.com/tauri-apps/tauri/pull/3997) ([#4007](https://www.github.com/tauri-apps/tauri/pull/4007)) on 2022-04-29 +- Prevent building when the bundle identifier is the default `com.tauri.dev`. + - [95726ebb](https://www.github.com/tauri-apps/tauri/commit/95726ebb6180d371be44bff9f16ca1eee049006a) feat(cli): prevent default bundle identifier from building, closes [#4041](https://www.github.com/tauri-apps/tauri/pull/4041) ([#4042](https://www.github.com/tauri-apps/tauri/pull/4042)) on 2022-05-04 + +## \[1.0.0-rc.9] + +- Exit CLI when Cargo returns a non-compilation error in `tauri dev`. + - [b5622882](https://www.github.com/tauri-apps/tauri/commit/b5622882cf3748e1e5a90915f415c0cd922aaaf8) fix(cli): exit on non-compilation Cargo errors, closes [#3930](https://www.github.com/tauri-apps/tauri/pull/3930) ([#3942](https://www.github.com/tauri-apps/tauri/pull/3942)) on 2022-04-22 +- Notify CLI update when running `tauri dev`. + - [a649aad7](https://www.github.com/tauri-apps/tauri/commit/a649aad7ad26d4578699370d6e63d80edeca1f97) feat(cli): check and notify about updates on `tauri dev`, closes [#3789](https://www.github.com/tauri-apps/tauri/pull/3789) ([#3960](https://www.github.com/tauri-apps/tauri/pull/3960)) on 2022-04-25 +- Kill the `beforeDevCommand` and app processes if the dev command returns an error. + - [485c9743](https://www.github.com/tauri-apps/tauri/commit/485c97438ac956d86bcf3794ceaa626bef968a4e) fix(cli): kill beforeDevCommand if dev code returns an error ([#3907](https://www.github.com/tauri-apps/tauri/pull/3907)) on 2022-04-19 +- Fix `info` command showing outdated text for latest versions. + - [73a4b74a](https://www.github.com/tauri-apps/tauri/commit/73a4b74aea8544e6fda51c1f6697630b0768072c) fix(cli.rs/info): don't show outdated text for latest versions ([#3829](https://www.github.com/tauri-apps/tauri/pull/3829)) on 2022-04-02 +- **Breaking change:** Enable default Cargo features except `tauri/custom-protocol` on the dev command. + - [f2a30d8b](https://www.github.com/tauri-apps/tauri/commit/f2a30d8bc54fc3ba49e16f69a413eca5f61a9b1f) refactor(core): use ayatana appindicator by default, keep option to use gtk ([#3916](https://www.github.com/tauri-apps/tauri/pull/3916)) on 2022-04-19 +- Kill the `beforeDevCommand` process recursively on Unix. + - [e251e1b0](https://www.github.com/tauri-apps/tauri/commit/e251e1b0991d26ab10aea33cfb228f3e7f0f85b5) fix(cli): kill before dev command recursively on Unix, closes [#2794](https://www.github.com/tauri-apps/tauri/pull/2794) ([#3848](https://www.github.com/tauri-apps/tauri/pull/3848)) on 2022-04-03 + +## \[1.0.0-rc.8] + +- Allows the `tauri.conf.json` file to be git ignored on the path lookup function. + - [cc7c2d77](https://www.github.com/tauri-apps/tauri/commit/cc7c2d77da2e4a39ec2a97b080d41a719e6d0161) feat(cli): allow conf path to be gitignored, closes [#3636](https://www.github.com/tauri-apps/tauri/pull/3636) ([#3683](https://www.github.com/tauri-apps/tauri/pull/3683)) on 2022-03-13 +- Remove `minimumSystemVersion: null` from the application template configuration. + - [c81534eb](https://www.github.com/tauri-apps/tauri/commit/c81534ebd873c358e0346c7949aeb171803149a5) feat(cli): use default macOS minimum system version when it is empty ([#3658](https://www.github.com/tauri-apps/tauri/pull/3658)) on 2022-03-13 +- Improve readability of the `info` subcommand output. + - [49d2f13f](https://www.github.com/tauri-apps/tauri/commit/49d2f13fc07d763d5de9bf4b19d00c901776c11d) feat(cli): colorful cli ([#3635](https://www.github.com/tauri-apps/tauri/pull/3635)) on 2022-03-08 +- Fixes DMG bundling on macOS 12.3. + - [348a1ab5](https://www.github.com/tauri-apps/tauri/commit/348a1ab59d2697478a594016016f1fccbf1ac054) fix(bundler): DMG bundling on macOS 12.3 cannot use bless, closes [#3719](https://www.github.com/tauri-apps/tauri/pull/3719) ([#3721](https://www.github.com/tauri-apps/tauri/pull/3721)) on 2022-03-18 +- Fixes resources bundling on Windows when the path is on the root of the Tauri folder. + - [4c84559e](https://www.github.com/tauri-apps/tauri/commit/4c84559e1f3019e7aa2666b10a1a0bd97bb09d24) fix(cli): root resource bundling on Windows, closes [#3539](https://www.github.com/tauri-apps/tauri/pull/3539) ([#3685](https://www.github.com/tauri-apps/tauri/pull/3685)) on 2022-03-13 + +## \[1.0.0-rc.6] + +- Added `tsp` config option under `tauri > bundle > windows`, which enables Time-Stamp Protocol (RFC 3161) for the timestamping + server under code signing on Windows if set to `true`. + - [bdd5f7c2](https://www.github.com/tauri-apps/tauri/commit/bdd5f7c2f03af4af8b60a9527e55bb18525d989b) fix: add support for Time-Stamping Protocol for Windows codesigning (fix [#3563](https://www.github.com/tauri-apps/tauri/pull/3563)) ([#3570](https://www.github.com/tauri-apps/tauri/pull/3570)) on 2022-03-07 +- Added `i686-pc-windows-msvc` to the prebuilt targets. + - [fb6744da](https://www.github.com/tauri-apps/tauri/commit/fb6744daa45165c7e00e5c01f7df0880d69ca509) feat(cli.js): add 32bit cli for windows ([#3540](https://www.github.com/tauri-apps/tauri/pull/3540)) on 2022-02-24 +- Change the `plugin init` templates to use the new `tauri::plugin::Builder` syntax. + - [f7acb061](https://www.github.com/tauri-apps/tauri/commit/f7acb061e4d1ecdbfe182793587632d7ba6d8eff) feat(cli): use plugin::Builder syntax on the plugin template ([#3606](https://www.github.com/tauri-apps/tauri/pull/3606)) on 2022-03-03 + +## \[1.0.0-rc.5] + +- Improve "waiting for your dev server to start" message. + - [5999379f](https://www.github.com/tauri-apps/tauri/commit/5999379fb06052a115f04f99274ab46d1eefd659) chore(cli): improve "waiting for dev server" message, closes [#3491](https://www.github.com/tauri-apps/tauri/pull/3491) ([#3504](https://www.github.com/tauri-apps/tauri/pull/3504)) on 2022-02-18 +- Do not panic if the updater private key password is wrong. + - [17f17a80](https://www.github.com/tauri-apps/tauri/commit/17f17a80f818bcc20c387583a6ff00a8e07ec533) fix(cli): do not panic if private key password is wrong, closes [#3449](https://www.github.com/tauri-apps/tauri/pull/3449) ([#3495](https://www.github.com/tauri-apps/tauri/pull/3495)) on 2022-02-17 +- Check the current folder before checking the directories on the app and tauri dir path lookup function. + - [a06de376](https://www.github.com/tauri-apps/tauri/commit/a06de3760184caa71acfe7a2fe2189a033b565f5) fix(cli): path lookup should not check subfolder before the current one ([#3465](https://www.github.com/tauri-apps/tauri/pull/3465)) on 2022-02-15 +- Fixes the signature of the `signer sign` command to not have duplicated short flags. + - [a9755514](https://www.github.com/tauri-apps/tauri/commit/a975551461f3698db3f3b6afa5101189aaeeada9) fix(cli): duplicated short flag for `signer sign`, closes [#3483](https://www.github.com/tauri-apps/tauri/pull/3483) ([#3492](https://www.github.com/tauri-apps/tauri/pull/3492)) on 2022-02-17 + +## \[1.0.0-rc.4] + +- Change the `run` function to take a callback and run asynchronously instead of blocking the event loop. + - [cd9a20b9](https://www.github.com/tauri-apps/tauri/commit/cd9a20b9ab013759b4bdb742f358988022450795) refactor(cli.js): run on separate thread ([#3436](https://www.github.com/tauri-apps/tauri/pull/3436)) on 2022-02-13 +- Improve error message when the dev runner command fails. + - [759d1afb](https://www.github.com/tauri-apps/tauri/commit/759d1afb86f3657f6071a2ae39c9be21e20ed22c) feat(cli): improve error message when dev runner command fails ([#3447](https://www.github.com/tauri-apps/tauri/pull/3447)) on 2022-02-13 +- Show full error message from `cli.rs` instead of just the outermost underlying error message. + - [63826010](https://www.github.com/tauri-apps/tauri/commit/63826010d1f38544f36afd3aac67c45d4608d15b) feat(cli.js): show full error message ([#3442](https://www.github.com/tauri-apps/tauri/pull/3442)) on 2022-02-13 +- Increase `tauri.conf.json` directory lookup depth to `3` and allow changing it with the `TAURI_PATH_DEPTH` environment variable. + - [c6031c70](https://www.github.com/tauri-apps/tauri/commit/c6031c7070c6bb7539bbfdfe42cb73012829c910) feat(cli): increase lookup depth, add env var option ([#3451](https://www.github.com/tauri-apps/tauri/pull/3451)) on 2022-02-13 +- Added `tauri-build`, `tao` and `wry` version to the `info` command output. + - [16f1173f](https://www.github.com/tauri-apps/tauri/commit/16f1173f456b1db543d0160df2c9828708bfc68a) feat(cli): add tao and wry version to the `info` output ([#3443](https://www.github.com/tauri-apps/tauri/pull/3443)) on 2022-02-13 + +## \[1.0.0-rc.3] + +- Change default value for the `freezePrototype` configuration to `false`. + - Bumped due to a bump in cli.rs. + - [3a4c0160](https://www.github.com/tauri-apps/tauri/commit/3a4c01606184be762adee055ddac803de0d28527) fix(core): change default `freezePrototype` to false, closes [#3416](https://www.github.com/tauri-apps/tauri/pull/3416) [#3406](https://www.github.com/tauri-apps/tauri/pull/3406) ([#3423](https://www.github.com/tauri-apps/tauri/pull/3423)) on 2022-02-12 + +## \[1.0.0-rc.2] + +- Fixes Tauri path resolution on projects without Git or a `.gitignore` file. + - [d8acbe11](https://www.github.com/tauri-apps/tauri/commit/d8acbe11492bd990e6983c7e63e0f1a8f1ea5c7c) fix(cli.rs): app path resolution on projects without git, closes [#3409](https://www.github.com/tauri-apps/tauri/pull/3409) ([#3410](https://www.github.com/tauri-apps/tauri/pull/3410)) on 2022-02-11 + +## \[1.0.0-rc.1] + +- Fix `init` command prompting for values even if the argument has been provided on the command line. + - [def76840](https://www.github.com/tauri-apps/tauri/commit/def76840257a1447723ecda13c807cf0c881f083) fix(cli.rs): do not prompt for `init` values if arg set ([#3400](https://www.github.com/tauri-apps/tauri/pull/3400)) on 2022-02-11 + - [41052dee](https://www.github.com/tauri-apps/tauri/commit/41052deeda2a00ee2b8ec2041c9c87c11de82ab2) fix(covector): add cli.js to change files on 2022-02-11 +- Fixes CLI freezing when running `light.exe` on Windows without the `--verbose` flag. + - [8beab636](https://www.github.com/tauri-apps/tauri/commit/8beab6363491e2a8757cc9fc0fa1eccc98ece916) fix(cli): build freezing on Windows, closes [#3399](https://www.github.com/tauri-apps/tauri/pull/3399) ([#3402](https://www.github.com/tauri-apps/tauri/pull/3402)) on 2022-02-11 +- Respect `.gitignore` configuration when looking for the folder with the `tauri.conf.json` file. + - [9c6c5a8c](https://www.github.com/tauri-apps/tauri/commit/9c6c5a8c52c6460d0b0a1a55300e1828262994ba) perf(cli.rs): improve performance of tauri dir lookup reading .gitignore ([#3405](https://www.github.com/tauri-apps/tauri/pull/3405)) on 2022-02-11 + - [41052dee](https://www.github.com/tauri-apps/tauri/commit/41052deeda2a00ee2b8ec2041c9c87c11de82ab2) fix(covector): add cli.js to change files on 2022-02-11 + +## \[1.0.0-rc.0] + +- Do not force Tauri application code on `src-tauri` folder and use a glob pattern to look for a subfolder with a `tauri.conf.json` file. + - [a8cff6b3](https://www.github.com/tauri-apps/tauri/commit/a8cff6b3bc3288a53d7cdc5b3cb95d371309d2d6) feat(cli): do not enforce `src-tauri` folder structure, closes [#2643](https://www.github.com/tauri-apps/tauri/pull/2643) ([#2654](https://www.github.com/tauri-apps/tauri/pull/2654)) on 2021-09-27 +- Added CommonJS output to the `dist` folder. + - [205b0dc8](https://www.github.com/tauri-apps/tauri/commit/205b0dc8f30bf70902979a2c0a08c8bc8c8e5360) feat(cli.js): add CommonJS dist files ([#2646](https://www.github.com/tauri-apps/tauri/pull/2646)) on 2021-09-23 +- Fixes `.ico` icon generation. + - [11db96e4](https://www.github.com/tauri-apps/tauri/commit/11db96e440e6cadc1c70992d07bfea3c448208b1) fix(cli.js): `.ico` icon generation, closes [#2692](https://www.github.com/tauri-apps/tauri/pull/2692) ([#2694](https://www.github.com/tauri-apps/tauri/pull/2694)) on 2021-10-02 +- Automatically unplug `@tauri-apps/cli` in yarn 2+ installations to fix the download of the rust-cli. + - [1e336b68](https://www.github.com/tauri-apps/tauri/commit/1e336b6872c3b78caf7c2c6e71e03016c6abdacf) fix(cli.js): Fix package installation on yarn 2+ ([#3012](https://www.github.com/tauri-apps/tauri/pull/3012)) on 2021-12-09 +- Read `package.json` and check for a `tauri` object containing the `appPath` string, which points to the tauri crate path. + - [fb2b9a52](https://www.github.com/tauri-apps/tauri/commit/fb2b9a52f594830c0a68ea40ea429a09892f7ba7) feat(cli.js): allow configuring tauri app path on package.json [#2752](https://www.github.com/tauri-apps/tauri/pull/2752) ([#3035](https://www.github.com/tauri-apps/tauri/pull/3035)) on 2021-12-09 +- Removed the `icon` command, now exposed as a separate package, see https://github.com/tauri-apps/tauricon. + - [58030172](https://www.github.com/tauri-apps/tauri/commit/58030172eddb2403a84b56a21b5bdcebca42c265) feat(tauricon): remove from cli ([#3293](https://www.github.com/tauri-apps/tauri/pull/3293)) on 2022-02-07 diff --git a/scripts/node_modules/@tauri-apps/cli/LICENSE_APACHE-2.0 b/scripts/node_modules/@tauri-apps/cli/LICENSE_APACHE-2.0 new file mode 100644 index 0000000000000000000000000000000000000000..f433b1a53f5b830a205fd2df78e2b34974656c7b --- /dev/null +++ b/scripts/node_modules/@tauri-apps/cli/LICENSE_APACHE-2.0 @@ -0,0 +1,177 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS diff --git a/scripts/node_modules/@tauri-apps/cli/LICENSE_MIT b/scripts/node_modules/@tauri-apps/cli/LICENSE_MIT new file mode 100644 index 0000000000000000000000000000000000000000..b08530d59433b3060f4fad8751ac2610c0b0aff3 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/cli/LICENSE_MIT @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2017 - Present Tauri Apps 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/scripts/node_modules/@tauri-apps/cli/README.md b/scripts/node_modules/@tauri-apps/cli/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2255c26b691afdfec73cd4390209dbba97e2d783 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/cli/README.md @@ -0,0 +1,52 @@ +# @tauri-apps/cli + + + +[![status](https://img.shields.io/badge/status-stable-blue.svg)](https://github.com/tauri-apps/tauri/tree/dev) +[![License](https://img.shields.io/badge/License-MIT%20or%20Apache%202-green.svg)](https://opencollective.com/tauri) +[![test cli](https://img.shields.io/github/actions/workflow/status/tauri-apps/tauri/test-cli-js.yml?label=test%20cli&logo=github)](https://github.com/tauri-apps/tauri/actions/workflows/test-cli-js.yml) +[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Ftauri-apps%2Ftauri.svg?type=shield)](https://app.fossa.com/projects/git%2Bgithub.com%2Ftauri-apps%2Ftauri?ref=badge_shield) +[![Chat Server](https://img.shields.io/badge/chat-discord-7289da.svg)](https://discord.gg/SpmNs4S) +[![website](https://img.shields.io/badge/website-tauri.app-purple.svg)](https://tauri.app) +[![https://good-labs.github.io/greater-good-affirmation/assets/images/badge.svg](https://good-labs.github.io/greater-good-affirmation/assets/images/badge.svg)](https://good-labs.github.io/greater-good-affirmation) +[![support](https://img.shields.io/badge/sponsor-Open%20Collective-blue.svg)](https://opencollective.com/tauri) + +| Component | Version | +| --------------- | ----------------------------------------------------- | +| @tauri-apps/cli | ![](https://img.shields.io/npm/v/@tauri-apps/cli.svg) | + +## About Tauri + +Tauri is a polyglot and generic system that is very composable and allows engineers to make a wide variety of applications. It is used for building applications for Desktop Computers using a combination of Rust tools and HTML rendered in a Webview. Apps built with Tauri can ship with any number of pieces of an optional JS API / Rust API so that webviews can control the system via message passing. In fact, developers can extend the default API with their own functionality and bridge the Webview and Rust-based backend easily. + +Tauri apps can have custom menus and have tray-type interfaces. They can be updated, and are managed by the user's operating system as expected. They are very small, because they use the system's webview. They do not ship a runtime, since the final binary is compiled from rust. This makes the reversing of Tauri apps not a trivial task. + +## This module + +Written in Typescript and packaged such that it can be used with `npm`, `pnpm`, `yarn`, and `bun`, this library provides a node.js runner for common tasks when using Tauri, like `pnpm tauri dev`. For the most part it is a wrapper around [tauri-cli](https://github.com/tauri-apps/tauri/blob/dev/crates/tauri-cli). + +To learn more about the details of how all of these pieces fit together, please consult this [ARCHITECTURE.md](https://github.com/tauri-apps/tauri/blob/dev/ARCHITECTURE.md) document. + +## Installation + +The preferred method is to install this module locally as a development dependency: + +``` +$ pnpm add -D @tauri-apps/cli +$ yarn add -D @tauri-apps/cli +$ npm add -D @tauri-apps/cli +``` + +## Semver + +**tauri** is following [Semantic Versioning 2.0](https://semver.org/). + +## Licenses + +Code: (c) 2019 - 2021 - The Tauri Programme within The Commons Conservancy. + +MIT or MIT/Apache 2.0 where applicable. + +Logo: CC-BY-NC-ND + +- Original Tauri Logo Designs by [Daniel Thompson-Yvetot](https://github.com/nothingismagick) and [Guillaume Chau](https://github.com/akryum) diff --git a/scripts/node_modules/@tauri-apps/cli/append-headers.js b/scripts/node_modules/@tauri-apps/cli/append-headers.js new file mode 100644 index 0000000000000000000000000000000000000000..22c6768e0d73a817d3682268683c00f2a3cf780e --- /dev/null +++ b/scripts/node_modules/@tauri-apps/cli/append-headers.js @@ -0,0 +1,15 @@ +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT + +const HEADERS = `// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT` + +const fs = require('fs') + +for (const file of ['index.js', 'index.d.ts']) { + const content = fs.readFileSync(file, 'utf8') + const newContent = `${HEADERS}\n\n${content}` + fs.writeFileSync(file, newContent, 'utf8') +} diff --git a/scripts/node_modules/@tauri-apps/cli/config.schema.json b/scripts/node_modules/@tauri-apps/cli/config.schema.json new file mode 100644 index 0000000000000000000000000000000000000000..664b695e186a9d1944455e3406b518b8341fb9b7 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/cli/config.schema.json @@ -0,0 +1,3846 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "$id": "https://schema.tauri.app/config/2.10.3", + "title": "Config", + "description": "The Tauri configuration object.\n It is read from a file where you can define your frontend assets,\n configure the bundler and define a tray icon.\n\n The configuration file is generated by the\n [`tauri init`](https://v2.tauri.app/reference/cli/#init) command that lives in\n your Tauri application source directory (src-tauri).\n\n Once generated, you may modify it at will to customize your Tauri application.\n\n ## File Formats\n\n By default, the configuration is defined as a JSON file named `tauri.conf.json`.\n\n Tauri also supports JSON5 and TOML files via the `config-json5` and `config-toml` Cargo features, respectively.\n The JSON5 file name must be either `tauri.conf.json` or `tauri.conf.json5`.\n The TOML file name is `Tauri.toml`.\n\n ## Platform-Specific Configuration\n\n In addition to the default configuration file, Tauri can\n read a platform-specific configuration from `tauri.linux.conf.json`,\n `tauri.windows.conf.json`, `tauri.macos.conf.json`, `tauri.android.conf.json` and `tauri.ios.conf.json`\n (or `Tauri.linux.toml`, `Tauri.windows.toml`, `Tauri.macos.toml`, `Tauri.android.toml` and `Tauri.ios.toml` if the `Tauri.toml` format is used),\n which gets merged with the main configuration object.\n\n ## Configuration Structure\n\n The configuration is composed of the following objects:\n\n - [`app`](#appconfig): The Tauri configuration\n - [`build`](#buildconfig): The build configuration\n - [`bundle`](#bundleconfig): The bundle configurations\n - [`plugins`](#pluginconfig): The plugins configuration\n\n Example tauri.config.json file:\n\n ```json\n {\n \"productName\": \"tauri-app\",\n \"version\": \"0.1.0\",\n \"build\": {\n \"beforeBuildCommand\": \"\",\n \"beforeDevCommand\": \"\",\n \"devUrl\": \"http://localhost:3000\",\n \"frontendDist\": \"../dist\"\n },\n \"app\": {\n \"security\": {\n \"csp\": null\n },\n \"windows\": [\n {\n \"fullscreen\": false,\n \"height\": 600,\n \"resizable\": true,\n \"title\": \"Tauri App\",\n \"width\": 800\n }\n ]\n },\n \"bundle\": {},\n \"plugins\": {}\n }\n ```", + "type": "object", + "required": [ + "identifier" + ], + "properties": { + "$schema": { + "description": "The JSON schema for the Tauri config.", + "type": [ + "string", + "null" + ] + }, + "productName": { + "description": "App name.", + "type": [ + "string", + "null" + ], + "pattern": "^[^/\\:*?\"<>|]+$" + }, + "mainBinaryName": { + "description": "Overrides app's main binary filename.\n\n By default, Tauri uses the output binary from `cargo`, by setting this, we will rename that binary in `tauri-cli`'s\n `tauri build` command, and target `tauri bundle` to it\n\n If possible, change the [`package name`] or set the [`name field`] instead,\n and if that's not enough and you're using nightly, consider using the [`different-binary-name`] feature instead\n\n Note: this config should not include the binary extension (e.g. `.exe`), we'll add that for you\n\n [`package name`]: https://doc.rust-lang.org/cargo/reference/manifest.html#the-name-field\n [`name field`]: https://doc.rust-lang.org/cargo/reference/cargo-targets.html#the-name-field\n [`different-binary-name`]: https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#different-binary-name", + "type": [ + "string", + "null" + ] + }, + "version": { + "description": "App version. It is a semver version number or a path to a `package.json` file containing the `version` field.\n\n If removed the version number from `Cargo.toml` is used.\n It's recommended to manage the app versioning in the Tauri config.\n\n ## Platform-specific\n\n - **macOS**: Translates to the bundle's CFBundleShortVersionString property and is used as the default CFBundleVersion.\n You can set an specific bundle version using [`bundle > macOS > bundleVersion`](MacConfig::bundle_version).\n - **iOS**: Translates to the bundle's CFBundleShortVersionString property and is used as the default CFBundleVersion.\n You can set an specific bundle version using [`bundle > iOS > bundleVersion`](IosConfig::bundle_version).\n The `tauri ios build` CLI command has a `--build-number ` option that lets you append a build number to the app version.\n - **Android**: By default version 1.0 is used. You can set a version code using [`bundle > android > versionCode`](AndroidConfig::version_code).\n\n By default version 1.0 is used on Android.", + "type": [ + "string", + "null" + ] + }, + "identifier": { + "description": "The application identifier in reverse domain name notation (e.g. `com.tauri.example`).\n This string must be unique across applications since it is used in system configurations like\n the bundle ID and path to the webview data directory.\n This string must contain only alphanumeric characters (A-Z, a-z, and 0-9), hyphens (-),\n and periods (.).", + "type": "string" + }, + "app": { + "description": "The App configuration.", + "default": { + "enableGTKAppId": false, + "macOSPrivateApi": false, + "security": { + "assetProtocol": { + "enable": false, + "scope": [] + }, + "capabilities": [], + "dangerousDisableAssetCspModification": false, + "freezePrototype": false, + "pattern": { + "use": "brownfield" + } + }, + "windows": [], + "withGlobalTauri": false + }, + "allOf": [ + { + "$ref": "#/definitions/AppConfig" + } + ] + }, + "build": { + "description": "The build configuration.", + "default": { + "additionalWatchFolders": [], + "removeUnusedCommands": false + }, + "allOf": [ + { + "$ref": "#/definitions/BuildConfig" + } + ] + }, + "bundle": { + "description": "The bundler configuration.", + "default": { + "active": false, + "android": { + "autoIncrementVersionCode": false, + "minSdkVersion": 24 + }, + "createUpdaterArtifacts": false, + "iOS": { + "minimumSystemVersion": "14.0" + }, + "icon": [], + "linux": { + "appimage": { + "bundleMediaFramework": false, + "files": {} + }, + "deb": { + "files": {} + }, + "rpm": { + "epoch": 0, + "files": {}, + "release": "1" + } + }, + "macOS": { + "dmg": { + "appPosition": { + "x": 180, + "y": 170 + }, + "applicationFolderPosition": { + "x": 480, + "y": 170 + }, + "windowSize": { + "height": 400, + "width": 660 + } + }, + "files": {}, + "hardenedRuntime": true, + "minimumSystemVersion": "10.13" + }, + "targets": "all", + "useLocalToolsDir": false, + "windows": { + "allowDowngrades": true, + "certificateThumbprint": null, + "digestAlgorithm": null, + "nsis": null, + "signCommand": null, + "timestampUrl": null, + "tsp": false, + "webviewInstallMode": { + "silent": true, + "type": "downloadBootstrapper" + }, + "wix": null + } + }, + "allOf": [ + { + "$ref": "#/definitions/BundleConfig" + } + ] + }, + "plugins": { + "description": "The plugins config.", + "default": {}, + "allOf": [ + { + "$ref": "#/definitions/PluginConfig" + } + ] + } + }, + "additionalProperties": false, + "definitions": { + "AppConfig": { + "description": "The App configuration object.\n\n See more: ", + "type": "object", + "properties": { + "windows": { + "description": "The app windows configuration.\n\n ## Example:\n\n To create a window at app startup\n\n ```json\n {\n \"app\": {\n \"windows\": [\n { \"width\": 800, \"height\": 600 }\n ]\n }\n }\n ```\n\n If not specified, the window's label (its identifier) defaults to \"main\",\n you can use this label to get the window through\n `app.get_webview_window` in Rust or `WebviewWindow.getByLabel` in JavaScript\n\n When working with multiple windows, each window will need an unique label\n\n ```json\n {\n \"app\": {\n \"windows\": [\n { \"label\": \"main\", \"width\": 800, \"height\": 600 },\n { \"label\": \"secondary\", \"width\": 800, \"height\": 600 }\n ]\n }\n }\n ```\n\n You can also set `create` to false and use this config through the Rust APIs\n\n ```json\n {\n \"app\": {\n \"windows\": [\n { \"create\": false, \"width\": 800, \"height\": 600 }\n ]\n }\n }\n ```\n\n and use it like this\n\n ```rust\n tauri::Builder::default()\n .setup(|app| {\n tauri::WebviewWindowBuilder::from_config(app.handle(), &app.config().app.windows[0])?.build()?;\n Ok(())\n });\n ```", + "default": [], + "type": "array", + "items": { + "$ref": "#/definitions/WindowConfig" + } + }, + "security": { + "description": "Security configuration.", + "default": { + "assetProtocol": { + "enable": false, + "scope": [] + }, + "capabilities": [], + "dangerousDisableAssetCspModification": false, + "freezePrototype": false, + "pattern": { + "use": "brownfield" + } + }, + "allOf": [ + { + "$ref": "#/definitions/SecurityConfig" + } + ] + }, + "trayIcon": { + "description": "Configuration for app tray icon.", + "anyOf": [ + { + "$ref": "#/definitions/TrayIconConfig" + }, + { + "type": "null" + } + ] + }, + "macOSPrivateApi": { + "description": "MacOS private API configuration. Enables the transparent background API and sets the `fullScreenEnabled` preference to `true`.", + "default": false, + "type": "boolean" + }, + "withGlobalTauri": { + "description": "Whether we should inject the Tauri API on `window.__TAURI__` or not.", + "default": false, + "type": "boolean" + }, + "enableGTKAppId": { + "description": "If set to true \"identifier\" will be set as GTK app ID (on systems that use GTK).", + "default": false, + "type": "boolean" + } + }, + "additionalProperties": false + }, + "WindowConfig": { + "description": "The window configuration object.\n\n See more: ", + "type": "object", + "properties": { + "label": { + "description": "The window identifier. It must be alphanumeric.", + "default": "main", + "type": "string" + }, + "create": { + "description": "Whether Tauri should create this window at app startup or not.\n\n When this is set to `false` you must manually grab the config object via `app.config().app.windows`\n and create it with [`WebviewWindowBuilder::from_config`](https://docs.rs/tauri/2/tauri/webview/struct.WebviewWindowBuilder.html#method.from_config).\n\n ## Example:\n\n ```rust\n tauri::Builder::default()\n .setup(|app| {\n tauri::WebviewWindowBuilder::from_config(app.handle(), &app.config().app.windows[0])?.build()?;\n Ok(())\n });\n ```", + "default": true, + "type": "boolean" + }, + "url": { + "description": "The window webview URL.", + "default": "index.html", + "allOf": [ + { + "$ref": "#/definitions/WebviewUrl" + } + ] + }, + "userAgent": { + "description": "The user agent for the webview", + "type": [ + "string", + "null" + ] + }, + "dragDropEnabled": { + "description": "Whether the drag and drop is enabled or not on the webview. By default it is enabled.\n\n Disabling it is required to use HTML5 drag and drop on the frontend on Windows.", + "default": true, + "type": "boolean" + }, + "center": { + "description": "Whether or not the window starts centered or not.", + "default": false, + "type": "boolean" + }, + "x": { + "description": "The horizontal position of the window's top left corner in logical pixels", + "type": [ + "number", + "null" + ], + "format": "double" + }, + "y": { + "description": "The vertical position of the window's top left corner in logical pixels", + "type": [ + "number", + "null" + ], + "format": "double" + }, + "width": { + "description": "The window width in logical pixels.", + "default": 800.0, + "type": "number", + "format": "double" + }, + "height": { + "description": "The window height in logical pixels.", + "default": 600.0, + "type": "number", + "format": "double" + }, + "minWidth": { + "description": "The min window width in logical pixels.", + "type": [ + "number", + "null" + ], + "format": "double" + }, + "minHeight": { + "description": "The min window height in logical pixels.", + "type": [ + "number", + "null" + ], + "format": "double" + }, + "maxWidth": { + "description": "The max window width in logical pixels.", + "type": [ + "number", + "null" + ], + "format": "double" + }, + "maxHeight": { + "description": "The max window height in logical pixels.", + "type": [ + "number", + "null" + ], + "format": "double" + }, + "preventOverflow": { + "description": "Whether or not to prevent the window from overflowing the workarea\n\n ## Platform-specific\n\n - **iOS / Android:** Unsupported.", + "anyOf": [ + { + "$ref": "#/definitions/PreventOverflowConfig" + }, + { + "type": "null" + } + ] + }, + "resizable": { + "description": "Whether the window is resizable or not. When resizable is set to false, native window's maximize button is automatically disabled.", + "default": true, + "type": "boolean" + }, + "maximizable": { + "description": "Whether the window's native maximize button is enabled or not.\n If resizable is set to false, this setting is ignored.\n\n ## Platform-specific\n\n - **macOS:** Disables the \"zoom\" button in the window titlebar, which is also used to enter fullscreen mode.\n - **Linux / iOS / Android:** Unsupported.", + "default": true, + "type": "boolean" + }, + "minimizable": { + "description": "Whether the window's native minimize button is enabled or not.\n\n ## Platform-specific\n\n - **Linux / iOS / Android:** Unsupported.", + "default": true, + "type": "boolean" + }, + "closable": { + "description": "Whether the window's native close button is enabled or not.\n\n ## Platform-specific\n\n - **Linux:** \"GTK+ will do its best to convince the window manager not to show a close button.\n Depending on the system, this function may not have any effect when called on a window that is already visible\"\n - **iOS / Android:** Unsupported.", + "default": true, + "type": "boolean" + }, + "title": { + "description": "The window title.", + "default": "Tauri App", + "type": "string" + }, + "fullscreen": { + "description": "Whether the window starts as fullscreen or not.", + "default": false, + "type": "boolean" + }, + "focus": { + "description": "Whether the window will be initially focused or not.", + "default": true, + "type": "boolean" + }, + "focusable": { + "description": "Whether the window will be focusable or not.", + "default": true, + "type": "boolean" + }, + "transparent": { + "description": "Whether the window is transparent or not.\n\n Note that on `macOS` this requires the `macos-private-api` feature flag, enabled under `tauri > macOSPrivateApi`.\n WARNING: Using private APIs on `macOS` prevents your application from being accepted to the `App Store`.", + "default": false, + "type": "boolean" + }, + "maximized": { + "description": "Whether the window is maximized or not.", + "default": false, + "type": "boolean" + }, + "visible": { + "description": "Whether the window is visible or not.", + "default": true, + "type": "boolean" + }, + "decorations": { + "description": "Whether the window should have borders and bars.", + "default": true, + "type": "boolean" + }, + "alwaysOnBottom": { + "description": "Whether the window should always be below other windows.", + "default": false, + "type": "boolean" + }, + "alwaysOnTop": { + "description": "Whether the window should always be on top of other windows.", + "default": false, + "type": "boolean" + }, + "visibleOnAllWorkspaces": { + "description": "Whether the window should be visible on all workspaces or virtual desktops.\n\n ## Platform-specific\n\n - **Windows / iOS / Android:** Unsupported.", + "default": false, + "type": "boolean" + }, + "contentProtected": { + "description": "Prevents the window contents from being captured by other apps.", + "default": false, + "type": "boolean" + }, + "skipTaskbar": { + "description": "If `true`, hides the window icon from the taskbar on Windows and Linux.", + "default": false, + "type": "boolean" + }, + "windowClassname": { + "description": "The name of the window class created on Windows to create the window. **Windows only**.", + "type": [ + "string", + "null" + ] + }, + "theme": { + "description": "The initial window theme. Defaults to the system theme. Only implemented on Windows and macOS 10.14+.", + "anyOf": [ + { + "$ref": "#/definitions/Theme" + }, + { + "type": "null" + } + ] + }, + "titleBarStyle": { + "description": "The style of the macOS title bar.", + "default": "Visible", + "allOf": [ + { + "$ref": "#/definitions/TitleBarStyle" + } + ] + }, + "trafficLightPosition": { + "description": "The position of the window controls on macOS.\n\n Requires titleBarStyle: Overlay and decorations: true.", + "anyOf": [ + { + "$ref": "#/definitions/LogicalPosition" + }, + { + "type": "null" + } + ] + }, + "hiddenTitle": { + "description": "If `true`, sets the window title to be hidden on macOS.", + "default": false, + "type": "boolean" + }, + "acceptFirstMouse": { + "description": "Whether clicking an inactive window also clicks through to the webview on macOS.", + "default": false, + "type": "boolean" + }, + "tabbingIdentifier": { + "description": "Defines the window [tabbing identifier] for macOS.\n\n Windows with matching tabbing identifiers will be grouped together.\n If the tabbing identifier is not set, automatic tabbing will be disabled.\n\n [tabbing identifier]: ", + "type": [ + "string", + "null" + ] + }, + "additionalBrowserArgs": { + "description": "Defines additional browser arguments on Windows. By default wry passes `--disable-features=msWebOOUI,msPdfOOUI,msSmartScreenProtection`\n so if you use this method, you also need to disable these components by yourself if you want.", + "type": [ + "string", + "null" + ] + }, + "shadow": { + "description": "Whether or not the window has shadow.\n\n ## Platform-specific\n\n - **Windows:**\n - `false` has no effect on decorated window, shadow are always ON.\n - `true` will make undecorated window have a 1px white border,\n and on Windows 11, it will have a rounded corners.\n - **Linux:** Unsupported.", + "default": true, + "type": "boolean" + }, + "windowEffects": { + "description": "Window effects.\n\n Requires the window to be transparent.\n\n ## Platform-specific:\n\n - **Windows**: If using decorations or shadows, you may want to try this workaround \n - **Linux**: Unsupported", + "anyOf": [ + { + "$ref": "#/definitions/WindowEffectsConfig" + }, + { + "type": "null" + } + ] + }, + "incognito": { + "description": "Whether or not the webview should be launched in incognito mode.\n\n ## Platform-specific:\n\n - **Android**: Unsupported.", + "default": false, + "type": "boolean" + }, + "parent": { + "description": "Sets the window associated with this label to be the parent of the window to be created.\n\n ## Platform-specific\n\n - **Windows**: This sets the passed parent as an owner window to the window to be created.\n From [MSDN owned windows docs](https://docs.microsoft.com/en-us/windows/win32/winmsg/window-features#owned-windows):\n - An owned window is always above its owner in the z-order.\n - The system automatically destroys an owned window when its owner is destroyed.\n - An owned window is hidden when its owner is minimized.\n - **Linux**: This makes the new window transient for parent, see \n - **macOS**: This adds the window as a child of parent, see ", + "type": [ + "string", + "null" + ] + }, + "proxyUrl": { + "description": "The proxy URL for the WebView for all network requests.\n\n Must be either a `http://` or a `socks5://` URL.\n\n ## Platform-specific\n\n - **macOS**: Requires the `macos-proxy` feature flag and only compiles for macOS 14+.", + "type": [ + "string", + "null" + ], + "format": "uri" + }, + "zoomHotkeysEnabled": { + "description": "Whether page zooming by hotkeys is enabled\n\n ## Platform-specific:\n\n - **Windows**: Controls WebView2's [`IsZoomControlEnabled`](https://learn.microsoft.com/en-us/microsoft-edge/webview2/reference/winrt/microsoft_web_webview2_core/corewebview2settings?view=webview2-winrt-1.0.2420.47#iszoomcontrolenabled) setting.\n - **MacOS / Linux**: Injects a polyfill that zooms in and out with `ctrl/command` + `-/=`,\n 20% in each step, ranging from 20% to 1000%. Requires `webview:allow-set-webview-zoom` permission\n\n - **Android / iOS**: Unsupported.", + "default": false, + "type": "boolean" + }, + "browserExtensionsEnabled": { + "description": "Whether browser extensions can be installed for the webview process\n\n ## Platform-specific:\n\n - **Windows**: Enables the WebView2 environment's [`AreBrowserExtensionsEnabled`](https://learn.microsoft.com/en-us/microsoft-edge/webview2/reference/winrt/microsoft_web_webview2_core/corewebview2environmentoptions?view=webview2-winrt-1.0.2739.15#arebrowserextensionsenabled)\n - **MacOS / Linux / iOS / Android** - Unsupported.", + "default": false, + "type": "boolean" + }, + "useHttpsScheme": { + "description": "Sets whether the custom protocols should use `https://.localhost` instead of the default `http://.localhost` on Windows and Android. Defaults to `false`.\n\n ## Note\n\n Using a `https` scheme will NOT allow mixed content when trying to fetch `http` endpoints and therefore will not match the behavior of the `://localhost` protocols used on macOS and Linux.\n\n ## Warning\n\n Changing this value between releases will change the IndexedDB, cookies and localstorage location and your app will not be able to access the old data.", + "default": false, + "type": "boolean" + }, + "devtools": { + "description": "Enable web inspector which is usually called browser devtools. Enabled by default.\n\n This API works in **debug** builds, but requires `devtools` feature flag to enable it in **release** builds.\n\n ## Platform-specific\n\n - macOS: This will call private functions on **macOS**.\n - Android: Open `chrome://inspect/#devices` in Chrome to get the devtools window. Wry's `WebView` devtools API isn't supported on Android.\n - iOS: Open Safari > Develop > [Your Device Name] > [Your WebView] to get the devtools window.", + "type": [ + "boolean", + "null" + ] + }, + "backgroundColor": { + "description": "Set the window and webview background color.\n\n ## Platform-specific:\n\n - **Windows**: alpha channel is ignored for the window layer.\n - **Windows**: On Windows 7, alpha channel is ignored for the webview layer.\n - **Windows**: On Windows 8 and newer, if alpha channel is not `0`, it will be ignored for the webview layer.", + "anyOf": [ + { + "$ref": "#/definitions/Color" + }, + { + "type": "null" + } + ] + }, + "backgroundThrottling": { + "description": "Change the default background throttling behaviour.\n\n By default, browsers use a suspend policy that will throttle timers and even unload\n the whole tab (view) to free resources after roughly 5 minutes when a view became\n minimized or hidden. This will pause all tasks until the documents visibility state\n changes back from hidden to visible by bringing the view back to the foreground.\n\n ## Platform-specific\n\n - **Linux / Windows / Android**: Unsupported. Workarounds like a pending WebLock transaction might suffice.\n - **iOS**: Supported since version 17.0+.\n - **macOS**: Supported since version 14.0+.\n\n see https://github.com/tauri-apps/tauri/issues/5250#issuecomment-2569380578", + "anyOf": [ + { + "$ref": "#/definitions/BackgroundThrottlingPolicy" + }, + { + "type": "null" + } + ] + }, + "javascriptDisabled": { + "description": "Whether we should disable JavaScript code execution on the webview or not.", + "default": false, + "type": "boolean" + }, + "allowLinkPreview": { + "description": "on macOS and iOS there is a link preview on long pressing links, this is enabled by default.\n see https://docs.rs/objc2-web-kit/latest/objc2_web_kit/struct.WKWebView.html#method.allowsLinkPreview", + "default": true, + "type": "boolean" + }, + "disableInputAccessoryView": { + "description": "Allows disabling the input accessory view on iOS.\n\n The accessory view is the view that appears above the keyboard when a text input element is focused.\n It usually displays a view with \"Done\", \"Next\" buttons.", + "default": false, + "type": "boolean" + }, + "dataDirectory": { + "description": "Set a custom path for the webview's data directory (localStorage, cache, etc.) **relative to [`appDataDir()`]/${label}**.\n\n To set absolute paths, use [`WebviewWindowBuilder::data_directory`](https://docs.rs/tauri/2/tauri/webview/struct.WebviewWindowBuilder.html#method.data_directory)\n\n #### Platform-specific:\n\n - **Windows**: WebViews with different values for settings like `additionalBrowserArgs`, `browserExtensionsEnabled` or `scrollBarStyle` must have different data directories.\n - **macOS / iOS**: Unsupported, use `dataStoreIdentifier` instead.\n - **Android**: Unsupported.", + "type": [ + "string", + "null" + ] + }, + "dataStoreIdentifier": { + "description": "Initialize the WebView with a custom data store identifier. This can be seen as a replacement for `dataDirectory` which is unavailable in WKWebView.\n See https://developer.apple.com/documentation/webkit/wkwebsitedatastore/init(foridentifier:)?language=objc\n\n The array must contain 16 u8 numbers.\n\n #### Platform-specific:\n\n - **iOS**: Supported since version 17.0+.\n - **macOS**: Supported since version 14.0+.\n - **Windows / Linux / Android**: Unsupported.", + "type": [ + "array", + "null" + ], + "items": { + "type": "integer", + "format": "uint8", + "minimum": 0.0 + }, + "maxItems": 16, + "minItems": 16 + }, + "scrollBarStyle": { + "description": "Specifies the native scrollbar style to use with the webview.\n CSS styles that modify the scrollbar are applied on top of the native appearance configured here.\n\n Defaults to `default`, which is the browser default.\n\n ## Platform-specific\n\n - **Windows**:\n - `fluentOverlay` requires WebView2 Runtime version 125.0.2535.41 or higher,\n and does nothing on older versions.\n - This option must be given the same value for all webviews that target the same data directory.\n - **Linux / Android / iOS / macOS**: Unsupported. Only supports `Default` and performs no operation.", + "default": "default", + "allOf": [ + { + "$ref": "#/definitions/ScrollBarStyle" + } + ] + } + }, + "additionalProperties": false + }, + "WebviewUrl": { + "description": "An URL to open on a Tauri webview window.", + "anyOf": [ + { + "description": "An external URL. Must use either the `http` or `https` schemes.", + "type": "string", + "format": "uri" + }, + { + "description": "The path portion of an app URL.\n For instance, to load `tauri://localhost/users/john`,\n you can simply provide `users/john` in this configuration.", + "type": "string" + }, + { + "description": "A custom protocol url, for example, `doom://index.html`", + "type": "string", + "format": "uri" + } + ] + }, + "PreventOverflowConfig": { + "description": "Prevent overflow with a margin", + "anyOf": [ + { + "description": "Enable prevent overflow or not", + "type": "boolean" + }, + { + "description": "Enable prevent overflow with a margin\n so that the window's size + this margin won't overflow the workarea", + "allOf": [ + { + "$ref": "#/definitions/PreventOverflowMargin" + } + ] + } + ] + }, + "PreventOverflowMargin": { + "description": "Enable prevent overflow with a margin\n so that the window's size + this margin won't overflow the workarea", + "type": "object", + "required": [ + "height", + "width" + ], + "properties": { + "width": { + "description": "Horizontal margin in physical pixels", + "type": "integer", + "format": "uint32", + "minimum": 0.0 + }, + "height": { + "description": "Vertical margin in physical pixels", + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + }, + "additionalProperties": false + }, + "Theme": { + "description": "System theme.", + "oneOf": [ + { + "description": "Light theme.", + "type": "string", + "enum": [ + "Light" + ] + }, + { + "description": "Dark theme.", + "type": "string", + "enum": [ + "Dark" + ] + } + ] + }, + "TitleBarStyle": { + "description": "How the window title bar should be displayed on macOS.", + "oneOf": [ + { + "description": "A normal title bar.", + "type": "string", + "enum": [ + "Visible" + ] + }, + { + "description": "Makes the title bar transparent, so the window background color is shown instead.\n\n Useful if you don't need to have actual HTML under the title bar. This lets you avoid the caveats of using `TitleBarStyle::Overlay`. Will be more useful when Tauri lets you set a custom window background color.", + "type": "string", + "enum": [ + "Transparent" + ] + }, + { + "description": "Shows the title bar as a transparent overlay over the window's content.\n\n Keep in mind:\n - The height of the title bar is different on different OS versions, which can lead to window the controls and title not being where you don't expect.\n - You need to define a custom drag region to make your window draggable, however due to a limitation you can't drag the window when it's not in focus .\n - The color of the window title depends on the system theme.", + "type": "string", + "enum": [ + "Overlay" + ] + } + ] + }, + "LogicalPosition": { + "description": "Position coordinates struct.", + "type": "object", + "required": [ + "x", + "y" + ], + "properties": { + "x": { + "description": "X coordinate.", + "type": "number", + "format": "double" + }, + "y": { + "description": "Y coordinate.", + "type": "number", + "format": "double" + } + }, + "additionalProperties": false + }, + "WindowEffectsConfig": { + "description": "The window effects configuration object", + "type": "object", + "required": [ + "effects" + ], + "properties": { + "effects": { + "description": "List of Window effects to apply to the Window.\n Conflicting effects will apply the first one and ignore the rest.", + "type": "array", + "items": { + "$ref": "#/definitions/WindowEffect" + } + }, + "state": { + "description": "Window effect state **macOS Only**", + "anyOf": [ + { + "$ref": "#/definitions/WindowEffectState" + }, + { + "type": "null" + } + ] + }, + "radius": { + "description": "Window effect corner radius **macOS Only**", + "type": [ + "number", + "null" + ], + "format": "double" + }, + "color": { + "description": "Window effect color. Affects [`WindowEffect::Blur`] and [`WindowEffect::Acrylic`] only\n on Windows 10 v1903+. Doesn't have any effect on Windows 7 or Windows 11.", + "anyOf": [ + { + "$ref": "#/definitions/Color" + }, + { + "type": "null" + } + ] + } + }, + "additionalProperties": false + }, + "WindowEffect": { + "description": "Platform-specific window effects", + "oneOf": [ + { + "description": "A default material appropriate for the view's effectiveAppearance. **macOS 10.14-**", + "deprecated": true, + "type": "string", + "enum": [ + "appearanceBased" + ] + }, + { + "description": "**macOS 10.14-**", + "deprecated": true, + "type": "string", + "enum": [ + "light" + ] + }, + { + "description": "**macOS 10.14-**", + "deprecated": true, + "type": "string", + "enum": [ + "dark" + ] + }, + { + "description": "**macOS 10.14-**", + "deprecated": true, + "type": "string", + "enum": [ + "mediumLight" + ] + }, + { + "description": "**macOS 10.14-**", + "deprecated": true, + "type": "string", + "enum": [ + "ultraDark" + ] + }, + { + "description": "**macOS 10.10+**", + "type": "string", + "enum": [ + "titlebar" + ] + }, + { + "description": "**macOS 10.10+**", + "type": "string", + "enum": [ + "selection" + ] + }, + { + "description": "**macOS 10.11+**", + "type": "string", + "enum": [ + "menu" + ] + }, + { + "description": "**macOS 10.11+**", + "type": "string", + "enum": [ + "popover" + ] + }, + { + "description": "**macOS 10.11+**", + "type": "string", + "enum": [ + "sidebar" + ] + }, + { + "description": "**macOS 10.14+**", + "type": "string", + "enum": [ + "headerView" + ] + }, + { + "description": "**macOS 10.14+**", + "type": "string", + "enum": [ + "sheet" + ] + }, + { + "description": "**macOS 10.14+**", + "type": "string", + "enum": [ + "windowBackground" + ] + }, + { + "description": "**macOS 10.14+**", + "type": "string", + "enum": [ + "hudWindow" + ] + }, + { + "description": "**macOS 10.14+**", + "type": "string", + "enum": [ + "fullScreenUI" + ] + }, + { + "description": "**macOS 10.14+**", + "type": "string", + "enum": [ + "tooltip" + ] + }, + { + "description": "**macOS 10.14+**", + "type": "string", + "enum": [ + "contentBackground" + ] + }, + { + "description": "**macOS 10.14+**", + "type": "string", + "enum": [ + "underWindowBackground" + ] + }, + { + "description": "**macOS 10.14+**", + "type": "string", + "enum": [ + "underPageBackground" + ] + }, + { + "description": "Mica effect that matches the system dark preference **Windows 11 Only**", + "type": "string", + "enum": [ + "mica" + ] + }, + { + "description": "Mica effect with dark mode but only if dark mode is enabled on the system **Windows 11 Only**", + "type": "string", + "enum": [ + "micaDark" + ] + }, + { + "description": "Mica effect with light mode **Windows 11 Only**", + "type": "string", + "enum": [ + "micaLight" + ] + }, + { + "description": "Tabbed effect that matches the system dark preference **Windows 11 Only**", + "type": "string", + "enum": [ + "tabbed" + ] + }, + { + "description": "Tabbed effect with dark mode but only if dark mode is enabled on the system **Windows 11 Only**", + "type": "string", + "enum": [ + "tabbedDark" + ] + }, + { + "description": "Tabbed effect with light mode **Windows 11 Only**", + "type": "string", + "enum": [ + "tabbedLight" + ] + }, + { + "description": "**Windows 7/10/11(22H1) Only**\n\n ## Notes\n\n This effect has bad performance when resizing/dragging the window on Windows 11 build 22621.", + "type": "string", + "enum": [ + "blur" + ] + }, + { + "description": "**Windows 10/11 Only**\n\n ## Notes\n\n This effect has bad performance when resizing/dragging the window on Windows 10 v1903+ and Windows 11 build 22000.", + "type": "string", + "enum": [ + "acrylic" + ] + } + ] + }, + "WindowEffectState": { + "description": "Window effect state **macOS only**\n\n ", + "oneOf": [ + { + "description": "Make window effect state follow the window's active state", + "type": "string", + "enum": [ + "followsWindowActiveState" + ] + }, + { + "description": "Make window effect state always active", + "type": "string", + "enum": [ + "active" + ] + }, + { + "description": "Make window effect state always inactive", + "type": "string", + "enum": [ + "inactive" + ] + } + ] + }, + "Color": { + "anyOf": [ + { + "description": "Color hex string, for example: #fff, #ffffff, or #ffffffff.", + "type": "string", + "pattern": "^#?([A-Fa-f0-9]{3}|[A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$" + }, + { + "description": "Array of RGB colors. Each value has minimum of 0 and maximum of 255.", + "type": "array", + "items": [ + { + "type": "integer", + "format": "uint8", + "minimum": 0.0 + }, + { + "type": "integer", + "format": "uint8", + "minimum": 0.0 + }, + { + "type": "integer", + "format": "uint8", + "minimum": 0.0 + } + ], + "maxItems": 3, + "minItems": 3 + }, + { + "description": "Array of RGBA colors. Each value has minimum of 0 and maximum of 255.", + "type": "array", + "items": [ + { + "type": "integer", + "format": "uint8", + "minimum": 0.0 + }, + { + "type": "integer", + "format": "uint8", + "minimum": 0.0 + }, + { + "type": "integer", + "format": "uint8", + "minimum": 0.0 + }, + { + "type": "integer", + "format": "uint8", + "minimum": 0.0 + } + ], + "maxItems": 4, + "minItems": 4 + }, + { + "description": "Object of red, green, blue, alpha color values. Each value has minimum of 0 and maximum of 255.", + "type": "object", + "required": [ + "blue", + "green", + "red" + ], + "properties": { + "red": { + "type": "integer", + "format": "uint8", + "minimum": 0.0 + }, + "green": { + "type": "integer", + "format": "uint8", + "minimum": 0.0 + }, + "blue": { + "type": "integer", + "format": "uint8", + "minimum": 0.0 + }, + "alpha": { + "default": 255, + "type": "integer", + "format": "uint8", + "minimum": 0.0 + } + } + } + ] + }, + "BackgroundThrottlingPolicy": { + "description": "Background throttling policy.", + "oneOf": [ + { + "description": "A policy where background throttling is disabled", + "type": "string", + "enum": [ + "disabled" + ] + }, + { + "description": "A policy where a web view that's not in a window fully suspends tasks. This is usually the default behavior in case no policy is set.", + "type": "string", + "enum": [ + "suspend" + ] + }, + { + "description": "A policy where a web view that's not in a window limits processing, but does not fully suspend tasks.", + "type": "string", + "enum": [ + "throttle" + ] + } + ] + }, + "ScrollBarStyle": { + "description": "The scrollbar style to use in the webview.\n\n ## Platform-specific\n\n - **Windows**: This option must be given the same value for all webviews that target the same data directory.", + "oneOf": [ + { + "description": "The scrollbar style to use in the webview.", + "type": "string", + "enum": [ + "default" + ] + }, + { + "description": "Fluent UI style overlay scrollbars. **Windows Only**\n\n Requires WebView2 Runtime version 125.0.2535.41 or higher, does nothing on older versions,\n see https://learn.microsoft.com/en-us/microsoft-edge/webview2/release-notes/?tabs=dotnetcsharp#10253541", + "type": "string", + "enum": [ + "fluentOverlay" + ] + } + ] + }, + "SecurityConfig": { + "description": "Security configuration.\n\n See more: ", + "type": "object", + "properties": { + "csp": { + "description": "The Content Security Policy that will be injected on all HTML files on the built application.\n If [`dev_csp`](#SecurityConfig.devCsp) is not specified, this value is also injected on dev.\n\n This is a really important part of the configuration since it helps you ensure your WebView is secured.\n See .", + "anyOf": [ + { + "$ref": "#/definitions/Csp" + }, + { + "type": "null" + } + ] + }, + "devCsp": { + "description": "The Content Security Policy that will be injected on all HTML files on development.\n\n This is a really important part of the configuration since it helps you ensure your WebView is secured.\n See .", + "anyOf": [ + { + "$ref": "#/definitions/Csp" + }, + { + "type": "null" + } + ] + }, + "freezePrototype": { + "description": "Freeze the `Object.prototype` when using the custom protocol.", + "default": false, + "type": "boolean" + }, + "dangerousDisableAssetCspModification": { + "description": "Disables the Tauri-injected CSP sources.\n\n At compile time, Tauri parses all the frontend assets and changes the Content-Security-Policy\n to only allow loading of your own scripts and styles by injecting nonce and hash sources.\n This stricts your CSP, which may introduce issues when using along with other flexing sources.\n\n This configuration option allows both a boolean and a list of strings as value.\n A boolean instructs Tauri to disable the injection for all CSP injections,\n and a list of strings indicates the CSP directives that Tauri cannot inject.\n\n **WARNING:** Only disable this if you know what you are doing and have properly configured the CSP.\n Your application might be vulnerable to XSS attacks without this Tauri protection.", + "default": false, + "allOf": [ + { + "$ref": "#/definitions/DisabledCspModificationKind" + } + ] + }, + "assetProtocol": { + "description": "Custom protocol config.", + "default": { + "enable": false, + "scope": [] + }, + "allOf": [ + { + "$ref": "#/definitions/AssetProtocolConfig" + } + ] + }, + "pattern": { + "description": "The pattern to use.", + "default": { + "use": "brownfield" + }, + "allOf": [ + { + "$ref": "#/definitions/PatternKind" + } + ] + }, + "capabilities": { + "description": "List of capabilities that are enabled on the application.\n\n By default (not set or empty list), all capability files from `./capabilities/` are included,\n by setting values in this entry, you have fine grained control over which capabilities are included\n\n You can either reference a capability file defined in `./capabilities/` with its identifier or inline a [`Capability`]\n\n ### Example\n\n ```json\n {\n \"app\": {\n \"capabilities\": [\n \"main-window\",\n {\n \"identifier\": \"drag-window\",\n \"permissions\": [\"core:window:allow-start-dragging\"]\n }\n ]\n }\n }\n ```", + "default": [], + "type": "array", + "items": { + "$ref": "#/definitions/CapabilityEntry" + } + }, + "headers": { + "description": "The headers, which are added to every http response from tauri to the web view\n This doesn't include IPC Messages and error responses", + "anyOf": [ + { + "$ref": "#/definitions/HeaderConfig" + }, + { + "type": "null" + } + ] + } + }, + "additionalProperties": false + }, + "Csp": { + "description": "A Content-Security-Policy definition.\n See .", + "anyOf": [ + { + "description": "The entire CSP policy in a single text string.", + "type": "string" + }, + { + "description": "An object mapping a directive with its sources values as a list of strings.", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/CspDirectiveSources" + } + } + ] + }, + "CspDirectiveSources": { + "description": "A Content-Security-Policy directive source list.\n See .", + "anyOf": [ + { + "description": "An inline list of CSP sources. Same as [`Self::List`], but concatenated with a space separator.", + "type": "string" + }, + { + "description": "A list of CSP sources. The collection will be concatenated with a space separator for the CSP string.", + "type": "array", + "items": { + "type": "string" + } + } + ] + }, + "DisabledCspModificationKind": { + "description": "The possible values for the `dangerous_disable_asset_csp_modification` config option.", + "anyOf": [ + { + "description": "If `true`, disables all CSP modification.\n `false` is the default value and it configures Tauri to control the CSP.", + "type": "boolean" + }, + { + "description": "Disables the given list of CSP directives modifications.", + "type": "array", + "items": { + "type": "string" + } + } + ] + }, + "AssetProtocolConfig": { + "description": "Config for the asset custom protocol.\n\n See more: ", + "type": "object", + "properties": { + "scope": { + "description": "The access scope for the asset protocol.", + "default": [], + "allOf": [ + { + "$ref": "#/definitions/FsScope" + } + ] + }, + "enable": { + "description": "Enables the asset protocol.", + "default": false, + "type": "boolean" + } + }, + "additionalProperties": false + }, + "FsScope": { + "description": "Protocol scope definition.\n It is a list of glob patterns that restrict the API access from the webview.\n\n Each pattern can start with a variable that resolves to a system base directory.\n The variables are: `$AUDIO`, `$CACHE`, `$CONFIG`, `$DATA`, `$LOCALDATA`, `$DESKTOP`,\n `$DOCUMENT`, `$DOWNLOAD`, `$EXE`, `$FONT`, `$HOME`, `$PICTURE`, `$PUBLIC`, `$RUNTIME`,\n `$TEMPLATE`, `$VIDEO`, `$RESOURCE`, `$TEMP`,\n `$APPCONFIG`, `$APPDATA`, `$APPLOCALDATA`, `$APPCACHE`, `$APPLOG`.", + "anyOf": [ + { + "description": "A list of paths that are allowed by this scope.", + "type": "array", + "items": { + "type": "string" + } + }, + { + "description": "A complete scope configuration.", + "type": "object", + "properties": { + "allow": { + "description": "A list of paths that are allowed by this scope.", + "default": [], + "type": "array", + "items": { + "type": "string" + } + }, + "deny": { + "description": "A list of paths that are not allowed by this scope.\n This gets precedence over the [`Self::Scope::allow`] list.", + "default": [], + "type": "array", + "items": { + "type": "string" + } + }, + "requireLiteralLeadingDot": { + "description": "Whether or not paths that contain components that start with a `.`\n will require that `.` appears literally in the pattern; `*`, `?`, `**`,\n or `[...]` will not match. This is useful because such files are\n conventionally considered hidden on Unix systems and it might be\n desirable to skip them when listing files.\n\n Defaults to `true` on Unix systems and `false` on Windows", + "type": [ + "boolean", + "null" + ] + } + } + } + ] + }, + "PatternKind": { + "description": "The application pattern.", + "oneOf": [ + { + "description": "Brownfield pattern.", + "type": "object", + "required": [ + "use" + ], + "properties": { + "use": { + "type": "string", + "enum": [ + "brownfield" + ] + } + } + }, + { + "description": "Isolation pattern. Recommended for security purposes.", + "type": "object", + "required": [ + "options", + "use" + ], + "properties": { + "use": { + "type": "string", + "enum": [ + "isolation" + ] + }, + "options": { + "type": "object", + "required": [ + "dir" + ], + "properties": { + "dir": { + "description": "The dir containing the index.html file that contains the secure isolation application.", + "type": "string" + } + } + } + } + } + ] + }, + "CapabilityEntry": { + "description": "A capability entry which can be either an inlined capability or a reference to a capability defined on its own file.", + "anyOf": [ + { + "description": "An inlined capability.", + "allOf": [ + { + "$ref": "#/definitions/Capability" + } + ] + }, + { + "description": "Reference to a capability identifier.", + "type": "string" + } + ] + }, + "Capability": { + "description": "A grouping and boundary mechanism developers can use to isolate access to the IPC layer.\n\n It controls application windows' and webviews' fine grained access\n to the Tauri core, application, or plugin commands.\n If a webview or its window is not matching any capability then it has no access to the IPC layer at all.\n\n This can be done to create groups of windows, based on their required system access, which can reduce\n impact of frontend vulnerabilities in less privileged windows.\n Windows can be added to a capability by exact name (e.g. `main-window`) or glob patterns like `*` or `admin-*`.\n A Window can have none, one, or multiple associated capabilities.\n\n ## Example\n\n ```json\n {\n \"identifier\": \"main-user-files-write\",\n \"description\": \"This capability allows the `main` window on macOS and Windows access to `filesystem` write related commands and `dialog` commands to enable programmatic access to files selected by the user.\",\n \"windows\": [\n \"main\"\n ],\n \"permissions\": [\n \"core:default\",\n \"dialog:open\",\n {\n \"identifier\": \"fs:allow-write-text-file\",\n \"allow\": [{ \"path\": \"$HOME/test.txt\" }]\n },\n ],\n \"platforms\": [\"macOS\",\"windows\"]\n }\n ```", + "type": "object", + "required": [ + "identifier", + "permissions" + ], + "properties": { + "identifier": { + "description": "Identifier of the capability.\n\n ## Example\n\n `main-user-files-write`", + "type": "string" + }, + "description": { + "description": "Description of what the capability is intended to allow on associated windows.\n\n It should contain a description of what the grouped permissions should allow.\n\n ## Example\n\n This capability allows the `main` window access to `filesystem` write related\n commands and `dialog` commands to enable programmatic access to files selected by the user.", + "default": "", + "type": "string" + }, + "remote": { + "description": "Configure remote URLs that can use the capability permissions.\n\n This setting is optional and defaults to not being set, as our\n default use case is that the content is served from our local application.\n\n :::caution\n Make sure you understand the security implications of providing remote\n sources with local system access.\n :::\n\n ## Example\n\n ```json\n {\n \"urls\": [\"https://*.mydomain.dev\"]\n }\n ```", + "anyOf": [ + { + "$ref": "#/definitions/CapabilityRemote" + }, + { + "type": "null" + } + ] + }, + "local": { + "description": "Whether this capability is enabled for local app URLs or not. Defaults to `true`.", + "default": true, + "type": "boolean" + }, + "windows": { + "description": "List of windows that are affected by this capability. Can be a glob pattern.\n\n If a window label matches any of the patterns in this list,\n the capability will be enabled on all the webviews of that window,\n regardless of the value of [`Self::webviews`].\n\n On multiwebview windows, prefer specifying [`Self::webviews`] and omitting [`Self::windows`]\n for a fine grained access control.\n\n ## Example\n\n `[\"main\"]`", + "type": "array", + "items": { + "type": "string" + } + }, + "webviews": { + "description": "List of webviews that are affected by this capability. Can be a glob pattern.\n\n The capability will be enabled on all the webviews\n whose label matches any of the patterns in this list,\n regardless of whether the webview's window label matches a pattern in [`Self::windows`].\n\n ## Example\n\n `[\"sub-webview-one\", \"sub-webview-two\"]`", + "type": "array", + "items": { + "type": "string" + } + }, + "permissions": { + "description": "List of permissions attached to this capability.\n\n Must include the plugin name as prefix in the form of `${plugin-name}:${permission-name}`.\n For commands directly implemented in the application itself only `${permission-name}`\n is required.\n\n ## Example\n\n ```json\n [\n \"core:default\",\n \"shell:allow-open\",\n \"dialog:open\",\n {\n \"identifier\": \"fs:allow-write-text-file\",\n \"allow\": [{ \"path\": \"$HOME/test.txt\" }]\n }\n ]\n ```", + "type": "array", + "items": { + "$ref": "#/definitions/PermissionEntry" + }, + "uniqueItems": true + }, + "platforms": { + "description": "Limit which target platforms this capability applies to.\n\n By default all platforms are targeted.\n\n ## Example\n\n `[\"macOS\",\"windows\"]`", + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/definitions/Target" + } + } + } + }, + "CapabilityRemote": { + "description": "Configuration for remote URLs that are associated with the capability.", + "type": "object", + "required": [ + "urls" + ], + "properties": { + "urls": { + "description": "Remote domains this capability refers to using the [URLPattern standard](https://urlpattern.spec.whatwg.org/).\n\n ## Examples\n\n - \"https://*.mydomain.dev\": allows subdomains of mydomain.dev\n - \"https://mydomain.dev/api/*\": allows any subpath of mydomain.dev/api", + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "PermissionEntry": { + "description": "An entry for a permission value in a [`Capability`] can be either a raw permission [`Identifier`]\n or an object that references a permission and extends its scope.", + "anyOf": [ + { + "description": "Reference a permission or permission set by identifier.", + "allOf": [ + { + "$ref": "#/definitions/Identifier" + } + ] + }, + { + "description": "Reference a permission or permission set by identifier and extends its scope.", + "type": "object", + "required": [ + "identifier" + ], + "properties": { + "identifier": { + "description": "Identifier of the permission or permission set.", + "allOf": [ + { + "$ref": "#/definitions/Identifier" + } + ] + }, + "allow": { + "description": "Data that defines what is allowed by the scope.", + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/definitions/Value" + } + }, + "deny": { + "description": "Data that defines what is denied by the scope. This should be prioritized by validation logic.", + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/definitions/Value" + } + } + } + } + ] + }, + "Identifier": { + "type": "string" + }, + "Value": { + "description": "All supported ACL values.", + "anyOf": [ + { + "description": "Represents a null JSON value.", + "type": "null" + }, + { + "description": "Represents a [`bool`].", + "type": "boolean" + }, + { + "description": "Represents a valid ACL [`Number`].", + "allOf": [ + { + "$ref": "#/definitions/Number" + } + ] + }, + { + "description": "Represents a [`String`].", + "type": "string" + }, + { + "description": "Represents a list of other [`Value`]s.", + "type": "array", + "items": { + "$ref": "#/definitions/Value" + } + }, + { + "description": "Represents a map of [`String`] keys to [`Value`]s.", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/Value" + } + } + ] + }, + "Number": { + "description": "A valid ACL number.", + "anyOf": [ + { + "description": "Represents an [`i64`].", + "type": "integer", + "format": "int64" + }, + { + "description": "Represents a [`f64`].", + "type": "number", + "format": "double" + } + ] + }, + "Target": { + "description": "Platform target.", + "oneOf": [ + { + "description": "MacOS.", + "type": "string", + "enum": [ + "macOS" + ] + }, + { + "description": "Windows.", + "type": "string", + "enum": [ + "windows" + ] + }, + { + "description": "Linux.", + "type": "string", + "enum": [ + "linux" + ] + }, + { + "description": "Android.", + "type": "string", + "enum": [ + "android" + ] + }, + { + "description": "iOS.", + "type": "string", + "enum": [ + "iOS" + ] + } + ] + }, + "HeaderConfig": { + "description": "A struct, where the keys are some specific http header names.\n\n If the values to those keys are defined, then they will be send as part of a response message.\n This does not include error messages and ipc messages\n\n ## Example configuration\n ```javascript\n {\n //..\n app:{\n //..\n security: {\n headers: {\n \"Cross-Origin-Opener-Policy\": \"same-origin\",\n \"Cross-Origin-Embedder-Policy\": \"require-corp\",\n \"Timing-Allow-Origin\": [\n \"https://developer.mozilla.org\",\n \"https://example.com\",\n ],\n \"Access-Control-Expose-Headers\": \"Tauri-Custom-Header\",\n \"Tauri-Custom-Header\": {\n \"key1\": \"'value1' 'value2'\",\n \"key2\": \"'value3'\"\n }\n },\n csp: \"default-src 'self'; connect-src ipc: http://ipc.localhost\",\n }\n //..\n }\n //..\n }\n ```\n In this example `Cross-Origin-Opener-Policy` and `Cross-Origin-Embedder-Policy` are set to allow for the use of [`SharedArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer).\n The result is, that those headers are then set on every response sent via the `get_response` function in crates/tauri/src/protocol/tauri.rs.\n The Content-Security-Policy header is defined separately, because it is also handled separately.\n\n For the helloworld example, this config translates into those response headers:\n ```http\n access-control-allow-origin: http://tauri.localhost\n access-control-expose-headers: Tauri-Custom-Header\n content-security-policy: default-src 'self'; connect-src ipc: http://ipc.localhost; script-src 'self' 'sha256-Wjjrs6qinmnr+tOry8x8PPwI77eGpUFR3EEGZktjJNs='\n content-type: text/html\n cross-origin-embedder-policy: require-corp\n cross-origin-opener-policy: same-origin\n tauri-custom-header: key1 'value1' 'value2'; key2 'value3'\n timing-allow-origin: https://developer.mozilla.org, https://example.com\n ```\n Since the resulting header values are always 'string-like'. So depending on the what data type the HeaderSource is, they need to be converted.\n - `String`(JS/Rust): stay the same for the resulting header value\n - `Array`(JS)/`Vec\\`(Rust): Item are joined by \", \" for the resulting header value\n - `Object`(JS)/ `Hashmap\\`(Rust): Items are composed from: key + space + value. Item are then joined by \"; \" for the resulting header value", + "type": "object", + "properties": { + "Access-Control-Allow-Credentials": { + "description": "The Access-Control-Allow-Credentials response header tells browsers whether the\n server allows cross-origin HTTP requests to include credentials.\n\n See ", + "anyOf": [ + { + "$ref": "#/definitions/HeaderSource" + }, + { + "type": "null" + } + ] + }, + "Access-Control-Allow-Headers": { + "description": "The Access-Control-Allow-Headers response header is used in response\n to a preflight request which includes the Access-Control-Request-Headers\n to indicate which HTTP headers can be used during the actual request.\n\n This header is required if the request has an Access-Control-Request-Headers header.\n\n See ", + "anyOf": [ + { + "$ref": "#/definitions/HeaderSource" + }, + { + "type": "null" + } + ] + }, + "Access-Control-Allow-Methods": { + "description": "The Access-Control-Allow-Methods response header specifies one or more methods\n allowed when accessing a resource in response to a preflight request.\n\n See ", + "anyOf": [ + { + "$ref": "#/definitions/HeaderSource" + }, + { + "type": "null" + } + ] + }, + "Access-Control-Expose-Headers": { + "description": "The Access-Control-Expose-Headers response header allows a server to indicate\n which response headers should be made available to scripts running in the browser,\n in response to a cross-origin request.\n\n See ", + "anyOf": [ + { + "$ref": "#/definitions/HeaderSource" + }, + { + "type": "null" + } + ] + }, + "Access-Control-Max-Age": { + "description": "The Access-Control-Max-Age response header indicates how long the results of a\n preflight request (that is the information contained in the\n Access-Control-Allow-Methods and Access-Control-Allow-Headers headers) can\n be cached.\n\n See ", + "anyOf": [ + { + "$ref": "#/definitions/HeaderSource" + }, + { + "type": "null" + } + ] + }, + "Cross-Origin-Embedder-Policy": { + "description": "The HTTP Cross-Origin-Embedder-Policy (COEP) response header configures embedding\n cross-origin resources into the document.\n\n See ", + "anyOf": [ + { + "$ref": "#/definitions/HeaderSource" + }, + { + "type": "null" + } + ] + }, + "Cross-Origin-Opener-Policy": { + "description": "The HTTP Cross-Origin-Opener-Policy (COOP) response header allows you to ensure a\n top-level document does not share a browsing context group with cross-origin documents.\n COOP will process-isolate your document and potential attackers can't access your global\n object if they were to open it in a popup, preventing a set of cross-origin attacks dubbed XS-Leaks.\n\n See ", + "anyOf": [ + { + "$ref": "#/definitions/HeaderSource" + }, + { + "type": "null" + } + ] + }, + "Cross-Origin-Resource-Policy": { + "description": "The HTTP Cross-Origin-Resource-Policy response header conveys a desire that the\n browser blocks no-cors cross-origin/cross-site requests to the given resource.\n\n See ", + "anyOf": [ + { + "$ref": "#/definitions/HeaderSource" + }, + { + "type": "null" + } + ] + }, + "Permissions-Policy": { + "description": "The HTTP Permissions-Policy header provides a mechanism to allow and deny the\n use of browser features in a document or within any \\ elements in the document.\n\n See ", + "anyOf": [ + { + "$ref": "#/definitions/HeaderSource" + }, + { + "type": "null" + } + ] + }, + "Service-Worker-Allowed": { + "description": "The HTTP Service-Worker-Allowed response header is used to broaden the path restriction for a\n service worker's default scope.\n\n By default, the scope for a service worker registration is the directory where the service\n worker script is located. For example, if the script `sw.js` is located in `/js/sw.js`,\n it can only control URLs under `/js/` by default. Servers can use the `Service-Worker-Allowed`\n header to allow a service worker to control URLs outside of its own directory.\n\n See ", + "anyOf": [ + { + "$ref": "#/definitions/HeaderSource" + }, + { + "type": "null" + } + ] + }, + "Timing-Allow-Origin": { + "description": "The Timing-Allow-Origin response header specifies origins that are allowed to see values\n of attributes retrieved via features of the Resource Timing API, which would otherwise be\n reported as zero due to cross-origin restrictions.\n\n See ", + "anyOf": [ + { + "$ref": "#/definitions/HeaderSource" + }, + { + "type": "null" + } + ] + }, + "X-Content-Type-Options": { + "description": "The X-Content-Type-Options response HTTP header is a marker used by the server to indicate\n that the MIME types advertised in the Content-Type headers should be followed and not be\n changed. The header allows you to avoid MIME type sniffing by saying that the MIME types\n are deliberately configured.\n\n See ", + "anyOf": [ + { + "$ref": "#/definitions/HeaderSource" + }, + { + "type": "null" + } + ] + }, + "Tauri-Custom-Header": { + "description": "A custom header field Tauri-Custom-Header, don't use it.\n Remember to set Access-Control-Expose-Headers accordingly\n\n **NOT INTENDED FOR PRODUCTION USE**", + "anyOf": [ + { + "$ref": "#/definitions/HeaderSource" + }, + { + "type": "null" + } + ] + } + }, + "additionalProperties": false + }, + "HeaderSource": { + "description": "definition of a header source\n\n The header value to a header name", + "anyOf": [ + { + "description": "string version of the header Value", + "type": "string" + }, + { + "description": "list version of the header value. Item are joined by \",\" for the real header value", + "type": "array", + "items": { + "type": "string" + } + }, + { + "description": "(Rust struct | Json | JavaScript Object) equivalent of the header value. Items are composed from: key + space + value. Item are then joined by \";\" for the real header value", + "type": "object", + "additionalProperties": { + "type": "string" + } + } + ] + }, + "TrayIconConfig": { + "description": "Configuration for application tray icon.\n\n See more: ", + "type": "object", + "required": [ + "iconPath" + ], + "properties": { + "id": { + "description": "Set an id for this tray icon so you can reference it later, defaults to `main`.", + "type": [ + "string", + "null" + ] + }, + "iconPath": { + "description": "Path to the default icon to use for the tray icon.\n\n Note: this stores the image in raw pixels to the final binary,\n so keep the icon size (width and height) small\n or else it's going to bloat your final executable", + "type": "string" + }, + "iconAsTemplate": { + "description": "A Boolean value that determines whether the image represents a [template](https://developer.apple.com/documentation/appkit/nsimage/1520017-template?language=objc) image on macOS.", + "default": false, + "type": "boolean" + }, + "menuOnLeftClick": { + "description": "A Boolean value that determines whether the menu should appear when the tray icon receives a left click.\n\n ## Platform-specific:\n\n - **Linux**: Unsupported.", + "default": true, + "deprecated": true, + "type": "boolean" + }, + "showMenuOnLeftClick": { + "description": "A Boolean value that determines whether the menu should appear when the tray icon receives a left click.\n\n ## Platform-specific:\n\n - **Linux**: Unsupported.", + "default": true, + "type": "boolean" + }, + "title": { + "description": "Title for MacOS tray", + "type": [ + "string", + "null" + ] + }, + "tooltip": { + "description": "Tray icon tooltip on Windows and macOS", + "type": [ + "string", + "null" + ] + } + }, + "additionalProperties": false + }, + "BuildConfig": { + "description": "The Build configuration object.\n\n See more: ", + "type": "object", + "properties": { + "runner": { + "description": "The binary used to build and run the application.", + "anyOf": [ + { + "$ref": "#/definitions/RunnerConfig" + }, + { + "type": "null" + } + ] + }, + "devUrl": { + "description": "The URL to load in development.\n\n This is usually an URL to a dev server, which serves your application assets with hot-reload and HMR.\n Most modern JavaScript bundlers like [Vite](https://vite.dev/guide/) provides a way to start a dev server by default.\n\n If you don't have a dev server or don't want to use one, ignore this option and use [`frontendDist`](BuildConfig::frontend_dist)\n and point to a web assets directory, and Tauri CLI will run its built-in dev server and provide a simple hot-reload experience.", + "type": [ + "string", + "null" + ], + "format": "uri" + }, + "frontendDist": { + "description": "The path to the application assets (usually the `dist` folder of your javascript bundler)\n or a URL that could be either a custom protocol registered in the tauri app (for example: `myprotocol://`)\n or a remote URL (for example: `https://site.com/app`).\n\n When a path relative to the configuration file is provided,\n it is read recursively and all files are embedded in the application binary.\n Tauri then looks for an `index.html` and serves it as the default entry point for your application.\n\n You can also provide a list of paths to be embedded, which allows granular control over what files are added to the binary.\n In this case, all files are added to the root and you must reference it that way in your HTML files.\n\n When a URL is provided, the application won't have bundled assets\n and the application will load that URL by default.", + "anyOf": [ + { + "$ref": "#/definitions/FrontendDist" + }, + { + "type": "null" + } + ] + }, + "beforeDevCommand": { + "description": "A shell command to run before `tauri dev` kicks in.\n\n The TAURI_ENV_PLATFORM, TAURI_ENV_ARCH, TAURI_ENV_FAMILY, TAURI_ENV_PLATFORM_VERSION, TAURI_ENV_PLATFORM_TYPE and TAURI_ENV_DEBUG environment variables are set if you perform conditional compilation.", + "anyOf": [ + { + "$ref": "#/definitions/BeforeDevCommand" + }, + { + "type": "null" + } + ] + }, + "beforeBuildCommand": { + "description": "A shell command to run before `tauri build` kicks in.\n\n The TAURI_ENV_PLATFORM, TAURI_ENV_ARCH, TAURI_ENV_FAMILY, TAURI_ENV_PLATFORM_VERSION, TAURI_ENV_PLATFORM_TYPE and TAURI_ENV_DEBUG environment variables are set if you perform conditional compilation.", + "anyOf": [ + { + "$ref": "#/definitions/HookCommand" + }, + { + "type": "null" + } + ] + }, + "beforeBundleCommand": { + "description": "A shell command to run before the bundling phase in `tauri build` kicks in.\n\n The TAURI_ENV_PLATFORM, TAURI_ENV_ARCH, TAURI_ENV_FAMILY, TAURI_ENV_PLATFORM_VERSION, TAURI_ENV_PLATFORM_TYPE and TAURI_ENV_DEBUG environment variables are set if you perform conditional compilation.", + "anyOf": [ + { + "$ref": "#/definitions/HookCommand" + }, + { + "type": "null" + } + ] + }, + "features": { + "description": "Features passed to `cargo` commands.", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "removeUnusedCommands": { + "description": "Try to remove unused commands registered from plugins base on the ACL list during `tauri build`,\n the way it works is that tauri-cli will read this and set the environment variables for the build script and macros,\n and they'll try to get all the allowed commands and remove the rest\n\n Note:\n - This won't be accounting for dynamically added ACLs when you use features from the `dynamic-acl` (currently enabled by default) feature flag, so make sure to check it when using this\n - This feature requires tauri-plugin 2.1 and tauri 2.4", + "default": false, + "type": "boolean" + }, + "additionalWatchFolders": { + "description": "Additional paths to watch for changes when running `tauri dev`.", + "default": [], + "type": "array", + "items": { + "type": "string" + } + } + }, + "additionalProperties": false + }, + "RunnerConfig": { + "description": "The runner configuration.", + "anyOf": [ + { + "description": "A string specifying the binary to run.", + "type": "string" + }, + { + "description": "An object with advanced configuration options.", + "type": "object", + "required": [ + "cmd" + ], + "properties": { + "cmd": { + "description": "The binary to run.", + "type": "string" + }, + "cwd": { + "description": "The current working directory to run the command from.", + "type": [ + "string", + "null" + ] + }, + "args": { + "description": "Arguments to pass to the command.", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + } + } + } + ] + }, + "FrontendDist": { + "description": "Defines the URL or assets to embed in the application.", + "anyOf": [ + { + "description": "An external URL that should be used as the default application URL. No assets are embedded in the app in this case.", + "type": "string", + "format": "uri" + }, + { + "description": "Path to a directory containing the frontend dist assets.", + "type": "string" + }, + { + "description": "An array of files to embed in the app.", + "type": "array", + "items": { + "type": "string" + } + } + ] + }, + "BeforeDevCommand": { + "description": "Describes the shell command to run before `tauri dev`.", + "anyOf": [ + { + "description": "Run the given script with the default options.", + "type": "string" + }, + { + "description": "Run the given script with custom options.", + "type": "object", + "required": [ + "script" + ], + "properties": { + "script": { + "description": "The script to execute.", + "type": "string" + }, + "cwd": { + "description": "The current working directory.", + "type": [ + "string", + "null" + ] + }, + "wait": { + "description": "Whether `tauri dev` should wait for the command to finish or not. Defaults to `false`.", + "default": false, + "type": "boolean" + } + } + } + ] + }, + "HookCommand": { + "description": "Describes a shell command to be executed when a CLI hook is triggered.", + "anyOf": [ + { + "description": "Run the given script with the default options.", + "type": "string" + }, + { + "description": "Run the given script with custom options.", + "type": "object", + "required": [ + "script" + ], + "properties": { + "script": { + "description": "The script to execute.", + "type": "string" + }, + "cwd": { + "description": "The current working directory.", + "type": [ + "string", + "null" + ] + } + } + } + ] + }, + "BundleConfig": { + "description": "Configuration for tauri-bundler.\n\n See more: ", + "type": "object", + "properties": { + "active": { + "description": "Whether Tauri should bundle your application or just output the executable.", + "default": false, + "type": "boolean" + }, + "targets": { + "description": "The bundle targets, currently supports [\"deb\", \"rpm\", \"appimage\", \"nsis\", \"msi\", \"app\", \"dmg\"] or \"all\".", + "default": "all", + "allOf": [ + { + "$ref": "#/definitions/BundleTarget" + } + ] + }, + "createUpdaterArtifacts": { + "description": "Produce updaters and their signatures or not", + "default": false, + "allOf": [ + { + "$ref": "#/definitions/Updater" + } + ] + }, + "publisher": { + "description": "The application's publisher. Defaults to the second element in the identifier string.\n\n Currently maps to the Manufacturer property of the Windows Installer\n and the Maintainer field of debian packages if the Cargo.toml does not have the authors field.", + "type": [ + "string", + "null" + ] + }, + "homepage": { + "description": "A url to the home page of your application. If unset, will\n fallback to `homepage` defined in `Cargo.toml`.\n\n Supported bundle targets: `deb`, `rpm`, `nsis` and `msi`.", + "type": [ + "string", + "null" + ] + }, + "icon": { + "description": "The app's icons", + "default": [], + "type": "array", + "items": { + "type": "string" + } + }, + "resources": { + "description": "App resources to bundle.\n Each resource is a path to a file or directory.\n Glob patterns are supported.\n\n ## Examples\n\n To include a list of files:\n\n ```json\n {\n \"bundle\": {\n \"resources\": [\n \"./path/to/some-file.txt\",\n \"/absolute/path/to/textfile.txt\",\n \"../relative/path/to/jsonfile.json\",\n \"some-folder/\",\n \"resources/**/*.md\"\n ]\n }\n }\n ```\n\n The bundled files will be in `$RESOURCES/` with the original directory structure preserved,\n for example: `./path/to/some-file.txt` -> `$RESOURCE/path/to/some-file.txt`\n\n To fine control where the files will get copied to, use a map instead\n\n ```json\n {\n \"bundle\": {\n \"resources\": {\n \"/absolute/path/to/textfile.txt\": \"resources/textfile.txt\",\n \"relative/path/to/jsonfile.json\": \"resources/jsonfile.json\",\n \"resources/\": \"\",\n \"docs/**/*md\": \"website-docs/\"\n }\n }\n }\n ```\n\n Note that when using glob pattern in this case, the original directory structure is not preserved,\n everything gets copied to the target directory directly\n\n See more: ", + "anyOf": [ + { + "$ref": "#/definitions/BundleResources" + }, + { + "type": "null" + } + ] + }, + "copyright": { + "description": "A copyright string associated with your application.", + "type": [ + "string", + "null" + ] + }, + "license": { + "description": "The package's license identifier to be included in the appropriate bundles.\n If not set, defaults to the license from the Cargo.toml file.", + "type": [ + "string", + "null" + ] + }, + "licenseFile": { + "description": "The path to the license file to be included in the appropriate bundles.", + "type": [ + "string", + "null" + ] + }, + "category": { + "description": "The application kind.\n\n Should be one of the following:\n Business, DeveloperTool, Education, Entertainment, Finance, Game, ActionGame, AdventureGame, ArcadeGame, BoardGame, CardGame, CasinoGame, DiceGame, EducationalGame, FamilyGame, KidsGame, MusicGame, PuzzleGame, RacingGame, RolePlayingGame, SimulationGame, SportsGame, StrategyGame, TriviaGame, WordGame, GraphicsAndDesign, HealthcareAndFitness, Lifestyle, Medical, Music, News, Photography, Productivity, Reference, SocialNetworking, Sports, Travel, Utility, Video, Weather.", + "type": [ + "string", + "null" + ] + }, + "fileAssociations": { + "description": "File types to associate with the application.", + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/definitions/FileAssociation" + } + }, + "shortDescription": { + "description": "A short description of your application.", + "type": [ + "string", + "null" + ] + }, + "longDescription": { + "description": "A longer, multi-line description of the application.", + "type": [ + "string", + "null" + ] + }, + "useLocalToolsDir": { + "description": "Whether to use the project's `target` directory, for caching build tools (e.g., Wix and NSIS) when building this application. Defaults to `false`.\n\n If true, tools will be cached in `target/.tauri/`.\n If false, tools will be cached in the current user's platform-specific cache directory.\n\n An example where it can be appropriate to set this to `true` is when building this application as a Windows System user (e.g., AWS EC2 workloads),\n because the Window system's app data directory is restricted.", + "default": false, + "type": "boolean" + }, + "externalBin": { + "description": "A list of—either absolute or relative—paths to binaries to embed with your application.\n\n Note that Tauri will look for system-specific binaries following the pattern \"binary-name{-target-triple}{.system-extension}\".\n\n E.g. for the external binary \"my-binary\", Tauri looks for:\n\n - \"my-binary-x86_64-pc-windows-msvc.exe\" for Windows\n - \"my-binary-x86_64-apple-darwin\" for macOS\n - \"my-binary-x86_64-unknown-linux-gnu\" for Linux\n\n so don't forget to provide binaries for all targeted platforms.", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "windows": { + "description": "Configuration for the Windows bundles.", + "default": { + "allowDowngrades": true, + "certificateThumbprint": null, + "digestAlgorithm": null, + "nsis": null, + "signCommand": null, + "timestampUrl": null, + "tsp": false, + "webviewInstallMode": { + "silent": true, + "type": "downloadBootstrapper" + }, + "wix": null + }, + "allOf": [ + { + "$ref": "#/definitions/WindowsConfig" + } + ] + }, + "linux": { + "description": "Configuration for the Linux bundles.", + "default": { + "appimage": { + "bundleMediaFramework": false, + "files": {} + }, + "deb": { + "files": {} + }, + "rpm": { + "epoch": 0, + "files": {}, + "release": "1" + } + }, + "allOf": [ + { + "$ref": "#/definitions/LinuxConfig" + } + ] + }, + "macOS": { + "description": "Configuration for the macOS bundles.", + "default": { + "dmg": { + "appPosition": { + "x": 180, + "y": 170 + }, + "applicationFolderPosition": { + "x": 480, + "y": 170 + }, + "windowSize": { + "height": 400, + "width": 660 + } + }, + "files": {}, + "hardenedRuntime": true, + "minimumSystemVersion": "10.13" + }, + "allOf": [ + { + "$ref": "#/definitions/MacConfig" + } + ] + }, + "iOS": { + "description": "iOS configuration.", + "default": { + "minimumSystemVersion": "14.0" + }, + "allOf": [ + { + "$ref": "#/definitions/IosConfig" + } + ] + }, + "android": { + "description": "Android configuration.", + "default": { + "autoIncrementVersionCode": false, + "minSdkVersion": 24 + }, + "allOf": [ + { + "$ref": "#/definitions/AndroidConfig" + } + ] + } + }, + "additionalProperties": false + }, + "BundleTarget": { + "description": "Targets to bundle. Each value is case insensitive.", + "anyOf": [ + { + "description": "Bundle all targets.", + "const": "all" + }, + { + "description": "A list of bundle targets.", + "type": "array", + "items": { + "$ref": "#/definitions/BundleType" + } + }, + { + "description": "A single bundle target.", + "allOf": [ + { + "$ref": "#/definitions/BundleType" + } + ] + } + ] + }, + "BundleType": { + "description": "A bundle referenced by tauri-bundler.", + "oneOf": [ + { + "description": "The debian bundle (.deb).", + "type": "string", + "enum": [ + "deb" + ] + }, + { + "description": "The RPM bundle (.rpm).", + "type": "string", + "enum": [ + "rpm" + ] + }, + { + "description": "The AppImage bundle (.appimage).", + "type": "string", + "enum": [ + "appimage" + ] + }, + { + "description": "The Microsoft Installer bundle (.msi).", + "type": "string", + "enum": [ + "msi" + ] + }, + { + "description": "The NSIS bundle (.exe).", + "type": "string", + "enum": [ + "nsis" + ] + }, + { + "description": "The macOS application bundle (.app).", + "type": "string", + "enum": [ + "app" + ] + }, + { + "description": "The Apple Disk Image bundle (.dmg).", + "type": "string", + "enum": [ + "dmg" + ] + } + ] + }, + "Updater": { + "description": "Updater type", + "anyOf": [ + { + "description": "Generates legacy zipped v1 compatible updaters", + "allOf": [ + { + "$ref": "#/definitions/V1Compatible" + } + ] + }, + { + "description": "Produce updaters and their signatures or not", + "type": "boolean" + } + ] + }, + "V1Compatible": { + "description": "Generates legacy zipped v1 compatible updaters", + "oneOf": [ + { + "description": "Generates legacy zipped v1 compatible updaters", + "type": "string", + "enum": [ + "v1Compatible" + ] + } + ] + }, + "BundleResources": { + "description": "Definition for bundle resources.\n Can be either a list of paths to include or a map of source to target paths.", + "anyOf": [ + { + "description": "A list of paths to include.", + "type": "array", + "items": { + "type": "string" + } + }, + { + "description": "A map of source to target paths.", + "type": "object", + "additionalProperties": { + "type": "string" + } + } + ] + }, + "FileAssociation": { + "description": "File association", + "type": "object", + "required": [ + "ext" + ], + "properties": { + "ext": { + "description": "File extensions to associate with this app. e.g. 'png'", + "type": "array", + "items": { + "$ref": "#/definitions/AssociationExt" + } + }, + "contentTypes": { + "description": "Declare support to a file with the given content type. Maps to `LSItemContentTypes` on macOS.\n\n This allows supporting any file format declared by another application that conforms to this type.\n Declaration of new types can be done with [`Self::exported_type`] and linking to certain content types are done via [`ExportedFileAssociation::conforms_to`].", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "name": { + "description": "The name. Maps to `CFBundleTypeName` on macOS. Default to `ext[0]`", + "type": [ + "string", + "null" + ] + }, + "description": { + "description": "The association description. Windows-only. It is displayed on the `Type` column on Windows Explorer.", + "type": [ + "string", + "null" + ] + }, + "role": { + "description": "The app's role with respect to the type. Maps to `CFBundleTypeRole` on macOS.", + "default": "Editor", + "allOf": [ + { + "$ref": "#/definitions/BundleTypeRole" + } + ] + }, + "mimeType": { + "description": "The mime-type e.g. 'image/png' or 'text/plain'. Linux-only.", + "type": [ + "string", + "null" + ] + }, + "rank": { + "description": "The ranking of this app among apps that declare themselves as editors or viewers of the given file type. Maps to `LSHandlerRank` on macOS.", + "default": "Default", + "allOf": [ + { + "$ref": "#/definitions/HandlerRank" + } + ] + }, + "exportedType": { + "description": "The exported type definition. Maps to a `UTExportedTypeDeclarations` entry on macOS.\n\n You should define this if the associated file is a custom file type defined by your application.", + "anyOf": [ + { + "$ref": "#/definitions/ExportedFileAssociation" + }, + { + "type": "null" + } + ] + } + }, + "additionalProperties": false + }, + "AssociationExt": { + "description": "An extension for a [`FileAssociation`].\n\n A leading `.` is automatically stripped.", + "type": "string" + }, + "BundleTypeRole": { + "description": "macOS-only. Corresponds to CFBundleTypeRole", + "oneOf": [ + { + "description": "CFBundleTypeRole.Editor. Files can be read and edited.", + "type": "string", + "enum": [ + "Editor" + ] + }, + { + "description": "CFBundleTypeRole.Viewer. Files can be read.", + "type": "string", + "enum": [ + "Viewer" + ] + }, + { + "description": "CFBundleTypeRole.Shell", + "type": "string", + "enum": [ + "Shell" + ] + }, + { + "description": "CFBundleTypeRole.QLGenerator", + "type": "string", + "enum": [ + "QLGenerator" + ] + }, + { + "description": "CFBundleTypeRole.None", + "type": "string", + "enum": [ + "None" + ] + } + ] + }, + "HandlerRank": { + "description": "Corresponds to LSHandlerRank", + "oneOf": [ + { + "description": "LSHandlerRank.Default. This app is an opener of files of this type; this value is also used if no rank is specified.", + "type": "string", + "enum": [ + "Default" + ] + }, + { + "description": "LSHandlerRank.Owner. This app is the primary creator of files of this type.", + "type": "string", + "enum": [ + "Owner" + ] + }, + { + "description": "LSHandlerRank.Alternate. This app is a secondary viewer of files of this type.", + "type": "string", + "enum": [ + "Alternate" + ] + }, + { + "description": "LSHandlerRank.None. This app is never selected to open files of this type, but it accepts drops of files of this type.", + "type": "string", + "enum": [ + "None" + ] + } + ] + }, + "ExportedFileAssociation": { + "description": "The exported type definition. Maps to a `UTExportedTypeDeclarations` entry on macOS.", + "type": "object", + "required": [ + "identifier" + ], + "properties": { + "identifier": { + "description": "The unique identifier for the exported type. Maps to `UTTypeIdentifier`.", + "type": "string" + }, + "conformsTo": { + "description": "The types that this type conforms to. Maps to `UTTypeConformsTo`.\n\n Examples are `public.data`, `public.image`, `public.json` and `public.database`.", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + } + }, + "additionalProperties": false + }, + "WindowsConfig": { + "description": "Windows bundler configuration.\n\n See more: ", + "type": "object", + "properties": { + "digestAlgorithm": { + "description": "Specifies the file digest algorithm to use for creating file signatures.\n Required for code signing. SHA-256 is recommended.", + "type": [ + "string", + "null" + ] + }, + "certificateThumbprint": { + "description": "Specifies the SHA1 hash of the signing certificate.", + "type": [ + "string", + "null" + ] + }, + "timestampUrl": { + "description": "Server to use during timestamping.", + "type": [ + "string", + "null" + ] + }, + "tsp": { + "description": "Whether to use Time-Stamp Protocol (TSP, a.k.a. RFC 3161) for the timestamp server. Your code signing provider may\n use a TSP timestamp server, like e.g. SSL.com does. If so, enable TSP by setting to true.", + "default": false, + "type": "boolean" + }, + "webviewInstallMode": { + "description": "The installation mode for the Webview2 runtime.", + "default": { + "silent": true, + "type": "downloadBootstrapper" + }, + "allOf": [ + { + "$ref": "#/definitions/WebviewInstallMode" + } + ] + }, + "allowDowngrades": { + "description": "Validates a second app installation, blocking the user from installing an older version if set to `false`.\n\n For instance, if `1.2.1` is installed, the user won't be able to install app version `1.2.0` or `1.1.5`.\n\n The default value of this flag is `true`.", + "default": true, + "type": "boolean" + }, + "wix": { + "description": "Configuration for the MSI generated with WiX.", + "anyOf": [ + { + "$ref": "#/definitions/WixConfig" + }, + { + "type": "null" + } + ] + }, + "nsis": { + "description": "Configuration for the installer generated with NSIS.", + "anyOf": [ + { + "$ref": "#/definitions/NsisConfig" + }, + { + "type": "null" + } + ] + }, + "signCommand": { + "description": "Specify a custom command to sign the binaries.\n This command needs to have a `%1` in args which is just a placeholder for the binary path,\n which we will detect and replace before calling the command.\n\n By Default we use `signtool.exe` which can be found only on Windows so\n if you are on another platform and want to cross-compile and sign you will\n need to use another tool like `osslsigncode`.", + "anyOf": [ + { + "$ref": "#/definitions/CustomSignCommandConfig" + }, + { + "type": "null" + } + ] + } + }, + "additionalProperties": false + }, + "WebviewInstallMode": { + "description": "Install modes for the Webview2 runtime.\n Note that for the updater bundle [`Self::DownloadBootstrapper`] is used.\n\n For more information see .", + "oneOf": [ + { + "description": "Do not install the Webview2 as part of the Windows Installer.", + "type": "object", + "required": [ + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "skip" + ] + } + }, + "additionalProperties": false + }, + { + "description": "Download the bootstrapper and run it.\n Requires an internet connection.\n Results in a smaller installer size, but is not recommended on Windows 7.", + "type": "object", + "required": [ + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "downloadBootstrapper" + ] + }, + "silent": { + "description": "Instructs the installer to run the bootstrapper in silent mode. Defaults to `true`.", + "default": true, + "type": "boolean" + } + }, + "additionalProperties": false + }, + { + "description": "Embed the bootstrapper and run it.\n Requires an internet connection.\n Increases the installer size by around 1.8MB, but offers better support on Windows 7.", + "type": "object", + "required": [ + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "embedBootstrapper" + ] + }, + "silent": { + "description": "Instructs the installer to run the bootstrapper in silent mode. Defaults to `true`.", + "default": true, + "type": "boolean" + } + }, + "additionalProperties": false + }, + { + "description": "Embed the offline installer and run it.\n Does not require an internet connection.\n Increases the installer size by around 127MB.", + "type": "object", + "required": [ + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "offlineInstaller" + ] + }, + "silent": { + "description": "Instructs the installer to run the installer in silent mode. Defaults to `true`.", + "default": true, + "type": "boolean" + } + }, + "additionalProperties": false + }, + { + "description": "Embed a fixed webview2 version and use it at runtime.\n Increases the installer size by around 180MB.", + "type": "object", + "required": [ + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "fixedRuntime" + ] + }, + "path": { + "description": "The path to the fixed runtime to use.\n\n The fixed version can be downloaded [on the official website](https://developer.microsoft.com/en-us/microsoft-edge/webview2/#download-section).\n The `.cab` file must be extracted to a folder and this folder path must be defined on this field.", + "type": "string" + } + }, + "additionalProperties": false + } + ] + }, + "WixConfig": { + "description": "Configuration for the MSI bundle using WiX.\n\n See more: ", + "type": "object", + "properties": { + "version": { + "description": "MSI installer version in the format `major.minor.patch.build` (build is optional).\n\n Because a valid version is required for MSI installer, it will be derived from [`Config::version`] if this field is not set.\n\n The first field is the major version and has a maximum value of 255. The second field is the minor version and has a maximum value of 255.\n The third and fourth fields have a maximum value of 65,535.\n\n See for more info.", + "type": [ + "string", + "null" + ] + }, + "upgradeCode": { + "description": "A GUID upgrade code for MSI installer. This code **_must stay the same across all of your updates_**,\n otherwise, Windows will treat your update as a different app and your users will have duplicate versions of your app.\n\n By default, tauri generates this code by generating a Uuid v5 using the string `.exe.app.x64` in the DNS namespace.\n You can use Tauri's CLI to generate and print this code for you, run `tauri inspect wix-upgrade-code`.\n\n It is recommended that you set this value in your tauri config file to avoid accidental changes in your upgrade code\n whenever you want to change your product name.", + "type": [ + "string", + "null" + ], + "format": "uuid" + }, + "language": { + "description": "The installer languages to build. See .", + "default": "en-US", + "allOf": [ + { + "$ref": "#/definitions/WixLanguage" + } + ] + }, + "template": { + "description": "A custom .wxs template to use.", + "type": [ + "string", + "null" + ] + }, + "fragmentPaths": { + "description": "A list of paths to .wxs files with WiX fragments to use.", + "default": [], + "type": "array", + "items": { + "type": "string" + } + }, + "componentGroupRefs": { + "description": "The ComponentGroup element ids you want to reference from the fragments.", + "default": [], + "type": "array", + "items": { + "type": "string" + } + }, + "componentRefs": { + "description": "The Component element ids you want to reference from the fragments.", + "default": [], + "type": "array", + "items": { + "type": "string" + } + }, + "featureGroupRefs": { + "description": "The FeatureGroup element ids you want to reference from the fragments.", + "default": [], + "type": "array", + "items": { + "type": "string" + } + }, + "featureRefs": { + "description": "The Feature element ids you want to reference from the fragments.", + "default": [], + "type": "array", + "items": { + "type": "string" + } + }, + "mergeRefs": { + "description": "The Merge element ids you want to reference from the fragments.", + "default": [], + "type": "array", + "items": { + "type": "string" + } + }, + "enableElevatedUpdateTask": { + "description": "Create an elevated update task within Windows Task Scheduler.", + "default": false, + "type": "boolean" + }, + "bannerPath": { + "description": "Path to a bitmap file to use as the installation user interface banner.\n This bitmap will appear at the top of all but the first page of the installer.\n\n The required dimensions are 493px × 58px.", + "type": [ + "string", + "null" + ] + }, + "dialogImagePath": { + "description": "Path to a bitmap file to use on the installation user interface dialogs.\n It is used on the welcome and completion dialogs.\n\n The required dimensions are 493px × 312px.", + "type": [ + "string", + "null" + ] + }, + "fipsCompliant": { + "description": "Enables FIPS compliant algorithms.\n Can also be enabled via the `TAURI_BUNDLER_WIX_FIPS_COMPLIANT` env var.", + "default": false, + "type": "boolean" + } + }, + "additionalProperties": false + }, + "WixLanguage": { + "description": "The languages to build using WiX.", + "anyOf": [ + { + "description": "A single language to build, without configuration.", + "type": "string" + }, + { + "description": "A list of languages to build, without configuration.", + "type": "array", + "items": { + "type": "string" + } + }, + { + "description": "A map of languages and its configuration.", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/WixLanguageConfig" + } + } + ] + }, + "WixLanguageConfig": { + "description": "Configuration for a target language for the WiX build.\n\n See more: ", + "type": "object", + "properties": { + "localePath": { + "description": "The path to a locale (`.wxl`) file. See .", + "type": [ + "string", + "null" + ] + } + }, + "additionalProperties": false + }, + "NsisConfig": { + "description": "Configuration for the Installer bundle using NSIS.", + "type": "object", + "properties": { + "template": { + "description": "A custom .nsi template to use.", + "type": [ + "string", + "null" + ] + }, + "headerImage": { + "description": "The path to a bitmap file to display on the header of installers pages.\n\n The recommended dimensions are 150px x 57px.", + "type": [ + "string", + "null" + ] + }, + "sidebarImage": { + "description": "The path to a bitmap file for the Welcome page and the Finish page.\n\n The recommended dimensions are 164px x 314px.", + "type": [ + "string", + "null" + ] + }, + "installerIcon": { + "description": "The path to an icon file used as the installer icon.", + "type": [ + "string", + "null" + ] + }, + "installMode": { + "description": "Whether the installation will be for all users or just the current user.", + "default": "currentUser", + "allOf": [ + { + "$ref": "#/definitions/NSISInstallerMode" + } + ] + }, + "languages": { + "description": "A list of installer languages.\n By default the OS language is used. If the OS language is not in the list of languages, the first language will be used.\n To allow the user to select the language, set `display_language_selector` to `true`.\n\n See for the complete list of languages.", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "customLanguageFiles": { + "description": "A key-value pair where the key is the language and the\n value is the path to a custom `.nsh` file that holds the translated text for tauri's custom messages.\n\n See for an example `.nsh` file.\n\n **Note**: the key must be a valid NSIS language and it must be added to [`NsisConfig`] languages array,", + "type": [ + "object", + "null" + ], + "additionalProperties": { + "type": "string" + } + }, + "displayLanguageSelector": { + "description": "Whether to display a language selector dialog before the installer and uninstaller windows are rendered or not.\n By default the OS language is selected, with a fallback to the first language in the `languages` array.", + "default": false, + "type": "boolean" + }, + "compression": { + "description": "Set the compression algorithm used to compress files in the installer.\n\n See ", + "default": "lzma", + "allOf": [ + { + "$ref": "#/definitions/NsisCompression" + } + ] + }, + "startMenuFolder": { + "description": "Set the folder name for the start menu shortcut.\n\n Use this option if you have multiple apps and wish to group their shortcuts under one folder\n or if you generally prefer to set your shortcut inside a folder.\n\n Examples:\n - `AwesomePublisher`, shortcut will be placed in `%AppData%\\Microsoft\\Windows\\Start Menu\\Programs\\AwesomePublisher\\.lnk`\n - If unset, shortcut will be placed in `%AppData%\\Microsoft\\Windows\\Start Menu\\Programs\\.lnk`", + "type": [ + "string", + "null" + ] + }, + "installerHooks": { + "description": "A path to a `.nsh` file that contains special NSIS macros to be hooked into the\n main installer.nsi script.\n\n Supported hooks are:\n\n - `NSIS_HOOK_PREINSTALL`: This hook runs before copying files, setting registry key values and creating shortcuts.\n - `NSIS_HOOK_POSTINSTALL`: This hook runs after the installer has finished copying all files, setting the registry keys and created shortcuts.\n - `NSIS_HOOK_PREUNINSTALL`: This hook runs before removing any files, registry keys and shortcuts.\n - `NSIS_HOOK_POSTUNINSTALL`: This hook runs after files, registry keys and shortcuts have been removed.\n\n ### Example\n\n ```nsh\n !macro NSIS_HOOK_PREINSTALL\n MessageBox MB_OK \"PreInstall\"\n !macroend\n\n !macro NSIS_HOOK_POSTINSTALL\n MessageBox MB_OK \"PostInstall\"\n !macroend\n\n !macro NSIS_HOOK_PREUNINSTALL\n MessageBox MB_OK \"PreUnInstall\"\n !macroend\n\n !macro NSIS_HOOK_POSTUNINSTALL\n MessageBox MB_OK \"PostUninstall\"\n !macroend\n ```", + "type": [ + "string", + "null" + ] + }, + "minimumWebview2Version": { + "description": "Try to ensure that the WebView2 version is equal to or newer than this version,\n if the user's WebView2 is older than this version,\n the installer will try to trigger a WebView2 update.", + "type": [ + "string", + "null" + ] + } + }, + "additionalProperties": false + }, + "NSISInstallerMode": { + "description": "Install Modes for the NSIS installer.", + "oneOf": [ + { + "description": "Default mode for the installer.\n\n Install the app by default in a directory that doesn't require Administrator access.\n\n Installer metadata will be saved under the `HKCU` registry path.", + "type": "string", + "enum": [ + "currentUser" + ] + }, + { + "description": "Install the app by default in the `Program Files` folder directory requires Administrator\n access for the installation.\n\n Installer metadata will be saved under the `HKLM` registry path.", + "type": "string", + "enum": [ + "perMachine" + ] + }, + { + "description": "Combines both modes and allows the user to choose at install time\n whether to install for the current user or per machine. Note that this mode\n will require Administrator access even if the user wants to install it for the current user only.\n\n Installer metadata will be saved under the `HKLM` or `HKCU` registry path based on the user's choice.", + "type": "string", + "enum": [ + "both" + ] + } + ] + }, + "NsisCompression": { + "description": "Compression algorithms used in the NSIS installer.\n\n See ", + "oneOf": [ + { + "description": "ZLIB uses the deflate algorithm, it is a quick and simple method. With the default compression level it uses about 300 KB of memory.", + "type": "string", + "enum": [ + "zlib" + ] + }, + { + "description": "BZIP2 usually gives better compression ratios than ZLIB, but it is a bit slower and uses more memory. With the default compression level it uses about 4 MB of memory.", + "type": "string", + "enum": [ + "bzip2" + ] + }, + { + "description": "LZMA (default) is a new compression method that gives very good compression ratios. The decompression speed is high (10-20 MB/s on a 2 GHz CPU), the compression speed is lower. The memory size that will be used for decompression is the dictionary size plus a few KBs, the default is 8 MB.", + "type": "string", + "enum": [ + "lzma" + ] + }, + { + "description": "Disable compression", + "type": "string", + "enum": [ + "none" + ] + } + ] + }, + "CustomSignCommandConfig": { + "description": "Custom Signing Command configuration.", + "anyOf": [ + { + "description": "A string notation of the script to execute.\n\n \"%1\" will be replaced with the path to the binary to be signed.\n\n This is a simpler notation for the command.\n Tauri will split the string with `' '` and use the first element as the command name and the rest as arguments.\n\n If you need to use whitespace in the command or arguments, use the object notation [`Self::CommandWithOptions`].", + "type": "string" + }, + { + "description": "An object notation of the command.\n\n This is more complex notation for the command but\n this allows you to use whitespace in the command and arguments.", + "type": "object", + "required": [ + "args", + "cmd" + ], + "properties": { + "cmd": { + "description": "The command to run to sign the binary.", + "type": "string" + }, + "args": { + "description": "The arguments to pass to the command.\n\n \"%1\" will be replaced with the path to the binary to be signed.", + "type": "array", + "items": { + "type": "string" + } + } + }, + "additionalProperties": false + } + ] + }, + "LinuxConfig": { + "description": "Configuration for Linux bundles.\n\n See more: ", + "type": "object", + "properties": { + "appimage": { + "description": "Configuration for the AppImage bundle.", + "default": { + "bundleMediaFramework": false, + "files": {} + }, + "allOf": [ + { + "$ref": "#/definitions/AppImageConfig" + } + ] + }, + "deb": { + "description": "Configuration for the Debian bundle.", + "default": { + "files": {} + }, + "allOf": [ + { + "$ref": "#/definitions/DebConfig" + } + ] + }, + "rpm": { + "description": "Configuration for the RPM bundle.", + "default": { + "epoch": 0, + "files": {}, + "release": "1" + }, + "allOf": [ + { + "$ref": "#/definitions/RpmConfig" + } + ] + } + }, + "additionalProperties": false + }, + "AppImageConfig": { + "description": "Configuration for AppImage bundles.\n\n See more: ", + "type": "object", + "properties": { + "bundleMediaFramework": { + "description": "Include additional gstreamer dependencies needed for audio and video playback.\n This increases the bundle size by ~15-35MB depending on your build system.", + "default": false, + "type": "boolean" + }, + "files": { + "description": "The files to include in the Appimage Binary.", + "default": {}, + "type": "object", + "additionalProperties": { + "type": "string" + } + } + }, + "additionalProperties": false + }, + "DebConfig": { + "description": "Configuration for Debian (.deb) bundles.\n\n See more: ", + "type": "object", + "properties": { + "depends": { + "description": "The list of deb dependencies your application relies on.", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "recommends": { + "description": "The list of deb dependencies your application recommends.", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "provides": { + "description": "The list of dependencies the package provides.", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "conflicts": { + "description": "The list of package conflicts.", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "replaces": { + "description": "The list of package replaces.", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "files": { + "description": "The files to include on the package.", + "default": {}, + "type": "object", + "additionalProperties": { + "type": "string" + } + }, + "section": { + "description": "Define the section in Debian Control file. See : https://www.debian.org/doc/debian-policy/ch-archive.html#s-subsections", + "type": [ + "string", + "null" + ] + }, + "priority": { + "description": "Change the priority of the Debian Package. By default, it is set to `optional`.\n Recognized Priorities as of now are : `required`, `important`, `standard`, `optional`, `extra`", + "type": [ + "string", + "null" + ] + }, + "changelog": { + "description": "Path of the uncompressed Changelog file, to be stored at /usr/share/doc/package-name/changelog.gz. See\n ", + "type": [ + "string", + "null" + ] + }, + "desktopTemplate": { + "description": "Path to a custom desktop file Handlebars template.\n\n Available variables: `categories`, `comment` (optional), `exec`, `icon` and `name`.", + "type": [ + "string", + "null" + ] + }, + "preInstallScript": { + "description": "Path to script that will be executed before the package is unpacked. See\n ", + "type": [ + "string", + "null" + ] + }, + "postInstallScript": { + "description": "Path to script that will be executed after the package is unpacked. See\n ", + "type": [ + "string", + "null" + ] + }, + "preRemoveScript": { + "description": "Path to script that will be executed before the package is removed. See\n ", + "type": [ + "string", + "null" + ] + }, + "postRemoveScript": { + "description": "Path to script that will be executed after the package is removed. See\n ", + "type": [ + "string", + "null" + ] + } + }, + "additionalProperties": false + }, + "RpmConfig": { + "description": "Configuration for RPM bundles.", + "type": "object", + "properties": { + "depends": { + "description": "The list of RPM dependencies your application relies on.", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "recommends": { + "description": "The list of RPM dependencies your application recommends.", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "provides": { + "description": "The list of RPM dependencies your application provides.", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "conflicts": { + "description": "The list of RPM dependencies your application conflicts with. They must not be present\n in order for the package to be installed.", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "obsoletes": { + "description": "The list of RPM dependencies your application supersedes - if this package is installed,\n packages listed as \"obsoletes\" will be automatically removed (if they are present).", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "release": { + "description": "The RPM release tag.", + "default": "1", + "type": "string" + }, + "epoch": { + "description": "The RPM epoch.", + "default": 0, + "type": "integer", + "format": "uint32", + "minimum": 0.0 + }, + "files": { + "description": "The files to include on the package.", + "default": {}, + "type": "object", + "additionalProperties": { + "type": "string" + } + }, + "desktopTemplate": { + "description": "Path to a custom desktop file Handlebars template.\n\n Available variables: `categories`, `comment` (optional), `exec`, `icon` and `name`.", + "type": [ + "string", + "null" + ] + }, + "preInstallScript": { + "description": "Path to script that will be executed before the package is unpacked. See\n ", + "type": [ + "string", + "null" + ] + }, + "postInstallScript": { + "description": "Path to script that will be executed after the package is unpacked. See\n ", + "type": [ + "string", + "null" + ] + }, + "preRemoveScript": { + "description": "Path to script that will be executed before the package is removed. See\n ", + "type": [ + "string", + "null" + ] + }, + "postRemoveScript": { + "description": "Path to script that will be executed after the package is removed. See\n ", + "type": [ + "string", + "null" + ] + }, + "compression": { + "description": "Compression algorithm and level. Defaults to `Gzip` with level 6.", + "anyOf": [ + { + "$ref": "#/definitions/RpmCompression" + }, + { + "type": "null" + } + ] + } + }, + "additionalProperties": false + }, + "RpmCompression": { + "description": "Compression algorithms used when bundling RPM packages.", + "oneOf": [ + { + "description": "Gzip compression", + "type": "object", + "required": [ + "level", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "gzip" + ] + }, + "level": { + "description": "Gzip compression level", + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + }, + "additionalProperties": false + }, + { + "description": "Zstd compression", + "type": "object", + "required": [ + "level", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "zstd" + ] + }, + "level": { + "description": "Zstd compression level", + "type": "integer", + "format": "int32" + } + }, + "additionalProperties": false + }, + { + "description": "Xz compression", + "type": "object", + "required": [ + "level", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "xz" + ] + }, + "level": { + "description": "Xz compression level", + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + }, + "additionalProperties": false + }, + { + "description": "Bzip2 compression", + "type": "object", + "required": [ + "level", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "bzip2" + ] + }, + "level": { + "description": "Bzip2 compression level", + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + }, + "additionalProperties": false + }, + { + "description": "Disable compression", + "type": "object", + "required": [ + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "none" + ] + } + }, + "additionalProperties": false + } + ] + }, + "MacConfig": { + "description": "Configuration for the macOS bundles.\n\n See more: ", + "type": "object", + "properties": { + "frameworks": { + "description": "A list of strings indicating any macOS X frameworks that need to be bundled with the application.\n\n If a name is used, \".framework\" must be omitted and it will look for standard install locations. You may also use a path to a specific framework.", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "files": { + "description": "The files to include in the application relative to the Contents directory.", + "default": {}, + "type": "object", + "additionalProperties": { + "type": "string" + } + }, + "bundleVersion": { + "description": "The version of the build that identifies an iteration of the bundle.\n\n Translates to the bundle's CFBundleVersion property.", + "type": [ + "string", + "null" + ] + }, + "bundleName": { + "description": "The name of the builder that built the bundle.\n\n Translates to the bundle's CFBundleName property.\n\n If not set, defaults to the package's product name.", + "type": [ + "string", + "null" + ] + }, + "minimumSystemVersion": { + "description": "A version string indicating the minimum macOS X version that the bundled application supports. Defaults to `10.13`.\n\n Setting it to `null` completely removes the `LSMinimumSystemVersion` field on the bundle's `Info.plist`\n and the `MACOSX_DEPLOYMENT_TARGET` environment variable.\n\n Ignored in `tauri dev`.\n\n An empty string is considered an invalid value so the default value is used.", + "default": "10.13", + "type": [ + "string", + "null" + ] + }, + "exceptionDomain": { + "description": "Allows your application to communicate with the outside world.\n It should be a lowercase, without port and protocol domain name.", + "type": [ + "string", + "null" + ] + }, + "signingIdentity": { + "description": "Identity to use for code signing.", + "type": [ + "string", + "null" + ] + }, + "hardenedRuntime": { + "description": "Whether the codesign should enable [hardened runtime](https://developer.apple.com/documentation/security/hardened_runtime) (for executables) or not.", + "default": true, + "type": "boolean" + }, + "providerShortName": { + "description": "Provider short name for notarization.", + "type": [ + "string", + "null" + ] + }, + "entitlements": { + "description": "Path to the entitlements file.", + "type": [ + "string", + "null" + ] + }, + "infoPlist": { + "description": "Path to a Info.plist file to merge with the default Info.plist.\n\n Note that Tauri also looks for a `Info.plist` file in the same directory as the Tauri configuration file.", + "type": [ + "string", + "null" + ] + }, + "dmg": { + "description": "DMG-specific settings.", + "default": { + "appPosition": { + "x": 180, + "y": 170 + }, + "applicationFolderPosition": { + "x": 480, + "y": 170 + }, + "windowSize": { + "height": 400, + "width": 660 + } + }, + "allOf": [ + { + "$ref": "#/definitions/DmgConfig" + } + ] + } + }, + "additionalProperties": false + }, + "DmgConfig": { + "description": "Configuration for Apple Disk Image (.dmg) bundles.\n\n See more: ", + "type": "object", + "properties": { + "background": { + "description": "Image to use as the background in dmg file. Accepted formats: `png`/`jpg`/`gif`.", + "type": [ + "string", + "null" + ] + }, + "windowPosition": { + "description": "Position of volume window on screen.", + "anyOf": [ + { + "$ref": "#/definitions/Position" + }, + { + "type": "null" + } + ] + }, + "windowSize": { + "description": "Size of volume window.", + "default": { + "height": 400, + "width": 660 + }, + "allOf": [ + { + "$ref": "#/definitions/Size" + } + ] + }, + "appPosition": { + "description": "Position of app file on window.", + "default": { + "x": 180, + "y": 170 + }, + "allOf": [ + { + "$ref": "#/definitions/Position" + } + ] + }, + "applicationFolderPosition": { + "description": "Position of application folder on window.", + "default": { + "x": 480, + "y": 170 + }, + "allOf": [ + { + "$ref": "#/definitions/Position" + } + ] + } + }, + "additionalProperties": false + }, + "Position": { + "description": "Position coordinates struct.", + "type": "object", + "required": [ + "x", + "y" + ], + "properties": { + "x": { + "description": "X coordinate.", + "type": "integer", + "format": "uint32", + "minimum": 0.0 + }, + "y": { + "description": "Y coordinate.", + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + }, + "additionalProperties": false + }, + "Size": { + "description": "Size of the window.", + "type": "object", + "required": [ + "height", + "width" + ], + "properties": { + "width": { + "description": "Width of the window.", + "type": "integer", + "format": "uint32", + "minimum": 0.0 + }, + "height": { + "description": "Height of the window.", + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + }, + "additionalProperties": false + }, + "IosConfig": { + "description": "General configuration for the iOS target.", + "type": "object", + "properties": { + "template": { + "description": "A custom [XcodeGen] project.yml template to use.\n\n [XcodeGen]: ", + "type": [ + "string", + "null" + ] + }, + "frameworks": { + "description": "A list of strings indicating any iOS frameworks that need to be bundled with the application.\n\n Note that you need to recreate the iOS project for the changes to be applied.", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "developmentTeam": { + "description": "The development team. This value is required for iOS development because code signing is enforced.\n The `APPLE_DEVELOPMENT_TEAM` environment variable can be set to overwrite it.", + "type": [ + "string", + "null" + ] + }, + "bundleVersion": { + "description": "The version of the build that identifies an iteration of the bundle.\n\n Translates to the bundle's CFBundleVersion property.", + "type": [ + "string", + "null" + ] + }, + "minimumSystemVersion": { + "description": "A version string indicating the minimum iOS version that the bundled application supports. Defaults to `13.0`.\n\n Maps to the IPHONEOS_DEPLOYMENT_TARGET value.", + "default": "14.0", + "type": "string" + }, + "infoPlist": { + "description": "Path to a Info.plist file to merge with the default Info.plist.\n\n Note that Tauri also looks for a `Info.plist` and `Info.ios.plist` file in the same directory as the Tauri configuration file.", + "type": [ + "string", + "null" + ] + } + }, + "additionalProperties": false + }, + "AndroidConfig": { + "description": "General configuration for the Android target.", + "type": "object", + "properties": { + "minSdkVersion": { + "description": "The minimum API level required for the application to run.\n The Android system will prevent the user from installing the application if the system's API level is lower than the value specified.", + "default": 24, + "type": "integer", + "format": "uint32", + "minimum": 0.0 + }, + "versionCode": { + "description": "The version code of the application.\n It is limited to 2,100,000,000 as per Google Play Store requirements.\n\n By default we use your configured version and perform the following math:\n versionCode = version.major * 1000000 + version.minor * 1000 + version.patch", + "type": [ + "integer", + "null" + ], + "format": "uint32", + "maximum": 2100000000.0, + "minimum": 1.0 + }, + "autoIncrementVersionCode": { + "description": "Whether to automatically increment the `versionCode` on each build.\n\n - If `true`, the generator will try to read the last `versionCode` from\n `tauri.properties` and increment it by 1 for every build.\n - If `false` or not set, it falls back to `version_code` or semver-derived logic.\n\n Note that to use this feature, you should remove `/tauri.properties` from `src-tauri/gen/android/app/.gitignore` so the current versionCode is committed to the repository.", + "default": false, + "type": "boolean" + } + }, + "additionalProperties": false + }, + "PluginConfig": { + "description": "The plugin configs holds a HashMap mapping a plugin name to its configuration object.\n\n See more: ", + "type": "object", + "additionalProperties": true + } + } +} \ No newline at end of file diff --git a/scripts/node_modules/@tauri-apps/cli/index.d.ts b/scripts/node_modules/@tauri-apps/cli/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..956ddc1a04d83749e151004f26c8d9efcf547524 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/cli/index.d.ts @@ -0,0 +1,9 @@ +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT + +/* auto-generated by NAPI-RS */ +/* eslint-disable */ +export declare function logError(error: string): void + +export declare function run(args: Array, binName: string | undefined | null, callback: ((err: Error | null, arg: boolean) => any)): void diff --git a/scripts/node_modules/@tauri-apps/cli/index.js b/scripts/node_modules/@tauri-apps/cli/index.js new file mode 100644 index 0000000000000000000000000000000000000000..c9e3996961170026966cd6a7cb58e32031ec154f --- /dev/null +++ b/scripts/node_modules/@tauri-apps/cli/index.js @@ -0,0 +1,580 @@ +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT + +// prettier-ignore +/* eslint-disable */ +// @ts-nocheck +/* auto-generated by NAPI-RS */ + +const { readFileSync } = require('node:fs') +let nativeBinding = null +const loadErrors = [] + +const isMusl = () => { + let musl = false + if (process.platform === 'linux') { + musl = isMuslFromFilesystem() + if (musl === null) { + musl = isMuslFromReport() + } + if (musl === null) { + musl = isMuslFromChildProcess() + } + } + return musl +} + +const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-') + +const isMuslFromFilesystem = () => { + try { + return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl') + } catch { + return null + } +} + +const isMuslFromReport = () => { + let report = null + if (typeof process.report?.getReport === 'function') { + process.report.excludeNetwork = true + report = process.report.getReport() + } + if (!report) { + return null + } + if (report.header && report.header.glibcVersionRuntime) { + return false + } + if (Array.isArray(report.sharedObjects)) { + if (report.sharedObjects.some(isFileMusl)) { + return true + } + } + return false +} + +const isMuslFromChildProcess = () => { + try { + return require('child_process').execSync('ldd --version', { encoding: 'utf8' }).includes('musl') + } catch (e) { + // If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false + return false + } +} + +function requireNative() { + if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) { + try { + return require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH); + } catch (err) { + loadErrors.push(err) + } + } else if (process.platform === 'android') { + if (process.arch === 'arm64') { + try { + return require('./cli.android-arm64.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-android-arm64') + const bindingPackageVersion = require('@tauri-apps/cli-android-arm64/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } else if (process.arch === 'arm') { + try { + return require('./cli.android-arm-eabi.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-android-arm-eabi') + const bindingPackageVersion = require('@tauri-apps/cli-android-arm-eabi/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } else { + loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`)) + } + } else if (process.platform === 'win32') { + if (process.arch === 'x64') { + if (process.config?.variables?.shlib_suffix === 'dll.a' || process.config?.variables?.node_target_type === 'shared_library') { + try { + return require('./cli.win32-x64-gnu.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-win32-x64-gnu') + const bindingPackageVersion = require('@tauri-apps/cli-win32-x64-gnu/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } else { + try { + return require('./cli.win32-x64-msvc.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-win32-x64-msvc') + const bindingPackageVersion = require('@tauri-apps/cli-win32-x64-msvc/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } + } else if (process.arch === 'ia32') { + try { + return require('./cli.win32-ia32-msvc.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-win32-ia32-msvc') + const bindingPackageVersion = require('@tauri-apps/cli-win32-ia32-msvc/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } else if (process.arch === 'arm64') { + try { + return require('./cli.win32-arm64-msvc.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-win32-arm64-msvc') + const bindingPackageVersion = require('@tauri-apps/cli-win32-arm64-msvc/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } else { + loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`)) + } + } else if (process.platform === 'darwin') { + try { + return require('./cli.darwin-universal.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-darwin-universal') + const bindingPackageVersion = require('@tauri-apps/cli-darwin-universal/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + if (process.arch === 'x64') { + try { + return require('./cli.darwin-x64.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-darwin-x64') + const bindingPackageVersion = require('@tauri-apps/cli-darwin-x64/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } else if (process.arch === 'arm64') { + try { + return require('./cli.darwin-arm64.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-darwin-arm64') + const bindingPackageVersion = require('@tauri-apps/cli-darwin-arm64/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } else { + loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`)) + } + } else if (process.platform === 'freebsd') { + if (process.arch === 'x64') { + try { + return require('./cli.freebsd-x64.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-freebsd-x64') + const bindingPackageVersion = require('@tauri-apps/cli-freebsd-x64/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } else if (process.arch === 'arm64') { + try { + return require('./cli.freebsd-arm64.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-freebsd-arm64') + const bindingPackageVersion = require('@tauri-apps/cli-freebsd-arm64/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } else { + loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`)) + } + } else if (process.platform === 'linux') { + if (process.arch === 'x64') { + if (isMusl()) { + try { + return require('./cli.linux-x64-musl.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-linux-x64-musl') + const bindingPackageVersion = require('@tauri-apps/cli-linux-x64-musl/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } else { + try { + return require('./cli.linux-x64-gnu.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-linux-x64-gnu') + const bindingPackageVersion = require('@tauri-apps/cli-linux-x64-gnu/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } + } else if (process.arch === 'arm64') { + if (isMusl()) { + try { + return require('./cli.linux-arm64-musl.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-linux-arm64-musl') + const bindingPackageVersion = require('@tauri-apps/cli-linux-arm64-musl/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } else { + try { + return require('./cli.linux-arm64-gnu.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-linux-arm64-gnu') + const bindingPackageVersion = require('@tauri-apps/cli-linux-arm64-gnu/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } + } else if (process.arch === 'arm') { + if (isMusl()) { + try { + return require('./cli.linux-arm-musleabihf.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-linux-arm-musleabihf') + const bindingPackageVersion = require('@tauri-apps/cli-linux-arm-musleabihf/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } else { + try { + return require('./cli.linux-arm-gnueabihf.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-linux-arm-gnueabihf') + const bindingPackageVersion = require('@tauri-apps/cli-linux-arm-gnueabihf/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } + } else if (process.arch === 'loong64') { + if (isMusl()) { + try { + return require('./cli.linux-loong64-musl.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-linux-loong64-musl') + const bindingPackageVersion = require('@tauri-apps/cli-linux-loong64-musl/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } else { + try { + return require('./cli.linux-loong64-gnu.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-linux-loong64-gnu') + const bindingPackageVersion = require('@tauri-apps/cli-linux-loong64-gnu/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } + } else if (process.arch === 'riscv64') { + if (isMusl()) { + try { + return require('./cli.linux-riscv64-musl.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-linux-riscv64-musl') + const bindingPackageVersion = require('@tauri-apps/cli-linux-riscv64-musl/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } else { + try { + return require('./cli.linux-riscv64-gnu.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-linux-riscv64-gnu') + const bindingPackageVersion = require('@tauri-apps/cli-linux-riscv64-gnu/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } + } else if (process.arch === 'ppc64') { + try { + return require('./cli.linux-ppc64-gnu.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-linux-ppc64-gnu') + const bindingPackageVersion = require('@tauri-apps/cli-linux-ppc64-gnu/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } else if (process.arch === 's390x') { + try { + return require('./cli.linux-s390x-gnu.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-linux-s390x-gnu') + const bindingPackageVersion = require('@tauri-apps/cli-linux-s390x-gnu/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } else { + loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`)) + } + } else if (process.platform === 'openharmony') { + if (process.arch === 'arm64') { + try { + return require('./cli.openharmony-arm64.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-openharmony-arm64') + const bindingPackageVersion = require('@tauri-apps/cli-openharmony-arm64/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } else if (process.arch === 'x64') { + try { + return require('./cli.openharmony-x64.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-openharmony-x64') + const bindingPackageVersion = require('@tauri-apps/cli-openharmony-x64/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } else if (process.arch === 'arm') { + try { + return require('./cli.openharmony-arm.node') + } catch (e) { + loadErrors.push(e) + } + try { + const binding = require('@tauri-apps/cli-openharmony-arm') + const bindingPackageVersion = require('@tauri-apps/cli-openharmony-arm/package.json').version + if (bindingPackageVersion !== '2.10.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { + throw new Error(`Native binding package version mismatch, expected 2.10.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) + } + return binding + } catch (e) { + loadErrors.push(e) + } + } else { + loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`)) + } + } else { + loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`)) + } +} + +nativeBinding = requireNative() + +if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) { + let wasiBinding = null + let wasiBindingError = null + try { + wasiBinding = require('./cli.wasi.cjs') + nativeBinding = wasiBinding + } catch (err) { + if (process.env.NAPI_RS_FORCE_WASI) { + wasiBindingError = err + } + } + if (!nativeBinding) { + try { + wasiBinding = require('@tauri-apps/cli-wasm32-wasi') + nativeBinding = wasiBinding + } catch (err) { + if (process.env.NAPI_RS_FORCE_WASI) { + wasiBindingError.cause = err + loadErrors.push(err) + } + } + } + if (process.env.NAPI_RS_FORCE_WASI === 'error' && !wasiBinding) { + const error = new Error('WASI binding not found and NAPI_RS_FORCE_WASI is set to error') + error.cause = wasiBindingError + throw error + } +} + +if (!nativeBinding) { + if (loadErrors.length > 0) { + throw new Error( + `Cannot find native binding. ` + + `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` + + 'Please try `npm i` again after removing both package-lock.json and node_modules directory.', + { + cause: loadErrors.reduce((err, cur) => { + cur.cause = err + return cur + }), + }, + ) + } + throw new Error(`Failed to load native binding`) +} + +module.exports = nativeBinding +module.exports.logError = nativeBinding.logError +module.exports.run = nativeBinding.run diff --git a/scripts/node_modules/@tauri-apps/cli/main.d.ts b/scripts/node_modules/@tauri-apps/cli/main.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ee5d858381588a7d7947baf1375585fd06c75e80 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/cli/main.d.ts @@ -0,0 +1,11 @@ +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT + +/* tslint:disable */ +/* eslint-disable */ + +export function run( + args: Array, + binName?: string | undefined | null +): Promise diff --git a/scripts/node_modules/@tauri-apps/cli/main.js b/scripts/node_modules/@tauri-apps/cli/main.js new file mode 100644 index 0000000000000000000000000000000000000000..5fb1933ded588db68f1efa1e269f931f04f7aee2 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/cli/main.js @@ -0,0 +1,19 @@ +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT + +const { run, logError } = require('./index') + +module.exports.run = (args, binName) => { + return new Promise((resolve, reject) => { + run(args, binName, (error, res) => { + if (error) { + reject(error) + } else { + resolve(res) + } + }) + }) +} + +module.exports.logError = logError diff --git a/scripts/node_modules/@tauri-apps/cli/package.json b/scripts/node_modules/@tauri-apps/cli/package.json new file mode 100644 index 0000000000000000000000000000000000000000..8953d44cb80098417d8a167c033d31c16cb24d44 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/cli/package.json @@ -0,0 +1,80 @@ +{ + "name": "@tauri-apps/cli", + "version": "2.10.1", + "description": "Command line interface for building Tauri apps", + "type": "commonjs", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/tauri" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/tauri-apps/tauri.git" + }, + "contributors": [ + "Tauri Programme within The Commons Conservancy" + ], + "license": "Apache-2.0 OR MIT", + "bugs": { + "url": "https://github.com/tauri-apps/tauri/issues" + }, + "homepage": "https://github.com/tauri-apps/tauri#readme", + "publishConfig": { + "access": "public" + }, + "main": "main.js", + "types": "main.d.ts", + "napi": { + "binaryName": "cli", + "targets": [ + "x86_64-unknown-linux-gnu", + "x86_64-pc-windows-msvc", + "x86_64-apple-darwin", + "aarch64-apple-darwin", + "aarch64-unknown-linux-gnu", + "aarch64-unknown-linux-musl", + "armv7-unknown-linux-gnueabihf", + "x86_64-unknown-linux-musl", + "riscv64gc-unknown-linux-gnu", + "i686-pc-windows-msvc", + "aarch64-pc-windows-msvc" + ] + }, + "devDependencies": { + "@napi-rs/cli": "^3.4.1", + "@types/node": "^24.0.0", + "cross-env": "10.1.0", + "vitest": "^4.0.0" + }, + "engines": { + "node": ">= 10" + }, + "bin": { + "tauri": "./tauri.js" + }, + "scripts": { + "artifacts": "napi artifacts", + "build": "cross-env TARGET=node napi build --platform --profile release-size-optimized", + "postbuild": "node append-headers.js", + "build:debug": "cross-env TARGET=node napi build --platform", + "postbuild:debug": "node append-headers.js", + "prepublishOnly": "napi prepublish -t npm --gh-release-id $RELEASE_ID", + "prepack": "cp ../../crates/tauri-schema-generator/schemas/config.schema.json .", + "version": "napi version", + "test": "vitest run", + "tauri": "node ./tauri.js" + }, + "optionalDependencies": { + "@tauri-apps/cli-linux-x64-gnu": "2.10.1", + "@tauri-apps/cli-win32-x64-msvc": "2.10.1", + "@tauri-apps/cli-darwin-x64": "2.10.1", + "@tauri-apps/cli-darwin-arm64": "2.10.1", + "@tauri-apps/cli-linux-arm64-gnu": "2.10.1", + "@tauri-apps/cli-linux-arm64-musl": "2.10.1", + "@tauri-apps/cli-linux-arm-gnueabihf": "2.10.1", + "@tauri-apps/cli-linux-x64-musl": "2.10.1", + "@tauri-apps/cli-linux-riscv64-gnu": "2.10.1", + "@tauri-apps/cli-win32-ia32-msvc": "2.10.1", + "@tauri-apps/cli-win32-arm64-msvc": "2.10.1" + } +} \ No newline at end of file diff --git a/scripts/node_modules/@tauri-apps/cli/tauri.js b/scripts/node_modules/@tauri-apps/cli/tauri.js new file mode 100644 index 0000000000000000000000000000000000000000..452202cbbd183677da91f716054545a19e4ad181 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/cli/tauri.js @@ -0,0 +1,57 @@ +#!/usr/bin/env node + +// Copyright 2019-2024 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT + +const cli = require('./main') +const path = require('path') + +const [bin, script, ...args] = process.argv +const binStem = path.parse(bin).name.toLowerCase() + +// We want to make a helpful binary name for the underlying CLI helper, if we +// can successfully detect what command likely started the execution. +let binName + +// deno run -A npm:@tauri-apps/cli or deno task tauri +if (globalThis.navigator?.userAgent?.includes('Deno')) { + binName = bin +} +// Even if started by a package manager, the binary will be NodeJS. +// Some distribution still use "nodejs" as the binary name. +else if (binStem.match(/(nodejs|node|bun|electron)\-?([0-9]*)*$/g)) { + const managerStem = process.env.npm_execpath + ? path.parse(process.env.npm_execpath).name.toLowerCase() + : null + if (managerStem) { + let manager + switch (managerStem) { + // Only supported package manager that has a different filename is npm. + case 'npm-cli': + manager = 'npm' + break + + // Yarn, pnpm, and bun have the same stem name as their bin. + // We assume all unknown package managers do as well. + default: + manager = managerStem + break + } + + binName = `${manager} run ${process.env.npm_lifecycle_event}` + } else { + // Assume running NodeJS if we didn't detect a manager from the env. + // We normalize the path to prevent the script's absolute path being used. + const scriptNormal = path.normalize(path.relative(process.cwd(), script)) + binName = `${binStem} ${scriptNormal}` + } +} else { + // We don't know what started it, assume it's already stripped. + args.unshift(bin) +} + +cli.run(args, binName).catch((err) => { + cli.logError(err.message) + process.exit(1) +}) diff --git a/scripts/node_modules/@tauri-apps/plugin-dialog/LICENSE.spdx b/scripts/node_modules/@tauri-apps/plugin-dialog/LICENSE.spdx new file mode 100644 index 0000000000000000000000000000000000000000..cdd0df5ad76e63d23a80834469609c1d8109ff2e --- /dev/null +++ b/scripts/node_modules/@tauri-apps/plugin-dialog/LICENSE.spdx @@ -0,0 +1,20 @@ +SPDXVersion: SPDX-2.1 +DataLicense: CC0-1.0 +PackageName: tauri +DataFormat: SPDXRef-1 +PackageSupplier: Organization: The Tauri Programme in the Commons Conservancy +PackageHomePage: https://tauri.app +PackageLicenseDeclared: Apache-2.0 +PackageLicenseDeclared: MIT +PackageCopyrightText: 2019-2022, The Tauri Programme in the Commons Conservancy +PackageSummary: Tauri is a rust project that enables developers to make secure +and small desktop applications using a web frontend. + +PackageComment: The package includes the following libraries; see +Relationship information. + +Created: 2019-05-20T09:00:00Z +PackageDownloadLocation: git://github.com/tauri-apps/tauri +PackageDownloadLocation: git+https://github.com/tauri-apps/tauri.git +PackageDownloadLocation: git+ssh://github.com/tauri-apps/tauri.git +Creator: Person: Daniel Thompson-Yvetot \ No newline at end of file diff --git a/scripts/node_modules/@tauri-apps/plugin-dialog/README.md b/scripts/node_modules/@tauri-apps/plugin-dialog/README.md new file mode 100644 index 0000000000000000000000000000000000000000..e062c803f5ff6b05153034373cc41d2c5ed3a4c8 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/plugin-dialog/README.md @@ -0,0 +1,107 @@ +![plugin-dialog](https://github.com/tauri-apps/plugins-workspace/raw/v2/plugins/dialog/banner.png) + +Native system dialogs for opening and saving files along with message dialogs. + +| Platform | Supported | +| -------- | --------- | +| Linux | ✓ | +| Windows | ✓ | +| macOS | ✓ | +| Android | ✓ | +| iOS | ✓ | + +## Install + +_This plugin requires a Rust version of at least **1.77.2**_ + +There are three general methods of installation that we can recommend. + +1. Use crates.io and npm (easiest, and requires you to trust that our publishing pipeline worked) +2. Pull sources directly from Github using git tags / revision hashes (most secure) +3. Git submodule install this repo in your tauri project and then use file protocol to ingest the source (most secure, but inconvenient to use) + +Install the Core plugin by adding the following to your `Cargo.toml` file: + +`src-tauri/Cargo.toml` + +```toml +[dependencies] +tauri-plugin-dialog = "2.0.0" +# alternatively with Git: +tauri-plugin-dialog = { git = "https://github.com/tauri-apps/plugins-workspace", branch = "v2" } +``` + +### Linux XDG Desktop Portal Support + +By default, this plugin uses gtk to show dialogs, however since `v2.5.0` you can switch to using [XDG Desktop Portal](https://flatpak.github.io/xdg-desktop-portal/) by adding the following to your `Cargo.toml` file: + +```toml +[dependencies] +tauri-plugin-dialog = { version = "2.5.0", default-features = false, features = ["xdg-portal"] } +# alternatively with Git: +tauri-plugin-dialog = { git = "https://github.com/tauri-apps/plugins-workspace", branch = "v2", default-features = false, features = ["xdg-portal"] } + +``` + +Do note if you use the `xdg-portal` feature, you need to ensure that [`zenity`](https://gitlab.gnome.org/GNOME/zenity) and an [XDG Desktop Portal backend](https://flatpak.github.io/xdg-desktop-portal#using-portals) is installed with your program. + +For more information, see [XDG Desktop Portal documentation](https://flatpak.github.io/xdg-desktop-portal/) and [`rfd` documentation](https://docs.rs/rfd/latest/rfd#xdg-desktop-portal-backend). + +### JavaScript + +You can install the JavaScript Guest bindings using your preferred JavaScript package manager: + +```sh +pnpm add @tauri-apps/plugin-dialog +# or +npm add @tauri-apps/plugin-dialog +# or +yarn add @tauri-apps/plugin-dialog +``` + +## Usage + +First you need to register the core plugin with Tauri: + +`src-tauri/src/lib.rs` + +```rust +fn main() { + tauri::Builder::default() + .plugin(tauri_plugin_dialog::init()) + .run(tauri::generate_context!()) + .expect("error while running tauri application"); +} +``` + +Afterwards all the plugin's APIs are available through the JavaScript guest bindings: + +```javascript + +``` + +## Contributing + +PRs accepted. Please make sure to read the Contributing Guide before making a pull request. + +## Partners + + + + + + + +
+ + CrabNebula + +
+ +For the complete list of sponsors please visit our [website](https://tauri.app#sponsors) and [Open Collective](https://opencollective.com/tauri). + +## License + +Code: (c) 2015 - Present - The Tauri Programme within The Commons Conservancy. + +MIT or MIT/Apache 2.0 where applicable. diff --git a/scripts/node_modules/@tauri-apps/plugin-dialog/dist-js/index.cjs b/scripts/node_modules/@tauri-apps/plugin-dialog/dist-js/index.cjs new file mode 100644 index 0000000000000000000000000000000000000000..ac35dc05b04d9e63751a6756608ca0402bdb67ff --- /dev/null +++ b/scripts/node_modules/@tauri-apps/plugin-dialog/dist-js/index.cjs @@ -0,0 +1,218 @@ +'use strict'; + +var core = require('@tauri-apps/api/core'); + +// Copyright 2019-2023 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * Internal function to convert the buttons to the Rust type. + */ +function buttonsToRust(buttons) { + if (buttons === undefined) { + return undefined; + } + if (typeof buttons === 'string') { + return buttons; + } + else if ('ok' in buttons && 'cancel' in buttons) { + return { OkCancelCustom: [buttons.ok, buttons.cancel] }; + } + else if ('yes' in buttons && 'no' in buttons && 'cancel' in buttons) { + return { + YesNoCancelCustom: [buttons.yes, buttons.no, buttons.cancel] + }; + } + else if ('ok' in buttons) { + return { OkCustom: buttons.ok }; + } + return undefined; +} +/** + * Open a file/directory selection dialog. + * + * The selected paths are added to the filesystem and asset protocol scopes. + * When security is more important than the easy of use of this API, + * prefer writing a dedicated command instead. + * + * Note that the scope change is not persisted, so the values are cleared when the application is restarted. + * You can save it to the filesystem using [tauri-plugin-persisted-scope](https://github.com/tauri-apps/tauri-plugin-persisted-scope). + * @example + * ```typescript + * import { open } from '@tauri-apps/plugin-dialog'; + * // Open a selection dialog for image files + * const selected = await open({ + * multiple: true, + * filters: [{ + * name: 'Image', + * extensions: ['png', 'jpeg'] + * }] + * }); + * if (Array.isArray(selected)) { + * // user selected multiple files + * } else if (selected === null) { + * // user cancelled the selection + * } else { + * // user selected a single file + * } + * ``` + * + * @example + * ```typescript + * import { open } from '@tauri-apps/plugin-dialog'; + * import { appDir } from '@tauri-apps/api/path'; + * // Open a selection dialog for directories + * const selected = await open({ + * directory: true, + * multiple: true, + * defaultPath: await appDir(), + * }); + * if (Array.isArray(selected)) { + * // user selected multiple directories + * } else if (selected === null) { + * // user cancelled the selection + * } else { + * // user selected a single directory + * } + * ``` + * + * @returns A promise resolving to the selected path(s) + * + * @since 2.0.0 + */ +async function open(options = {}) { + if (typeof options === 'object') { + Object.freeze(options); + } + return await core.invoke('plugin:dialog|open', { options }); +} +/** + * Open a file/directory save dialog. + * + * The selected path is added to the filesystem and asset protocol scopes. + * When security is more important than the easy of use of this API, + * prefer writing a dedicated command instead. + * + * Note that the scope change is not persisted, so the values are cleared when the application is restarted. + * You can save it to the filesystem using [tauri-plugin-persisted-scope](https://github.com/tauri-apps/tauri-plugin-persisted-scope). + * @example + * ```typescript + * import { save } from '@tauri-apps/plugin-dialog'; + * const filePath = await save({ + * filters: [{ + * name: 'Image', + * extensions: ['png', 'jpeg'] + * }] + * }); + * ``` + * + * @returns A promise resolving to the selected path. + * + * @since 2.0.0 + */ +async function save(options = {}) { + if (typeof options === 'object') { + Object.freeze(options); + } + return await core.invoke('plugin:dialog|save', { options }); +} +async function messageCommand(message, options) { + return await core.invoke('plugin:dialog|message', { + message, + title: options?.title, + kind: options?.kind, + buttons: buttonsToRust(options?.buttons) + }); +} +/** + * Shows a message dialog with an `Ok` button. + * @example + * ```typescript + * import { message } from '@tauri-apps/plugin-dialog'; + * await message('Tauri is awesome', 'Tauri'); + * await message('File not found', { title: 'Tauri', kind: 'error' }); + * ``` + * + * @param message The message to show. + * @param options The dialog's options. If a string, it represents the dialog title. + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.0.0 + * + */ +async function message(message, options) { + const opts = typeof options === 'string' ? { title: options } : options; + if (opts && !opts.buttons && opts.okLabel) { + opts.buttons = { ok: opts.okLabel }; + } + return messageCommand(message, opts); +} +/** + * Shows a question dialog with `Yes` and `No` buttons. + * + * Convenient wrapper for `await message('msg', { buttons: 'YesNo' }) === 'Yes'` + * + * @example + * ```typescript + * import { ask } from '@tauri-apps/plugin-dialog'; + * const yes = await ask('Are you sure?', 'Tauri'); + * const yes2 = await ask('This action cannot be reverted. Are you sure?', { title: 'Tauri', kind: 'warning' }); + * ``` + * + * @param message The message to show. + * @param options The dialog's options. If a string, it represents the dialog title. + * + * @returns A promise resolving to a boolean indicating whether `Yes` was clicked or not. + * + * @since 2.0.0 + */ +async function ask(message, options) { + const opts = typeof options === 'string' ? { title: options } : options; + const customButtons = opts?.okLabel || opts?.cancelLabel; + const okLabel = opts?.okLabel ?? 'Yes'; + return ((await messageCommand(message, { + title: opts?.title, + kind: opts?.kind, + buttons: customButtons + ? { ok: okLabel, cancel: opts.cancelLabel ?? 'No' } + : 'YesNo' + })) === okLabel); +} +/** + * Shows a question dialog with `Ok` and `Cancel` buttons. + * + * Convenient wrapper for `await message('msg', { buttons: 'OkCancel' }) === 'Ok'` + * + * @example + * ```typescript + * import { confirm } from '@tauri-apps/plugin-dialog'; + * const confirmed = await confirm('Are you sure?', 'Tauri'); + * const confirmed2 = await confirm('This action cannot be reverted. Are you sure?', { title: 'Tauri', kind: 'warning' }); + * ``` + * + * @param message The message to show. + * @param options The dialog's options. If a string, it represents the dialog title. + * + * @returns A promise resolving to a boolean indicating whether `Ok` was clicked or not. + * + * @since 2.0.0 + */ +async function confirm(message, options) { + const opts = typeof options === 'string' ? { title: options } : options; + const customButtons = opts?.okLabel || opts?.cancelLabel; + const okLabel = opts?.okLabel ?? 'Ok'; + return ((await messageCommand(message, { + title: opts?.title, + kind: opts?.kind, + buttons: customButtons + ? { ok: okLabel, cancel: opts.cancelLabel ?? 'Cancel' } + : 'OkCancel' + })) === okLabel); +} + +exports.ask = ask; +exports.confirm = confirm; +exports.message = message; +exports.open = open; +exports.save = save; diff --git a/scripts/node_modules/@tauri-apps/plugin-dialog/dist-js/index.d.ts b/scripts/node_modules/@tauri-apps/plugin-dialog/dist-js/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e2e559d188bbb42162976343e24e387b465d0acb --- /dev/null +++ b/scripts/node_modules/@tauri-apps/plugin-dialog/dist-js/index.d.ts @@ -0,0 +1,388 @@ +/** + * Extension filters for the file dialog. + * + * @since 2.0.0 + */ +interface DialogFilter { + /** Filter name. */ + name: string; + /** + * Extensions to filter, without a `.` prefix. + * + * **Note:** Mobile platforms have different APIs for filtering that may not support extensions. + * iOS: Extensions are supported in the document picker, but not in the media picker. + * Android: Extensions are not supported. + * + * For these platforms, MIME types are the primary way to filter files, as opposed to extensions. + * This means the string values here labeled as `extensions` may also be a MIME type. + * This property name of `extensions` is being kept for backwards compatibility, but this may be revisited to + * specify the difference between extension or MIME type filtering. + * + * @example + * ```typescript + * extensions: ['svg', 'png'] + * ``` + */ + extensions: string[]; +} +/** + * Options for the open dialog. + * + * @since 2.0.0 + */ +interface OpenDialogOptions { + /** The title of the dialog window (desktop only). */ + title?: string; + /** + * The filters of the dialog. + * On mobile platforms, if either: + * A) the {@linkcode pickerMode} is set to `media`, `image`, or `video` + * -- or -- + * B) the filters include **only** either image or video mime types, the media picker will be displayed. + * Otherwise, the document picker will be displayed. + */ + filters?: DialogFilter[]; + /** + * Initial directory or file path. + * If it's a directory path, the dialog interface will change to that folder. + * If it's not an existing directory, the file name will be set to the dialog's file name input and the dialog will be set to the parent folder. + * + * On mobile the file name is always used on the dialog's file name input. + * If not provided, Android uses `(invalid).txt` as default file name. + */ + defaultPath?: string; + /** Whether the dialog allows multiple selection or not. */ + multiple?: boolean; + /** Whether the dialog is a directory selection or not. */ + directory?: boolean; + /** + * If `directory` is true, indicates that it will be read recursively later. + * Defines whether subdirectories will be allowed on the scope or not. + */ + recursive?: boolean; + /** Whether to allow creating directories in the dialog. Enabled by default. **macOS Only** */ + canCreateDirectories?: boolean; + /** + * The preferred mode of the dialog. + * This is meant for mobile platforms (iOS and Android) which have distinct file and media pickers. + * If not provided, the dialog will automatically choose the best mode based on the MIME types or extensions of the {@linkcode filters}. + * On desktop, this option is ignored. + */ + pickerMode?: PickerMode; + /** + * The file access mode of the dialog. + * If not provided, `copy` is used, which matches the behavior of the {@linkcode open} method before the introduction of this option. + * + * **Usage** + * If a file is opened with {@linkcode fileAccessMode: 'copy'}, it will be copied to the app's sandbox. + * This means the file can be read, edited, deleted, copied, or any other operation without any issues, since the file + * now belongs to the app. + * This also means that the caller has responsibility of deleting the file if this file is not meant to be retained + * in the app sandbox. + * + * If a file is opened with {@linkcode fileAccessMode: 'scoped'}, the file will remain in its original location + * and security-scoped access will be automatically managed by the system. + * + * **Note** + * This is specifically meant for document pickers on iOS or MacOS, in conjunction with [security scoped resources](https://developer.apple.com/documentation/foundation/nsurl/startaccessingsecurityscopedresource()). + * + * Why only document pickers, and not image or video pickers? + * The image and video pickers on iOS behave differently from the document pickers, and return [NSItemProvider](https://developer.apple.com/documentation/foundation/nsitemprovider) objects instead of file URLs. + * These are meant to be ephemeral (only available within the callback of the picker), and are not accessible outside of the callback. + * So for image and video pickers, the only way to access the file is to copy it to the app's sandbox, and this is the URL that is returned from this API. + * This means there is no provision for using `scoped` mode with image or video pickers. + * If an image or video picker is used, `copy` is always used. + */ + fileAccessMode?: FileAccessMode; +} +/** + * Options for the save dialog. + * + * @since 2.0.0 + */ +interface SaveDialogOptions { + /** The title of the dialog window (desktop only). */ + title?: string; + /** The filters of the dialog. */ + filters?: DialogFilter[]; + /** + * Initial directory or file path. + * If it's a directory path, the dialog interface will change to that folder. + * If it's not an existing directory, the file name will be set to the dialog's file name input and the dialog will be set to the parent folder. + * + * On mobile the file name is always used on the dialog's file name input. + * If not provided, Android uses `(invalid).txt` as default file name. + */ + defaultPath?: string; + /** Whether to allow creating directories in the dialog. Enabled by default. **macOS Only** */ + canCreateDirectories?: boolean; +} +/** + * The preferred mode of the dialog. + * This is meant for mobile platforms (iOS and Android) which have distinct file and media pickers. + * On desktop, this option is ignored. + * If not provided, the dialog will automatically choose the best mode based on the MIME types or extensions of the {@linkcode filters}. + * + * **Note:** This option is only supported on iOS 14 and above. This parameter is ignored on iOS 13 and below. + */ +export type PickerMode = 'document' | 'media' | 'image' | 'video'; +/** + * The file access mode of the dialog. + * + * - `copy`: copy/move the picked file to the app sandbox; no scoped access required. + * - `scoped`: keep file in place; security-scoped access is automatically managed. + * + * **Note:** This option is only supported on iOS 14 and above. This parameter is ignored on iOS 13 and below. + */ +export type FileAccessMode = 'copy' | 'scoped'; +/** + * Default buttons for a message dialog. + * + * @since 2.4.0 + */ +export type MessageDialogDefaultButtons = 'Ok' | 'OkCancel' | 'YesNo' | 'YesNoCancel'; +/** All possible button keys. */ +type ButtonKey = 'ok' | 'cancel' | 'yes' | 'no'; +/** Ban everything except a set of keys. */ +type BanExcept = Partial, never>>; +/** + * The Yes, No and Cancel buttons of a message dialog. + * + * @since 2.4.0 + */ +export type MessageDialogButtonsYesNoCancel = { + /** The Yes button. */ + yes: string; + /** The No button. */ + no: string; + /** The Cancel button. */ + cancel: string; +} & BanExcept<'yes' | 'no' | 'cancel'>; +/** + * The Ok and Cancel buttons of a message dialog. + * + * @since 2.4.0 + */ +export type MessageDialogButtonsOkCancel = { + /** The Ok button. */ + ok: string; + /** The Cancel button. */ + cancel: string; +} & BanExcept<'ok' | 'cancel'>; +/** + * The Ok button of a message dialog. + * + * @since 2.4.0 + */ +export type MessageDialogButtonsOk = { + /** The Ok button. */ + ok: string; +} & BanExcept<'ok'>; +/** + * Custom buttons for a message dialog. + * + * @since 2.4.0 + */ +export type MessageDialogCustomButtons = MessageDialogButtonsYesNoCancel | MessageDialogButtonsOkCancel | MessageDialogButtonsOk; +/** + * The buttons of a message dialog. + * + * @since 2.4.0 + */ +export type MessageDialogButtons = MessageDialogDefaultButtons | MessageDialogCustomButtons; +/** + * @since 2.0.0 + */ +interface MessageDialogOptions { + /** The title of the dialog. Defaults to the app name. */ + title?: string; + /** The kind of the dialog. Defaults to `info`. */ + kind?: 'info' | 'warning' | 'error'; + /** + * The label of the Ok button. + * + * @deprecated Use {@linkcode MessageDialogOptions.buttons} instead. + */ + okLabel?: string; + /** + * The buttons of the dialog. + * + * @example + * + * ```ts + * // Use system default buttons texts + * await message('Hello World!', { buttons: 'Ok' }) + * await message('Hello World!', { buttons: 'OkCancel' }) + * + * // Or with custom button texts + * await message('Hello World!', { buttons: { ok: 'Yes!' } }) + * await message('Take on the task?', { + * buttons: { ok: 'Accept', cancel: 'Cancel' } + * }) + * await message('Show the file content?', { + * buttons: { yes: 'Show content', no: 'Show in folder', cancel: 'Cancel' } + * }) + * ``` + * + * @since 2.4.0 + */ + buttons?: MessageDialogButtons; +} +interface ConfirmDialogOptions { + /** The title of the dialog. Defaults to the app name. */ + title?: string; + /** The kind of the dialog. Defaults to `info`. */ + kind?: 'info' | 'warning' | 'error'; + /** The label of the confirm button. */ + okLabel?: string; + /** The label of the cancel button. */ + cancelLabel?: string; +} +type OpenDialogReturn = T['directory'] extends true ? T['multiple'] extends true ? string[] | null : string | null : T['multiple'] extends true ? string[] | null : string | null; +/** + * Open a file/directory selection dialog. + * + * The selected paths are added to the filesystem and asset protocol scopes. + * When security is more important than the easy of use of this API, + * prefer writing a dedicated command instead. + * + * Note that the scope change is not persisted, so the values are cleared when the application is restarted. + * You can save it to the filesystem using [tauri-plugin-persisted-scope](https://github.com/tauri-apps/tauri-plugin-persisted-scope). + * @example + * ```typescript + * import { open } from '@tauri-apps/plugin-dialog'; + * // Open a selection dialog for image files + * const selected = await open({ + * multiple: true, + * filters: [{ + * name: 'Image', + * extensions: ['png', 'jpeg'] + * }] + * }); + * if (Array.isArray(selected)) { + * // user selected multiple files + * } else if (selected === null) { + * // user cancelled the selection + * } else { + * // user selected a single file + * } + * ``` + * + * @example + * ```typescript + * import { open } from '@tauri-apps/plugin-dialog'; + * import { appDir } from '@tauri-apps/api/path'; + * // Open a selection dialog for directories + * const selected = await open({ + * directory: true, + * multiple: true, + * defaultPath: await appDir(), + * }); + * if (Array.isArray(selected)) { + * // user selected multiple directories + * } else if (selected === null) { + * // user cancelled the selection + * } else { + * // user selected a single directory + * } + * ``` + * + * @returns A promise resolving to the selected path(s) + * + * @since 2.0.0 + */ +declare function open(options?: T): Promise>; +/** + * Open a file/directory save dialog. + * + * The selected path is added to the filesystem and asset protocol scopes. + * When security is more important than the easy of use of this API, + * prefer writing a dedicated command instead. + * + * Note that the scope change is not persisted, so the values are cleared when the application is restarted. + * You can save it to the filesystem using [tauri-plugin-persisted-scope](https://github.com/tauri-apps/tauri-plugin-persisted-scope). + * @example + * ```typescript + * import { save } from '@tauri-apps/plugin-dialog'; + * const filePath = await save({ + * filters: [{ + * name: 'Image', + * extensions: ['png', 'jpeg'] + * }] + * }); + * ``` + * + * @returns A promise resolving to the selected path. + * + * @since 2.0.0 + */ +declare function save(options?: SaveDialogOptions): Promise; +/** + * The result of a message dialog. + * + * The result is a string if the dialog has custom buttons, + * otherwise it is one of the default buttons. + * + * @since 2.4.0 + */ +export type MessageDialogResult = 'Yes' | 'No' | 'Ok' | 'Cancel' | (string & {}); +/** + * Shows a message dialog with an `Ok` button. + * @example + * ```typescript + * import { message } from '@tauri-apps/plugin-dialog'; + * await message('Tauri is awesome', 'Tauri'); + * await message('File not found', { title: 'Tauri', kind: 'error' }); + * ``` + * + * @param message The message to show. + * @param options The dialog's options. If a string, it represents the dialog title. + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.0.0 + * + */ +declare function message(message: string, options?: string | MessageDialogOptions): Promise; +/** + * Shows a question dialog with `Yes` and `No` buttons. + * + * Convenient wrapper for `await message('msg', { buttons: 'YesNo' }) === 'Yes'` + * + * @example + * ```typescript + * import { ask } from '@tauri-apps/plugin-dialog'; + * const yes = await ask('Are you sure?', 'Tauri'); + * const yes2 = await ask('This action cannot be reverted. Are you sure?', { title: 'Tauri', kind: 'warning' }); + * ``` + * + * @param message The message to show. + * @param options The dialog's options. If a string, it represents the dialog title. + * + * @returns A promise resolving to a boolean indicating whether `Yes` was clicked or not. + * + * @since 2.0.0 + */ +declare function ask(message: string, options?: string | ConfirmDialogOptions): Promise; +/** + * Shows a question dialog with `Ok` and `Cancel` buttons. + * + * Convenient wrapper for `await message('msg', { buttons: 'OkCancel' }) === 'Ok'` + * + * @example + * ```typescript + * import { confirm } from '@tauri-apps/plugin-dialog'; + * const confirmed = await confirm('Are you sure?', 'Tauri'); + * const confirmed2 = await confirm('This action cannot be reverted. Are you sure?', { title: 'Tauri', kind: 'warning' }); + * ``` + * + * @param message The message to show. + * @param options The dialog's options. If a string, it represents the dialog title. + * + * @returns A promise resolving to a boolean indicating whether `Ok` was clicked or not. + * + * @since 2.0.0 + */ +declare function confirm(message: string, options?: string | ConfirmDialogOptions): Promise; +export type { DialogFilter, OpenDialogOptions, OpenDialogReturn, SaveDialogOptions, MessageDialogOptions, ConfirmDialogOptions }; +export { open, save, message, ask, confirm }; diff --git a/scripts/node_modules/@tauri-apps/plugin-dialog/dist-js/index.js b/scripts/node_modules/@tauri-apps/plugin-dialog/dist-js/index.js new file mode 100644 index 0000000000000000000000000000000000000000..b0cae11fef41e8a243f4ed5250657fc3da5ecdca --- /dev/null +++ b/scripts/node_modules/@tauri-apps/plugin-dialog/dist-js/index.js @@ -0,0 +1,212 @@ +import { invoke } from '@tauri-apps/api/core'; + +// Copyright 2019-2023 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * Internal function to convert the buttons to the Rust type. + */ +function buttonsToRust(buttons) { + if (buttons === undefined) { + return undefined; + } + if (typeof buttons === 'string') { + return buttons; + } + else if ('ok' in buttons && 'cancel' in buttons) { + return { OkCancelCustom: [buttons.ok, buttons.cancel] }; + } + else if ('yes' in buttons && 'no' in buttons && 'cancel' in buttons) { + return { + YesNoCancelCustom: [buttons.yes, buttons.no, buttons.cancel] + }; + } + else if ('ok' in buttons) { + return { OkCustom: buttons.ok }; + } + return undefined; +} +/** + * Open a file/directory selection dialog. + * + * The selected paths are added to the filesystem and asset protocol scopes. + * When security is more important than the easy of use of this API, + * prefer writing a dedicated command instead. + * + * Note that the scope change is not persisted, so the values are cleared when the application is restarted. + * You can save it to the filesystem using [tauri-plugin-persisted-scope](https://github.com/tauri-apps/tauri-plugin-persisted-scope). + * @example + * ```typescript + * import { open } from '@tauri-apps/plugin-dialog'; + * // Open a selection dialog for image files + * const selected = await open({ + * multiple: true, + * filters: [{ + * name: 'Image', + * extensions: ['png', 'jpeg'] + * }] + * }); + * if (Array.isArray(selected)) { + * // user selected multiple files + * } else if (selected === null) { + * // user cancelled the selection + * } else { + * // user selected a single file + * } + * ``` + * + * @example + * ```typescript + * import { open } from '@tauri-apps/plugin-dialog'; + * import { appDir } from '@tauri-apps/api/path'; + * // Open a selection dialog for directories + * const selected = await open({ + * directory: true, + * multiple: true, + * defaultPath: await appDir(), + * }); + * if (Array.isArray(selected)) { + * // user selected multiple directories + * } else if (selected === null) { + * // user cancelled the selection + * } else { + * // user selected a single directory + * } + * ``` + * + * @returns A promise resolving to the selected path(s) + * + * @since 2.0.0 + */ +async function open(options = {}) { + if (typeof options === 'object') { + Object.freeze(options); + } + return await invoke('plugin:dialog|open', { options }); +} +/** + * Open a file/directory save dialog. + * + * The selected path is added to the filesystem and asset protocol scopes. + * When security is more important than the easy of use of this API, + * prefer writing a dedicated command instead. + * + * Note that the scope change is not persisted, so the values are cleared when the application is restarted. + * You can save it to the filesystem using [tauri-plugin-persisted-scope](https://github.com/tauri-apps/tauri-plugin-persisted-scope). + * @example + * ```typescript + * import { save } from '@tauri-apps/plugin-dialog'; + * const filePath = await save({ + * filters: [{ + * name: 'Image', + * extensions: ['png', 'jpeg'] + * }] + * }); + * ``` + * + * @returns A promise resolving to the selected path. + * + * @since 2.0.0 + */ +async function save(options = {}) { + if (typeof options === 'object') { + Object.freeze(options); + } + return await invoke('plugin:dialog|save', { options }); +} +async function messageCommand(message, options) { + return await invoke('plugin:dialog|message', { + message, + title: options?.title, + kind: options?.kind, + buttons: buttonsToRust(options?.buttons) + }); +} +/** + * Shows a message dialog with an `Ok` button. + * @example + * ```typescript + * import { message } from '@tauri-apps/plugin-dialog'; + * await message('Tauri is awesome', 'Tauri'); + * await message('File not found', { title: 'Tauri', kind: 'error' }); + * ``` + * + * @param message The message to show. + * @param options The dialog's options. If a string, it represents the dialog title. + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.0.0 + * + */ +async function message(message, options) { + const opts = typeof options === 'string' ? { title: options } : options; + if (opts && !opts.buttons && opts.okLabel) { + opts.buttons = { ok: opts.okLabel }; + } + return messageCommand(message, opts); +} +/** + * Shows a question dialog with `Yes` and `No` buttons. + * + * Convenient wrapper for `await message('msg', { buttons: 'YesNo' }) === 'Yes'` + * + * @example + * ```typescript + * import { ask } from '@tauri-apps/plugin-dialog'; + * const yes = await ask('Are you sure?', 'Tauri'); + * const yes2 = await ask('This action cannot be reverted. Are you sure?', { title: 'Tauri', kind: 'warning' }); + * ``` + * + * @param message The message to show. + * @param options The dialog's options. If a string, it represents the dialog title. + * + * @returns A promise resolving to a boolean indicating whether `Yes` was clicked or not. + * + * @since 2.0.0 + */ +async function ask(message, options) { + const opts = typeof options === 'string' ? { title: options } : options; + const customButtons = opts?.okLabel || opts?.cancelLabel; + const okLabel = opts?.okLabel ?? 'Yes'; + return ((await messageCommand(message, { + title: opts?.title, + kind: opts?.kind, + buttons: customButtons + ? { ok: okLabel, cancel: opts.cancelLabel ?? 'No' } + : 'YesNo' + })) === okLabel); +} +/** + * Shows a question dialog with `Ok` and `Cancel` buttons. + * + * Convenient wrapper for `await message('msg', { buttons: 'OkCancel' }) === 'Ok'` + * + * @example + * ```typescript + * import { confirm } from '@tauri-apps/plugin-dialog'; + * const confirmed = await confirm('Are you sure?', 'Tauri'); + * const confirmed2 = await confirm('This action cannot be reverted. Are you sure?', { title: 'Tauri', kind: 'warning' }); + * ``` + * + * @param message The message to show. + * @param options The dialog's options. If a string, it represents the dialog title. + * + * @returns A promise resolving to a boolean indicating whether `Ok` was clicked or not. + * + * @since 2.0.0 + */ +async function confirm(message, options) { + const opts = typeof options === 'string' ? { title: options } : options; + const customButtons = opts?.okLabel || opts?.cancelLabel; + const okLabel = opts?.okLabel ?? 'Ok'; + return ((await messageCommand(message, { + title: opts?.title, + kind: opts?.kind, + buttons: customButtons + ? { ok: okLabel, cancel: opts.cancelLabel ?? 'Cancel' } + : 'OkCancel' + })) === okLabel); +} + +export { ask, confirm, message, open, save }; diff --git a/scripts/node_modules/@tauri-apps/plugin-dialog/dist-js/init.d.ts b/scripts/node_modules/@tauri-apps/plugin-dialog/dist-js/init.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..cb0ff5c3b541f646105198ee23ac0fc3d805023e --- /dev/null +++ b/scripts/node_modules/@tauri-apps/plugin-dialog/dist-js/init.d.ts @@ -0,0 +1 @@ +export {}; diff --git a/scripts/node_modules/@tauri-apps/plugin-dialog/package.json b/scripts/node_modules/@tauri-apps/plugin-dialog/package.json new file mode 100644 index 0000000000000000000000000000000000000000..8d3dad4479318fbfa1d00552961d5f2423094135 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/plugin-dialog/package.json @@ -0,0 +1,29 @@ +{ + "name": "@tauri-apps/plugin-dialog", + "version": "2.7.0", + "license": "MIT OR Apache-2.0", + "authors": [ + "Tauri Programme within The Commons Conservancy" + ], + "repository": "https://github.com/tauri-apps/plugins-workspace", + "type": "module", + "types": "./dist-js/index.d.ts", + "main": "./dist-js/index.cjs", + "module": "./dist-js/index.js", + "exports": { + "types": "./dist-js/index.d.ts", + "import": "./dist-js/index.js", + "require": "./dist-js/index.cjs" + }, + "scripts": { + "build": "rollup -c" + }, + "files": [ + "dist-js", + "README.md", + "LICENSE" + ], + "dependencies": { + "@tauri-apps/api": "^2.10.1" + } +} diff --git a/scripts/node_modules/@tauri-apps/plugin-fs/LICENSE.spdx b/scripts/node_modules/@tauri-apps/plugin-fs/LICENSE.spdx new file mode 100644 index 0000000000000000000000000000000000000000..cdd0df5ad76e63d23a80834469609c1d8109ff2e --- /dev/null +++ b/scripts/node_modules/@tauri-apps/plugin-fs/LICENSE.spdx @@ -0,0 +1,20 @@ +SPDXVersion: SPDX-2.1 +DataLicense: CC0-1.0 +PackageName: tauri +DataFormat: SPDXRef-1 +PackageSupplier: Organization: The Tauri Programme in the Commons Conservancy +PackageHomePage: https://tauri.app +PackageLicenseDeclared: Apache-2.0 +PackageLicenseDeclared: MIT +PackageCopyrightText: 2019-2022, The Tauri Programme in the Commons Conservancy +PackageSummary: Tauri is a rust project that enables developers to make secure +and small desktop applications using a web frontend. + +PackageComment: The package includes the following libraries; see +Relationship information. + +Created: 2019-05-20T09:00:00Z +PackageDownloadLocation: git://github.com/tauri-apps/tauri +PackageDownloadLocation: git+https://github.com/tauri-apps/tauri.git +PackageDownloadLocation: git+ssh://github.com/tauri-apps/tauri.git +Creator: Person: Daniel Thompson-Yvetot \ No newline at end of file diff --git a/scripts/node_modules/@tauri-apps/plugin-fs/README.md b/scripts/node_modules/@tauri-apps/plugin-fs/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d02c71d59322c0248ce45169bb9bf54ef52127f9 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/plugin-fs/README.md @@ -0,0 +1,91 @@ +![plugin-fs](https://github.com/tauri-apps/plugins-workspace/raw/v2/plugins/fs/banner.png) + +Access the file system. + +| Platform | Supported | +| -------- | --------- | +| Linux | ✓ | +| Windows | ✓ | +| macOS | ✓ | +| Android | ✓ | +| iOS | ✓ | + +## Install + +_This plugin requires a Rust version of at least **1.77.2**_ + +There are three general methods of installation that we can recommend. + +1. Use crates.io and npm (easiest, and requires you to trust that our publishing pipeline worked) +2. Pull sources directly from Github using git tags / revision hashes (most secure) +3. Git submodule install this repo in your tauri project and then use file protocol to ingest the source (most secure, but inconvenient to use) + +Install the Core plugin by adding the following to your `Cargo.toml` file: + +`src-tauri/Cargo.toml` + +```toml +[dependencies] +tauri-plugin-fs = "2.0.0" +# alternatively with Git: +tauri-plugin-fs = { git = "https://github.com/tauri-apps/plugins-workspace", branch = "v2" } +``` + +You can install the JavaScript Guest bindings using your preferred JavaScript package manager: + +```sh +pnpm add @tauri-apps/plugin-fs +# or +npm add @tauri-apps/plugin-fs +# or +yarn add @tauri-apps/plugin-fs +``` + +## Usage + +First you need to register the core plugin with Tauri: + +`src-tauri/src/lib.rs` + +```rust +fn main() { + tauri::Builder::default() + .plugin(tauri_plugin_fs::init()) + .run(tauri::generate_context!()) + .expect("error while running tauri application"); +} +``` + +Afterwards all the plugin's APIs are available through the JavaScript guest bindings: + +```javascript +import { stat } from '@tauri-apps/plugin-fs' + +await stat('/path/to/file') +``` + +## Contributing + +PRs accepted. Please make sure to read the Contributing Guide before making a pull request. + +## Partners + + + + + + + +
+ + CrabNebula + +
+ +For the complete list of sponsors please visit our [website](https://tauri.app#sponsors) and [Open Collective](https://opencollective.com/tauri). + +## License + +Code: (c) 2015 - Present - The Tauri Programme within The Commons Conservancy. + +MIT or MIT/Apache 2.0 where applicable. diff --git a/scripts/node_modules/@tauri-apps/plugin-fs/dist-js/index.cjs b/scripts/node_modules/@tauri-apps/plugin-fs/dist-js/index.cjs new file mode 100644 index 0000000000000000000000000000000000000000..f2a32be66f6d5194669173b1efb106cf22aa0167 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/plugin-fs/dist-js/index.cjs @@ -0,0 +1,891 @@ +'use strict'; + +var path = require('@tauri-apps/api/path'); +var core = require('@tauri-apps/api/core'); + +// Copyright 2019-2023 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * Access the file system. + * + * ## iOS security-scoped resources + * + * On iOS, the `fs` plugin automatically manages access to security-scoped resources when a file URL is accessed. + * This is required for files outside the app's sandbox (e.g., from file picker). + * + * @example + * ```typescript + * import { open } from '@tauri-apps/plugin-fs'; + * + * const file = await open('file:///path/to/file.txt'); + * await file.close(); + * ``` + * + * ## Security + * + * This module prevents path traversal, not allowing parent directory accessors to be used + * (i.e. "/usr/path/to/../file" or "../path/to/file" paths are not allowed). + * Paths accessed with this API must be either relative to one of the {@link BaseDirectory | base directories} + * or created with the {@link https://v2.tauri.app/reference/javascript/api/namespacepath/ | path API}. + * + * The API has a scope configuration that forces you to restrict the paths that can be accessed using glob patterns. + * + * The scope configuration is an array of glob patterns describing file/directory paths that are allowed. + * For instance, this scope configuration allows **all** enabled `fs` APIs to (only) access files in the + * *databases* directory of the {@link https://v2.tauri.app/reference/javascript/api/namespacepath/#appdatadir | `$APPDATA` directory}: + * ```json + * { + * "permissions": [ + * { + * "identifier": "fs:scope", + * "allow": [{ "path": "$APPDATA/databases/*" }] + * } + * ] + * } + * ``` + * + * Scopes can also be applied to specific `fs` APIs by using the API's identifier instead of `fs:scope`: + * ```json + * { + * "permissions": [ + * { + * "identifier": "fs:allow-exists", + * "allow": [{ "path": "$APPDATA/databases/*" }] + * } + * ] + * } + * ``` + * + * Notice the use of the `$APPDATA` variable. The value is injected at runtime, resolving to the {@link https://v2.tauri.app/reference/javascript/api/namespacepath/#appdatadir | app data directory}. + * + * The available variables are: + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#appconfigdir | $APPCONFIG}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#appdatadir | $APPDATA}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#applocaldatadir | $APPLOCALDATA}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#appcachedir | $APPCACHE}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#applogdir | $APPLOG}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#audiodir | $AUDIO}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#cachedir | $CACHE}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#configdir | $CONFIG}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#datadir | $DATA}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#localdatadir | $LOCALDATA}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#desktopdir | $DESKTOP}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#documentdir | $DOCUMENT}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#downloaddir | $DOWNLOAD}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#executabledir | $EXE}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#fontdir | $FONT}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#homedir | $HOME}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#picturedir | $PICTURE}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#publicdir | $PUBLIC}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#runtimedir | $RUNTIME}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#templatedir | $TEMPLATE}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#videodir | $VIDEO}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#resourcedir | $RESOURCE}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#tempdir | $TEMP}. + * + * Trying to execute any API with a URL not configured on the scope results in a promise rejection due to denied access. + * + * @module + */ +exports.SeekMode = void 0; +(function (SeekMode) { + SeekMode[SeekMode["Start"] = 0] = "Start"; + SeekMode[SeekMode["Current"] = 1] = "Current"; + SeekMode[SeekMode["End"] = 2] = "End"; +})(exports.SeekMode || (exports.SeekMode = {})); +function parseFileInfo(r) { + return { + isFile: r.isFile, + isDirectory: r.isDirectory, + isSymlink: r.isSymlink, + size: r.size, + mtime: r.mtime !== null ? new Date(r.mtime) : null, + atime: r.atime !== null ? new Date(r.atime) : null, + birthtime: r.birthtime !== null ? new Date(r.birthtime) : null, + readonly: r.readonly, + fileAttributes: r.fileAttributes, + dev: r.dev, + ino: r.ino, + mode: r.mode, + nlink: r.nlink, + uid: r.uid, + gid: r.gid, + rdev: r.rdev, + blksize: r.blksize, + blocks: r.blocks + }; +} +// https://gist.github.com/zapthedingbat/38ebfbedd98396624e5b5f2ff462611d +/** Converts a big-endian eight byte array to number */ +function fromBytes(buffer) { + const bytes = new Uint8ClampedArray(buffer); + const size = bytes.byteLength; + let x = 0; + for (let i = 0; i < size; i++) { + // eslint-disable-next-line security/detect-object-injection + const byte = bytes[i]; + x *= 0x100; + x += byte; + } + return x; +} +/** + * The Tauri abstraction for reading and writing files. + * + * @since 2.0.0 + */ +class FileHandle extends core.Resource { + /** + * Reads up to `p.byteLength` bytes into `p`. It resolves to the number of + * bytes read (`0` < `n` <= `p.byteLength`) and rejects if any error + * encountered. Even if `read()` resolves to `n` < `p.byteLength`, it may + * use all of `p` as scratch space during the call. If some data is + * available but not `p.byteLength` bytes, `read()` conventionally resolves + * to what is available instead of waiting for more. + * + * When `read()` encounters end-of-file condition, it resolves to EOF + * (`null`). + * + * When `read()` encounters an error, it rejects with an error. + * + * Callers should always process the `n` > `0` bytes returned before + * considering the EOF (`null`). Doing so correctly handles I/O errors that + * happen after reading some bytes and also both of the allowed EOF + * behaviors. + * + * @example + * ```typescript + * import { open, BaseDirectory } from "@tauri-apps/plugin-fs" + * // if "$APPCONFIG/foo/bar.txt" contains the text "hello world": + * const file = await open("foo/bar.txt", { baseDir: BaseDirectory.AppConfig }); + * const buf = new Uint8Array(100); + * const numberOfBytesRead = await file.read(buf); // 11 bytes + * const text = new TextDecoder().decode(buf); // "hello world" + * await file.close(); + * ``` + * + * @since 2.0.0 + */ + async read(buffer) { + if (buffer.byteLength === 0) { + return 0; + } + const data = await core.invoke('plugin:fs|read', { + rid: this.rid, + len: buffer.byteLength + }); + // Rust side will never return an empty array for this command and + // ensure there is at least 8 elements there. + // + // This is an optimization to include the number of read bytes (as bigendian bytes) + // at the end of returned array to avoid serialization overhead of separate values. + const nread = fromBytes(data.slice(-8)); + const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : data; + buffer.set(bytes.slice(0, bytes.length - 8)); + return nread === 0 ? null : nread; + } + /** + * Seek sets the offset for the next `read()` or `write()` to offset, + * interpreted according to `whence`: `Start` means relative to the + * start of the file, `Current` means relative to the current offset, + * and `End` means relative to the end. Seek resolves to the new offset + * relative to the start of the file. + * + * Seeking to an offset before the start of the file is an error. Seeking to + * any positive offset is legal, but the behavior of subsequent I/O + * operations on the underlying object is implementation-dependent. + * It returns the number of cursor position. + * + * @example + * ```typescript + * import { open, SeekMode, BaseDirectory } from '@tauri-apps/plugin-fs'; + * + * // Given hello.txt pointing to file with "Hello world", which is 11 bytes long: + * const file = await open('hello.txt', { read: true, write: true, truncate: true, create: true, baseDir: BaseDirectory.AppLocalData }); + * await file.write(new TextEncoder().encode("Hello world")); + * + * // Seek 6 bytes from the start of the file + * console.log(await file.seek(6, SeekMode.Start)); // "6" + * // Seek 2 more bytes from the current position + * console.log(await file.seek(2, SeekMode.Current)); // "8" + * // Seek backwards 2 bytes from the end of the file + * console.log(await file.seek(-2, SeekMode.End)); // "9" (e.g. 11-2) + * + * await file.close(); + * ``` + * + * @since 2.0.0 + */ + async seek(offset, whence) { + return await core.invoke('plugin:fs|seek', { + rid: this.rid, + offset, + whence + }); + } + /** + * Returns a {@linkcode FileInfo } for this file. + * + * @example + * ```typescript + * import { open, BaseDirectory } from '@tauri-apps/plugin-fs'; + * const file = await open("file.txt", { read: true, baseDir: BaseDirectory.AppLocalData }); + * const fileInfo = await file.stat(); + * console.log(fileInfo.isFile); // true + * await file.close(); + * ``` + * + * @since 2.0.0 + */ + async stat() { + const res = await core.invoke('plugin:fs|fstat', { + rid: this.rid + }); + return parseFileInfo(res); + } + /** + * Truncates or extends this file, to reach the specified `len`. + * If `len` is not specified then the entire file contents are truncated. + * + * @example + * ```typescript + * import { open, BaseDirectory } from '@tauri-apps/plugin-fs'; + * + * // truncate the entire file + * const file = await open("my_file.txt", { read: true, write: true, create: true, baseDir: BaseDirectory.AppLocalData }); + * await file.truncate(); + * + * // truncate part of the file + * const file = await open("my_file.txt", { read: true, write: true, create: true, baseDir: BaseDirectory.AppLocalData }); + * await file.write(new TextEncoder().encode("Hello World")); + * await file.truncate(7); + * const data = new Uint8Array(32); + * await file.read(data); + * console.log(new TextDecoder().decode(data)); // Hello W + * await file.close(); + * ``` + * + * @since 2.0.0 + */ + async truncate(len) { + await core.invoke('plugin:fs|ftruncate', { + rid: this.rid, + len + }); + } + /** + * Writes `data.byteLength` bytes from `data` to the underlying data stream. It + * resolves to the number of bytes written from `data` (`0` <= `n` <= + * `data.byteLength`) or reject with the error encountered that caused the + * write to stop early. `write()` must reject with a non-null error if + * would resolve to `n` < `data.byteLength`. `write()` must not modify the + * slice data, even temporarily. + * + * @example + * ```typescript + * import { open, write, BaseDirectory } from '@tauri-apps/plugin-fs'; + * const encoder = new TextEncoder(); + * const data = encoder.encode("Hello world"); + * const file = await open("bar.txt", { write: true, baseDir: BaseDirectory.AppLocalData }); + * const bytesWritten = await file.write(data); // 11 + * await file.close(); + * ``` + * + * @since 2.0.0 + */ + async write(data) { + return await core.invoke('plugin:fs|write', { + rid: this.rid, + data + }); + } +} +/** + * Creates a file if none exists or truncates an existing file and resolves to + * an instance of {@linkcode FileHandle }. + * + * @example + * ```typescript + * import { create, BaseDirectory } from "@tauri-apps/plugin-fs" + * const file = await create("foo/bar.txt", { baseDir: BaseDirectory.AppConfig }); + * await file.write(new TextEncoder().encode("Hello world")); + * await file.close(); + * ``` + * + * @since 2.0.0 + */ +async function create(path, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + const rid = await core.invoke('plugin:fs|create', { + path: path instanceof URL ? path.toString() : path, + options + }); + return new FileHandle(rid); +} +/** + * Open a file and resolve to an instance of {@linkcode FileHandle}. The + * file does not need to previously exist if using the `create` or `createNew` + * open options. It is the callers responsibility to close the file when finished + * with it. + * + * @example + * ```typescript + * import { open, BaseDirectory } from "@tauri-apps/plugin-fs" + * const file = await open("foo/bar.txt", { read: true, write: true, baseDir: BaseDirectory.AppLocalData }); + * // Do work with file + * await file.close(); + * ``` + * + * @since 2.0.0 + */ +async function open(path, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + const rid = await core.invoke('plugin:fs|open', { + path: path instanceof URL ? path.toString() : path, + options + }); + return new FileHandle(rid); +} +/** + * Copies the contents and permissions of one file to another specified path, by default creating a new file if needed, else overwriting. + * @example + * ```typescript + * import { copyFile, BaseDirectory } from '@tauri-apps/plugin-fs'; + * await copyFile('app.conf', 'app.conf.bk', { fromPathBaseDir: BaseDirectory.AppConfig, toPathBaseDir: BaseDirectory.AppConfig }); + * ``` + * + * @since 2.0.0 + */ +async function copyFile(fromPath, toPath, options) { + if ((fromPath instanceof URL && fromPath.protocol !== 'file:') + || (toPath instanceof URL && toPath.protocol !== 'file:')) { + throw new TypeError('Must be a file URL.'); + } + await core.invoke('plugin:fs|copy_file', { + fromPath: fromPath instanceof URL ? fromPath.toString() : fromPath, + toPath: toPath instanceof URL ? toPath.toString() : toPath, + options + }); +} +/** + * Creates a new directory with the specified path. + * @example + * ```typescript + * import { mkdir, BaseDirectory } from '@tauri-apps/plugin-fs'; + * await mkdir('users', { baseDir: BaseDirectory.AppLocalData }); + * ``` + * + * @since 2.0.0 + */ +async function mkdir(path, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + await core.invoke('plugin:fs|mkdir', { + path: path instanceof URL ? path.toString() : path, + options + }); +} +/** + * Reads the directory given by path and returns an array of `DirEntry`. + * @example + * ```typescript + * import { readDir, BaseDirectory } from '@tauri-apps/plugin-fs'; + * import { join } from '@tauri-apps/api/path'; + * const dir = "users" + * const entries = await readDir('users', { baseDir: BaseDirectory.AppLocalData }); + * processEntriesRecursively(dir, entries); + * async function processEntriesRecursively(parent, entries) { + * for (const entry of entries) { + * console.log(`Entry: ${entry.name}`); + * if (entry.isDirectory) { + * const dir = await join(parent, entry.name); + * processEntriesRecursively(dir, await readDir(dir, { baseDir: BaseDirectory.AppLocalData })) + * } + * } + * } + * ``` + * + * @since 2.0.0 + */ +async function readDir(path, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + return await core.invoke('plugin:fs|read_dir', { + path: path instanceof URL ? path.toString() : path, + options + }); +} +/** + * Reads and resolves to the entire contents of a file as an array of bytes. + * TextDecoder can be used to transform the bytes to string if required. + * @example + * ```typescript + * import { readFile, BaseDirectory } from '@tauri-apps/plugin-fs'; + * const contents = await readFile('avatar.png', { baseDir: BaseDirectory.Resource }); + * ``` + * + * @since 2.0.0 + */ +async function readFile(path, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + const arr = await core.invoke('plugin:fs|read_file', { + path: path instanceof URL ? path.toString() : path, + options + }); + return arr instanceof ArrayBuffer ? new Uint8Array(arr) : Uint8Array.from(arr); +} +/** + * Reads and returns the entire contents of a file as a string using the specified encoding (default: UTF-8). + * @example + * ```typescript + * import { readTextFile, BaseDirectory } from '@tauri-apps/plugin-fs'; + * const contents = await readTextFile('app.conf', { baseDir: BaseDirectory.AppConfig }); + * ``` + * + * @since 2.0.0 + */ +async function readTextFile(path, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + const arr = await core.invoke('plugin:fs|read_text_file', { + path: path instanceof URL ? path.toString() : path, + options + }); + const bytes = arr instanceof ArrayBuffer ? arr : Uint8Array.from(arr); + return new TextDecoder(options?.encoding ?? 'utf-8').decode(bytes); +} +/** + * Returns an async {@linkcode AsyncIterableIterator} over the lines of a file, decoded using the specified encoding (default: UTF-8). + * @example + * ```typescript + * import { readTextFileLines, BaseDirectory } from '@tauri-apps/plugin-fs'; + * const lines = await readTextFileLines('app.conf', { baseDir: BaseDirectory.AppConfig }); + * for await (const line of lines) { + * console.log(line); + * } + * ``` + * You could also call {@linkcode AsyncIterableIterator.next} to advance the + * iterator so you can lazily read the next line whenever you want. + * + * @since 2.0.0 + */ +async function readTextFileLines(path, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + const pathStr = path instanceof URL ? path.toString() : path; + return await Promise.resolve({ + path: pathStr, + rid: null, + async next() { + const decoder = new TextDecoder(options?.encoding ?? 'utf-8'); + if (this.rid === null) { + // Use the normalized encoding label for options. + const encoding = decoder.encoding; + this.rid = await core.invoke('plugin:fs|read_text_file_lines', { + path: pathStr, + options: options != null ? { ...options, encoding } : undefined + }); + } + const arr = await core.invoke('plugin:fs|read_text_file_lines_next', { rid: this.rid }); + const bytes = arr instanceof ArrayBuffer ? new Uint8Array(arr) : Uint8Array.from(arr); + // Rust side will never return an empty array for this command and + // ensure there is at least one elements there. + // + // This is an optimization to include whether we finished iteration or not (1 or 0) + // at the end of returned array to avoid serialization overhead of separate values. + const done = bytes[bytes.byteLength - 1] === 1; + if (done) { + // a full iteration is over, reset rid for next iteration + this.rid = null; + return { value: null, done }; + } + const line = decoder.decode(bytes.slice(0, bytes.byteLength - 1)); + return { + value: line, + done + }; + }, + [Symbol.asyncIterator]() { + return this; + } + }); +} +/** + * Removes the named file or directory. + * If the directory is not empty and the `recursive` option isn't set to true, the promise will be rejected. + * @example + * ```typescript + * import { remove, BaseDirectory } from '@tauri-apps/plugin-fs'; + * await remove('users/file.txt', { baseDir: BaseDirectory.AppLocalData }); + * await remove('users', { baseDir: BaseDirectory.AppLocalData }); + * ``` + * + * @since 2.0.0 + */ +async function remove(path, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + await core.invoke('plugin:fs|remove', { + path: path instanceof URL ? path.toString() : path, + options + }); +} +/** + * Renames (moves) oldpath to newpath. Paths may be files or directories. + * If newpath already exists and is not a directory, rename() replaces it. + * OS-specific restrictions may apply when oldpath and newpath are in different directories. + * + * On Unix, this operation does not follow symlinks at either path. + * + * @example + * ```typescript + * import { rename, BaseDirectory } from '@tauri-apps/plugin-fs'; + * await rename('avatar.png', 'deleted.png', { oldPathBaseDir: BaseDirectory.App, newPathBaseDir: BaseDirectory.AppLocalData }); + * ``` + * + * @since 2.0.0 + */ +async function rename(oldPath, newPath, options) { + if ((oldPath instanceof URL && oldPath.protocol !== 'file:') + || (newPath instanceof URL && newPath.protocol !== 'file:')) { + throw new TypeError('Must be a file URL.'); + } + await core.invoke('plugin:fs|rename', { + oldPath: oldPath instanceof URL ? oldPath.toString() : oldPath, + newPath: newPath instanceof URL ? newPath.toString() : newPath, + options + }); +} +/** + * Resolves to a {@linkcode FileInfo} for the specified `path`. Will always + * follow symlinks but will reject if the symlink points to a path outside of the scope. + * + * @example + * ```typescript + * import { stat, BaseDirectory } from '@tauri-apps/plugin-fs'; + * const fileInfo = await stat("hello.txt", { baseDir: BaseDirectory.AppLocalData }); + * console.log(fileInfo.isFile); // true + * ``` + * + * @since 2.0.0 + */ +async function stat(path, options) { + const res = await core.invoke('plugin:fs|stat', { + path: path instanceof URL ? path.toString() : path, + options + }); + return parseFileInfo(res); +} +/** + * Resolves to a {@linkcode FileInfo} for the specified `path`. If `path` is a + * symlink, information for the symlink will be returned instead of what it + * points to. + * + * @example + * ```typescript + * import { lstat, BaseDirectory } from '@tauri-apps/plugin-fs'; + * const fileInfo = await lstat("hello.txt", { baseDir: BaseDirectory.AppLocalData }); + * console.log(fileInfo.isFile); // true + * ``` + * + * @since 2.0.0 + */ +async function lstat(path, options) { + const res = await core.invoke('plugin:fs|lstat', { + path: path instanceof URL ? path.toString() : path, + options + }); + return parseFileInfo(res); +} +/** + * Truncates or extends the specified file, to reach the specified `len`. + * If `len` is `0` or not specified, then the entire file contents are truncated. + * + * @example + * ```typescript + * import { truncate, readTextFile, writeTextFile, BaseDirectory } from '@tauri-apps/plugin-fs'; + * // truncate the entire file + * await truncate("my_file.txt", 0, { baseDir: BaseDirectory.AppLocalData }); + * + * // truncate part of the file + * const filePath = "file.txt"; + * await writeTextFile(filePath, "Hello World", { baseDir: BaseDirectory.AppLocalData }); + * await truncate(filePath, 7, { baseDir: BaseDirectory.AppLocalData }); + * const data = await readTextFile(filePath, { baseDir: BaseDirectory.AppLocalData }); + * console.log(data); // "Hello W" + * ``` + * + * @since 2.0.0 + */ +async function truncate(path, len, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + await core.invoke('plugin:fs|truncate', { + path: path instanceof URL ? path.toString() : path, + len, + options + }); +} +/** + * Write `data` to the given `path`, by default creating a new file if needed, else overwriting. + * @example + * ```typescript + * import { writeFile, BaseDirectory } from '@tauri-apps/plugin-fs'; + * + * let encoder = new TextEncoder(); + * let data = encoder.encode("Hello World"); + * await writeFile('file.txt', data, { baseDir: BaseDirectory.AppLocalData }); + * ``` + * + * @since 2.0.0 + */ +async function writeFile(path, data, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + if (data instanceof ReadableStream) { + const file = await open(path, { + read: false, + create: true, + write: true, + ...options + }); + const reader = data.getReader(); + try { + while (true) { + const { done, value } = await reader.read(); + if (done) + break; + await file.write(value); + } + } + finally { + reader.releaseLock(); + await file.close(); + } + } + else { + await core.invoke('plugin:fs|write_file', data, { + headers: { + path: encodeURIComponent(path instanceof URL ? path.toString() : path), + options: JSON.stringify(options) + } + }); + } +} +/** + * Writes UTF-8 string `data` to the given `path`, by default creating a new file if needed, else overwriting. + @example + * ```typescript + * import { writeTextFile, BaseDirectory } from '@tauri-apps/plugin-fs'; + * + * await writeTextFile('file.txt', "Hello world", { baseDir: BaseDirectory.AppLocalData }); + * ``` + * + * @since 2.0.0 + */ +async function writeTextFile(path, data, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + const encoder = new TextEncoder(); + await core.invoke('plugin:fs|write_text_file', encoder.encode(data), { + headers: { + path: encodeURIComponent(path instanceof URL ? path.toString() : path), + options: JSON.stringify(options) + } + }); +} +/** + * Check if a path exists. + * @example + * ```typescript + * import { exists, BaseDirectory } from '@tauri-apps/plugin-fs'; + * // Check if the `$APPDATA/avatar.png` file exists + * await exists('avatar.png', { baseDir: BaseDirectory.AppData }); + * ``` + * + * @since 2.0.0 + */ +async function exists(path, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + return await core.invoke('plugin:fs|exists', { + path: path instanceof URL ? path.toString() : path, + options + }); +} +class Watcher extends core.Resource { +} +async function watchInternal(paths, cb, options) { + const watchPaths = Array.isArray(paths) ? paths : [paths]; + for (const path of watchPaths) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + } + const onEvent = new core.Channel(); + onEvent.onmessage = cb; + const rid = await core.invoke('plugin:fs|watch', { + paths: watchPaths.map((p) => (p instanceof URL ? p.toString() : p)), + options, + onEvent + }); + const watcher = new Watcher(rid); + return () => { + void watcher.close(); + }; +} +// TODO: Return `Watcher` instead in v3 +/** + * Watch changes (after a delay) on files or directories. + * + * @since 2.0.0 + */ +async function watch(paths, cb, options) { + return await watchInternal(paths, cb, { + delayMs: 2000, + ...options + }); +} +// TODO: Return `Watcher` instead in v3 +/** + * Watch changes on files or directories. + * + * @since 2.0.0 + */ +async function watchImmediate(paths, cb, options) { + return await watchInternal(paths, cb, { + ...options, + delayMs: undefined + }); +} +/** + * Get the size of a file or directory. For files, the `stat` functions can be used as well. + * + * If `path` is a directory, this function will recursively iterate over every file and every directory inside of `path` and therefore will be very time consuming if used on larger directories. + * + * @example + * ```typescript + * import { size, BaseDirectory } from '@tauri-apps/plugin-fs'; + * // Get the size of the `$APPDATA/tauri` directory. + * const dirSize = await size('tauri', { baseDir: BaseDirectory.AppData }); + * console.log(dirSize); // 1024 + * ``` + * + * @since 2.1.0 + */ +async function size(path) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + return await core.invoke('plugin:fs|size', { + path: path instanceof URL ? path.toString() : path + }); +} +/** + * Starts accessing a security-scoped resource for the given file URL. + * This should be called when you're accessing a file that was opened + * using a security-scoped URL (e.g., from a file picker). + * + * Note that accessing security-scoped resources is automatically managed by the plugin on iOS, so you don't need to call this function + * unless you want to manage the scope manually. + * + * You must call {@linkcode stopAccessingSecurityScopedResource} when you're done accessing the resource. + * + * #### Platform-specific + * + * - **iOS:** Starts accessing the security-scoped resource. + * - **Other platforms:** does nothing. + * + * @example + * ```typescript + * import { startAccessingSecurityScopedResource } from '@tauri-apps/plugin-fs'; + * + * const filePath = 'file:///path/to/file.txt'; + * await startAccessingSecurityScopedResource(filePath); + * // ... use the resource ... + * ``` + * + * @since 2.5.0 + */ +async function startAccessingSecurityScopedResource(path) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + await core.invoke('plugin:fs|start_accessing_security_scoped_resource', { + path: path instanceof URL ? path.toString() : path + }); +} +/** + * Stops accessing a security-scoped resource for the given file URL. + * This should be called when you're done accessing a file that was opened + * using a security-scoped URL (e.g., from a file picker) when using manual tracking via {@linkcode startAccessingSecurityScopedResource}. + * + * #### Platform-specific + * + * - **iOS:** Stops accessing the security-scoped resource. + * - **Other platforms:** does nothing. + * + * @example + * ```typescript + * import { stopAccessingSecurityScopedResource } from '@tauri-apps/plugin-fs'; + * + * const filePath = 'file:///path/to/file.txt'; + * await startAccessingSecurityScopedResource(filePath); + * // ... use the resource ... + * // when you're done with the resource: + * await stopAccessingSecurityScopedResource(filePath); + * ``` + * + * @since 2.5.0 + */ +async function stopAccessingSecurityScopedResource(path) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + await core.invoke('plugin:fs|stop_accessing_security_scoped_resource', { + path: path instanceof URL ? path.toString() : path + }); +} + +Object.defineProperty(exports, "BaseDirectory", { + enumerable: true, + get: function () { return path.BaseDirectory; } +}); +exports.FileHandle = FileHandle; +exports.copyFile = copyFile; +exports.create = create; +exports.exists = exists; +exports.lstat = lstat; +exports.mkdir = mkdir; +exports.open = open; +exports.readDir = readDir; +exports.readFile = readFile; +exports.readTextFile = readTextFile; +exports.readTextFileLines = readTextFileLines; +exports.remove = remove; +exports.rename = rename; +exports.size = size; +exports.startAccessingSecurityScopedResource = startAccessingSecurityScopedResource; +exports.stat = stat; +exports.stopAccessingSecurityScopedResource = stopAccessingSecurityScopedResource; +exports.truncate = truncate; +exports.watch = watch; +exports.watchImmediate = watchImmediate; +exports.writeFile = writeFile; +exports.writeTextFile = writeTextFile; diff --git a/scripts/node_modules/@tauri-apps/plugin-fs/dist-js/index.d.ts b/scripts/node_modules/@tauri-apps/plugin-fs/dist-js/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d48ad4d62189e5e74c9b15157b3f7c3fa772a6e8 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/plugin-fs/dist-js/index.d.ts @@ -0,0 +1,928 @@ +/** + * Access the file system. + * + * ## iOS security-scoped resources + * + * On iOS, the `fs` plugin automatically manages access to security-scoped resources when a file URL is accessed. + * This is required for files outside the app's sandbox (e.g., from file picker). + * + * @example + * ```typescript + * import { open } from '@tauri-apps/plugin-fs'; + * + * const file = await open('file:///path/to/file.txt'); + * await file.close(); + * ``` + * + * ## Security + * + * This module prevents path traversal, not allowing parent directory accessors to be used + * (i.e. "/usr/path/to/../file" or "../path/to/file" paths are not allowed). + * Paths accessed with this API must be either relative to one of the {@link BaseDirectory | base directories} + * or created with the {@link https://v2.tauri.app/reference/javascript/api/namespacepath/ | path API}. + * + * The API has a scope configuration that forces you to restrict the paths that can be accessed using glob patterns. + * + * The scope configuration is an array of glob patterns describing file/directory paths that are allowed. + * For instance, this scope configuration allows **all** enabled `fs` APIs to (only) access files in the + * *databases* directory of the {@link https://v2.tauri.app/reference/javascript/api/namespacepath/#appdatadir | `$APPDATA` directory}: + * ```json + * { + * "permissions": [ + * { + * "identifier": "fs:scope", + * "allow": [{ "path": "$APPDATA/databases/*" }] + * } + * ] + * } + * ``` + * + * Scopes can also be applied to specific `fs` APIs by using the API's identifier instead of `fs:scope`: + * ```json + * { + * "permissions": [ + * { + * "identifier": "fs:allow-exists", + * "allow": [{ "path": "$APPDATA/databases/*" }] + * } + * ] + * } + * ``` + * + * Notice the use of the `$APPDATA` variable. The value is injected at runtime, resolving to the {@link https://v2.tauri.app/reference/javascript/api/namespacepath/#appdatadir | app data directory}. + * + * The available variables are: + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#appconfigdir | $APPCONFIG}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#appdatadir | $APPDATA}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#applocaldatadir | $APPLOCALDATA}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#appcachedir | $APPCACHE}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#applogdir | $APPLOG}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#audiodir | $AUDIO}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#cachedir | $CACHE}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#configdir | $CONFIG}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#datadir | $DATA}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#localdatadir | $LOCALDATA}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#desktopdir | $DESKTOP}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#documentdir | $DOCUMENT}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#downloaddir | $DOWNLOAD}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#executabledir | $EXE}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#fontdir | $FONT}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#homedir | $HOME}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#picturedir | $PICTURE}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#publicdir | $PUBLIC}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#runtimedir | $RUNTIME}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#templatedir | $TEMPLATE}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#videodir | $VIDEO}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#resourcedir | $RESOURCE}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#tempdir | $TEMP}. + * + * Trying to execute any API with a URL not configured on the scope results in a promise rejection due to denied access. + * + * @module + */ +import { BaseDirectory } from '@tauri-apps/api/path'; +import { Resource } from '@tauri-apps/api/core'; +declare enum SeekMode { + Start = 0, + Current = 1, + End = 2 +} +/** + * A FileInfo describes a file and is returned by `stat`, `lstat` or `fstat`. + * + * @since 2.0.0 + */ +interface FileInfo { + /** + * True if this is info for a regular file. Mutually exclusive to + * `FileInfo.isDirectory` and `FileInfo.isSymlink`. + */ + isFile: boolean; + /** + * True if this is info for a regular directory. Mutually exclusive to + * `FileInfo.isFile` and `FileInfo.isSymlink`. + */ + isDirectory: boolean; + /** + * True if this is info for a symlink. Mutually exclusive to + * `FileInfo.isFile` and `FileInfo.isDirectory`. + */ + isSymlink: boolean; + /** + * The size of the file, in bytes. + */ + size: number; + /** + * The last modification time of the file. This corresponds to the `mtime` + * field from `stat` on Linux/Mac OS and `ftLastWriteTime` on Windows. This + * may not be available on all platforms. + */ + mtime: Date | null; + /** + * The last access time of the file. This corresponds to the `atime` + * field from `stat` on Unix and `ftLastAccessTime` on Windows. This may not + * be available on all platforms. + */ + atime: Date | null; + /** + * The creation time of the file. This corresponds to the `birthtime` + * field from `stat` on Mac/BSD and `ftCreationTime` on Windows. This may + * not be available on all platforms. + */ + birthtime: Date | null; + /** Whether this is a readonly (unwritable) file. */ + readonly: boolean; + /** + * This field contains the file system attribute information for a file + * or directory. For possible values and their descriptions, see + * {@link https://docs.microsoft.com/en-us/windows/win32/fileio/file-attribute-constants | File Attribute Constants} in the Windows Dev Center + * + * #### Platform-specific + * + * - **macOS / Linux / Android / iOS:** Unsupported. + */ + fileAttributes: number | null; + /** + * ID of the device containing the file. + * + * #### Platform-specific + * + * - **Windows:** Unsupported. + */ + dev: number | null; + /** + * Inode number. + * + * #### Platform-specific + * + * - **Windows:** Unsupported. + */ + ino: number | null; + /** + * The underlying raw `st_mode` bits that contain the standard Unix + * permissions for this file/directory. + * + * #### Platform-specific + * + * - **Windows:** Unsupported. + */ + mode: number | null; + /** + * Number of hard links pointing to this file. + * + * #### Platform-specific + * + * - **Windows:** Unsupported. + */ + nlink: number | null; + /** + * User ID of the owner of this file. + * + * #### Platform-specific + * + * - **Windows:** Unsupported. + */ + uid: number | null; + /** + * Group ID of the owner of this file. + * + * #### Platform-specific + * + * - **Windows:** Unsupported. + */ + gid: number | null; + /** + * Device ID of this file. + * + * #### Platform-specific + * + * - **Windows:** Unsupported. + */ + rdev: number | null; + /** + * Blocksize for filesystem I/O. + * + * #### Platform-specific + * + * - **Windows:** Unsupported. + */ + blksize: number | null; + /** + * Number of blocks allocated to the file, in 512-byte units. + * + * #### Platform-specific + * + * - **Windows:** Unsupported. + */ + blocks: number | null; +} +/** + * The Tauri abstraction for reading and writing files. + * + * @since 2.0.0 + */ +declare class FileHandle extends Resource { + /** + * Reads up to `p.byteLength` bytes into `p`. It resolves to the number of + * bytes read (`0` < `n` <= `p.byteLength`) and rejects if any error + * encountered. Even if `read()` resolves to `n` < `p.byteLength`, it may + * use all of `p` as scratch space during the call. If some data is + * available but not `p.byteLength` bytes, `read()` conventionally resolves + * to what is available instead of waiting for more. + * + * When `read()` encounters end-of-file condition, it resolves to EOF + * (`null`). + * + * When `read()` encounters an error, it rejects with an error. + * + * Callers should always process the `n` > `0` bytes returned before + * considering the EOF (`null`). Doing so correctly handles I/O errors that + * happen after reading some bytes and also both of the allowed EOF + * behaviors. + * + * @example + * ```typescript + * import { open, BaseDirectory } from "@tauri-apps/plugin-fs" + * // if "$APPCONFIG/foo/bar.txt" contains the text "hello world": + * const file = await open("foo/bar.txt", { baseDir: BaseDirectory.AppConfig }); + * const buf = new Uint8Array(100); + * const numberOfBytesRead = await file.read(buf); // 11 bytes + * const text = new TextDecoder().decode(buf); // "hello world" + * await file.close(); + * ``` + * + * @since 2.0.0 + */ + read(buffer: Uint8Array): Promise; + /** + * Seek sets the offset for the next `read()` or `write()` to offset, + * interpreted according to `whence`: `Start` means relative to the + * start of the file, `Current` means relative to the current offset, + * and `End` means relative to the end. Seek resolves to the new offset + * relative to the start of the file. + * + * Seeking to an offset before the start of the file is an error. Seeking to + * any positive offset is legal, but the behavior of subsequent I/O + * operations on the underlying object is implementation-dependent. + * It returns the number of cursor position. + * + * @example + * ```typescript + * import { open, SeekMode, BaseDirectory } from '@tauri-apps/plugin-fs'; + * + * // Given hello.txt pointing to file with "Hello world", which is 11 bytes long: + * const file = await open('hello.txt', { read: true, write: true, truncate: true, create: true, baseDir: BaseDirectory.AppLocalData }); + * await file.write(new TextEncoder().encode("Hello world")); + * + * // Seek 6 bytes from the start of the file + * console.log(await file.seek(6, SeekMode.Start)); // "6" + * // Seek 2 more bytes from the current position + * console.log(await file.seek(2, SeekMode.Current)); // "8" + * // Seek backwards 2 bytes from the end of the file + * console.log(await file.seek(-2, SeekMode.End)); // "9" (e.g. 11-2) + * + * await file.close(); + * ``` + * + * @since 2.0.0 + */ + seek(offset: number, whence: SeekMode): Promise; + /** + * Returns a {@linkcode FileInfo } for this file. + * + * @example + * ```typescript + * import { open, BaseDirectory } from '@tauri-apps/plugin-fs'; + * const file = await open("file.txt", { read: true, baseDir: BaseDirectory.AppLocalData }); + * const fileInfo = await file.stat(); + * console.log(fileInfo.isFile); // true + * await file.close(); + * ``` + * + * @since 2.0.0 + */ + stat(): Promise; + /** + * Truncates or extends this file, to reach the specified `len`. + * If `len` is not specified then the entire file contents are truncated. + * + * @example + * ```typescript + * import { open, BaseDirectory } from '@tauri-apps/plugin-fs'; + * + * // truncate the entire file + * const file = await open("my_file.txt", { read: true, write: true, create: true, baseDir: BaseDirectory.AppLocalData }); + * await file.truncate(); + * + * // truncate part of the file + * const file = await open("my_file.txt", { read: true, write: true, create: true, baseDir: BaseDirectory.AppLocalData }); + * await file.write(new TextEncoder().encode("Hello World")); + * await file.truncate(7); + * const data = new Uint8Array(32); + * await file.read(data); + * console.log(new TextDecoder().decode(data)); // Hello W + * await file.close(); + * ``` + * + * @since 2.0.0 + */ + truncate(len?: number): Promise; + /** + * Writes `data.byteLength` bytes from `data` to the underlying data stream. It + * resolves to the number of bytes written from `data` (`0` <= `n` <= + * `data.byteLength`) or reject with the error encountered that caused the + * write to stop early. `write()` must reject with a non-null error if + * would resolve to `n` < `data.byteLength`. `write()` must not modify the + * slice data, even temporarily. + * + * @example + * ```typescript + * import { open, write, BaseDirectory } from '@tauri-apps/plugin-fs'; + * const encoder = new TextEncoder(); + * const data = encoder.encode("Hello world"); + * const file = await open("bar.txt", { write: true, baseDir: BaseDirectory.AppLocalData }); + * const bytesWritten = await file.write(data); // 11 + * await file.close(); + * ``` + * + * @since 2.0.0 + */ + write(data: Uint8Array): Promise; +} +/** + * @since 2.0.0 + */ +interface CreateOptions { + /** Base directory for `path` */ + baseDir?: BaseDirectory; +} +/** + * Creates a file if none exists or truncates an existing file and resolves to + * an instance of {@linkcode FileHandle }. + * + * @example + * ```typescript + * import { create, BaseDirectory } from "@tauri-apps/plugin-fs" + * const file = await create("foo/bar.txt", { baseDir: BaseDirectory.AppConfig }); + * await file.write(new TextEncoder().encode("Hello world")); + * await file.close(); + * ``` + * + * @since 2.0.0 + */ +declare function create(path: string | URL, options?: CreateOptions): Promise; +/** + * @since 2.0.0 + */ +interface OpenOptions { + /** + * Sets the option for read access. This option, when `true`, means that the + * file should be read-able if opened. + */ + read?: boolean; + /** + * Sets the option for write access. This option, when `true`, means that + * the file should be write-able if opened. If the file already exists, + * any write calls on it will overwrite its contents, by default without + * truncating it. + */ + write?: boolean; + /** + * Sets the option for the append mode. This option, when `true`, means that + * writes will append to a file instead of overwriting previous contents. + * Note that setting `{ write: true, append: true }` has the same effect as + * setting only `{ append: true }`. + */ + append?: boolean; + /** + * Sets the option for truncating a previous file. If a file is + * successfully opened with this option set it will truncate the file to `0` + * size if it already exists. The file must be opened with write access + * for truncate to work. + */ + truncate?: boolean; + /** + * Sets the option to allow creating a new file, if one doesn't already + * exist at the specified path. Requires write or append access to be + * used. + */ + create?: boolean; + /** + * Defaults to `false`. If set to `true`, no file, directory, or symlink is + * allowed to exist at the target location. Requires write or append + * access to be used. When createNew is set to `true`, create and truncate + * are ignored. + */ + createNew?: boolean; + /** + * Permissions to use if creating the file (defaults to `0o666`, before + * the process's umask). + * Ignored on Windows. + */ + mode?: number; + /** Base directory for `path` */ + baseDir?: BaseDirectory; +} +/** + * Open a file and resolve to an instance of {@linkcode FileHandle}. The + * file does not need to previously exist if using the `create` or `createNew` + * open options. It is the callers responsibility to close the file when finished + * with it. + * + * @example + * ```typescript + * import { open, BaseDirectory } from "@tauri-apps/plugin-fs" + * const file = await open("foo/bar.txt", { read: true, write: true, baseDir: BaseDirectory.AppLocalData }); + * // Do work with file + * await file.close(); + * ``` + * + * @since 2.0.0 + */ +declare function open(path: string | URL, options?: OpenOptions): Promise; +/** + * @since 2.0.0 + */ +interface CopyFileOptions { + /** Base directory for `fromPath`. */ + fromPathBaseDir?: BaseDirectory; + /** Base directory for `toPath`. */ + toPathBaseDir?: BaseDirectory; +} +/** + * Copies the contents and permissions of one file to another specified path, by default creating a new file if needed, else overwriting. + * @example + * ```typescript + * import { copyFile, BaseDirectory } from '@tauri-apps/plugin-fs'; + * await copyFile('app.conf', 'app.conf.bk', { fromPathBaseDir: BaseDirectory.AppConfig, toPathBaseDir: BaseDirectory.AppConfig }); + * ``` + * + * @since 2.0.0 + */ +declare function copyFile(fromPath: string | URL, toPath: string | URL, options?: CopyFileOptions): Promise; +/** + * @since 2.0.0 + */ +interface MkdirOptions { + /** Permissions to use when creating the directory (defaults to `0o777`, before the process's umask). Ignored on Windows. */ + mode?: number; + /** + * Defaults to `false`. If set to `true`, means that any intermediate directories will also be created (as with the shell command `mkdir -p`). + * */ + recursive?: boolean; + /** Base directory for `path` */ + baseDir?: BaseDirectory; +} +/** + * Creates a new directory with the specified path. + * @example + * ```typescript + * import { mkdir, BaseDirectory } from '@tauri-apps/plugin-fs'; + * await mkdir('users', { baseDir: BaseDirectory.AppLocalData }); + * ``` + * + * @since 2.0.0 + */ +declare function mkdir(path: string | URL, options?: MkdirOptions): Promise; +/** + * @since 2.0.0 + */ +interface ReadDirOptions { + /** Base directory for `path` */ + baseDir?: BaseDirectory; +} +/** + * A disk entry which is either a file, a directory or a symlink. + * + * This is the result of the {@linkcode readDir}. + * + * @since 2.0.0 + */ +interface DirEntry { + /** The name of the entry (file name with extension or directory name). */ + name: string; + /** Specifies whether this entry is a directory or not. */ + isDirectory: boolean; + /** Specifies whether this entry is a file or not. */ + isFile: boolean; + /** Specifies whether this entry is a symlink or not. */ + isSymlink: boolean; +} +/** + * Reads the directory given by path and returns an array of `DirEntry`. + * @example + * ```typescript + * import { readDir, BaseDirectory } from '@tauri-apps/plugin-fs'; + * import { join } from '@tauri-apps/api/path'; + * const dir = "users" + * const entries = await readDir('users', { baseDir: BaseDirectory.AppLocalData }); + * processEntriesRecursively(dir, entries); + * async function processEntriesRecursively(parent, entries) { + * for (const entry of entries) { + * console.log(`Entry: ${entry.name}`); + * if (entry.isDirectory) { + * const dir = await join(parent, entry.name); + * processEntriesRecursively(dir, await readDir(dir, { baseDir: BaseDirectory.AppLocalData })) + * } + * } + * } + * ``` + * + * @since 2.0.0 + */ +declare function readDir(path: string | URL, options?: ReadDirOptions): Promise; +/** + * @since 2.0.0 + */ +interface ReadFileOptions { + /** Base directory for `path` */ + baseDir?: BaseDirectory; + /** Text encoding to use when reading a text file. Defaults to 'utf-8'. */ + encoding?: string; +} +/** + * Reads and resolves to the entire contents of a file as an array of bytes. + * TextDecoder can be used to transform the bytes to string if required. + * @example + * ```typescript + * import { readFile, BaseDirectory } from '@tauri-apps/plugin-fs'; + * const contents = await readFile('avatar.png', { baseDir: BaseDirectory.Resource }); + * ``` + * + * @since 2.0.0 + */ +declare function readFile(path: string | URL, options?: ReadFileOptions): Promise>; +/** + * Reads and returns the entire contents of a file as a string using the specified encoding (default: UTF-8). + * @example + * ```typescript + * import { readTextFile, BaseDirectory } from '@tauri-apps/plugin-fs'; + * const contents = await readTextFile('app.conf', { baseDir: BaseDirectory.AppConfig }); + * ``` + * + * @since 2.0.0 + */ +declare function readTextFile(path: string | URL, options?: ReadFileOptions): Promise; +/** + * Returns an async {@linkcode AsyncIterableIterator} over the lines of a file, decoded using the specified encoding (default: UTF-8). + * @example + * ```typescript + * import { readTextFileLines, BaseDirectory } from '@tauri-apps/plugin-fs'; + * const lines = await readTextFileLines('app.conf', { baseDir: BaseDirectory.AppConfig }); + * for await (const line of lines) { + * console.log(line); + * } + * ``` + * You could also call {@linkcode AsyncIterableIterator.next} to advance the + * iterator so you can lazily read the next line whenever you want. + * + * @since 2.0.0 + */ +declare function readTextFileLines(path: string | URL, options?: ReadFileOptions): Promise>; +/** + * @since 2.0.0 + */ +interface RemoveOptions { + /** Defaults to `false`. If set to `true`, path will be removed even if it's a non-empty directory. */ + recursive?: boolean; + /** Base directory for `path` */ + baseDir?: BaseDirectory; +} +/** + * Removes the named file or directory. + * If the directory is not empty and the `recursive` option isn't set to true, the promise will be rejected. + * @example + * ```typescript + * import { remove, BaseDirectory } from '@tauri-apps/plugin-fs'; + * await remove('users/file.txt', { baseDir: BaseDirectory.AppLocalData }); + * await remove('users', { baseDir: BaseDirectory.AppLocalData }); + * ``` + * + * @since 2.0.0 + */ +declare function remove(path: string | URL, options?: RemoveOptions): Promise; +/** + * @since 2.0.0 + */ +interface RenameOptions { + /** Base directory for `oldPath`. */ + oldPathBaseDir?: BaseDirectory; + /** Base directory for `newPath`. */ + newPathBaseDir?: BaseDirectory; +} +/** + * Renames (moves) oldpath to newpath. Paths may be files or directories. + * If newpath already exists and is not a directory, rename() replaces it. + * OS-specific restrictions may apply when oldpath and newpath are in different directories. + * + * On Unix, this operation does not follow symlinks at either path. + * + * @example + * ```typescript + * import { rename, BaseDirectory } from '@tauri-apps/plugin-fs'; + * await rename('avatar.png', 'deleted.png', { oldPathBaseDir: BaseDirectory.App, newPathBaseDir: BaseDirectory.AppLocalData }); + * ``` + * + * @since 2.0.0 + */ +declare function rename(oldPath: string | URL, newPath: string | URL, options?: RenameOptions): Promise; +/** + * @since 2.0.0 + */ +interface StatOptions { + /** Base directory for `path`. */ + baseDir?: BaseDirectory; +} +/** + * Resolves to a {@linkcode FileInfo} for the specified `path`. Will always + * follow symlinks but will reject if the symlink points to a path outside of the scope. + * + * @example + * ```typescript + * import { stat, BaseDirectory } from '@tauri-apps/plugin-fs'; + * const fileInfo = await stat("hello.txt", { baseDir: BaseDirectory.AppLocalData }); + * console.log(fileInfo.isFile); // true + * ``` + * + * @since 2.0.0 + */ +declare function stat(path: string | URL, options?: StatOptions): Promise; +/** + * Resolves to a {@linkcode FileInfo} for the specified `path`. If `path` is a + * symlink, information for the symlink will be returned instead of what it + * points to. + * + * @example + * ```typescript + * import { lstat, BaseDirectory } from '@tauri-apps/plugin-fs'; + * const fileInfo = await lstat("hello.txt", { baseDir: BaseDirectory.AppLocalData }); + * console.log(fileInfo.isFile); // true + * ``` + * + * @since 2.0.0 + */ +declare function lstat(path: string | URL, options?: StatOptions): Promise; +/** + * @since 2.0.0 + */ +interface TruncateOptions { + /** Base directory for `path`. */ + baseDir?: BaseDirectory; +} +/** + * Truncates or extends the specified file, to reach the specified `len`. + * If `len` is `0` or not specified, then the entire file contents are truncated. + * + * @example + * ```typescript + * import { truncate, readTextFile, writeTextFile, BaseDirectory } from '@tauri-apps/plugin-fs'; + * // truncate the entire file + * await truncate("my_file.txt", 0, { baseDir: BaseDirectory.AppLocalData }); + * + * // truncate part of the file + * const filePath = "file.txt"; + * await writeTextFile(filePath, "Hello World", { baseDir: BaseDirectory.AppLocalData }); + * await truncate(filePath, 7, { baseDir: BaseDirectory.AppLocalData }); + * const data = await readTextFile(filePath, { baseDir: BaseDirectory.AppLocalData }); + * console.log(data); // "Hello W" + * ``` + * + * @since 2.0.0 + */ +declare function truncate(path: string | URL, len?: number, options?: TruncateOptions): Promise; +/** + * @since 2.0.0 + */ +interface WriteFileOptions { + /** Defaults to `false`. If set to `true`, will append to a file instead of overwriting previous contents. */ + append?: boolean; + /** Sets the option to allow creating a new file, if one doesn't already exist at the specified path (defaults to `true`). */ + create?: boolean; + /** Sets the option to create a new file, failing if it already exists. */ + createNew?: boolean; + /** File permissions. Ignored on Windows. */ + mode?: number; + /** Base directory for `path` */ + baseDir?: BaseDirectory; +} +/** + * Write `data` to the given `path`, by default creating a new file if needed, else overwriting. + * @example + * ```typescript + * import { writeFile, BaseDirectory } from '@tauri-apps/plugin-fs'; + * + * let encoder = new TextEncoder(); + * let data = encoder.encode("Hello World"); + * await writeFile('file.txt', data, { baseDir: BaseDirectory.AppLocalData }); + * ``` + * + * @since 2.0.0 + */ +declare function writeFile(path: string | URL, data: Uint8Array | ReadableStream, options?: WriteFileOptions): Promise; +/** + * Writes UTF-8 string `data` to the given `path`, by default creating a new file if needed, else overwriting. + @example + * ```typescript + * import { writeTextFile, BaseDirectory } from '@tauri-apps/plugin-fs'; + * + * await writeTextFile('file.txt', "Hello world", { baseDir: BaseDirectory.AppLocalData }); + * ``` + * + * @since 2.0.0 + */ +declare function writeTextFile(path: string | URL, data: string, options?: WriteFileOptions): Promise; +/** + * @since 2.0.0 + */ +interface ExistsOptions { + /** Base directory for `path`. */ + baseDir?: BaseDirectory; +} +/** + * Check if a path exists. + * @example + * ```typescript + * import { exists, BaseDirectory } from '@tauri-apps/plugin-fs'; + * // Check if the `$APPDATA/avatar.png` file exists + * await exists('avatar.png', { baseDir: BaseDirectory.AppData }); + * ``` + * + * @since 2.0.0 + */ +declare function exists(path: string | URL, options?: ExistsOptions): Promise; +/** + * @since 2.0.0 + */ +interface WatchOptions { + /** Watch a directory recursively */ + recursive?: boolean; + /** Base directory for `path` */ + baseDir?: BaseDirectory; +} +/** + * @since 2.0.0 + */ +interface DebouncedWatchOptions extends WatchOptions { + /** Debounce delay */ + delayMs?: number; +} +/** + * @since 2.0.0 + */ +interface WatchEvent { + type: WatchEventKind; + paths: string[]; + attrs: unknown; +} +/** + * @since 2.0.0 + */ +type WatchEventKind = 'any' | { + access: WatchEventKindAccess; +} | { + create: WatchEventKindCreate; +} | { + modify: WatchEventKindModify; +} | { + remove: WatchEventKindRemove; +} | 'other'; +/** + * @since 2.0.0 + */ +type WatchEventKindAccess = { + kind: 'any'; +} | { + kind: 'close'; + mode: 'any' | 'execute' | 'read' | 'write' | 'other'; +} | { + kind: 'open'; + mode: 'any' | 'execute' | 'read' | 'write' | 'other'; +} | { + kind: 'other'; +}; +/** + * @since 2.0.0 + */ +type WatchEventKindCreate = { + kind: 'any'; +} | { + kind: 'file'; +} | { + kind: 'folder'; +} | { + kind: 'other'; +}; +/** + * @since 2.0.0 + */ +type WatchEventKindModify = { + kind: 'any'; +} | { + kind: 'data'; + mode: 'any' | 'size' | 'content' | 'other'; +} | { + kind: 'metadata'; + mode: 'any' | 'access-time' | 'write-time' | 'permissions' | 'ownership' | 'extended' | 'other'; +} | { + kind: 'rename'; + mode: 'any' | 'to' | 'from' | 'both' | 'other'; +} | { + kind: 'other'; +}; +/** + * @since 2.0.0 + */ +type WatchEventKindRemove = { + kind: 'any'; +} | { + kind: 'file'; +} | { + kind: 'folder'; +} | { + kind: 'other'; +}; +/** + * @since 2.0.0 + */ +type UnwatchFn = () => void; +/** + * Watch changes (after a delay) on files or directories. + * + * @since 2.0.0 + */ +declare function watch(paths: string | string[] | URL | URL[], cb: (event: WatchEvent) => void, options?: DebouncedWatchOptions): Promise; +/** + * Watch changes on files or directories. + * + * @since 2.0.0 + */ +declare function watchImmediate(paths: string | string[] | URL | URL[], cb: (event: WatchEvent) => void, options?: WatchOptions): Promise; +/** + * Get the size of a file or directory. For files, the `stat` functions can be used as well. + * + * If `path` is a directory, this function will recursively iterate over every file and every directory inside of `path` and therefore will be very time consuming if used on larger directories. + * + * @example + * ```typescript + * import { size, BaseDirectory } from '@tauri-apps/plugin-fs'; + * // Get the size of the `$APPDATA/tauri` directory. + * const dirSize = await size('tauri', { baseDir: BaseDirectory.AppData }); + * console.log(dirSize); // 1024 + * ``` + * + * @since 2.1.0 + */ +declare function size(path: string | URL): Promise; +/** + * Starts accessing a security-scoped resource for the given file URL. + * This should be called when you're accessing a file that was opened + * using a security-scoped URL (e.g., from a file picker). + * + * Note that accessing security-scoped resources is automatically managed by the plugin on iOS, so you don't need to call this function + * unless you want to manage the scope manually. + * + * You must call {@linkcode stopAccessingSecurityScopedResource} when you're done accessing the resource. + * + * #### Platform-specific + * + * - **iOS:** Starts accessing the security-scoped resource. + * - **Other platforms:** does nothing. + * + * @example + * ```typescript + * import { startAccessingSecurityScopedResource } from '@tauri-apps/plugin-fs'; + * + * const filePath = 'file:///path/to/file.txt'; + * await startAccessingSecurityScopedResource(filePath); + * // ... use the resource ... + * ``` + * + * @since 2.5.0 + */ +declare function startAccessingSecurityScopedResource(path: string | URL): Promise; +/** + * Stops accessing a security-scoped resource for the given file URL. + * This should be called when you're done accessing a file that was opened + * using a security-scoped URL (e.g., from a file picker) when using manual tracking via {@linkcode startAccessingSecurityScopedResource}. + * + * #### Platform-specific + * + * - **iOS:** Stops accessing the security-scoped resource. + * - **Other platforms:** does nothing. + * + * @example + * ```typescript + * import { stopAccessingSecurityScopedResource } from '@tauri-apps/plugin-fs'; + * + * const filePath = 'file:///path/to/file.txt'; + * await startAccessingSecurityScopedResource(filePath); + * // ... use the resource ... + * // when you're done with the resource: + * await stopAccessingSecurityScopedResource(filePath); + * ``` + * + * @since 2.5.0 + */ +declare function stopAccessingSecurityScopedResource(path: string | URL): Promise; +export type { CreateOptions, OpenOptions, CopyFileOptions, MkdirOptions, DirEntry, ReadDirOptions, ReadFileOptions, RemoveOptions, RenameOptions, StatOptions, TruncateOptions, WriteFileOptions, ExistsOptions, FileInfo, WatchOptions, DebouncedWatchOptions, WatchEvent, WatchEventKind, WatchEventKindAccess, WatchEventKindCreate, WatchEventKindModify, WatchEventKindRemove, UnwatchFn }; +export { BaseDirectory, FileHandle, create, open, copyFile, mkdir, readDir, readFile, readTextFile, readTextFileLines, remove, rename, SeekMode, stat, lstat, truncate, writeFile, writeTextFile, exists, watch, watchImmediate, size, startAccessingSecurityScopedResource, stopAccessingSecurityScopedResource }; diff --git a/scripts/node_modules/@tauri-apps/plugin-fs/dist-js/index.js b/scripts/node_modules/@tauri-apps/plugin-fs/dist-js/index.js new file mode 100644 index 0000000000000000000000000000000000000000..f90d976f2b14cef3cbdf667832405ae278b70c13 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/plugin-fs/dist-js/index.js @@ -0,0 +1,864 @@ +export { BaseDirectory } from '@tauri-apps/api/path'; +import { Resource, invoke, Channel } from '@tauri-apps/api/core'; + +// Copyright 2019-2023 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * Access the file system. + * + * ## iOS security-scoped resources + * + * On iOS, the `fs` plugin automatically manages access to security-scoped resources when a file URL is accessed. + * This is required for files outside the app's sandbox (e.g., from file picker). + * + * @example + * ```typescript + * import { open } from '@tauri-apps/plugin-fs'; + * + * const file = await open('file:///path/to/file.txt'); + * await file.close(); + * ``` + * + * ## Security + * + * This module prevents path traversal, not allowing parent directory accessors to be used + * (i.e. "/usr/path/to/../file" or "../path/to/file" paths are not allowed). + * Paths accessed with this API must be either relative to one of the {@link BaseDirectory | base directories} + * or created with the {@link https://v2.tauri.app/reference/javascript/api/namespacepath/ | path API}. + * + * The API has a scope configuration that forces you to restrict the paths that can be accessed using glob patterns. + * + * The scope configuration is an array of glob patterns describing file/directory paths that are allowed. + * For instance, this scope configuration allows **all** enabled `fs` APIs to (only) access files in the + * *databases* directory of the {@link https://v2.tauri.app/reference/javascript/api/namespacepath/#appdatadir | `$APPDATA` directory}: + * ```json + * { + * "permissions": [ + * { + * "identifier": "fs:scope", + * "allow": [{ "path": "$APPDATA/databases/*" }] + * } + * ] + * } + * ``` + * + * Scopes can also be applied to specific `fs` APIs by using the API's identifier instead of `fs:scope`: + * ```json + * { + * "permissions": [ + * { + * "identifier": "fs:allow-exists", + * "allow": [{ "path": "$APPDATA/databases/*" }] + * } + * ] + * } + * ``` + * + * Notice the use of the `$APPDATA` variable. The value is injected at runtime, resolving to the {@link https://v2.tauri.app/reference/javascript/api/namespacepath/#appdatadir | app data directory}. + * + * The available variables are: + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#appconfigdir | $APPCONFIG}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#appdatadir | $APPDATA}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#applocaldatadir | $APPLOCALDATA}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#appcachedir | $APPCACHE}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#applogdir | $APPLOG}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#audiodir | $AUDIO}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#cachedir | $CACHE}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#configdir | $CONFIG}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#datadir | $DATA}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#localdatadir | $LOCALDATA}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#desktopdir | $DESKTOP}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#documentdir | $DOCUMENT}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#downloaddir | $DOWNLOAD}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#executabledir | $EXE}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#fontdir | $FONT}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#homedir | $HOME}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#picturedir | $PICTURE}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#publicdir | $PUBLIC}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#runtimedir | $RUNTIME}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#templatedir | $TEMPLATE}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#videodir | $VIDEO}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#resourcedir | $RESOURCE}, + * {@linkcode https://v2.tauri.app/reference/javascript/api/namespacepath/#tempdir | $TEMP}. + * + * Trying to execute any API with a URL not configured on the scope results in a promise rejection due to denied access. + * + * @module + */ +var SeekMode; +(function (SeekMode) { + SeekMode[SeekMode["Start"] = 0] = "Start"; + SeekMode[SeekMode["Current"] = 1] = "Current"; + SeekMode[SeekMode["End"] = 2] = "End"; +})(SeekMode || (SeekMode = {})); +function parseFileInfo(r) { + return { + isFile: r.isFile, + isDirectory: r.isDirectory, + isSymlink: r.isSymlink, + size: r.size, + mtime: r.mtime !== null ? new Date(r.mtime) : null, + atime: r.atime !== null ? new Date(r.atime) : null, + birthtime: r.birthtime !== null ? new Date(r.birthtime) : null, + readonly: r.readonly, + fileAttributes: r.fileAttributes, + dev: r.dev, + ino: r.ino, + mode: r.mode, + nlink: r.nlink, + uid: r.uid, + gid: r.gid, + rdev: r.rdev, + blksize: r.blksize, + blocks: r.blocks + }; +} +// https://gist.github.com/zapthedingbat/38ebfbedd98396624e5b5f2ff462611d +/** Converts a big-endian eight byte array to number */ +function fromBytes(buffer) { + const bytes = new Uint8ClampedArray(buffer); + const size = bytes.byteLength; + let x = 0; + for (let i = 0; i < size; i++) { + // eslint-disable-next-line security/detect-object-injection + const byte = bytes[i]; + x *= 0x100; + x += byte; + } + return x; +} +/** + * The Tauri abstraction for reading and writing files. + * + * @since 2.0.0 + */ +class FileHandle extends Resource { + /** + * Reads up to `p.byteLength` bytes into `p`. It resolves to the number of + * bytes read (`0` < `n` <= `p.byteLength`) and rejects if any error + * encountered. Even if `read()` resolves to `n` < `p.byteLength`, it may + * use all of `p` as scratch space during the call. If some data is + * available but not `p.byteLength` bytes, `read()` conventionally resolves + * to what is available instead of waiting for more. + * + * When `read()` encounters end-of-file condition, it resolves to EOF + * (`null`). + * + * When `read()` encounters an error, it rejects with an error. + * + * Callers should always process the `n` > `0` bytes returned before + * considering the EOF (`null`). Doing so correctly handles I/O errors that + * happen after reading some bytes and also both of the allowed EOF + * behaviors. + * + * @example + * ```typescript + * import { open, BaseDirectory } from "@tauri-apps/plugin-fs" + * // if "$APPCONFIG/foo/bar.txt" contains the text "hello world": + * const file = await open("foo/bar.txt", { baseDir: BaseDirectory.AppConfig }); + * const buf = new Uint8Array(100); + * const numberOfBytesRead = await file.read(buf); // 11 bytes + * const text = new TextDecoder().decode(buf); // "hello world" + * await file.close(); + * ``` + * + * @since 2.0.0 + */ + async read(buffer) { + if (buffer.byteLength === 0) { + return 0; + } + const data = await invoke('plugin:fs|read', { + rid: this.rid, + len: buffer.byteLength + }); + // Rust side will never return an empty array for this command and + // ensure there is at least 8 elements there. + // + // This is an optimization to include the number of read bytes (as bigendian bytes) + // at the end of returned array to avoid serialization overhead of separate values. + const nread = fromBytes(data.slice(-8)); + const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : data; + buffer.set(bytes.slice(0, bytes.length - 8)); + return nread === 0 ? null : nread; + } + /** + * Seek sets the offset for the next `read()` or `write()` to offset, + * interpreted according to `whence`: `Start` means relative to the + * start of the file, `Current` means relative to the current offset, + * and `End` means relative to the end. Seek resolves to the new offset + * relative to the start of the file. + * + * Seeking to an offset before the start of the file is an error. Seeking to + * any positive offset is legal, but the behavior of subsequent I/O + * operations on the underlying object is implementation-dependent. + * It returns the number of cursor position. + * + * @example + * ```typescript + * import { open, SeekMode, BaseDirectory } from '@tauri-apps/plugin-fs'; + * + * // Given hello.txt pointing to file with "Hello world", which is 11 bytes long: + * const file = await open('hello.txt', { read: true, write: true, truncate: true, create: true, baseDir: BaseDirectory.AppLocalData }); + * await file.write(new TextEncoder().encode("Hello world")); + * + * // Seek 6 bytes from the start of the file + * console.log(await file.seek(6, SeekMode.Start)); // "6" + * // Seek 2 more bytes from the current position + * console.log(await file.seek(2, SeekMode.Current)); // "8" + * // Seek backwards 2 bytes from the end of the file + * console.log(await file.seek(-2, SeekMode.End)); // "9" (e.g. 11-2) + * + * await file.close(); + * ``` + * + * @since 2.0.0 + */ + async seek(offset, whence) { + return await invoke('plugin:fs|seek', { + rid: this.rid, + offset, + whence + }); + } + /** + * Returns a {@linkcode FileInfo } for this file. + * + * @example + * ```typescript + * import { open, BaseDirectory } from '@tauri-apps/plugin-fs'; + * const file = await open("file.txt", { read: true, baseDir: BaseDirectory.AppLocalData }); + * const fileInfo = await file.stat(); + * console.log(fileInfo.isFile); // true + * await file.close(); + * ``` + * + * @since 2.0.0 + */ + async stat() { + const res = await invoke('plugin:fs|fstat', { + rid: this.rid + }); + return parseFileInfo(res); + } + /** + * Truncates or extends this file, to reach the specified `len`. + * If `len` is not specified then the entire file contents are truncated. + * + * @example + * ```typescript + * import { open, BaseDirectory } from '@tauri-apps/plugin-fs'; + * + * // truncate the entire file + * const file = await open("my_file.txt", { read: true, write: true, create: true, baseDir: BaseDirectory.AppLocalData }); + * await file.truncate(); + * + * // truncate part of the file + * const file = await open("my_file.txt", { read: true, write: true, create: true, baseDir: BaseDirectory.AppLocalData }); + * await file.write(new TextEncoder().encode("Hello World")); + * await file.truncate(7); + * const data = new Uint8Array(32); + * await file.read(data); + * console.log(new TextDecoder().decode(data)); // Hello W + * await file.close(); + * ``` + * + * @since 2.0.0 + */ + async truncate(len) { + await invoke('plugin:fs|ftruncate', { + rid: this.rid, + len + }); + } + /** + * Writes `data.byteLength` bytes from `data` to the underlying data stream. It + * resolves to the number of bytes written from `data` (`0` <= `n` <= + * `data.byteLength`) or reject with the error encountered that caused the + * write to stop early. `write()` must reject with a non-null error if + * would resolve to `n` < `data.byteLength`. `write()` must not modify the + * slice data, even temporarily. + * + * @example + * ```typescript + * import { open, write, BaseDirectory } from '@tauri-apps/plugin-fs'; + * const encoder = new TextEncoder(); + * const data = encoder.encode("Hello world"); + * const file = await open("bar.txt", { write: true, baseDir: BaseDirectory.AppLocalData }); + * const bytesWritten = await file.write(data); // 11 + * await file.close(); + * ``` + * + * @since 2.0.0 + */ + async write(data) { + return await invoke('plugin:fs|write', { + rid: this.rid, + data + }); + } +} +/** + * Creates a file if none exists or truncates an existing file and resolves to + * an instance of {@linkcode FileHandle }. + * + * @example + * ```typescript + * import { create, BaseDirectory } from "@tauri-apps/plugin-fs" + * const file = await create("foo/bar.txt", { baseDir: BaseDirectory.AppConfig }); + * await file.write(new TextEncoder().encode("Hello world")); + * await file.close(); + * ``` + * + * @since 2.0.0 + */ +async function create(path, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + const rid = await invoke('plugin:fs|create', { + path: path instanceof URL ? path.toString() : path, + options + }); + return new FileHandle(rid); +} +/** + * Open a file and resolve to an instance of {@linkcode FileHandle}. The + * file does not need to previously exist if using the `create` or `createNew` + * open options. It is the callers responsibility to close the file when finished + * with it. + * + * @example + * ```typescript + * import { open, BaseDirectory } from "@tauri-apps/plugin-fs" + * const file = await open("foo/bar.txt", { read: true, write: true, baseDir: BaseDirectory.AppLocalData }); + * // Do work with file + * await file.close(); + * ``` + * + * @since 2.0.0 + */ +async function open(path, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + const rid = await invoke('plugin:fs|open', { + path: path instanceof URL ? path.toString() : path, + options + }); + return new FileHandle(rid); +} +/** + * Copies the contents and permissions of one file to another specified path, by default creating a new file if needed, else overwriting. + * @example + * ```typescript + * import { copyFile, BaseDirectory } from '@tauri-apps/plugin-fs'; + * await copyFile('app.conf', 'app.conf.bk', { fromPathBaseDir: BaseDirectory.AppConfig, toPathBaseDir: BaseDirectory.AppConfig }); + * ``` + * + * @since 2.0.0 + */ +async function copyFile(fromPath, toPath, options) { + if ((fromPath instanceof URL && fromPath.protocol !== 'file:') + || (toPath instanceof URL && toPath.protocol !== 'file:')) { + throw new TypeError('Must be a file URL.'); + } + await invoke('plugin:fs|copy_file', { + fromPath: fromPath instanceof URL ? fromPath.toString() : fromPath, + toPath: toPath instanceof URL ? toPath.toString() : toPath, + options + }); +} +/** + * Creates a new directory with the specified path. + * @example + * ```typescript + * import { mkdir, BaseDirectory } from '@tauri-apps/plugin-fs'; + * await mkdir('users', { baseDir: BaseDirectory.AppLocalData }); + * ``` + * + * @since 2.0.0 + */ +async function mkdir(path, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + await invoke('plugin:fs|mkdir', { + path: path instanceof URL ? path.toString() : path, + options + }); +} +/** + * Reads the directory given by path and returns an array of `DirEntry`. + * @example + * ```typescript + * import { readDir, BaseDirectory } from '@tauri-apps/plugin-fs'; + * import { join } from '@tauri-apps/api/path'; + * const dir = "users" + * const entries = await readDir('users', { baseDir: BaseDirectory.AppLocalData }); + * processEntriesRecursively(dir, entries); + * async function processEntriesRecursively(parent, entries) { + * for (const entry of entries) { + * console.log(`Entry: ${entry.name}`); + * if (entry.isDirectory) { + * const dir = await join(parent, entry.name); + * processEntriesRecursively(dir, await readDir(dir, { baseDir: BaseDirectory.AppLocalData })) + * } + * } + * } + * ``` + * + * @since 2.0.0 + */ +async function readDir(path, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + return await invoke('plugin:fs|read_dir', { + path: path instanceof URL ? path.toString() : path, + options + }); +} +/** + * Reads and resolves to the entire contents of a file as an array of bytes. + * TextDecoder can be used to transform the bytes to string if required. + * @example + * ```typescript + * import { readFile, BaseDirectory } from '@tauri-apps/plugin-fs'; + * const contents = await readFile('avatar.png', { baseDir: BaseDirectory.Resource }); + * ``` + * + * @since 2.0.0 + */ +async function readFile(path, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + const arr = await invoke('plugin:fs|read_file', { + path: path instanceof URL ? path.toString() : path, + options + }); + return arr instanceof ArrayBuffer ? new Uint8Array(arr) : Uint8Array.from(arr); +} +/** + * Reads and returns the entire contents of a file as a string using the specified encoding (default: UTF-8). + * @example + * ```typescript + * import { readTextFile, BaseDirectory } from '@tauri-apps/plugin-fs'; + * const contents = await readTextFile('app.conf', { baseDir: BaseDirectory.AppConfig }); + * ``` + * + * @since 2.0.0 + */ +async function readTextFile(path, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + const arr = await invoke('plugin:fs|read_text_file', { + path: path instanceof URL ? path.toString() : path, + options + }); + const bytes = arr instanceof ArrayBuffer ? arr : Uint8Array.from(arr); + return new TextDecoder(options?.encoding ?? 'utf-8').decode(bytes); +} +/** + * Returns an async {@linkcode AsyncIterableIterator} over the lines of a file, decoded using the specified encoding (default: UTF-8). + * @example + * ```typescript + * import { readTextFileLines, BaseDirectory } from '@tauri-apps/plugin-fs'; + * const lines = await readTextFileLines('app.conf', { baseDir: BaseDirectory.AppConfig }); + * for await (const line of lines) { + * console.log(line); + * } + * ``` + * You could also call {@linkcode AsyncIterableIterator.next} to advance the + * iterator so you can lazily read the next line whenever you want. + * + * @since 2.0.0 + */ +async function readTextFileLines(path, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + const pathStr = path instanceof URL ? path.toString() : path; + return await Promise.resolve({ + path: pathStr, + rid: null, + async next() { + const decoder = new TextDecoder(options?.encoding ?? 'utf-8'); + if (this.rid === null) { + // Use the normalized encoding label for options. + const encoding = decoder.encoding; + this.rid = await invoke('plugin:fs|read_text_file_lines', { + path: pathStr, + options: options != null ? { ...options, encoding } : undefined + }); + } + const arr = await invoke('plugin:fs|read_text_file_lines_next', { rid: this.rid }); + const bytes = arr instanceof ArrayBuffer ? new Uint8Array(arr) : Uint8Array.from(arr); + // Rust side will never return an empty array for this command and + // ensure there is at least one elements there. + // + // This is an optimization to include whether we finished iteration or not (1 or 0) + // at the end of returned array to avoid serialization overhead of separate values. + const done = bytes[bytes.byteLength - 1] === 1; + if (done) { + // a full iteration is over, reset rid for next iteration + this.rid = null; + return { value: null, done }; + } + const line = decoder.decode(bytes.slice(0, bytes.byteLength - 1)); + return { + value: line, + done + }; + }, + [Symbol.asyncIterator]() { + return this; + } + }); +} +/** + * Removes the named file or directory. + * If the directory is not empty and the `recursive` option isn't set to true, the promise will be rejected. + * @example + * ```typescript + * import { remove, BaseDirectory } from '@tauri-apps/plugin-fs'; + * await remove('users/file.txt', { baseDir: BaseDirectory.AppLocalData }); + * await remove('users', { baseDir: BaseDirectory.AppLocalData }); + * ``` + * + * @since 2.0.0 + */ +async function remove(path, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + await invoke('plugin:fs|remove', { + path: path instanceof URL ? path.toString() : path, + options + }); +} +/** + * Renames (moves) oldpath to newpath. Paths may be files or directories. + * If newpath already exists and is not a directory, rename() replaces it. + * OS-specific restrictions may apply when oldpath and newpath are in different directories. + * + * On Unix, this operation does not follow symlinks at either path. + * + * @example + * ```typescript + * import { rename, BaseDirectory } from '@tauri-apps/plugin-fs'; + * await rename('avatar.png', 'deleted.png', { oldPathBaseDir: BaseDirectory.App, newPathBaseDir: BaseDirectory.AppLocalData }); + * ``` + * + * @since 2.0.0 + */ +async function rename(oldPath, newPath, options) { + if ((oldPath instanceof URL && oldPath.protocol !== 'file:') + || (newPath instanceof URL && newPath.protocol !== 'file:')) { + throw new TypeError('Must be a file URL.'); + } + await invoke('plugin:fs|rename', { + oldPath: oldPath instanceof URL ? oldPath.toString() : oldPath, + newPath: newPath instanceof URL ? newPath.toString() : newPath, + options + }); +} +/** + * Resolves to a {@linkcode FileInfo} for the specified `path`. Will always + * follow symlinks but will reject if the symlink points to a path outside of the scope. + * + * @example + * ```typescript + * import { stat, BaseDirectory } from '@tauri-apps/plugin-fs'; + * const fileInfo = await stat("hello.txt", { baseDir: BaseDirectory.AppLocalData }); + * console.log(fileInfo.isFile); // true + * ``` + * + * @since 2.0.0 + */ +async function stat(path, options) { + const res = await invoke('plugin:fs|stat', { + path: path instanceof URL ? path.toString() : path, + options + }); + return parseFileInfo(res); +} +/** + * Resolves to a {@linkcode FileInfo} for the specified `path`. If `path` is a + * symlink, information for the symlink will be returned instead of what it + * points to. + * + * @example + * ```typescript + * import { lstat, BaseDirectory } from '@tauri-apps/plugin-fs'; + * const fileInfo = await lstat("hello.txt", { baseDir: BaseDirectory.AppLocalData }); + * console.log(fileInfo.isFile); // true + * ``` + * + * @since 2.0.0 + */ +async function lstat(path, options) { + const res = await invoke('plugin:fs|lstat', { + path: path instanceof URL ? path.toString() : path, + options + }); + return parseFileInfo(res); +} +/** + * Truncates or extends the specified file, to reach the specified `len`. + * If `len` is `0` or not specified, then the entire file contents are truncated. + * + * @example + * ```typescript + * import { truncate, readTextFile, writeTextFile, BaseDirectory } from '@tauri-apps/plugin-fs'; + * // truncate the entire file + * await truncate("my_file.txt", 0, { baseDir: BaseDirectory.AppLocalData }); + * + * // truncate part of the file + * const filePath = "file.txt"; + * await writeTextFile(filePath, "Hello World", { baseDir: BaseDirectory.AppLocalData }); + * await truncate(filePath, 7, { baseDir: BaseDirectory.AppLocalData }); + * const data = await readTextFile(filePath, { baseDir: BaseDirectory.AppLocalData }); + * console.log(data); // "Hello W" + * ``` + * + * @since 2.0.0 + */ +async function truncate(path, len, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + await invoke('plugin:fs|truncate', { + path: path instanceof URL ? path.toString() : path, + len, + options + }); +} +/** + * Write `data` to the given `path`, by default creating a new file if needed, else overwriting. + * @example + * ```typescript + * import { writeFile, BaseDirectory } from '@tauri-apps/plugin-fs'; + * + * let encoder = new TextEncoder(); + * let data = encoder.encode("Hello World"); + * await writeFile('file.txt', data, { baseDir: BaseDirectory.AppLocalData }); + * ``` + * + * @since 2.0.0 + */ +async function writeFile(path, data, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + if (data instanceof ReadableStream) { + const file = await open(path, { + read: false, + create: true, + write: true, + ...options + }); + const reader = data.getReader(); + try { + while (true) { + const { done, value } = await reader.read(); + if (done) + break; + await file.write(value); + } + } + finally { + reader.releaseLock(); + await file.close(); + } + } + else { + await invoke('plugin:fs|write_file', data, { + headers: { + path: encodeURIComponent(path instanceof URL ? path.toString() : path), + options: JSON.stringify(options) + } + }); + } +} +/** + * Writes UTF-8 string `data` to the given `path`, by default creating a new file if needed, else overwriting. + @example + * ```typescript + * import { writeTextFile, BaseDirectory } from '@tauri-apps/plugin-fs'; + * + * await writeTextFile('file.txt', "Hello world", { baseDir: BaseDirectory.AppLocalData }); + * ``` + * + * @since 2.0.0 + */ +async function writeTextFile(path, data, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + const encoder = new TextEncoder(); + await invoke('plugin:fs|write_text_file', encoder.encode(data), { + headers: { + path: encodeURIComponent(path instanceof URL ? path.toString() : path), + options: JSON.stringify(options) + } + }); +} +/** + * Check if a path exists. + * @example + * ```typescript + * import { exists, BaseDirectory } from '@tauri-apps/plugin-fs'; + * // Check if the `$APPDATA/avatar.png` file exists + * await exists('avatar.png', { baseDir: BaseDirectory.AppData }); + * ``` + * + * @since 2.0.0 + */ +async function exists(path, options) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + return await invoke('plugin:fs|exists', { + path: path instanceof URL ? path.toString() : path, + options + }); +} +class Watcher extends Resource { +} +async function watchInternal(paths, cb, options) { + const watchPaths = Array.isArray(paths) ? paths : [paths]; + for (const path of watchPaths) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + } + const onEvent = new Channel(); + onEvent.onmessage = cb; + const rid = await invoke('plugin:fs|watch', { + paths: watchPaths.map((p) => (p instanceof URL ? p.toString() : p)), + options, + onEvent + }); + const watcher = new Watcher(rid); + return () => { + void watcher.close(); + }; +} +// TODO: Return `Watcher` instead in v3 +/** + * Watch changes (after a delay) on files or directories. + * + * @since 2.0.0 + */ +async function watch(paths, cb, options) { + return await watchInternal(paths, cb, { + delayMs: 2000, + ...options + }); +} +// TODO: Return `Watcher` instead in v3 +/** + * Watch changes on files or directories. + * + * @since 2.0.0 + */ +async function watchImmediate(paths, cb, options) { + return await watchInternal(paths, cb, { + ...options, + delayMs: undefined + }); +} +/** + * Get the size of a file or directory. For files, the `stat` functions can be used as well. + * + * If `path` is a directory, this function will recursively iterate over every file and every directory inside of `path` and therefore will be very time consuming if used on larger directories. + * + * @example + * ```typescript + * import { size, BaseDirectory } from '@tauri-apps/plugin-fs'; + * // Get the size of the `$APPDATA/tauri` directory. + * const dirSize = await size('tauri', { baseDir: BaseDirectory.AppData }); + * console.log(dirSize); // 1024 + * ``` + * + * @since 2.1.0 + */ +async function size(path) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + return await invoke('plugin:fs|size', { + path: path instanceof URL ? path.toString() : path + }); +} +/** + * Starts accessing a security-scoped resource for the given file URL. + * This should be called when you're accessing a file that was opened + * using a security-scoped URL (e.g., from a file picker). + * + * Note that accessing security-scoped resources is automatically managed by the plugin on iOS, so you don't need to call this function + * unless you want to manage the scope manually. + * + * You must call {@linkcode stopAccessingSecurityScopedResource} when you're done accessing the resource. + * + * #### Platform-specific + * + * - **iOS:** Starts accessing the security-scoped resource. + * - **Other platforms:** does nothing. + * + * @example + * ```typescript + * import { startAccessingSecurityScopedResource } from '@tauri-apps/plugin-fs'; + * + * const filePath = 'file:///path/to/file.txt'; + * await startAccessingSecurityScopedResource(filePath); + * // ... use the resource ... + * ``` + * + * @since 2.5.0 + */ +async function startAccessingSecurityScopedResource(path) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + await invoke('plugin:fs|start_accessing_security_scoped_resource', { + path: path instanceof URL ? path.toString() : path + }); +} +/** + * Stops accessing a security-scoped resource for the given file URL. + * This should be called when you're done accessing a file that was opened + * using a security-scoped URL (e.g., from a file picker) when using manual tracking via {@linkcode startAccessingSecurityScopedResource}. + * + * #### Platform-specific + * + * - **iOS:** Stops accessing the security-scoped resource. + * - **Other platforms:** does nothing. + * + * @example + * ```typescript + * import { stopAccessingSecurityScopedResource } from '@tauri-apps/plugin-fs'; + * + * const filePath = 'file:///path/to/file.txt'; + * await startAccessingSecurityScopedResource(filePath); + * // ... use the resource ... + * // when you're done with the resource: + * await stopAccessingSecurityScopedResource(filePath); + * ``` + * + * @since 2.5.0 + */ +async function stopAccessingSecurityScopedResource(path) { + if (path instanceof URL && path.protocol !== 'file:') { + throw new TypeError('Must be a file URL.'); + } + await invoke('plugin:fs|stop_accessing_security_scoped_resource', { + path: path instanceof URL ? path.toString() : path + }); +} + +export { FileHandle, SeekMode, copyFile, create, exists, lstat, mkdir, open, readDir, readFile, readTextFile, readTextFileLines, remove, rename, size, startAccessingSecurityScopedResource, stat, stopAccessingSecurityScopedResource, truncate, watch, watchImmediate, writeFile, writeTextFile }; diff --git a/scripts/node_modules/@tauri-apps/plugin-fs/package.json b/scripts/node_modules/@tauri-apps/plugin-fs/package.json new file mode 100644 index 0000000000000000000000000000000000000000..d0a61d12ba1407182346bf082703ced788ee7a88 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/plugin-fs/package.json @@ -0,0 +1,30 @@ +{ + "name": "@tauri-apps/plugin-fs", + "version": "2.5.0", + "description": "Access the file system.", + "license": "MIT OR Apache-2.0", + "authors": [ + "Tauri Programme within The Commons Conservancy" + ], + "repository": "https://github.com/tauri-apps/plugins-workspace", + "type": "module", + "types": "./dist-js/index.d.ts", + "main": "./dist-js/index.cjs", + "module": "./dist-js/index.js", + "exports": { + "types": "./dist-js/index.d.ts", + "import": "./dist-js/index.js", + "require": "./dist-js/index.cjs" + }, + "scripts": { + "build": "rollup -c" + }, + "files": [ + "dist-js", + "README.md", + "LICENSE" + ], + "dependencies": { + "@tauri-apps/api": "^2.10.1" + } +} diff --git a/scripts/node_modules/@tauri-apps/plugin-shell/LICENSE.spdx b/scripts/node_modules/@tauri-apps/plugin-shell/LICENSE.spdx new file mode 100644 index 0000000000000000000000000000000000000000..cdd0df5ad76e63d23a80834469609c1d8109ff2e --- /dev/null +++ b/scripts/node_modules/@tauri-apps/plugin-shell/LICENSE.spdx @@ -0,0 +1,20 @@ +SPDXVersion: SPDX-2.1 +DataLicense: CC0-1.0 +PackageName: tauri +DataFormat: SPDXRef-1 +PackageSupplier: Organization: The Tauri Programme in the Commons Conservancy +PackageHomePage: https://tauri.app +PackageLicenseDeclared: Apache-2.0 +PackageLicenseDeclared: MIT +PackageCopyrightText: 2019-2022, The Tauri Programme in the Commons Conservancy +PackageSummary: Tauri is a rust project that enables developers to make secure +and small desktop applications using a web frontend. + +PackageComment: The package includes the following libraries; see +Relationship information. + +Created: 2019-05-20T09:00:00Z +PackageDownloadLocation: git://github.com/tauri-apps/tauri +PackageDownloadLocation: git+https://github.com/tauri-apps/tauri.git +PackageDownloadLocation: git+ssh://github.com/tauri-apps/tauri.git +Creator: Person: Daniel Thompson-Yvetot \ No newline at end of file diff --git a/scripts/node_modules/@tauri-apps/plugin-shell/README.md b/scripts/node_modules/@tauri-apps/plugin-shell/README.md new file mode 100644 index 0000000000000000000000000000000000000000..132d1ccb8d564037f7735a17dfd47e333abf1075 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/plugin-shell/README.md @@ -0,0 +1,90 @@ +![plugin-shell](https://github.com/tauri-apps/plugins-workspace/raw/v2/plugins/shell/banner.png) + +Access the system shell. Allows you to spawn child processes and manage files and URLs using their default application. + +| Platform | Supported | +| -------- | --------- | +| Linux | ✓ | +| Windows | ✓ | +| macOS | ✓ | +| Android | ✓ | +| iOS | ✓ | + +## Install + +_This plugin requires a Rust version of at least **1.77.2**_ + +There are three general methods of installation that we can recommend. + +1. Use crates.io and npm (easiest, and requires you to trust that our publishing pipeline worked) +2. Pull sources directly from Github using git tags / revision hashes (most secure) +3. Git submodule install this repo in your tauri project and then use file protocol to ingest the source (most secure, but inconvenient to use) + +Install the Core plugin by adding the following to your `Cargo.toml` file: + +`src-tauri/Cargo.toml` + +```toml +[dependencies] +tauri-plugin-shell = "2.0.0" +# alternatively with Git: +tauri-plugin-shell = { git = "https://github.com/tauri-apps/plugins-workspace", branch = "v2" } +``` + +You can install the JavaScript Guest bindings using your preferred JavaScript package manager: + +```sh +pnpm add @tauri-apps/plugin-shell +# or +npm add @tauri-apps/plugin-shell +# or +yarn add @tauri-apps/plugin-shell +``` + +## Usage + +First you need to register the core plugin with Tauri: + +`src-tauri/src/lib.rs` + +```rust +fn main() { + tauri::Builder::default() + .plugin(tauri_plugin_shell::init()) + .run(tauri::generate_context!()) + .expect("error while running tauri application"); +} +``` + +Afterwards all the plugin's APIs are available through the JavaScript guest bindings: + +```javascript +import { Command } from '@tauri-apps/plugin-shell' +Command.create('git', ['commit', '-m', 'the commit message']) +``` + +## Contributing + +PRs accepted. Please make sure to read the Contributing Guide before making a pull request. + +## Partners + + + + + + + +
+ + CrabNebula + +
+ +For the complete list of sponsors please visit our [website](https://tauri.app#sponsors) and [Open Collective](https://opencollective.com/tauri). + +## License + +Code: (c) 2015 - Present - The Tauri Programme within The Commons Conservancy. + +MIT or MIT/Apache 2.0 where applicable. diff --git a/scripts/node_modules/@tauri-apps/plugin-shell/dist-js/index.cjs b/scripts/node_modules/@tauri-apps/plugin-shell/dist-js/index.cjs new file mode 100644 index 0000000000000000000000000000000000000000..3e3a98d8218529322ebac1bea3c5fca26e53b4a7 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/plugin-shell/dist-js/index.cjs @@ -0,0 +1,451 @@ +'use strict'; + +var core = require('@tauri-apps/api/core'); + +// Copyright 2019-2023 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * Access the system shell. + * Allows you to spawn child processes and manage files and URLs using their default application. + * + * ## Security + * + * This API has a scope configuration that forces you to restrict the programs and arguments that can be used. + * + * ### Restricting access to the {@link open | `open`} API + * + * On the configuration object, `open: true` means that the {@link open} API can be used with any URL, + * as the argument is validated with the `^((mailto:\w+)|(tel:\w+)|(https?://\w+)).+` regex. + * You can change that regex by changing the boolean value to a string, e.g. `open: ^https://github.com/`. + * + * ### Restricting access to the {@link Command | `Command`} APIs + * + * The plugin permissions object has a `scope` field that defines an array of CLIs that can be used. + * Each CLI is a configuration object `{ name: string, cmd: string, sidecar?: bool, args?: boolean | Arg[] }`. + * + * - `name`: the unique identifier of the command, passed to the {@link Command.create | Command.create function}. + * If it's a sidecar, this must be the value defined on `tauri.conf.json > bundle > externalBin`. + * - `cmd`: the program that is executed on this configuration. If it's a sidecar, this value is ignored. + * - `sidecar`: whether the object configures a sidecar or a system program. + * - `args`: the arguments that can be passed to the program. By default no arguments are allowed. + * - `true` means that any argument list is allowed. + * - `false` means that no arguments are allowed. + * - otherwise an array can be configured. Each item is either a string representing the fixed argument value + * or a `{ validator: string }` that defines a regex validating the argument value. + * + * #### Example scope configuration + * + * CLI: `git commit -m "the commit message"` + * + * Capability: + * ```json + * { + * "permissions": [ + * { + * "identifier": "shell:allow-execute", + * "allow": [ + * { + * "name": "run-git-commit", + * "cmd": "git", + * "args": ["commit", "-m", { "validator": "\\S+" }] + * } + * ] + * } + * ] + * } + * ``` + * Usage: + * ```typescript + * import { Command } from '@tauri-apps/plugin-shell' + * Command.create('run-git-commit', ['commit', '-m', 'the commit message']) + * ``` + * + * Trying to execute any API with a program not configured on the scope results in a promise rejection due to denied access. + * + * @module + */ +/** + * @since 2.0.0 + */ +// eslint-disable-next-line @typescript-eslint/no-explicit-any +class EventEmitter { + constructor() { + /** @ignore */ + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any + this.eventListeners = Object.create(null); + } + /** + * Alias for `emitter.on(eventName, listener)`. + * + * @since 2.0.0 + */ + addListener(eventName, listener) { + return this.on(eventName, listener); + } + /** + * Alias for `emitter.off(eventName, listener)`. + * + * @since 2.0.0 + */ + removeListener(eventName, listener) { + return this.off(eventName, listener); + } + /** + * Adds the `listener` function to the end of the listeners array for the + * event named `eventName`. No checks are made to see if the `listener` has + * already been added. Multiple calls passing the same combination of `eventName`and `listener` will result in the `listener` being added, and called, multiple + * times. + * + * Returns a reference to the `EventEmitter`, so that calls can be chained. + * + * @since 2.0.0 + */ + on(eventName, listener) { + if (eventName in this.eventListeners) { + // eslint-disable-next-line security/detect-object-injection + this.eventListeners[eventName].push(listener); + } + else { + // eslint-disable-next-line security/detect-object-injection + this.eventListeners[eventName] = [listener]; + } + return this; + } + /** + * Adds a **one-time**`listener` function for the event named `eventName`. The + * next time `eventName` is triggered, this listener is removed and then invoked. + * + * Returns a reference to the `EventEmitter`, so that calls can be chained. + * + * @since 2.0.0 + */ + once(eventName, listener) { + const wrapper = (arg) => { + this.removeListener(eventName, wrapper); + listener(arg); + }; + return this.addListener(eventName, wrapper); + } + /** + * Removes the all specified listener from the listener array for the event eventName + * Returns a reference to the `EventEmitter`, so that calls can be chained. + * + * @since 2.0.0 + */ + off(eventName, listener) { + if (eventName in this.eventListeners) { + // eslint-disable-next-line security/detect-object-injection + this.eventListeners[eventName] = this.eventListeners[eventName].filter((l) => l !== listener); + } + return this; + } + /** + * Removes all listeners, or those of the specified eventName. + * + * Returns a reference to the `EventEmitter`, so that calls can be chained. + * + * @since 2.0.0 + */ + removeAllListeners(event) { + if (event) { + // eslint-disable-next-line security/detect-object-injection + delete this.eventListeners[event]; + } + else { + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + this.eventListeners = Object.create(null); + } + return this; + } + /** + * @ignore + * Synchronously calls each of the listeners registered for the event named`eventName`, in the order they were registered, passing the supplied arguments + * to each. + * + * @returns `true` if the event had listeners, `false` otherwise. + * + * @since 2.0.0 + */ + emit(eventName, arg) { + if (eventName in this.eventListeners) { + // eslint-disable-next-line security/detect-object-injection + const listeners = this.eventListeners[eventName]; + for (const listener of listeners) + listener(arg); + return true; + } + return false; + } + /** + * Returns the number of listeners listening to the event named `eventName`. + * + * @since 2.0.0 + */ + listenerCount(eventName) { + if (eventName in this.eventListeners) + // eslint-disable-next-line security/detect-object-injection + return this.eventListeners[eventName].length; + return 0; + } + /** + * Adds the `listener` function to the _beginning_ of the listeners array for the + * event named `eventName`. No checks are made to see if the `listener` has + * already been added. Multiple calls passing the same combination of `eventName`and `listener` will result in the `listener` being added, and called, multiple + * times. + * + * Returns a reference to the `EventEmitter`, so that calls can be chained. + * + * @since 2.0.0 + */ + prependListener(eventName, listener) { + if (eventName in this.eventListeners) { + // eslint-disable-next-line security/detect-object-injection + this.eventListeners[eventName].unshift(listener); + } + else { + // eslint-disable-next-line security/detect-object-injection + this.eventListeners[eventName] = [listener]; + } + return this; + } + /** + * Adds a **one-time**`listener` function for the event named `eventName` to the_beginning_ of the listeners array. The next time `eventName` is triggered, this + * listener is removed, and then invoked. + * + * Returns a reference to the `EventEmitter`, so that calls can be chained. + * + * @since 2.0.0 + */ + prependOnceListener(eventName, listener) { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const wrapper = (arg) => { + this.removeListener(eventName, wrapper); + // eslint-disable-next-line @typescript-eslint/no-unsafe-argument + listener(arg); + }; + return this.prependListener(eventName, wrapper); + } +} +/** + * @since 2.0.0 + */ +class Child { + constructor(pid) { + this.pid = pid; + } + /** + * Writes `data` to the `stdin`. + * + * @param data The message to write, either a string or a byte array. + * @example + * ```typescript + * import { Command } from '@tauri-apps/plugin-shell'; + * const command = Command.create('node'); + * const child = await command.spawn(); + * await child.write('message'); + * await child.write([0, 1, 2, 3, 4, 5]); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.0.0 + */ + async write(data) { + await core.invoke('plugin:shell|stdin_write', { + pid: this.pid, + buffer: data + }); + } + /** + * Kills the child process. + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.0.0 + */ + async kill() { + await core.invoke('plugin:shell|kill', { + cmd: 'killChild', + pid: this.pid + }); + } +} +/** + * The entry point for spawning child processes. + * It emits the `close` and `error` events. + * @example + * ```typescript + * import { Command } from '@tauri-apps/plugin-shell'; + * const command = Command.create('node'); + * command.on('close', data => { + * console.log(`command finished with code ${data.code} and signal ${data.signal}`) + * }); + * command.on('error', error => console.error(`command error: "${error}"`)); + * command.stdout.on('data', line => console.log(`command stdout: "${line}"`)); + * command.stderr.on('data', line => console.log(`command stderr: "${line}"`)); + * + * const child = await command.spawn(); + * console.log('pid:', child.pid); + * ``` + * + * @since 2.0.0 + * + */ +class Command extends EventEmitter { + /** + * @ignore + * Creates a new `Command` instance. + * + * @param program The program name to execute. + * It must be configured in your project's capabilities. + * @param args Program arguments. + * @param options Spawn options. + */ + constructor(program, args = [], options) { + super(); + /** Event emitter for the `stdout`. Emits the `data` event. */ + this.stdout = new EventEmitter(); + /** Event emitter for the `stderr`. Emits the `data` event. */ + this.stderr = new EventEmitter(); + this.program = program; + this.args = typeof args === 'string' ? [args] : args; + this.options = options ?? {}; + } + /** + * Creates a command to execute the given program. + * @example + * ```typescript + * import { Command } from '@tauri-apps/plugin-shell'; + * const command = Command.create('my-app', ['run', 'tauri']); + * const output = await command.execute(); + * ``` + * + * @param program The program to execute. + * It must be configured in your project's capabilities. + */ + static create(program, args = [], options) { + return new Command(program, args, options); + } + /** + * Creates a command to execute the given sidecar program. + * @example + * ```typescript + * import { Command } from '@tauri-apps/plugin-shell'; + * const command = Command.sidecar('my-sidecar'); + * const output = await command.execute(); + * ``` + * + * @param program The program to execute. + * It must be configured in your project's capabilities. + */ + static sidecar(program, args = [], options) { + const instance = new Command(program, args, options); + instance.options.sidecar = true; + return instance; + } + /** + * Executes the command as a child process, returning a handle to it. + * + * @returns A promise resolving to the child process handle. + * + * @since 2.0.0 + */ + async spawn() { + const program = this.program; + const args = this.args; + const options = this.options; + if (typeof args === 'object') { + Object.freeze(args); + } + const onEvent = new core.Channel(); + onEvent.onmessage = (event) => { + switch (event.event) { + case 'Error': + this.emit('error', event.payload); + break; + case 'Terminated': + this.emit('close', event.payload); + break; + case 'Stdout': + this.stdout.emit('data', event.payload); + break; + case 'Stderr': + this.stderr.emit('data', event.payload); + break; + } + }; + return await core.invoke('plugin:shell|spawn', { + program, + args, + options, + onEvent + }).then((pid) => new Child(pid)); + } + /** + * Executes the command as a child process, waiting for it to finish and collecting all of its output. + * @example + * ```typescript + * import { Command } from '@tauri-apps/plugin-shell'; + * const output = await Command.create('echo', 'message').execute(); + * assert(output.code === 0); + * assert(output.signal === null); + * assert(output.stdout === 'message'); + * assert(output.stderr === ''); + * ``` + * + * @returns A promise resolving to the child process output. + * + * @since 2.0.0 + */ + async execute() { + const program = this.program; + const args = this.args; + const options = this.options; + if (typeof args === 'object') { + Object.freeze(args); + } + return await core.invoke('plugin:shell|execute', { + program, + args, + options + }); + } +} +/** + * Opens a path or URL with the system's default app, + * or the one specified with `openWith`. + * + * The `openWith` value must be one of `firefox`, `google chrome`, `chromium` `safari`, + * `open`, `start`, `xdg-open`, `gio`, `gnome-open`, `kde-open` or `wslview`. + * + * @example + * ```typescript + * import { open } from '@tauri-apps/plugin-shell'; + * // opens the given URL on the default browser: + * await open('https://github.com/tauri-apps/tauri'); + * // opens the given URL using `firefox`: + * await open('https://github.com/tauri-apps/tauri', 'firefox'); + * // opens a file using the default program: + * await open('/path/to/file'); + * ``` + * + * @param path The path or URL to open. + * This value is matched against the string regex defined on `tauri.conf.json > plugins > shell > open`, + * which defaults to `^((mailto:\w+)|(tel:\w+)|(https?://\w+)).+`. + * @param openWith The app to open the file or URL with. + * Defaults to the system default application for the specified path type. + * + * @since 2.0.0 + */ +async function open(path, openWith) { + await core.invoke('plugin:shell|open', { + path, + with: openWith + }); +} + +exports.Child = Child; +exports.Command = Command; +exports.EventEmitter = EventEmitter; +exports.open = open; diff --git a/scripts/node_modules/@tauri-apps/plugin-shell/dist-js/index.d.ts b/scripts/node_modules/@tauri-apps/plugin-shell/dist-js/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7871805856517d4b44bfbf378e2bff5f98c2e466 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/plugin-shell/dist-js/index.d.ts @@ -0,0 +1,277 @@ +/** + * @since 2.0.0 + */ +interface SpawnOptions { + /** Current working directory. */ + cwd?: string; + /** Environment variables. set to `null` to clear the process env. */ + env?: Record; + /** + * Character encoding for stdout/stderr + * + * @since 2.0.0 + * */ + encoding?: string; +} +/** + * @since 2.0.0 + */ +interface ChildProcess { + /** Exit code of the process. `null` if the process was terminated by a signal on Unix. */ + code: number | null; + /** If the process was terminated by a signal, represents that signal. */ + signal: number | null; + /** The data that the process wrote to `stdout`. */ + stdout: O; + /** The data that the process wrote to `stderr`. */ + stderr: O; +} +/** + * @since 2.0.0 + */ +declare class EventEmitter> { + /** @ignore */ + private eventListeners; + /** + * Alias for `emitter.on(eventName, listener)`. + * + * @since 2.0.0 + */ + addListener(eventName: N, listener: (arg: E[typeof eventName]) => void): this; + /** + * Alias for `emitter.off(eventName, listener)`. + * + * @since 2.0.0 + */ + removeListener(eventName: N, listener: (arg: E[typeof eventName]) => void): this; + /** + * Adds the `listener` function to the end of the listeners array for the + * event named `eventName`. No checks are made to see if the `listener` has + * already been added. Multiple calls passing the same combination of `eventName`and `listener` will result in the `listener` being added, and called, multiple + * times. + * + * Returns a reference to the `EventEmitter`, so that calls can be chained. + * + * @since 2.0.0 + */ + on(eventName: N, listener: (arg: E[typeof eventName]) => void): this; + /** + * Adds a **one-time**`listener` function for the event named `eventName`. The + * next time `eventName` is triggered, this listener is removed and then invoked. + * + * Returns a reference to the `EventEmitter`, so that calls can be chained. + * + * @since 2.0.0 + */ + once(eventName: N, listener: (arg: E[typeof eventName]) => void): this; + /** + * Removes the all specified listener from the listener array for the event eventName + * Returns a reference to the `EventEmitter`, so that calls can be chained. + * + * @since 2.0.0 + */ + off(eventName: N, listener: (arg: E[typeof eventName]) => void): this; + /** + * Removes all listeners, or those of the specified eventName. + * + * Returns a reference to the `EventEmitter`, so that calls can be chained. + * + * @since 2.0.0 + */ + removeAllListeners(event?: N): this; + /** + * @ignore + * Synchronously calls each of the listeners registered for the event named`eventName`, in the order they were registered, passing the supplied arguments + * to each. + * + * @returns `true` if the event had listeners, `false` otherwise. + * + * @since 2.0.0 + */ + emit(eventName: N, arg: E[typeof eventName]): boolean; + /** + * Returns the number of listeners listening to the event named `eventName`. + * + * @since 2.0.0 + */ + listenerCount(eventName: N): number; + /** + * Adds the `listener` function to the _beginning_ of the listeners array for the + * event named `eventName`. No checks are made to see if the `listener` has + * already been added. Multiple calls passing the same combination of `eventName`and `listener` will result in the `listener` being added, and called, multiple + * times. + * + * Returns a reference to the `EventEmitter`, so that calls can be chained. + * + * @since 2.0.0 + */ + prependListener(eventName: N, listener: (arg: E[typeof eventName]) => void): this; + /** + * Adds a **one-time**`listener` function for the event named `eventName` to the_beginning_ of the listeners array. The next time `eventName` is triggered, this + * listener is removed, and then invoked. + * + * Returns a reference to the `EventEmitter`, so that calls can be chained. + * + * @since 2.0.0 + */ + prependOnceListener(eventName: N, listener: (arg: E[typeof eventName]) => void): this; +} +/** + * @since 2.0.0 + */ +declare class Child { + /** The child process `pid`. */ + pid: number; + constructor(pid: number); + /** + * Writes `data` to the `stdin`. + * + * @param data The message to write, either a string or a byte array. + * @example + * ```typescript + * import { Command } from '@tauri-apps/plugin-shell'; + * const command = Command.create('node'); + * const child = await command.spawn(); + * await child.write('message'); + * await child.write([0, 1, 2, 3, 4, 5]); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.0.0 + */ + write(data: IOPayload | number[]): Promise; + /** + * Kills the child process. + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.0.0 + */ + kill(): Promise; +} +interface CommandEvents { + close: TerminatedPayload; + error: string; +} +interface OutputEvents { + data: O; +} +/** + * The entry point for spawning child processes. + * It emits the `close` and `error` events. + * @example + * ```typescript + * import { Command } from '@tauri-apps/plugin-shell'; + * const command = Command.create('node'); + * command.on('close', data => { + * console.log(`command finished with code ${data.code} and signal ${data.signal}`) + * }); + * command.on('error', error => console.error(`command error: "${error}"`)); + * command.stdout.on('data', line => console.log(`command stdout: "${line}"`)); + * command.stderr.on('data', line => console.log(`command stderr: "${line}"`)); + * + * const child = await command.spawn(); + * console.log('pid:', child.pid); + * ``` + * + * @since 2.0.0 + * + */ +declare class Command extends EventEmitter { + /** @ignore Program to execute. */ + private readonly program; + /** @ignore Program arguments */ + private readonly args; + /** @ignore Spawn options. */ + private readonly options; + /** Event emitter for the `stdout`. Emits the `data` event. */ + readonly stdout: EventEmitter>; + /** Event emitter for the `stderr`. Emits the `data` event. */ + readonly stderr: EventEmitter>; + /** + * @ignore + * Creates a new `Command` instance. + * + * @param program The program name to execute. + * It must be configured in your project's capabilities. + * @param args Program arguments. + * @param options Spawn options. + */ + private constructor(); + static create(program: string, args?: string | string[]): Command; + static create(program: string, args?: string | string[], options?: SpawnOptions & { + encoding: 'raw'; + }): Command; + static create(program: string, args?: string | string[], options?: SpawnOptions): Command; + static sidecar(program: string, args?: string | string[]): Command; + static sidecar(program: string, args?: string | string[], options?: SpawnOptions & { + encoding: 'raw'; + }): Command; + static sidecar(program: string, args?: string | string[], options?: SpawnOptions): Command; + /** + * Executes the command as a child process, returning a handle to it. + * + * @returns A promise resolving to the child process handle. + * + * @since 2.0.0 + */ + spawn(): Promise; + /** + * Executes the command as a child process, waiting for it to finish and collecting all of its output. + * @example + * ```typescript + * import { Command } from '@tauri-apps/plugin-shell'; + * const output = await Command.create('echo', 'message').execute(); + * assert(output.code === 0); + * assert(output.signal === null); + * assert(output.stdout === 'message'); + * assert(output.stderr === ''); + * ``` + * + * @returns A promise resolving to the child process output. + * + * @since 2.0.0 + */ + execute(): Promise>; +} +/** + * Payload for the `Terminated` command event. + */ +interface TerminatedPayload { + /** Exit code of the process. `null` if the process was terminated by a signal on Unix. */ + code: number | null; + /** If the process was terminated by a signal, represents that signal. */ + signal: number | null; +} +/** Event payload type */ +type IOPayload = string | Uint8Array; +/** + * Opens a path or URL with the system's default app, + * or the one specified with `openWith`. + * + * The `openWith` value must be one of `firefox`, `google chrome`, `chromium` `safari`, + * `open`, `start`, `xdg-open`, `gio`, `gnome-open`, `kde-open` or `wslview`. + * + * @example + * ```typescript + * import { open } from '@tauri-apps/plugin-shell'; + * // opens the given URL on the default browser: + * await open('https://github.com/tauri-apps/tauri'); + * // opens the given URL using `firefox`: + * await open('https://github.com/tauri-apps/tauri', 'firefox'); + * // opens a file using the default program: + * await open('/path/to/file'); + * ``` + * + * @param path The path or URL to open. + * This value is matched against the string regex defined on `tauri.conf.json > plugins > shell > open`, + * which defaults to `^((mailto:\w+)|(tel:\w+)|(https?://\w+)).+`. + * @param openWith The app to open the file or URL with. + * Defaults to the system default application for the specified path type. + * + * @since 2.0.0 + */ +declare function open(path: string, openWith?: string): Promise; +export { Command, Child, EventEmitter, open }; +export type { IOPayload, CommandEvents, TerminatedPayload, OutputEvents, ChildProcess, SpawnOptions }; diff --git a/scripts/node_modules/@tauri-apps/plugin-shell/dist-js/index.js b/scripts/node_modules/@tauri-apps/plugin-shell/dist-js/index.js new file mode 100644 index 0000000000000000000000000000000000000000..a75a17806e4b14391e02486c2c555cb52e6c45e2 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/plugin-shell/dist-js/index.js @@ -0,0 +1,446 @@ +import { invoke, Channel } from '@tauri-apps/api/core'; + +// Copyright 2019-2023 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT +/** + * Access the system shell. + * Allows you to spawn child processes and manage files and URLs using their default application. + * + * ## Security + * + * This API has a scope configuration that forces you to restrict the programs and arguments that can be used. + * + * ### Restricting access to the {@link open | `open`} API + * + * On the configuration object, `open: true` means that the {@link open} API can be used with any URL, + * as the argument is validated with the `^((mailto:\w+)|(tel:\w+)|(https?://\w+)).+` regex. + * You can change that regex by changing the boolean value to a string, e.g. `open: ^https://github.com/`. + * + * ### Restricting access to the {@link Command | `Command`} APIs + * + * The plugin permissions object has a `scope` field that defines an array of CLIs that can be used. + * Each CLI is a configuration object `{ name: string, cmd: string, sidecar?: bool, args?: boolean | Arg[] }`. + * + * - `name`: the unique identifier of the command, passed to the {@link Command.create | Command.create function}. + * If it's a sidecar, this must be the value defined on `tauri.conf.json > bundle > externalBin`. + * - `cmd`: the program that is executed on this configuration. If it's a sidecar, this value is ignored. + * - `sidecar`: whether the object configures a sidecar or a system program. + * - `args`: the arguments that can be passed to the program. By default no arguments are allowed. + * - `true` means that any argument list is allowed. + * - `false` means that no arguments are allowed. + * - otherwise an array can be configured. Each item is either a string representing the fixed argument value + * or a `{ validator: string }` that defines a regex validating the argument value. + * + * #### Example scope configuration + * + * CLI: `git commit -m "the commit message"` + * + * Capability: + * ```json + * { + * "permissions": [ + * { + * "identifier": "shell:allow-execute", + * "allow": [ + * { + * "name": "run-git-commit", + * "cmd": "git", + * "args": ["commit", "-m", { "validator": "\\S+" }] + * } + * ] + * } + * ] + * } + * ``` + * Usage: + * ```typescript + * import { Command } from '@tauri-apps/plugin-shell' + * Command.create('run-git-commit', ['commit', '-m', 'the commit message']) + * ``` + * + * Trying to execute any API with a program not configured on the scope results in a promise rejection due to denied access. + * + * @module + */ +/** + * @since 2.0.0 + */ +// eslint-disable-next-line @typescript-eslint/no-explicit-any +class EventEmitter { + constructor() { + /** @ignore */ + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any + this.eventListeners = Object.create(null); + } + /** + * Alias for `emitter.on(eventName, listener)`. + * + * @since 2.0.0 + */ + addListener(eventName, listener) { + return this.on(eventName, listener); + } + /** + * Alias for `emitter.off(eventName, listener)`. + * + * @since 2.0.0 + */ + removeListener(eventName, listener) { + return this.off(eventName, listener); + } + /** + * Adds the `listener` function to the end of the listeners array for the + * event named `eventName`. No checks are made to see if the `listener` has + * already been added. Multiple calls passing the same combination of `eventName`and `listener` will result in the `listener` being added, and called, multiple + * times. + * + * Returns a reference to the `EventEmitter`, so that calls can be chained. + * + * @since 2.0.0 + */ + on(eventName, listener) { + if (eventName in this.eventListeners) { + // eslint-disable-next-line security/detect-object-injection + this.eventListeners[eventName].push(listener); + } + else { + // eslint-disable-next-line security/detect-object-injection + this.eventListeners[eventName] = [listener]; + } + return this; + } + /** + * Adds a **one-time**`listener` function for the event named `eventName`. The + * next time `eventName` is triggered, this listener is removed and then invoked. + * + * Returns a reference to the `EventEmitter`, so that calls can be chained. + * + * @since 2.0.0 + */ + once(eventName, listener) { + const wrapper = (arg) => { + this.removeListener(eventName, wrapper); + listener(arg); + }; + return this.addListener(eventName, wrapper); + } + /** + * Removes the all specified listener from the listener array for the event eventName + * Returns a reference to the `EventEmitter`, so that calls can be chained. + * + * @since 2.0.0 + */ + off(eventName, listener) { + if (eventName in this.eventListeners) { + // eslint-disable-next-line security/detect-object-injection + this.eventListeners[eventName] = this.eventListeners[eventName].filter((l) => l !== listener); + } + return this; + } + /** + * Removes all listeners, or those of the specified eventName. + * + * Returns a reference to the `EventEmitter`, so that calls can be chained. + * + * @since 2.0.0 + */ + removeAllListeners(event) { + if (event) { + // eslint-disable-next-line security/detect-object-injection + delete this.eventListeners[event]; + } + else { + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + this.eventListeners = Object.create(null); + } + return this; + } + /** + * @ignore + * Synchronously calls each of the listeners registered for the event named`eventName`, in the order they were registered, passing the supplied arguments + * to each. + * + * @returns `true` if the event had listeners, `false` otherwise. + * + * @since 2.0.0 + */ + emit(eventName, arg) { + if (eventName in this.eventListeners) { + // eslint-disable-next-line security/detect-object-injection + const listeners = this.eventListeners[eventName]; + for (const listener of listeners) + listener(arg); + return true; + } + return false; + } + /** + * Returns the number of listeners listening to the event named `eventName`. + * + * @since 2.0.0 + */ + listenerCount(eventName) { + if (eventName in this.eventListeners) + // eslint-disable-next-line security/detect-object-injection + return this.eventListeners[eventName].length; + return 0; + } + /** + * Adds the `listener` function to the _beginning_ of the listeners array for the + * event named `eventName`. No checks are made to see if the `listener` has + * already been added. Multiple calls passing the same combination of `eventName`and `listener` will result in the `listener` being added, and called, multiple + * times. + * + * Returns a reference to the `EventEmitter`, so that calls can be chained. + * + * @since 2.0.0 + */ + prependListener(eventName, listener) { + if (eventName in this.eventListeners) { + // eslint-disable-next-line security/detect-object-injection + this.eventListeners[eventName].unshift(listener); + } + else { + // eslint-disable-next-line security/detect-object-injection + this.eventListeners[eventName] = [listener]; + } + return this; + } + /** + * Adds a **one-time**`listener` function for the event named `eventName` to the_beginning_ of the listeners array. The next time `eventName` is triggered, this + * listener is removed, and then invoked. + * + * Returns a reference to the `EventEmitter`, so that calls can be chained. + * + * @since 2.0.0 + */ + prependOnceListener(eventName, listener) { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const wrapper = (arg) => { + this.removeListener(eventName, wrapper); + // eslint-disable-next-line @typescript-eslint/no-unsafe-argument + listener(arg); + }; + return this.prependListener(eventName, wrapper); + } +} +/** + * @since 2.0.0 + */ +class Child { + constructor(pid) { + this.pid = pid; + } + /** + * Writes `data` to the `stdin`. + * + * @param data The message to write, either a string or a byte array. + * @example + * ```typescript + * import { Command } from '@tauri-apps/plugin-shell'; + * const command = Command.create('node'); + * const child = await command.spawn(); + * await child.write('message'); + * await child.write([0, 1, 2, 3, 4, 5]); + * ``` + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.0.0 + */ + async write(data) { + await invoke('plugin:shell|stdin_write', { + pid: this.pid, + buffer: data + }); + } + /** + * Kills the child process. + * + * @returns A promise indicating the success or failure of the operation. + * + * @since 2.0.0 + */ + async kill() { + await invoke('plugin:shell|kill', { + cmd: 'killChild', + pid: this.pid + }); + } +} +/** + * The entry point for spawning child processes. + * It emits the `close` and `error` events. + * @example + * ```typescript + * import { Command } from '@tauri-apps/plugin-shell'; + * const command = Command.create('node'); + * command.on('close', data => { + * console.log(`command finished with code ${data.code} and signal ${data.signal}`) + * }); + * command.on('error', error => console.error(`command error: "${error}"`)); + * command.stdout.on('data', line => console.log(`command stdout: "${line}"`)); + * command.stderr.on('data', line => console.log(`command stderr: "${line}"`)); + * + * const child = await command.spawn(); + * console.log('pid:', child.pid); + * ``` + * + * @since 2.0.0 + * + */ +class Command extends EventEmitter { + /** + * @ignore + * Creates a new `Command` instance. + * + * @param program The program name to execute. + * It must be configured in your project's capabilities. + * @param args Program arguments. + * @param options Spawn options. + */ + constructor(program, args = [], options) { + super(); + /** Event emitter for the `stdout`. Emits the `data` event. */ + this.stdout = new EventEmitter(); + /** Event emitter for the `stderr`. Emits the `data` event. */ + this.stderr = new EventEmitter(); + this.program = program; + this.args = typeof args === 'string' ? [args] : args; + this.options = options ?? {}; + } + /** + * Creates a command to execute the given program. + * @example + * ```typescript + * import { Command } from '@tauri-apps/plugin-shell'; + * const command = Command.create('my-app', ['run', 'tauri']); + * const output = await command.execute(); + * ``` + * + * @param program The program to execute. + * It must be configured in your project's capabilities. + */ + static create(program, args = [], options) { + return new Command(program, args, options); + } + /** + * Creates a command to execute the given sidecar program. + * @example + * ```typescript + * import { Command } from '@tauri-apps/plugin-shell'; + * const command = Command.sidecar('my-sidecar'); + * const output = await command.execute(); + * ``` + * + * @param program The program to execute. + * It must be configured in your project's capabilities. + */ + static sidecar(program, args = [], options) { + const instance = new Command(program, args, options); + instance.options.sidecar = true; + return instance; + } + /** + * Executes the command as a child process, returning a handle to it. + * + * @returns A promise resolving to the child process handle. + * + * @since 2.0.0 + */ + async spawn() { + const program = this.program; + const args = this.args; + const options = this.options; + if (typeof args === 'object') { + Object.freeze(args); + } + const onEvent = new Channel(); + onEvent.onmessage = (event) => { + switch (event.event) { + case 'Error': + this.emit('error', event.payload); + break; + case 'Terminated': + this.emit('close', event.payload); + break; + case 'Stdout': + this.stdout.emit('data', event.payload); + break; + case 'Stderr': + this.stderr.emit('data', event.payload); + break; + } + }; + return await invoke('plugin:shell|spawn', { + program, + args, + options, + onEvent + }).then((pid) => new Child(pid)); + } + /** + * Executes the command as a child process, waiting for it to finish and collecting all of its output. + * @example + * ```typescript + * import { Command } from '@tauri-apps/plugin-shell'; + * const output = await Command.create('echo', 'message').execute(); + * assert(output.code === 0); + * assert(output.signal === null); + * assert(output.stdout === 'message'); + * assert(output.stderr === ''); + * ``` + * + * @returns A promise resolving to the child process output. + * + * @since 2.0.0 + */ + async execute() { + const program = this.program; + const args = this.args; + const options = this.options; + if (typeof args === 'object') { + Object.freeze(args); + } + return await invoke('plugin:shell|execute', { + program, + args, + options + }); + } +} +/** + * Opens a path or URL with the system's default app, + * or the one specified with `openWith`. + * + * The `openWith` value must be one of `firefox`, `google chrome`, `chromium` `safari`, + * `open`, `start`, `xdg-open`, `gio`, `gnome-open`, `kde-open` or `wslview`. + * + * @example + * ```typescript + * import { open } from '@tauri-apps/plugin-shell'; + * // opens the given URL on the default browser: + * await open('https://github.com/tauri-apps/tauri'); + * // opens the given URL using `firefox`: + * await open('https://github.com/tauri-apps/tauri', 'firefox'); + * // opens a file using the default program: + * await open('/path/to/file'); + * ``` + * + * @param path The path or URL to open. + * This value is matched against the string regex defined on `tauri.conf.json > plugins > shell > open`, + * which defaults to `^((mailto:\w+)|(tel:\w+)|(https?://\w+)).+`. + * @param openWith The app to open the file or URL with. + * Defaults to the system default application for the specified path type. + * + * @since 2.0.0 + */ +async function open(path, openWith) { + await invoke('plugin:shell|open', { + path, + with: openWith + }); +} + +export { Child, Command, EventEmitter, open }; diff --git a/scripts/node_modules/@tauri-apps/plugin-shell/dist-js/init.d.ts b/scripts/node_modules/@tauri-apps/plugin-shell/dist-js/init.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..cb0ff5c3b541f646105198ee23ac0fc3d805023e --- /dev/null +++ b/scripts/node_modules/@tauri-apps/plugin-shell/dist-js/init.d.ts @@ -0,0 +1 @@ +export {}; diff --git a/scripts/node_modules/@tauri-apps/plugin-shell/package.json b/scripts/node_modules/@tauri-apps/plugin-shell/package.json new file mode 100644 index 0000000000000000000000000000000000000000..7d82118ac80fe1bb4ed2e5edd7ca2a3f6c7e4220 --- /dev/null +++ b/scripts/node_modules/@tauri-apps/plugin-shell/package.json @@ -0,0 +1,29 @@ +{ + "name": "@tauri-apps/plugin-shell", + "version": "2.3.5", + "license": "MIT OR Apache-2.0", + "authors": [ + "Tauri Programme within The Commons Conservancy" + ], + "repository": "https://github.com/tauri-apps/plugins-workspace", + "type": "module", + "types": "./dist-js/index.d.ts", + "main": "./dist-js/index.cjs", + "module": "./dist-js/index.js", + "exports": { + "types": "./dist-js/index.d.ts", + "import": "./dist-js/index.js", + "require": "./dist-js/index.cjs" + }, + "scripts": { + "build": "rollup -c" + }, + "files": [ + "dist-js", + "README.md", + "LICENSE" + ], + "dependencies": { + "@tauri-apps/api": "^2.10.1" + } +} diff --git a/scripts/node_modules/@types/babel__core/LICENSE b/scripts/node_modules/@types/babel__core/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..9e841e7a26e4eb057b24511e7b92d42b257a80e5 --- /dev/null +++ b/scripts/node_modules/@types/babel__core/LICENSE @@ -0,0 +1,21 @@ + MIT License + + Copyright (c) Microsoft Corporation. + + 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/scripts/node_modules/@types/babel__core/README.md b/scripts/node_modules/@types/babel__core/README.md new file mode 100644 index 0000000000000000000000000000000000000000..3e4c0244391a0eb77cf65dbabce2a4a891f365e0 --- /dev/null +++ b/scripts/node_modules/@types/babel__core/README.md @@ -0,0 +1,15 @@ +# Installation +> `npm install --save @types/babel__core` + +# Summary +This package contains type definitions for @babel/core (https://github.com/babel/babel/tree/master/packages/babel-core). + +# Details +Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/babel__core. + +### Additional Details + * Last updated: Mon, 20 Nov 2023 23:36:23 GMT + * Dependencies: [@babel/parser](https://npmjs.com/package/@babel/parser), [@babel/types](https://npmjs.com/package/@babel/types), [@types/babel__generator](https://npmjs.com/package/@types/babel__generator), [@types/babel__template](https://npmjs.com/package/@types/babel__template), [@types/babel__traverse](https://npmjs.com/package/@types/babel__traverse) + +# Credits +These definitions were written by [Troy Gerwien](https://github.com/yortus), [Marvin Hagemeister](https://github.com/marvinhagemeister), [Melvin Groenhoff](https://github.com/mgroenhoff), [Jessica Franco](https://github.com/Jessidhia), and [Ifiok Jr.](https://github.com/ifiokjr). diff --git a/scripts/node_modules/@types/babel__core/index.d.ts b/scripts/node_modules/@types/babel__core/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..48dc0500c5c387adef8c088f059f3bde89776d87 --- /dev/null +++ b/scripts/node_modules/@types/babel__core/index.d.ts @@ -0,0 +1,831 @@ +import { GeneratorOptions } from "@babel/generator"; +import { ParserOptions } from "@babel/parser"; +import template from "@babel/template"; +import traverse, { Hub, NodePath, Scope, Visitor } from "@babel/traverse"; +import * as t from "@babel/types"; + +export { GeneratorOptions, NodePath, ParserOptions, t as types, template, traverse, Visitor }; + +export type Node = t.Node; +export type ParseResult = ReturnType; +export const version: string; +export const DEFAULT_EXTENSIONS: [".js", ".jsx", ".es6", ".es", ".mjs"]; + +/** + * Source map standard format as to revision 3 + * @see {@link https://sourcemaps.info/spec.html} + * @see {@link https://github.com/mozilla/source-map/blob/HEAD/source-map.d.ts} + */ +interface InputSourceMap { + version: number; + sources: string[]; + names: string[]; + sourceRoot?: string | undefined; + sourcesContent?: string[] | undefined; + mappings: string; + file: string; +} + +export interface TransformOptions { + /** + * Specify which assumptions it can make about your code, to better optimize the compilation result. **NOTE**: This replaces the various `loose` options in plugins in favor of + * top-level options that can apply to multiple plugins + * + * @see https://babeljs.io/docs/en/assumptions + */ + assumptions?: { [name: string]: boolean } | null | undefined; + + /** + * Include the AST in the returned object + * + * Default: `false` + */ + ast?: boolean | null | undefined; + + /** + * Attach a comment after all non-user injected code + * + * Default: `null` + */ + auxiliaryCommentAfter?: string | null | undefined; + + /** + * Attach a comment before all non-user injected code + * + * Default: `null` + */ + auxiliaryCommentBefore?: string | null | undefined; + + /** + * Specify the "root" folder that defines the location to search for "babel.config.js", and the default folder to allow `.babelrc` files inside of. + * + * Default: `"."` + */ + root?: string | null | undefined; + + /** + * This option, combined with the "root" value, defines how Babel chooses its project root. + * The different modes define different ways that Babel can process the "root" value to get + * the final project root. + * + * @see https://babeljs.io/docs/en/next/options#rootmode + */ + rootMode?: "root" | "upward" | "upward-optional" | undefined; + + /** + * The config file to load Babel's config from. Defaults to searching for "babel.config.js" inside the "root" folder. `false` will disable searching for config files. + * + * Default: `undefined` + */ + configFile?: string | boolean | null | undefined; + + /** + * Specify whether or not to use .babelrc and + * .babelignore files. + * + * Default: `true` + */ + babelrc?: boolean | null | undefined; + + /** + * Specify which packages should be search for .babelrc files when they are being compiled. `true` to always search, or a path string or an array of paths to packages to search + * inside of. Defaults to only searching the "root" package. + * + * Default: `(root)` + */ + babelrcRoots?: boolean | MatchPattern | MatchPattern[] | null | undefined; + + /** + * Toggles whether or not browserslist config sources are used, which includes searching for any browserslist files or referencing the browserslist key inside package.json. + * This is useful for projects that use a browserslist config for files that won't be compiled with Babel. + * + * If a string is specified, it must represent the path of a browserslist configuration file. Relative paths are resolved relative to the configuration file which specifies + * this option, or to `cwd` when it's passed as part of the programmatic options. + * + * Default: `true` + */ + browserslistConfigFile?: boolean | null | undefined; + + /** + * The Browserslist environment to use. + * + * Default: `undefined` + */ + browserslistEnv?: string | null | undefined; + + /** + * By default `babel.transformFromAst` will clone the input AST to avoid mutations. + * Specifying `cloneInputAst: false` can improve parsing performance if the input AST is not used elsewhere. + * + * Default: `true` + */ + cloneInputAst?: boolean | null | undefined; + + /** + * Defaults to environment variable `BABEL_ENV` if set, or else `NODE_ENV` if set, or else it defaults to `"development"` + * + * Default: env vars + */ + envName?: string | undefined; + + /** + * If any of patterns match, the current configuration object is considered inactive and is ignored during config processing. + */ + exclude?: MatchPattern | MatchPattern[] | undefined; + + /** + * Enable code generation + * + * Default: `true` + */ + code?: boolean | null | undefined; + + /** + * Output comments in generated output + * + * Default: `true` + */ + comments?: boolean | null | undefined; + + /** + * Do not include superfluous whitespace characters and line terminators. When set to `"auto"` compact is set to `true` on input sizes of >500KB + * + * Default: `"auto"` + */ + compact?: boolean | "auto" | null | undefined; + + /** + * The working directory that Babel's programmatic options are loaded relative to. + * + * Default: `"."` + */ + cwd?: string | null | undefined; + + /** + * Utilities may pass a caller object to identify themselves to Babel and + * pass capability-related flags for use by configs, presets and plugins. + * + * @see https://babeljs.io/docs/en/next/options#caller + */ + caller?: TransformCaller | undefined; + + /** + * This is an object of keys that represent different environments. For example, you may have: `{ env: { production: { \/* specific options *\/ } } }` + * which will use those options when the `envName` is `production` + * + * Default: `{}` + */ + env?: { [index: string]: TransformOptions | null | undefined } | null | undefined; + + /** + * A path to a `.babelrc` file to extend + * + * Default: `null` + */ + extends?: string | null | undefined; + + /** + * Filename for use in errors etc + * + * Default: `"unknown"` + */ + filename?: string | null | undefined; + + /** + * Filename relative to `sourceRoot` + * + * Default: `(filename)` + */ + filenameRelative?: string | null | undefined; + + /** + * An object containing the options to be passed down to the babel code generator, @babel/generator + * + * Default: `{}` + */ + generatorOpts?: GeneratorOptions | null | undefined; + + /** + * Specify a custom callback to generate a module id with. Called as `getModuleId(moduleName)`. If falsy value is returned then the generated module id is used + * + * Default: `null` + */ + getModuleId?: ((moduleName: string) => string | null | undefined) | null | undefined; + + /** + * ANSI highlight syntax error code frames + * + * Default: `true` + */ + highlightCode?: boolean | null | undefined; + + /** + * Opposite to the `only` option. `ignore` is disregarded if `only` is specified + * + * Default: `null` + */ + ignore?: MatchPattern[] | null | undefined; + + /** + * This option is a synonym for "test" + */ + include?: MatchPattern | MatchPattern[] | undefined; + + /** + * A source map object that the output source map will be based on + * + * Default: `null` + */ + inputSourceMap?: InputSourceMap | null | undefined; + + /** + * Should the output be minified (not printing last semicolons in blocks, printing literal string values instead of escaped ones, stripping `()` from `new` when safe) + * + * Default: `false` + */ + minified?: boolean | null | undefined; + + /** + * Specify a custom name for module ids + * + * Default: `null` + */ + moduleId?: string | null | undefined; + + /** + * If truthy, insert an explicit id for modules. By default, all modules are anonymous. (Not available for `common` modules) + * + * Default: `false` + */ + moduleIds?: boolean | null | undefined; + + /** + * Optional prefix for the AMD module formatter that will be prepend to the filename on module definitions + * + * Default: `(sourceRoot)` + */ + moduleRoot?: string | null | undefined; + + /** + * A glob, regex, or mixed array of both, matching paths to **only** compile. Can also be an array of arrays containing paths to explicitly match. When attempting to compile + * a non-matching file it's returned verbatim + * + * Default: `null` + */ + only?: MatchPattern[] | null | undefined; + + /** + * Allows users to provide an array of options that will be merged into the current configuration one at a time. + * This feature is best used alongside the "test"/"include"/"exclude" options to provide conditions for which an override should apply + */ + overrides?: TransformOptions[] | undefined; + + /** + * An object containing the options to be passed down to the babel parser, @babel/parser + * + * Default: `{}` + */ + parserOpts?: ParserOptions | null | undefined; + + /** + * List of plugins to load and use + * + * Default: `[]` + */ + plugins?: PluginItem[] | null | undefined; + + /** + * List of presets (a set of plugins) to load and use + * + * Default: `[]` + */ + presets?: PluginItem[] | null | undefined; + + /** + * Retain line numbers. This will lead to wacky code but is handy for scenarios where you can't use source maps. (**NOTE**: This will not retain the columns) + * + * Default: `false` + */ + retainLines?: boolean | null | undefined; + + /** + * An optional callback that controls whether a comment should be output or not. Called as `shouldPrintComment(commentContents)`. **NOTE**: This overrides the `comment` option when used + * + * Default: `null` + */ + shouldPrintComment?: ((commentContents: string) => boolean) | null | undefined; + + /** + * Set `sources[0]` on returned source map + * + * Default: `(filenameRelative)` + */ + sourceFileName?: string | null | undefined; + + /** + * If truthy, adds a `map` property to returned output. If set to `"inline"`, a comment with a sourceMappingURL directive is added to the bottom of the returned code. If set to `"both"` + * then a `map` property is returned as well as a source map comment appended. **This does not emit sourcemap files by itself!** + * + * Default: `false` + */ + sourceMaps?: boolean | "inline" | "both" | null | undefined; + + /** + * The root from which all sources are relative + * + * Default: `(moduleRoot)` + */ + sourceRoot?: string | null | undefined; + + /** + * Indicate the mode the code should be parsed in. Can be one of "script", "module", or "unambiguous". `"unambiguous"` will make Babel attempt to guess, based on the presence of ES6 + * `import` or `export` statements. Files with ES6 `import`s and `export`s are considered `"module"` and are otherwise `"script"`. + * + * Default: `("module")` + */ + sourceType?: "script" | "module" | "unambiguous" | null | undefined; + + /** + * If all patterns fail to match, the current configuration object is considered inactive and is ignored during config processing. + */ + test?: MatchPattern | MatchPattern[] | undefined; + + /** + * Describes the environments you support/target for your project. + * This can either be a [browserslist-compatible](https://github.com/ai/browserslist) query (with [caveats](https://babeljs.io/docs/en/babel-preset-env#ineffective-browserslist-queries)) + * + * Default: `{}` + */ + targets?: + | string + | string[] + | { + esmodules?: boolean; + node?: Omit | "current" | true; + safari?: Omit | "tp"; + browsers?: string | string[]; + android?: string; + chrome?: string; + deno?: string; + edge?: string; + electron?: string; + firefox?: string; + ie?: string; + ios?: string; + opera?: string; + rhino?: string; + samsung?: string; + }; + + /** + * An optional callback that can be used to wrap visitor methods. **NOTE**: This is useful for things like introspection, and not really needed for implementing anything. Called as + * `wrapPluginVisitorMethod(pluginAlias, visitorType, callback)`. + */ + wrapPluginVisitorMethod?: + | (( + pluginAlias: string, + visitorType: "enter" | "exit", + callback: (path: NodePath, state: any) => void, + ) => (path: NodePath, state: any) => void) + | null + | undefined; +} + +export interface TransformCaller { + // the only required property + name: string; + // e.g. set to true by `babel-loader` and false by `babel-jest` + supportsStaticESM?: boolean | undefined; + supportsDynamicImport?: boolean | undefined; + supportsExportNamespaceFrom?: boolean | undefined; + supportsTopLevelAwait?: boolean | undefined; + // augment this with a "declare module '@babel/core' { ... }" if you need more keys +} + +export type FileResultCallback = (err: Error | null, result: BabelFileResult | null) => any; + +export interface MatchPatternContext { + envName: string; + dirname: string; + caller: TransformCaller | undefined; +} +export type MatchPattern = string | RegExp | ((filename: string | undefined, context: MatchPatternContext) => boolean); + +/** + * Transforms the passed in code. Calling a callback with an object with the generated code, source map, and AST. + */ +export function transform(code: string, callback: FileResultCallback): void; + +/** + * Transforms the passed in code. Calling a callback with an object with the generated code, source map, and AST. + */ +export function transform(code: string, opts: TransformOptions | undefined, callback: FileResultCallback): void; + +/** + * Here for backward-compatibility. Ideally use `transformSync` if you want a synchronous API. + */ +export function transform(code: string, opts?: TransformOptions): BabelFileResult | null; + +/** + * Transforms the passed in code. Returning an object with the generated code, source map, and AST. + */ +export function transformSync(code: string, opts?: TransformOptions): BabelFileResult | null; + +/** + * Transforms the passed in code. Calling a callback with an object with the generated code, source map, and AST. + */ +export function transformAsync(code: string, opts?: TransformOptions): Promise; + +/** + * Asynchronously transforms the entire contents of a file. + */ +export function transformFile(filename: string, callback: FileResultCallback): void; + +/** + * Asynchronously transforms the entire contents of a file. + */ +export function transformFile(filename: string, opts: TransformOptions | undefined, callback: FileResultCallback): void; + +/** + * Synchronous version of `babel.transformFile`. Returns the transformed contents of the `filename`. + */ +export function transformFileSync(filename: string, opts?: TransformOptions): BabelFileResult | null; + +/** + * Asynchronously transforms the entire contents of a file. + */ +export function transformFileAsync(filename: string, opts?: TransformOptions): Promise; + +/** + * Given an AST, transform it. + */ +export function transformFromAst(ast: Node, code: string | undefined, callback: FileResultCallback): void; + +/** + * Given an AST, transform it. + */ +export function transformFromAst( + ast: Node, + code: string | undefined, + opts: TransformOptions | undefined, + callback: FileResultCallback, +): void; + +/** + * Here for backward-compatibility. Ideally use ".transformSync" if you want a synchronous API. + */ +export function transformFromAstSync(ast: Node, code?: string, opts?: TransformOptions): BabelFileResult | null; + +/** + * Given an AST, transform it. + */ +export function transformFromAstAsync( + ast: Node, + code?: string, + opts?: TransformOptions, +): Promise; + +// A babel plugin is a simple function which must return an object matching +// the following interface. Babel will throw if it finds unknown properties. +// The list of allowed plugin keys is here: +// https://github.com/babel/babel/blob/4e50b2d9d9c376cee7a2cbf56553fe5b982ea53c/packages/babel-core/src/config/option-manager.js#L71 +export interface PluginObj { + name?: string | undefined; + manipulateOptions?(opts: any, parserOpts: any): void; + pre?(this: S, file: BabelFile): void; + visitor: Visitor; + post?(this: S, file: BabelFile): void; + inherits?: any; +} + +export interface BabelFile { + ast: t.File; + opts: TransformOptions; + hub: Hub; + metadata: object; + path: NodePath; + scope: Scope; + inputMap: object | null; + code: string; +} + +export interface PluginPass { + file: BabelFile; + key: string; + opts: object; + cwd: string; + filename: string | undefined; + get(key: unknown): any; + set(key: unknown, value: unknown): void; + [key: string]: unknown; +} + +export interface BabelFileResult { + ast?: t.File | null | undefined; + code?: string | null | undefined; + ignored?: boolean | undefined; + map?: + | { + version: number; + sources: string[]; + names: string[]; + sourceRoot?: string | undefined; + sourcesContent?: string[] | undefined; + mappings: string; + file: string; + } + | null + | undefined; + metadata?: BabelFileMetadata | undefined; +} + +export interface BabelFileMetadata { + usedHelpers: string[]; + marked: Array<{ + type: string; + message: string; + loc: object; + }>; + modules: BabelFileModulesMetadata; +} + +export interface BabelFileModulesMetadata { + imports: object[]; + exports: { + exported: object[]; + specifiers: object[]; + }; +} + +export type FileParseCallback = (err: Error | null, result: ParseResult | null) => any; + +/** + * Given some code, parse it using Babel's standard behavior. + * Referenced presets and plugins will be loaded such that optional syntax plugins are automatically enabled. + */ +export function parse(code: string, callback: FileParseCallback): void; + +/** + * Given some code, parse it using Babel's standard behavior. + * Referenced presets and plugins will be loaded such that optional syntax plugins are automatically enabled. + */ +export function parse(code: string, options: TransformOptions | undefined, callback: FileParseCallback): void; + +/** + * Given some code, parse it using Babel's standard behavior. + * Referenced presets and plugins will be loaded such that optional syntax plugins are automatically enabled. + */ +export function parse(code: string, options?: TransformOptions): ParseResult | null; + +/** + * Given some code, parse it using Babel's standard behavior. + * Referenced presets and plugins will be loaded such that optional syntax plugins are automatically enabled. + */ +export function parseSync(code: string, options?: TransformOptions): ParseResult | null; + +/** + * Given some code, parse it using Babel's standard behavior. + * Referenced presets and plugins will be loaded such that optional syntax plugins are automatically enabled. + */ +export function parseAsync(code: string, options?: TransformOptions): Promise; + +/** + * Resolve Babel's options fully, resulting in an options object where: + * + * * opts.plugins is a full list of Plugin instances. + * * opts.presets is empty and all presets are flattened into opts. + * * It can be safely passed back to Babel. Fields like babelrc have been set to false so that later calls to Babel + * will not make a second attempt to load config files. + * + * Plugin instances aren't meant to be manipulated directly, but often callers will serialize this opts to JSON to + * use it as a cache key representing the options Babel has received. Caching on this isn't 100% guaranteed to + * invalidate properly, but it is the best we have at the moment. + */ +export function loadOptions(options?: TransformOptions): object | null; + +/** + * To allow systems to easily manipulate and validate a user's config, this function resolves the plugins and + * presets and proceeds no further. The expectation is that callers will take the config's .options, manipulate it + * as then see fit and pass it back to Babel again. + * + * * `babelrc: string | void` - The path of the `.babelrc` file, if there was one. + * * `babelignore: string | void` - The path of the `.babelignore` file, if there was one. + * * `options: ValidatedOptions` - The partially resolved options, which can be manipulated and passed back + * to Babel again. + * * `plugins: Array` - See below. + * * `presets: Array` - See below. + * * It can be safely passed back to Babel. Fields like `babelrc` have been set to false so that later calls to + * Babel will not make a second attempt to load config files. + * + * `ConfigItem` instances expose properties to introspect the values, but each item should be treated as + * immutable. If changes are desired, the item should be removed from the list and replaced with either a normal + * Babel config value, or with a replacement item created by `babel.createConfigItem`. See that function for + * information about `ConfigItem` fields. + */ +export function loadPartialConfig(options?: TransformOptions): Readonly | null; +export function loadPartialConfigAsync(options?: TransformOptions): Promise | null>; + +export interface PartialConfig { + options: TransformOptions; + babelrc?: string | undefined; + babelignore?: string | undefined; + config?: string | undefined; + hasFilesystemConfig: () => boolean; +} + +export interface ConfigItem { + /** + * The name that the user gave the plugin instance, e.g. `plugins: [ ['env', {}, 'my-env'] ]` + */ + name?: string | undefined; + + /** + * The resolved value of the plugin. + */ + value: object | ((...args: any[]) => any); + + /** + * The options object passed to the plugin. + */ + options?: object | false | undefined; + + /** + * The path that the options are relative to. + */ + dirname: string; + + /** + * Information about the plugin's file, if Babel knows it. + * * + */ + file?: + | { + /** + * The file that the user requested, e.g. `"@babel/env"` + */ + request: string; + + /** + * The full path of the resolved file, e.g. `"/tmp/node_modules/@babel/preset-env/lib/index.js"` + */ + resolved: string; + } + | null + | undefined; +} + +export type PluginOptions = object | undefined | false; + +export type PluginTarget = string | object | ((...args: any[]) => any); + +export type PluginItem = + | ConfigItem + | PluginObj + | PluginTarget + | [PluginTarget, PluginOptions] + | [PluginTarget, PluginOptions, string | undefined]; + +export function resolvePlugin(name: string, dirname: string): string | null; +export function resolvePreset(name: string, dirname: string): string | null; + +export interface CreateConfigItemOptions { + dirname?: string | undefined; + type?: "preset" | "plugin" | undefined; +} + +/** + * Allows build tooling to create and cache config items up front. If this function is called multiple times for a + * given plugin, Babel will call the plugin's function itself multiple times. If you have a clear set of expected + * plugins and presets to inject, pre-constructing the config items would be recommended. + */ +export function createConfigItem( + value: PluginTarget | [PluginTarget, PluginOptions] | [PluginTarget, PluginOptions, string | undefined], + options?: CreateConfigItemOptions, +): ConfigItem; + +// NOTE: the documentation says the ConfigAPI also exposes @babel/core's exports, but it actually doesn't +/** + * @see https://babeljs.io/docs/en/next/config-files#config-function-api + */ +export interface ConfigAPI { + /** + * The version string for the Babel version that is loading the config file. + * + * @see https://babeljs.io/docs/en/next/config-files#apiversion + */ + version: string; + /** + * @see https://babeljs.io/docs/en/next/config-files#apicache + */ + cache: SimpleCacheConfigurator; + /** + * @see https://babeljs.io/docs/en/next/config-files#apienv + */ + env: EnvFunction; + // undocumented; currently hardcoded to return 'false' + // async(): boolean + /** + * This API is used as a way to access the `caller` data that has been passed to Babel. + * Since many instances of Babel may be running in the same process with different `caller` values, + * this API is designed to automatically configure `api.cache`, the same way `api.env()` does. + * + * The `caller` value is available as the first parameter of the callback function. + * It is best used with something like this to toggle configuration behavior + * based on a specific environment: + * + * @example + * function isBabelRegister(caller?: { name: string }) { + * return !!(caller && caller.name === "@babel/register") + * } + * api.caller(isBabelRegister) + * + * @see https://babeljs.io/docs/en/next/config-files#apicallercb + */ + caller(callerCallback: (caller: TransformOptions["caller"]) => T): T; + /** + * While `api.version` can be useful in general, it's sometimes nice to just declare your version. + * This API exposes a simple way to do that with: + * + * @example + * api.assertVersion(7) // major version only + * api.assertVersion("^7.2") + * + * @see https://babeljs.io/docs/en/next/config-files#apiassertversionrange + */ + assertVersion(versionRange: number | string): boolean; + // NOTE: this is an undocumented reexport from "@babel/parser" but it's missing from its types + // tokTypes: typeof tokTypes +} + +/** + * JS configs are great because they can compute a config on the fly, + * but the downside there is that it makes caching harder. + * Babel wants to avoid re-executing the config function every time a file is compiled, + * because then it would also need to re-execute any plugin and preset functions + * referenced in that config. + * + * To avoid this, Babel expects users of config functions to tell it how to manage caching + * within a config file. + * + * @see https://babeljs.io/docs/en/next/config-files#apicache + */ +export interface SimpleCacheConfigurator { + // there is an undocumented call signature that is a shorthand for forever()/never()/using(). + // (ever: boolean): void + // (callback: CacheCallback): T + /** + * Permacache the computed config and never call the function again. + */ + forever(): void; + /** + * Do not cache this config, and re-execute the function every time. + */ + never(): void; + /** + * Any time the using callback returns a value other than the one that was expected, + * the overall config function will be called again and a new entry will be added to the cache. + * + * @example + * api.cache.using(() => process.env.NODE_ENV) + */ + using(callback: SimpleCacheCallback): T; + /** + * Any time the using callback returns a value other than the one that was expected, + * the overall config function will be called again and all entries in the cache will + * be replaced with the result. + * + * @example + * api.cache.invalidate(() => process.env.NODE_ENV) + */ + invalidate(callback: SimpleCacheCallback): T; +} + +// https://github.com/babel/babel/blob/v7.3.3/packages/babel-core/src/config/caching.js#L231 +export type SimpleCacheKey = string | boolean | number | null | undefined; +export type SimpleCacheCallback = () => T; + +/** + * Since `NODE_ENV` is a fairly common way to toggle behavior, Babel also includes an API function + * meant specifically for that. This API is used as a quick way to check the `"envName"` that Babel + * was loaded with, which takes `NODE_ENV` into account if no other overriding environment is set. + * + * @see https://babeljs.io/docs/en/next/config-files#apienv + */ +export interface EnvFunction { + /** + * @returns the current `envName` string + */ + (): string; + /** + * @returns `true` if the `envName` is `===` any of the given strings + */ + (envName: string | readonly string[]): boolean; + // the official documentation is misleading for this one... + // this just passes the callback to `cache.using` but with an additional argument. + // it returns its result instead of necessarily returning a boolean. + (envCallback: (envName: NonNullable) => T): T; +} + +export type ConfigFunction = (api: ConfigAPI) => TransformOptions; + +export as namespace babel; diff --git a/scripts/node_modules/@types/babel__core/package.json b/scripts/node_modules/@types/babel__core/package.json new file mode 100644 index 0000000000000000000000000000000000000000..487e31cc1fb37eb5b0b21caa448b6ea1a4937c47 --- /dev/null +++ b/scripts/node_modules/@types/babel__core/package.json @@ -0,0 +1,51 @@ +{ + "name": "@types/babel__core", + "version": "7.20.5", + "description": "TypeScript definitions for @babel/core", + "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/babel__core", + "license": "MIT", + "contributors": [ + { + "name": "Troy Gerwien", + "githubUsername": "yortus", + "url": "https://github.com/yortus" + }, + { + "name": "Marvin Hagemeister", + "githubUsername": "marvinhagemeister", + "url": "https://github.com/marvinhagemeister" + }, + { + "name": "Melvin Groenhoff", + "githubUsername": "mgroenhoff", + "url": "https://github.com/mgroenhoff" + }, + { + "name": "Jessica Franco", + "githubUsername": "Jessidhia", + "url": "https://github.com/Jessidhia" + }, + { + "name": "Ifiok Jr.", + "githubUsername": "ifiokjr", + "url": "https://github.com/ifiokjr" + } + ], + "main": "", + "types": "index.d.ts", + "repository": { + "type": "git", + "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", + "directory": "types/babel__core" + }, + "scripts": {}, + "dependencies": { + "@babel/parser": "^7.20.7", + "@babel/types": "^7.20.7", + "@types/babel__generator": "*", + "@types/babel__template": "*", + "@types/babel__traverse": "*" + }, + "typesPublisherContentHash": "3ece429b02ff9f70503a5644f2b303b04d10e6da7940c91a9eff5e52f2c76b91", + "typeScriptVersion": "4.5" +} \ No newline at end of file diff --git a/scripts/node_modules/@types/babel__generator/LICENSE b/scripts/node_modules/@types/babel__generator/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..9e841e7a26e4eb057b24511e7b92d42b257a80e5 --- /dev/null +++ b/scripts/node_modules/@types/babel__generator/LICENSE @@ -0,0 +1,21 @@ + MIT License + + Copyright (c) Microsoft Corporation. + + 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/scripts/node_modules/@types/babel__generator/README.md b/scripts/node_modules/@types/babel__generator/README.md new file mode 100644 index 0000000000000000000000000000000000000000..8bb78e419742324a9b15e9e70da682c18d4b00ee --- /dev/null +++ b/scripts/node_modules/@types/babel__generator/README.md @@ -0,0 +1,15 @@ +# Installation +> `npm install --save @types/babel__generator` + +# Summary +This package contains type definitions for @babel/generator (https://github.com/babel/babel/tree/master/packages/babel-generator). + +# Details +Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/babel__generator. + +### Additional Details + * Last updated: Thu, 03 Apr 2025 16:02:41 GMT + * Dependencies: [@babel/types](https://npmjs.com/package/@babel/types) + +# Credits +These definitions were written by [Troy Gerwien](https://github.com/yortus), [Melvin Groenhoff](https://github.com/mgroenhoff), [Cameron Yan](https://github.com/khell), and [Lyanbin](https://github.com/Lyanbin). diff --git a/scripts/node_modules/@types/babel__generator/index.d.ts b/scripts/node_modules/@types/babel__generator/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b89cc42ea81c3d3b16c7f4413e650f68bf408401 --- /dev/null +++ b/scripts/node_modules/@types/babel__generator/index.d.ts @@ -0,0 +1,210 @@ +import * as t from "@babel/types"; + +export interface GeneratorOptions { + /** + * Optional string to add as a block comment at the start of the output file. + */ + auxiliaryCommentBefore?: string | undefined; + + /** + * Optional string to add as a block comment at the end of the output file. + */ + auxiliaryCommentAfter?: string | undefined; + + /** + * Function that takes a comment (as a string) and returns true if the comment should be included in the output. + * By default, comments are included if `opts.comments` is `true` or if `opts.minifed` is `false` and the comment + * contains `@preserve` or `@license`. + */ + shouldPrintComment?(comment: string): boolean; + + /** + * Attempt to use the same line numbers in the output code as in the source code (helps preserve stack traces). + * Defaults to `false`. + */ + retainLines?: boolean | undefined; + + /** + * Retain parens around function expressions (could be used to change engine parsing behavior) + * Defaults to `false`. + */ + retainFunctionParens?: boolean | undefined; + + /** + * Should comments be included in output? Defaults to `true`. + */ + comments?: boolean | undefined; + + /** + * Set to true to avoid adding whitespace for formatting. Defaults to the value of `opts.minified`. + */ + compact?: boolean | "auto" | undefined; + + /** + * Should the output be minified. Defaults to `false`. + */ + minified?: boolean | undefined; + + /** + * Set to true to reduce whitespace (but not as much as opts.compact). Defaults to `false`. + */ + concise?: boolean | undefined; + + /** + * Used in warning messages + */ + filename?: string | undefined; + + /** + * Enable generating source maps. Defaults to `false`. + */ + sourceMaps?: boolean | undefined; + + /** + * A root for all relative URLs in the source map. + */ + sourceRoot?: string | undefined; + + /** + * The filename for the source code (i.e. the code in the `code` argument). + * This will only be used if `code` is a string. + */ + sourceFileName?: string | undefined; + + /** + * Set to true to run jsesc with "json": true to print "\u00A9" vs. "©"; + */ + jsonCompatibleStrings?: boolean | undefined; + + /** + * Set to true to enable support for experimental decorators syntax before module exports. + * Defaults to `false`. + */ + decoratorsBeforeExport?: boolean | undefined; + + /** + * The import attributes/assertions syntax to use. + * When not specified, @babel/generator will try to match the style in the input code based on the AST shape. + */ + importAttributesKeyword?: "with" | "assert" | "with-legacy"; + + /** + * Options for outputting jsesc representation. + */ + jsescOption?: { + /** + * The default value for the quotes option is 'single'. This means that any occurrences of ' in the input + * string are escaped as \', so that the output can be used in a string literal wrapped in single quotes. + */ + quotes?: "single" | "double" | "backtick" | undefined; + + /** + * The default value for the numbers option is 'decimal'. This means that any numeric values are represented + * using decimal integer literals. Other valid options are binary, octal, and hexadecimal, which result in + * binary integer literals, octal integer literals, and hexadecimal integer literals, respectively. + */ + numbers?: "binary" | "octal" | "decimal" | "hexadecimal" | undefined; + + /** + * The wrap option takes a boolean value (true or false), and defaults to false (disabled). When enabled, the + * output is a valid JavaScript string literal wrapped in quotes. The type of quotes can be specified through + * the quotes setting. + */ + wrap?: boolean | undefined; + + /** + * The es6 option takes a boolean value (true or false), and defaults to false (disabled). When enabled, any + * astral Unicode symbols in the input are escaped using ECMAScript 6 Unicode code point escape sequences + * instead of using separate escape sequences for each surrogate half. If backwards compatibility with ES5 + * environments is a concern, don’t enable this setting. If the json setting is enabled, the value for the es6 + * setting is ignored (as if it was false). + */ + es6?: boolean | undefined; + + /** + * The escapeEverything option takes a boolean value (true or false), and defaults to false (disabled). When + * enabled, all the symbols in the output are escaped — even printable ASCII symbols. + */ + escapeEverything?: boolean | undefined; + + /** + * The minimal option takes a boolean value (true or false), and defaults to false (disabled). When enabled, + * only a limited set of symbols in the output are escaped: \0, \b, \t, \n, \f, \r, \\, \u2028, \u2029. + */ + minimal?: boolean | undefined; + + /** + * The isScriptContext option takes a boolean value (true or false), and defaults to false (disabled). When + * enabled, occurrences of or