@maz-ui/mcp 5.2.0-beta.0 → 5.3.0

package/dist/chunks/theme.mjs

@@ -1,19 +1,17 @@
 import { execFileSync } from 'node:child_process';
 import { existsSync, statSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { a as globSync } from '../shared/mcp.Ccxm-Aoc.mjs';
+import { a as globSync } from '../shared/mcp.ByQS-5Nc.mjs';
 import 'fs';
 import 'path';
 import 'url';
 import 'module';
-import '../shared/mcp.D3_Fk0U3.mjs';
+import '../shared/mcp.CXId5vdl.mjs';
 import 'node:buffer';
 import 'node:util';
-import 'node:process';
-import 'tty';
-import 'node:tty';
-import 'node:crypto';
 import 'node:url';
+import 'node:crypto';
+import 'node:process';
 
 class Position {
   constructor(line, col, index) {
@@ -108,6 +106,7 @@ const StandardErrors = {
   DecoratorSemicolon: "Decorators must not be followed by a semicolon.",
   DecoratorStaticBlock: "Decorators can't be used with a static block.",
   DeferImportRequiresNamespace: 'Only `import defer * as x from "./module"` is valid.',
+  DeferExportInvalidAll: '`export defer * from "./module"` is invalid. Explicitly list the re-exported names.',
   DeletePrivateField: "Deleting a private field is not allowed.",
   DestructureNamedImport: "ES2015 named imports do not destructure. Use another statement for destructuring after the import.",
   DuplicateConstructor: "Duplicate constructor in the same class.",
@@ -124,6 +123,11 @@ const StandardErrors = {
     exportName
   }) => `A string literal cannot be used as an exported binding without \`from\`.\n- Did you mean \`export { '${localName}' as '${exportName}' } from 'some-module'\`?`,
   ExportDefaultFromAsIdentifier: "'from' is not allowed as an identifier after 'export default'.",
+  FilteredNamespaceDuplicateName: ({
+    name
+  }) => `Duplicate name '${name}' in filtered namespace.`,
+  FilteredNamespaceRename: "Names in a filtered namespace cannot be renamed using `as`.",
+  FilteredNamespaceTypeModifier: "Names in a filtered namespace cannot have a type modifier.",
   ForInOfLoopInitializer: ({
     type
   }) => `'${type === "ForInStatement" ? "for-in" : "for-of"}' loop variable declaration may not have an initializer.`,
@@ -140,14 +144,17 @@ const StandardErrors = {
     importName
   }) => `A string literal cannot be used as an imported binding.\n- Did you mean \`import { "${importName}" as foo }\`?`,
   ImportCallArity: ({
-    phase
-  }) => `\`import${phase ? `.${phase}` : ""}()\` requires exactly one or two arguments.`,
+    phase,
+    sync
+  }) => `\`import${phase ? `.${phase}` : sync ? ".sync" : ""}()\` requires exactly one or two arguments.`,
   ImportCallNotNewExpression: ({
-    phase
-  }) => `Cannot use new with import${phase ? `.${phase}` : ""}().`,
+    phase,
+    sync
+  }) => `Cannot use new with import${phase ? `.${phase}` : sync ? ".sync" : ""}().`,
   ImportCallSpreadArgument: ({
-    phase
-  }) => `\`...\` is not allowed in \`import${phase ? `.${phase}` : ""}()\`.`,
+    phase,
+    sync
+  }) => `\`...\` is not allowed in \`import${phase ? `.${phase}` : sync ? ".sync" : ""}()\`.`,
   IncompatibleRegExpUVFlags: "The 'u' and 'v' regular expression flags cannot be enabled at the same time.",
   InvalidBigIntLiteral: "Invalid BigIntLiteral.",
   InvalidCodePoint: "Code point out of bounds.",
@@ -173,7 +180,6 @@ const StandardErrors = {
   InvalidLhsOptionalChaining: ({
     ancestor
   }) => `Invalid optional chaining in the left-hand side of ${toNodeDescription(ancestor)}.`,
-  InvalidNumber: "Invalid number.",
   InvalidOrMissingExponent: "Floating-point numbers require a valid exponent after the 'e'.",
   InvalidOrUnexpectedToken: ({
     unexpected
@@ -473,12 +479,14 @@ function getOptions(opts) {
   return options;
 }
 function toESTreeLocation(node) {
-  const {
-    start,
-    end
-  } = node.loc;
-  node.loc.start = new Position(start.line, start.column);
-  node.loc.end = new Position(end.line, end.column);
+  if (node.loc) {
+    const {
+      start,
+      end
+    } = node.loc;
+    node.loc.start = new Position(start.line, start.column);
+    node.loc.end = new Position(end.line, end.column);
+  }
   return node;
 }
 const estree = superClass => class ESTreeParserMixin extends superClass {
@@ -754,7 +762,7 @@ const estree = superClass => class ESTreeParserMixin extends superClass {
         node.exported = null;
         break;
       case "ExportNamedDeclaration":
-        if (node.specifiers.length === 1 && node.specifiers[0].type === "ExportNamespaceSpecifier") {
+        if (node.specifiers.length === 1 && node.specifiers[0].type === "ExportNamespaceSpecifier" && !node.specifiers[0].exportsFilter) {
           this.castNodeTo(node, "ExportAllDeclaration");
           node.exported = node.specifiers[0].exported;
           delete node.specifiers;
@@ -1189,6 +1197,12 @@ const tt = {
   _static: createKeywordLike("static", {
     startsExpr
   }),
+  _struct: createKeywordLike("struct", {
+    startsExpr
+  }),
+  _sync: createKeywordLike("sync", {
+    startsExpr
+  }),
   _using: createKeywordLike("using", {
     startsExpr
   }),
@@ -1296,16 +1310,16 @@ const tt = {
   jsxTagEnd: createToken("jsxTagEnd")
 };
 function tokenIsIdentifier(token) {
-  return token >= 89 && token <= 130;
+  return token >= 89 && token <= 132;
 }
 function tokenKeywordOrIdentifierIsKeyword(token) {
   return token <= 88;
 }
 function tokenIsKeywordOrIdentifier(token) {
-  return token >= 54 && token <= 130;
+  return token >= 54 && token <= 132;
 }
 function tokenIsLiteralPropertyName(token) {
-  return token >= 54 && token <= 133;
+  return token >= 54 && token <= 135;
 }
 function tokenComesBeforeExpression(token) {
   return tokenBeforeExprs[token];
@@ -1317,7 +1331,7 @@ function tokenIsAssignment(token) {
   return token >= 25 && token <= 29;
 }
 function tokenIsFlowInterfaceOrTypeOrOpaque(token) {
-  return token >= 126 && token <= 128;
+  return token >= 128 && token <= 130;
 }
 function tokenIsLoop(token) {
   return token >= 86 && token <= 88;
@@ -1335,10 +1349,10 @@ function tokenIsPrefix(token) {
   return tokenPrefixes[token];
 }
 function tokenIsTSTypeOperator(token) {
-  return token >= 118 && token <= 120;
+  return token >= 120 && token <= 122;
 }
 function tokenIsTSDeclarationStart(token) {
-  return token >= 121 && token <= 127;
+  return token >= 123 && token <= 129;
 }
 function tokenLabelName(token) {
   return tokenLabels[token];
@@ -1748,7 +1762,7 @@ const flow = superClass => class FlowParserMixin extends superClass {
     return this.getPluginOption("flow", "all") || this.flowPragma === "flow";
   }
   finishToken(type, val) {
-    if (type !== 131 && type !== 9 && type !== 24) {
+    if (type !== 133 && type !== 9 && type !== 24) {
       if (this.flowPragma === undefined) {
         this.flowPragma = null;
       }
@@ -1780,7 +1794,7 @@ const flow = superClass => class FlowParserMixin extends superClass {
     const node = this.startNode();
     const moduloLoc = this.state.startLoc;
     this.next();
-    this.expectContextual(107);
+    this.expectContextual(109);
     if (this.state.lastTokStartLoc.index > moduloLoc.index + 1) {
       this.raise(FlowErrors.UnexpectedSpaceBetweenModuloChecks, moduloLoc);
     }
@@ -1846,7 +1860,7 @@ const flow = superClass => class FlowParserMixin extends superClass {
       return this.flowParseDeclareFunction(node);
     } else if (this.match(70)) {
       return this.flowParseDeclareVariable(node);
-    } else if (this.eatContextual(124)) {
+    } else if (this.eatContextual(126)) {
       if (this.match(12)) {
         return this.flowParseDeclareModuleExports(node);
       } else {
@@ -1855,11 +1869,11 @@ const flow = superClass => class FlowParserMixin extends superClass {
         }
         return this.flowParseDeclareModule(node);
       }
-    } else if (this.isContextual(127)) {
+    } else if (this.isContextual(129)) {
       return this.flowParseDeclareTypeAlias(node);
-    } else if (this.isContextual(128)) {
+    } else if (this.isContextual(130)) {
       return this.flowParseDeclareOpaqueType(node);
-    } else if (this.isContextual(126)) {
+    } else if (this.isContextual(128)) {
       return this.flowParseDeclareInterface(node);
     } else if (this.match(78)) {
       return this.flowParseDeclareExportDeclaration(node, insideModule);
@@ -1875,7 +1889,7 @@ const flow = superClass => class FlowParserMixin extends superClass {
   }
   flowParseDeclareModule(node) {
     this.scope.enter(0);
-    if (this.match(131)) {
+    if (this.match(133)) {
       node.id = super.parseExprAtom();
     } else {
       node.id = this.parseIdentifier();
@@ -1887,12 +1901,12 @@ const flow = superClass => class FlowParserMixin extends superClass {
       const bodyNode = this.startNode();
       if (this.match(79)) {
         this.next();
-        if (!this.isContextual(127) && !this.match(83)) {
+        if (!this.isContextual(129) && !this.match(83)) {
           this.raise(FlowErrors.InvalidNonTypeImportInDeclareModule, this.state.lastTokStartLoc);
         }
         body.push(super.parseImport(bodyNode));
       } else {
-        this.expectContextual(122, FlowErrors.UnsupportedStatementInDeclareModule);
+        this.expectContextual(124, FlowErrors.UnsupportedStatementInDeclareModule);
         body.push(this.flowParseDeclare(bodyNode, true));
       }
     }
@@ -1933,18 +1947,18 @@ const flow = superClass => class FlowParserMixin extends superClass {
       node.default = true;
       return this.finishNode(node, "DeclareExportDeclaration");
     } else {
-      if (this.match(71) || this.isLet() || (this.isContextual(127) || this.isContextual(126)) && !insideModule) {
+      if (this.match(71) || this.isLet() || (this.isContextual(129) || this.isContextual(128)) && !insideModule) {
         const label = this.state.value;
         throw this.raise(FlowErrors.UnsupportedDeclareExportKind, this.state.startLoc, {
           unsupportedExportKind: label,
           suggestion: exportSuggestions[label]
         });
       }
-      if (this.match(70) || this.match(64) || this.match(76) || this.isContextual(128)) {
+      if (this.match(70) || this.match(64) || this.match(76) || this.isContextual(130)) {
         node.declaration = this.flowParseDeclare(this.startNode());
         node.default = false;
         return this.finishNode(node, "DeclareExportDeclaration");
-      } else if (this.match(51) || this.match(2) || this.isContextual(126) || this.isContextual(127) || this.isContextual(128)) {
+      } else if (this.match(51) || this.match(2) || this.isContextual(128) || this.isContextual(129) || this.isContextual(130)) {
         const result = this.parseExport(node, null);
         if (result.type === "ExportNamedDeclaration") {
           result.default = false;
@@ -1959,7 +1973,7 @@ const flow = superClass => class FlowParserMixin extends superClass {
   }
   flowParseDeclareModuleExports(node) {
     this.next();
-    this.expectContextual(108);
+    this.expectContextual(110);
     node.typeAnnotation = this.flowParseTypeAnnotation();
     this.semicolon();
     return this.finishNode(node, "DeclareModuleExports");
@@ -1996,12 +2010,12 @@ const flow = superClass => class FlowParserMixin extends superClass {
     if (isClass) {
       const implemented = [];
       const mixins = [];
-      if (this.eatContextual(114)) {
+      if (this.eatContextual(116)) {
         do {
           mixins.push(this.flowParseInterfaceExtends());
         } while (this.eat(8));
       }
-      if (this.eatContextual(110)) {
+      if (this.eatContextual(112)) {
         do {
           implemented.push(this.flowParseClassImplements());
         } while (this.eat(8));
@@ -2064,7 +2078,7 @@ const flow = superClass => class FlowParserMixin extends superClass {
     return this.finishNode(node, "TypeAlias");
   }
   flowParseOpaqueType(node, declare) {
-    this.expectContextual(127);
+    this.expectContextual(129);
     node.id = this.flowParseRestrictedIdentifier(true, true);
     this.scope.declareName(node.id.name, 8201, node.id.start);
     if (this.match(43)) {
@@ -2113,7 +2127,7 @@ const flow = superClass => class FlowParserMixin extends superClass {
     const node = this.startNode();
     node.params = [];
     this.state.inType = true;
-    if (this.match(43) || this.match(139)) {
+    if (this.match(43) || this.match(141)) {
       this.next();
     } else {
       this.unexpected();
@@ -2193,7 +2207,7 @@ const flow = superClass => class FlowParserMixin extends superClass {
   }
   flowParseInterfaceType() {
     const node = this.startNode();
-    this.expectContextual(126);
+    this.expectContextual(128);
     node.extends = [];
     if (this.eat(77)) {
       do {
@@ -2210,7 +2224,7 @@ const flow = superClass => class FlowParserMixin extends superClass {
     return this.finishNode(node, "InterfaceTypeAnnotation");
   }
   flowParseObjectPropertyKey() {
-    return this.match(132) || this.match(131) ? super.parseExprAtom() : this.parseIdentifier(true);
+    return this.match(134) || this.match(133) ? super.parseExprAtom() : this.parseIdentifier(true);
   }
   flowParseObjectTypeIndexer(node, isStatic, variance) {
     node.static = isStatic;
@@ -2311,7 +2325,7 @@ const flow = superClass => class FlowParserMixin extends superClass {
       let protoStartLoc = null;
       let inexactStartLoc = null;
       const node = this.startNode();
-      if (allowProto && this.isContextual(115)) {
+      if (allowProto && this.isContextual(117)) {
         const lookahead = this.lookahead();
         if (lookahead.type !== 10 && lookahead.type !== 13) {
           this.next();
@@ -2653,7 +2667,7 @@ const flow = superClass => class FlowParserMixin extends superClass {
           node.typeParameters = null;
           return this.finishNode(node, "FunctionTypeAnnotation");
         }
-      case 131:
+      case 133:
         return this.parseLiteral(this.state.value, "StringLiteralTypeAnnotation");
       case 81:
       case 82:
@@ -2663,18 +2677,18 @@ const flow = superClass => class FlowParserMixin extends superClass {
       case 49:
         if (this.state.value === "-") {
           this.next();
-          if (this.match(132)) {
+          if (this.match(134)) {
             return this.parseLiteralAtNode(-this.state.value, "NumberLiteralTypeAnnotation", node);
           }
-          if (this.match(133)) {
+          if (this.match(135)) {
             return this.parseLiteralAtNode(-this.state.value, "BigIntLiteralTypeAnnotation", node);
           }
           throw this.raise(FlowErrors.UnexpectedSubtractionOperand, this.state.startLoc);
         }
         throw this.unexpected();
-      case 132:
+      case 134:
         return this.parseLiteral(this.state.value, "NumberLiteralTypeAnnotation");
-      case 133:
+      case 135:
         return this.parseLiteral(this.state.value, "BigIntLiteralTypeAnnotation");
       case 84:
         this.next();
@@ -2696,7 +2710,7 @@ const flow = superClass => class FlowParserMixin extends superClass {
           this.next();
           return super.createIdentifier(node, label);
         } else if (tokenIsIdentifier(this.state.type)) {
-          if (this.isContextual(126)) {
+          if (this.isContextual(128)) {
             return this.flowParseInterfaceType();
           }
           return this.flowIdentToTypeAnnotation(startLoc, node, this.parseIdentifier());
@@ -2781,7 +2795,7 @@ const flow = superClass => class FlowParserMixin extends superClass {
     return type;
   }
   flowParseTypeOrImplicitInstantiation() {
-    if (this.state.type === 129 && this.state.value === "_") {
+    if (this.state.type === 131 && this.state.value === "_") {
       const startLoc = this.state.startLoc;
       const node = this.parseIdentifier();
       return this.flowParseGenericType(startLoc, node);
@@ -2841,14 +2855,14 @@ const flow = superClass => class FlowParserMixin extends superClass {
     return super.parseFunctionBodyAndFinish(node, type, isMethod);
   }
   parseStatementLike(flags) {
-    if (this.state.strict && this.isContextual(126)) {
+    if (this.state.strict && this.isContextual(128)) {
       const lookahead = this.lookahead();
       if (tokenIsKeywordOrIdentifier(lookahead.type)) {
         const node = this.startNode();
         this.next();
         return this.flowParseInterface(node);
       }
-    } else if (this.isContextual(123)) {
+    } else if (this.isContextual(125)) {
       const node = this.startNode();
       this.next();
       return this.flowParseEnumDeclaration(node);
@@ -2881,7 +2895,7 @@ const flow = superClass => class FlowParserMixin extends superClass {
     const {
       type
     } = this.state;
-    if (type === 123 || tokenIsFlowInterfaceOrTypeOrOpaque(type)) {
+    if (type === 125 || tokenIsFlowInterfaceOrTypeOrOpaque(type)) {
       return !this.state.containsEsc;
     }
     return super.shouldParseExportDeclaration();
@@ -2890,13 +2904,13 @@ const flow = superClass => class FlowParserMixin extends superClass {
     const {
       type
     } = this.state;
-    if (type === 123 || tokenIsFlowInterfaceOrTypeOrOpaque(type)) {
+    if (type === 125 || tokenIsFlowInterfaceOrTypeOrOpaque(type)) {
       return this.state.containsEsc;
     }
     return super.isExportDefaultSpecifier();
   }
   parseExportDefaultExpression() {
-    if (this.isContextual(123)) {
+    if (this.isContextual(125)) {
       const node = this.startNode();
       this.next();
       return this.flowParseEnumDeclaration(node);
@@ -3030,7 +3044,7 @@ const flow = superClass => class FlowParserMixin extends superClass {
     super.assertModuleNodeAllowed(node);
   }
   parseExportDeclaration(node) {
-    if (this.isContextual(127)) {
+    if (this.isContextual(129)) {
       node.exportKind = "type";
       const declarationNode = this.startNode();
       this.next();
@@ -3041,17 +3055,17 @@ const flow = superClass => class FlowParserMixin extends superClass {
       } else {
         return this.flowParseTypeAlias(declarationNode);
       }
-    } else if (this.isContextual(128)) {
+    } else if (this.isContextual(130)) {
       node.exportKind = "type";
       const declarationNode = this.startNode();
       this.next();
       return this.flowParseOpaqueType(declarationNode, false);
-    } else if (this.isContextual(126)) {
+    } else if (this.isContextual(128)) {
       node.exportKind = "type";
       const declarationNode = this.startNode();
       this.next();
       return this.flowParseInterface(declarationNode);
-    } else if (this.isContextual(123)) {
+    } else if (this.isContextual(125)) {
       node.exportKind = "value";
       const declarationNode = this.startNode();
       this.next();
@@ -3062,7 +3076,7 @@ const flow = superClass => class FlowParserMixin extends superClass {
   }
   eatExportStar(node) {
     if (super.eatExportStar(node)) return true;
-    if (this.isContextual(127) && this.lookahead().type === 51) {
+    if (this.isContextual(129) && this.lookahead().type === 51) {
       node.exportKind = "type";
       this.next();
       this.next();
@@ -3080,8 +3094,16 @@ const flow = superClass => class FlowParserMixin extends superClass {
     }
     return hasNamespace;
   }
+  maybeParseExportNamedSpecifiers(node) {
+    if (!super.maybeParseExportNamedSpecifiers(node)) return false;
+    const specifier = node.specifiers[node.specifiers.length - 1];
+    if (node.exportKind === "type" && specifier?.type === "ExportNamespaceSpecifier") {
+      this.unexpected(specifier.start);
+    }
+    return true;
+  }
   parseClassId(node, isStatement, optionalId) {
-    if ((!isStatement || optionalId) && this.isContextual(110)) {
+    if ((!isStatement || optionalId) && this.isContextual(112)) {
       node.id = null;
       return;
     }
@@ -3094,7 +3116,7 @@ const flow = superClass => class FlowParserMixin extends superClass {
     const {
       startLoc
     } = this.state;
-    if (this.isContextual(122)) {
+    if (this.isContextual(124)) {
       if (super.parseClassMemberFromModifier(classBody, member)) {
         return;
       }
@@ -3120,7 +3142,7 @@ const flow = superClass => class FlowParserMixin extends superClass {
         identifierName: fullWord
       });
     }
-    this.finishToken(129, fullWord);
+    this.finishToken(131, fullWord);
   }
   getTokenFromCode(code) {
     const next = this.input.charCodeAt(this.state.pos + 1);
@@ -3247,7 +3269,7 @@ const flow = superClass => class FlowParserMixin extends superClass {
     if (node.superClass && (this.match(43) || this.match(47))) {
       node.superTypeArguments = this.flowParseTypeParameterInstantiationInExpression();
     }
-    if (this.eatContextual(110)) {
+    if (this.eatContextual(112)) {
       const implemented = node.implements = [];
       do {
         implemented.push(this.flowParseClassImplements());
@@ -3319,7 +3341,7 @@ const flow = superClass => class FlowParserMixin extends superClass {
   }
   isPotentialImportPhase(isExport) {
     if (super.isPotentialImportPhase(isExport)) return true;
-    if (this.isContextual(127)) {
+    if (this.isContextual(129)) {
       if (!isExport) return true;
       const ch = this.lookaheadCharCode();
       return ch === 123 || ch === 42;
@@ -3338,7 +3360,14 @@ const flow = superClass => class FlowParserMixin extends superClass {
       node.importKind = phase === "type" || phase === "typeof" ? phase : "value";
     }
   }
-  parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
+  parseNamedOrFilteredImportSpecifiers(node) {
+    super.parseNamedOrFilteredImportSpecifiers(node);
+    const specifier = node.specifiers[node.specifiers.length - 1];
+    if (hasTypeImportKind(node) && specifier?.type === "ImportNamespaceSpecifier") {
+      this.unexpected(specifier.start);
+    }
+  }
+  parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly) {
     const firstIdent = specifier.imported;
     let specifierTypeKind = null;
     if (firstIdent.type === "Identifier") {
@@ -3348,7 +3377,6 @@ const flow = superClass => class FlowParserMixin extends superClass {
         specifierTypeKind = "typeof";
       }
     }
-    let isBinding = false;
     if (this.isContextual(90) && !this.isLookaheadContextual("as")) {
       const as_ident = this.parseIdentifier(true);
       if (specifierTypeKind !== null && !tokenIsKeywordOrIdentifier(this.state.type)) {
@@ -3365,32 +3393,30 @@ const flow = superClass => class FlowParserMixin extends superClass {
         specifier.imported = this.parseIdentifier(true);
         specifier.importKind = specifierTypeKind;
       } else {
-        if (importedIsString) {
-          throw this.raise(Errors.ImportBindingIsString, specifier, {
-            importName: firstIdent.value
-          });
-        }
         specifier.imported = firstIdent;
         specifier.importKind = null;
       }
       if (this.eatContextual(90)) {
         specifier.local = this.parseIdentifier();
       } else {
-        isBinding = true;
         specifier.local = this.cloneIdentifier(specifier.imported);
       }
     }
+    return this.finishNode(specifier, "ImportSpecifier");
+  }
+  checkImportSpecifier(specifier, isInTypeOnlyImport) {
     const specifierIsTypeImport = hasTypeImportKind(specifier);
-    if (isInTypeOnlyImport && specifierIsTypeImport) {
-      this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, specifier);
-    }
-    if (isInTypeOnlyImport || specifierIsTypeImport) {
-      this.checkReservedType(specifier.local.name, specifier.local.start, true);
-    }
-    if (isBinding && !isInTypeOnlyImport && !specifierIsTypeImport) {
-      this.checkReservedWord(specifier.local.name, specifier.start, true, true);
+    const isTypeImport = isInTypeOnlyImport || specifierIsTypeImport;
+    if (isTypeImport) {
+      if (isInTypeOnlyImport && specifierIsTypeImport) {
+        this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, specifier);
+      }
+      const {
+        local
+      } = specifier;
+      this.checkReservedType(local.name, local.start, true);
     }
-    return this.finishImportSpecifier(specifier, "ImportSpecifier");
+    super.checkImportSpecifier(specifier, isInTypeOnlyImport, 8201, !isTypeImport);
   }
   parseBindingAtom() {
     switch (this.state.type) {
@@ -3429,7 +3455,7 @@ const flow = superClass => class FlowParserMixin extends superClass {
   parseMaybeAssign(refExpressionErrors, isParenItem) {
     let state = null;
     let jsx;
-    if (this.hasPlugin("jsx") && (this.match(139) || this.match(43))) {
+    if (this.hasPlugin("jsx") && (this.match(141) || this.match(43))) {
       state = this.state.clone();
       jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, isParenItem), state);
       if (!jsx.error) return jsx.node;
@@ -3680,7 +3706,7 @@ const flow = superClass => class FlowParserMixin extends superClass {
     const startLoc = this.state.startLoc;
     const endOfInit = () => this.match(8) || this.match(4);
     switch (this.state.type) {
-      case 132:
+      case 134:
         {
           const literal = this.parseNumericLiteral(this.state.value);
           if (endOfInit()) {
@@ -3692,7 +3718,7 @@ const flow = superClass => class FlowParserMixin extends superClass {
           }
           break;
         }
-      case 131:
+      case 133:
         {
           const literal = this.parseStringLiteral(this.state.value);
           if (endOfInit()) {
@@ -4372,14 +4398,14 @@ const jsx = superClass => class JSXParserMixin extends superClass {
           if (this.state.pos === this.state.start) {
             if (ch === 60 && this.state.canStartJSXElement) {
               ++this.state.pos;
-              this.finishToken(139);
+              this.finishToken(141);
             } else {
               super.getTokenFromCode(ch);
             }
             return;
           }
           out += this.input.slice(chunkStart, this.state.pos);
-          this.finishToken(138, out);
+          this.finishToken(140, out);
           return;
         case 38:
           out += this.input.slice(chunkStart, this.state.pos);
@@ -4439,7 +4465,7 @@ const jsx = superClass => class JSXParserMixin extends superClass {
       }
     }
     out += this.input.slice(chunkStart, this.state.pos++);
-    this.finishToken(131, out);
+    this.finishToken(133, out);
   }
   jsxReadEntity() {
     const startPos = ++this.state.pos;
@@ -4479,11 +4505,11 @@ const jsx = superClass => class JSXParserMixin extends superClass {
     do {
       ch = this.input.charCodeAt(++this.state.pos);
     } while (isIdentifierChar(ch) || ch === 45);
-    this.finishToken(137, this.input.slice(start, this.state.pos));
+    this.finishToken(139, this.input.slice(start, this.state.pos));
   }
   jsxParseIdentifier() {
     const node = this.startNode();
-    if (this.match(137)) {
+    if (this.match(139)) {
       node.name = this.state.value;
     } else if (tokenIsKeyword(this.state.type)) {
       node.name = tokenLabelName(this.state.type);
@@ -4528,8 +4554,8 @@ const jsx = superClass => class JSXParserMixin extends superClass {
           this.raise(JsxErrors.AttributeIsEmpty, node);
         }
         return node;
-      case 139:
-      case 131:
+      case 141:
+      case 133:
         return this.parseExprAtom();
       default:
         throw this.raise(JsxErrors.UnsupportedJsxValue, this.state.startLoc);
@@ -4580,7 +4606,7 @@ const jsx = superClass => class JSXParserMixin extends superClass {
     return this.finishNode(node, "JSXAttribute");
   }
   jsxParseOpeningElementAt(startLoc) {
-    if (this.eat(140)) {
+    if (this.eat(142)) {
       const node = this.startNodeAt(startLoc);
       return this.finishNode(node, "JSXOpeningFragment");
     }
@@ -4590,22 +4616,22 @@ const jsx = superClass => class JSXParserMixin extends superClass {
   }
   jsxParseOpeningElementAfterName(node) {
     const attributes = [];
-    while (!this.match(52) && !this.match(140)) {
+    while (!this.match(52) && !this.match(142)) {
       attributes.push(this.jsxParseAttribute());
     }
     node.attributes = attributes;
     node.selfClosing = this.eat(52);
-    this.expect(140);
+    this.expect(142);
     return this.finishNode(node, "JSXOpeningElement");
   }
   jsxParseClosingElementAt(startLoc) {
-    if (this.eat(140)) {
+    if (this.eat(142)) {
       const node = this.startNodeAt(startLoc);
       return this.finishNode(node, "JSXClosingFragment");
     }
     const node = this.startNodeAt(startLoc);
     node.name = this.jsxParseElementName();
-    this.expect(140);
+    this.expect(142);
     return this.finishNode(node, "JSXClosingElement");
   }
   jsxParseElementAt(startLoc) {
@@ -4616,17 +4642,16 @@ const jsx = superClass => class JSXParserMixin extends superClass {
     if (!openingElement.selfClosing) {
       contents: for (;;) {
         switch (this.state.type) {
-          case 139:
+          case 141:
             startLoc = this.state.startLoc;
             this.next();
             if (this.eat(52)) {
-              this.setLoc(startLoc);
               closingElement = this.jsxParseClosingElementAt(startLoc);
               break contents;
             }
             children.push(this.jsxParseElementAt(startLoc));
             break;
-          case 138:
+          case 140:
             children.push(this.parseLiteral(this.state.value, "JSXText"));
             break;
           case 2:
@@ -4684,10 +4709,10 @@ const jsx = superClass => class JSXParserMixin extends superClass {
     context[context.length - 1] = newContext;
   }
   parseExprAtom(refExpressionErrors) {
-    if (this.match(139)) {
+    if (this.match(141)) {
       return this.jsxParseElement();
     } else if (this.match(43) && this.input.charCodeAt(this.state.pos) !== 33) {
-      this.replaceToken(139);
+      this.replaceToken(141);
       return this.jsxParseElement();
     } else {
       return super.parseExprAtom(refExpressionErrors);
@@ -4710,7 +4735,7 @@ const jsx = superClass => class JSXParserMixin extends superClass {
       }
       if (code === 62) {
         ++this.state.pos;
-        this.finishToken(140);
+        this.finishToken(142);
         return;
       }
       if ((code === 34 || code === 39) && context === types.j_oTag) {
@@ -4720,7 +4745,7 @@ const jsx = superClass => class JSXParserMixin extends superClass {
     }
     if (code === 60 && this.state.canStartJSXElement && this.input.charCodeAt(this.state.pos + 1) !== 33) {
       ++this.state.pos;
-      this.finishToken(139);
+      this.finishToken(141);
       return;
     }
     super.getTokenFromCode(code);
@@ -4730,12 +4755,12 @@ const jsx = superClass => class JSXParserMixin extends superClass {
       context,
       type
     } = this.state;
-    if (type === 52 && prevType === 139) {
+    if (type === 52 && prevType === 141) {
       context.splice(-2, 2, types.j_cTag);
       this.state.canStartJSXElement = false;
-    } else if (type === 139) {
+    } else if (type === 141) {
       context.push(types.j_oTag);
-    } else if (type === 140) {
+    } else if (type === 142) {
       const out = context[context.length - 1];
       if (out === types.j_oTag && prevType === 52 || out === types.j_cTag) {
         context.pop();
@@ -5009,6 +5034,10 @@ class CommentsParser extends BaseParser {
           case "ImportDeclaration":
             adjustInnerComments(node, node.specifiers, commentWS);
             break;
+          case "ImportNamespaceSpecifier":
+          case "ExportNamespaceSpecifier":
+            adjustInnerComments(node, node.exportsFilter ?? [], commentWS);
+            break;
           case "TSEnumBody":
             adjustInnerComments(node, node.members, commentWS);
             break;
@@ -5047,6 +5076,12 @@ class CommentsParser extends BaseParser {
       commentWS.leadingNode = null;
     }
   }
+  replaceNodeInPendingComments(oldNode, newNode) {
+    for (const commentWS of this.state.commentStack) {
+      if (commentWS.leadingNode === oldNode) commentWS.leadingNode = newNode;
+      if (commentWS.trailingNode === oldNode) commentWS.trailingNode = newNode;
+    }
+  }
   takeSurroundingComments(node, start, end) {
     const {
       commentStack
@@ -5162,7 +5197,7 @@ class State {
   commentsLen = 0;
   commentStack = [];
   pos = 0;
-  type = 136;
+  type = 138;
   value = null;
   start = 0;
   end = 0;
@@ -5581,6 +5616,7 @@ class Tokenizer extends CommentsParser {
       end: state.end,
       context: [this.curContext()],
       inType: state.inType,
+      strict: state.strict,
       startLoc: state.startLoc,
       lastTokEndLoc: state.lastTokEndLoc,
       curLine: state.curLine,
@@ -5647,7 +5683,7 @@ class Tokenizer extends CommentsParser {
     this.state.start = this.state.pos;
     if (!this.isLookahead) this.state.startLoc = this.state.curPosition();
     if (this.state.pos >= this.length) {
-      this.finishToken(136);
+      this.finishToken(138);
       return;
     }
     this.getTokenFromCode(this.codePointAtPos(this.state.pos));
@@ -5823,10 +5859,10 @@ class Tokenizer extends CommentsParser {
     }
     if (isIdentifierStart(next)) {
       ++this.state.pos;
-      this.finishToken(135, this.readWord1(next));
+      this.finishToken(137, this.readWord1(next));
     } else if (next === 92) {
       ++this.state.pos;
-      this.finishToken(135, this.readWord1());
+      this.finishToken(137, this.readWord1());
     } else {
       this.finishOp(23, 1);
     }
@@ -6206,7 +6242,7 @@ class Tokenizer extends CommentsParser {
       mods += char;
     }
     this.state.pos = pos;
-    this.finishToken(134, {
+    this.finishToken(136, {
       pattern: content,
       flags: mods
     });
@@ -6219,41 +6255,63 @@ class Tokenizer extends CommentsParser {
     this.state.pos = pos;
     return n;
   }
+  readLiteralInt(radix) {
+    let pos = this.state.pos;
+    let val = 0;
+    let code;
+    for (;;) {
+      code = this.input.charCodeAt(pos);
+      let digit;
+      if (code >= 48 && code <= 57) {
+        digit = code - 48;
+      } else {
+        digit = (code | 0x20) - 97;
+        if (digit < 0 || digit > 5) break;
+        digit += 10;
+      }
+      if (digit >= radix) break;
+      val = val * radix + digit;
+      ++pos;
+    }
+    if (code === 95 || code >= 48 && code <= 57) {
+      return this.readInt(radix);
+    }
+    if (pos === this.state.pos) return null;
+    this.state.pos = pos;
+    return val;
+  }
   readRadixNumber(radix) {
     const start = this.state.pos;
     const startLoc = this.state.curPosition();
-    let isBigInt = false;
     this.state.pos += 2;
-    const val = this.readInt(radix);
+    let val = this.readLiteralInt(radix);
+    const end = this.state.pos;
     if (val == null) {
       this.raise(Errors.InvalidDigit, createPositionWithColumnOffset(startLoc, 2), {
         radix
       });
     }
-    const next = this.input.charCodeAt(this.state.pos);
-    if (next === 110) {
-      ++this.state.pos;
-      isBigInt = true;
-    }
+    const isBigInt = this.input.charCodeAt(this.state.pos) === 110;
+    if (isBigInt) ++this.state.pos;
     if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {
       throw this.raise(Errors.NumberIdentifier, this.state.curPosition());
     }
-    if (isBigInt) {
-      const str = this.input.slice(start, this.state.pos).replace(/[_n]/g, "");
-      this.finishToken(133, str);
-      return;
+    if (isBigInt || val !== null && val > Number.MAX_SAFE_INTEGER) {
+      const str = this.input.slice(start, end).replaceAll("_", "");
+      if (isBigInt) {
+        this.finishToken(135, str);
+        return;
+      }
+      val = Number(radix !== 16 && this.optionFlags & 4096 ? str.replace(radix === 2 ? /[2-9]/g : /[89]/g, "0") : str);
     }
-    this.finishToken(132, val);
+    this.finishToken(134, val);
   }
   readNumber(startsWithDot) {
     const start = this.state.pos;
     const startLoc = this.state.curPosition();
     let isFloat = false;
-    let isBigInt = false;
     let isOctal = false;
-    if (!startsWithDot && this.readInt(10) === null) {
-      this.raise(Errors.InvalidNumber, this.state.curPosition());
-    }
+    const integerValue = startsWithDot ? 0 : this.readLiteralInt(10);
     const hasLeadingZero = this.state.pos - start >= 2 && this.input.charCodeAt(start) === 48;
     if (hasLeadingZero) {
       const integer = this.input.slice(start, this.state.pos);
@@ -6264,12 +6322,12 @@ class Tokenizer extends CommentsParser {
           this.raise(Errors.ZeroDigitNumericSeparator, createPositionWithColumnOffset(startLoc, underscorePos));
         }
       }
-      isOctal = hasLeadingZero && !/[89]/.test(integer);
+      isOctal = !/[89]/.test(integer);
     }
     let next = this.input.charCodeAt(this.state.pos);
     if (next === 46 && !isOctal) {
       ++this.state.pos;
-      this.readInt(10);
+      this.readLiteralInt(10);
       isFloat = true;
       next = this.input.charCodeAt(this.state.pos);
     }
@@ -6278,29 +6336,34 @@ class Tokenizer extends CommentsParser {
       if (next === 43 || next === 45) {
         ++this.state.pos;
       }
-      if (this.readInt(10) === null) {
+      if (this.readLiteralInt(10) === null) {
         this.raise(Errors.InvalidOrMissingExponent, startLoc);
       }
       isFloat = true;
       next = this.input.charCodeAt(this.state.pos);
     }
-    const str = this.input.slice(start, this.state.pos).replaceAll("_", "");
-    if (next === 110) {
+    const end = this.state.pos;
+    const isBigInt = next === 110;
+    if (isBigInt) {
       if (isFloat || hasLeadingZero) {
         this.raise(Errors.InvalidBigIntLiteral, startLoc);
       }
       ++this.state.pos;
-      isBigInt = true;
     }
     if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {
       throw this.raise(Errors.NumberIdentifier, this.state.curPosition());
     }
+    if (!isFloat && !isBigInt && !hasLeadingZero && integerValue <= Number.MAX_SAFE_INTEGER) {
+      this.finishToken(134, integerValue);
+      return;
+    }
+    const str = this.input.slice(start, end).replaceAll("_", "");
     if (isBigInt) {
-      this.finishToken(133, str);
+      this.finishToken(135, str);
       return;
     }
     const val = isOctal ? parseInt(str, 8) : parseFloat(str);
-    this.finishToken(132, val);
+    this.finishToken(134, val);
   }
   readCodePoint(throwOnInvalid) {
     const {
@@ -6320,7 +6383,7 @@ class Tokenizer extends CommentsParser {
     this.state.pos = pos + 1;
     this.state.lineStart = lineStart;
     this.state.curLine = curLine;
-    this.finishToken(131, str);
+    this.finishToken(133, str);
   }
   readTemplateContinuation() {
     if (!this.match(4)) {
@@ -6352,6 +6415,7 @@ class Tokenizer extends CommentsParser {
     }
   }
   recordStrictModeErrors(toParseError, at) {
+    if (this.isLookahead) return;
     const index = at.index;
     if (this.state.strict && !this.state.strictErrors.has(index)) {
       this.raise(toParseError, at);
@@ -6402,7 +6466,7 @@ class Tokenizer extends CommentsParser {
     if (type !== undefined) {
       this.finishToken(type, tokenLabelName(type));
     } else {
-      this.finishToken(129, word);
+      this.finishToken(131, word);
     }
   }
   checkKeywordEscapes() {
@@ -6577,6 +6641,9 @@ class ExpressionScope {
   isCertainlyParameterDeclaration() {
     return this.type === 3;
   }
+  isInitializer() {
+    return this.type === 4;
+  }
 }
 class ArrowHeadParsingScope extends ExpressionScope {
   declarationErrors = new Map();
@@ -6605,6 +6672,10 @@ class ExpressionScopeHandler {
   exit() {
     this.stack.pop();
   }
+  canBeInParameters() {
+    const scope = this.stack[this.stack.length - 1];
+    return scope.canBeArrowParameterDeclaration() || scope.isCertainlyParameterDeclaration();
+  }
   recordParameterInitializerError(toParseError, loc) {
     const {
       stack
@@ -6614,7 +6685,7 @@ class ExpressionScopeHandler {
     while (!scope.isCertainlyParameterDeclaration()) {
       if (scope.canBeArrowParameterDeclaration()) {
         scope.recordDeclarationError(toParseError, loc);
-      } else {
+      } else if (!scope.isInitializer()) {
         return;
       }
       scope = stack[--i];
@@ -6639,13 +6710,15 @@ class ExpressionScopeHandler {
     const {
       stack
     } = this;
-    let i = stack.length - 1;
-    let scope = stack[i];
-    while (scope.canBeArrowParameterDeclaration()) {
-      if (scope.type === 2) {
-        scope.recordDeclarationError(Errors.AwaitBindingIdentifier, at);
+    for (let i = stack.length - 1;; i--) {
+      const scope = stack[i];
+      if (scope.canBeArrowParameterDeclaration()) {
+        if (scope.type === 2) {
+          scope.recordDeclarationError(Errors.AwaitBindingIdentifier, at);
+        }
+      } else if (!scope.isInitializer()) {
+        return;
       }
-      scope = stack[--i];
     }
   }
   validateAsPattern() {
@@ -6656,27 +6729,26 @@ class ExpressionScopeHandler {
     if (!currentScope.canBeArrowParameterDeclaration()) return;
     currentScope.iterateErrors((toParseError, key) => {
       this.parser.raise(toParseError, key);
-      let i = stack.length - 2;
-      let scope = stack[i];
-      while (scope.canBeArrowParameterDeclaration()) {
-        scope.clearDeclarationError(key);
-        scope = stack[--i];
+      for (let i = stack.length - 2;; i--) {
+        const scope = stack[i];
+        if (scope.canBeArrowParameterDeclaration()) {
+          scope.clearDeclarationError(key);
+        } else if (!scope.isInitializer()) {
+          break;
+        }
       }
     });
   }
 }
-function newParameterDeclarationScope() {
-  return new ExpressionScope(3);
-}
 function newArrowHeadScope() {
   return new ArrowHeadParsingScope(1);
 }
 function newAsyncArrowScope() {
   return new ArrowHeadParsingScope(2);
 }
-function newExpressionScope() {
-  return new ExpressionScope();
-}
+const sharedExpressionScope = new ExpressionScope();
+const parameterDeclarationScope = new ExpressionScope(3);
+const initializerScope = new ExpressionScope(4);
 class ProductionParameterHandler {
   stacks = [];
   enter(flags) {
@@ -6732,7 +6804,7 @@ class UtilParser extends Tokenizer {
   isUnparsedContextual(nameStart, name) {
     if (this.input.startsWith(name, nameStart)) {
       const nextCh = this.input.charCodeAt(nameStart + name.length);
-      return !(isIdentifierChar(nextCh) || (nextCh & 0xfc00) === 0xd800);
+      return !(isIdentifierChar(nextCh) || nextCh === 92 || (nextCh & 0xfc00) === 0xd800);
     }
     return false;
   }
@@ -6756,7 +6828,7 @@ class UtilParser extends Tokenizer {
     }
   }
   canInsertSemicolon() {
-    return this.match(136) || this.match(4) || this.hasPrecedingLineBreak();
+    return this.match(138) || this.match(4) || this.hasPrecedingLineBreak();
   }
   hasPrecedingLineBreak() {
     return hasNewLine(this.input, this.offsetToSourcePos(this.state.lastTokEndLoc.index), this.state.start);
@@ -6776,10 +6848,28 @@ class UtilParser extends Tokenizer {
       this.unexpected(loc, type);
     }
   }
+  snapshotScopeStacks() {
+    return {
+      scopeDepth: this.scope.scopeStack.length,
+      prodParamDepth: this.prodParam.stacks.length,
+      classScopeDepth: this.classScope.stack.length,
+      expressionScopeDepth: this.expressionScope.stack.length
+    };
+  }
+  restoreScopeStacks(snapshot) {
+    const {
+      scope
+    } = this;
+    while (scope.scopeStack.length > snapshot.scopeDepth) scope.exit();
+    this.prodParam.stacks.length = snapshot.prodParamDepth;
+    this.classScope.stack.length = snapshot.classScopeDepth;
+    this.expressionScope.stack.length = snapshot.expressionScopeDepth;
+  }
   tryParse(fn, oldState = this.state.clone()) {
     const abortSignal = {
       node: null
     };
+    const scopeStacksSnapshot = this.snapshotScopeStacks();
     try {
       const node = fn((node = null) => {
         abortSignal.node = node;
@@ -6807,6 +6897,7 @@ class UtilParser extends Tokenizer {
     } catch (error) {
       const failState = this.state;
       this.state = oldState;
+      this.restoreScopeStacks(scopeStacksSnapshot);
       if (error instanceof SyntaxError) {
         return {
           node: null,
@@ -6957,13 +7048,10 @@ class NodeUtils extends UtilParser {
     return loc;
   }
   startNode() {
-    const {
-      startLoc
-    } = this.state;
-    this.setLoc(startLoc);
-    return this.startNodeAt(startLoc);
+    return this.startNodeAt(this.state.startLoc);
   }
   startNodeAt(loc) {
+    this.setLoc(loc);
     const {
       optionFlags,
       filename
@@ -7099,6 +7187,20 @@ const unwrapParenthesizedExpression = node => {
   return node.type === "ParenthesizedExpression" ? unwrapParenthesizedExpression(node.expression) : node;
 };
 class LValParser extends NodeUtils {
+  raiseOnce(toParseError, node) {
+    const {
+      errors
+    } = this.state;
+    const length = errors.length;
+    const error = this.raise(toParseError, node);
+    if (errors.length === length) return;
+    for (let i = length - 1; i >= 0; i--) {
+      if (errors[i].pos === error.pos && errors[i].reasonCode === error.reasonCode) {
+        errors.pop();
+        return;
+      }
+    }
+  }
   toAssignable(node, isLHS = false) {
     let parenthesized = undefined;
     if (node.type === "ParenthesizedExpression" || node.extra?.parenthesized) {
@@ -7107,10 +7209,10 @@ class LValParser extends NodeUtils {
         if (parenthesized.type === "Identifier") {
           this.expressionScope.recordArrowParameterBindingError(Errors.InvalidParenthesizedAssignment, node);
         } else if (parenthesized.type !== "CallExpression" && parenthesized.type !== "MemberExpression" && !this.isOptionalMemberExpression(parenthesized)) {
-          this.raise(Errors.InvalidParenthesizedAssignment, node);
+          this.raiseOnce(Errors.InvalidParenthesizedAssignment, node);
         }
       } else {
-        this.raise(Errors.InvalidParenthesizedAssignment, node);
+        this.raiseOnce(Errors.InvalidParenthesizedAssignment, node);
       }
     }
     switch (node.type) {
@@ -7336,7 +7438,7 @@ class LValParser extends NodeUtils {
       return this.parseBindingRestProperty(this.startNode());
     }
     const prop = this.startNode();
-    if (type === 135) {
+    if (type === 137) {
       this.expectPlugin("destructuringPrivate", startLoc);
       this.classScope.usePrivateName(this.state.value, startLoc);
       prop.key = this.parsePrivateName();
@@ -7543,11 +7645,11 @@ class ExpressionParser extends LValParser {
   getExpression() {
     this.enterInitialScopes();
     this.nextToken();
-    if (this.match(136)) {
+    if (this.match(138)) {
       throw this.raise(Errors.ParseExpressionEmptyInput, this.state.startLoc);
     }
     const expr = this.parseExpression();
-    if (!this.match(136)) {
+    if (!this.match(138)) {
       throw this.raise(Errors.ParseExpressionExpectsEOF, this.state.startLoc, {
         unexpected: this.input.codePointAt(this.state.start)
       });
@@ -7591,7 +7693,7 @@ class ExpressionParser extends LValParser {
   }
   parseMaybeAssign(refExpressionErrors, isParenItem) {
     const startLoc = this.state.startLoc;
-    const isYield = this.isContextual(105);
+    const isYield = this.isContextual(107);
     if (isYield) {
       if (this.prodParam.hasYield) {
         this.next();
@@ -7603,11 +7705,16 @@ class ExpressionParser extends LValParser {
       }
     }
     let ownExpressionErrors;
+    let inInitializerScope = false;
     if (refExpressionErrors) {
       ownExpressionErrors = false;
     } else {
       refExpressionErrors = new ExpressionErrors();
       ownExpressionErrors = true;
+      if (this.expressionScope.canBeInParameters()) {
+        this.expressionScope.enter(initializerScope);
+        inInitializerScope = true;
+      }
     }
     this.state.canStartArrow = true;
     let left = this.parseMaybeConditional(refExpressionErrors);
@@ -7640,10 +7747,12 @@ class ExpressionParser extends LValParser {
       }
       this.next();
       node.right = this.parseMaybeAssign();
+      if (inInitializerScope) this.expressionScope.exit();
       this.checkLVal(left, this.finishNode(node, "AssignmentExpression"), undefined, undefined, undefined, undefined, operator === "||=" || operator === "&&=" || operator === "??=");
       return node;
     } else if (ownExpressionErrors) {
       this.checkExpressionErrors(refExpressionErrors, true);
+      if (inInitializerScope) this.expressionScope.exit();
     }
     if (isYield) {
       const {
@@ -7677,7 +7786,7 @@ class ExpressionParser extends LValParser {
     return expr;
   }
   parseMaybeUnaryOrPrivate(refExpressionErrors) {
-    return this.match(135) ? this.parsePrivateName() : this.parseMaybeUnary(refExpressionErrors);
+    return this.match(137) ? this.parsePrivateName() : this.parseMaybeUnary(refExpressionErrors);
   }
   parseExprOps(refExpressionErrors) {
     const startLoc = this.state.startLoc;
@@ -7846,7 +7955,6 @@ class ExpressionParser extends LValParser {
   }
   parseExprSubscripts(refExpressionErrors) {
     const startLoc = this.state.startLoc;
-    this.setLoc(startLoc);
     if (refExpressionErrors != null && (this.match(2) || this.match(0))) {
       const atomExpressionErrors = new ExpressionErrors();
       const expr = this.parseExprAtom(atomExpressionErrors);
@@ -7922,7 +8030,7 @@ class ExpressionParser extends LValParser {
     if (computed) {
       node.property = this.parseExpression();
       this.expect(1);
-    } else if (this.match(135)) {
+    } else if (this.match(137)) {
       if (base.type === "Super") {
         this.raise(Errors.SuperPrivateField, startLoc);
       }
@@ -8073,7 +8181,7 @@ class ExpressionParser extends LValParser {
         node = this.startNode();
         this.next();
         if (this.match(12)) {
-          return this.parseImportMetaPropertyOrPhaseCall(node);
+          return this.parseImportMetaPropertyOrPhaseCallOrSyncCall(node);
         }
         if (this.match(6)) {
           if (this.optionFlags & 1024) {
@@ -8099,11 +8207,11 @@ class ExpressionParser extends LValParser {
           this.readRegexp();
           return this.parseRegExpLiteral(this.state.value);
         }
-      case 132:
+      case 134:
         return this.parseNumericLiteral(this.state.value);
-      case 133:
+      case 135:
         return this.parseBigIntLiteral(this.state.value);
-      case 131:
+      case 133:
         return this.parseStringLiteral(this.state.value);
       case 80:
         return this.parseNullLiteral();
@@ -8148,7 +8256,7 @@ class ExpressionParser extends LValParser {
             throw this.raise(Errors.UnsupportedBind, callee);
           }
         }
-      case 135:
+      case 137:
         {
           this.raise(Errors.PrivateInExpectedIn, this.state.startLoc, {
             identifierName: this.state.value
@@ -8182,13 +8290,13 @@ class ExpressionParser extends LValParser {
         {
           const lookaheadCh = this.input.codePointAt(this.nextTokenStart());
           if (isIdentifierStart(lookaheadCh) || lookaheadCh === 62) {
-            throw this.expectOnePlugin(["jsx", "flow", "typescript"]);
+            this.expectOnePlugin(["jsx", "flow", "typescript"]);
           }
           throw this.unexpected();
         }
       default:
         if (tokenIsIdentifier(type)) {
-          if (this.isContextual(124) && this.lookaheadInLineCharCode() === 123) {
+          if (this.isContextual(126) && this.lookaheadInLineCharCode() === 123) {
             return this.parseModuleExpression();
           }
           const {
@@ -8346,7 +8454,7 @@ class ExpressionParser extends LValParser {
     }
     return this.finishNode(node, "MetaProperty");
   }
-  parseImportMetaPropertyOrPhaseCall(node) {
+  parseImportMetaPropertyOrPhaseCallOrSyncCall(node) {
     this.next();
     if (this.isContextual(102) || this.isContextual(94)) {
       const isSource = this.isContextual(102);
@@ -8354,6 +8462,11 @@ class ExpressionParser extends LValParser {
       this.next();
       node.phase = isSource ? "source" : "defer";
       return this.parseImportCall(node);
+    } else if (this.isContextual(105)) {
+      this.expectPlugin("importSync");
+      this.next();
+      node.sync = true;
+      return this.parseImportCall(node);
     } else {
       const id = this.createIdentifierAt(this.startNodeAtNode(node), "import", this.state.lastTokStartLoc);
       if (this.isContextual(98)) {
@@ -8745,16 +8858,16 @@ class ExpressionParser extends LValParser {
         key = this.parseIdentifier(true);
       } else {
         switch (type) {
-          case 132:
+          case 134:
             key = this.parseNumericLiteral(value);
             break;
-          case 131:
+          case 133:
             key = this.parseStringLiteral(value);
             break;
-          case 133:
+          case 135:
             key = this.parseBigIntLiteral(value);
             break;
-          case 135:
+          case 137:
             {
               const privateKeyLoc = this.state.startLoc;
               if (refExpressionErrors != null) {
@@ -8772,7 +8885,7 @@ class ExpressionParser extends LValParser {
         }
       }
       prop.key = key;
-      if (type !== 135) {
+      if (type !== 137) {
         prop.computed = false;
       }
     }
@@ -8829,7 +8942,7 @@ class ExpressionParser extends LValParser {
   }
   parseFunctionBody(node, allowExpression, isMethod = false) {
     const isExpression = allowExpression && !this.match(2);
-    this.expressionScope.enter(newExpressionScope());
+    this.expressionScope.enter(sharedExpressionScope);
     if (isExpression) {
       node.body = this.parseMaybeAssign();
       this.checkParams(node, false, allowExpression, false);
@@ -8950,7 +9063,7 @@ class ExpressionParser extends LValParser {
     const tokenIsKeyword = tokenKeywordOrIdentifierIsKeyword(type);
     if (liberal) {
       if (tokenIsKeyword) {
-        this.replaceToken(129);
+        this.replaceToken(131);
       }
     } else {
       this.checkReservedWord(name, this.sourceToOffsetPos(start), tokenIsKeyword, false);
@@ -9008,7 +9121,6 @@ class ExpressionParser extends LValParser {
   }
   parseAwait(startLoc, soloAwait) {
     const startIndex = startLoc.index;
-    this.setLoc(startLoc);
     const node = this.startNodeAt(startLoc);
     this.expressionScope.recordParameterInitializerError(Errors.AwaitExpressionFormalParameter, startIndex);
     if (this.eat(51)) {
@@ -9032,10 +9144,9 @@ class ExpressionParser extends LValParser {
     const {
       type
     } = this.state;
-    return type === 49 || type === 6 || type === 0 || tokenIsTemplate(type) || type === 99 && !this.state.containsEsc || type === 134 || type === 52 || this.hasPlugin("v8intrinsic") && type === 50;
+    return type === 49 || type === 6 || type === 0 || tokenIsTemplate(type) || type === 99 && !this.state.containsEsc || type === 136 || type === 52 || this.hasPlugin("v8intrinsic") && type === 50;
   }
   parseYield(startLoc) {
-    this.setLoc(startLoc);
     const node = this.startNodeAt(startLoc);
     this.expressionScope.recordParameterInitializerError(Errors.YieldInParameter, startLoc.index);
     let delegating = false;
@@ -9044,7 +9155,7 @@ class ExpressionParser extends LValParser {
       delegating = this.eat(51);
       switch (this.state.type) {
         case 9:
-        case 136:
+        case 138:
         case 4:
         case 7:
         case 1:
@@ -9052,6 +9163,8 @@ class ExpressionParser extends LValParser {
         case 10:
         case 8:
           if (!delegating) break;
+        case 54:
+          if (this.options.annexB && !delegating) break;
         default:
           argument = this.parseMaybeAssign();
       }
@@ -9191,6 +9304,7 @@ const loopLabel = {
   };
 const loneSurrogate = /[\uD800-\uDFFF]/u;
 const keywordRelationalOperator = /in(?:stanceof)?/y;
+const keywordLikeWord = /[a-z]{2,10}/y;
 function createExportedTokens(tokens) {
   for (let i = 0; i < tokens.length; i++) {
     const token = tokens[i];
@@ -9205,7 +9319,7 @@ function createExportedTokens(tokens) {
 }
 class StatementParser extends ExpressionParser {
   parseTopLevel(file, program) {
-    file.program = this.parseProgram(program, 136, this.options.sourceType === "module" ? "module" : "script");
+    file.program = this.parseProgram(program, 138, this.options.sourceType === "module" ? "module" : "script");
     file.comments = this.comments;
     if (this.optionFlags & 512) {
       file.tokens = createExportedTokens(this.tokens);
@@ -9227,7 +9341,7 @@ class StatementParser extends ExpressionParser {
       this.addExtra(program, "topLevelAwait", this.state.hasTopLevelAwait);
     }
     let finishedProgram;
-    if (end === 136) {
+    if (end === 138) {
       finishedProgram = this.finishNode(program, "Program");
     } else {
       finishedProgram = this.finishNodeAt(program, "Program", createPositionWithColumnOffset(this.state.startLoc, -1));
@@ -9263,13 +9377,13 @@ class StatementParser extends ExpressionParser {
     return this.hasFollowingBindingAtom();
   }
   isUsing() {
-    if (!this.isContextual(104)) {
+    if (!this.isContextual(106)) {
       return false;
     }
     return this.nextTokenIsIdentifierOnSameLine();
   }
   isForUsing() {
-    if (!this.isContextual(104)) {
+    if (!this.isContextual(106)) {
       return false;
     }
     const next = this.nextTokenInLineStart();
@@ -9320,6 +9434,22 @@ class StatementParser extends ExpressionParser {
       return false;
     }
   }
+  isReservedWordOnNewLineAfterLet(pos) {
+    if (!hasNewLine(this.input, this.state.end, pos)) {
+      return false;
+    }
+    keywordLikeWord.lastIndex = pos;
+    if (!keywordLikeWord.test(this.input)) {
+      return false;
+    }
+    const end = keywordLikeWord.lastIndex;
+    const endCh = this.codePointAtPos(end);
+    if (isIdentifierChar(endCh) || endCh === 92) {
+      return false;
+    }
+    const word = this.input.slice(pos, end);
+    return isKeyword(word) || isReservedWord(word, false);
+  }
   chStartsBindingPattern(ch) {
     return ch === 91 || ch === 123;
   }
@@ -9388,6 +9518,13 @@ class StatementParser extends ExpressionParser {
       case 76:
         if (!allowDeclaration) this.unexpected();
         return this.parseClass(this.maybeTakeDecorators(decorators, node), true);
+      case 104:
+        if (!this.state.containsEsc && this.nextTokenIsIdentifierOnSameLine()) {
+          this.expectPlugin("structs");
+          if (!allowDeclaration) this.unexpected();
+          return this.parseStructDeclaration(node, false);
+        }
+        break;
       case 65:
         return this.parseIfStatement(node);
       case 66:
@@ -9411,7 +9548,7 @@ class StatementParser extends ExpressionParser {
           return this.parseVarStatement(node, "await using");
         }
         break;
-      case 104:
+      case 106:
         if (this.state.containsEsc || !this.hasInLineFollowingBindingIdentifierOrBrace()) {
           break;
         }
@@ -9433,6 +9570,7 @@ class StatementParser extends ExpressionParser {
             if (!this.chStartsBindingIdentifier(nextCh, next) && nextCh !== 123) {
               break;
             }
+            if (this.isReservedWordOnNewLineAfterLet(next)) break;
           }
         }
       case 71:
@@ -9558,7 +9696,7 @@ class StatementParser extends ExpressionParser {
         while (this.eat(12)) {
           const node = this.startNodeAt(startLoc);
           node.object = expr;
-          if (this.match(135)) {
+          if (this.match(137)) {
             this.classScope.usePrivateName(this.state.value, this.state.startLoc);
             node.property = this.parsePrivateName();
           } else {
@@ -10034,7 +10172,7 @@ class StatementParser extends ExpressionParser {
     this.scope.enter(514);
     this.prodParam.enter(functionFlags(isAsync, node.generator));
     if (!isDeclaration && tokenIsIdentifier(this.state.type)) {
-      this.expressionScope.enter(newExpressionScope());
+      this.expressionScope.enter(sharedExpressionScope);
       node.id = this.parseFunctionId();
       this.expressionScope.exit();
     }
@@ -10052,7 +10190,7 @@ class StatementParser extends ExpressionParser {
   }
   parseFunctionParams(node, isConstructor) {
     this.expect(6);
-    this.expressionScope.enter(newParameterDeclarationScope());
+    this.expressionScope.enter(parameterDeclarationScope);
     node.params = this.parseBindingList(7, 41, 2 | (isConstructor ? 4 : 0));
     this.expressionScope.exit();
   }
@@ -10164,7 +10302,7 @@ class StatementParser extends ExpressionParser {
     this.parsePropertyNamePrefixOperator(member);
     if (this.eat(51)) {
       method.kind = "method";
-      const isPrivateName = this.match(135);
+      const isPrivateName = this.match(137);
       this.parseClassElementName(method);
       this.parsePostMemberNameModifiers(method);
       if (isPrivateName) {
@@ -10219,7 +10357,7 @@ class StatementParser extends ExpressionParser {
         this.unexpected(maybeQuestionTokenStartLoc);
       }
       method.kind = "method";
-      const isPrivate = this.match(135);
+      const isPrivate = this.match(137);
       this.parseClassElementName(method);
       this.parsePostMemberNameModifiers(publicMember);
       if (isPrivate) {
@@ -10233,7 +10371,7 @@ class StatementParser extends ExpressionParser {
     } else if ((maybeContextualKw === "get" || maybeContextualKw === "set") && !(this.match(51) && this.isLineTerminator())) {
       this.resetPreviousNodeTrailingComments(key);
       method.kind = maybeContextualKw;
-      const isPrivate = this.match(135);
+      const isPrivate = this.match(137);
       this.parseClassElementName(publicMethod);
       if (isPrivate) {
         this.pushClassPrivateMethod(classBody, privateMethod, false, false);
@@ -10247,7 +10385,7 @@ class StatementParser extends ExpressionParser {
     } else if (maybeContextualKw === "accessor" && !this.isLineTerminator()) {
       this.expectPlugin("decoratorAutoAccessors");
       this.resetPreviousNodeTrailingComments(key);
-      const isPrivate = this.match(135);
+      const isPrivate = this.match(137);
       this.parseClassElementName(publicProp);
       this.pushClassAccessorProperty(classBody, accessorProp, isPrivate);
     } else if (this.isLineTerminator()) {
@@ -10265,10 +10403,10 @@ class StatementParser extends ExpressionParser {
       type,
       value
     } = this.state;
-    if ((type === 129 || type === 131) && member.static && value === "prototype") {
+    if ((type === 131 || type === 133) && member.static && value === "prototype") {
       this.raise(Errors.StaticPrototype, this.state.startLoc);
     }
-    if (type === 135) {
+    if (type === 137) {
       if (value === "constructor") {
         this.raise(Errors.ConstructorClassPrivateField, this.state.startLoc);
       }
@@ -10345,7 +10483,7 @@ class StatementParser extends ExpressionParser {
   }
   parseInitializer(node) {
     this.scope.enter(576 | 16);
-    this.expressionScope.enter(newExpressionScope());
+    this.expressionScope.enter(sharedExpressionScope);
     this.prodParam.enter(0);
     node.value = this.eat(25) ? this.parseMaybeAssignAllowIn() : null;
     this.expressionScope.exit();
@@ -10375,6 +10513,36 @@ class StatementParser extends ExpressionParser {
       node.superClass = null;
     }
   }
+  parseStructDeclaration(node, optionalId) {
+    this.next();
+    const oldStrict = this.state.strict;
+    this.state.strict = true;
+    this.parseClassId(node, true, optionalId);
+    this.parseClassSuper(node);
+    node.body = this.parseStructBody(!!node.superClass, oldStrict);
+    return this.finishNode(node, "StructDeclaration");
+  }
+  parseStructBody(hadSuperClass, oldStrict) {
+    this.classScope.enter();
+    const state = {
+      hadConstructor: false,
+      hadSuperClass
+    };
+    const structBody = this.startNode();
+    structBody.body = [];
+    this.expect(2);
+    while (!this.match(4)) {
+      if (this.eat(9)) {
+        continue;
+      }
+      const member = this.startNode();
+      this.parseClassMember(structBody, member, state);
+    }
+    this.state.strict = oldStrict;
+    this.next();
+    this.classScope.exit();
+    return this.finishNode(structBody, "StructBody");
+  }
   parseExport(node, decorators) {
     const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, true);
     const hasDefault = this.maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier);
@@ -10382,17 +10550,20 @@ class StatementParser extends ExpressionParser {
     const hasStar = parseAfterDefault && this.eatExportStar(node);
     const hasNamespace = hasStar && this.maybeParseExportNamespaceSpecifier(node);
     const parseAfterNamespace = parseAfterDefault && !hasNamespace;
-    const isFromRequired = hasDefault || hasStar;
     if (hasStar && !hasNamespace) {
       if (hasDefault) this.unexpected();
       if (decorators) {
         throw this.raise(Errors.UnsupportedDecoratorExport, node);
       }
+      if (node.phase === "defer") {
+        this.raise(Errors.DeferExportInvalidAll, node);
+      }
       this.parseExportFrom(node, true);
       this.sawUnambiguousESM = true;
       return this.finishNode(node, "ExportAllDeclaration");
     }
     const hasSpecifiers = parseAfterNamespace && this.maybeParseExportNamedSpecifiers(node);
+    const isFromRequired = hasDefault || hasStar || node.phase === "defer" || hasSpecifiers && node.specifiers[0]?.type === "ExportNamespaceSpecifier";
     if (hasDefault && parseAfterDefault && !hasStar && !hasSpecifiers) {
       this.unexpected(null, 2);
     }
@@ -10414,6 +10585,7 @@ class StatementParser extends ExpressionParser {
       } else if (decorators) {
         throw this.raise(Errors.UnsupportedDecoratorExport, node);
       }
+      if (this.hasPlugin("deferredReexports")) node2.phase ??= null;
       this.sawUnambiguousESM = true;
       return this.finishNode(node2, "ExportNamedDeclaration");
     }
@@ -10467,7 +10639,19 @@ class StatementParser extends ExpressionParser {
       const node2 = node;
       if (!node2.specifiers) node2.specifiers = [];
       const isTypeExport = node2.exportKind === "type";
-      node2.specifiers.push(...this.parseExportSpecifiers(isTypeExport));
+      const startLoc = this.state.startLoc;
+      this.setLoc(startLoc);
+      const specifiers = this.parseExportSpecifiers(isTypeExport);
+      if (this.isContextual(90) && !this.hasPrecedingLineBreak()) {
+        this.expectPlugin("namespaceImportFilter");
+        const specifier = this.startNodeAt(startLoc);
+        specifier.exportsFilter = this.toNamespaceExportsFilter(specifiers);
+        this.next();
+        specifier.exported = this.parseModuleExportName();
+        node2.specifiers.push(this.finishNode(specifier, "ExportNamespaceSpecifier"));
+      } else {
+        node2.specifiers.push(...specifiers);
+      }
       node2.source = null;
       node2.attributes = [];
       node2.declaration = null;
@@ -10503,10 +10687,18 @@ class StatementParser extends ExpressionParser {
     if (this.match(76)) {
       return this.parseClass(expr, true, true);
     }
+    if (this.isContextual(104)) {
+      const next = this.nextTokenInLineStart();
+      const nextCh = this.codePointAtPos(next);
+      if (nextCh === 123 || this.chStartsBindingIdentifier(nextCh, next)) {
+        this.expectPlugin("structs");
+        return this.parseStructDeclaration(expr, true);
+      }
+    }
     if (this.match(22)) {
       return this.parseClass(this.maybeTakeDecorators(this.parseDecorators(false), this.startNode()), true, true);
     }
-    if (this.match(71) || this.match(70) || this.isLet() || this.isUsing() || this.isAwaitUsing()) {
+    if (this.match(71) || this.match(70) || this.isLet() && !this.isReservedWordOnNewLineAfterLet(this.nextTokenStart()) || this.isUsing() || this.isAwaitUsing()) {
       throw this.raise(Errors.UnsupportedDefaultExport, this.state.startLoc);
     }
     const res = this.parseMaybeAssignAllowIn();
@@ -10518,6 +10710,14 @@ class StatementParser extends ExpressionParser {
       const node = this.parseClass(this.startNode(), true, false);
       return node;
     }
+    if (this.isContextual(104) && this.nextTokenIsIdentifierOnSameLine()) {
+      this.expectPlugin("structs");
+      const node = this.parseStructDeclaration(this.startNode(), false);
+      return node;
+    }
+    if (this.isContextual(97)) {
+      return this.parseVarStatement(this.startNode(), "let");
+    }
     return this.parseStatementListItem();
   }
   isExportDefaultSpecifier() {
@@ -10528,11 +10728,13 @@ class StatementParser extends ExpressionParser {
       if (type === 92 && !this.state.containsEsc || type === 97) {
         return false;
       }
-      if ((type === 127 || type === 126) && !this.state.containsEsc) {
+      if ((type === 129 || type === 128 || type === 104) && !this.state.containsEsc) {
         const next = this.nextTokenStart();
         const nextChar = this.input.charCodeAt(next);
-        if (nextChar === 123 || this.chStartsBindingIdentifier(nextChar, next) && !this.input.startsWith("from", next)) {
-          this.expectOnePlugin(["flow", "typescript"]);
+        if (nextChar === 123 || this.chStartsBindingIdentifier(nextChar, next) && !this.isUnparsedContextual(next, "from")) {
+          if (type !== 104) {
+            this.expectOnePlugin(["flow", "typescript"]);
+          }
           return false;
         }
       }
@@ -10577,7 +10779,7 @@ class StatementParser extends ExpressionParser {
       this.raise(Errors.UsingDeclarationExport, this.state.startLoc);
       return true;
     }
-    return type === 70 || type === 71 || type === 64 || type === 76 || this.isLet() || this.isAsyncFunction();
+    return type === 70 || type === 71 || type === 64 || type === 76 || this.isLet() || this.isAsyncFunction() || this.isContextual(104) && this.nextTokenIsIdentifierOnSameLine();
   }
   checkNamedExport(node, isFrom) {
     if (node.specifiers?.length) {
@@ -10604,7 +10806,7 @@ class StatementParser extends ExpressionParser {
       }
     } else if (node.declaration) {
       const decl = node.declaration;
-      if (decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration") {
+      if (decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration" || decl.type === "StructDeclaration") {
         const {
           id
         } = decl;
@@ -10661,8 +10863,8 @@ class StatementParser extends ExpressionParser {
         this.expect(8);
         if (this.eat(4)) break;
       }
-      const isMaybeTypeOnly = this.isContextual(127);
-      const isString = this.match(131);
+      const isMaybeTypeOnly = this.isContextual(129);
+      const isString = this.match(133);
       const node = this.startNode();
       node.local = this.parseModuleExportName();
       nodes.push(this.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly));
@@ -10680,7 +10882,7 @@ class StatementParser extends ExpressionParser {
     return this.finishNode(node, "ExportSpecifier");
   }
   parseModuleExportName() {
-    if (this.match(131)) {
+    if (this.match(133)) {
       const result = this.parseStringLiteral(this.state.value);
       const surrogate = loneSurrogate.exec(result.value);
       if (surrogate) {
@@ -10692,27 +10894,80 @@ class StatementParser extends ExpressionParser {
     }
     return this.parseIdentifier(true);
   }
+  toNamespaceExportsFilter(specifiers) {
+    const seen = new Set();
+    return specifiers.map(specifier => {
+      let name, alias, kind;
+      if (specifier.type === "ImportSpecifier") {
+        ({
+          imported: name,
+          local: alias,
+          importKind: kind
+        } = specifier);
+      } else {
+        ({
+          local: name,
+          exported: alias,
+          exportKind: kind
+        } = specifier);
+      }
+      const nameString = name.type === "Identifier" ? name.name : this.isStringModuleExportName(name) ? name.value : null;
+      if (nameString !== null) {
+        if (seen.has(nameString)) {
+          this.raise(Errors.FilteredNamespaceDuplicateName, name, {
+            name: nameString
+          });
+        }
+        seen.add(nameString);
+      }
+      let invalid = false;
+      if (alias.start !== name.start) {
+        this.raise(Errors.FilteredNamespaceRename, alias);
+        invalid = true;
+      }
+      if (kind === "type" || kind === "typeof") {
+        this.raise(Errors.FilteredNamespaceTypeModifier, specifier);
+        invalid = true;
+      }
+      if (invalid) {
+        return specifier;
+      }
+      this.replaceNodeInPendingComments(specifier, name);
+      return name;
+    });
+  }
   checkImportPhase(node) {
+    if (node.phase == null) {
+      return;
+    }
     const {
       specifiers
     } = node;
     const singleBindingType = specifiers.length === 1 ? specifiers[0].type : null;
     if (node.phase === "source") {
       if (singleBindingType !== "ImportDefaultSpecifier") {
-        this.raise(Errors.SourcePhaseImportRequiresDefault, specifiers[0]);
+        this.raise(Errors.SourcePhaseImportRequiresDefault, node);
       }
     } else if (node.phase === "defer") {
       if (singleBindingType !== "ImportNamespaceSpecifier") {
-        this.raise(Errors.DeferImportRequiresNamespace, specifiers[0]);
+        this.raise(Errors.DeferImportRequiresNamespace, node);
       }
     }
   }
   isPotentialImportPhase(isExport) {
-    if (isExport) return false;
+    if (isExport) {
+      if (!this.isContextual(94)) return false;
+      const ch = this.lookaheadCharCode();
+      return ch === 123 || ch === 42;
+    }
     return this.isContextual(102) || this.isContextual(94);
   }
   applyImportPhase(node, isExport, phase, loc) {
     if (isExport) {
+      if (phase === "defer") {
+        this.expectPlugin("deferredReexports", loc);
+        node.phase = "defer";
+      }
       return;
     }
     if (phase === "source") {
@@ -10751,7 +11006,7 @@ class StatementParser extends ExpressionParser {
     return tokenIsIdentifier(type) ? type !== 95 || this.lookaheadCharCode() === 102 : type !== 8;
   }
   parseImport(node) {
-    if (this.match(131)) {
+    if (this.match(133)) {
       return this.parseImportSourceAndAttributes(node);
     }
     return this.parseImportSpecifiersAndAfter(node, this.parseMaybeImportPhase(node, false));
@@ -10761,7 +11016,7 @@ class StatementParser extends ExpressionParser {
     const hasDefault = this.maybeParseDefaultImportSpecifier(node, maybeDefaultIdentifier);
     const parseNext = !hasDefault || this.eat(8);
     const hasStar = parseNext && this.maybeParseStarImportSpecifier(node);
-    if (parseNext && !hasStar) this.parseNamedImportSpecifiers(node);
+    if (parseNext && !hasStar) this.parseNamedOrFilteredImportSpecifiers(node);
     this.expectContextual(95);
     return this.parseImportSourceAndAttributes(node);
   }
@@ -10775,17 +11030,17 @@ class StatementParser extends ExpressionParser {
     return this.finishNode(node, "ImportDeclaration");
   }
   parseImportSource() {
-    if (!this.match(131)) this.unexpected();
+    if (!this.match(133)) this.unexpected();
     return this.parseExprAtom();
   }
   parseImportSpecifierLocal(node, specifier, type) {
     specifier.local = this.parseIdentifier();
     node.specifiers.push(this.finishImportSpecifier(specifier, type));
   }
-  finishImportSpecifier(specifier, type, bindingType = 8201) {
+  finishImportSpecifier(specifier, type) {
     this.checkLVal(specifier.local, {
       type
-    }, bindingType);
+    }, 8201);
     return this.finishNode(specifier, type);
   }
   parseImportAttributes() {
@@ -10804,13 +11059,13 @@ class StatementParser extends ExpressionParser {
         });
       }
       attrNames.add(keyName);
-      if (this.match(131)) {
+      if (this.match(133)) {
         node.key = this.parseStringLiteral(keyName);
       } else {
         node.key = this.parseIdentifier(true);
       }
       this.expect(10);
-      if (!this.match(131)) {
+      if (!this.match(133)) {
         throw this.raise(Errors.ModuleAttributeInvalidValue, this.state.startLoc);
       }
       node.value = this.parseStringLiteral(this.state.value);
@@ -10854,6 +11109,24 @@ class StatementParser extends ExpressionParser {
     }
     return false;
   }
+  parseNamedOrFilteredImportSpecifiers(node) {
+    const startLoc = this.state.startLoc;
+    this.setLoc(startLoc);
+    const specifiersStart = node.specifiers.length;
+    this.parseNamedImportSpecifiers(node);
+    if (this.isContextual(90)) {
+      this.expectPlugin("namespaceImportFilter");
+      const specifier = this.startNodeAt(startLoc);
+      specifier.exportsFilter = this.toNamespaceExportsFilter(node.specifiers.splice(specifiersStart));
+      this.next();
+      this.parseImportSpecifierLocal(node, specifier, "ImportNamespaceSpecifier");
+      return;
+    }
+    const isInTypeOnlyImport = node.importKind === "type" || node.importKind === "typeof";
+    for (let i = specifiersStart; i < node.specifiers.length; i++) {
+      this.checkImportSpecifier(node.specifiers[i], isInTypeOnlyImport);
+    }
+  }
   parseNamedImportSpecifiers(node) {
     let first = true;
     this.expect(2);
@@ -10868,31 +11141,40 @@ class StatementParser extends ExpressionParser {
         if (this.eat(4)) break;
       }
       const specifier = this.startNode();
-      const importedIsString = this.match(131);
-      const isMaybeTypeOnly = this.isContextual(127);
+      const importedIsString = this.match(133);
+      const isMaybeTypeOnly = this.isContextual(129);
       specifier.imported = this.parseModuleExportName();
-      const importSpecifier = this.parseImportSpecifier(specifier, importedIsString, node.importKind === "type" || node.importKind === "typeof", isMaybeTypeOnly, undefined);
+      const importSpecifier = this.parseImportSpecifier(specifier, importedIsString, node.importKind === "type" || node.importKind === "typeof", isMaybeTypeOnly);
       node.specifiers.push(importSpecifier);
     }
   }
-  parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
+  parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly) {
     if (this.eatContextual(90)) {
       specifier.local = this.parseIdentifier();
     } else {
-      const {
-        imported
-      } = specifier;
-      if (importedIsString) {
-        throw this.raise(Errors.ImportBindingIsString, specifier, {
-          importName: imported.value
-        });
-      }
-      this.checkReservedWord(imported.name, specifier.start, true, true);
-      if (!specifier.local) {
-        specifier.local = this.cloneIdentifier(imported);
-      }
+      specifier.local ??= this.cloneIdentifier(specifier.imported);
+    }
+    return this.finishNode(specifier, "ImportSpecifier");
+  }
+  checkImportSpecifier(specifier, isInTypeOnlyImport, bindingType = 8201, checkReservedWord = true) {
+    const {
+      imported,
+      local
+    } = specifier;
+    if (this.isStringModuleExportName(local)) {
+      throw this.raise(Errors.ImportBindingIsString, specifier, {
+        importName: imported.value
+      });
     }
-    return this.finishImportSpecifier(specifier, "ImportSpecifier", bindingType);
+    if (checkReservedWord && local.start === imported.start) {
+      this.checkReservedWord(local.name, local.start, true, true);
+    }
+    this.checkLVal(local, {
+      type: "ImportSpecifier"
+    }, bindingType);
+  }
+  isStringModuleExportName(node) {
+    return node.type === "StringLiteral" || node.type === "Literal";
   }
   isThisParam(param) {
     return param.type === "Identifier" && param.name === "this";
@@ -11070,6 +11352,17 @@ function tsIsEntityName(node) {
       return false;
   }
 }
+function tsIsTypeCast(node) {
+  switch (node.type) {
+    case "TSAsExpression":
+    case "TSSatisfiesExpression":
+    case "TSNonNullExpression":
+    case "TSTypeAssertion":
+      return true;
+    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"]);
@@ -11082,7 +11375,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
     return tokenIsIdentifier(this.state.type);
   }
   tsTokenCanFollowModifier() {
-    return this.match(0) || this.match(2) || this.match(51) || this.match(17) || this.match(135) || this.isLiteralPropertyName();
+    return this.match(0) || this.match(2) || this.match(51) || this.match(17) || this.match(137) || this.isLiteralPropertyName();
   }
   tsNextTokenOnSameLineAndCanFollowModifier() {
     this.next();
@@ -11259,7 +11552,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
     const node = this.startNode();
     this.expect(79);
     this.expect(6);
-    if (!this.match(131)) {
+    if (!this.match(133)) {
       this.raise(TSErrors.UnsupportedImportTypeArgument, this.state.startLoc);
       node.source = this.tsParseNonConditionalType();
     } else {
@@ -11304,7 +11597,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
     this.expect(2);
     while (!this.match(4)) {
       const type = this.state.type;
-      if (tokenIsIdentifier(type) || type === 131) {
+      if (tokenIsIdentifier(type) || type === 133) {
         properties.push(super.parsePropertyDefinition(null));
       } else {
         this.unexpected();
@@ -11388,7 +11681,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
   }
   tsParseTypeParameters(parseModifiers) {
     const node = this.startNode();
-    if (this.match(43) || this.match(139)) {
+    if (this.match(43) || this.match(141)) {
       this.next();
     } else {
       this.unexpected();
@@ -11559,9 +11852,9 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
   tsIsStartOfMappedType() {
     this.next();
     if (this.eat(49)) {
-      return this.isContextual(119);
+      return this.isContextual(121);
     }
-    if (this.isContextual(119)) {
+    if (this.isContextual(121)) {
       this.next();
     }
     if (!this.match(0)) {
@@ -11580,8 +11873,8 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
     if (this.match(49)) {
       node.readonly = this.state.value;
       this.next();
-      this.expectContextual(119);
-    } else if (this.eatContextual(119)) {
+      this.expectContextual(121);
+    } else if (this.eatContextual(121)) {
       node.readonly = true;
     }
     this.expect(0);
@@ -11705,9 +11998,9 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
   tsParseLiteralTypeNode() {
     const node = this.startNode();
     switch (this.state.type) {
-      case 132:
+      case 134:
+      case 135:
       case 133:
-      case 131:
       case 81:
       case 82:
         node.literal = super.parseExprAtom();
@@ -11747,7 +12040,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
   }
   tsParseThisTypeOrThisTypePredicate() {
     const thisKeyword = this.tsParseThisTypeNode();
-    if (this.isContextual(113) && !this.hasPrecedingLineBreak()) {
+    if (this.isContextual(115) && !this.hasPrecedingLineBreak()) {
       return this.tsParseThisTypePredicate(thisKeyword);
     } else {
       return thisKeyword;
@@ -11755,9 +12048,9 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
   }
   tsParseNonArrayType() {
     switch (this.state.type) {
-      case 131:
-      case 132:
       case 133:
+      case 134:
+      case 135:
       case 81:
       case 82:
         return this.tsParseLiteralTypeNode();
@@ -11765,7 +12058,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
         if (this.state.value === "-") {
           const node = this.startNode();
           const nextToken = this.lookahead();
-          if (nextToken.type !== 132 && nextToken.type !== 133) {
+          if (nextToken.type !== 134 && nextToken.type !== 135) {
             this.unexpected();
           }
           node.literal = this.parseMaybeUnary();
@@ -11857,7 +12150,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
   }
   tsParseInferType() {
     const node = this.startNode();
-    this.expectContextual(112);
+    this.expectContextual(114);
     const typeParameter = this.startNode();
     typeParameter.name = this.tsParseTypeParameterName();
     typeParameter.constraint = this.tsTryParse(() => this.tsParseConstraintForInferType());
@@ -11874,7 +12167,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
   }
   tsParseTypeOperatorOrHigher() {
     const isTypeOperator = tokenIsTSTypeOperator(this.state.type) && !this.state.containsEsc;
-    return isTypeOperator ? this.tsParseTypeOperator() : this.isContextual(112) ? this.tsParseInferType() : this.tsInAllowConditionalTypesContext(() => this.tsParseArrayTypeOrHigher());
+    return isTypeOperator ? this.tsParseTypeOperator() : this.isContextual(114) ? this.tsParseInferType() : this.tsInAllowConditionalTypesContext(() => this.tsParseArrayTypeOrHigher());
   }
   tsParseUnionOrIntersectionType(kind, parseConstituentType, operator) {
     const node = this.startNode();
@@ -11906,28 +12199,23 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
       this.next();
       return true;
     }
-    if (this.match(2)) {
-      const {
-        errors
-      } = this.state;
-      const previousErrorCount = errors.length;
-      try {
-        this.parseObjectLike(4, true);
-        return errors.length === previousErrorCount;
-      } catch {
-        return false;
-      }
-    }
-    if (this.match(0)) {
-      this.next();
+    const isObjectPattern = this.match(2);
+    if (isObjectPattern || this.match(0)) {
+      if (!isObjectPattern) this.next();
       const {
         errors
       } = this.state;
       const previousErrorCount = errors.length;
+      const scopeStacksSnapshot = this.snapshotScopeStacks();
       try {
-        super.parseBindingList(1, 93, 1);
+        if (isObjectPattern) {
+          this.parseObjectLike(4, true);
+        } else {
+          super.parseBindingList(1, 93, 1);
+        }
         return errors.length === previousErrorCount;
       } catch {
+        this.restoreScopeStacks(scopeStacksSnapshot);
         return false;
       }
     }
@@ -12005,13 +12293,13 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
   }
   tsParseTypePredicatePrefix() {
     const id = this.parseIdentifier();
-    if (this.isContextual(113) && !this.hasPrecedingLineBreak()) {
+    if (this.isContextual(115) && !this.hasPrecedingLineBreak()) {
       this.next();
       return id;
     }
   }
   tsParseTypePredicateAsserts() {
-    if (this.state.type !== 106) {
+    if (this.state.type !== 108) {
       return false;
     }
     const containsEsc = this.state.containsEsc;
@@ -12049,7 +12337,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
     return this.finishNode(node, "TSConditionalType");
   }
   isAbstractConstructorSignature() {
-    return this.isContextual(121) && this.isLookaheadContextual("new");
+    return this.isContextual(123) && this.isLookaheadContextual("new");
   }
   tsParseNonConditionalType() {
     if (this.tsIsStartOfFunctionType()) {
@@ -12106,7 +12394,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
   }
   tsParseInterfaceDeclaration(node, properties = {}) {
     if (this.hasFollowingLineBreak()) return null;
-    this.expectContextual(126);
+    this.expectContextual(128);
     if (properties.declare) node.declare = true;
     if (tokenIsIdentifier(this.state.type)) {
       node.id = this.parseIdentifier();
@@ -12130,7 +12418,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
     node.typeAnnotation = this.tsInType(() => {
       node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers);
       this.expect(25);
-      if (this.isContextual(111) && this.lookaheadCharCode() !== 46) {
+      if (this.isContextual(113) && this.lookaheadCharCode() !== 46) {
         const node = this.startNode();
         this.next();
         return this.finishNode(node, "TSIntrinsicKeyword");
@@ -12199,7 +12487,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
   }
   tsParseEnumMember() {
     const node = this.startNode();
-    node.id = this.match(131) ? super.parseStringLiteral(this.state.value) : this.parseIdentifier(true);
+    node.id = this.match(133) ? super.parseStringLiteral(this.state.value) : this.parseIdentifier(true);
     if (this.eat(25)) {
       node.initializer = super.parseMaybeAssignAllowIn();
     }
@@ -12208,7 +12496,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
   tsParseEnumDeclaration(node, properties = {}) {
     if (properties.const) node.const = true;
     if (properties.declare) node.declare = true;
-    this.expectContextual(123);
+    this.expectContextual(125);
     node.id = this.parseIdentifier();
     this.checkIdentifier(node.id, node.const ? 8971 : 8459);
     node.body = this.tsParseEnumBody();
@@ -12246,7 +12534,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
     return this.finishNode(node, "TSModuleDeclaration");
   }
   tsParseAmbientExternalModuleDeclaration(node) {
-    const isGlobal = this.isContextual(109);
+    const isGlobal = this.isContextual(111);
     if (isGlobal) {
       node.kind = "global";
       node.id = this.parseIdentifier();
@@ -12256,7 +12544,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
         type,
         value
       } = this.state;
-      if (type === 131) {
+      if (type === 133) {
         node.id = super.parseStringLiteral(value);
       } else if (tokenIsIdentifier(type)) {
         this.raise(TSErrors.InlineModuleDeclarationMustUseString, this.state.startLoc);
@@ -12296,16 +12584,16 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
     return this.finishNode(node, "TSImportEqualsDeclaration");
   }
   tsIsExternalModuleReference() {
-    return this.isContextual(116) && this.lookaheadCharCode() === 40;
+    return this.isContextual(118) && this.lookaheadCharCode() === 40;
   }
   tsParseModuleReference() {
     return this.tsIsExternalModuleReference() ? this.tsParseExternalModuleReference() : this.tsParseEntityName(0);
   }
   tsParseExternalModuleReference() {
     const node = this.startNode();
-    this.expectContextual(116);
+    this.expectContextual(118);
     this.expect(6);
-    if (!this.match(131)) {
+    if (!this.match(133)) {
       this.unexpected();
     }
     node.expression = super.parseExprAtom();
@@ -12346,11 +12634,11 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
         case 76:
           node.declare = true;
           return this.parseClass(node, true, false);
-        case 123:
+        case 125:
           return this.tsParseEnumDeclaration(node, {
             declare: true
           });
-        case 109:
+        case 111:
           return this.tsParseAmbientExternalModuleDeclaration(node);
         case 97:
           if (this.state.containsEsc) {
@@ -12367,7 +12655,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
             const: true,
             declare: true
           });
-        case 104:
+        case 106:
           if (this.isUsing()) {
             this.raise(TSErrors.InvalidModifierOnUsingDeclaration, this.state.startLoc, "declare");
             node.declare = true;
@@ -12382,7 +12670,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
             return this.parseVarStatement(node, "await using", true);
           }
           break;
-        case 126:
+        case 128:
           {
             const result = this.tsParseInterfaceDeclaration(node, {
               declare: true
@@ -12401,23 +12689,23 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
   }
   tsParseDeclaration(node, type, next, decorators) {
     switch (type) {
-      case 121:
+      case 123:
         if (this.tsCheckLineTerminator(next) && (this.match(76) || tokenIsIdentifier(this.state.type))) {
           return this.tsParseAbstractDeclaration(node, decorators);
         }
         break;
-      case 124:
+      case 126:
         if (this.tsCheckLineTerminator(next)) {
           return this.tsParseAmbientExternalModuleDeclaration(node);
         }
         break;
-      case 125:
+      case 127:
         if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) {
           node.kind = "namespace";
           return this.tsParseNamespaceDeclaration(node);
         }
         break;
-      case 127:
+      case 129:
         if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) {
           return this.tsParseTypeAliasDeclaration(node);
         }
@@ -12490,8 +12778,6 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
       const pp = startLoc ? this.startNodeAt(startLoc) : this.startNodeAtNode(decorators[0]);
       if (decorators.length) {
         pp.decorators = decorators;
-      } else {
-        this.setLoc(startLoc);
       }
       if (accessibility) pp.accessibility = accessibility;
       if (readonly) pp.readonly = readonly;
@@ -12628,7 +12914,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
           return this.finishCallExpression(node, state.optionalChainMember);
         }
         const tokenType = this.state.type;
-        if (tokenType === 44 || tokenType === 48 || tokenType !== 6 && tokenType !== 90 && tokenType !== 117 && tokenCanStartExpression(tokenType) && !this.hasPrecedingLineBreak()) {
+        if (tokenType === 44 || tokenType === 48 || tokenType !== 6 && tokenType !== 90 && tokenType !== 119 && tokenCanStartExpression(tokenType) && !this.hasPrecedingLineBreak()) {
           return;
         }
         const node = this.startNodeAt(startLoc);
@@ -12665,7 +12951,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
   }
   parseExprOp(left, leftStartLoc, minPrec) {
     let isSatisfies;
-    if (tokenOperatorPrecedence(54) > minPrec && !this.hasPrecedingLineBreak() && (this.isContextual(90) || (isSatisfies = this.isContextual(117)))) {
+    if (tokenOperatorPrecedence(54) > minPrec && !this.hasPrecedingLineBreak() && (this.isContextual(90) || (isSatisfies = this.isContextual(119)))) {
       const node = this.startNodeAt(leftStartLoc);
       node.expression = left;
       node.typeAnnotation = this.tsInType(() => {
@@ -12694,7 +12980,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
   checkDuplicateExports() {}
   isPotentialImportPhase(isExport) {
     if (super.isPotentialImportPhase(isExport)) return true;
-    if (this.isContextual(127)) {
+    if (this.isContextual(129)) {
       const ch = this.lookaheadCharCode();
       return isExport ? ch === 123 || ch === 42 : ch !== 61;
     }
@@ -12709,7 +12995,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
     }
   }
   parseImport(node) {
-    if (this.match(131)) {
+    if (this.match(133)) {
       node.importKind = "value";
       if (this.scope.inTSNamespace) {
         this.raise(TSErrors.ImportInTSNamespace, node);
@@ -12724,7 +13010,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
         this.raise(TSErrors.ImportInTSNamespace, node);
       }
       return result;
-    } else if (this.isContextual(127)) {
+    } else if (this.isContextual(129)) {
       const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, false);
       if (this.lookaheadCharCode() === 61) {
         if (this.scope.inTSNamespace) {
@@ -12749,7 +13035,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
       const nodeImportEquals = this.startNode();
       this.next();
       let maybeDefaultIdentifier = null;
-      if (this.isContextual(127) && this.isPotentialImportPhase(false)) {
+      if (this.isContextual(129) && this.isPotentialImportPhase(false)) {
         maybeDefaultIdentifier = this.parseMaybeImportPhase(nodeImportEquals, false);
       } else {
         nodeImportEquals.importKind = "value";
@@ -12772,7 +13058,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
       return this.finishNode(assign, "TSExportAssignment");
     } else if (this.eatContextual(90)) {
       const decl = node;
-      this.expectContextual(125);
+      this.expectContextual(127);
       decl.id = this.parseIdentifier();
       this.checkIdentifier(decl.id, 8201);
       this.semicolon();
@@ -12789,7 +13075,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
     }
   }
   isAbstractClass() {
-    return this.isContextual(121) && this.isLookaheadContextual("class");
+    return this.isContextual(123) && this.isLookaheadContextual("class");
   }
   parseExportDefaultExpression() {
     if (this.isAbstractClass()) {
@@ -12798,7 +13084,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
       cls.abstract = true;
       return this.parseClass(cls, true, true);
     }
-    if (this.match(126)) {
+    if (this.match(128)) {
       const result = this.tsParseInterfaceDeclaration(this.startNode());
       if (result) return result;
     }
@@ -12851,30 +13137,30 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
             }
             break;
           }
-        case 121:
-        case 122:
+        case 123:
+        case 124:
           {
             if (this.nextTokenIsIdentifierAndNotTSRelationalOperatorOnSameLine()) {
               const token = this.state.type;
               const node = this.startNode();
               this.next();
-              const declaration = token === 122 ? this.tsTryParseDeclare(node) : this.tsParseAbstractDeclaration(node, decorators);
+              const declaration = token === 124 ? this.tsTryParseDeclare(node) : this.tsParseAbstractDeclaration(node, decorators);
               if (declaration) {
-                if (token === 122) {
+                if (token === 124) {
                   declaration.declare = true;
                 }
                 return declaration;
               } else {
-                node.expression = this.createIdentifier(this.startNodeAtNode(node), token === 122 ? "declare" : "abstract");
+                node.expression = this.createIdentifier(this.startNodeAtNode(node), token === 124 ? "declare" : "abstract");
                 this.semicolon(false);
                 return this.finishNode(node, "ExpressionStatement");
               }
             }
             break;
           }
-        case 123:
+        case 125:
           return this.tsParseEnumDeclaration(this.startNode());
-        case 109:
+        case 111:
           {
             const nextCh = this.lookaheadCharCode();
             if (nextCh === 123) {
@@ -12883,7 +13169,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
             }
             break;
           }
-        case 126:
+        case 128:
           {
             const result = this.tsParseInterfaceDeclaration(this.startNode());
             if (result) {
@@ -12894,30 +13180,30 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
             }
             break;
           }
-        case 124:
+        case 126:
           {
             if (this.nextTokenIsStringLiteralOnSameLine()) {
               const node = this.startNode();
               this.next();
-              return this.tsParseDeclaration(node, 124, false, decorators);
+              return this.tsParseDeclaration(node, 126, false, decorators);
             } else if (this.nextTokenIsIdentifierOnSameLine()) {
               this.raise(TSErrors.InlineModuleDeclarationMustUseString, this.state.startLoc);
               const node = this.startNode();
               this.next();
-              return this.tsParseDeclaration(node, 125, false, decorators);
+              return this.tsParseDeclaration(node, 127, false, decorators);
             }
             break;
           }
-        case 125:
+        case 127:
           {
             if (this.nextTokenIsIdentifierOnSameLine()) {
               const node = this.startNode();
               this.next();
-              return this.tsParseDeclaration(node, 125, false, decorators);
+              return this.tsParseDeclaration(node, 127, false, decorators);
             }
             break;
           }
-        case 127:
+        case 129:
           {
             if (this.nextTokenIsIdentifierOnSameLine()) {
               const node = this.startNode();
@@ -13057,12 +13343,12 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
     return node;
   }
   parseExportDeclaration(node) {
-    if (!this.state.isAmbientContext && this.isContextual(122)) {
+    if (!this.state.isAmbientContext && this.isContextual(124)) {
       return this.tsInAmbientContext(() => this.parseExportDeclaration(node));
     }
     const startLoc = this.state.startLoc;
-    const isDeclare = this.eatContextual(122);
-    if (isDeclare && (this.isContextual(122) || !this.shouldParseExportDeclaration())) {
+    const isDeclare = this.eatContextual(124);
+    if (isDeclare && (this.isContextual(124) || !this.shouldParseExportDeclaration())) {
       throw this.raise(TSErrors.ExpectedAmbientAfterExportDeclare, this.state.startLoc);
     }
     const isIdentifier = tokenIsIdentifier(this.state.type);
@@ -13078,7 +13364,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
     return declaration;
   }
   parseClassId(node, isStatement, optionalId, bindingType) {
-    if ((!isStatement || optionalId) && this.isContextual(110)) {
+    if ((!isStatement || optionalId) && this.isContextual(112)) {
       node.id = null;
       return;
     }
@@ -13182,7 +13468,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
         node.superTypeArguments = this.tsParseTypeArgumentsInExpression();
       }
     }
-    if (this.eatContextual(110)) {
+    if (this.eatContextual(112)) {
       node.implements = this.tsParseHeritageClause("implements");
     }
   }
@@ -13217,7 +13503,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
     let state;
     let jsx;
     let typeCast;
-    if (this.hasPlugin("jsx") && (this.match(139) || this.match(43))) {
+    if (this.hasPlugin("jsx") && (this.match(141) || this.match(43))) {
       state = this.state.clone();
       jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, isParenItem), state);
       if (!jsx.error) return jsx.node;
@@ -13324,21 +13610,19 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
     }
   }
   toAssignable(node, isLHS = false) {
+    if (tsIsTypeCast(node)) {
+      if (isLHS) {
+        this.expressionScope.recordArrowParameterBindingError(TSErrors.UnexpectedTypeCastInParameter, node);
+      } else {
+        this.raiseOnce(TSErrors.UnexpectedTypeCastInParameter, node);
+      }
+      this.toAssignable(node.expression, isLHS);
+      return;
+    }
     switch (node.type) {
       case "ParenthesizedExpression":
         this.toAssignableParenthesizedExpression(node, isLHS);
         break;
-      case "TSAsExpression":
-      case "TSSatisfiesExpression":
-      case "TSNonNullExpression":
-      case "TSTypeAssertion":
-        if (isLHS) {
-          this.expressionScope.recordArrowParameterBindingError(TSErrors.UnexpectedTypeCastInParameter, node);
-        } else {
-          this.raise(TSErrors.UnexpectedTypeCastInParameter, node);
-        }
-        this.toAssignable(node.expression, isLHS);
-        break;
       case "AssignmentExpression":
         if (!isLHS && node.left.type === "TSTypeCastExpression") {
           node.left = this.typeCastToParameter(node.left);
@@ -13348,28 +13632,17 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
     }
   }
   toAssignableParenthesizedExpression(node, isLHS) {
-    switch (node.expression.type) {
-      case "TSAsExpression":
-      case "TSSatisfiesExpression":
-      case "TSNonNullExpression":
-      case "TSTypeAssertion":
-      case "ParenthesizedExpression":
-        this.toAssignable(node.expression, isLHS);
-        break;
-      default:
-        super.toAssignable(node, isLHS);
+    if (tsIsTypeCast(node.expression) || node.expression.type === "ParenthesizedExpression") {
+      this.toAssignable(node.expression, isLHS);
+    } else {
+      super.toAssignable(node, isLHS);
     }
   }
   checkToRestConversion(node, allowPattern) {
-    switch (node.type) {
-      case "TSAsExpression":
-      case "TSSatisfiesExpression":
-      case "TSTypeAssertion":
-      case "TSNonNullExpression":
-        this.checkToRestConversion(node.expression, false);
-        break;
-      default:
-        super.checkToRestConversion(node, allowPattern);
+    if (tsIsTypeCast(node)) {
+      this.checkToRestConversion(node.expression, false);
+    } else {
+      super.checkToRestConversion(node, allowPattern);
     }
   }
   isValidLVal(type, disallowCallExpression, isUnparenthesizedInAssign, binding) {
@@ -13549,7 +13822,7 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
     if (this.match(76)) {
       node.abstract = true;
       return this.maybeTakeDecorators(decorators, this.parseClass(node, true, false));
-    } else if (this.isContextual(126)) {
+    } else if (this.isContextual(128)) {
       if (!this.hasFollowingLineBreak()) {
         node.abstract = true;
         this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifier, node);
@@ -13602,15 +13875,22 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
     node.exportKind = "value";
     return super.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly);
   }
-  parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
+  parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly) {
     if (!importedIsString && isMaybeTypeOnly) {
-      this.parseTypeOnlyImportSpecifier(specifier, isInTypeOnlyImport);
+      this.parseTypeOnlyImportSpecifier(specifier);
       return this.finishNode(specifier, "ImportSpecifier");
     }
     specifier.importKind = "value";
-    return super.parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, isInTypeOnlyImport ? 4098 : 4096);
+    return super.parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly);
+  }
+  checkImportSpecifier(specifier, isInTypeOnlyImport) {
+    const hasTypeSpecifier = specifier.importKind === "type";
+    if (hasTypeSpecifier && isInTypeOnlyImport) {
+      this.raise(TSErrors.TypeModifierIsUsedInTypeImports, specifier);
+    }
+    super.checkImportSpecifier(specifier, isInTypeOnlyImport, hasTypeSpecifier || isInTypeOnlyImport ? 4098 : 4096);
   }
-  parseTypeOnlyImportSpecifier(node, isInTypeOnly) {
+  parseTypeOnlyImportSpecifier(node) {
     let leftOfAs = node.imported;
     let hasTypeSpecifier = false;
     if (this.isContextual(90)) {
@@ -13633,16 +13913,10 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
     } else if (tokenIsKeywordOrIdentifier(this.state.type)) {
       hasTypeSpecifier = true;
       leftOfAs = this.parseIdentifier(true);
-      if (!this.isContextual(90)) {
-        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 ??= this.eatContextual(90) ? this.parseIdentifier() : this.cloneIdentifier(node.imported), hasTypeSpecifier ? 4098 : 4096);
+    node.local ??= this.eatContextual(90) ? this.parseIdentifier() : this.cloneIdentifier(node.imported);
   }
   parseTypeOnlyExportSpecifier(node, isInTypeOnly) {
     const local = node.local;
@@ -13896,13 +14170,13 @@ const PlaceholderErrorTemplates = {
 const PlaceholderErrors = ParseErrorEnum`placeholders`(PlaceholderErrorTemplates);
 const placeholders = superClass => class PlaceholdersParserMixin extends superClass {
   parsePlaceholder(expectedNode) {
-    if (this.match(130)) {
+    if (this.match(132)) {
       const node = this.startNode();
       this.next();
       this.assertNoSpace();
       node.name = super.parseIdentifier(true);
       this.assertNoSpace();
-      this.expect(130);
+      this.expect(132);
       return this.finishPlaceholder(node, expectedNode);
     }
   }
@@ -13916,7 +14190,7 @@ const placeholders = superClass => class PlaceholdersParserMixin extends superCl
   }
   getTokenFromCode(code) {
     if (code === 37 && this.input.charCodeAt(this.state.pos + 1) === 37) {
-      this.finishOp(130, 2);
+      this.finishOp(132, 2);
     } else {
       super.getTokenFromCode(code);
     }
@@ -14000,7 +14274,7 @@ const placeholders = superClass => class PlaceholdersParserMixin extends superCl
     const oldStrict = this.state.strict;
     const placeholder = this.parsePlaceholder("Identifier");
     if (placeholder) {
-      if (this.match(77) || this.match(130) || this.match(2)) {
+      if (this.match(77) || this.match(132) || this.match(2)) {
         node.id = placeholder;
       } else if (optionalId || !isStatement) {
         node.id = null;
@@ -14036,7 +14310,7 @@ const placeholders = superClass => class PlaceholdersParserMixin extends superCl
     if (this.match(61)) {
       const next = this.nextTokenStart();
       if (this.isUnparsedContextual(next, "from")) {
-        if (this.input.startsWith(tokenLabelName(130), this.hasPlugin("exportDefaultFrom") ? this.nextTokenStartSince(next + 4) : this.nextTokenInLineStartSince(next + 4))) {
+        if (this.input.startsWith(tokenLabelName(132), this.hasPlugin("exportDefaultFrom") ? this.nextTokenStartSince(next + 4) : this.nextTokenInLineStartSince(next + 4))) {
           return true;
         }
       }
@@ -14064,7 +14338,7 @@ const placeholders = superClass => class PlaceholdersParserMixin extends superCl
     node.specifiers.push(this.finishNode(specifier, "ImportDefaultSpecifier"));
     if (this.eat(8)) {
       const hasStarImport = this.maybeParseStarImportSpecifier(node);
-      if (!hasStarImport) this.parseNamedImportSpecifiers(node);
+      if (!hasStarImport) this.parseNamedOrFilteredImportSpecifiers(node);
     }
     this.expectContextual(95);
     node.source = this.parseImportSource();
@@ -14087,6 +14361,7 @@ const v8intrinsic = superClass => class V8IntrinsicMixin extends superClass {
       const node = this.startNode();
       this.next();
       if (tokenIsIdentifier(this.state.type)) {
+        this.setLoc(this.state.startLoc);
         const name = this.parseIdentifierName();
         const identifier = this.createIdentifier(node, name);
         this.castNodeTo(identifier, "V8IntrinsicIdentifier");
@@ -14166,6 +14441,9 @@ function validatePlugins(pluginsMap) {
   if (pluginsMap.has("importReflection")) {
     throw new Error("The 'importReflection' plugin has been removed in Babel 8. Use 'sourcePhaseImports' instead, and " + "replace 'import module' with 'import source' in your code.");
   }
+  if (pluginsMap.has("deferredReexports") && !pluginsMap.has("deferredImportEvaluation")) {
+    throw new Error("The 'deferredReexports' plugin requires 'deferredImportEvaluation'.");
+  }
 }
 const mixinPlugins = {
   estree,
@@ -14357,7 +14635,12 @@ function literalValue(node, source) {
     case "ObjectExpression":
       return Object.fromEntries(expression.properties.flatMap((property) => {
         const key = keyOf(property);
-        return key && property.type === "ObjectProperty" ? [[key, literalValue(property.value, source)]] : [];
+        return key && property.type === "ObjectProperty" ? [
+          [
+            key,
+            literalValue(property.value, source)
+          ]
+        ] : [];
       }));
     default:
       return `<expr: ${sourceOf(expression, source)}>`;
@@ -14384,7 +14667,11 @@ function findPresetCalls(node, found, name) {
 function readPresets(file, source) {
   let program;
   try {
-    program = parse(source, { sourceType: "module", plugins: ["typescript"], errorRecovery: true }).program;
+    program = parse(source, {
+      sourceType: "module",
+      plugins: ["typescript"],
+      errorRecovery: true
+    }).program;
   } catch {
     return [];
   }
@@ -14397,19 +14684,24 @@ function readPresets(file, source) {
     const options = literalValue(argument, source);
     const base = options.base;
     const overrides = options.overrides;
-    return [{
-      file,
-      exportName: name,
-      base: typeof base === "string" ? base.replace(/^<expr: (.*)>$/, "$1") : void 0,
-      overrides: overrides && typeof overrides === "object" && !Array.isArray(overrides) ? overrides : {}
-    }];
+    return [
+      {
+        file,
+        exportName: name,
+        base: typeof base === "string" ? base.replace(/^<expr: (.*)>$/, "$1") : void 0,
+        overrides: overrides && typeof overrides === "object" && !Array.isArray(overrides) ? overrides : {}
+      }
+    ];
   });
 }
 
 const BLOCK_AT_RULES = /^@(?:utility|keyframes|custom-variant)\s/;
 function blankComments(css, comments) {
   return css.replaceAll(/\/\*([\s\S]*?)\*\//g, (match, text, index) => {
-    comments.push({ end: index + match.length, text: text.replaceAll(/\s*\n\s*\*?\s*/g, " ").trim() });
+    comments.push({
+      end: index + match.length,
+      text: text.replaceAll(/\s*\n\s*\*?\s*/g, " ").trim()
+    });
     return match.replaceAll(/[^\n]/g, " ");
   });
 }
@@ -14462,44 +14754,149 @@ function parseCss(source) {
       flush(index);
       start = index + 1;
     } else if (char === "{") {
-      stack.push({ prelude: css.slice(start, index).trim().replaceAll(/\s+/g, " "), open: index });
+      stack.push({
+        prelude: css.slice(start, index).trim().replaceAll(/\s+/g, " "),
+        open: index
+      });
       start = index + 1;
     } else if (char === "}") {
       flush(index);
       start = index + 1;
       const block = stack.pop();
-      if (block && BLOCK_AT_RULES.test(block.prelude))
-        result.blocks.push({ prelude: block.prelude, body: css.slice(block.open + 1, index).trim().replaceAll(/\s+/g, " ") });
+      if (block && BLOCK_AT_RULES.test(block.prelude)) {
+        result.blocks.push({
+          prelude: block.prelude,
+          body: css.slice(block.open + 1, index).trim().replaceAll(/\s+/g, " ")
+        });
+      }
     }
   }
   return result;
 }
 const NAMESPACES = [
-  { prefix: "--color-", topic: "colors", usage: (name) => `bg-${name} text-${name} border-${name}...` },
-  { prefix: "--font-weight-", topic: "typography", usage: (name) => `font-${name}` },
-  { prefix: "--font-", topic: "typography", usage: (name) => `font-${name}` },
-  { prefix: "--text-shadow-", topic: "shadows", usage: (name) => `text-shadow-${name}` },
-  { prefix: "--text-", topic: "typography", usage: (name) => `text-${name}` },
-  { prefix: "--tracking-", topic: "typography", usage: (name) => `tracking-${name}` },
-  { prefix: "--leading-", topic: "typography", usage: (name) => `leading-${name}` },
-  { prefix: "--animate-", topic: "typography", usage: (name) => `animate-${name}` },
-  { prefix: "--ease-", topic: "typography", usage: (name) => `ease-${name}` },
-  { prefix: "--duration-", topic: "typography", usage: (name) => `duration-(--duration-${name})` },
-  { prefix: "--radius-", topic: "radius", usage: (name) => `rounded-${name}` },
-  { prefix: "--inset-shadow-", topic: "shadows", usage: (name) => `inset-shadow-${name}` },
-  { prefix: "--drop-shadow-", topic: "shadows", usage: (name) => `drop-shadow-${name}` },
-  { prefix: "--shadow-", topic: "shadows", usage: (name) => `shadow-${name}` },
-  { prefix: "--spacing-", topic: "spacing", usage: (name) => `p-${name} gap-${name} w-${name}...` },
-  { prefix: "--breakpoint-", topic: "breakpoints", usage: (name) => `${name}:` },
-  { prefix: "--container-", topic: "layout", usage: (name) => `max-w-${name} @${name}:` },
-  { prefix: "--aspect-", topic: "layout", usage: (name) => `aspect-${name}` },
-  { prefix: "--z-", topic: "z-index", usage: (name) => `z-${name}` }
+  {
+    prefix: "--color-",
+    topic: "colors",
+    usage: (name) => `bg-${name} text-${name} border-${name}...`
+  },
+  {
+    prefix: "--font-weight-",
+    topic: "typography",
+    usage: (name) => `font-${name}`
+  },
+  {
+    prefix: "--font-",
+    topic: "typography",
+    usage: (name) => `font-${name}`
+  },
+  {
+    prefix: "--text-shadow-",
+    topic: "shadows",
+    usage: (name) => `text-shadow-${name}`
+  },
+  {
+    prefix: "--text-",
+    topic: "typography",
+    usage: (name) => `text-${name}`
+  },
+  {
+    prefix: "--tracking-",
+    topic: "typography",
+    usage: (name) => `tracking-${name}`
+  },
+  {
+    prefix: "--leading-",
+    topic: "typography",
+    usage: (name) => `leading-${name}`
+  },
+  {
+    prefix: "--animate-",
+    topic: "typography",
+    usage: (name) => `animate-${name}`
+  },
+  {
+    prefix: "--ease-",
+    topic: "typography",
+    usage: (name) => `ease-${name}`
+  },
+  {
+    prefix: "--duration-",
+    topic: "typography",
+    usage: (name) => `duration-(--duration-${name})`
+  },
+  {
+    prefix: "--radius-",
+    topic: "radius",
+    usage: (name) => `rounded-${name}`
+  },
+  {
+    prefix: "--inset-shadow-",
+    topic: "shadows",
+    usage: (name) => `inset-shadow-${name}`
+  },
+  {
+    prefix: "--drop-shadow-",
+    topic: "shadows",
+    usage: (name) => `drop-shadow-${name}`
+  },
+  {
+    prefix: "--shadow-",
+    topic: "shadows",
+    usage: (name) => `shadow-${name}`
+  },
+  {
+    prefix: "--spacing-",
+    topic: "spacing",
+    usage: (name) => `p-${name} gap-${name} w-${name}...`
+  },
+  {
+    prefix: "--breakpoint-",
+    topic: "breakpoints",
+    usage: (name) => `${name}:`
+  },
+  {
+    prefix: "--container-",
+    topic: "layout",
+    usage: (name) => `max-w-${name} @${name}:`
+  },
+  {
+    prefix: "--aspect-",
+    topic: "layout",
+    usage: (name) => `aspect-${name}`
+  },
+  {
+    prefix: "--z-",
+    topic: "z-index",
+    usage: (name) => `z-${name}`
+  }
 ];
 function tokenOf(variable, value, { inline = false, comment } = {}) {
-  if (variable === "--spacing")
-    return { variable, value, topic: "spacing", usage: "p-4 gap-2 w-8... (base step)", inline, comment };
+  if (variable === "--spacing") {
+    return {
+      variable,
+      value,
+      topic: "spacing",
+      usage: "p-4 gap-2 w-8... (base step)",
+      inline,
+      comment
+    };
+  }
   const namespace = NAMESPACES.find((entry) => variable.startsWith(entry.prefix));
-  return namespace ? { variable, value, topic: namespace.topic, usage: namespace.usage(variable.slice(namespace.prefix.length)), inline, comment } : { variable, value, topic: "css-variables", usage: `var(${variable})`, inline, comment };
+  return namespace ? {
+    variable,
+    value,
+    topic: namespace.topic,
+    usage: namespace.usage(variable.slice(namespace.prefix.length)),
+    inline,
+    comment
+  } : {
+    variable,
+    value,
+    topic: "css-variables",
+    usage: `var(${variable})`,
+    inline,
+    comment
+  };
 }
 function importPath(statement) {
   return /^@import\s+(?:url\()?\s*["']([^"']+)["']/.exec(statement)?.[1];
@@ -14509,7 +14906,16 @@ function themeContext(context) {
 }
 function readStylesheet(file, source) {
   const { declarations, statements, blocks } = parseCss(source);
-  const stylesheet = { file, imports: [], tokens: [], resets: [], variants: [], utilities: [], keyframes: [], mazVariables: [] };
+  const stylesheet = {
+    file,
+    imports: [],
+    tokens: [],
+    resets: [],
+    variants: [],
+    utilities: [],
+    keyframes: [],
+    mazVariables: []
+  };
   for (const statement of statements) {
     const path = importPath(statement);
     const variant = /^@custom-variant ([\w-]+) (.+)$/.exec(statement);
@@ -14530,12 +14936,20 @@ function readStylesheet(file, source) {
   for (const { property, value, context, comment } of declarations) {
     const theme = themeContext(context);
     if (theme && property.startsWith("--")) {
-      if (value === "initial")
+      if (value === "initial") {
         stylesheet.resets.push(property);
-      else if (!/^--[\w-]+--/.test(property))
-        stylesheet.tokens.push(tokenOf(property, value, { inline: /\binline\b/.test(theme), comment }));
+      } else if (!/^--[\w-]+--/.test(property)) {
+        stylesheet.tokens.push(tokenOf(property, value, {
+          inline: /\binline\b/.test(theme),
+          comment
+        }));
+      }
     } else if (!theme && property.startsWith("--maz-")) {
-      stylesheet.mazVariables.push({ variable: property, value, selector: context.filter((prelude) => !prelude.startsWith("@layer")).join(" ") });
+      stylesheet.mazVariables.push({
+        variable: property,
+        value,
+        selector: context.filter((prelude) => !prelude.startsWith("@layer")).join(" ")
+      });
     }
   }
   return stylesheet;
@@ -14556,11 +14970,30 @@ const IGNORED = [
   "**/*.{spec,test}.*"
 ];
 const MAX_FILE_SIZE = 3e5;
-const PATTERNS = ["*.css", "*.ts", "*.mts", "*.cts", "*.js", "*.mjs"];
+const PATTERNS = [
+  "*.css",
+  "*.ts",
+  "*.mts",
+  "*.cts",
+  "*.js",
+  "*.mjs"
+];
 const IGNORED_PATH = /(?:^|\/)(?:node_modules|dist|build|coverage|public|fixtures|__tests__|\.[^/]+)\/|\.min\.css$|\.d\.ts$|\.(?:spec|test)\.\w+$/;
 function projectFiles(rootDir) {
   try {
-    return execFileSync("git", ["ls-files", "--cached", "--others", "--exclude-standard", "--", ...PATTERNS], { cwd: rootDir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 64 * 1024 * 1024 }).split("\n").filter((file) => file && !IGNORED_PATH.test(file));
+    return execFileSync("git", [
+      "ls-files",
+      "--cached",
+      "--others",
+      "--exclude-standard",
+      "--",
+      ...PATTERNS
+    ], {
+      cwd: rootDir,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      maxBuffer: 64 * 1024 * 1024
+    }).split("\n").filter((file) => file && !IGNORED_PATH.test(file));
   } catch {
     return globSync(PATTERNS.map((pattern) => `**/${pattern}`), { cwd: rootDir, ignore: IGNORED, deep: 8 }).filter((file) => !IGNORED_PATH.test(file));
   }
@@ -14642,7 +15075,12 @@ function presetColors(preset) {
   const colors = asRecord(preset.overrides.colors);
   const light = asRecord(colors.light);
   const dark = asRecord(colors.dark);
-  const names = [.../* @__PURE__ */ new Set([...Object.keys(light), ...Object.keys(dark)])];
+  const names = [
+    .../* @__PURE__ */ new Set([
+      ...Object.keys(light),
+      ...Object.keys(dark)
+    ])
+  ];
   if (names.length === 0)
     return [];
   return [
@@ -14666,8 +15104,11 @@ function presetScales(preset, wanted) {
 function flatten(value, path) {
   const record = asRecord(value);
   const keys = Object.keys(record);
-  if (keys.length === 0 || keys.every((key) => key === "light" || key === "dark"))
-    return [[path, value]];
+  if (keys.length === 0 || keys.every((key) => key === "light" || key === "dark")) {
+    return [
+      [path, value]
+    ];
+  }
   return keys.flatMap((key) => flatten(record[key], path ? `${path}.${key}` : key));
 }
 function presetComponents(preset) {
@@ -14731,10 +15172,24 @@ function renderStylesheet(stylesheet, mazUi, wanted, animated) {
   }
   if (stylesheet.resets.length > 0 && wanted("colors"))
     sections.push(`Reset namespaces: ${stylesheet.resets.map((reset) => code(reset)).join(", ")}: the default Tailwind tokens of these namespaces do not exist.`);
-  if (stylesheet.variants.length > 0 && (wanted("variants") || wanted("breakpoints")))
-    sections.push(["#### Custom variants", "", "| Variant | Definition |", "| --- | --- |", ...stylesheet.variants.map((variant) => `| \`${variant.name}:\` | ${code(shorten(variant.definition))} |`)].join("\n"));
-  if (stylesheet.utilities.length > 0 && wanted("utilities"))
-    sections.push(["#### Custom utilities", "", "| Class | CSS |", "| --- | --- |", ...stylesheet.utilities.map((utility) => `| \`${utility.name}\` | ${code(shorten(utility.css))} |`)].join("\n"));
+  if (stylesheet.variants.length > 0 && (wanted("variants") || wanted("breakpoints"))) {
+    sections.push([
+      "#### Custom variants",
+      "",
+      "| Variant | Definition |",
+      "| --- | --- |",
+      ...stylesheet.variants.map((variant) => `| \`${variant.name}:\` | ${code(shorten(variant.definition))} |`)
+    ].join("\n"));
+  }
+  if (stylesheet.utilities.length > 0 && wanted("utilities")) {
+    sections.push([
+      "#### Custom utilities",
+      "",
+      "| Class | CSS |",
+      "| --- | --- |",
+      ...stylesheet.utilities.map((utility) => `| \`${utility.name}\` | ${code(shorten(utility.css))} |`)
+    ].join("\n"));
+  }
   const keyframes = stylesheet.keyframes.filter((name) => !animated.has(name));
   if (keyframes.length > 0 && wanted("typography"))
     sections.push(`Keyframes without \`animate-*\` token: ${keyframes.map((name) => code(name)).join(", ")}. Use them in CSS or add a \`--animate-<name>\` token to the \`@theme\` to get a class.`);
@@ -14754,7 +15209,11 @@ function renderStylesheetSection(stylesheet, mazUi, topics, animated) {
   if (topics?.length && sections.length === 0)
     return void 0;
   const imports = stylesheet.imports.length > 0 ? [`Imports: ${stylesheet.imports.map((path) => code(path)).join(", ")}`] : [];
-  return [`### Tailwind \`${stylesheet.file}\``, ...imports, ...sections].join("\n\n");
+  return [
+    `### Tailwind \`${stylesheet.file}\``,
+    ...imports,
+    ...sections
+  ].join("\n\n");
 }
 function stylesheetProblems(stylesheet) {
   if (!stylesheet.imports.includes("tailwindcss"))