weapp-tailwindcss 5.5.4 → 5.5.6

package/dist/{compiler-DFROuh5Z.cjs → compiler-C8FqI-P3.cjs}

@@ -1,9 +1,9 @@
 const require_rolldown_runtime = require("./rolldown-runtime-Ctb5zv51.cjs");
 const require_framework = require("./framework.cjs");
-const require_generator = require("./generator-RK2HtgOb.cjs");
-const require_tailwindcss = require("./tailwindcss-B03BGeTO.cjs");
+const require_generator = require("./generator-Bvr4WmuF.cjs");
+const require_tailwindcss = require("./tailwindcss-CBYjzRmV.cjs");
 require("./utils-CuKLf1Zv.cjs");
-const require_defaults = require("./defaults-CiGsr8Xq.cjs");
+const require_defaults = require("./defaults-CyX5iO9y.cjs");
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path, 1);
 let node_process = require("node:process");
@@ -3298,7 +3298,7 @@ function readCodePoint$1(input, pos, lineStart, curLine, throwOnInvalid, errors)
 	};
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@babel+types@8.0.4/node_modules/@babel/types/lib/index.js
+//#region ../../node_modules/.pnpm/@babel+types@8.0.5/node_modules/@babel/types/lib/index.js
 var lib_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
 	ACCESSOR_TYPES: () => ACCESSOR_TYPES,
 	ALIAS_KEYS: () => ALIAS_KEYS,
@@ -4341,7 +4341,7 @@ var lib_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
 	isTopicReference: () => isTopicReference$1,
 	isTryStatement: () => isTryStatement,
 	isTupleTypeAnnotation: () => isTupleTypeAnnotation$1,
-	isType: () => isType$1,
+	isType: () => isType$2,
 	isTypeAlias: () => isTypeAlias,
 	isTypeAnnotation: () => isTypeAnnotation$1,
 	isTypeCastExpression: () => isTypeCastExpression,
@@ -4553,6 +4553,9 @@ function shallowEqual(actual, expected) {
 	for (const key of keys) if (actual[key] !== expected[key]) return false;
 	return true;
 }
+function isType$1(type, node, opts) {
+	return node?.type === type && (opts == null || shallowEqual(node, opts));
+}
 const warnings = /* @__PURE__ */ new Set();
 function deprecationWarning$1(oldName, newName, prefix = "", cacheKey = oldName) {
 	if (warnings.has(cacheKey)) return;
@@ -4582,1244 +4585,748 @@ function captureShortStackTrace(skip, length) {
 	};
 }
 function isArrayExpression$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ArrayExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ArrayExpression", node, opts);
 }
 function isAssignmentExpression$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "AssignmentExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("AssignmentExpression", node, opts);
 }
 function isBinaryExpression(node, opts) {
-	if (!node) return false;
-	if (node.type !== "BinaryExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("BinaryExpression", node, opts);
 }
 function isInterpreterDirective(node, opts) {
-	if (!node) return false;
-	if (node.type !== "InterpreterDirective") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("InterpreterDirective", node, opts);
 }
 function isDirective(node, opts) {
-	if (!node) return false;
-	if (node.type !== "Directive") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("Directive", node, opts);
 }
 function isDirectiveLiteral(node, opts) {
-	if (!node) return false;
-	if (node.type !== "DirectiveLiteral") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("DirectiveLiteral", node, opts);
 }
 function isBlockStatement$2(node, opts) {
-	if (!node) return false;
-	if (node.type !== "BlockStatement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("BlockStatement", node, opts);
 }
 function isBreakStatement(node, opts) {
-	if (!node) return false;
-	if (node.type !== "BreakStatement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("BreakStatement", node, opts);
 }
 function isCallExpression$4(node, opts) {
-	if (!node) return false;
-	if (node.type !== "CallExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("CallExpression", node, opts);
 }
 function isCatchClause(node, opts) {
-	if (!node) return false;
-	if (node.type !== "CatchClause") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("CatchClause", node, opts);
 }
 function isConditionalExpression(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ConditionalExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ConditionalExpression", node, opts);
 }
 function isContinueStatement(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ContinueStatement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ContinueStatement", node, opts);
 }
 function isDebuggerStatement(node, opts) {
-	if (!node) return false;
-	if (node.type !== "DebuggerStatement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("DebuggerStatement", node, opts);
 }
 function isDoWhileStatement(node, opts) {
-	if (!node) return false;
-	if (node.type !== "DoWhileStatement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("DoWhileStatement", node, opts);
 }
 function isEmptyStatement$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "EmptyStatement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("EmptyStatement", node, opts);
 }
 function isExpressionStatement$2(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ExpressionStatement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ExpressionStatement", node, opts);
 }
 function isFile(node, opts) {
-	if (!node) return false;
-	if (node.type !== "File") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("File", node, opts);
 }
 function isForInStatement(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ForInStatement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ForInStatement", node, opts);
 }
 function isForStatement$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ForStatement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ForStatement", node, opts);
 }
 function isFunctionDeclaration$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "FunctionDeclaration") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("FunctionDeclaration", node, opts);
 }
 function isFunctionExpression(node, opts) {
-	if (!node) return false;
-	if (node.type !== "FunctionExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("FunctionExpression", node, opts);
 }
 function isIdentifier$7(node, opts) {
-	if (!node) return false;
-	if (node.type !== "Identifier") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("Identifier", node, opts);
 }
 function isIfStatement$2(node, opts) {
-	if (!node) return false;
-	if (node.type !== "IfStatement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("IfStatement", node, opts);
 }
 function isLabeledStatement(node, opts) {
-	if (!node) return false;
-	if (node.type !== "LabeledStatement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("LabeledStatement", node, opts);
 }
 function isStringLiteral$3(node, opts) {
-	if (!node) return false;
-	if (node.type !== "StringLiteral") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("StringLiteral", node, opts);
 }
 function isNumericLiteral(node, opts) {
-	if (!node) return false;
-	if (node.type !== "NumericLiteral") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("NumericLiteral", node, opts);
 }
 function isNullLiteral$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "NullLiteral") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("NullLiteral", node, opts);
 }
 function isBooleanLiteral(node, opts) {
-	if (!node) return false;
-	if (node.type !== "BooleanLiteral") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("BooleanLiteral", node, opts);
 }
 function isRegExpLiteral$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "RegExpLiteral") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("RegExpLiteral", node, opts);
 }
 function isLogicalExpression(node, opts) {
-	if (!node) return false;
-	if (node.type !== "LogicalExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("LogicalExpression", node, opts);
 }
 function isMemberExpression$3(node, opts) {
-	if (!node) return false;
-	if (node.type !== "MemberExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("MemberExpression", node, opts);
 }
 function isNewExpression$2(node, opts) {
-	if (!node) return false;
-	if (node.type !== "NewExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("NewExpression", node, opts);
 }
 function isProgram$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "Program") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("Program", node, opts);
 }
 function isObjectExpression$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ObjectExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ObjectExpression", node, opts);
 }
 function isObjectMethod(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ObjectMethod") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ObjectMethod", node, opts);
 }
 function isObjectProperty$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ObjectProperty") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ObjectProperty", node, opts);
 }
 function isRestElement$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "RestElement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("RestElement", node, opts);
 }
 function isReturnStatement(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ReturnStatement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ReturnStatement", node, opts);
 }
 function isSequenceExpression$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "SequenceExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("SequenceExpression", node, opts);
 }
 function isParenthesizedExpression(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ParenthesizedExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ParenthesizedExpression", node, opts);
 }
 function isSwitchCase(node, opts) {
-	if (!node) return false;
-	if (node.type !== "SwitchCase") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("SwitchCase", node, opts);
 }
 function isSwitchStatement(node, opts) {
-	if (!node) return false;
-	if (node.type !== "SwitchStatement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("SwitchStatement", node, opts);
 }
 function isThisExpression$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ThisExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ThisExpression", node, opts);
 }
 function isThrowStatement(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ThrowStatement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ThrowStatement", node, opts);
 }
 function isTryStatement(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TryStatement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TryStatement", node, opts);
 }
 function isUnaryExpression$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "UnaryExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("UnaryExpression", node, opts);
 }
 function isUpdateExpression(node, opts) {
-	if (!node) return false;
-	if (node.type !== "UpdateExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("UpdateExpression", node, opts);
 }
 function isVariableDeclaration$3(node, opts) {
-	if (!node) return false;
-	if (node.type !== "VariableDeclaration") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("VariableDeclaration", node, opts);
 }
 function isVariableDeclarator(node, opts) {
-	if (!node) return false;
-	if (node.type !== "VariableDeclarator") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("VariableDeclarator", node, opts);
 }
 function isWhileStatement(node, opts) {
-	if (!node) return false;
-	if (node.type !== "WhileStatement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("WhileStatement", node, opts);
 }
 function isWithStatement(node, opts) {
-	if (!node) return false;
-	if (node.type !== "WithStatement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("WithStatement", node, opts);
 }
 function isAssignmentPattern$2(node, opts) {
-	if (!node) return false;
-	if (node.type !== "AssignmentPattern") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("AssignmentPattern", node, opts);
 }
 function isArrayPattern(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ArrayPattern") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ArrayPattern", node, opts);
 }
 function isArrowFunctionExpression(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ArrowFunctionExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ArrowFunctionExpression", node, opts);
 }
 function isClassBody$2(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ClassBody") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ClassBody", node, opts);
 }
 function isClassExpression(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ClassExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ClassExpression", node, opts);
 }
 function isClassDeclaration$2(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ClassDeclaration") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ClassDeclaration", node, opts);
 }
 function isExportAllDeclaration$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ExportAllDeclaration") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ExportAllDeclaration", node, opts);
 }
 function isExportDefaultDeclaration$2(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ExportDefaultDeclaration") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ExportDefaultDeclaration", node, opts);
 }
 function isExportNamedDeclaration$3(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ExportNamedDeclaration") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ExportNamedDeclaration", node, opts);
 }
 function isExportSpecifier(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ExportSpecifier") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ExportSpecifier", node, opts);
 }
 function isForOfStatement$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ForOfStatement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ForOfStatement", node, opts);
 }
 function isImportDeclaration$2(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ImportDeclaration") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ImportDeclaration", node, opts);
 }
 function isImportDefaultSpecifier$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ImportDefaultSpecifier") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ImportDefaultSpecifier", node, opts);
 }
 function isImportNamespaceSpecifier$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ImportNamespaceSpecifier") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ImportNamespaceSpecifier", node, opts);
 }
 function isImportSpecifier$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ImportSpecifier") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ImportSpecifier", node, opts);
 }
 function isMetaProperty$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "MetaProperty") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("MetaProperty", node, opts);
 }
 function isClassMethod(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ClassMethod") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ClassMethod", node, opts);
 }
 function isObjectPattern(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ObjectPattern") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ObjectPattern", node, opts);
 }
 function isSpreadElement(node, opts) {
-	if (!node) return false;
-	if (node.type !== "SpreadElement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("SpreadElement", node, opts);
 }
 function isSuper$2(node, opts) {
-	if (!node) return false;
-	if (node.type !== "Super") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("Super", node, opts);
 }
 function isTaggedTemplateExpression$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TaggedTemplateExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TaggedTemplateExpression", node, opts);
 }
 function isTemplateElement(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TemplateElement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TemplateElement", node, opts);
 }
 function isTemplateLiteral$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TemplateLiteral") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TemplateLiteral", node, opts);
 }
 function isYieldExpression$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "YieldExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("YieldExpression", node, opts);
 }
 function isAwaitExpression(node, opts) {
-	if (!node) return false;
-	if (node.type !== "AwaitExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("AwaitExpression", node, opts);
 }
 function isImportExpression(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ImportExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ImportExpression", node, opts);
 }
 function isImport(node, opts) {
-	if (!node) return false;
-	if (node.type !== "Import") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("Import", node, opts);
 }
 function isBigIntLiteral(node, opts) {
-	if (!node) return false;
-	if (node.type !== "BigIntLiteral") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("BigIntLiteral", node, opts);
 }
 function isExportNamespaceSpecifier$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ExportNamespaceSpecifier") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ExportNamespaceSpecifier", node, opts);
 }
 function isOptionalMemberExpression$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "OptionalMemberExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("OptionalMemberExpression", node, opts);
 }
 function isOptionalCallExpression(node, opts) {
-	if (!node) return false;
-	if (node.type !== "OptionalCallExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("OptionalCallExpression", node, opts);
 }
 function isClassProperty(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ClassProperty") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ClassProperty", node, opts);
 }
 function isClassPrivateProperty(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ClassPrivateProperty") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ClassPrivateProperty", node, opts);
 }
 function isClassPrivateMethod(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ClassPrivateMethod") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ClassPrivateMethod", node, opts);
 }
 function isPrivateName$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "PrivateName") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("PrivateName", node, opts);
 }
 function isStaticBlock(node, opts) {
-	if (!node) return false;
-	if (node.type !== "StaticBlock") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("StaticBlock", node, opts);
 }
 function isImportAttribute(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ImportAttribute") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ImportAttribute", node, opts);
 }
 function isAnyTypeAnnotation$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "AnyTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("AnyTypeAnnotation", node, opts);
 }
 function isArrayTypeAnnotation$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ArrayTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ArrayTypeAnnotation", node, opts);
 }
 function isBooleanTypeAnnotation$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "BooleanTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("BooleanTypeAnnotation", node, opts);
 }
 function isBooleanLiteralTypeAnnotation(node, opts) {
-	if (!node) return false;
-	if (node.type !== "BooleanLiteralTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("BooleanLiteralTypeAnnotation", node, opts);
 }
 function isNullLiteralTypeAnnotation(node, opts) {
-	if (!node) return false;
-	if (node.type !== "NullLiteralTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("NullLiteralTypeAnnotation", node, opts);
 }
 function isClassImplements(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ClassImplements") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ClassImplements", node, opts);
 }
 function isDeclareClass(node, opts) {
-	if (!node) return false;
-	if (node.type !== "DeclareClass") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("DeclareClass", node, opts);
 }
 function isDeclareFunction(node, opts) {
-	if (!node) return false;
-	if (node.type !== "DeclareFunction") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("DeclareFunction", node, opts);
 }
 function isDeclareInterface(node, opts) {
-	if (!node) return false;
-	if (node.type !== "DeclareInterface") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("DeclareInterface", node, opts);
 }
 function isDeclareModule(node, opts) {
-	if (!node) return false;
-	if (node.type !== "DeclareModule") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("DeclareModule", node, opts);
 }
 function isDeclareModuleExports(node, opts) {
-	if (!node) return false;
-	if (node.type !== "DeclareModuleExports") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("DeclareModuleExports", node, opts);
 }
 function isDeclareTypeAlias(node, opts) {
-	if (!node) return false;
-	if (node.type !== "DeclareTypeAlias") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("DeclareTypeAlias", node, opts);
 }
 function isDeclareOpaqueType(node, opts) {
-	if (!node) return false;
-	if (node.type !== "DeclareOpaqueType") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("DeclareOpaqueType", node, opts);
 }
 function isDeclareVariable(node, opts) {
-	if (!node) return false;
-	if (node.type !== "DeclareVariable") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("DeclareVariable", node, opts);
 }
 function isDeclareExportDeclaration$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "DeclareExportDeclaration") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("DeclareExportDeclaration", node, opts);
 }
 function isDeclareExportAllDeclaration(node, opts) {
-	if (!node) return false;
-	if (node.type !== "DeclareExportAllDeclaration") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("DeclareExportAllDeclaration", node, opts);
 }
 function isDeclaredPredicate(node, opts) {
-	if (!node) return false;
-	if (node.type !== "DeclaredPredicate") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("DeclaredPredicate", node, opts);
 }
 function isExistsTypeAnnotation(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ExistsTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ExistsTypeAnnotation", node, opts);
 }
 function isFunctionTypeAnnotation(node, opts) {
-	if (!node) return false;
-	if (node.type !== "FunctionTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("FunctionTypeAnnotation", node, opts);
 }
 function isFunctionTypeParam(node, opts) {
-	if (!node) return false;
-	if (node.type !== "FunctionTypeParam") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("FunctionTypeParam", node, opts);
 }
 function isGenericTypeAnnotation$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "GenericTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("GenericTypeAnnotation", node, opts);
 }
 function isInferredPredicate(node, opts) {
-	if (!node) return false;
-	if (node.type !== "InferredPredicate") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("InferredPredicate", node, opts);
 }
 function isInterfaceExtends(node, opts) {
-	if (!node) return false;
-	if (node.type !== "InterfaceExtends") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("InterfaceExtends", node, opts);
 }
 function isInterfaceDeclaration(node, opts) {
-	if (!node) return false;
-	if (node.type !== "InterfaceDeclaration") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("InterfaceDeclaration", node, opts);
 }
 function isInterfaceTypeAnnotation(node, opts) {
-	if (!node) return false;
-	if (node.type !== "InterfaceTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("InterfaceTypeAnnotation", node, opts);
 }
 function isIntersectionTypeAnnotation(node, opts) {
-	if (!node) return false;
-	if (node.type !== "IntersectionTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("IntersectionTypeAnnotation", node, opts);
 }
 function isMixedTypeAnnotation$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "MixedTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("MixedTypeAnnotation", node, opts);
 }
 function isEmptyTypeAnnotation$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "EmptyTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("EmptyTypeAnnotation", node, opts);
 }
 function isNullableTypeAnnotation(node, opts) {
-	if (!node) return false;
-	if (node.type !== "NullableTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("NullableTypeAnnotation", node, opts);
 }
 function isNumberLiteralTypeAnnotation(node, opts) {
-	if (!node) return false;
-	if (node.type !== "NumberLiteralTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("NumberLiteralTypeAnnotation", node, opts);
 }
 function isBigIntLiteralTypeAnnotation(node, opts) {
-	if (!node) return false;
-	if (node.type !== "BigIntLiteralTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("BigIntLiteralTypeAnnotation", node, opts);
 }
 function isNumberTypeAnnotation$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "NumberTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("NumberTypeAnnotation", node, opts);
 }
 function isObjectTypeAnnotation(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ObjectTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ObjectTypeAnnotation", node, opts);
 }
 function isObjectTypeInternalSlot(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ObjectTypeInternalSlot") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ObjectTypeInternalSlot", node, opts);
 }
 function isObjectTypeCallProperty(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ObjectTypeCallProperty") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ObjectTypeCallProperty", node, opts);
 }
 function isObjectTypeIndexer(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ObjectTypeIndexer") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ObjectTypeIndexer", node, opts);
 }
 function isObjectTypeProperty(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ObjectTypeProperty") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ObjectTypeProperty", node, opts);
 }
 function isObjectTypeSpreadProperty(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ObjectTypeSpreadProperty") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ObjectTypeSpreadProperty", node, opts);
 }
 function isOpaqueType(node, opts) {
-	if (!node) return false;
-	if (node.type !== "OpaqueType") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("OpaqueType", node, opts);
 }
 function isQualifiedTypeIdentifier(node, opts) {
-	if (!node) return false;
-	if (node.type !== "QualifiedTypeIdentifier") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("QualifiedTypeIdentifier", node, opts);
 }
 function isStringLiteralTypeAnnotation(node, opts) {
-	if (!node) return false;
-	if (node.type !== "StringLiteralTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("StringLiteralTypeAnnotation", node, opts);
 }
 function isStringTypeAnnotation$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "StringTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("StringTypeAnnotation", node, opts);
 }
 function isSymbolTypeAnnotation(node, opts) {
-	if (!node) return false;
-	if (node.type !== "SymbolTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("SymbolTypeAnnotation", node, opts);
 }
 function isThisTypeAnnotation(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ThisTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ThisTypeAnnotation", node, opts);
 }
 function isTupleTypeAnnotation$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TupleTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TupleTypeAnnotation", node, opts);
 }
 function isTypeofTypeAnnotation(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TypeofTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TypeofTypeAnnotation", node, opts);
 }
 function isTypeAlias(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TypeAlias") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TypeAlias", node, opts);
 }
 function isTypeAnnotation$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TypeAnnotation", node, opts);
 }
 function isTypeCastExpression(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TypeCastExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TypeCastExpression", node, opts);
 }
 function isTypeParameter(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TypeParameter") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TypeParameter", node, opts);
 }
 function isTypeParameterDeclaration(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TypeParameterDeclaration") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TypeParameterDeclaration", node, opts);
 }
 function isTypeParameterInstantiation(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TypeParameterInstantiation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TypeParameterInstantiation", node, opts);
 }
 function isUnionTypeAnnotation$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "UnionTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("UnionTypeAnnotation", node, opts);
 }
 function isVariance(node, opts) {
-	if (!node) return false;
-	if (node.type !== "Variance") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("Variance", node, opts);
 }
 function isVoidTypeAnnotation$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "VoidTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("VoidTypeAnnotation", node, opts);
 }
 function isEnumDeclaration(node, opts) {
-	if (!node) return false;
-	if (node.type !== "EnumDeclaration") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("EnumDeclaration", node, opts);
 }
 function isEnumBooleanBody(node, opts) {
-	if (!node) return false;
-	if (node.type !== "EnumBooleanBody") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("EnumBooleanBody", node, opts);
 }
 function isEnumNumberBody(node, opts) {
-	if (!node) return false;
-	if (node.type !== "EnumNumberBody") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("EnumNumberBody", node, opts);
 }
 function isEnumStringBody(node, opts) {
-	if (!node) return false;
-	if (node.type !== "EnumStringBody") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("EnumStringBody", node, opts);
 }
 function isEnumSymbolBody(node, opts) {
-	if (!node) return false;
-	if (node.type !== "EnumSymbolBody") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("EnumSymbolBody", node, opts);
 }
 function isEnumBooleanMember(node, opts) {
-	if (!node) return false;
-	if (node.type !== "EnumBooleanMember") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("EnumBooleanMember", node, opts);
 }
 function isEnumNumberMember(node, opts) {
-	if (!node) return false;
-	if (node.type !== "EnumNumberMember") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("EnumNumberMember", node, opts);
 }
 function isEnumStringMember(node, opts) {
-	if (!node) return false;
-	if (node.type !== "EnumStringMember") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("EnumStringMember", node, opts);
 }
 function isEnumDefaultedMember(node, opts) {
-	if (!node) return false;
-	if (node.type !== "EnumDefaultedMember") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("EnumDefaultedMember", node, opts);
 }
 function isIndexedAccessType(node, opts) {
-	if (!node) return false;
-	if (node.type !== "IndexedAccessType") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("IndexedAccessType", node, opts);
 }
 function isOptionalIndexedAccessType(node, opts) {
-	if (!node) return false;
-	if (node.type !== "OptionalIndexedAccessType") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("OptionalIndexedAccessType", node, opts);
 }
 function isJSXAttribute(node, opts) {
-	if (!node) return false;
-	if (node.type !== "JSXAttribute") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("JSXAttribute", node, opts);
 }
 function isJSXClosingElement(node, opts) {
-	if (!node) return false;
-	if (node.type !== "JSXClosingElement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("JSXClosingElement", node, opts);
 }
 function isJSXElement(node, opts) {
-	if (!node) return false;
-	if (node.type !== "JSXElement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("JSXElement", node, opts);
 }
 function isJSXEmptyExpression(node, opts) {
-	if (!node) return false;
-	if (node.type !== "JSXEmptyExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("JSXEmptyExpression", node, opts);
 }
 function isJSXExpressionContainer(node, opts) {
-	if (!node) return false;
-	if (node.type !== "JSXExpressionContainer") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("JSXExpressionContainer", node, opts);
 }
 function isJSXSpreadChild(node, opts) {
-	if (!node) return false;
-	if (node.type !== "JSXSpreadChild") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("JSXSpreadChild", node, opts);
 }
 function isJSXIdentifier$2(node, opts) {
-	if (!node) return false;
-	if (node.type !== "JSXIdentifier") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("JSXIdentifier", node, opts);
 }
 function isJSXMemberExpression$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "JSXMemberExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("JSXMemberExpression", node, opts);
 }
 function isJSXNamespacedName(node, opts) {
-	if (!node) return false;
-	if (node.type !== "JSXNamespacedName") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("JSXNamespacedName", node, opts);
 }
 function isJSXOpeningElement(node, opts) {
-	if (!node) return false;
-	if (node.type !== "JSXOpeningElement") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("JSXOpeningElement", node, opts);
 }
 function isJSXSpreadAttribute(node, opts) {
-	if (!node) return false;
-	if (node.type !== "JSXSpreadAttribute") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("JSXSpreadAttribute", node, opts);
 }
 function isJSXText(node, opts) {
-	if (!node) return false;
-	if (node.type !== "JSXText") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("JSXText", node, opts);
 }
 function isJSXFragment(node, opts) {
-	if (!node) return false;
-	if (node.type !== "JSXFragment") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("JSXFragment", node, opts);
 }
 function isJSXOpeningFragment(node, opts) {
-	if (!node) return false;
-	if (node.type !== "JSXOpeningFragment") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("JSXOpeningFragment", node, opts);
 }
 function isJSXClosingFragment(node, opts) {
-	if (!node) return false;
-	if (node.type !== "JSXClosingFragment") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("JSXClosingFragment", node, opts);
 }
 function isPlaceholder$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "Placeholder") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("Placeholder", node, opts);
 }
 function isV8IntrinsicIdentifier(node, opts) {
-	if (!node) return false;
-	if (node.type !== "V8IntrinsicIdentifier") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("V8IntrinsicIdentifier", node, opts);
 }
 function isArgumentPlaceholder(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ArgumentPlaceholder") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ArgumentPlaceholder", node, opts);
 }
 function isBindExpression(node, opts) {
-	if (!node) return false;
-	if (node.type !== "BindExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("BindExpression", node, opts);
 }
 function isClassAccessorProperty(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ClassAccessorProperty") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ClassAccessorProperty", node, opts);
 }
 function isDecorator(node, opts) {
-	if (!node) return false;
-	if (node.type !== "Decorator") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("Decorator", node, opts);
 }
 function isDoExpression(node, opts) {
-	if (!node) return false;
-	if (node.type !== "DoExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("DoExpression", node, opts);
 }
 function isExportDefaultSpecifier$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ExportDefaultSpecifier") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ExportDefaultSpecifier", node, opts);
 }
 function isModuleExpression(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ModuleExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("ModuleExpression", node, opts);
 }
 function isTopicReference$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TopicReference") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TopicReference", node, opts);
 }
 function isVoidPattern$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "VoidPattern") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("VoidPattern", node, opts);
 }
 function isTSParameterProperty(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSParameterProperty") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSParameterProperty", node, opts);
 }
 function isTSDeclareFunction(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSDeclareFunction") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSDeclareFunction", node, opts);
 }
 function isTSDeclareMethod(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSDeclareMethod") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSDeclareMethod", node, opts);
 }
 function isTSQualifiedName(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSQualifiedName") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSQualifiedName", node, opts);
 }
 function isTSCallSignatureDeclaration(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSCallSignatureDeclaration") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSCallSignatureDeclaration", node, opts);
 }
 function isTSConstructSignatureDeclaration(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSConstructSignatureDeclaration") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSConstructSignatureDeclaration", node, opts);
 }
 function isTSPropertySignature(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSPropertySignature") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSPropertySignature", node, opts);
 }
 function isTSMethodSignature(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSMethodSignature") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSMethodSignature", node, opts);
 }
 function isTSIndexSignature(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSIndexSignature") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSIndexSignature", node, opts);
 }
 function isTSAnyKeyword(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSAnyKeyword") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSAnyKeyword", node, opts);
 }
 function isTSBooleanKeyword(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSBooleanKeyword") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSBooleanKeyword", node, opts);
 }
 function isTSBigIntKeyword(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSBigIntKeyword") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSBigIntKeyword", node, opts);
 }
 function isTSIntrinsicKeyword(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSIntrinsicKeyword") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSIntrinsicKeyword", node, opts);
 }
 function isTSNeverKeyword(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSNeverKeyword") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSNeverKeyword", node, opts);
 }
 function isTSNullKeyword(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSNullKeyword") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSNullKeyword", node, opts);
 }
 function isTSNumberKeyword(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSNumberKeyword") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSNumberKeyword", node, opts);
 }
 function isTSObjectKeyword(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSObjectKeyword") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSObjectKeyword", node, opts);
 }
 function isTSStringKeyword(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSStringKeyword") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSStringKeyword", node, opts);
 }
 function isTSSymbolKeyword(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSSymbolKeyword") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSSymbolKeyword", node, opts);
 }
 function isTSUndefinedKeyword(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSUndefinedKeyword") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSUndefinedKeyword", node, opts);
 }
 function isTSUnknownKeyword(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSUnknownKeyword") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSUnknownKeyword", node, opts);
 }
 function isTSVoidKeyword(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSVoidKeyword") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSVoidKeyword", node, opts);
 }
 function isTSThisType(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSThisType") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSThisType", node, opts);
 }
 function isTSFunctionType(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSFunctionType") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSFunctionType", node, opts);
 }
 function isTSConstructorType(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSConstructorType") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSConstructorType", node, opts);
 }
 function isTSTypeReference$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSTypeReference") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSTypeReference", node, opts);
 }
 function isTSTypePredicate(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSTypePredicate") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSTypePredicate", node, opts);
 }
 function isTSTypeQuery(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSTypeQuery") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSTypeQuery", node, opts);
 }
 function isTSTypeLiteral(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSTypeLiteral") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSTypeLiteral", node, opts);
 }
 function isTSArrayType$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSArrayType") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSArrayType", node, opts);
 }
 function isTSTupleType(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSTupleType") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSTupleType", node, opts);
 }
 function isTSOptionalType(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSOptionalType") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSOptionalType", node, opts);
 }
 function isTSRestType(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSRestType") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSRestType", node, opts);
 }
 function isTSNamedTupleMember(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSNamedTupleMember") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSNamedTupleMember", node, opts);
 }
 function isTSUnionType(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSUnionType") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSUnionType", node, opts);
 }
 function isTSIntersectionType(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSIntersectionType") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSIntersectionType", node, opts);
 }
 function isTSConditionalType(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSConditionalType") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSConditionalType", node, opts);
 }
 function isTSInferType(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSInferType") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSInferType", node, opts);
 }
 function isTSParenthesizedType(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSParenthesizedType") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSParenthesizedType", node, opts);
 }
 function isTSTypeOperator(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSTypeOperator") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSTypeOperator", node, opts);
 }
 function isTSIndexedAccessType(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSIndexedAccessType") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSIndexedAccessType", node, opts);
 }
 function isTSMappedType(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSMappedType") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSMappedType", node, opts);
 }
 function isTSTemplateLiteralType(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSTemplateLiteralType") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSTemplateLiteralType", node, opts);
 }
 function isTSLiteralType(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSLiteralType") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSLiteralType", node, opts);
 }
 function isTSClassImplements(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSClassImplements") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSClassImplements", node, opts);
 }
 function isTSInterfaceHeritage(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSInterfaceHeritage") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSInterfaceHeritage", node, opts);
 }
 function isTSInterfaceDeclaration(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSInterfaceDeclaration") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSInterfaceDeclaration", node, opts);
 }
 function isTSInterfaceBody$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSInterfaceBody") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSInterfaceBody", node, opts);
 }
 function isTSTypeAliasDeclaration(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSTypeAliasDeclaration") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSTypeAliasDeclaration", node, opts);
 }
 function isTSInstantiationExpression(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSInstantiationExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSInstantiationExpression", node, opts);
 }
 function isTSAsExpression(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSAsExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSAsExpression", node, opts);
 }
 function isTSSatisfiesExpression(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSSatisfiesExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSSatisfiesExpression", node, opts);
 }
 function isTSTypeAssertion(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSTypeAssertion") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSTypeAssertion", node, opts);
 }
 function isTSEnumBody(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSEnumBody") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSEnumBody", node, opts);
 }
 function isTSEnumDeclaration(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSEnumDeclaration") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSEnumDeclaration", node, opts);
 }
 function isTSEnumMember$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSEnumMember") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSEnumMember", node, opts);
 }
 function isTSModuleDeclaration(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSModuleDeclaration") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSModuleDeclaration", node, opts);
 }
 function isTSModuleBlock(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSModuleBlock") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSModuleBlock", node, opts);
 }
 function isTSImportType(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSImportType") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSImportType", node, opts);
 }
 function isTSImportEqualsDeclaration(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSImportEqualsDeclaration") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSImportEqualsDeclaration", node, opts);
 }
 function isTSExternalModuleReference(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSExternalModuleReference") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSExternalModuleReference", node, opts);
 }
 function isTSNonNullExpression(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSNonNullExpression") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSNonNullExpression", node, opts);
 }
 function isTSExportAssignment(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSExportAssignment") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSExportAssignment", node, opts);
 }
 function isTSNamespaceExportDeclaration(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSNamespaceExportDeclaration") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSNamespaceExportDeclaration", node, opts);
 }
 function isTSTypeAnnotation$1(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSTypeAnnotation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSTypeAnnotation", node, opts);
 }
 function isTSTypeParameterInstantiation(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSTypeParameterInstantiation") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSTypeParameterInstantiation", node, opts);
 }
 function isTSTypeParameterDeclaration(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSTypeParameterDeclaration") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSTypeParameterDeclaration", node, opts);
 }
 function isTSTypeParameter(node, opts) {
-	if (!node) return false;
-	if (node.type !== "TSTypeParameter") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("TSTypeParameter", node, opts);
 }
 function isStandardized(node, opts) {
 	if (!node) return false;
@@ -6814,6 +6321,7 @@ function isTSType$1(node, opts) {
 		case "TSTupleType":
 		case "TSOptionalType":
 		case "TSRestType":
+		case "TSNamedTupleMember":
 		case "TSUnionType":
 		case "TSIntersectionType":
 		case "TSConditionalType":
@@ -6856,27 +6364,19 @@ function isTSBaseType(node, opts) {
 }
 function isNumberLiteral(node, opts) {
 	deprecationWarning$1("isNumberLiteral", "isNumericLiteral");
-	if (!node) return false;
-	if (node.type !== "NumberLiteral") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("NumberLiteral", node, opts);
 }
 function isRegexLiteral(node, opts) {
 	deprecationWarning$1("isRegexLiteral", "isRegExpLiteral");
-	if (!node) return false;
-	if (node.type !== "RegexLiteral") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("RegexLiteral", node, opts);
 }
 function isRestProperty$1(node, opts) {
 	deprecationWarning$1("isRestProperty", "isRestElement");
-	if (!node) return false;
-	if (node.type !== "RestProperty") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("RestProperty", node, opts);
 }
 function isSpreadProperty$1(node, opts) {
 	deprecationWarning$1("isSpreadProperty", "isSpreadElement");
-	if (!node) return false;
-	if (node.type !== "SpreadProperty") return false;
-	return opts == null || shallowEqual(node, opts);
+	return isType$1("SpreadProperty", node, opts);
 }
 function isModuleDeclaration(node, opts) {
 	deprecationWarning$1("isModuleDeclaration", "isImportOrExportDeclaration");
@@ -6915,7 +6415,7 @@ const isReactComponent = buildMatchMemberExpression$1("React.Component");
 function isCompatTag$1(tagName) {
 	return !!tagName && /^[a-z]/.test(tagName);
 }
-function isType$1(nodeType, targetType) {
+function isType$2(nodeType, targetType) {
 	if (nodeType === targetType) return true;
 	if (nodeType == null) return false;
 	if (ALIAS_KEYS[targetType]) return false;
@@ -6929,7 +6429,7 @@ function isPlaceholderType(placeholderType, targetType) {
 }
 function is(type, node, opts) {
 	if (!node) return false;
-	if (!isType$1(node.type, type)) {
+	if (!isType$2(node.type, type)) {
 		if (!opts && node.type === "Placeholder" && type in FLIPPED_ALIAS_KEYS$1) return isPlaceholderType(node.expectedNode, type);
 		return false;
 	}
@@ -7848,7 +7348,7 @@ defineType$4("MemberExpression", {
 defineType$4("NewExpression", {
 	inherits: "CallExpression",
 	fields: {
-		callee: { validate: assertNodeType("Expression") },
+		callee: { validate: assertNodeType("Expression", "V8IntrinsicIdentifier") },
 		arguments: validateArrayOfType("Expression", "SpreadElement", "ArgumentPlaceholder"),
 		typeArguments: {
 			validate: assertNodeType("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
@@ -8199,11 +7699,7 @@ defineType$4("AssignmentPattern", {
 	fields: {
 		...patternLikeCommon(),
 		left: { validate: assertNodeType("Identifier", "ObjectPattern", "ArrayPattern", "MemberExpression", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression") },
-		right: { validate: assertNodeType("Expression") },
-		decorators: {
-			validate: arrayOfType("Decorator"),
-			optional: true
-		}
+		right: { validate: assertNodeType("Expression") }
 	}
 });
 defineType$4("ArrayPattern", {
@@ -8302,7 +7798,7 @@ defineType$4("ClassExpression", {
 			optional: true,
 			validate: assertNodeType("Expression")
 		},
-		["superTypeArguments"]: {
+		superTypeArguments: {
 			validate: assertNodeType("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
 			optional: true
 		},
@@ -8342,7 +7838,7 @@ defineType$4("ClassDeclaration", {
 			optional: true,
 			validate: assertNodeType("Expression")
 		},
-		["superTypeArguments"]: {
+		superTypeArguments: {
 			validate: assertNodeType("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
 			optional: true
 		},
@@ -8472,7 +7968,7 @@ defineType$4("ExportSpecifier", {
 	visitor: ["local", "exported"],
 	aliases: ["ModuleSpecifier"],
 	fields: {
-		local: { validate: assertNodeType("Identifier") },
+		local: { validate: assertNodeType("Identifier", "StringLiteral") },
 		exported: { validate: assertNodeType("Identifier", "StringLiteral") },
 		exportKind: {
 			validate: assertOneOf("type", "value"),
@@ -8624,11 +8120,11 @@ const classMethodOrPropertyCommon = () => ({
 	},
 	key: { validate: chain(function() {
 		const normal = assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral");
-		const computed = assertNodeType("Expression");
+		const computed = assertNodeType("Expression", "PrivateName");
 		return function(node, key, val) {
 			(node.computed ? computed : normal)(node, key, val);
 		};
-	}(), assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression")) }
+	}(), assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression", "PrivateName")) }
 });
 const classMethodOrDeclareMethodCommon = (allowDecorators = true) => ({
 	...functionCommon(),
@@ -8716,7 +8212,7 @@ defineType$4("TaggedTemplateExpression", {
 	fields: {
 		tag: { validate: assertNodeType("Expression") },
 		quasi: { validate: assertNodeType("TemplateLiteral") },
-		["typeArguments"]: {
+		typeArguments: {
 			validate: assertNodeType("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
 			optional: true
 		}
@@ -9435,7 +8931,7 @@ defineType$3("TupleTypeAnnotation", {
 defineType$3("TypeofTypeAnnotation", {
 	visitor: ["argument"],
 	aliases: ["FlowType"],
-	fields: { argument: validateType("FlowType") }
+	fields: { argument: validateType("FlowType", "Identifier") }
 });
 defineType$3("TypeAlias", {
 	visitor: [
@@ -9456,7 +8952,7 @@ defineType$3("TypeAlias", {
 });
 defineType$3("TypeAnnotation", {
 	visitor: ["typeAnnotation"],
-	fields: { typeAnnotation: validateType("FlowType") }
+	fields: { typeAnnotation: validateType("FlowType", "Identifier") }
 });
 defineType$3("TypeCastExpression", {
 	visitor: ["expression", "typeAnnotation"],
@@ -9902,7 +9398,7 @@ defineType("TSDeclareMethod", {
 		"params",
 		"returnType"
 	],
-	...classMethodOrPropertyUnionShapeCommon(),
+	...classMethodOrPropertyUnionShapeCommon(true),
 	fields: {
 		...classMethodOrDeclareMethodCommon(false),
 		...tSFunctionTypeAnnotationCommon()
@@ -9918,8 +9414,8 @@ defineType("TSQualifiedName", {
 });
 const signatureDeclarationCommon = () => ({
 	typeParameters: validateOptionalType("TSTypeParameterDeclaration"),
-	["params"]: validateArrayOfType("ArrayPattern", "Identifier", "ObjectPattern", "RestElement"),
-	["returnType"]: validateOptionalType("TSTypeAnnotation")
+	params: validateArrayOfType("ArrayPattern", "Identifier", "ObjectPattern", "RestElement"),
+	returnType: validateOptionalType("TSTypeAnnotation")
 });
 const callConstructSignatureDeclaration = {
 	aliases: ["TSTypeElement"],
@@ -10025,7 +9521,7 @@ defineType("TSTypeReference", {
 	visitor: ["typeName", "typeArguments"],
 	fields: {
 		typeName: validateType("TSEntityName"),
-		["typeArguments"]: validateOptionalType("TSTypeParameterInstantiation")
+		typeArguments: validateOptionalType("TSTypeParameterInstantiation")
 	}
 });
 defineType("TSTypePredicate", {
@@ -10047,7 +9543,7 @@ defineType("TSTypeQuery", {
 	visitor: ["exprName", "typeArguments"],
 	fields: {
 		exprName: validateType("TSEntityName", "TSImportType"),
-		["typeArguments"]: validateOptionalType("TSTypeParameterInstantiation")
+		typeArguments: validateOptionalType("TSTypeParameterInstantiation")
 	}
 });
 defineType("TSTypeLiteral", {
@@ -10076,6 +9572,7 @@ defineType("TSRestType", {
 	fields: { typeAnnotation: validateType("TSType") }
 });
 defineType("TSNamedTupleMember", {
+	aliases: ["TSType"],
 	visitor: ["label", "elementType"],
 	builder: [
 		"label",
@@ -10253,7 +9750,7 @@ defineType("TSInstantiationExpression", {
 	visitor: ["expression", "typeArguments"],
 	fields: {
 		expression: validateType("Expression"),
-		["typeArguments"]: validateOptionalType("TSTypeParameterInstantiation")
+		typeArguments: validateOptionalType("TSTypeParameterInstantiation")
 	}
 });
 const TSTypeExpression = {
@@ -15145,7 +14642,7 @@ function isBlockScoped$1(node) {
 	return isFunctionDeclaration$1(node) || isClassDeclaration$2(node) || isLet(node);
 }
 function isImmutable(node) {
-	if (isType$1(node.type, "Immutable")) return true;
+	if (isType$2(node.type, "Immutable")) return true;
 	if (isIdentifier$7(node)) {
 		if (node.name === "undefined") return true;
 		else return false;
@@ -15278,7 +14775,7 @@ const react$1 = {
 	buildChildren
 };
 //#endregion
-//#region ../../node_modules/.pnpm/@babel+parser@8.0.4/node_modules/@babel/parser/lib/index.js
+//#region ../../node_modules/.pnpm/@babel+parser@8.0.5/node_modules/@babel/parser/lib/index.js
 var Position = class {
 	constructor(line, col, index) {
 		this.line = void 0;
@@ -15655,7 +15152,7 @@ const estree = (superClass) => class ESTreeParserMixin extends superClass {
 			bigInt = null;
 		}
 		const node = this.estreeParseLiteral(bigInt);
-		node.bigint = String(node.value || value);
+		node.bigint = node.value !== null ? String(node.value) : value;
 		return node;
 	}
 	estreeParseLiteral(value) {
@@ -17652,7 +17149,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 		if (this.flowPragma === void 0 && !this.isValidDirective(stmt)) this.flowPragma = null;
 		return stmt;
 	}
-	parseExpressionStatement(node, expr, decorators) {
+	parseExpressionStatement(node, expr) {
 		if (expr.type === "Identifier") {
 			if (expr.name === "declare") {
 				if (this.match(76) || tokenIsIdentifier(this.state.type) || this.match(64) || this.match(70) || this.match(78)) return this.flowParseDeclare(node);
@@ -17662,7 +17159,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 				else if (expr.name === "opaque") return this.flowParseOpaqueType(node, false);
 			}
 		}
-		return super.parseExpressionStatement(node, expr, decorators);
+		return super.parseExpressionStatement(node, expr);
 	}
 	shouldParseExportDeclaration() {
 		const { type } = this.state;
@@ -17721,7 +17218,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 		this.expect(10);
 		node.test = expr;
 		node.consequent = consequent;
-		node.alternate = this.forwardNoArrowParamsConversionAt(node, () => this.parseMaybeAssign(void 0, void 0));
+		node.alternate = this.forwardNoArrowParamsConversionAt(node, () => this.parseMaybeAssign());
 		return this.finishNode(node, "ConditionalExpression");
 	}
 	tryParseConditionalConsequent() {
@@ -18086,12 +17583,12 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 	shouldParseAsyncArrow() {
 		return this.match(10) || super.shouldParseAsyncArrow();
 	}
-	parseMaybeAssign(refExpressionErrors, afterLeftParse) {
+	parseMaybeAssign(refExpressionErrors, isParenItem) {
 		let state = null;
 		let jsx;
 		if (this.hasPlugin("jsx") && (this.match(138) || this.match(43))) {
 			state = this.state.clone();
-			jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);
+			jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, isParenItem), state);
 			if (!jsx.error) return jsx.node;
 			const { context } = this.state;
 			const currentContext = context[context.length - 1];
@@ -18103,7 +17600,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 			const arrow = this.tryParse((abort) => {
 				typeParameters = this.flowParseTypeParameterDeclaration();
 				const arrowExpression = this.forwardNoArrowParamsConversionAt(typeParameters, () => {
-					const result = super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
+					const result = super.parseMaybeAssign(refExpressionErrors, isParenItem);
 					this.resetStartLocationFromNode(result, typeParameters);
 					return result;
 				});
@@ -18134,7 +17631,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 			if (arrow.thrown) throw arrow.error;
 			throw this.raise(FlowErrors.UnexpectedTokenAfterTypeParameter, typeParameters);
 		}
-		return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
+		return super.parseMaybeAssign(refExpressionErrors, isParenItem);
 	}
 	parseArrow(node) {
 		if (this.match(10)) {
@@ -18951,7 +18448,7 @@ const jsx = (superClass) => class JSXParserMixin extends superClass {
 				++this.state.pos;
 			}
 			const codePoint = this.readInt(radix, void 0, false, "bail");
-			if (codePoint !== null && this.codePointAtPos(this.state.pos) === 59) {
+			if (codePoint !== null && codePoint <= 1114111 && this.codePointAtPos(this.state.pos) === 59) {
 				++this.state.pos;
 				return String.fromCodePoint(codePoint);
 			}
@@ -20045,7 +19542,8 @@ var Tokenizer$1 = class extends CommentsParser {
 	}
 	skipSpace() {
 		const spaceStart = this.state.pos;
-		const comments = this.optionFlags & 8192 ? [] : null;
+		const attachComment = (this.optionFlags & 8192) > 0;
+		let comments;
 		loop: while (this.state.pos < this.length) {
 			const ch = this.input.charCodeAt(this.state.pos);
 			switch (ch) {
@@ -20068,7 +19566,7 @@ var Tokenizer$1 = class extends CommentsParser {
 							const comment = this.skipBlockComment("*/");
 							if (comment !== void 0) {
 								this.addComment(comment);
-								comments?.push(comment);
+								if (attachComment) (comments ?? (comments = [])).push(comment);
 							}
 							break;
 						}
@@ -20076,7 +19574,7 @@ var Tokenizer$1 = class extends CommentsParser {
 							const comment = this.skipLineComment(2);
 							if (comment !== void 0) {
 								this.addComment(comment);
-								comments?.push(comment);
+								if (attachComment) (comments ?? (comments = [])).push(comment);
 							}
 							break;
 						}
@@ -20090,7 +19588,7 @@ var Tokenizer$1 = class extends CommentsParser {
 						const comment = this.skipLineComment(3);
 						if (comment !== void 0) {
 							this.addComment(comment);
-							comments?.push(comment);
+							if (attachComment) (comments ?? (comments = [])).push(comment);
 						}
 					} else break loop;
 				} else if (ch === 60 && !this.inModule && this.optionFlags & 16384) {
@@ -20099,13 +19597,13 @@ var Tokenizer$1 = class extends CommentsParser {
 						const comment = this.skipLineComment(4);
 						if (comment !== void 0) {
 							this.addComment(comment);
-							comments?.push(comment);
+							if (attachComment) (comments ?? (comments = [])).push(comment);
 						}
 					} else break loop;
 				} else break loop;
 			}
 		}
-		if (comments?.length > 0) {
+		if (comments?.length) {
 			const end = this.state.pos;
 			const commentWhitespace = {
 				start: this.sourceToOffsetPos(spaceStart),
@@ -21224,7 +20722,7 @@ var LValParser = class extends NodeUtils {
 	parseSpread(refExpressionErrors) {
 		const node = this.startNode();
 		this.next();
-		node.argument = this.parseMaybeAssignAllowIn(refExpressionErrors, void 0);
+		node.argument = this.parseMaybeAssignAllowIn(refExpressionErrors);
 		return this.finishNode(node, "SpreadElement");
 	}
 	parseRestBinding() {
@@ -21451,23 +20949,23 @@ var ExpressionParser = class extends LValParser {
 		}
 		return expr;
 	}
-	parseMaybeAssignDisallowIn(refExpressionErrors, afterLeftParse) {
-		return this.disallowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse));
+	parseMaybeAssignDisallowIn(refExpressionErrors) {
+		return this.disallowInAnd(() => this.parseMaybeAssign(refExpressionErrors));
 	}
-	parseMaybeAssignAllowIn(refExpressionErrors, afterLeftParse) {
-		return this.allowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse));
+	parseMaybeAssignAllowIn(refExpressionErrors, isParenItem) {
+		return this.allowInAnd(() => this.parseMaybeAssign(refExpressionErrors, isParenItem));
 	}
 	setOptionalParametersError(refExpressionErrors) {
 		refExpressionErrors.optionalParametersLoc = this.state.startLoc;
 	}
-	parseMaybeAssign(refExpressionErrors, afterLeftParse) {
+	parseMaybeAssign(refExpressionErrors, isParenItem) {
 		const startLoc = this.state.startLoc;
 		const isYield = this.isContextual(104);
 		if (isYield) {
 			if (this.prodParam.hasYield) {
 				this.next();
 				let left = this.parseYield(startLoc);
-				if (afterLeftParse) left = afterLeftParse.call(this, left, startLoc);
+				if (isParenItem) left = this.parseParenItem(left, startLoc);
 				return left;
 			}
 		}
@@ -21479,7 +20977,7 @@ var ExpressionParser = class extends LValParser {
 		}
 		this.state.canStartArrow = true;
 		let left = this.parseMaybeConditional(refExpressionErrors);
-		if (afterLeftParse) left = afterLeftParse.call(this, left, startLoc);
+		if (isParenItem) left = this.parseParenItem(left, startLoc);
 		if (tokenIsAssignment(this.state.type)) {
 			const node = this.startNodeAt(startLoc);
 			const operator = this.state.value;
@@ -21715,9 +21213,10 @@ var ExpressionParser = class extends LValParser {
 		const node = this.startNodeAt(startLoc);
 		node.object = base;
 		this.next();
-		const isImport = this.match(79);
-		const callee = this.parseNoCallExpr();
-		if (callee.type === "Super" || isImport && callee.type === "ImportExpression" || callee.type === "Import") throw this.raise(Errors.UnsupportedBindRHS, callee);
+		const callee = this.parseNoCallExpr((base) => {
+			throw this.raise(Errors.UnsupportedBindRHS, base);
+		});
+		if (callee.type === "Super" || callee.type === "Import") throw this.raise(Errors.UnsupportedBindRHS, callee);
 		node.callee = callee;
 		state.stop = true;
 		return this.parseSubscripts(this.finishNode(node, "BindExpression"), startLoc, false);
@@ -21796,9 +21295,12 @@ var ExpressionParser = class extends LValParser {
 		if (call.callee.trailingComments) setInnerComments(node, call.callee.trailingComments);
 		return node;
 	}
-	parseNoCallExpr() {
+	parseNoCallExpr(onUnparenthesizedImportExpression) {
 		const startLoc = this.state.startLoc;
-		return this.parseSubscripts(this.parseExprAtom(), startLoc, true);
+		const isImport = this.match(79);
+		const base = this.parseExprAtom();
+		if (isImport && base.type === "ImportExpression") onUnparenthesizedImportExpression(base);
+		return this.parseSubscripts(base, startLoc, true);
 	}
 	parseExprAtom(refExpressionErrors) {
 		let node;
@@ -21845,7 +21347,9 @@ var ExpressionParser = class extends LValParser {
 				node = this.startNode();
 				this.next();
 				node.object = null;
-				const callee = node.callee = this.parseNoCallExpr();
+				const callee = node.callee = this.parseNoCallExpr((base) => {
+					throw this.raise(Errors.UnsupportedBind, base);
+				});
 				if (callee.type === "MemberExpression") return this.finishNode(node, "BindExpression");
 				else throw this.raise(Errors.UnsupportedBind, callee);
 			}
@@ -22078,7 +21582,7 @@ var ExpressionParser = class extends LValParser {
 				spreadStartLoc = this.state.startLoc;
 				exprList.push(this.parseParenItem(this.parseRestBinding(), spreadNodeStartLoc));
 				if (!this.checkCommaAfterRest(41)) break;
-			} else exprList.push(this.parseMaybeAssignAllowInOrVoidPattern(7, refExpressionErrors, this.parseParenItem));
+			} else exprList.push(this.parseMaybeAssignAllowInOrVoidPattern(7, refExpressionErrors, true));
 		}
 		const innerEndLoc = this.state.lastTokEndLoc;
 		this.expect(7);
@@ -22146,10 +21650,10 @@ var ExpressionParser = class extends LValParser {
 		return this.finishNode(node, "NewExpression");
 	}
 	parseNewCallee(node) {
-		const isImport = this.match(79);
-		const callee = this.parseNoCallExpr();
+		const callee = this.parseNoCallExpr((base) => {
+			this.raise(Errors.ImportCallNotNewExpression, base, base);
+		});
 		node.callee = callee;
-		if (isImport && callee.type === "ImportExpression") this.raise(Errors.ImportCallNotNewExpression, callee, callee);
 		if (callee.type === "Import") this.raise(Errors.ImportCallNotNewExpression, callee);
 		if (callee.type === "Super") this.raise(Errors.SuperCallNotNewExpression, callee);
 	}
@@ -22348,7 +21852,7 @@ var ExpressionParser = class extends LValParser {
 					key = this.parsePrivateName();
 					break;
 				}
-				default: this.unexpected();
+				default: throw this.unexpected();
 			}
 			prop.key = key;
 			if (type !== 134) prop.computed = false;
@@ -22462,7 +21966,7 @@ var ExpressionParser = class extends LValParser {
 			const node = this.startNode();
 			this.next();
 			elt = this.finishNode(node, "ArgumentPlaceholder");
-		} else elt = this.parseMaybeAssignAllowInOrVoidPattern(close, refExpressionErrors, this.parseParenItem);
+		} else elt = this.parseMaybeAssignAllowInOrVoidPattern(close, refExpressionErrors, true);
 		return elt;
 	}
 	parseIdentifier(liberal) {
@@ -22666,12 +22170,12 @@ var ExpressionParser = class extends LValParser {
 		this.next();
 		return this.finishNode(node, "VoidPattern");
 	}
-	parseMaybeAssignAllowInOrVoidPattern(close, refExpressionErrors, afterLeftParse) {
+	parseMaybeAssignAllowInOrVoidPattern(close, refExpressionErrors, isParenItem) {
 		if (refExpressionErrors != null && this.match(84)) {
 			const nextCode = this.lookaheadCharCode();
 			if (nextCode === 44 || nextCode === (close === 1 ? 93 : close === 4 ? 125 : 41) || nextCode === 61) return this.parseMaybeDefault(this.state.startLoc, this.parseVoidPattern(refExpressionErrors));
 		}
-		return this.parseMaybeAssignAllowIn(refExpressionErrors, afterLeftParse);
+		return this.parseMaybeAssignAllowIn(refExpressionErrors, isParenItem);
 	}
 	parsePropertyNamePrefixOperator(prop) {}
 };
@@ -22888,7 +22392,7 @@ var StatementParser = class extends ExpressionParser {
 		const maybeName = this.state.value;
 		const expr = this.parseExpression();
 		if (tokenIsIdentifier(startType) && expr.type === "Identifier" && this.eat(10)) return this.parseLabeledStatement(node, maybeName, expr, flags);
-		else return this.parseExpressionStatement(node, expr, decorators);
+		else return this.parseExpressionStatement(node, expr);
 	}
 	assertModuleNodeAllowed(node) {
 		if (!(this.optionFlags & 8) && !this.inModule) this.raise(Errors.ImportOutsideModule, node);
@@ -23040,7 +22544,7 @@ var StatementParser = class extends ExpressionParser {
 				const init = this.finishNode(initNode, "VariableDeclaration");
 				const isForIn = this.match(54);
 				if (isForIn && starsWithUsingDeclaration) this.raise(Errors.ForInUsing, init);
-				if ((isForIn || this.isContextual(98)) && init.declarations.length === 1) return this.parseForIn(node, init, awaitAt);
+				if ((isForIn || this.isContextual(98)) && init.declarations.length === 1) return this.parseForX(node, init, awaitAt);
 				if (awaitAt !== null) this.unexpected(awaitAt);
 				return this.parseFor(node, init);
 			}
@@ -23058,7 +22562,7 @@ var StatementParser = class extends ExpressionParser {
 			this.toAssignable(init, true);
 			const type = isForOf ? "ForOfStatement" : "ForInStatement";
 			this.checkLVal(init, { type });
-			return this.parseForIn(node, init, awaitAt);
+			return this.parseForX(node, init, awaitAt);
 		} else this.checkExpressionErrors(refExpressionErrors, true);
 		if (awaitAt !== null) this.unexpected(awaitAt);
 		return this.parseFor(node, init);
@@ -23194,7 +22698,7 @@ var StatementParser = class extends ExpressionParser {
 		node.label = expr;
 		return this.finishNode(node, "LabeledStatement");
 	}
-	parseExpressionStatement(node, expr, decorators) {
+	parseExpressionStatement(node, expr) {
 		node.expression = expr;
 		this.semicolon();
 		return this.finishNode(node, "ExpressionStatement");
@@ -23253,7 +22757,7 @@ var StatementParser = class extends ExpressionParser {
 		this.state.labels.pop();
 		return this.finishNode(node, "ForStatement");
 	}
-	parseForIn(node, init, awaitAt) {
+	parseForX(node, init, awaitAt) {
 		const isForIn = this.match(54);
 		this.next();
 		if (isForIn) {
@@ -23617,7 +23121,7 @@ var StatementParser = class extends ExpressionParser {
 		} else hasDeclaration = this.maybeParseExportDeclaration(node);
 		if (isFromRequired || hasSpecifiers || hasDeclaration) {
 			const node2 = node;
-			this.checkExport(node2, true, false, !!node2.source);
+			this.checkNamedExport(node2, !!node2.source);
 			if (node2.declaration?.type === "ClassDeclaration") this.maybeTakeDecorators(decorators, node2.declaration, node2);
 			else if (decorators) throw this.raise(Errors.UnsupportedDecoratorExport, node);
 			this.sawUnambiguousESM = true;
@@ -23629,7 +23133,10 @@ var StatementParser = class extends ExpressionParser {
 			node2.declaration = decl;
 			if (decl.type === "ClassDeclaration") this.maybeTakeDecorators(decorators, decl, node2);
 			else if (decorators) throw this.raise(Errors.UnsupportedDecoratorExport, node);
-			this.checkExport(node2, true, true);
+			this.checkDuplicateExports(node, "default");
+			if (this.hasPlugin("exportDefaultFrom")) {
+				if (decl.type === "Identifier" && decl.name === "from" && decl.end - decl.start === 4 && !decl.extra?.parenthesized) this.raise(Errors.ExportDefaultFromAsIdentifier, decl);
+			}
 			this.sawUnambiguousESM = true;
 			return this.finishNode(node2, "ExportDefaultDeclaration");
 		}
@@ -23734,7 +23241,6 @@ var StatementParser = class extends ExpressionParser {
 	parseExportFrom(node, expect) {
 		if (this.eatContextual(94)) {
 			node.source = this.parseImportSource();
-			this.checkExport(node);
 			this.maybeParseImportAttributes(node);
 		} else if (expect) this.unexpected();
 		this.semicolon();
@@ -23755,38 +23261,30 @@ var StatementParser = class extends ExpressionParser {
 		}
 		return type === 70 || type === 71 || type === 64 || type === 76 || this.isLet() || this.isAsyncFunction();
 	}
-	checkExport(node, checkNames, isDefault, isFrom) {
-		if (checkNames) {
-			if (isDefault) {
-				this.checkDuplicateExports(node, "default");
-				if (this.hasPlugin("exportDefaultFrom")) {
-					const declaration = node.declaration;
-					if (declaration.type === "Identifier" && declaration.name === "from" && declaration.end - declaration.start === 4 && !declaration.extra?.parenthesized) this.raise(Errors.ExportDefaultFromAsIdentifier, declaration);
-				}
-			} else if (node.specifiers?.length) for (const specifier of node.specifiers) {
-				const { exported } = specifier;
-				const exportName = exported.type === "Identifier" ? exported.name : exported.value;
-				this.checkDuplicateExports(specifier, exportName);
-				if (!isFrom && specifier.local) {
-					const { local } = specifier;
-					if (local.type !== "Identifier") this.raise(Errors.ExportBindingIsString, specifier, {
-						localName: local.value,
-						exportName
-					});
-					else {
-						this.checkReservedWord(local.name, local.start, true, false);
-						this.scope.checkLocalExport(local);
-					}
+	checkNamedExport(node, isFrom) {
+		if (node.specifiers?.length) for (const specifier of node.specifiers) {
+			const { exported } = specifier;
+			const exportName = exported.type === "Identifier" ? exported.name : exported.value;
+			this.checkDuplicateExports(specifier, exportName);
+			if (!isFrom && specifier.type === "ExportSpecifier") {
+				const { local } = specifier;
+				if (local.type !== "Identifier") this.raise(Errors.ExportBindingIsString, specifier, {
+					localName: local.value,
+					exportName
+				});
+				else {
+					this.checkReservedWord(local.name, local.start, true, false);
+					this.scope.checkLocalExport(local);
 				}
 			}
-			else if (node.declaration) {
-				const decl = node.declaration;
-				if (decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration") {
-					const { id } = decl;
-					if (!id) throw new Error("Assertion failure");
-					this.checkDuplicateExports(node, id.name);
-				} else if (decl.type === "VariableDeclaration") for (const declaration of decl.declarations) this.checkDeclaration(declaration.id);
-			}
+		}
+		else if (node.declaration) {
+			const decl = node.declaration;
+			if (decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration") {
+				const { id } = decl;
+				if (!id) throw new Error("Assertion failure");
+				this.checkDuplicateExports(node, id.name);
+			} else if (decl.type === "VariableDeclaration") for (const declaration of decl.declarations) this.checkDeclaration(declaration.id);
 		}
 	}
 	checkDeclaration(node) {
@@ -24113,45 +23611,64 @@ function tsIsEntityName(node) {
 		default: return false;
 	}
 }
+const ClassMemberModifiers = buildModifiersMap([
+	"declare",
+	"private",
+	"public",
+	"protected",
+	"override",
+	"abstract",
+	"readonly",
+	"static"
+], ["in", "out"]);
+const IndexSignatureModifiers = buildModifiersMap(["readonly"], [
+	"declare",
+	"abstract",
+	"private",
+	"protected",
+	"public",
+	"static",
+	"override"
+]);
+const BindingElementModifiers = buildModifiersMap([
+	"public",
+	"private",
+	"protected",
+	"override",
+	"readonly"
+]);
+const AccessModifiers = buildModifiersMap([
+	"private",
+	"public",
+	"protected"
+]);
 const typescript = (superClass) => class TypeScriptParserMixin extends superClass {
 	constructor(..._args5) {
 		super(..._args5);
-		require_generator._defineProperty(this, "tsParseInOutModifiers", this.tsParseModifiers.bind(this, {
-			allowedModifiers: ["in", "out"],
-			disallowedModifiers: [
-				"const",
-				"public",
-				"private",
-				"protected",
-				"readonly",
-				"declare",
-				"abstract",
-				"override"
-			],
-			errorTemplate: TSErrors.InvalidModifierOnTypeParameter
-		}));
-		require_generator._defineProperty(this, "tsParseConstModifier", this.tsParseModifiers.bind(this, {
-			allowedModifiers: ["const"],
-			disallowedModifiers: ["in", "out"],
-			errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
-		}));
-		require_generator._defineProperty(this, "tsParseInOutConstModifiers", this.tsParseModifiers.bind(this, {
-			allowedModifiers: [
-				"in",
-				"out",
-				"const"
-			],
-			disallowedModifiers: [
-				"public",
-				"private",
-				"protected",
-				"readonly",
-				"declare",
-				"abstract",
-				"override"
-			],
-			errorTemplate: TSErrors.InvalidModifierOnTypeParameter
-		}));
+		require_generator._defineProperty(this, "tsParseInOutModifiers", this.tsParseModifiers.bind(this, buildModifiersMap(["in", "out"], [
+			"const",
+			"public",
+			"private",
+			"protected",
+			"readonly",
+			"declare",
+			"abstract",
+			"override"
+		]), TSErrors.InvalidModifierOnTypeParameter));
+		require_generator._defineProperty(this, "tsParseConstModifier", this.tsParseModifiers.bind(this, buildModifiersMap(["const"], ["in", "out"]), TSErrors.InvalidModifierOnTypeParameterPositions));
+		require_generator._defineProperty(this, "tsParseInOutConstModifiers", this.tsParseModifiers.bind(this, buildModifiersMap([
+			"in",
+			"out",
+			"const"
+		], [
+			"public",
+			"private",
+			"protected",
+			"readonly",
+			"declare",
+			"abstract",
+			"override"
+		]), TSErrors.InvalidModifierOnTypeParameter));
 	}
 	getScopeHandler() {
 		return TypeScriptScopeHandler;
@@ -24174,16 +23691,16 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		}
 		return this.tsNextTokenOnSameLineAndCanFollowModifier();
 	}
-	tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock, hasSeenStaticModifier) {
+	tsParseModifier(modifiers, stopOnStartOfClassStaticBlock, hasSeenStaticModifier) {
 		if (!tokenIsIdentifier(this.state.type) && this.state.type !== 54 && this.state.type !== 71) return;
 		const modifier = this.state.value;
-		if (allowedModifiers.includes(modifier)) {
+		if (modifiers.has(modifier)) {
 			if (hasSeenStaticModifier && this.match(102)) return;
 			if (stopOnStartOfClassStaticBlock && this.tsIsStartOfStaticBlocks()) return;
 			if (this.tsTryParse(this.tsNextTokenCanFollowModifier.bind(this))) return modifier;
 		}
 	}
-	tsParseModifiers({ allowedModifiers, disallowedModifiers, stopOnStartOfClassStaticBlock, errorTemplate = TSErrors.InvalidModifierOnTypeMember }, modified) {
+	tsParseModifiers(modifiers, errorTemplate = TSErrors.InvalidModifierOnTypeMember, modified, stopOnStartOfClassStaticBlock = false) {
 		const enforceOrder = (loc, modifier, before, after) => {
 			if (modifier === before && modified[after]) this.raise(TSErrors.InvalidModifiersOrder, loc, { orderedModifiers: [before, after] });
 		};
@@ -24192,7 +23709,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		};
 		for (;;) {
 			const { startLoc } = this.state;
-			const modifier = this.tsParseModifier(allowedModifiers.concat(disallowedModifiers ?? []), stopOnStartOfClassStaticBlock, modified.static);
+			const modifier = this.tsParseModifier(modifiers, stopOnStartOfClassStaticBlock, modified.static);
 			if (!modifier) break;
 			if (tsIsAccessModifier(modifier)) {
 				if (modified.accessibility) this.raise(TSErrors.DuplicateAccessibilityModifier, startLoc, { modifier });
@@ -24218,7 +23735,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 				}
 				modified[modifier] = true;
 			}
-			if (disallowedModifiers?.includes(modifier)) this.raise(errorTemplate, startLoc, { modifier });
+			if (!modifiers.get(modifier)) this.raise(errorTemplate, startLoc, { modifier });
 		}
 	}
 	tsIsListTerminator(kind) {
@@ -24472,18 +23989,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 				return this.tsParsePropertyOrMethodSignature(node, false);
 			}
 		}
-		this.tsParseModifiers({
-			allowedModifiers: ["readonly"],
-			disallowedModifiers: [
-				"declare",
-				"abstract",
-				"private",
-				"protected",
-				"public",
-				"static",
-				"override"
-			]
-		}, node);
+		this.tsParseModifiers(IndexSignatureModifiers, void 0, node);
 		const idx = this.tsTryParseIndexSignature(node);
 		if (idx) return idx;
 		super.parsePropertyName(node);
@@ -25271,13 +24777,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 	parseBindingElement(flags, decorators) {
 		const startLoc = decorators.length ? null : this.state.startLoc;
 		const modified = {};
-		this.tsParseModifiers({ allowedModifiers: [
-			"public",
-			"private",
-			"protected",
-			"override",
-			"readonly"
-		] }, modified);
+		this.tsParseModifiers(BindingElementModifiers, void 0, modified);
 		const accessibility = modified.accessibility;
 		const override = modified.override;
 		const readonly = modified.readonly;
@@ -25619,11 +25119,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		return super.parseStatementContent(flags, decorators);
 	}
 	parseAccessModifier() {
-		return this.tsParseModifier([
-			"public",
-			"protected",
-			"private"
-		]);
+		return this.tsParseModifier(AccessModifiers);
 	}
 	tsHasSomeModifiers(member, modifiers) {
 		return modifiers.some((modifier) => {
@@ -25635,27 +25131,21 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		return this.isContextual(102) && this.lookaheadCharCode() === 123;
 	}
 	parseClassMember(classBody, member, state) {
-		const modifiers = [
-			"declare",
-			"private",
-			"public",
-			"protected",
-			"override",
-			"abstract",
-			"readonly",
-			"static"
-		];
-		this.tsParseModifiers({
-			allowedModifiers: modifiers,
-			disallowedModifiers: ["in", "out"],
-			stopOnStartOfClassStaticBlock: true,
-			errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
-		}, member);
+		this.tsParseModifiers(ClassMemberModifiers, TSErrors.InvalidModifierOnTypeParameterPositions, member, true);
 		const callParseClassMemberWithIsStatic = () => {
 			if (this.tsIsStartOfStaticBlocks()) {
 				this.next();
 				this.next();
-				if (this.tsHasSomeModifiers(member, modifiers)) this.raise(TSErrors.StaticBlockCannotHaveModifier, this.state.curPosition());
+				if (this.tsHasSomeModifiers(member, [
+					"declare",
+					"private",
+					"public",
+					"protected",
+					"override",
+					"abstract",
+					"readonly",
+					"static"
+				])) this.raise(TSErrors.StaticBlockCannotHaveModifier, this.state.curPosition());
 				super.parseClassStaticBlock(classBody, member);
 			} else this.parseClassMemberWithIsStatic(classBody, member, state, !!member.static);
 		};
@@ -25836,24 +25326,24 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		if (this.match(10)) node.returnType = this.tsParseTypeAnnotation();
 		return super.parseAsyncArrowFromCallExpression(node, call);
 	}
-	parseMaybeAssign(refExpressionErrors, afterLeftParse) {
+	parseMaybeAssign(refExpressionErrors, isParenItem) {
 		let state;
 		let jsx;
 		let typeCast;
 		if (this.hasPlugin("jsx") && (this.match(138) || this.match(43))) {
 			state = this.state.clone();
-			jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);
+			jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, isParenItem), state);
 			if (!jsx.error) return jsx.node;
 			const { context } = this.state;
 			const currentContext = context[context.length - 1];
 			if (currentContext === types.j_oTag || currentContext === types.j_expr) context.pop();
 		}
-		if (!jsx?.error && !this.match(43)) return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
+		if (!jsx?.error && !this.match(43)) return super.parseMaybeAssign(refExpressionErrors, isParenItem);
 		if (!state || state === this.state) state = this.state.clone();
 		let typeParameters;
 		const arrow = this.tryParse((abort) => {
 			typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);
-			const expr = super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
+			const expr = super.parseMaybeAssign(refExpressionErrors, isParenItem);
 			if (expr.type !== "ArrowFunctionExpression" || expr.extra?.parenthesized) abort();
 			if (typeParameters?.params.length !== 0) this.resetStartLocationFromNode(expr, typeParameters);
 			expr.typeParameters = typeParameters;
@@ -25869,7 +25359,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		}
 		if (!jsx) {
 			assert(!this.hasPlugin("jsx"));
-			typeCast = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);
+			typeCast = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, isParenItem), state);
 			if (!typeCast.error) return typeCast.node;
 		}
 		if (jsx?.node) {
@@ -26151,7 +25641,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 	}
 	parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) {
 		if (!isString && isMaybeTypeOnly) {
-			this.parseTypeOnlyImportExportSpecifier(node, false, isInTypeExport);
+			this.parseTypeOnlyExportSpecifier(node, isInTypeExport);
 			return this.finishNode(node, "ExportSpecifier");
 		}
 		node.exportKind = "value";
@@ -26159,20 +25649,15 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 	}
 	parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
 		if (!importedIsString && isMaybeTypeOnly) {
-			this.parseTypeOnlyImportExportSpecifier(specifier, true, isInTypeOnlyImport);
+			this.parseTypeOnlyImportSpecifier(specifier, isInTypeOnlyImport);
 			return this.finishNode(specifier, "ImportSpecifier");
 		}
 		specifier.importKind = "value";
 		return super.parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, isInTypeOnlyImport ? 4098 : 4096);
 	}
-	parseTypeOnlyImportExportSpecifier(node, isImport, isInTypeOnlyImportExport) {
-		const leftOfAsKey = isImport ? "imported" : "local";
-		const rightOfAsKey = isImport ? "local" : "exported";
-		let leftOfAs = node[leftOfAsKey];
-		let rightOfAs;
+	parseTypeOnlyImportSpecifier(node, isInTypeOnly) {
+		let leftOfAs = node.imported;
 		let hasTypeSpecifier = false;
-		let canParseAsKeyword = true;
-		const loc = leftOfAs.start;
 		if (this.isContextual(89)) {
 			const firstAs = this.parseIdentifier();
 			if (this.isContextual(89)) {
@@ -26180,34 +25665,47 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 				if (tokenIsKeywordOrIdentifier(this.state.type)) {
 					hasTypeSpecifier = true;
 					leftOfAs = firstAs;
-					rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();
-					canParseAsKeyword = false;
-				} else {
-					rightOfAs = secondAs;
-					canParseAsKeyword = false;
-				}
-			} else if (tokenIsKeywordOrIdentifier(this.state.type)) {
-				canParseAsKeyword = false;
-				rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();
-			} else {
+					node.local = this.parseIdentifier();
+				} else node.local = secondAs;
+			} else if (tokenIsKeywordOrIdentifier(this.state.type)) node.local = this.parseIdentifier();
+			else {
 				hasTypeSpecifier = true;
 				leftOfAs = firstAs;
 			}
 		} else if (tokenIsKeywordOrIdentifier(this.state.type)) {
 			hasTypeSpecifier = true;
-			if (isImport) {
-				leftOfAs = this.parseIdentifier(true);
-				if (!this.isContextual(89)) this.checkReservedWord(leftOfAs.name, leftOfAs.start, true, true);
-			} else leftOfAs = this.parseModuleExportName();
-		}
-		if (hasTypeSpecifier && isInTypeOnlyImportExport) this.raise(isImport ? TSErrors.TypeModifierIsUsedInTypeImports : TSErrors.TypeModifierIsUsedInTypeExports, loc);
-		node[leftOfAsKey] = leftOfAs;
-		node[rightOfAsKey] = rightOfAs;
-		const kindKey = isImport ? "importKind" : "exportKind";
-		node[kindKey] = hasTypeSpecifier ? "type" : "value";
-		if (canParseAsKeyword && this.eatContextual(89)) node[rightOfAsKey] = isImport ? this.parseIdentifier() : this.parseModuleExportName();
-		if (!node[rightOfAsKey]) node[rightOfAsKey] = this.cloneIdentifier(node[leftOfAsKey]);
-		if (isImport) this.checkIdentifier(node[rightOfAsKey], hasTypeSpecifier ? 4098 : 4096);
+			leftOfAs = this.parseIdentifier(true);
+			if (!this.isContextual(89)) this.checkReservedWord(leftOfAs.name, leftOfAs.start, true, true);
+		}
+		if (hasTypeSpecifier && isInTypeOnly) this.raise(TSErrors.TypeModifierIsUsedInTypeImports, node.imported);
+		node.imported = leftOfAs;
+		node.importKind = hasTypeSpecifier ? "type" : "value";
+		this.checkIdentifier(node.local ?? (node.local = this.eatContextual(89) ? this.parseIdentifier() : this.cloneIdentifier(node.imported)), hasTypeSpecifier ? 4098 : 4096);
+	}
+	parseTypeOnlyExportSpecifier(node, isInTypeOnly) {
+		const local = node.local;
+		let hasTypeSpecifier = false;
+		if (this.isContextual(89)) {
+			const firstAs = this.parseIdentifier();
+			if (this.isContextual(89)) {
+				const secondAs = this.parseIdentifier();
+				if (tokenIsKeywordOrIdentifier(this.state.type)) {
+					hasTypeSpecifier = true;
+					node.local = firstAs;
+					node.exported = this.parseModuleExportName();
+				} else node.exported = secondAs;
+			} else if (tokenIsKeywordOrIdentifier(this.state.type)) node.exported = this.parseModuleExportName();
+			else {
+				hasTypeSpecifier = true;
+				node.local = firstAs;
+			}
+		} else if (tokenIsKeywordOrIdentifier(this.state.type)) {
+			hasTypeSpecifier = true;
+			node.local = this.parseModuleExportName();
+		}
+		if (hasTypeSpecifier && isInTypeOnly) this.raise(TSErrors.TypeModifierIsUsedInTypeExports, local);
+		node.exportKind = hasTypeSpecifier ? "type" : "value";
+		node.exported ?? (node.exported = this.eatContextual(89) ? this.parseModuleExportName() : this.cloneIdentifier(node.local));
 	}
 	fillOptionalPropertiesForTSESLint(node) {
 		switch (node.type) {
@@ -26370,6 +25868,12 @@ function isUncomputedMemberExpressionChain(expression) {
 	if (expression.type !== "MemberExpression" || expression.computed) return false;
 	return isUncomputedMemberExpressionChain(expression.object);
 }
+function buildModifiersMap(allowed, disallow = []) {
+	const map = /* @__PURE__ */ new Map();
+	for (const modifier of allowed) map.set(modifier, true);
+	for (const modifier of disallow) map.set(modifier, false);
+	return map;
+}
 const PlaceholderErrors = ParseErrorEnum`placeholders`({
 	ClassNameIsRequired: "A class name is required.",
 	UnexpectedSpace: "Unexpected space in placeholder."
@@ -26500,12 +26004,7 @@ const placeholders = (superClass) => class PlaceholdersParserMixin extends super
 		if (node.specifiers?.length) return true;
 		return super.maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier);
 	}
-	checkExport(node) {
-		const { specifiers } = node;
-		if (specifiers?.length) node.specifiers = specifiers.filter((node) => node.exported.type === "Placeholder");
-		super.checkExport(node);
-		node.specifiers = specifiers;
-	}
+	checkNamedExport() {}
 	parseImport(node) {
 		const placeholder = this.parsePlaceholder("Identifier");
 		if (!placeholder) return super.parseImport(node);
@@ -26785,11 +26284,11 @@ var builtin_upper_default = [
 var comma = ",".charCodeAt(0);
 var semicolon = ";".charCodeAt(0);
 var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-var intToChar = /* @__PURE__ */ new Uint8Array(64);
+var intToChar$1 = /* @__PURE__ */ new Uint8Array(64);
 var charToInt = /* @__PURE__ */ new Uint8Array(128);
 for (let i = 0; i < chars.length; i++) {
 	const c = chars.charCodeAt(i);
-	intToChar[i] = c;
+	intToChar$1[i] = c;
 	charToInt[c] = i;
 }
 function decodeInteger(reader) {
@@ -26811,7 +26310,7 @@ function encodeInteger(builder, num) {
 		let clamped = num & 31;
 		num >>>= 5;
 		if (num > 0) clamped |= 32;
-		builder.write(intToChar[clamped]);
+		builder.write(intToChar$1[clamped]);
 	} while (num > 0);
 }
 function encodeSign(num) {
@@ -26865,6 +26364,21 @@ var StringReader = class {
 		return idx === -1 ? buffer.length : idx;
 	}
 };
+function encodeRangeMappings(decoded) {
+	if (decoded.length === 0) return "";
+	const writer = new StringWriter();
+	for (let i = 0; i < decoded.length; i++) {
+		const indices = decoded[i];
+		if (i > 0) writer.write(semicolon);
+		let index = 0;
+		for (let j = 0; j < indices.length; j++) {
+			const offset = indices[j];
+			encodeInteger(writer, offset - index);
+			index = offset;
+		}
+	}
+	return writer.flush();
+}
 function decode(mappings) {
 	const { length } = mappings;
 	const reader = new StringReader(mappings);
@@ -27271,7 +26785,7 @@ function traceSegmentInternal(segments, memo, line, column, bias) {
 	return index;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@jridgewell+gen-mapping@0.3.13/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs
+//#region ../../node_modules/.pnpm/@jridgewell+gen-mapping@0.4.0-beta.0/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs
 var SetArray = class {
 	constructor() {
 		this._indexes = { __proto__: null };
@@ -27305,6 +26819,7 @@ var GenMapping = class {
 		this.file = file;
 		this.sourceRoot = sourceRoot;
 		this._ignoreList = new SetArray();
+		this._rangeMappings = [];
 	}
 };
 function cast2(map) {
@@ -27318,9 +26833,23 @@ function setSourceContent(map, source, content) {
 	const index = put(sources, source);
 	sourcesContent[index] = content;
 }
+function setRangeSegment(map, line, column, add = true) {
+	const { _mappings: mappings, _rangeMappings: rangeMappings } = cast2(map);
+	const index = getSegmentIndex(getLine(mappings, line), column) - 1;
+	const ranges = getLine(rangeMappings, line);
+	const i = getRangeIndex(ranges, index);
+	if (add) {
+		if (i >= 0) return;
+		insert(ranges, ~i, index);
+	} else {
+		if (i < 0) return;
+		ranges.splice(i, 1);
+	}
+}
 function toDecodedMap(map) {
-	const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, _ignoreList: ignoreList } = cast2(map);
+	const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, _ignoreList: { array: ignoreList }, _rangeMappings: rangeMappings } = cast2(map);
 	removeEmptyFinalLines(mappings);
+	removeEmptyFinalLines(rangeMappings);
 	return {
 		version: 3,
 		file: map.file || void 0,
@@ -27329,16 +26858,20 @@ function toDecodedMap(map) {
 		sources: sources.array,
 		sourcesContent,
 		mappings,
-		ignoreList: ignoreList.array
+		ignoreList: ignoreList.length > 0 ? ignoreList : void 0,
+		rangeMappings: rangeMappings.length > 0 ? rangeMappings : void 0
 	};
 }
 function toEncodedMap(map) {
 	const decoded = toDecodedMap(map);
-	return Object.assign({}, decoded, { mappings: encode(decoded.mappings) });
+	const encoded = decoded;
+	encoded.mappings = encode(decoded.mappings);
+	if (decoded.rangeMappings) encoded.rangeMappings = encodeRangeMappings(decoded.rangeMappings);
+	return encoded;
 }
 function allMappings(map) {
 	const out = [];
-	const { _mappings: mappings, _sources: sources, _names: names } = cast2(map);
+	const { _mappings: mappings, _sources: { array: sources }, _names: { array: names } } = cast2(map);
 	for (let i = 0; i < mappings.length; i++) {
 		const line = mappings[i];
 		for (let j = 0; j < line.length; j++) {
@@ -27351,12 +26884,12 @@ function allMappings(map) {
 			let original = void 0;
 			let name = void 0;
 			if (seg.length !== 1) {
-				source = sources.array[seg[SOURCES_INDEX]];
+				source = sources[seg[SOURCES_INDEX]];
 				original = {
 					line: seg[SOURCE_LINE] + 1,
 					column: seg[SOURCE_COLUMN]
 				};
-				if (seg.length === 5) name = names.array[seg[NAMES_INDEX]];
+				if (seg.length === 5) name = names[seg[NAMES_INDEX]];
 			}
 			out.push({
 				generated,
@@ -27369,18 +26902,21 @@ function allMappings(map) {
 	return out;
 }
 function addSegmentInternal(skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) {
-	const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names } = cast2(map);
-	const line = getIndex(mappings, genLine);
-	const index = getColumnIndex(line, genColumn);
+	const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, _rangeMappings: rangeMappings } = cast2(map);
+	const line = getLine(mappings, genLine);
+	const index = getSegmentIndex(line, genColumn);
 	if (!source) {
-		if (skipable && skipSourceless(line, index)) return;
-		return insert(line, index, [genColumn]);
+		if (skipable && skipSourceless(line, index) && !isRangeOpen(mappings, rangeMappings, genLine, index - 1)) return;
+		if (index < line.length) adjustRangeMappings(rangeMappings, genLine, index);
+		insert(line, index, [genColumn]);
+		return;
 	}
 	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 ? [
+	if (skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex) && !isRangeOpen(mappings, rangeMappings, genLine, index - 1)) return;
+	if (index < line.length) adjustRangeMappings(rangeMappings, genLine, index);
+	insert(line, index, name ? [
 		genColumn,
 		sourcesIndex,
 		sourceLine,
@@ -27393,24 +26929,53 @@ function addSegmentInternal(skipable, map, genLine, genColumn, source, sourceLin
 		sourceColumn
 	]);
 }
-function getIndex(arr, index) {
+function getLine(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--) if (genColumn >= line[i][COLUMN]) break;
-	return index;
+function getSegmentIndex(line, genColumn) {
+	for (let i = line.length; i > 0; i--) if (genColumn >= line[i - 1][COLUMN]) return i;
+	return 0;
+}
+function isRangeOpen(mappings, rangeMappings, genLine, index) {
+	if (rangeMappings.length === 0) return false;
+	if (index < 0) while (--genLine >= 0) {
+		const segments = mappings[genLine];
+		if (segments.length > 0) {
+			index = segments.length - 1;
+			break;
+		}
+	}
+	if (genLine < 0) return false;
+	if (genLine >= rangeMappings.length) return false;
+	const ranges = rangeMappings[genLine];
+	return getRangeIndex(ranges, index) >= 0;
 }
 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;
+	for (let i = mappings.length - 1; i >= 0; i--) {
+		if (mappings[i].length > 0) break;
+		mappings.pop();
+	}
+}
+function getRangeIndex(ranges, index) {
+	for (let i = ranges.length; i > 0; i--) {
+		const range = ranges[i - 1];
+		if (range === index) return i - 1;
+		if (range < index) return ~i;
+	}
+	return -1;
+}
+function adjustRangeMappings(rangeMappings, genLine, index) {
+	if (genLine >= rangeMappings.length) return;
+	const line = rangeMappings[genLine];
+	for (let i = line.length - 1; i >= 0; i--) {
+		if (line[i] < index) break;
+		line[i]++;
+	}
 }
 function skipSourceless(line, index) {
 	if (index === 0) return true;
@@ -27423,9 +26988,10 @@ function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIn
 	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);
-	return addSegmentInternal(skipable, map, generated.line - 1, generated.column, source, original.line - 1, original.column, name, content);
+	const { generated, source, original, name, content, isRange } = mapping;
+	if (!source) addSegmentInternal(skipable, map, generated.line - 1, generated.column, null, null, null, null, null);
+	else addSegmentInternal(skipable, map, generated.line - 1, generated.column, source, original.line - 1, original.column, name, content);
+	if (isRange) setRangeSegment(map, generated.line - 1, generated.column);
 }
 //#endregion
 //#region ../../node_modules/.pnpm/jsesc@3.1.0/node_modules/jsesc/jsesc.js
@@ -27634,7 +27200,7 @@ var require_jsesc = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exp
 	module.exports = jsesc;
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/@babel+generator@8.0.0/node_modules/@babel/generator/lib/index.js
+//#region ../../node_modules/.pnpm/@babel+generator@8.0.5/node_modules/@babel/generator/lib/index.js
 var import_jsesc = /* @__PURE__ */ require_rolldown_runtime.__toESM(require_jsesc(), 1);
 var SourceMap$1 = class {
 	constructor(opts, code) {
@@ -27657,10 +27223,14 @@ var SourceMap$1 = class {
 		else if (typeof code === "object") for (const sourceFileName of Object.keys(code)) setSourceContent(map, sourceFileName.replace(/\\/g, "/"), code[sourceFileName]);
 	}
 	get() {
-		return toEncodedMap(this._map);
+		const encoded = toEncodedMap(this._map);
+		encoded.ignoreList ?? (encoded.ignoreList = []);
+		return encoded;
 	}
 	getDecoded() {
-		return toDecodedMap(this._map);
+		const decoded = toDecodedMap(this._map);
+		decoded.ignoreList ?? (decoded.ignoreList = []);
+		return decoded;
 	}
 	getRawMappings() {
 		return this._rawMappings || (this._rawMappings = allMappings(this._map));
@@ -30847,6 +30417,19 @@ function newCalleeNeedsParens(node) {
 		case "TaggedTemplateExpression":
 			current = current.tag;
 			break;
+		case "TSInstantiationExpression":
+		case "TSNonNullExpression":
+			current = current.expression;
+			break;
+		default: return false;
+	}
+}
+function templateTagNeedsParens(node) {
+	let current = node;
+	while (true) switch (current.type) {
+		case "OptionalCallExpression":
+		case "OptionalMemberExpression": return true;
+		case "TSInstantiationExpression":
 		case "TSNonNullExpression":
 			current = current.expression;
 			break;
@@ -30858,6 +30441,9 @@ function parentNeedsParens(node, parent, parentId) {
 		case 113:
 			if (parent.callee === node) return newCalleeNeedsParens(node);
 			break;
+		case 220:
+			if (parent.tag === node) return templateTagNeedsParens(node);
+			break;
 		case 43: return !isDecoratorMemberExpression(node) && !(node.type === "CallExpression" && isDecoratorMemberExpression(node.callee)) && node.type !== "ParenthesizedExpression";
 	}
 	return false;
@@ -32033,7 +31619,7 @@ const index = Object.assign(smart.bind(void 0), {
 	ast: smart.ast
 });
 //#endregion
-//#region ../../node_modules/.pnpm/@babel+traverse@8.0.4/node_modules/@babel/traverse/lib/index.js
+//#region ../../node_modules/.pnpm/@babel+traverse@8.0.5/node_modules/@babel/traverse/lib/index.js
 const virtualTypes = /*#__PURE__*/ Object.defineProperty({
 	__proto__: null,
 	BindingIdentifier: ["Identifier"],
@@ -32329,7 +31915,7 @@ function verify$1(visitor) {
 	for (const nodeType of Object.keys(visitor)) {
 		if (nodeType === "enter" || nodeType === "exit") validateVisitorMethods(nodeType, visitor[nodeType]);
 		if (shouldIgnoreKey(nodeType)) continue;
-		if (!TYPES.includes(nodeType)) throw new Error(`You gave us a visitor for the node type ${nodeType} but it's not a valid type in @babel/traverse 8.0.4`);
+		if (!TYPES.includes(nodeType)) throw new Error(`You gave us a visitor for the node type ${nodeType} but it's not a valid type in @babel/traverse 8.0.5`);
 		const visitors = visitor[nodeType];
 		if (typeof visitors === "object") for (const visitorKey of Object.keys(visitors)) if (visitorKey === "enter" || visitorKey === "exit") validateVisitorMethods(`${nodeType}.${visitorKey}`, visitors[visitorKey]);
 		else throw new Error(`You passed \`traverse()\` a visitor object with the property ${nodeType} that has the invalid property ${visitorKey}`);
@@ -33720,8 +33306,8 @@ const hooks = [
 		}
 	},
 	function(self, parent) {
-		if (parent.isSequenceExpression() && parent.node.expressions.length === 1) {
-			parent.replaceWith(parent.node.expressions[0]);
+		if (parent.isSequenceExpression() && parent.node.expressions.length === 2) {
+			parent.replaceWith(parent.node.expressions[self.key === 0 ? 1 : 0]);
 			return true;
 		}
 	},
@@ -35171,23 +34757,17 @@ function getNextSibling() {
 	return this.getSibling(this.key + 1);
 }
 function getAllNextSiblings() {
-	let _key = this.key;
-	let sibling = this.getSibling(++_key);
-	const siblings = [];
-	while (sibling.node) {
-		siblings.push(sibling);
-		sibling = this.getSibling(++_key);
-	}
+	const _key = this.key;
+	if (!Number.isInteger(_key)) return [];
+	const siblings = [], containerLength = this.container.length;
+	for (let key = _key + 1; key < containerLength; key++) siblings.push(this.getSibling(key));
 	return siblings;
 }
 function getAllPrevSiblings() {
-	let _key = this.key;
-	let sibling = this.getSibling(--_key);
+	const _key = this.key;
+	if (!Number.isInteger(_key)) return [];
 	const siblings = [];
-	while (sibling.node) {
-		siblings.push(sibling);
-		sibling = this.getSibling(--_key);
-	}
+	for (let key = _key - 1; key >= 0; key--) siblings.push(this.getSibling(key));
 	return siblings;
 }
 function get(key, context = true) {
@@ -35790,7 +35370,7 @@ function babelParse(code, opts = {}) {
 	return result;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/magic-string@1.2.3/node_modules/magic-string/dist/index.mjs
+//#region ../../node_modules/.pnpm/magic-string@1.4.1/node_modules/magic-string/dist/index.mjs
 var BitSet = class BitSet {
 	constructor(arg) {
 		this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
@@ -35901,8 +35481,10 @@ var Chunk = class Chunk {
 		if (this.outro.length) return true;
 		const trimmed = this.content.replace(rx, "");
 		if (trimmed.length) {
-			if (trimmed !== this.content) if (this.edited) this.edit(trimmed, this.storeName, true);
-			else this.split(this.start + trimmed.length).edit("", void 0, true);
+			if (trimmed !== this.content) {
+				if (this.edited) this.edit(trimmed, this.storeName, true);
+				else this.split(this.start + trimmed.length).edit("", void 0, true);
+			}
 			return true;
 		} else {
 			this.edit("", void 0, true);
@@ -35915,10 +35497,12 @@ var Chunk = class Chunk {
 		if (this.intro.length) return true;
 		const trimmed = this.content.replace(rx, "");
 		if (trimmed.length) {
-			if (trimmed !== this.content) if (this.edited) this.edit(trimmed, this.storeName, true);
-			else {
-				this.split(this.end - trimmed.length);
-				this.edit("", void 0, true);
+			if (trimmed !== this.content) {
+				if (this.edited) this.edit(trimmed, this.storeName, true);
+				else {
+					this.split(this.end - trimmed.length);
+					this.edit("", void 0, true);
+				}
 			}
 			return true;
 		} else {
@@ -35941,12 +35525,14 @@ var MagicStringError = class extends Error {
 	}
 };
 function getBtoa() {
+	/* v8 ignore next -- environment fallback, unreachable when `btoa` is present */
 	if (typeof globalThis !== "undefined" && typeof globalThis.btoa === "function") return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
 	const buffer = globalThis["Buffer"];
 	if (buffer) return (str) => buffer.from(str, "utf-8").toString("base64");
 	return () => {
 		throw new MagicStringError("unsupported environment: `btoa` or `Buffer` is required");
 	};
+	/* v8 ignore stop */
 }
 const btoa = /* #__PURE__ */ getBtoa();
 var SourceMap = class {
@@ -35956,9 +35542,17 @@ var SourceMap = class {
 		this.sources = properties.sources;
 		this.sourcesContent = properties.sourcesContent;
 		this.names = properties.names;
-		this.mappings = encode(properties.mappings);
+		this.mappings = typeof properties.mappings === "string" ? properties.mappings : encode(properties.mappings);
 		if (typeof properties.x_google_ignoreList !== "undefined") this.x_google_ignoreList = properties.x_google_ignoreList;
 		if (typeof properties.debugId !== "undefined") this.debugId = properties.debugId;
+		if (typeof properties.rangeMappings !== "undefined") {
+			let shouldOutputRangeMapping = false;
+			for (const line of properties.rangeMappings) if (line.length !== 0) {
+				shouldOutputRangeMapping = true;
+				break;
+			}
+			if (shouldOutputRangeMapping) this.rangeMappings = encodeRangeMappings(properties.rangeMappings);
+		}
 	}
 	/**
 	* Returns the equivalent of `JSON.stringify(map)`
@@ -35975,12 +35569,8 @@ var SourceMap = class {
 	}
 };
 function getLocator(source) {
-	const originalLines = source.split("\n");
-	const lineOffsets = [];
-	for (let i = 0, pos = 0; i < originalLines.length; i++) {
-		lineOffsets.push(pos);
-		pos += originalLines[i].length + 1;
-	}
+	const lineOffsets = [0];
+	for (let i = source.indexOf("\n"); i !== -1; i = source.indexOf("\n", i + 1)) lineOffsets.push(i + 1);
 	return function locate(index) {
 		let i = 0;
 		let j = lineOffsets.length;
@@ -36026,15 +35616,120 @@ const toString = Object.prototype.toString;
 function isObject(thing) {
 	return toString.call(thing) === "[object Object]";
 }
-const wordRegex = /\w/;
+const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const intToChar = /* #__PURE__ */ (() => {
+	const chars = /* @__PURE__ */ new Uint8Array(64);
+	for (let i = 0; i < 64; i++) chars[i] = BASE64_CHARS.charCodeAt(i);
+	return chars;
+})();
+const COMMA = 44;
+const SEMICOLON = 59;
+const BUFFER_SIZE = 16384;
+const FLUSH_THRESHOLD = 16348;
+const scratch = /* #__PURE__ */ new Uint8Array(BUFFER_SIZE);
+function writeVlq(pos, num) {
+	num = num < 0 ? -num << 1 | 1 : num << 1;
+	do {
+		let clamped = num & 31;
+		num >>>= 5;
+		if (num > 0) clamped |= 32;
+		scratch[pos++] = intToChar[clamped];
+	} while (num > 0);
+	return pos;
+}
+const decoder = /* #__PURE__ */ new TextDecoder();
+var MappingsEncoder = class {
+	constructor() {
+		this.out = "";
+		this.pos = 0;
+		this.lines = [];
+		this.buffered = 0;
+		this.needsComma = false;
+		this.prevGenColumn = 0;
+		this.prevSourceIndex = 0;
+		this.prevSourceLine = 0;
+		this.prevSourceColumn = 0;
+		this.prevNameIndex = 0;
+	}
+	endLine(segments) {
+		this.lines.push(segments);
+		this.buffered += segments.length + 1;
+		if (this.buffered >= 4096) this.drain(null);
+	}
+	segments(segments) {
+		this.drain(segments);
+	}
+	finish(segments) {
+		this.drain(segments);
+		this.flush();
+		return this.out;
+	}
+	drain(trailing) {
+		const lines = this.lines;
+		const lineCount = lines.length;
+		for (let l = 0; l <= lineCount; l++) {
+			const line = l < lineCount ? lines[l] : trailing;
+			if (line === null) break;
+			for (let i = 0; i < line.length; i++) {
+				if (this.pos > FLUSH_THRESHOLD) this.flush();
+				const segment = line[i];
+				if (this.needsComma) scratch[this.pos++] = COMMA;
+				this.needsComma = true;
+				this.pos = writeVlq(this.pos, segment[0] - this.prevGenColumn);
+				this.prevGenColumn = segment[0];
+				this.pos = writeVlq(this.pos, segment[1] - this.prevSourceIndex);
+				this.prevSourceIndex = segment[1];
+				this.pos = writeVlq(this.pos, segment[2] - this.prevSourceLine);
+				this.prevSourceLine = segment[2];
+				this.pos = writeVlq(this.pos, segment[3] - this.prevSourceColumn);
+				this.prevSourceColumn = segment[3];
+				if (segment.length === 5) {
+					this.pos = writeVlq(this.pos, segment[4] - this.prevNameIndex);
+					this.prevNameIndex = segment[4];
+				}
+			}
+			if (l < lineCount) {
+				if (this.pos > FLUSH_THRESHOLD) this.flush();
+				scratch[this.pos++] = SEMICOLON;
+				this.needsComma = false;
+				this.prevGenColumn = 0;
+			}
+		}
+		lines.length = 0;
+		this.buffered = 0;
+		this.flush();
+	}
+	flush() {
+		this.out += decoder.decode(scratch.subarray(0, this.pos));
+		this.pos = 0;
+	}
+};
+const NEWLINE_CHAR$1 = 10;
+function isWordCode(code) {
+	return code >= 97 && code <= 122 || code >= 65 && code <= 90 || code >= 48 && code <= 57 || code === 95;
+}
 var Mappings = class {
-	constructor(hires) {
+	constructor(hires, encoder = null) {
 		this.hires = hires;
 		this.generatedCodeLine = 0;
 		this.generatedCodeColumn = 0;
 		this.raw = [];
 		this.rawSegments = this.raw[this.generatedCodeLine] = [];
-		this.pending = null;
+		this.rawRangeMappings = [];
+		this.rawRangeMappingsIndices = this.rawRangeMappings[this.generatedCodeLine] = [];
+		this.encoder = encoder;
+	}
+	nextLine() {
+		if (this.encoder === null) {
+			this.generatedCodeLine += 1;
+			this.raw[this.generatedCodeLine] = this.rawSegments = [];
+		} else {
+			this.encoder.endLine(this.rawSegments);
+			this.rawSegments = [];
+			this.generatedCodeLine += 1;
+		}
+		this.generatedCodeColumn = 0;
+		this.rawRangeMappings[this.generatedCodeLine] = this.rawRangeMappingsIndices = [];
 	}
 	addEdit(sourceIndex, content, loc, nameIndex) {
 		if (content.length) {
@@ -36050,9 +35745,7 @@ var Mappings = class {
 				];
 				if (nameIndex >= 0) segment.push(nameIndex);
 				this.rawSegments.push(segment);
-				this.generatedCodeLine += 1;
-				this.raw[this.generatedCodeLine] = this.rawSegments = [];
-				this.generatedCodeColumn = 0;
+				this.nextLine();
 				previousContentLineEnd = contentLineEnd;
 				contentLineEnd = content.indexOf("\n", contentLineEnd + 1);
 			}
@@ -36065,63 +35758,122 @@ var Mappings = class {
 			if (nameIndex >= 0) segment.push(nameIndex);
 			this.rawSegments.push(segment);
 			this.advance(content.slice(previousContentLineEnd + 1));
-		} else if (this.pending) {
-			this.rawSegments.push(this.pending);
-			this.advance(content);
 		}
-		this.pending = null;
 	}
 	addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
-		let originalCharIndex = chunk.start;
-		let first = true;
-		let charInHiresBoundary = false;
-		while (originalCharIndex < chunk.end) {
-			if (original[originalCharIndex] === "\n") {
-				loc.line += 1;
-				loc.column = 0;
-				this.generatedCodeLine += 1;
-				this.raw[this.generatedCodeLine] = this.rawSegments = [];
-				this.generatedCodeColumn = 0;
-				first = true;
-				charInHiresBoundary = false;
-			} else {
-				if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
-					const segment = [
+		const end = chunk.end;
+		let i = chunk.start;
+		if (this.hires) {
+			const boundary = this.hires === "boundary";
+			const experimentalRange = this.hires === "experimental-range";
+			const encoder = experimentalRange ? null : this.encoder;
+			let charInHiresBoundary = false;
+			while (i < end) {
+				if (encoder !== null && this.rawSegments.length >= 4096) {
+					encoder.segments(this.rawSegments);
+					this.rawSegments.length = 0;
+				}
+				if (experimentalRange && i + 1 >= end) this.rawSegments.push([
+					this.generatedCodeColumn,
+					sourceIndex,
+					loc.line,
+					loc.column
+				]);
+				const code = original.charCodeAt(i);
+				if (code === NEWLINE_CHAR$1) {
+					loc.line += 1;
+					loc.column = 0;
+					this.nextLine();
+					charInHiresBoundary = false;
+				} else {
+					if (boundary) {
+						if (isWordCode(code)) {
+							if (!charInHiresBoundary) {
+								this.rawSegments.push([
+									this.generatedCodeColumn,
+									sourceIndex,
+									loc.line,
+									loc.column
+								]);
+								charInHiresBoundary = true;
+							}
+						} else {
+							this.rawSegments.push([
+								this.generatedCodeColumn,
+								sourceIndex,
+								loc.line,
+								loc.column
+							]);
+							charInHiresBoundary = false;
+						}
+					} else if (experimentalRange) {
+						if (i === chunk.start) {
+							this.rawRangeMappingsIndices.push(this.rawSegments.length);
+							this.rawSegments.push([
+								this.generatedCodeColumn,
+								sourceIndex,
+								loc.line,
+								loc.column
+							]);
+						}
+					} else this.rawSegments.push([
 						this.generatedCodeColumn,
 						sourceIndex,
 						loc.line,
 						loc.column
-					];
-					if (this.hires === "boundary") if (wordRegex.test(original[originalCharIndex])) {
-						if (!charInHiresBoundary) {
-							this.rawSegments.push(segment);
-							charInHiresBoundary = true;
+					]);
+					loc.column += 1;
+					this.generatedCodeColumn += 1;
+				}
+				i += 1;
+			}
+		} else {
+			const bits = sourcemapLocations.bits;
+			while (i < end) {
+				let newline = original.indexOf("\n", i);
+				if (newline === -1 || newline > end) newline = end;
+				if (newline > i) {
+					this.rawSegments.push([
+						this.generatedCodeColumn,
+						sourceIndex,
+						loc.line,
+						loc.column
+					]);
+					for (let w = i + 1 >> 5, last = newline - 1 >> 5; w <= last; w++) {
+						let word = bits[w];
+						if (!word) continue;
+						const base = w << 5;
+						while (word) {
+							const lowest = word & -word;
+							const index = base + 31 - Math.clz32(lowest);
+							if (index > i && index < newline) {
+								const offset = index - i;
+								this.rawSegments.push([
+									this.generatedCodeColumn + offset,
+									sourceIndex,
+									loc.line,
+									loc.column + offset
+								]);
+							}
+							word ^= lowest;
 						}
-					} else {
-						this.rawSegments.push(segment);
-						charInHiresBoundary = false;
 					}
-					else this.rawSegments.push(segment);
+					loc.column += newline - i;
+					this.generatedCodeColumn += newline - i;
 				}
-				loc.column += 1;
-				this.generatedCodeColumn += 1;
-				first = false;
+				if (newline === end) break;
+				loc.line += 1;
+				loc.column = 0;
+				this.nextLine();
+				i = newline + 1;
 			}
-			originalCharIndex += 1;
 		}
-		this.pending = null;
 	}
 	advance(str) {
 		if (!str) return;
-		const lines = str.split("\n");
-		if (lines.length > 1) {
-			for (let i = 0; i < lines.length - 1; i++) {
-				this.generatedCodeLine++;
-				this.raw[this.generatedCodeLine] = this.rawSegments = [];
-			}
-			this.generatedCodeColumn = 0;
-		}
-		this.generatedCodeColumn += lines[lines.length - 1].length;
+		const lastNewline = str.lastIndexOf("\n");
+		for (let i = str.indexOf("\n"); i !== -1; i = str.indexOf("\n", i + 1)) this.nextLine();
+		this.generatedCodeColumn += str.length - lastNewline - 1;
 	}
 };
 const n = "\n";
@@ -36132,6 +35884,63 @@ const warned = {
 	insertRight: false,
 	storeName: false
 };
+/**
+* Expands the `$` substitution patterns that `String.prototype.replace` accepts
+* in a string replacement.
+* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter
+*
+* `captures` holds the capture groups in order, so `captures[0]` is `$1`.
+* `namedCaptures` is `undefined` when the pattern has no named groups, and
+* `$<name>` is then literal text - which is also the case for a string search
+* value, where there are no groups of either kind.
+*/
+function expandReplacement(replacement, matched, position, str, captures, namedCaptures) {
+	if (!replacement.includes("$")) return replacement;
+	let result = "";
+	let index = 0;
+	while (index < replacement.length) {
+		const dollar = replacement.indexOf("$", index);
+		if (dollar === -1) {
+			result += replacement.slice(index);
+			break;
+		}
+		result += replacement.slice(index, dollar);
+		const char = replacement[dollar + 1];
+		let expansion = "$";
+		let consumed = 1;
+		if (char === "$") consumed = 2;
+		else if (char === "&") {
+			expansion = matched;
+			consumed = 2;
+		} else if (char === "`") {
+			expansion = str.slice(0, position);
+			consumed = 2;
+		} else if (char === "'") {
+			expansion = str.slice(position + matched.length);
+			consumed = 2;
+		} else if (char === "<" && namedCaptures !== void 0) {
+			const close = replacement.indexOf(">", dollar + 2);
+			if (close !== -1) {
+				expansion = namedCaptures[replacement.slice(dollar + 2, close)] ?? "";
+				consumed = close + 1 - dollar;
+			}
+		} else if (char >= "0" && char <= "9") {
+			const second = replacement[dollar + 2];
+			const double = second >= "0" && second <= "9" ? Number(char + second) : NaN;
+			const single = Number(char);
+			if (double >= 1 && double <= captures.length) {
+				expansion = captures[double - 1] ?? "";
+				consumed = 3;
+			} else if (single >= 1 && single <= captures.length) {
+				expansion = captures[single - 1] ?? "";
+				consumed = 2;
+			}
+		}
+		result += expansion;
+		index = dollar + consumed;
+	}
+	return result;
+}
 var MagicString = class MagicString {
 	constructor(string, options = {}) {
 		const chunk = new Chunk(0, string.length, string);
@@ -36282,9 +36091,32 @@ var MagicString = class MagicString {
 	*/
 	generateDecodedMap(options) {
 		options = options || {};
+		const mappings = new Mappings(options.hires);
+		const names = this._generateMappings(mappings);
+		return {
+			...this._mapProperties(options, names),
+			mappings: mappings.raw,
+			rangeMappings: mappings.rawRangeMappings
+		};
+	}
+	/**
+	* Generates a version 3 sourcemap.
+	*/
+	generateMap(options) {
+		options = options || {};
+		const encoder = new MappingsEncoder();
+		const mappings = new Mappings(options.hires, encoder);
+		const names = this._generateMappings(mappings);
+		return new SourceMap({
+			...this._mapProperties(options, names),
+			mappings: encoder.finish(mappings.rawSegments),
+			rangeMappings: mappings.rawRangeMappings
+		});
+	}
+	/** @internal */
+	_generateMappings(mappings) {
 		const sourceIndex = 0;
 		const names = Object.keys(this.storedNames);
-		const mappings = new Mappings(options.hires);
 		const locate = getLocator(this.original);
 		if (this.intro) mappings.advance(this.intro);
 		this.firstChunk.eachNext((chunk) => {
@@ -36295,21 +36127,18 @@ var MagicString = class MagicString {
 			if (chunk.outro.length) mappings.advance(chunk.outro);
 		});
 		if (this.outro) mappings.advance(this.outro);
+		return names;
+	}
+	/** @internal */
+	_mapProperties(options, names) {
 		return {
 			file: options.file ? options.file.split(/[/\\]/).pop() : void 0,
 			sources: [options.source ? getRelativePath(options.file || "", options.source) : options.file || ""],
 			sourcesContent: options.includeContent ? [this.original] : void 0,
 			names,
-			mappings: mappings.raw,
-			x_google_ignoreList: this.ignoreList ? [sourceIndex] : void 0
+			x_google_ignoreList: this.ignoreList ? [0] : void 0
 		};
 	}
-	/**
-	* Generates a version 3 sourcemap.
-	*/
-	generateMap(options) {
-		return new SourceMap(this.generateDecodedMap(options));
-	}
 	/** @internal */
 	_ensureindentStr() {
 		if (this.indentStr === void 0) this.indentStr = guessIndent(this.original);
@@ -36341,17 +36170,18 @@ var MagicString = class MagicString {
 			for (let i = exclusion[0]; i < exclusion[1]; i += 1) isExcluded[i] = true;
 		});
 		let shouldIndentNextCharacter = options.indentStart !== false;
-		const replacer = (match) => {
-			if (shouldIndentNextCharacter) return `${resolvedIndentStr}${match}`;
-			shouldIndentNextCharacter = true;
-			return match;
+		const indentPiece = (str) => {
+			if (str === "") return str;
+			const indented = str.replace(pattern, (match, offset) => offset > 0 || shouldIndentNextCharacter ? `${resolvedIndentStr}${match}` : match);
+			shouldIndentNextCharacter = str[str.length - 1] === "\n";
+			return indented;
 		};
-		this.intro = this.intro.replace(pattern, replacer);
+		this.intro = indentPiece(this.intro);
 		let charIndex = 0;
 		let chunk = this.firstChunk;
 		const indentAt = (index) => {
 			shouldIndentNextCharacter = false;
-			if (index === chunk.start) chunk.prependRight(resolvedIndentStr);
+			if (index === chunk.start) chunk.appendRight(resolvedIndentStr);
 			else {
 				this._splitChunk(chunk, index);
 				chunk = chunk.next;
@@ -36360,11 +36190,9 @@ var MagicString = class MagicString {
 		};
 		while (chunk) {
 			const end = chunk.end;
+			if (!isExcluded[chunk.start]) chunk.intro = indentPiece(chunk.intro);
 			if (chunk.edited) {
-				if (!isExcluded[charIndex]) {
-					chunk.content = chunk.content.replace(pattern, replacer);
-					if (chunk.content.length) shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === "\n";
-				}
+				if (!isExcluded[charIndex]) chunk.content = indentPiece(chunk.content);
 			} else if (options.exclude) {
 				charIndex = chunk.start;
 				while (charIndex < end) {
@@ -36394,10 +36222,11 @@ var MagicString = class MagicString {
 					charIndex += 1;
 				}
 			}
+			if (!isExcluded[chunk.end - 1]) chunk.outro = indentPiece(chunk.outro);
 			charIndex = chunk.end;
 			chunk = chunk.next;
 		}
-		this.outro = this.outro.replace(pattern, replacer);
+		this.outro = indentPiece(this.outro);
 		return this;
 	}
 	/** @internal */
@@ -36422,8 +36251,14 @@ var MagicString = class MagicString {
 	}
 	/**
 	* Moves the characters from `start` and `end` to `index`.
+	*
+	* `affinity` controls where the range is anchored at `index`. With the
+	* default `'right'`, it is inserted before the content that starts at `index`;
+	* with `'left'`, it is inserted after the content that ends at `index`. The
+	* two differ only when other content has already been moved to that boundary,
+	* mirroring the `appendLeft`/`appendRight` distinction.
 	*/
-	move(start, end, index) {
+	move(start, end, index, affinity = "right") {
 		start = start + this.offset;
 		end = end + this.offset;
 		index = index + this.offset;
@@ -36443,9 +36278,27 @@ var MagicString = class MagicString {
 		}
 		const oldLeft = first.previous;
 		const oldRight = last.next;
-		const newRight = this.byStart.get(index);
-		if (!newRight && last === this.lastChunk) return this;
-		const newLeft = newRight ? newRight.previous : this.lastChunk;
+		let newLeft;
+		let newRight;
+		if (affinity === "left") {
+			newLeft = this.byEnd.get(index) ?? null;
+			if (!newLeft) {
+				if (first === this.firstChunk) return this;
+				newRight = this.firstChunk;
+			} else {
+				if (newLeft.next === first) return this;
+				newRight = newLeft.next;
+			}
+		} else {
+			newRight = this.byStart.get(index) ?? null;
+			if (!newRight) {
+				if (last === this.lastChunk) return this;
+				newLeft = this.lastChunk;
+			} else {
+				if (newRight.previous === last) return this;
+				newLeft = newRight.previous;
+			}
+		}
 		if (oldLeft) oldLeft.next = oldRight;
 		if (oldRight) oldRight.previous = oldLeft;
 		if (newLeft) newLeft.next = first;
@@ -36520,6 +36373,7 @@ var MagicString = class MagicString {
 		}
 		const first = this.byStart.get(start);
 		const last = this.byEnd.get(end);
+		/* v8 ignore else -- unreachable: a valid start/end always yields a `first` chunk */
 		if (first) {
 			let chunk = first;
 			while (chunk !== last) {
@@ -36569,6 +36423,9 @@ var MagicString = class MagicString {
 	}
 	/**
 	* Removes the characters from `start` to `end` (of the original string, **not** the generated string).
+	* Content appended or prepended at positions strictly inside the range is removed with it, while
+	* content attached at `start` or `end` is preserved — use `s.overwrite(start, end, '')` to remove
+	* the range including its edge inserts.
 	* Removing the same content twice, or making removals that partially overlap, will cause an error.
 	*/
 	remove(start, end) {
@@ -36585,9 +36442,9 @@ var MagicString = class MagicString {
 		this._split(end);
 		let chunk = this.byStart.get(start);
 		while (chunk) {
-			chunk.intro = "";
-			chunk.outro = "";
-			chunk.edit("");
+			if (chunk.start > start) chunk.intro = "";
+			if (chunk.end < end) chunk.outro = "";
+			chunk.edit("", false, true);
 			chunk = end > chunk.end ? this.byStart.get(chunk.end) : null;
 		}
 		return this;
@@ -36667,12 +36524,13 @@ var MagicString = class MagicString {
 		let result = "";
 		let chunk = this.firstChunk;
 		while (chunk && (chunk.start > start || chunk.end <= start)) {
-			if (chunk.start < end && chunk.end >= end) return result;
+			if (chunk.start < end && chunk.end >= end || end === 0 && chunk.start === 0) return result;
 			chunk = chunk.next;
 		}
 		if (chunk && chunk.edited && chunk.start !== start) throw new MagicStringError(`cannot use edited character ${start} as slice start anchor`);
 		const startChunk = chunk;
 		while (chunk) {
+			if (end === 0 && chunk.start === 0) break;
 			if (chunk.intro && (startChunk !== chunk || chunk.start === start)) result += chunk.intro;
 			const containsEnd = chunk.start < end && chunk.end >= end;
 			if (containsEnd && chunk.edited && chunk.end !== end) throw new MagicStringError(`cannot use edited character ${end} as slice end anchor`);
@@ -36737,11 +36595,13 @@ var MagicString = class MagicString {
 	* Returns true if the resulting source is empty (disregarding white space).
 	*/
 	isEmpty() {
+		if (this.intro.length && this.intro.trim()) return false;
 		let chunk = this.firstChunk;
 		while (chunk) {
 			if (chunk.intro.length && chunk.intro.trim() || chunk.content.length && chunk.content.trim() || chunk.outro.length && chunk.outro.trim()) return false;
 			chunk = chunk.next;
 		}
+		if (this.outro.length && this.outro.trim()) return false;
 		return true;
 	}
 	length() {
@@ -36783,7 +36643,8 @@ var MagicString = class MagicString {
 			if (aborted) return true;
 			chunk = chunk.previous;
 		} while (chunk);
-		return false;
+		this.intro = this.intro.replace(rx, "");
+		return this.intro.length > 0;
 	}
 	/**
 	* Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the end.
@@ -36810,7 +36671,8 @@ var MagicString = class MagicString {
 			if (aborted) return true;
 			chunk = chunk.next;
 		} while (chunk);
-		return false;
+		this.outro = this.outro.replace(rx, "");
+		return this.outro.length > 0;
 	}
 	/**
 	* Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the start.
@@ -36837,41 +36699,66 @@ var MagicString = class MagicString {
 		}
 		return outputIndex !== this.original.length;
 	}
+	/**
+	* Whether the original range [start, end) has had any of its characters
+	* removed. `replace`/`replaceAll` search `original`, so a match can land on
+	* text that is no longer in the output - overwriting it would resurrect the
+	* removed characters, so such matches are skipped instead.
+	*
+	* @internal
+	*/
+	_hasRemovedContent(start, end) {
+		let chunk = this.firstChunk;
+		while (chunk) {
+			if (chunk.content === "" && chunk.start < end && chunk.end > start) return true;
+			chunk = chunk.next;
+		}
+		return false;
+	}
 	/** @internal */
 	_replaceRegexp(searchValue, replacement) {
 		function getReplacement(match, str) {
-			if (typeof replacement === "string") return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => {
-				if (i === "$") return "$";
-				if (i === "&") return match[0];
-				if (+i < match.length) return match[+i];
-				return `$${i}`;
-			});
-			else return replacement(match[0], ...match.slice(1), match.index, str, match.groups);
+			if (typeof replacement === "string") return expandReplacement(replacement, match[0], match.index, str, match.slice(1), match.groups);
+			else return match.groups === void 0 ? replacement(match[0], ...match.slice(1), match.index, str) : replacement(match[0], ...match.slice(1), match.index, str, match.groups);
 		}
 		const replaceMatch = (match) => {
-			if (match.index == null) return;
+			/* v8 ignore next 2 -- `match.index` is always defined for matches from `matchAll` */
+			if (match.index == null) return false;
+			if (this._hasRemovedContent(match.index, match.index + match[0].length)) return false;
 			const replacement = getReplacement(match, this.original);
-			if (replacement === match[0]) return;
+			if (replacement === match[0]) return true;
 			if (match[0].length === 0) this.appendRight(match.index, replacement);
 			else this.overwrite(match.index, match.index + match[0].length, replacement);
+			return true;
 		};
 		if (searchValue.global) {
 			searchValue.lastIndex = 0;
 			for (const match of this.original.matchAll(searchValue)) replaceMatch(match);
 		} else {
 			const match = this.original.match(searchValue);
-			if (match) replaceMatch(match);
+			if (match && !replaceMatch(match)) {
+				const global = new RegExp(searchValue.source, `${searchValue.flags}g`);
+				for (const next of this.original.matchAll(global)) if (replaceMatch(next)) break;
+			}
 		}
 		return this;
 	}
 	/** @internal */
 	_replaceString(string, replacement) {
 		const { original } = this;
-		const index = original.indexOf(string);
-		if (index !== -1) {
+		let index = original.indexOf(string);
+		while (index !== -1) {
+			if (this._hasRemovedContent(index, index + string.length)) {
+				index = original.indexOf(string, index + string.length);
+				continue;
+			}
 			if (typeof replacement === "function") replacement = replacement(string, index, original);
-			if (string !== replacement) if (string.length === 0) this.appendRight(index, replacement);
-			else this.overwrite(index, index + string.length, replacement);
+			else replacement = expandReplacement(replacement, string, index, original, [], void 0);
+			if (string !== replacement) {
+				if (string.length === 0) this.appendRight(index, replacement);
+				else this.overwrite(index, index + string.length, replacement);
+			}
+			break;
 		}
 		return this;
 	}
@@ -36888,14 +36775,15 @@ var MagicString = class MagicString {
 		const stringLength = string.length;
 		if (stringLength === 0) {
 			for (let index = 0; index <= original.length; index += 1) {
-				const _replacement = typeof replacement === "function" ? replacement("", index, original) : replacement;
+				const _replacement = typeof replacement === "function" ? replacement("", index, original) : expandReplacement(replacement, "", index, original, [], void 0);
 				if (_replacement !== "") this.appendRight(index, _replacement);
 			}
 			return this;
 		}
 		for (let index = original.indexOf(string); index !== -1; index = original.indexOf(string, index + stringLength)) {
+			if (this._hasRemovedContent(index, index + stringLength)) continue;
 			const previous = original.slice(index, index + stringLength);
-			const _replacement = typeof replacement === "function" ? replacement(previous, index, original) : replacement;
+			const _replacement = typeof replacement === "function" ? replacement(previous, index, original) : expandReplacement(replacement, previous, index, original, [], void 0);
 			if (previous !== _replacement) this.overwrite(index, index + stringLength, _replacement);
 		}
 		return this;
@@ -38337,7 +38225,7 @@ var CandidateIndex = class {
 			layer: "candidate-index",
 			keyFingerprint: createCompilerValueFingerprint(sourceId),
 			hit: addedCandidates.size === 0 && removedCandidates.size === 0,
-			invalidationReason: addedCandidates.size || removedCandidates.size ? "source-change" : void 0,
+			...addedCandidates.size || removedCandidates.size ? { invalidationReason: "source-change" } : {},
 			entries: this.candidatesBySource.size,
 			memoryBytes: [...this.candidatesBySource.values()].reduce((total, values) => total + values.size * 32, 0)
 		});
@@ -39326,7 +39214,7 @@ const readonlySetValues = /* @__PURE__ */ new WeakMap();
 const snapshotRegistry = /* @__PURE__ */ new WeakMap();
 var ImmutableSetView = class {
 	constructor(values) {
-		readonlySetValues.set(this, new Set(values));
+		readonlySetValues.set(this, values instanceof Set ? values : new Set(values));
 		Object.freeze(this);
 	}
 	get size() {
@@ -39371,29 +39259,32 @@ function uniqueSortedSources(sources) {
 	}
 	return Object.freeze([...values.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([, value]) => value));
 }
+function createFingerprint(parts) {
+	return (0, _weapp_tailwindcss_shared_node.md5)([...parts].join("\0"));
+}
 function createRootFingerprint(root, target, classSet, dependencies, sources) {
-	return [
+	return createFingerprint([
 		root.id,
 		String(root.revision),
 		target,
 		...[...classSet].sort(),
 		...dependencies,
 		...[...sources].map(sourceKey)
-	].join("\0");
+	]);
 }
 function createSnapshotFromState(state, reusableClassSet, reusableClassSetView) {
 	const roots = Object.freeze([...state.roots.values()].sort((left, right) => left.id.localeCompare(right.id)).map(({ id, revision }) => Object.freeze({
 		id,
 		revision
 	})));
-	const classSet = reusableClassSet ?? new Set(state.classSet);
-	const fingerprint = [
+	const classSet = reusableClassSet ?? (state.classSet instanceof Set ? state.classSet : new Set(state.classSet));
+	const fingerprint = createFingerprint([
 		state.target,
 		...[...state.roots.values()].map((root) => `${root.id}\0${root.revision}\0${root.fingerprint}`).sort(),
 		...[...classSet].sort(),
 		...state.dependencies,
 		...state.sources.map(sourceKey)
-	].join("\0");
+	]);
 	const snapshot = Object.freeze({
 		classSet: reusableClassSetView ?? new ImmutableSetView(classSet),
 		dependencies: state.dependencies,
@@ -39685,12 +39576,14 @@ async function collectTailwindV4GeneratorClassSet(tailwindRuntime) {
 	if (typeof tailwindRuntime.collectContentTokens !== "function") return;
 	try {
 		const source = require_generator.resolveCssMacroTailwindV4Source(await require_generator.resolveTailwindV4SourceFromRuntime(tailwindRuntime));
+		const bareArbitraryValues = require_generator.resolveRuntimeBareArbitraryValues(tailwindRuntime.options);
 		const generated = await require_generator.createTailwindV4Engine(source).generate({
+			...bareArbitraryValues === void 0 ? {} : { bareArbitraryValues },
 			scanSources: true,
 			target: "web"
 		});
 		const designSystem = await (0, _tailwindcss_mangle_engine.loadTailwindV4DesignSystem)(source);
-		const classSet = (0, _tailwindcss_mangle_engine.resolveValidTailwindV4Candidates)(designSystem, generated.classSet, { ...source.bareArbitraryValues === void 0 ? {} : { bareArbitraryValues: source.bareArbitraryValues } });
+		const classSet = (0, _tailwindcss_mangle_engine.resolveValidTailwindV4Candidates)(designSystem, generated.classSet, { ...bareArbitraryValues === void 0 ? {} : { bareArbitraryValues } });
 		debug$1("runtime class set resolved via tailwindcss v4 generator source scan, raw=%d valid=%d", generated.classSet.size, classSet.size);
 		return classSet;
 	} catch (error) {
@@ -40067,7 +39960,7 @@ function toCustomAttributesEntities(customAttributes) {
 	return Object.entries(customAttributes);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/oxc-walker@1.1.1_@oxc-project+types@0.149.0_oxc-parser@0.149.0_rolldown@1.2.7/node_modules/oxc-walker/dist/index.mjs
+//#region ../../node_modules/.pnpm/oxc-walker@1.1.1_@oxc-project+types@0.149.0_oxc-parser@0.150.0_rolldown@1.2.7/node_modules/oxc-walker/dist/index.mjs
 function isNode(v) {
 	return v !== null && typeof v === "object" && typeof v.type === "string";
 }
@@ -41118,10 +41011,10 @@ function syncLegacyFieldsToCssOptions(ctx) {
 }
 function applyFrameworkPlatformDefaults(ctx) {
 	if (ctx.cssOptions?.platform || ctx.platform) {
-		ctx.platform = normalizeFrameworkStylePlatform(ctx.cssOptions?.platform ?? ctx.platform, ctx.appType);
+		ctx.platform = normalizeFrameworkStylePlatform(ctx.cssOptions?.platform ?? ctx.platform, ctx.appType) ?? ctx.platform;
 		return;
 	}
-	if (ctx.appType === "mpx") ctx.platform = normalizeFrameworkStylePlatform(require_framework.resolveMpxPlatform().normalized, ctx.appType);
+	if (ctx.appType === "mpx") ctx.platform = normalizeFrameworkStylePlatform(require_framework.resolveMpxPlatform().normalized, ctx.appType) ?? ctx.platform;
 }
 async function clearTailwindcssRuntimeCache(tailwindRuntime, options) {
 	if (!tailwindRuntime) return;
@@ -41137,7 +41030,7 @@ async function clearTailwindcssRuntimeCache(tailwindRuntime, options) {
 	const normalizedCacheOptions = typeof cacheOptions === "object" ? cacheOptions : void 0;
 	const privateCachePath = tailwindRuntime?.cacheStore?.options?.path;
 	if (privateCachePath) cachePaths.set(privateCachePath, false);
-	if (normalizedCacheOptions?.path) cachePaths.set(normalizedCacheOptions.path, false);
+	if (normalizedCacheOptions && "path" in normalizedCacheOptions && typeof normalizedCacheOptions.path === "string") cachePaths.set(normalizedCacheOptions.path, false);
 	if (options?.removeDirectory && normalizedCacheOptions?.dir) cachePaths.set(normalizedCacheOptions.dir, true);
 	if (!cachePaths.size) return;
 	for (const [cachePath, recursive] of cachePaths.entries()) try {
@@ -41225,8 +41118,11 @@ function resolveCssTransformOptions(options) {
 	};
 }
 function finalizeResultRoot(result, snapshot, shouldFinalize) {
-	if (!shouldFinalize || result.root.type !== "root") return;
-	(0, _weapp_tailwindcss_postcss.finalizeMiniProgramCssRoot)(result.root, { isTailwindcssV4: snapshot.target === "weapp" });
+	if (!shouldFinalize) return;
+	if (result.root.type === "root") (0, _weapp_tailwindcss_postcss.finalizeMiniProgramCssRoot)(result.root, { isTailwindcssV4: snapshot.target === "weapp" });
+	if (snapshot.target === "weapp") result.root.walkComments((comment) => {
+		if (/^!\s*tailwindcss v/i.test(comment.text)) comment.remove();
+	});
 	result.css = result.root.toString();
 }
 function createCompilerTransforms({ ensureActive, track, userOptions }) {
@@ -41348,19 +41244,20 @@ function createCompiler(options = {}) {
 		const prepared = prepareCompilerGeneration(entry, request, source, !sourceReused || entry.appliedInvalidation !== invalidation);
 		const generationCacheKey = createCompilerGenerationCacheKey(request, prepared.compilation.candidates, target);
 		const reusableGeneration = engineReused && entry.generationCache && isSameCompilerGenerationCacheKey(entry.generationCache.key, generationCacheKey) ? entry.generationCache.result : void 0;
+		const latestRevision = getLatestRevision(entry);
 		cacheTelemetry?.record({
 			layer: "tailwind-generation",
 			keyFingerprint: generationCacheKey.candidateSignature,
 			hit: reusableGeneration !== void 0,
-			invalidationReason: reusableGeneration === void 0 && !engineReused ? "source-change" : void 0,
+			...reusableGeneration === void 0 && !engineReused ? { invalidationReason: "source-change" } : {},
 			entries: entry.generationCache ? 1 : 0,
-			revision: getLatestRevision(entry),
+			...latestRevision === void 0 ? {} : { revision: latestRevision },
 			operationId: entry.id
 		});
 		try {
 			const generated = reusableGeneration ? reuseCompilerGenerationResult(reusableGeneration) : await generator.generate({
 				...generateOptions,
-				candidates: prepared.explicitCandidates ? prepared.compilation.candidates : void 0,
+				...prepared.explicitCandidates ? { candidates: prepared.compilation.candidates } : {},
 				incrementalCache: generateOptions.incrementalCache ?? true,
 				target: target === "tailwind" ? "web" : target
 			});
@@ -41788,10 +41685,10 @@ function createJsRuntimeAffectingSignature(source) {
 		const stack = [ast];
 		while (stack.length > 0) {
 			const node = stack.pop();
-			if (node.type === "StringLiteral" && typeof node.value === "string") parts.push(`s:${node.value}`);
-			else if (node.type === "TemplateElement" && node.value && typeof node.value === "object" && "raw" in node.value && typeof node.value.raw === "string") parts.push(`t:${node.value.raw}`);
-			else if (node.type === "JSXText" && typeof node.value === "string") {
-				const value = node.value.trim();
+			if (node.type === "StringLiteral" && typeof node["value"] === "string") parts.push(`s:${node["value"]}`);
+			else if (node.type === "TemplateElement" && node["value"] && typeof node["value"] === "object" && "raw" in node["value"] && typeof node["value"].raw === "string") parts.push(`t:${node["value"].raw}`);
+			else if (node.type === "JSXText" && typeof node["value"] === "string") {
+				const value = node["value"].trim();
 				if (value.length > 0) parts.push(`x:${value}`);
 			}
 			const children = [];