@putout/babel 1.5.5 → 1.6.1

package/bundle/index.js

@@ -1019,7 +1019,7 @@ var require_browser = __commonJS({
     exports.load = load;
     exports.useColors = useColors;
     exports.storage = localstorage();
-    exports.destroy = (() => {
+    exports.destroy = /* @__PURE__ */ (() => {
       let warned = false;
       return () => {
         if (!warned) {
@@ -2584,6 +2584,30 @@ var require_globals = __commonJS({
         XPathEvaluator: false,
         XPathExpression: false,
         XPathResult: false,
+        XRAnchor: false,
+        XRBoundedReferenceSpace: false,
+        XRCPUDepthInformation: false,
+        XRDepthInformation: false,
+        XRFrame: false,
+        XRInputSource: false,
+        XRInputSourceArray: false,
+        XRInputSourceEvent: false,
+        XRInputSourcesChangeEvent: false,
+        XRPose: false,
+        XRReferenceSpace: false,
+        XRReferenceSpaceEvent: false,
+        XRRenderState: false,
+        XRRigidTransform: false,
+        XRSession: false,
+        XRSessionEvent: false,
+        XRSpace: false,
+        XRSystem: false,
+        XRView: false,
+        XRViewerPose: false,
+        XRViewport: false,
+        XRWebGLBinding: false,
+        XRWebGLDepthInformation: false,
+        XRWebGLLayer: false,
         XSLTProcessor: false
       },
       worker: {
@@ -4728,7 +4752,6 @@ __export(lib_exports, {
   toExpression: () => toExpression,
   toIdentifier: () => toIdentifier,
   toKeyAlias: () => toKeyAlias,
-  toSequenceExpression: () => toSequenceExpression,
   toStatement: () => toStatement,
   topicReference: () => topicReference,
   traverse: () => traverse,
@@ -9908,7 +9931,7 @@ var classMethodOrPropertyCommon = () => ({
   },
   key: {
     validate: chain(function() {
-      const normal = assertNodeType("Identifier", "StringLiteral", "NumericLiteral");
+      const normal = assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral");
       const computed = assertNodeType("Expression");
       return function(node, key, val) {
         const validator = node.computed ? computed : normal;
@@ -11178,11 +11201,10 @@ var namedTypeElementCommon = () => ({
 });
 defineType("TSPropertySignature", {
   aliases: ["TSTypeElement"],
-  visitor: ["key", "typeAnnotation", "initializer"],
+  visitor: ["key", "typeAnnotation"],
   fields: Object.assign({}, namedTypeElementCommon(), {
     readonly: validateOptional(bool),
     typeAnnotation: validateOptionalType("TSTypeAnnotation"),
-    initializer: validateOptionalType("Expression"),
     kind: {
       validate: assertOneOf("get", "set")
     }
@@ -12963,12 +12985,11 @@ function tsConstructSignatureDeclaration(typeParameters = null, parameters, type
     typeAnnotation: typeAnnotation2
   });
 }
-function tsPropertySignature(key, typeAnnotation2 = null, initializer = null) {
+function tsPropertySignature(key, typeAnnotation2 = null) {
   return validateNode({
     type: "TSPropertySignature",
     key,
     typeAnnotation: typeAnnotation2,
-    initializer,
     kind: null
   });
 }
@@ -14833,158 +14854,6 @@ toKeyAlias.increment = function() {
     return toKeyAlias.uid++;
   }
 };
-function getBindingIdentifiers(node, duplicates, outerOnly) {
-  const search = [].concat(node);
-  const ids = /* @__PURE__ */ Object.create(null);
-  while (search.length) {
-    const id = search.shift();
-    if (!id)
-      continue;
-    const keys = getBindingIdentifiers.keys[id.type];
-    if (isIdentifier(id)) {
-      if (duplicates) {
-        const _ids = ids[id.name] = ids[id.name] || [];
-        _ids.push(id);
-      } else {
-        ids[id.name] = id;
-      }
-      continue;
-    }
-    if (isExportDeclaration(id) && !isExportAllDeclaration(id)) {
-      if (isDeclaration(id.declaration)) {
-        search.push(id.declaration);
-      }
-      continue;
-    }
-    if (outerOnly) {
-      if (isFunctionDeclaration(id)) {
-        search.push(id.id);
-        continue;
-      }
-      if (isFunctionExpression(id)) {
-        continue;
-      }
-    }
-    if (keys) {
-      for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const nodes2 = id[key];
-        if (nodes2) {
-          Array.isArray(nodes2) ? search.push(...nodes2) : search.push(nodes2);
-        }
-      }
-    }
-  }
-  return ids;
-}
-getBindingIdentifiers.keys = {
-  DeclareClass: ["id"],
-  DeclareFunction: ["id"],
-  DeclareModule: ["id"],
-  DeclareVariable: ["id"],
-  DeclareInterface: ["id"],
-  DeclareTypeAlias: ["id"],
-  DeclareOpaqueType: ["id"],
-  InterfaceDeclaration: ["id"],
-  TypeAlias: ["id"],
-  OpaqueType: ["id"],
-  CatchClause: ["param"],
-  LabeledStatement: ["label"],
-  UnaryExpression: ["argument"],
-  AssignmentExpression: ["left"],
-  ImportSpecifier: ["local"],
-  ImportNamespaceSpecifier: ["local"],
-  ImportDefaultSpecifier: ["local"],
-  ImportDeclaration: ["specifiers"],
-  ExportSpecifier: ["exported"],
-  ExportNamespaceSpecifier: ["exported"],
-  ExportDefaultSpecifier: ["exported"],
-  FunctionDeclaration: ["id", "params"],
-  FunctionExpression: ["id", "params"],
-  ArrowFunctionExpression: ["params"],
-  ObjectMethod: ["params"],
-  ClassMethod: ["params"],
-  ClassPrivateMethod: ["params"],
-  ForInStatement: ["left"],
-  ForOfStatement: ["left"],
-  ClassDeclaration: ["id"],
-  ClassExpression: ["id"],
-  RestElement: ["argument"],
-  UpdateExpression: ["argument"],
-  ObjectProperty: ["value"],
-  AssignmentPattern: ["left"],
-  ArrayPattern: ["elements"],
-  ObjectPattern: ["properties"],
-  VariableDeclaration: ["declarations"],
-  VariableDeclarator: ["id"]
-};
-function gatherSequenceExpressions(nodes2, scope2, declars) {
-  const exprs = [];
-  let ensureLastUndefined = true;
-  for (const node of nodes2) {
-    if (!isEmptyStatement(node)) {
-      ensureLastUndefined = false;
-    }
-    if (isExpression(node)) {
-      exprs.push(node);
-    } else if (isExpressionStatement(node)) {
-      exprs.push(node.expression);
-    } else if (isVariableDeclaration(node)) {
-      if (node.kind !== "var")
-        return;
-      for (const declar of node.declarations) {
-        const bindings = getBindingIdentifiers(declar);
-        for (const key of Object.keys(bindings)) {
-          declars.push({
-            kind: node.kind,
-            id: cloneNode(bindings[key])
-          });
-        }
-        if (declar.init) {
-          exprs.push(assignmentExpression("=", declar.id, declar.init));
-        }
-      }
-      ensureLastUndefined = true;
-    } else if (isIfStatement(node)) {
-      const consequent = node.consequent ? gatherSequenceExpressions([node.consequent], scope2, declars) : scope2.buildUndefinedNode();
-      const alternate = node.alternate ? gatherSequenceExpressions([node.alternate], scope2, declars) : scope2.buildUndefinedNode();
-      if (!consequent || !alternate)
-        return;
-      exprs.push(conditionalExpression(node.test, consequent, alternate));
-    } else if (isBlockStatement(node)) {
-      const body = gatherSequenceExpressions(node.body, scope2, declars);
-      if (!body)
-        return;
-      exprs.push(body);
-    } else if (isEmptyStatement(node)) {
-      if (nodes2.indexOf(node) === 0) {
-        ensureLastUndefined = true;
-      }
-    } else {
-      return;
-    }
-  }
-  if (ensureLastUndefined) {
-    exprs.push(scope2.buildUndefinedNode());
-  }
-  if (exprs.length === 1) {
-    return exprs[0];
-  } else {
-    return sequenceExpression(exprs);
-  }
-}
-function toSequenceExpression(nodes2, scope2) {
-  if (!(nodes2 == null ? void 0 : nodes2.length))
-    return;
-  const declars = [];
-  const result = gatherSequenceExpressions(nodes2, scope2, declars);
-  if (!result)
-    return;
-  for (const declar of declars) {
-    scope2.push(declar);
-  }
-  return result;
-}
 function toStatement(node, ignore) {
   if (isStatement(node)) {
     return node;
@@ -15110,6 +14979,94 @@ function prependToMemberExpression(member, prepend) {
   member.object = memberExpression(prepend, member.object);
   return member;
 }
+function getBindingIdentifiers(node, duplicates, outerOnly, newBindingsOnly) {
+  const search = [].concat(node);
+  const ids = /* @__PURE__ */ Object.create(null);
+  while (search.length) {
+    const id = search.shift();
+    if (!id)
+      continue;
+    if (newBindingsOnly && (isAssignmentExpression(id) || isUnaryExpression(id))) {
+      continue;
+    }
+    const keys = getBindingIdentifiers.keys[id.type];
+    if (isIdentifier(id)) {
+      if (duplicates) {
+        const _ids = ids[id.name] = ids[id.name] || [];
+        _ids.push(id);
+      } else {
+        ids[id.name] = id;
+      }
+      continue;
+    }
+    if (isExportDeclaration(id) && !isExportAllDeclaration(id)) {
+      if (isDeclaration(id.declaration)) {
+        search.push(id.declaration);
+      }
+      continue;
+    }
+    if (outerOnly) {
+      if (isFunctionDeclaration(id)) {
+        search.push(id.id);
+        continue;
+      }
+      if (isFunctionExpression(id)) {
+        continue;
+      }
+    }
+    if (keys) {
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const nodes2 = id[key];
+        if (nodes2) {
+          Array.isArray(nodes2) ? search.push(...nodes2) : search.push(nodes2);
+        }
+      }
+    }
+  }
+  return ids;
+}
+getBindingIdentifiers.keys = {
+  DeclareClass: ["id"],
+  DeclareFunction: ["id"],
+  DeclareModule: ["id"],
+  DeclareVariable: ["id"],
+  DeclareInterface: ["id"],
+  DeclareTypeAlias: ["id"],
+  DeclareOpaqueType: ["id"],
+  InterfaceDeclaration: ["id"],
+  TypeAlias: ["id"],
+  OpaqueType: ["id"],
+  CatchClause: ["param"],
+  LabeledStatement: ["label"],
+  UnaryExpression: ["argument"],
+  AssignmentExpression: ["left"],
+  ImportSpecifier: ["local"],
+  ImportNamespaceSpecifier: ["local"],
+  ImportDefaultSpecifier: ["local"],
+  ImportDeclaration: ["specifiers"],
+  ExportSpecifier: ["exported"],
+  ExportNamespaceSpecifier: ["exported"],
+  ExportDefaultSpecifier: ["exported"],
+  FunctionDeclaration: ["id", "params"],
+  FunctionExpression: ["id", "params"],
+  ArrowFunctionExpression: ["params"],
+  ObjectMethod: ["params"],
+  ClassMethod: ["params"],
+  ClassPrivateMethod: ["params"],
+  ForInStatement: ["left"],
+  ForOfStatement: ["left"],
+  ClassDeclaration: ["id"],
+  ClassExpression: ["id"],
+  RestElement: ["argument"],
+  UpdateExpression: ["argument"],
+  ObjectProperty: ["value"],
+  AssignmentPattern: ["left"],
+  ArrayPattern: ["elements"],
+  ObjectPattern: ["properties"],
+  VariableDeclaration: ["declarations"],
+  VariableDeclarator: ["id"]
+};
 function getOuterBindingIdentifiers(node, duplicates) {
   return getBindingIdentifiers(node, duplicates, true);
 }
@@ -18822,11 +18779,6 @@ function newAsyncArrowScope() {
 function newExpressionScope() {
   return new ExpressionScope();
 }
-var PARAM = 0;
-var PARAM_YIELD = 1;
-var PARAM_AWAIT = 2;
-var PARAM_RETURN = 4;
-var PARAM_IN = 8;
 var ProductionParameterHandler = class {
   stacks = [];
   enter(flags) {
@@ -18839,20 +18791,20 @@ var ProductionParameterHandler = class {
     return this.stacks[this.stacks.length - 1];
   }
   get hasAwait() {
-    return (this.currentFlags() & PARAM_AWAIT) > 0;
+    return (this.currentFlags() & 2) > 0;
   }
   get hasYield() {
-    return (this.currentFlags() & PARAM_YIELD) > 0;
+    return (this.currentFlags() & 1) > 0;
   }
   get hasReturn() {
-    return (this.currentFlags() & PARAM_RETURN) > 0;
+    return (this.currentFlags() & 4) > 0;
   }
   get hasIn() {
-    return (this.currentFlags() & PARAM_IN) > 0;
+    return (this.currentFlags() & 8) > 0;
   }
 };
 function functionFlags(isAsync, isGenerator) {
-  return (isAsync ? PARAM_AWAIT : 0) | (isGenerator ? PARAM_YIELD : 0);
+  return (isAsync ? 2 : 0) | (isGenerator ? 1 : 0);
 }
 var UtilParser = class extends Tokenizer {
   addExtra(node, key, value, enumerable = true) {
@@ -19052,9 +19004,9 @@ var UtilParser = class extends Tokenizer {
     };
   }
   enterInitialScopes() {
-    let paramFlags = PARAM;
+    let paramFlags = 0;
     if (this.inModule) {
-      paramFlags |= PARAM_AWAIT;
+      paramFlags |= 2;
     }
     this.scope.enter(1);
     this.prodParam.enter(paramFlags);
@@ -19553,9 +19505,9 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
     this.flowParseInterfaceish(node, false);
     return this.finishNode(node, "DeclareInterface");
   }
-  flowParseInterfaceish(node, isClass4) {
-    node.id = this.flowParseRestrictedIdentifier(!isClass4, true);
-    this.scope.declareName(node.id.name, isClass4 ? 17 : 8201, node.id.loc.start);
+  flowParseInterfaceish(node, isClass3) {
+    node.id = this.flowParseRestrictedIdentifier(!isClass3, true);
+    this.scope.declareName(node.id.name, isClass3 ? 17 : 8201, node.id.loc.start);
     if (this.match(47)) {
       node.typeParameters = this.flowParseTypeParameterDeclaration();
     } else {
@@ -19565,9 +19517,9 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
     if (this.eat(81)) {
       do {
         node.extends.push(this.flowParseInterfaceExtends());
-      } while (!isClass4 && this.eat(12));
+      } while (!isClass3 && this.eat(12));
     }
-    if (isClass4) {
+    if (isClass3) {
       node.implements = [];
       node.mixins = [];
       if (this.eatContextual(117)) {
@@ -19582,10 +19534,10 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
       }
     }
     node.body = this.flowParseObjectType({
-      allowStatic: isClass4,
+      allowStatic: isClass3,
       allowExact: false,
       allowSpread: false,
-      allowProto: isClass4,
+      allowProto: isClass3,
       allowInexact: false
     });
   }
@@ -24130,7 +24082,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
       node.body = inner;
     } else {
       this.scope.enter(256);
-      this.prodParam.enter(PARAM);
+      this.prodParam.enter(0);
       node.body = this.tsParseModuleBlock();
       this.prodParam.exit();
       this.scope.exit();
@@ -24148,7 +24100,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     if (this.match(5)) {
       this.scope.enter(256);
-      this.prodParam.enter(PARAM);
+      this.prodParam.enter(0);
       node.body = this.tsParseModuleBlock();
       this.prodParam.exit();
       this.scope.exit();
@@ -24276,7 +24228,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
       case "global":
         if (this.match(5)) {
           this.scope.enter(256);
-          this.prodParam.enter(PARAM);
+          this.prodParam.enter(0);
           const mod = node;
           mod.global = true;
           mod.id = expr;
@@ -25896,7 +25848,7 @@ var defaultOptions = {
   strictMode: null,
   ranges: false,
   tokens: false,
-  createImportExpressions: false,
+  createImportExpressions: true,
   createParenthesizedExpressions: false,
   errorRecovery: false,
   attachComment: true,
@@ -26738,7 +26690,7 @@ var ExpressionParser = class extends LValParser {
     const oldLabels = this.state.labels;
     this.state.labels = [];
     if (isAsync) {
-      this.prodParam.enter(PARAM_AWAIT);
+      this.prodParam.enter(2);
       node.body = this.parseBlock();
       this.prodParam.exit();
     } else {
@@ -27307,7 +27259,7 @@ var ExpressionParser = class extends LValParser {
     this.scope.enter(2 | 4);
     let flags = functionFlags(isAsync, false);
     if (!this.match(5) && this.prodParam.hasIn) {
-      flags |= PARAM_IN;
+      flags |= 8;
     }
     this.prodParam.enter(flags);
     this.initFunction(node, isAsync);
@@ -27341,7 +27293,7 @@ var ExpressionParser = class extends LValParser {
       const oldStrict = this.state.strict;
       const oldLabels = this.state.labels;
       this.state.labels = [];
-      this.prodParam.enter(this.prodParam.currentFlags() | PARAM_RETURN);
+      this.prodParam.enter(this.prodParam.currentFlags() | 4);
       node.body = this.parseBlock(true, false, (hasStrictModeDirective) => {
         const nonSimple = !this.isSimpleParamList(node.params);
         if (hasStrictModeDirective && nonSimple) {
@@ -27686,9 +27638,9 @@ var ExpressionParser = class extends LValParser {
   }
   allowInAnd(callback) {
     const flags = this.prodParam.currentFlags();
-    const prodParamToSet = PARAM_IN & ~flags;
+    const prodParamToSet = 8 & ~flags;
     if (prodParamToSet) {
-      this.prodParam.enter(flags | PARAM_IN);
+      this.prodParam.enter(flags | 8);
       try {
         return callback();
       } finally {
@@ -27699,9 +27651,9 @@ var ExpressionParser = class extends LValParser {
   }
   disallowInAnd(callback) {
     const flags = this.prodParam.currentFlags();
-    const prodParamToClear = PARAM_IN & flags;
+    const prodParamToClear = 8 & flags;
     if (prodParamToClear) {
-      this.prodParam.enter(flags & ~PARAM_IN);
+      this.prodParam.enter(flags & ~8);
       try {
         return callback();
       } finally {
@@ -28904,7 +28856,7 @@ var StatementParser = class extends ExpressionParser {
     this.scope.enter(64 | 128 | 16);
     const oldLabels = this.state.labels;
     this.state.labels = [];
-    this.prodParam.enter(PARAM);
+    this.prodParam.enter(0);
     const body = member.body = [];
     this.parseBlockOrModuleBlockBody(body, void 0, false, 8);
     this.prodParam.exit();
@@ -28977,7 +28929,7 @@ var StatementParser = class extends ExpressionParser {
   parseInitializer(node) {
     this.scope.enter(64 | 16);
     this.expressionScope.enter(newExpressionScope());
-    this.prodParam.enter(PARAM);
+    this.prodParam.enter(0);
     node.value = this.eat(29) ? this.parseMaybeAssignAllowIn() : null;
     this.expressionScope.exit();
     this.prodParam.exit();
@@ -32527,8 +32479,12 @@ var SourceMap = class {
   }
 };
 var Buffer2 = class {
-  constructor(map) {
+  constructor(map, indentChar) {
     this._map = map;
+    this._indentChar = indentChar;
+    for (let i = 0; i < 64; i++) {
+      this._fastIndentations.push(indentChar.repeat(i));
+    }
     this._allocQueue();
   }
   _map = null;
@@ -32539,6 +32495,8 @@ var Buffer2 = class {
   _queue = [];
   _queueCursor = 0;
   _canMarkIdName = true;
+  _indentChar = "";
+  _fastIndentations = [];
   _position = {
     line: 1,
     column: 0
@@ -32638,8 +32596,10 @@ var Buffer2 = class {
     const sourcePosition = this._sourcePosition;
     this._pushQueue(char, 1, sourcePosition.line, sourcePosition.column, sourcePosition.filename);
   }
-  queueIndentation(char, repeat) {
-    this._pushQueue(char, repeat, void 0, void 0, void 0);
+  queueIndentation(repeat) {
+    if (repeat === 0)
+      return;
+    this._pushQueue(-1, repeat, void 0, void 0, void 0);
   }
   _flush() {
     const queueCursor = this._queueCursor;
@@ -32652,7 +32612,16 @@ var Buffer2 = class {
   }
   _appendChar(char, repeat, sourcePos) {
     this._last = char;
-    this._str += repeat > 1 ? String.fromCharCode(char).repeat(repeat) : String.fromCharCode(char);
+    if (char === -1) {
+      const fastIndentation = this._fastIndentations[repeat];
+      if (fastIndentation !== void 0) {
+        this._str += fastIndentation;
+      } else {
+        this._str += repeat > 1 ? this._indentChar.repeat(repeat) : this._indentChar;
+      }
+    } else {
+      this._str += repeat > 1 ? String.fromCharCode(char).repeat(repeat) : String.fromCharCode(char);
+    }
     if (char !== 10) {
       this._mark(sourcePos.line, sourcePos.column, sourcePos.identifierName, sourcePos.identifierNamePos, sourcePos.filename);
       this._position.column += repeat;
@@ -32831,8 +32800,8 @@ var Buffer2 = class {
 var {
   FLIPPED_ALIAS_KEYS: FLIPPED_ALIAS_KEYS$1,
   isArrayExpression: isArrayExpression2,
-  isAssignmentExpression: isAssignmentExpression$1,
-  isBinary: isBinary$1,
+  isAssignmentExpression: isAssignmentExpression2,
+  isBinary: isBinary2,
   isBlockStatement: isBlockStatement2,
   isCallExpression: isCallExpression$3,
   isFunction: isFunction$1,
@@ -32840,7 +32809,7 @@ var {
   isLiteral: isLiteral$1,
   isMemberExpression: isMemberExpression$3,
   isObjectExpression: isObjectExpression2,
-  isOptionalCallExpression: isOptionalCallExpression$1,
+  isOptionalCallExpression: isOptionalCallExpression2,
   isOptionalMemberExpression: isOptionalMemberExpression$1,
   isStringLiteral: isStringLiteral3
 } = lib_exports;
@@ -32851,10 +32820,10 @@ function crawlInternal(node, state) {
     crawlInternal(node.object, state);
     if (node.computed)
       crawlInternal(node.property, state);
-  } else if (isBinary$1(node) || isAssignmentExpression$1(node)) {
+  } else if (isBinary2(node) || isAssignmentExpression2(node)) {
     crawlInternal(node.left, state);
     crawlInternal(node.right, state);
-  } else if (isCallExpression$3(node) || isOptionalCallExpression$1(node)) {
+  } else if (isCallExpression$3(node) || isOptionalCallExpression2(node)) {
     state.hasCall = true;
     crawlInternal(node.callee, state);
   } else if (isFunction$1(node)) {
@@ -32880,7 +32849,7 @@ function isHelper(node) {
     return node.name === "require" || node.name.charCodeAt(0) === 95;
   } else if (isCallExpression$3(node)) {
     return isHelper(node.callee);
-  } else if (isBinary$1(node) || isAssignmentExpression$1(node)) {
+  } else if (isBinary2(node) || isAssignmentExpression2(node)) {
     return isIdentifier$2(node.left) && isHelper(node.left) || isHelper(node.right);
   } else {
     return false;
@@ -32970,98 +32939,36 @@ nodes.ObjectTypeInternalSlot = function(node, parent) {
 var {
   isArrayTypeAnnotation: isArrayTypeAnnotation2,
   isArrowFunctionExpression: isArrowFunctionExpression2,
-  isAssignmentExpression: isAssignmentExpression2,
-  isAwaitExpression: isAwaitExpression2,
-  isBinary: isBinary2,
   isBinaryExpression: isBinaryExpression2,
-  isUpdateExpression: isUpdateExpression2,
   isCallExpression: isCallExpression$2,
-  isClass: isClass2,
-  isClassExpression: isClassExpression2,
-  isConditional: isConditional2,
-  isConditionalExpression: isConditionalExpression2,
   isExportDeclaration: isExportDeclaration2,
-  isExportDefaultDeclaration: isExportDefaultDeclaration$1,
-  isExpressionStatement: isExpressionStatement$1,
-  isFor: isFor$1,
-  isForInStatement: isForInStatement2,
   isForOfStatement: isForOfStatement2,
-  isForStatement: isForStatement$1,
-  isFunctionExpression: isFunctionExpression2,
-  isIfStatement: isIfStatement$1,
   isIndexedAccessType: isIndexedAccessType2,
-  isIntersectionTypeAnnotation: isIntersectionTypeAnnotation2,
-  isLogicalExpression: isLogicalExpression2,
   isMemberExpression: isMemberExpression$2,
-  isNewExpression: isNewExpression$2,
-  isNullableTypeAnnotation: isNullableTypeAnnotation2,
   isObjectPattern: isObjectPattern2,
-  isOptionalCallExpression: isOptionalCallExpression2,
   isOptionalMemberExpression: isOptionalMemberExpression2,
-  isReturnStatement: isReturnStatement2,
-  isSequenceExpression: isSequenceExpression2,
-  isSwitchStatement: isSwitchStatement2,
-  isTSArrayType: isTSArrayType2,
-  isTSAsExpression: isTSAsExpression2,
-  isTSInstantiationExpression: isTSInstantiationExpression2,
-  isTSIntersectionType: isTSIntersectionType2,
-  isTSNonNullExpression: isTSNonNullExpression2,
-  isTSOptionalType: isTSOptionalType2,
-  isTSRestType: isTSRestType2,
-  isTSTypeAssertion: isTSTypeAssertion2,
-  isTSUnionType: isTSUnionType2,
-  isTaggedTemplateExpression: isTaggedTemplateExpression2,
-  isThrowStatement: isThrowStatement2,
-  isTypeAnnotation: isTypeAnnotation2,
-  isUnaryLike: isUnaryLike2,
-  isUnionTypeAnnotation: isUnionTypeAnnotation2,
-  isVariableDeclarator: isVariableDeclarator2,
-  isWhileStatement: isWhileStatement2,
-  isYieldExpression: isYieldExpression2,
-  isTSSatisfiesExpression: isTSSatisfiesExpression2
+  isYieldExpression: isYieldExpression2
 } = lib_exports;
-var PRECEDENCE = {
-  "||": 0,
-  "??": 0,
-  "|>": 0,
-  "&&": 1,
-  "|": 2,
-  "^": 3,
-  "&": 4,
-  "==": 5,
-  "===": 5,
-  "!=": 5,
-  "!==": 5,
-  "<": 6,
-  ">": 6,
-  "<=": 6,
-  ">=": 6,
-  in: 6,
-  instanceof: 6,
-  ">>": 7,
-  "<<": 7,
-  ">>>": 7,
-  "+": 8,
-  "-": 8,
-  "*": 9,
-  "/": 9,
-  "%": 9,
-  "**": 10
-};
-function isTSTypeExpression(node) {
-  return isTSAsExpression2(node) || isTSSatisfiesExpression2(node) || isTSTypeAssertion2(node);
+var PRECEDENCE = /* @__PURE__ */ new Map([["||", 0], ["??", 0], ["|>", 0], ["&&", 1], ["|", 2], ["^", 3], ["&", 4], ["==", 5], ["===", 5], ["!=", 5], ["!==", 5], ["<", 6], [">", 6], ["<=", 6], [">=", 6], ["in", 6], ["instanceof", 6], [">>", 7], ["<<", 7], [">>>", 7], ["+", 8], ["-", 8], ["*", 9], ["/", 9], ["%", 9], ["**", 10]]);
+function isTSTypeExpression(nodeType) {
+  return nodeType === "TSAsExpression" || nodeType === "TSSatisfiesExpression" || nodeType === "TSTypeAssertion";
 }
-var isClassExtendsClause = (node, parent) => isClass2(parent, {
-  superClass: node
-});
-var hasPostfixPart = (node, parent) => (isMemberExpression$2(parent) || isOptionalMemberExpression2(parent)) && parent.object === node || (isCallExpression$2(parent) || isOptionalCallExpression2(parent) || isNewExpression$2(parent)) && parent.callee === node || isTaggedTemplateExpression2(parent) && parent.tag === node || isTSNonNullExpression2(parent);
+var isClassExtendsClause = (node, parent) => {
+  const parentType = parent.type;
+  return (parentType === "ClassDeclaration" || parentType === "ClassExpression") && parent.superClass === node;
+};
+var hasPostfixPart = (node, parent) => {
+  const parentType = parent.type;
+  return (parentType === "MemberExpression" || parentType === "OptionalMemberExpression") && parent.object === node || (parentType === "CallExpression" || parentType === "OptionalCallExpression" || parentType === "NewExpression") && parent.callee === node || parentType === "TaggedTemplateExpression" && parent.tag === node || parentType === "TSNonNullExpression";
+};
 function NullableTypeAnnotation$1(node, parent) {
   return isArrayTypeAnnotation2(parent);
 }
 function FunctionTypeAnnotation$1(node, parent, printStack) {
   if (printStack.length < 3)
     return;
-  return isUnionTypeAnnotation2(parent) || isIntersectionTypeAnnotation2(parent) || isArrayTypeAnnotation2(parent) || isTypeAnnotation2(parent) && isArrowFunctionExpression2(printStack[printStack.length - 3]);
+  const parentType = parent.type;
+  return parentType === "UnionTypeAnnotation" || parentType === "IntersectionTypeAnnotation" || parentType === "ArrayTypeAnnotation" || parentType === "TypeAnnotation" && isArrowFunctionExpression2(printStack[printStack.length - 3]);
 }
 function UpdateExpression$1(node, parent) {
   return hasPostfixPart(node, parent) || isClassExtendsClause(node, parent);
@@ -33073,67 +32980,70 @@ function DoExpression$1(node, parent, printStack) {
   return !node.async && isFirstInContext(printStack, 1);
 }
 function Binary(node, parent) {
-  if (node.operator === "**" && isBinaryExpression2(parent, {
-    operator: "**"
-  })) {
+  const parentType = parent.type;
+  if (node.operator === "**" && parentType === "BinaryExpression" && parent.operator === "**") {
     return parent.left === node;
   }
   if (isClassExtendsClause(node, parent)) {
     return true;
   }
-  if (hasPostfixPart(node, parent) || isUnaryLike2(parent) || isAwaitExpression2(parent)) {
+  if (hasPostfixPart(node, parent) || parentType === "UnaryExpression" || parentType === "SpreadElement" || parentType === "AwaitExpression") {
     return true;
   }
-  if (isBinary2(parent)) {
-    const parentOp = parent.operator;
-    const parentPos = PRECEDENCE[parentOp];
-    const nodeOp = node.operator;
-    const nodePos = PRECEDENCE[nodeOp];
-    if (parentPos === nodePos && parent.right === node && !isLogicalExpression2(parent) || parentPos > nodePos) {
+  if (parentType === "BinaryExpression" || parentType === "LogicalExpression") {
+    const parentPos = PRECEDENCE.get(parent.operator);
+    const nodePos = PRECEDENCE.get(node.operator);
+    if (parentPos === nodePos && parent.right === node && parentType !== "LogicalExpression" || parentPos > nodePos) {
       return true;
     }
   }
+  return void 0;
 }
 function UnionTypeAnnotation$1(node, parent) {
-  return isArrayTypeAnnotation2(parent) || isNullableTypeAnnotation2(parent) || isIntersectionTypeAnnotation2(parent) || isUnionTypeAnnotation2(parent);
+  const parentType = parent.type;
+  return parentType === "ArrayTypeAnnotation" || parentType === "NullableTypeAnnotation" || parentType === "IntersectionTypeAnnotation" || parentType === "UnionTypeAnnotation";
 }
 function OptionalIndexedAccessType$1(node, parent) {
-  return isIndexedAccessType2(parent, {
-    objectType: node
-  });
+  return isIndexedAccessType2(parent) && parent.objectType === node;
 }
 function TSAsExpression() {
   return true;
 }
 function TSUnionType$1(node, parent) {
-  return isTSArrayType2(parent) || isTSOptionalType2(parent) || isTSIntersectionType2(parent) || isTSUnionType2(parent) || isTSRestType2(parent);
+  const parentType = parent.type;
+  return parentType === "TSArrayType" || parentType === "TSOptionalType" || parentType === "TSIntersectionType" || parentType === "TSUnionType" || parentType === "TSRestType";
 }
 function TSInferType$1(node, parent) {
-  return isTSArrayType2(parent) || isTSOptionalType2(parent);
+  const parentType = parent.type;
+  return parentType === "TSArrayType" || parentType === "TSOptionalType";
 }
 function TSInstantiationExpression$1(node, parent) {
-  return (isCallExpression$2(parent) || isOptionalCallExpression2(parent) || isNewExpression$2(parent) || isTSInstantiationExpression2(parent)) && !!parent.typeParameters;
+  const parentType = parent.type;
+  return (parentType === "CallExpression" || parentType === "OptionalCallExpression" || parentType === "NewExpression" || parentType === "TSInstantiationExpression") && !!parent.typeParameters;
 }
 function BinaryExpression(node, parent) {
-  return node.operator === "in" && (isVariableDeclarator2(parent) || isFor$1(parent));
+  if (node.operator === "in") {
+    const parentType = parent.type;
+    return parentType === "VariableDeclarator" || parentType === "ForStatement" || parentType === "ForInStatement" || parentType === "ForOfStatement";
+  }
+  return false;
 }
 function SequenceExpression$1(node, parent) {
-  if (isForStatement$1(parent) || isThrowStatement2(parent) || isReturnStatement2(parent) || isIfStatement$1(parent) && parent.test === node || isWhileStatement2(parent) && parent.test === node || isForInStatement2(parent) && parent.right === node || isSwitchStatement2(parent) && parent.discriminant === node || isExpressionStatement$1(parent) && parent.expression === node) {
+  const parentType = parent.type;
+  if (parentType === "ForStatement" || parentType === "ThrowStatement" || parentType === "ReturnStatement" || parentType === "IfStatement" && parent.test === node || parentType === "WhileStatement" && parent.test === node || parentType === "ForInStatement" && parent.right === node || parentType === "SwitchStatement" && parent.discriminant === node || parentType === "ExpressionStatement" && parent.expression === node) {
     return false;
   }
   return true;
 }
 function YieldExpression$1(node, parent) {
-  return isBinary2(parent) || isUnaryLike2(parent) || hasPostfixPart(node, parent) || isAwaitExpression2(parent) && isYieldExpression2(node) || isConditionalExpression2(parent) && node === parent.test || isClassExtendsClause(node, parent);
+  const parentType = parent.type;
+  return parentType === "BinaryExpression" || parentType === "LogicalExpression" || parentType === "UnaryExpression" || parentType === "SpreadElement" || hasPostfixPart(node, parent) || parentType === "AwaitExpression" && isYieldExpression2(node) || parentType === "ConditionalExpression" && node === parent.test || isClassExtendsClause(node, parent);
 }
 function ClassExpression(node, parent, printStack) {
   return isFirstInContext(printStack, 1 | 4);
 }
 function UnaryLike(node, parent) {
-  return hasPostfixPart(node, parent) || isBinaryExpression2(parent, {
-    operator: "**",
-    left: node
-  }) || isClassExtendsClause(node, parent);
+  return hasPostfixPart(node, parent) || isBinaryExpression2(parent) && parent.operator === "**" && parent.left === node || isClassExtendsClause(node, parent);
 }
 function FunctionExpression$1(node, parent, printStack) {
   return isFirstInContext(printStack, 1 | 4);
@@ -33142,19 +33052,14 @@ function ArrowFunctionExpression$1(node, parent) {
   return isExportDeclaration2(parent) || ConditionalExpression$1(node, parent);
 }
 function ConditionalExpression$1(node, parent) {
-  if (isUnaryLike2(parent) || isBinary2(parent) || isConditionalExpression2(parent, {
-    test: node
-  }) || isAwaitExpression2(parent) || isTSTypeExpression(parent)) {
+  const parentType = parent.type;
+  if (parentType === "UnaryExpression" || parentType === "SpreadElement" || parentType === "BinaryExpression" || parentType === "LogicalExpression" || parentType === "ConditionalExpression" && parent.test === node || parentType === "AwaitExpression" || isTSTypeExpression(parentType)) {
     return true;
   }
   return UnaryLike(node, parent);
 }
 function OptionalMemberExpression$1(node, parent) {
-  return isCallExpression$2(parent, {
-    callee: node
-  }) || isMemberExpression$2(parent, {
-    object: node
-  });
+  return isCallExpression$2(parent) && parent.callee === node || isMemberExpression$2(parent) && parent.object === node;
 }
 function AssignmentExpression$1(node, parent) {
   if (isObjectPattern2(node.left)) {
@@ -33164,27 +33069,28 @@ function AssignmentExpression$1(node, parent) {
   }
 }
 function LogicalExpression(node, parent) {
-  if (isTSTypeExpression(parent))
+  const parentType = parent.type;
+  if (isTSTypeExpression(parentType))
     return true;
+  if (parentType !== "LogicalExpression")
+    return false;
   switch (node.operator) {
     case "||":
-      if (!isLogicalExpression2(parent))
-        return false;
       return parent.operator === "??" || parent.operator === "&&";
     case "&&":
-      return isLogicalExpression2(parent, {
-        operator: "??"
-      });
+      return parent.operator === "??";
     case "??":
-      return isLogicalExpression2(parent) && parent.operator !== "??";
+      return parent.operator !== "??";
   }
 }
 function Identifier$1(node, parent, printStack) {
   var _a;
-  if (((_a = node.extra) == null ? void 0 : _a.parenthesized) && isAssignmentExpression2(parent, {
-    left: node
-  }) && (isFunctionExpression2(parent.right) || isClassExpression2(parent.right)) && parent.right.id == null) {
-    return true;
+  const parentType = parent.type;
+  if (((_a = node.extra) == null ? void 0 : _a.parenthesized) && parentType === "AssignmentExpression" && parent.left === node) {
+    const rightType = parent.right.type;
+    if ((rightType === "FunctionExpression" || rightType === "ClassExpression") && parent.right.id == null) {
+      return true;
+    }
   }
   if (node.name === "let") {
     const isFollowedByBracket = isMemberExpression$2(parent, {
@@ -33213,28 +33119,11 @@ function isFirstInContext(printStack, checkParam) {
   i--;
   let parent = printStack[i];
   while (i >= 0) {
-    if (expressionStatement5 && isExpressionStatement$1(parent, {
-      expression: node
-    }) || exportDefault && isExportDefaultDeclaration$1(parent, {
-      declaration: node
-    }) || arrowBody && isArrowFunctionExpression2(parent, {
-      body: node
-    }) || forHead && isForStatement$1(parent, {
-      init: node
-    }) || forInHead && isForInStatement2(parent, {
-      left: node
-    }) || forOfHead && isForOfStatement2(parent, {
-      left: node
-    })) {
+    const parentType = parent.type;
+    if (expressionStatement5 && parentType === "ExpressionStatement" && parent.expression === node || exportDefault && parentType === "ExportDefaultDeclaration" && node === parent.declaration || arrowBody && parentType === "ArrowFunctionExpression" && parent.body === node || forHead && parentType === "ForStatement" && parent.init === node || forInHead && parentType === "ForInStatement" && parent.left === node || forOfHead && parentType === "ForOfStatement" && parent.left === node) {
       return true;
     }
-    if (i > 0 && (hasPostfixPart(node, parent) && !isNewExpression$2(parent) || isSequenceExpression2(parent) && parent.expressions[0] === node || isUpdateExpression2(parent) && !parent.prefix || isConditional2(parent, {
-      test: node
-    }) || isBinary2(parent, {
-      left: node
-    }) || isAssignmentExpression2(parent, {
-      left: node
-    }))) {
+    if (i > 0 && (hasPostfixPart(node, parent) && parentType !== "NewExpression" || parentType === "SequenceExpression" && parent.expressions[0] === node || parentType === "UpdateExpression" && !parent.prefix || parentType === "ConditionalExpression" && parent.test === node || (parentType === "BinaryExpression" || parentType === "LogicalExpression") && parent.left === node || parentType === "AssignmentExpression" && parent.left === node)) {
       node = parent;
       i--;
       parent = printStack[i];
@@ -33285,13 +33174,12 @@ var {
   isNewExpression: isNewExpression$1
 } = lib_exports;
 function expandAliases(obj) {
-  const newObj = {};
+  const map = /* @__PURE__ */ new Map();
   function add(type, func) {
-    const fn = newObj[type];
-    newObj[type] = fn ? function(node, parent, stack) {
-      const result = fn(node, parent, stack);
-      return result == null ? func(node, parent, stack) : result;
-    } : func;
+    const fn = map.get(type);
+    map.set(type, fn ? function(node, parent, stack) {
+      return fn(node, parent, stack) ?? func(node, parent, stack);
+    } : func);
   }
   for (const type of Object.keys(obj)) {
     const aliases = FLIPPED_ALIAS_KEYS2[type];
@@ -33303,14 +33191,10 @@ function expandAliases(obj) {
       add(type, obj[type]);
     }
   }
-  return newObj;
+  return map;
 }
 var expandedParens = expandAliases(parens);
 var expandedWhitespaceNodes = expandAliases(nodes);
-function find(obj, node, parent, printStack) {
-  const fn = obj[node.type];
-  return fn ? fn(node, parent, printStack) : null;
-}
 function isOrHasCallExpression(node) {
   if (isCallExpression$1(node)) {
     return true;
@@ -33318,12 +33202,13 @@ function isOrHasCallExpression(node) {
   return isMemberExpression$1(node) && isOrHasCallExpression(node.object);
 }
 function needsWhitespace(node, parent, type) {
+  var _a;
   if (!node)
     return false;
   if (isExpressionStatement3(node)) {
     node = node.expression;
   }
-  const flag = find(expandedWhitespaceNodes, node, parent);
+  const flag = (_a = expandedWhitespaceNodes.get(node.type)) == null ? void 0 : _a(node, parent);
   if (typeof flag === "number") {
     return (flag & type) !== 0;
   }
@@ -33336,13 +33221,14 @@ function needsWhitespaceAfter(node, parent) {
   return needsWhitespace(node, parent, 2);
 }
 function needsParens$1(node, parent, printStack) {
+  var _a;
   if (!parent)
     return false;
   if (isNewExpression$1(parent) && parent.callee === node) {
     if (isOrHasCallExpression(node))
       return true;
   }
-  return find(expandedParens, node, parent, printStack);
+  return (_a = expandedParens.get(node.type)) == null ? void 0 : _a(node, parent, printStack);
 }
 var n = /* @__PURE__ */ Object.freeze({
   __proto__: null,
@@ -34610,15 +34496,16 @@ function NullLiteral() {
 function NumericLiteral(node) {
   const raw = this.getPossibleRaw(node);
   const opts = this.format.jsescOption;
-  const value = node.value + "";
+  const value = node.value;
+  const str = value + "";
   if (opts.numbers) {
-    this.number((0, import_jsesc.default)(node.value, opts));
+    this.number((0, import_jsesc.default)(value, opts), value);
   } else if (raw == null) {
-    this.number(value);
+    this.number(str, value);
   } else if (this.format.minified) {
-    this.number(raw.length < value.length ? raw : value);
+    this.number(raw.length < str.length ? raw : str, value);
   } else {
-    this.number(raw);
+    this.number(raw, value);
   }
 }
 function StringLiteral(node) {
@@ -35513,8 +35400,7 @@ function TSConstructSignatureDeclaration(node) {
 }
 function TSPropertySignature(node) {
   const {
-    readonly,
-    initializer
+    readonly
   } = node;
   if (readonly) {
     this.word("readonly");
@@ -35522,12 +35408,6 @@ function TSPropertySignature(node) {
   }
   this.tsPrintPropertyOrMethodName(node);
   this.print(node.typeAnnotation, node);
-  if (initializer) {
-    this.space();
-    this.tokenChar(61);
-    this.space();
-    this.print(initializer, node);
-  }
   this.tokenChar(59);
 }
 function tsPrintPropertyOrMethodName(node) {
@@ -36333,25 +36213,21 @@ var {
 } = lib_exports;
 var SCIENTIFIC_NOTATION = /e/i;
 var ZERO_DECIMAL_INTEGER = /\.0+$/;
-var NON_DECIMAL_LITERAL = /^0[box]/;
-var PURE_ANNOTATION_RE = /^\s*[@#]__PURE__\s*$/;
 var HAS_NEWLINE = /[\n\r\u2028\u2029]/;
-var HAS_BlOCK_COMMENT_END = /\*\//;
+var HAS_NEWLINE_OR_BlOCK_COMMENT_END = /[\n\r\u2028\u2029]|\*\//;
 var {
   needsParens
 } = n;
 var Printer = class {
   constructor(format, map) {
     this.format = format;
-    this._buf = new Buffer2(map);
-    this._indentChar = format.indent.style.charCodeAt(0);
     this._indentRepeat = format.indent.style.length;
     this._inputMap = map == null ? void 0 : map._inputMap;
+    this._buf = new Buffer2(map, format.indent.style[0]);
   }
   inForStatementInitCounter = 0;
   _printStack = [];
   _indent = 0;
-  _indentChar = 0;
   _indentRepeat = 0;
   _insideAux = false;
   _parenPushNewlineState = null;
@@ -36420,9 +36296,16 @@ var Printer = class {
     this._endsWithWord = true;
     this._noLineTerminator = noLineTerminatorAfter;
   }
-  number(str) {
+  number(str, number) {
+    function isNonDecimalLiteral(str2) {
+      if (str2.length > 2 && str2.charCodeAt(0) === 48) {
+        const secondChar = str2.charCodeAt(1);
+        return secondChar === 98 || secondChar === 111 || secondChar === 120;
+      }
+      return false;
+    }
     this.word(str);
-    this._endsWithInteger = Number.isInteger(+str) && !NON_DECIMAL_LITERAL.test(str) && !SCIENTIFIC_NOTATION.test(str) && !ZERO_DECIMAL_INTEGER.test(str) && str.charCodeAt(str.length - 1) !== 46;
+    this._endsWithInteger = Number.isInteger(number) && !isNonDecimalLiteral(str) && !SCIENTIFIC_NOTATION.test(str) && !ZERO_DECIMAL_INTEGER.test(str) && str.charCodeAt(str.length - 1) !== 46;
   }
   token(str, maybeNewline = false) {
     this._maybePrintInnerComments();
@@ -36540,7 +36423,7 @@ var Printer = class {
   }
   _maybeIndent(firstChar) {
     if (this._indent && firstChar !== 10 && this.endsWith(10)) {
-      this._buf.queueIndentation(this._indentChar, this._getIndent());
+      this._buf.queueIndentation(this._getIndent());
     }
   }
   _shouldIndent(firstChar) {
@@ -36582,9 +36465,7 @@ var Printer = class {
       }
       const chaPost = str.charCodeAt(i + 1);
       if (chaPost === 42) {
-        if (PURE_ANNOTATION_RE.test(str.slice(i + 2, len - 2))) {
-          return;
-        }
+        return;
       } else if (chaPost !== 47) {
         this._parenPushNewlineState = null;
         return;
@@ -36635,7 +36516,7 @@ var Printer = class {
     }
   }
   print(node, parent, noLineTerminatorAfter, trailingCommentsLineOffset, forceParens) {
-    var _a;
+    var _a, _b;
     if (!node)
       return;
     this._endsWithInnerRaw = false;
@@ -36653,7 +36534,25 @@ var Printer = class {
     const oldInAux = this._insideAux;
     this._insideAux = node.loc == void 0;
     this._maybeAddAuxComment(this._insideAux && !oldInAux);
-    const shouldPrintParens = forceParens || format.retainFunctionParens && nodeType === "FunctionExpression" && ((_a = node.extra) == null ? void 0 : _a.parenthesized) || needsParens(node, parent, this._printStack);
+    const parenthesized = (_a = node.extra) == null ? void 0 : _a.parenthesized;
+    let shouldPrintParens = forceParens || parenthesized && format.retainFunctionParens && nodeType === "FunctionExpression" || needsParens(node, parent, this._printStack);
+    if (!shouldPrintParens && parenthesized && ((_b = node.leadingComments) == null ? void 0 : _b.length) && node.leadingComments[0].type === "CommentBlock") {
+      const parentType = parent == null ? void 0 : parent.type;
+      switch (parentType) {
+        case "ExpressionStatement":
+        case "VariableDeclarator":
+        case "AssignmentExpression":
+        case "ReturnStatement":
+          break;
+        case "CallExpression":
+        case "OptionalCallExpression":
+        case "NewExpression":
+          if (parent.callee !== node)
+            break;
+        default:
+          shouldPrintParens = true;
+      }
+    }
     if (shouldPrintParens) {
       this.tokenChar(40);
       this._endsWithInnerRaw = false;
@@ -36714,7 +36613,7 @@ var Printer = class {
     }
   }
   printJoin(nodes2, parent, opts = {}) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     if (!(nodes2 == null ? void 0 : nodes2.length))
       return;
     let {
@@ -36745,11 +36644,14 @@ var Printer = class {
       if (i < len - 1)
         separator == null ? void 0 : separator();
       if (opts.statement) {
+        if (!((_c = node.trailingComments) == null ? void 0 : _c.length)) {
+          this._lastCommentLine = 0;
+        }
         if (i + 1 === len) {
           this.newline(1);
         } else {
           const nextNode = nodes2[i + 1];
-          newlineOpts.nextNodeStartLine = ((_c = nextNode.loc) == null ? void 0 : _c.start.line) || 0;
+          newlineOpts.nextNodeStartLine = ((_d = nextNode.loc) == null ? void 0 : _d.start.line) || 0;
           this._printNewline(true, newlineOpts);
         }
       }
@@ -36856,7 +36758,7 @@ var Printer = class {
       return 0;
     if (this._printedComments.has(comment))
       return 0;
-    if (this._noLineTerminator && (HAS_NEWLINE.test(comment.value) || HAS_BlOCK_COMMENT_END.test(comment.value))) {
+    if (this._noLineTerminator && HAS_NEWLINE_OR_BlOCK_COMMENT_END.test(comment.value)) {
       return 2;
     }
     this._printedComments.add(comment);
@@ -36879,6 +36781,14 @@ var Printer = class {
     }
     let val;
     if (isBlockComment) {
+      const {
+        _parenPushNewlineState
+      } = this;
+      if ((_parenPushNewlineState == null ? void 0 : _parenPushNewlineState.printed) === false && HAS_NEWLINE.test(comment.value)) {
+        this.tokenChar(40);
+        this.indent();
+        _parenPushNewlineState.printed = true;
+      }
       val = `/*${comment.value}*/`;
       if (this.format.indent.adjustMultilineComment) {
         const offset = (_a = comment.loc) == null ? void 0 : _a.start.column;
@@ -36886,12 +36796,17 @@ var Printer = class {
           const newlineRegex = new RegExp("\\n\\s{1," + offset + "}", "g");
           val = val.replace(newlineRegex, "\n");
         }
-        let indentSize = this.format.retainLines ? 0 : this._buf.getCurrentColumn();
-        if (this._shouldIndent(47) || this.format.retainLines) {
-          indentSize += this._getIndent();
-        }
-        val = val.replace(/\n(?!$)/g, `
+        if (this.format.concise) {
+          val = val.replace(/\n(?!$)/g, `
+`);
+        } else {
+          let indentSize = this.format.retainLines ? 0 : this._buf.getCurrentColumn();
+          if (this._shouldIndent(47) || this.format.retainLines) {
+            indentSize += this._getIndent();
+          }
+          val = val.replace(/\n(?!$)/g, `
 ${" ".repeat(indentSize)}`);
+        }
       }
     } else if (!noLineTerminator) {
       val = `//${comment.value}`;
@@ -36994,18 +36909,6 @@ function commaSeparator() {
   this.tokenChar(44);
   this.space();
 }
-var Generator = class extends Printer {
-  constructor(ast, opts = {}, code2) {
-    const format = normalizeOptions(code2, opts);
-    const map = opts.sourceMaps ? new SourceMap(opts, code2) : null;
-    super(format, map);
-    this.ast = ast;
-  }
-  ast;
-  generate() {
-    return super.generate(this.ast);
-  }
-};
 function normalizeOptions(code2, opts) {
   const format = {
     auxiliaryCommentBefore: opts.auxiliaryCommentBefore,
@@ -37058,9 +36961,11 @@ function normalizeOptions(code2, opts) {
   }
   return format;
 }
-function generate(ast, opts, code2) {
-  const gen = new Generator(ast, opts, code2);
-  return gen.generate();
+function generate(ast, opts = {}, code2) {
+  const format = normalizeOptions(code2, opts);
+  const map = opts.sourceMaps ? new SourceMap(opts, code2) : null;
+  const printer = new Printer(format, map);
+  return printer.generate(ast);
 }
 
 // node_modules/@babel/traverse/lib/index.js
@@ -37217,7 +37122,7 @@ var {
   isRegExpLiteral: isRegExpLiteral2,
   isRestElement: isRestElement2,
   isTemplateLiteral: isTemplateLiteral2,
-  isVariableDeclarator: isVariableDeclarator3,
+  isVariableDeclarator: isVariableDeclarator2,
   toBindingIdentifierName: toBindingIdentifierName2
 } = lib_exports;
 function getFunctionArity(node) {
@@ -37331,7 +37236,7 @@ function index2({
     kind: "method"
   })) && (!parent.computed || isLiteral3(parent.key))) {
     id = parent.key;
-  } else if (isVariableDeclarator3(parent)) {
+  } else if (isVariableDeclarator2(parent)) {
     id = parent.id;
     if (isIdentifier4(id) && !localBinding) {
       const binding = scope2.parent.getBinding(id.name);
@@ -37407,6 +37312,157 @@ var virtualTypes = /* @__PURE__ */ Object.freeze({
   User,
   Var
 });
+var {
+  isBinding: isBinding2,
+  isBlockScoped: nodeIsBlockScoped,
+  isExportDeclaration: isExportDeclaration$1,
+  isExpression: nodeIsExpression,
+  isFlow: nodeIsFlow,
+  isForStatement: isForStatement3,
+  isForXStatement: isForXStatement2,
+  isIdentifier: isIdentifier$6,
+  isImportDeclaration: isImportDeclaration$1,
+  isImportSpecifier: isImportSpecifier2,
+  isJSXIdentifier: isJSXIdentifier3,
+  isJSXMemberExpression: isJSXMemberExpression2,
+  isMemberExpression: isMemberExpression3,
+  isRestElement: nodeIsRestElement,
+  isReferenced: nodeIsReferenced,
+  isScope: nodeIsScope,
+  isStatement: nodeIsStatement,
+  isVar: nodeIsVar,
+  isVariableDeclaration: isVariableDeclaration$2,
+  react: react$1,
+  isForOfStatement: isForOfStatement3
+} = lib_exports;
+var {
+  isCompatTag: isCompatTag2
+} = react$1;
+function isReferencedIdentifier(opts) {
+  const {
+    node,
+    parent
+  } = this;
+  if (!isIdentifier$6(node, opts) && !isJSXMemberExpression2(parent, opts)) {
+    if (isJSXIdentifier3(node, opts)) {
+      if (isCompatTag2(node.name))
+        return false;
+    } else {
+      return false;
+    }
+  }
+  return nodeIsReferenced(node, parent, this.parentPath.parent);
+}
+function isReferencedMemberExpression() {
+  const {
+    node,
+    parent
+  } = this;
+  return isMemberExpression3(node) && nodeIsReferenced(node, parent);
+}
+function isBindingIdentifier() {
+  const {
+    node,
+    parent
+  } = this;
+  const grandparent = this.parentPath.parent;
+  return isIdentifier$6(node) && isBinding2(node, parent, grandparent);
+}
+function isStatement$13() {
+  const {
+    node,
+    parent
+  } = this;
+  if (nodeIsStatement(node)) {
+    if (isVariableDeclaration$2(node)) {
+      if (isForXStatement2(parent, {
+        left: node
+      }))
+        return false;
+      if (isForStatement3(parent, {
+        init: node
+      }))
+        return false;
+    }
+    return true;
+  } else {
+    return false;
+  }
+}
+function isExpression$3() {
+  if (this.isIdentifier()) {
+    return this.isReferencedIdentifier();
+  } else {
+    return nodeIsExpression(this.node);
+  }
+}
+function isScope2() {
+  return nodeIsScope(this.node, this.parent);
+}
+function isReferenced2() {
+  return nodeIsReferenced(this.node, this.parent);
+}
+function isBlockScoped2() {
+  return nodeIsBlockScoped(this.node);
+}
+function isVar2() {
+  return nodeIsVar(this.node);
+}
+function isUser() {
+  return this.node && !!this.node.loc;
+}
+function isGenerated() {
+  return !this.isUser();
+}
+function isPure(constantsOnly) {
+  return this.scope.isPure(this.node, constantsOnly);
+}
+function isFlow2() {
+  const {
+    node
+  } = this;
+  if (nodeIsFlow(node)) {
+    return true;
+  } else if (isImportDeclaration$1(node)) {
+    return node.importKind === "type" || node.importKind === "typeof";
+  } else if (isExportDeclaration$1(node)) {
+    return node.exportKind === "type";
+  } else if (isImportSpecifier2(node)) {
+    return node.importKind === "type" || node.importKind === "typeof";
+  } else {
+    return false;
+  }
+}
+function isRestProperty2() {
+  return nodeIsRestElement(this.node) && this.parentPath && this.parentPath.isObjectPattern();
+}
+function isSpreadProperty2() {
+  return nodeIsRestElement(this.node) && this.parentPath && this.parentPath.isObjectExpression();
+}
+function isForAwaitStatement() {
+  return isForOfStatement3(this.node, {
+    await: true
+  });
+}
+var NodePath_virtual_types_validator = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  isBindingIdentifier,
+  isBlockScoped: isBlockScoped2,
+  isExpression: isExpression$3,
+  isFlow: isFlow2,
+  isForAwaitStatement,
+  isGenerated,
+  isPure,
+  isReferenced: isReferenced2,
+  isReferencedIdentifier,
+  isReferencedMemberExpression,
+  isRestProperty: isRestProperty2,
+  isScope: isScope2,
+  isSpreadProperty: isSpreadProperty2,
+  isStatement: isStatement$13,
+  isUser,
+  isVar: isVar2
+});
 var {
   DEPRECATED_KEYS: DEPRECATED_KEYS2,
   DEPRECATED_ALIASES: DEPRECATED_ALIASES2,
@@ -37604,8 +37660,10 @@ function ensureCallbackArrays(obj) {
     obj.exit = [obj.exit];
 }
 function wrapCheck(nodeType, fn) {
+  const fnKey = `is${nodeType}`;
+  const validator = NodePath_virtual_types_validator[fnKey];
   const newFn = function(path) {
-    if (path[`is${nodeType}`]()) {
+    if (validator.call(path)) {
       return fn.apply(this, arguments);
     }
   };
@@ -37858,19 +37916,19 @@ var {
   NOT_LOCAL_BINDING: NOT_LOCAL_BINDING3,
   callExpression: callExpression$3,
   cloneNode: cloneNode$3,
-  getBindingIdentifiers: getBindingIdentifiers$1,
+  getBindingIdentifiers: getBindingIdentifiers$3,
   identifier: identifier$3,
   isArrayExpression: isArrayExpression3,
   isBinary: isBinary3,
-  isClass: isClass3,
+  isClass: isClass2,
   isClassBody: isClassBody3,
   isClassDeclaration: isClassDeclaration3,
   isExportAllDeclaration: isExportAllDeclaration2,
   isExportDefaultDeclaration: isExportDefaultDeclaration3,
   isExportNamedDeclaration: isExportNamedDeclaration$1,
   isFunctionDeclaration: isFunctionDeclaration2,
-  isIdentifier: isIdentifier$6,
-  isImportDeclaration: isImportDeclaration$1,
+  isIdentifier: isIdentifier$5,
+  isImportDeclaration: isImportDeclaration2,
   isLiteral: isLiteral$12,
   isMethod: isMethod2,
   isModuleSpecifier: isModuleSpecifier2,
@@ -37880,7 +37938,7 @@ var {
   isPureish: isPureish2,
   isRegExpLiteral: isRegExpLiteral3,
   isSuper: isSuper$1,
-  isTaggedTemplateExpression: isTaggedTemplateExpression3,
+  isTaggedTemplateExpression: isTaggedTemplateExpression2,
   isTemplateLiteral: isTemplateLiteral3,
   isThisExpression: isThisExpression2,
   isUnaryExpression: isUnaryExpression2,
@@ -37897,17 +37955,17 @@ var {
   isTopicReference: isTopicReference2,
   isMetaProperty: isMetaProperty2,
   isPrivateName: isPrivateName2,
-  isExportDeclaration: isExportDeclaration$1,
-  buildUndefinedNode: buildUndefinedNode2
+  isExportDeclaration: isExportDeclaration3,
+  buildUndefinedNode: buildUndefinedNode$1
 } = lib_exports;
 function gatherNodeParts(node, parts) {
   var _a;
   switch (node == null ? void 0 : node.type) {
     default:
-      if (isImportDeclaration$1(node) || isExportDeclaration$1(node)) {
-        if ((isExportAllDeclaration2(node) || isExportNamedDeclaration$1(node) || isImportDeclaration$1(node)) && node.source) {
+      if (isImportDeclaration2(node) || isExportDeclaration3(node)) {
+        if ((isExportAllDeclaration2(node) || isExportNamedDeclaration$1(node) || isImportDeclaration2(node)) && node.source) {
           gatherNodeParts(node.source, parts);
-        } else if ((isExportNamedDeclaration$1(node) || isImportDeclaration$1(node)) && ((_a = node.specifiers) == null ? void 0 : _a.length)) {
+        } else if ((isExportNamedDeclaration$1(node) || isImportDeclaration2(node)) && ((_a = node.specifiers) == null ? void 0 : _a.length)) {
           for (const e of node.specifiers)
             gatherNodeParts(e, parts);
         } else if ((isExportDefaultDeclaration3(node) || isExportNamedDeclaration$1(node)) && node.declaration) {
@@ -38073,7 +38131,7 @@ var collectorVisitor = {
         binding == null ? void 0 : binding.reference(path);
       } else if (isVariableDeclaration$1(declar)) {
         for (const decl of declar.declarations) {
-          for (const name of Object.keys(getBindingIdentifiers$1(decl))) {
+          for (const name of Object.keys(getBindingIdentifiers$3(decl))) {
             const binding = scope2.getBinding(name);
             binding == null ? void 0 : binding.reference(path);
           }
@@ -38219,7 +38277,7 @@ var Scope2 = class _Scope {
     if (isThisExpression2(node) || isSuper$1(node) || isTopicReference2(node)) {
       return true;
     }
-    if (isIdentifier$6(node)) {
+    if (isIdentifier$5(node)) {
       const binding = this.getBinding(node.name);
       if (binding) {
         return binding.constant;
@@ -38288,7 +38346,7 @@ var Scope2 = class _Scope {
     console.log(sep);
   }
   toArray(node, i, arrayLikeIsIterable) {
-    if (isIdentifier$6(node)) {
+    if (isIdentifier$5(node)) {
       const binding = this.getBinding(node.name);
       if ((binding == null ? void 0 : binding.constant) && binding.path.isGenericType("Array")) {
         return node;
@@ -38297,7 +38355,7 @@ var Scope2 = class _Scope {
     if (isArrayExpression3(node)) {
       return node;
     }
-    if (isIdentifier$6(node, {
+    if (isIdentifier$5(node, {
       name: "arguments"
     })) {
       return callExpression$3(memberExpression$1(memberExpression$1(memberExpression$1(identifier$3("Array"), identifier$3("prototype")), identifier$3("slice")), identifier$3("call")), [node]);
@@ -38361,7 +38419,7 @@ var Scope2 = class _Scope {
     }
   }
   buildUndefinedNode() {
-    return buildUndefinedNode2();
+    return buildUndefinedNode$1();
   }
   registerConstantViolation(path) {
     var _a;
@@ -38428,7 +38486,7 @@ var Scope2 = class _Scope {
   }
   isPure(node, constantsOnly) {
     var _a, _b, _c;
-    if (isIdentifier$6(node)) {
+    if (isIdentifier$5(node)) {
       const binding = this.getBinding(node.name);
       if (!binding)
         return false;
@@ -38437,7 +38495,7 @@ var Scope2 = class _Scope {
       return true;
     } else if (isThisExpression2(node) || isMetaProperty2(node) || isTopicReference2(node) || isPrivateName2(node)) {
       return true;
-    } else if (isClass3(node)) {
+    } else if (isClass2(node)) {
       if (node.superClass && !this.isPure(node.superClass, constantsOnly)) {
         return false;
       }
@@ -38486,7 +38544,7 @@ var Scope2 = class _Scope {
       return true;
     } else if (isUnaryExpression2(node)) {
       return this.isPure(node.argument, constantsOnly);
-    } else if (isTaggedTemplateExpression3(node)) {
+    } else if (isTaggedTemplateExpression2(node)) {
       return matchesPattern$1(node.tag, "String.raw") && !this.hasBinding("String", true) && this.isPure(node.quasi, constantsOnly);
     } else if (isTemplateLiteral3(node)) {
       for (const expression2 of node.expressions) {
@@ -38770,7 +38828,7 @@ function findParent(callback) {
   }
   return null;
 }
-function find2(callback) {
+function find(callback) {
   let path = this;
   do {
     if (callback(path))
@@ -38888,7 +38946,7 @@ function inType(...candidateTypes) {
 }
 var NodePath_ancestry = /* @__PURE__ */ Object.freeze({
   __proto__: null,
-  find: find2,
+  find,
   findParent,
   getAncestry,
   getDeepestCommonAncestorFrom,
@@ -39086,7 +39144,7 @@ var {
   tupleTypeAnnotation: tupleTypeAnnotation2,
   unionTypeAnnotation: unionTypeAnnotation2,
   voidTypeAnnotation: voidTypeAnnotation$1,
-  isIdentifier: isIdentifier$5
+  isIdentifier: isIdentifier$4
 } = lib_exports;
 function VariableDeclarator2() {
   if (!this.get("id").isIdentifier())
@@ -39202,7 +39260,7 @@ function CallExpression2() {
   } = this.node;
   if (isObjectKeys(callee)) {
     return arrayTypeAnnotation2(stringTypeAnnotation$1());
-  } else if (isArrayFrom(callee) || isObjectValues(callee) || isIdentifier$5(callee, {
+  } else if (isArrayFrom(callee) || isObjectValues(callee) || isIdentifier$4(callee, {
     name: "Array"
   })) {
     return arrayTypeAnnotation2(anyTypeAnnotation$1());
@@ -39277,16 +39335,16 @@ var {
   isEmptyTypeAnnotation: isEmptyTypeAnnotation2,
   isFlowBaseAnnotation: isFlowBaseAnnotation2,
   isGenericTypeAnnotation: isGenericTypeAnnotation2,
-  isIdentifier: isIdentifier$4,
+  isIdentifier: isIdentifier$3,
   isMixedTypeAnnotation: isMixedTypeAnnotation2,
   isNumberTypeAnnotation: isNumberTypeAnnotation2,
   isStringTypeAnnotation: isStringTypeAnnotation2,
-  isTSArrayType: isTSArrayType3,
+  isTSArrayType: isTSArrayType2,
   isTSTypeAnnotation: isTSTypeAnnotation2,
   isTSTypeReference: isTSTypeReference2,
   isTupleTypeAnnotation: isTupleTypeAnnotation2,
-  isTypeAnnotation: isTypeAnnotation3,
-  isUnionTypeAnnotation: isUnionTypeAnnotation3,
+  isTypeAnnotation: isTypeAnnotation2,
+  isUnionTypeAnnotation: isUnionTypeAnnotation2,
   isVoidTypeAnnotation: isVoidTypeAnnotation2,
   stringTypeAnnotation: stringTypeAnnotation2,
   voidTypeAnnotation: voidTypeAnnotation2
@@ -39297,7 +39355,7 @@ function getTypeAnnotation() {
     return type;
   }
   type = this._getTypeAnnotation() || anyTypeAnnotation2();
-  if (isTypeAnnotation3(type) || isTSTypeAnnotation2(type)) {
+  if (isTypeAnnotation2(type) || isTSTypeAnnotation2(type)) {
     type = type.typeAnnotation;
   }
   this.setData("typeAnnotation", type);
@@ -39371,7 +39429,7 @@ function couldBeBaseType(name) {
   const type = this.getTypeAnnotation();
   if (isAnyTypeAnnotation2(type))
     return true;
-  if (isUnionTypeAnnotation3(type)) {
+  if (isUnionTypeAnnotation2(type)) {
     for (const type2 of type.types) {
       if (isAnyTypeAnnotation2(type2) || _isBaseType(name, type2, true)) {
         return true;
@@ -39393,13 +39451,13 @@ function baseTypeStrictlyMatches(rightArg) {
 function isGenericType(genericName) {
   const type = this.getTypeAnnotation();
   if (genericName === "Array") {
-    if (isTSArrayType3(type) || isArrayTypeAnnotation3(type) || isTupleTypeAnnotation2(type)) {
+    if (isTSArrayType2(type) || isArrayTypeAnnotation3(type) || isTupleTypeAnnotation2(type)) {
       return true;
     }
   }
-  return isGenericTypeAnnotation2(type) && isIdentifier$4(type.id, {
+  return isGenericTypeAnnotation2(type) && isIdentifier$3(type.id, {
     name: genericName
-  }) || isTSTypeReference2(type) && isIdentifier$4(type.typeName, {
+  }) || isTSTypeReference2(type) && isIdentifier$3(type.typeName, {
     name: genericName
   });
 }
@@ -39418,19 +39476,27 @@ var {
   assignmentExpression: assignmentExpression$2,
   awaitExpression: awaitExpression2,
   blockStatement: blockStatement$2,
+  buildUndefinedNode: buildUndefinedNode2,
   callExpression: callExpression$2,
   cloneNode: cloneNode$2,
+  conditionalExpression: conditionalExpression$1,
   expressionStatement: expressionStatement$2,
+  getBindingIdentifiers: getBindingIdentifiers$2,
   identifier: identifier$1,
   inheritLeadingComments: inheritLeadingComments2,
   inheritTrailingComments: inheritTrailingComments2,
   inheritsComments: inheritsComments2,
-  isExpression: isExpression$3,
+  isBlockStatement: isBlockStatement$1,
+  isEmptyStatement: isEmptyStatement2,
+  isExpression: isExpression$2,
+  isExpressionStatement: isExpressionStatement4,
+  isIfStatement: isIfStatement3,
   isProgram: isProgram2,
-  isStatement: isStatement$13,
+  isStatement: isStatement4,
+  isVariableDeclaration: isVariableDeclaration2,
   removeComments: removeComments2,
   returnStatement: returnStatement$1,
-  toSequenceExpression: toSequenceExpression2,
+  sequenceExpression: sequenceExpression$1,
   validate: validate$13,
   yieldExpression: yieldExpression2
 } = lib_exports;
@@ -39495,13 +39561,13 @@ function replaceWith(replacementPath) {
     throw new Error("Don't use `path.replaceWith()` with a source string, use `path.replaceWithSourceString()`");
   }
   let nodePath = "";
-  if (this.isNodeType("Statement") && isExpression$3(replacement)) {
+  if (this.isNodeType("Statement") && isExpression$2(replacement)) {
     if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement) && !this.parentPath.isExportDefaultDeclaration()) {
       replacement = expressionStatement$2(replacement);
       nodePath = "expression";
     }
   }
-  if (this.isNodeType("Expression") && isStatement$13(replacement)) {
+  if (this.isNodeType("Expression") && isStatement4(replacement)) {
     if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement)) {
       return this.replaceExpressionWithStatements([replacement]);
     }
@@ -39533,9 +39599,14 @@ function _replaceWith(node) {
 }
 function replaceExpressionWithStatements(nodes2) {
   this.resync();
-  const nodesAsSequenceExpression = toSequenceExpression2(nodes2, this.scope);
-  if (nodesAsSequenceExpression) {
-    return this.replaceWith(nodesAsSequenceExpression)[0].get("expressions");
+  const declars = [];
+  const nodesAsSingleExpression = gatherSequenceExpressions(nodes2, declars);
+  if (nodesAsSingleExpression) {
+    for (const id of declars)
+      this.scope.push({
+        id
+      });
+    return this.replaceWith(nodesAsSingleExpression)[0].get("expressions");
   }
   const functionParent = this.getFunctionParent();
   const isParentAsync = functionParent == null ? void 0 : functionParent.is("async");
@@ -39583,6 +39654,57 @@ function replaceExpressionWithStatements(nodes2) {
   }
   return newCallee.get("body.body");
 }
+function gatherSequenceExpressions(nodes2, declars) {
+  const exprs = [];
+  let ensureLastUndefined = true;
+  for (const node of nodes2) {
+    if (!isEmptyStatement2(node)) {
+      ensureLastUndefined = false;
+    }
+    if (isExpression$2(node)) {
+      exprs.push(node);
+    } else if (isExpressionStatement4(node)) {
+      exprs.push(node.expression);
+    } else if (isVariableDeclaration2(node)) {
+      if (node.kind !== "var")
+        return;
+      for (const declar of node.declarations) {
+        const bindings = getBindingIdentifiers$2(declar);
+        for (const key of Object.keys(bindings)) {
+          declars.push(cloneNode$2(bindings[key]));
+        }
+        if (declar.init) {
+          exprs.push(assignmentExpression$2("=", declar.id, declar.init));
+        }
+      }
+      ensureLastUndefined = true;
+    } else if (isIfStatement3(node)) {
+      const consequent = node.consequent ? gatherSequenceExpressions([node.consequent], declars) : buildUndefinedNode2();
+      const alternate = node.alternate ? gatherSequenceExpressions([node.alternate], declars) : buildUndefinedNode2();
+      if (!consequent || !alternate)
+        return;
+      exprs.push(conditionalExpression$1(node.test, consequent, alternate));
+    } else if (isBlockStatement$1(node)) {
+      const body = gatherSequenceExpressions(node.body, declars);
+      if (!body)
+        return;
+      exprs.push(body);
+    } else if (isEmptyStatement2(node)) {
+      if (nodes2.indexOf(node) === 0) {
+        ensureLastUndefined = true;
+      }
+    } else {
+      return;
+    }
+  }
+  if (ensureLastUndefined)
+    exprs.push(buildUndefinedNode2());
+  if (exprs.length === 1) {
+    return exprs[0];
+  } else {
+    return sequenceExpression$1(exprs);
+  }
+}
 function replaceInline(nodes2) {
   this.resync();
   if (Array.isArray(nodes2)) {
@@ -39975,7 +40097,7 @@ var {
   conditionalExpression: conditionalExpression2,
   expressionStatement: expressionStatement$1,
   identifier: identifier6,
-  isIdentifier: isIdentifier$3,
+  isIdentifier: isIdentifier$22,
   jsxIdentifier: jsxIdentifier2,
   logicalExpression: logicalExpression2,
   LOGICAL_OPERATORS: LOGICAL_OPERATORS2,
@@ -40003,7 +40125,7 @@ function toComputedKey2() {
     throw new ReferenceError("todo");
   }
   if (!this.node.computed) {
-    if (isIdentifier$3(key))
+    if (isIdentifier$22(key))
       key = stringLiteral3(key.name);
   }
   return key;
@@ -40435,8 +40557,8 @@ var {
   STATEMENT_OR_BLOCK_KEYS: STATEMENT_OR_BLOCK_KEYS2,
   VISITOR_KEYS: VISITOR_KEYS$3,
   isBlockStatement: isBlockStatement3,
-  isExpression: isExpression$2,
-  isIdentifier: isIdentifier$22,
+  isExpression: isExpression$1,
+  isIdentifier: isIdentifier$12,
   isLiteral: isLiteral4,
   isStringLiteral: isStringLiteral4,
   isType: isType3,
@@ -40476,7 +40598,7 @@ function canSwapBetweenExpressionAndStatement(replacement) {
   if (this.isExpression()) {
     return isBlockStatement3(replacement);
   } else if (this.isBlockStatement()) {
-    return isExpression$2(replacement);
+    return isExpression$1(replacement);
   }
   return false;
 }
@@ -40534,7 +40656,7 @@ function referencesImport(moduleSource, importName) {
   if (path.isImportNamespaceSpecifier() && importName === "*") {
     return true;
   }
-  if (path.isImportSpecifier() && isIdentifier$22(path.node.imported, {
+  if (path.isImportSpecifier() && isIdentifier$12(path.node.imported, {
     name: importName
   })) {
     return true;
@@ -41090,6 +41212,9 @@ var hooks = [function(self, parent) {
     return true;
   }
 }];
+var {
+  getBindingIdentifiers: getBindingIdentifiers$1
+} = lib_exports;
 function remove() {
   var _a;
   this._assertUnremoved();
@@ -41106,7 +41231,7 @@ function remove() {
   this._markRemoved();
 }
 function _removeFromScope() {
-  const bindings = this.getBindingIdentifiers();
+  const bindings = getBindingIdentifiers$1(this.node, false, false, true);
   Object.keys(bindings).forEach((name) => this.scope.removeBinding(name));
 }
 function _callRemovalHooks() {
@@ -41145,7 +41270,7 @@ var NodePath_removal = /* @__PURE__ */ Object.freeze({
   remove
 });
 var {
-  react: react$1
+  react: react2
 } = lib_exports;
 var {
   cloneNode: cloneNode$1,
@@ -41155,7 +41280,7 @@ var {
 } = lib_exports;
 var referenceVisitor = {
   ReferencedIdentifier(path, state) {
-    if (path.isJSXIdentifier() && react$1.isCompatTag(path.node.name) && !path.parentPath.isJSXMemberExpression()) {
+    if (path.isJSXIdentifier() && react2.isCompatTag(path.node.name) && !path.parentPath.isJSXMemberExpression()) {
       return;
     }
     if (path.node.name === "this") {
@@ -41329,9 +41454,9 @@ var {
   isAssignmentExpression: isAssignmentExpression4,
   isCallExpression: isCallExpression4,
   isExportNamedDeclaration: isExportNamedDeclaration3,
-  isExpression: isExpression$1,
-  isIdentifier: isIdentifier$12,
-  isSequenceExpression: isSequenceExpression3,
+  isExpression: isExpression2,
+  isIdentifier: isIdentifier5,
+  isSequenceExpression: isSequenceExpression2,
   isSuper: isSuper2,
   thisExpression: thisExpression2
 } = lib_exports;
@@ -41390,10 +41515,10 @@ function _containerInsertAfter(nodes2) {
 }
 var last = (arr) => arr[arr.length - 1];
 function isHiddenInSequenceExpression(path) {
-  return isSequenceExpression3(path.parent) && (last(path.parent.expressions) !== path.node || isHiddenInSequenceExpression(path.parentPath));
+  return isSequenceExpression2(path.parent) && (last(path.parent.expressions) !== path.node || isHiddenInSequenceExpression(path.parentPath));
 }
 function isAlmostConstantAssignment(node, scope2) {
-  if (!isAssignmentExpression4(node) || !isIdentifier$12(node.left)) {
+  if (!isAssignmentExpression4(node) || !isIdentifier5(node.left)) {
     return false;
   }
   const blockScope = scope2.getBlockParent();
@@ -41411,7 +41536,7 @@ function insertAfter(nodes_) {
   } = this;
   if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || isExportNamedDeclaration3(parent) || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) {
     return parentPath.insertAfter(nodes2.map((node) => {
-      return isExpression$1(node) ? expressionStatement4(node) : node;
+      return isExpression2(node) ? expressionStatement4(node) : node;
     }));
   } else if (this.isNodeType("Expression") && !this.isJSXElement() && !parentPath.isJSXElement() || parentPath.isForStatement() && this.key === "init") {
     if (this.node) {
@@ -41904,14 +42029,11 @@ function shareCommentsWithSiblings() {
   }
 }
 function removeIfExisting(list, toRemove) {
-  if (!toRemove)
+  if (!(toRemove == null ? void 0 : toRemove.length))
     return list;
-  let lastFoundIndex = -1;
+  const set = new Set(toRemove);
   return list.filter((el) => {
-    const i = toRemove.indexOf(el, lastFoundIndex);
-    if (i === -1)
-      return true;
-    lastFoundIndex = i;
+    return !set.has(el);
   });
 }
 function addComment2(type, content, line) {
@@ -41926,157 +42048,6 @@ var NodePath_comments = /* @__PURE__ */ Object.freeze({
   addComments: addComments2,
   shareCommentsWithSiblings
 });
-var {
-  isBinding: isBinding2,
-  isBlockScoped: nodeIsBlockScoped,
-  isExportDeclaration: isExportDeclaration3,
-  isExpression: nodeIsExpression,
-  isFlow: nodeIsFlow,
-  isForStatement: isForStatement3,
-  isForXStatement: isForXStatement2,
-  isIdentifier: isIdentifier5,
-  isImportDeclaration: isImportDeclaration2,
-  isImportSpecifier: isImportSpecifier2,
-  isJSXIdentifier: isJSXIdentifier3,
-  isJSXMemberExpression: isJSXMemberExpression2,
-  isMemberExpression: isMemberExpression3,
-  isRestElement: nodeIsRestElement,
-  isReferenced: nodeIsReferenced,
-  isScope: nodeIsScope,
-  isStatement: nodeIsStatement,
-  isVar: nodeIsVar,
-  isVariableDeclaration: isVariableDeclaration2,
-  react: react2,
-  isForOfStatement: isForOfStatement3
-} = lib_exports;
-var {
-  isCompatTag: isCompatTag2
-} = react2;
-function isReferencedIdentifier(opts) {
-  const {
-    node,
-    parent
-  } = this;
-  if (!isIdentifier5(node, opts) && !isJSXMemberExpression2(parent, opts)) {
-    if (isJSXIdentifier3(node, opts)) {
-      if (isCompatTag2(node.name))
-        return false;
-    } else {
-      return false;
-    }
-  }
-  return nodeIsReferenced(node, parent, this.parentPath.parent);
-}
-function isReferencedMemberExpression() {
-  const {
-    node,
-    parent
-  } = this;
-  return isMemberExpression3(node) && nodeIsReferenced(node, parent);
-}
-function isBindingIdentifier() {
-  const {
-    node,
-    parent
-  } = this;
-  const grandparent = this.parentPath.parent;
-  return isIdentifier5(node) && isBinding2(node, parent, grandparent);
-}
-function isStatement4() {
-  const {
-    node,
-    parent
-  } = this;
-  if (nodeIsStatement(node)) {
-    if (isVariableDeclaration2(node)) {
-      if (isForXStatement2(parent, {
-        left: node
-      }))
-        return false;
-      if (isForStatement3(parent, {
-        init: node
-      }))
-        return false;
-    }
-    return true;
-  } else {
-    return false;
-  }
-}
-function isExpression2() {
-  if (this.isIdentifier()) {
-    return this.isReferencedIdentifier();
-  } else {
-    return nodeIsExpression(this.node);
-  }
-}
-function isScope2() {
-  return nodeIsScope(this.node, this.parent);
-}
-function isReferenced2() {
-  return nodeIsReferenced(this.node, this.parent);
-}
-function isBlockScoped2() {
-  return nodeIsBlockScoped(this.node);
-}
-function isVar2() {
-  return nodeIsVar(this.node);
-}
-function isUser() {
-  return this.node && !!this.node.loc;
-}
-function isGenerated() {
-  return !this.isUser();
-}
-function isPure(constantsOnly) {
-  return this.scope.isPure(this.node, constantsOnly);
-}
-function isFlow2() {
-  const {
-    node
-  } = this;
-  if (nodeIsFlow(node)) {
-    return true;
-  } else if (isImportDeclaration2(node)) {
-    return node.importKind === "type" || node.importKind === "typeof";
-  } else if (isExportDeclaration3(node)) {
-    return node.exportKind === "type";
-  } else if (isImportSpecifier2(node)) {
-    return node.importKind === "type" || node.importKind === "typeof";
-  } else {
-    return false;
-  }
-}
-function isRestProperty2() {
-  return nodeIsRestElement(this.node) && this.parentPath && this.parentPath.isObjectPattern();
-}
-function isSpreadProperty2() {
-  return nodeIsRestElement(this.node) && this.parentPath && this.parentPath.isObjectExpression();
-}
-function isForAwaitStatement() {
-  return isForOfStatement3(this.node, {
-    await: true
-  });
-}
-var NodePath_virtual_types_validator = /* @__PURE__ */ Object.freeze({
-  __proto__: null,
-  isBindingIdentifier,
-  isBlockScoped: isBlockScoped2,
-  isExpression: isExpression2,
-  isFlow: isFlow2,
-  isForAwaitStatement,
-  isGenerated,
-  isPure,
-  isReferenced: isReferenced2,
-  isReferencedIdentifier,
-  isReferencedMemberExpression,
-  isRestProperty: isRestProperty2,
-  isScope: isScope2,
-  isSpreadProperty: isSpreadProperty2,
-  isStatement: isStatement4,
-  isUser,
-  isVar: isVar2
-});
 var {
   validate: validate3
 } = lib_exports;