@putout/bundle 3.9.0 → 3.10.0

package/bundle/putout.js

@@ -2456,7 +2456,7 @@ function format(f) {
   if (!isString$b(f)) {
     var objects = [];
     for (var i = 0; i < arguments.length; i++) {
-      objects.push(inspect$1(arguments[i]));
+      objects.push(inspect(arguments[i]));
     }
     return objects.join(' ');
   }
@@ -2484,7 +2484,7 @@ function format(f) {
     if (isNull$1(x) || !isObject$5(x)) {
       str += ' ' + x;
     } else {
-      str += ' ' + inspect$1(x);
+      str += ' ' + inspect(x);
     }
   }
   return str;
@@ -2551,7 +2551,7 @@ function debuglog(set) {
  * @param {Object} opts Optional options object that alters the output.
  */
 /* legacy: obj, showHidden, depth, colors*/
-function inspect$1(obj, opts) {
+function inspect(obj, opts) {
   // default options
   var ctx = {
     seen: [],
@@ -2577,7 +2577,7 @@ function inspect$1(obj, opts) {
 }
 
 // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
-inspect$1.colors = {
+inspect.colors = {
   'bold' : [1, 22],
   'italic' : [3, 23],
   'underline' : [4, 24],
@@ -2594,7 +2594,7 @@ inspect$1.colors = {
 };
 
 // Don't use 'blue' not visible on cmd.exe
-inspect$1.styles = {
+inspect.styles = {
   'special': 'cyan',
   'number': 'yellow',
   'boolean': 'yellow',
@@ -2608,11 +2608,11 @@ inspect$1.styles = {
 
 
 function stylizeWithColor(str, styleType) {
-  var style = inspect$1.styles[styleType];
+  var style = inspect.styles[styleType];
 
   if (style) {
-    return '\u001b[' + inspect$1.colors[style][0] + 'm' + str +
-           '\u001b[' + inspect$1.colors[style][1] + 'm';
+    return '\u001b[' + inspect.colors[style][0] + 'm' + str +
+           '\u001b[' + inspect.colors[style][1] + 'm';
   } else {
     return str;
   }
@@ -2642,7 +2642,7 @@ function formatValue(ctx, value, recurseTimes) {
       value &&
       isFunction$3(value.inspect) &&
       // Filter out the util module, it's inspect function is special
-      value.inspect !== inspect$1 &&
+      value.inspect !== inspect &&
       // Also filter out any prototype objects using the circular check.
       !(value.constructor && value.constructor.prototype === value)) {
     var ret = value.inspect(recurseTimes, ctx);
@@ -3105,7 +3105,7 @@ var _polyfillNode_util = {
   isNull: isNull$1,
   isBoolean: isBoolean,
   isArray: isArray$f,
-  inspect: inspect$1,
+  inspect: inspect,
   deprecate: deprecate,
   format: format,
   debuglog: debuglog,
@@ -3122,7 +3122,7 @@ var _polyfillNode_util$1 = /*#__PURE__*/Object.freeze({
 	deprecate: deprecate,
 	format: format,
 	inherits: inherits$2,
-	inspect: inspect$1,
+	inspect: inspect,
 	isArray: isArray$f,
 	isBoolean: isBoolean,
 	isBuffer: isBuffer,
@@ -7473,10 +7473,10 @@ __export(lib_exports2, {
         return generate$6;
     },
     parse: function() {
-        return parse$5;
+        return parse$6;
     },
     parseExpression: function() {
-        return parseExpression$1;
+        return parseExpression;
     },
     template: function() {
         return index;
@@ -10007,7 +10007,7 @@ __export(lib_exports, {
         return isExpression$2;
     },
     isExpressionStatement: function() {
-        return isExpressionStatement$2;
+        return isExpressionStatement$1;
     },
     isExpressionWrapper: function() {
         return isExpressionWrapper;
@@ -12910,7 +12910,7 @@ function isEmptyStatement(node, opts) {
     if (node.type !== "EmptyStatement") return false;
     return opts == null || shallowEqual(node, opts);
 }
-function isExpressionStatement$2(node, opts) {
+function isExpressionStatement$1(node, opts) {
     if (!node) return false;
     if (node.type !== "ExpressionStatement") return false;
     return opts == null || shallowEqual(node, opts);
@@ -22261,927 +22261,927 @@ function assertNode(node) {
         throw new TypeError('Not a valid node of type "'.concat(type, '"'));
     }
 }
-function assert$1(type, node, opts) {
+function assert(type, node, opts) {
     if (!is$4(type, node, opts)) {
         throw new Error('Expected type "'.concat(type, '" with option ').concat(JSON.stringify(opts), ', but instead got "').concat(node.type, '".'));
     }
 }
 function assertArrayExpression(node, opts) {
-    assert$1("ArrayExpression", node, opts);
+    assert("ArrayExpression", node, opts);
 }
 function assertAssignmentExpression(node, opts) {
-    assert$1("AssignmentExpression", node, opts);
+    assert("AssignmentExpression", node, opts);
 }
 function assertBinaryExpression(node, opts) {
-    assert$1("BinaryExpression", node, opts);
+    assert("BinaryExpression", node, opts);
 }
 function assertInterpreterDirective(node, opts) {
-    assert$1("InterpreterDirective", node, opts);
+    assert("InterpreterDirective", node, opts);
 }
 function assertDirective(node, opts) {
-    assert$1("Directive", node, opts);
+    assert("Directive", node, opts);
 }
 function assertDirectiveLiteral(node, opts) {
-    assert$1("DirectiveLiteral", node, opts);
+    assert("DirectiveLiteral", node, opts);
 }
 function assertBlockStatement(node, opts) {
-    assert$1("BlockStatement", node, opts);
+    assert("BlockStatement", node, opts);
 }
 function assertBreakStatement(node, opts) {
-    assert$1("BreakStatement", node, opts);
+    assert("BreakStatement", node, opts);
 }
 function assertCallExpression(node, opts) {
-    assert$1("CallExpression", node, opts);
+    assert("CallExpression", node, opts);
 }
 function assertCatchClause(node, opts) {
-    assert$1("CatchClause", node, opts);
+    assert("CatchClause", node, opts);
 }
 function assertConditionalExpression(node, opts) {
-    assert$1("ConditionalExpression", node, opts);
+    assert("ConditionalExpression", node, opts);
 }
 function assertContinueStatement(node, opts) {
-    assert$1("ContinueStatement", node, opts);
+    assert("ContinueStatement", node, opts);
 }
 function assertDebuggerStatement(node, opts) {
-    assert$1("DebuggerStatement", node, opts);
+    assert("DebuggerStatement", node, opts);
 }
 function assertDoWhileStatement(node, opts) {
-    assert$1("DoWhileStatement", node, opts);
+    assert("DoWhileStatement", node, opts);
 }
 function assertEmptyStatement(node, opts) {
-    assert$1("EmptyStatement", node, opts);
+    assert("EmptyStatement", node, opts);
 }
 function assertExpressionStatement(node, opts) {
-    assert$1("ExpressionStatement", node, opts);
+    assert("ExpressionStatement", node, opts);
 }
 function assertFile(node, opts) {
-    assert$1("File", node, opts);
+    assert("File", node, opts);
 }
 function assertForInStatement(node, opts) {
-    assert$1("ForInStatement", node, opts);
+    assert("ForInStatement", node, opts);
 }
 function assertForStatement(node, opts) {
-    assert$1("ForStatement", node, opts);
+    assert("ForStatement", node, opts);
 }
 function assertFunctionDeclaration(node, opts) {
-    assert$1("FunctionDeclaration", node, opts);
+    assert("FunctionDeclaration", node, opts);
 }
 function assertFunctionExpression(node, opts) {
-    assert$1("FunctionExpression", node, opts);
+    assert("FunctionExpression", node, opts);
 }
 function assertIdentifier(node, opts) {
-    assert$1("Identifier", node, opts);
+    assert("Identifier", node, opts);
 }
 function assertIfStatement(node, opts) {
-    assert$1("IfStatement", node, opts);
+    assert("IfStatement", node, opts);
 }
 function assertLabeledStatement(node, opts) {
-    assert$1("LabeledStatement", node, opts);
+    assert("LabeledStatement", node, opts);
 }
 function assertStringLiteral(node, opts) {
-    assert$1("StringLiteral", node, opts);
+    assert("StringLiteral", node, opts);
 }
 function assertNumericLiteral(node, opts) {
-    assert$1("NumericLiteral", node, opts);
+    assert("NumericLiteral", node, opts);
 }
 function assertNullLiteral(node, opts) {
-    assert$1("NullLiteral", node, opts);
+    assert("NullLiteral", node, opts);
 }
 function assertBooleanLiteral(node, opts) {
-    assert$1("BooleanLiteral", node, opts);
+    assert("BooleanLiteral", node, opts);
 }
 function assertRegExpLiteral(node, opts) {
-    assert$1("RegExpLiteral", node, opts);
+    assert("RegExpLiteral", node, opts);
 }
 function assertLogicalExpression(node, opts) {
-    assert$1("LogicalExpression", node, opts);
+    assert("LogicalExpression", node, opts);
 }
 function assertMemberExpression(node, opts) {
-    assert$1("MemberExpression", node, opts);
+    assert("MemberExpression", node, opts);
 }
 function assertNewExpression(node, opts) {
-    assert$1("NewExpression", node, opts);
+    assert("NewExpression", node, opts);
 }
 function assertProgram(node, opts) {
-    assert$1("Program", node, opts);
+    assert("Program", node, opts);
 }
 function assertObjectExpression(node, opts) {
-    assert$1("ObjectExpression", node, opts);
+    assert("ObjectExpression", node, opts);
 }
 function assertObjectMethod(node, opts) {
-    assert$1("ObjectMethod", node, opts);
+    assert("ObjectMethod", node, opts);
 }
 function assertObjectProperty(node, opts) {
-    assert$1("ObjectProperty", node, opts);
+    assert("ObjectProperty", node, opts);
 }
 function assertRestElement(node, opts) {
-    assert$1("RestElement", node, opts);
+    assert("RestElement", node, opts);
 }
 function assertReturnStatement(node, opts) {
-    assert$1("ReturnStatement", node, opts);
+    assert("ReturnStatement", node, opts);
 }
 function assertSequenceExpression(node, opts) {
-    assert$1("SequenceExpression", node, opts);
+    assert("SequenceExpression", node, opts);
 }
 function assertParenthesizedExpression(node, opts) {
-    assert$1("ParenthesizedExpression", node, opts);
+    assert("ParenthesizedExpression", node, opts);
 }
 function assertSwitchCase(node, opts) {
-    assert$1("SwitchCase", node, opts);
+    assert("SwitchCase", node, opts);
 }
 function assertSwitchStatement(node, opts) {
-    assert$1("SwitchStatement", node, opts);
+    assert("SwitchStatement", node, opts);
 }
 function assertThisExpression(node, opts) {
-    assert$1("ThisExpression", node, opts);
+    assert("ThisExpression", node, opts);
 }
 function assertThrowStatement(node, opts) {
-    assert$1("ThrowStatement", node, opts);
+    assert("ThrowStatement", node, opts);
 }
 function assertTryStatement(node, opts) {
-    assert$1("TryStatement", node, opts);
+    assert("TryStatement", node, opts);
 }
 function assertUnaryExpression(node, opts) {
-    assert$1("UnaryExpression", node, opts);
+    assert("UnaryExpression", node, opts);
 }
 function assertUpdateExpression(node, opts) {
-    assert$1("UpdateExpression", node, opts);
+    assert("UpdateExpression", node, opts);
 }
 function assertVariableDeclaration(node, opts) {
-    assert$1("VariableDeclaration", node, opts);
+    assert("VariableDeclaration", node, opts);
 }
 function assertVariableDeclarator(node, opts) {
-    assert$1("VariableDeclarator", node, opts);
+    assert("VariableDeclarator", node, opts);
 }
 function assertWhileStatement(node, opts) {
-    assert$1("WhileStatement", node, opts);
+    assert("WhileStatement", node, opts);
 }
 function assertWithStatement(node, opts) {
-    assert$1("WithStatement", node, opts);
+    assert("WithStatement", node, opts);
 }
 function assertAssignmentPattern(node, opts) {
-    assert$1("AssignmentPattern", node, opts);
+    assert("AssignmentPattern", node, opts);
 }
 function assertArrayPattern(node, opts) {
-    assert$1("ArrayPattern", node, opts);
+    assert("ArrayPattern", node, opts);
 }
 function assertArrowFunctionExpression(node, opts) {
-    assert$1("ArrowFunctionExpression", node, opts);
+    assert("ArrowFunctionExpression", node, opts);
 }
 function assertClassBody(node, opts) {
-    assert$1("ClassBody", node, opts);
+    assert("ClassBody", node, opts);
 }
 function assertClassExpression(node, opts) {
-    assert$1("ClassExpression", node, opts);
+    assert("ClassExpression", node, opts);
 }
 function assertClassDeclaration(node, opts) {
-    assert$1("ClassDeclaration", node, opts);
+    assert("ClassDeclaration", node, opts);
 }
 function assertExportAllDeclaration(node, opts) {
-    assert$1("ExportAllDeclaration", node, opts);
+    assert("ExportAllDeclaration", node, opts);
 }
 function assertExportDefaultDeclaration(node, opts) {
-    assert$1("ExportDefaultDeclaration", node, opts);
+    assert("ExportDefaultDeclaration", node, opts);
 }
 function assertExportNamedDeclaration(node, opts) {
-    assert$1("ExportNamedDeclaration", node, opts);
+    assert("ExportNamedDeclaration", node, opts);
 }
 function assertExportSpecifier(node, opts) {
-    assert$1("ExportSpecifier", node, opts);
+    assert("ExportSpecifier", node, opts);
 }
 function assertForOfStatement(node, opts) {
-    assert$1("ForOfStatement", node, opts);
+    assert("ForOfStatement", node, opts);
 }
 function assertImportDeclaration(node, opts) {
-    assert$1("ImportDeclaration", node, opts);
+    assert("ImportDeclaration", node, opts);
 }
 function assertImportDefaultSpecifier(node, opts) {
-    assert$1("ImportDefaultSpecifier", node, opts);
+    assert("ImportDefaultSpecifier", node, opts);
 }
 function assertImportNamespaceSpecifier(node, opts) {
-    assert$1("ImportNamespaceSpecifier", node, opts);
+    assert("ImportNamespaceSpecifier", node, opts);
 }
 function assertImportSpecifier(node, opts) {
-    assert$1("ImportSpecifier", node, opts);
+    assert("ImportSpecifier", node, opts);
 }
 function assertImportExpression(node, opts) {
-    assert$1("ImportExpression", node, opts);
+    assert("ImportExpression", node, opts);
 }
 function assertMetaProperty(node, opts) {
-    assert$1("MetaProperty", node, opts);
+    assert("MetaProperty", node, opts);
 }
 function assertClassMethod(node, opts) {
-    assert$1("ClassMethod", node, opts);
+    assert("ClassMethod", node, opts);
 }
 function assertObjectPattern(node, opts) {
-    assert$1("ObjectPattern", node, opts);
+    assert("ObjectPattern", node, opts);
 }
 function assertSpreadElement(node, opts) {
-    assert$1("SpreadElement", node, opts);
+    assert("SpreadElement", node, opts);
 }
 function assertSuper(node, opts) {
-    assert$1("Super", node, opts);
+    assert("Super", node, opts);
 }
 function assertTaggedTemplateExpression(node, opts) {
-    assert$1("TaggedTemplateExpression", node, opts);
+    assert("TaggedTemplateExpression", node, opts);
 }
 function assertTemplateElement(node, opts) {
-    assert$1("TemplateElement", node, opts);
+    assert("TemplateElement", node, opts);
 }
 function assertTemplateLiteral(node, opts) {
-    assert$1("TemplateLiteral", node, opts);
+    assert("TemplateLiteral", node, opts);
 }
 function assertYieldExpression(node, opts) {
-    assert$1("YieldExpression", node, opts);
+    assert("YieldExpression", node, opts);
 }
 function assertAwaitExpression(node, opts) {
-    assert$1("AwaitExpression", node, opts);
+    assert("AwaitExpression", node, opts);
 }
 function assertImport(node, opts) {
-    assert$1("Import", node, opts);
+    assert("Import", node, opts);
 }
 function assertBigIntLiteral(node, opts) {
-    assert$1("BigIntLiteral", node, opts);
+    assert("BigIntLiteral", node, opts);
 }
 function assertExportNamespaceSpecifier(node, opts) {
-    assert$1("ExportNamespaceSpecifier", node, opts);
+    assert("ExportNamespaceSpecifier", node, opts);
 }
 function assertOptionalMemberExpression(node, opts) {
-    assert$1("OptionalMemberExpression", node, opts);
+    assert("OptionalMemberExpression", node, opts);
 }
 function assertOptionalCallExpression(node, opts) {
-    assert$1("OptionalCallExpression", node, opts);
+    assert("OptionalCallExpression", node, opts);
 }
 function assertClassProperty(node, opts) {
-    assert$1("ClassProperty", node, opts);
+    assert("ClassProperty", node, opts);
 }
 function assertClassAccessorProperty(node, opts) {
-    assert$1("ClassAccessorProperty", node, opts);
+    assert("ClassAccessorProperty", node, opts);
 }
 function assertClassPrivateProperty(node, opts) {
-    assert$1("ClassPrivateProperty", node, opts);
+    assert("ClassPrivateProperty", node, opts);
 }
 function assertClassPrivateMethod(node, opts) {
-    assert$1("ClassPrivateMethod", node, opts);
+    assert("ClassPrivateMethod", node, opts);
 }
 function assertPrivateName(node, opts) {
-    assert$1("PrivateName", node, opts);
+    assert("PrivateName", node, opts);
 }
 function assertStaticBlock(node, opts) {
-    assert$1("StaticBlock", node, opts);
+    assert("StaticBlock", node, opts);
 }
 function assertAnyTypeAnnotation(node, opts) {
-    assert$1("AnyTypeAnnotation", node, opts);
+    assert("AnyTypeAnnotation", node, opts);
 }
 function assertArrayTypeAnnotation(node, opts) {
-    assert$1("ArrayTypeAnnotation", node, opts);
+    assert("ArrayTypeAnnotation", node, opts);
 }
 function assertBooleanTypeAnnotation(node, opts) {
-    assert$1("BooleanTypeAnnotation", node, opts);
+    assert("BooleanTypeAnnotation", node, opts);
 }
 function assertBooleanLiteralTypeAnnotation(node, opts) {
-    assert$1("BooleanLiteralTypeAnnotation", node, opts);
+    assert("BooleanLiteralTypeAnnotation", node, opts);
 }
 function assertNullLiteralTypeAnnotation(node, opts) {
-    assert$1("NullLiteralTypeAnnotation", node, opts);
+    assert("NullLiteralTypeAnnotation", node, opts);
 }
 function assertClassImplements(node, opts) {
-    assert$1("ClassImplements", node, opts);
+    assert("ClassImplements", node, opts);
 }
 function assertDeclareClass(node, opts) {
-    assert$1("DeclareClass", node, opts);
+    assert("DeclareClass", node, opts);
 }
 function assertDeclareFunction(node, opts) {
-    assert$1("DeclareFunction", node, opts);
+    assert("DeclareFunction", node, opts);
 }
 function assertDeclareInterface(node, opts) {
-    assert$1("DeclareInterface", node, opts);
+    assert("DeclareInterface", node, opts);
 }
 function assertDeclareModule(node, opts) {
-    assert$1("DeclareModule", node, opts);
+    assert("DeclareModule", node, opts);
 }
 function assertDeclareModuleExports(node, opts) {
-    assert$1("DeclareModuleExports", node, opts);
+    assert("DeclareModuleExports", node, opts);
 }
 function assertDeclareTypeAlias(node, opts) {
-    assert$1("DeclareTypeAlias", node, opts);
+    assert("DeclareTypeAlias", node, opts);
 }
 function assertDeclareOpaqueType(node, opts) {
-    assert$1("DeclareOpaqueType", node, opts);
+    assert("DeclareOpaqueType", node, opts);
 }
 function assertDeclareVariable(node, opts) {
-    assert$1("DeclareVariable", node, opts);
+    assert("DeclareVariable", node, opts);
 }
 function assertDeclareExportDeclaration(node, opts) {
-    assert$1("DeclareExportDeclaration", node, opts);
+    assert("DeclareExportDeclaration", node, opts);
 }
 function assertDeclareExportAllDeclaration(node, opts) {
-    assert$1("DeclareExportAllDeclaration", node, opts);
+    assert("DeclareExportAllDeclaration", node, opts);
 }
 function assertDeclaredPredicate(node, opts) {
-    assert$1("DeclaredPredicate", node, opts);
+    assert("DeclaredPredicate", node, opts);
 }
 function assertExistsTypeAnnotation(node, opts) {
-    assert$1("ExistsTypeAnnotation", node, opts);
+    assert("ExistsTypeAnnotation", node, opts);
 }
 function assertFunctionTypeAnnotation(node, opts) {
-    assert$1("FunctionTypeAnnotation", node, opts);
+    assert("FunctionTypeAnnotation", node, opts);
 }
 function assertFunctionTypeParam(node, opts) {
-    assert$1("FunctionTypeParam", node, opts);
+    assert("FunctionTypeParam", node, opts);
 }
 function assertGenericTypeAnnotation(node, opts) {
-    assert$1("GenericTypeAnnotation", node, opts);
+    assert("GenericTypeAnnotation", node, opts);
 }
 function assertInferredPredicate(node, opts) {
-    assert$1("InferredPredicate", node, opts);
+    assert("InferredPredicate", node, opts);
 }
 function assertInterfaceExtends(node, opts) {
-    assert$1("InterfaceExtends", node, opts);
+    assert("InterfaceExtends", node, opts);
 }
 function assertInterfaceDeclaration(node, opts) {
-    assert$1("InterfaceDeclaration", node, opts);
+    assert("InterfaceDeclaration", node, opts);
 }
 function assertInterfaceTypeAnnotation(node, opts) {
-    assert$1("InterfaceTypeAnnotation", node, opts);
+    assert("InterfaceTypeAnnotation", node, opts);
 }
 function assertIntersectionTypeAnnotation(node, opts) {
-    assert$1("IntersectionTypeAnnotation", node, opts);
+    assert("IntersectionTypeAnnotation", node, opts);
 }
 function assertMixedTypeAnnotation(node, opts) {
-    assert$1("MixedTypeAnnotation", node, opts);
+    assert("MixedTypeAnnotation", node, opts);
 }
 function assertEmptyTypeAnnotation(node, opts) {
-    assert$1("EmptyTypeAnnotation", node, opts);
+    assert("EmptyTypeAnnotation", node, opts);
 }
 function assertNullableTypeAnnotation(node, opts) {
-    assert$1("NullableTypeAnnotation", node, opts);
+    assert("NullableTypeAnnotation", node, opts);
 }
 function assertNumberLiteralTypeAnnotation(node, opts) {
-    assert$1("NumberLiteralTypeAnnotation", node, opts);
+    assert("NumberLiteralTypeAnnotation", node, opts);
 }
 function assertNumberTypeAnnotation(node, opts) {
-    assert$1("NumberTypeAnnotation", node, opts);
+    assert("NumberTypeAnnotation", node, opts);
 }
 function assertObjectTypeAnnotation(node, opts) {
-    assert$1("ObjectTypeAnnotation", node, opts);
+    assert("ObjectTypeAnnotation", node, opts);
 }
 function assertObjectTypeInternalSlot(node, opts) {
-    assert$1("ObjectTypeInternalSlot", node, opts);
+    assert("ObjectTypeInternalSlot", node, opts);
 }
 function assertObjectTypeCallProperty(node, opts) {
-    assert$1("ObjectTypeCallProperty", node, opts);
+    assert("ObjectTypeCallProperty", node, opts);
 }
 function assertObjectTypeIndexer(node, opts) {
-    assert$1("ObjectTypeIndexer", node, opts);
+    assert("ObjectTypeIndexer", node, opts);
 }
 function assertObjectTypeProperty(node, opts) {
-    assert$1("ObjectTypeProperty", node, opts);
+    assert("ObjectTypeProperty", node, opts);
 }
 function assertObjectTypeSpreadProperty(node, opts) {
-    assert$1("ObjectTypeSpreadProperty", node, opts);
+    assert("ObjectTypeSpreadProperty", node, opts);
 }
 function assertOpaqueType(node, opts) {
-    assert$1("OpaqueType", node, opts);
+    assert("OpaqueType", node, opts);
 }
 function assertQualifiedTypeIdentifier(node, opts) {
-    assert$1("QualifiedTypeIdentifier", node, opts);
+    assert("QualifiedTypeIdentifier", node, opts);
 }
 function assertStringLiteralTypeAnnotation(node, opts) {
-    assert$1("StringLiteralTypeAnnotation", node, opts);
+    assert("StringLiteralTypeAnnotation", node, opts);
 }
 function assertStringTypeAnnotation(node, opts) {
-    assert$1("StringTypeAnnotation", node, opts);
+    assert("StringTypeAnnotation", node, opts);
 }
 function assertSymbolTypeAnnotation(node, opts) {
-    assert$1("SymbolTypeAnnotation", node, opts);
+    assert("SymbolTypeAnnotation", node, opts);
 }
 function assertThisTypeAnnotation(node, opts) {
-    assert$1("ThisTypeAnnotation", node, opts);
+    assert("ThisTypeAnnotation", node, opts);
 }
 function assertTupleTypeAnnotation(node, opts) {
-    assert$1("TupleTypeAnnotation", node, opts);
+    assert("TupleTypeAnnotation", node, opts);
 }
 function assertTypeofTypeAnnotation(node, opts) {
-    assert$1("TypeofTypeAnnotation", node, opts);
+    assert("TypeofTypeAnnotation", node, opts);
 }
 function assertTypeAlias(node, opts) {
-    assert$1("TypeAlias", node, opts);
+    assert("TypeAlias", node, opts);
 }
 function assertTypeAnnotation(node, opts) {
-    assert$1("TypeAnnotation", node, opts);
+    assert("TypeAnnotation", node, opts);
 }
 function assertTypeCastExpression(node, opts) {
-    assert$1("TypeCastExpression", node, opts);
+    assert("TypeCastExpression", node, opts);
 }
 function assertTypeParameter(node, opts) {
-    assert$1("TypeParameter", node, opts);
+    assert("TypeParameter", node, opts);
 }
 function assertTypeParameterDeclaration(node, opts) {
-    assert$1("TypeParameterDeclaration", node, opts);
+    assert("TypeParameterDeclaration", node, opts);
 }
 function assertTypeParameterInstantiation(node, opts) {
-    assert$1("TypeParameterInstantiation", node, opts);
+    assert("TypeParameterInstantiation", node, opts);
 }
 function assertUnionTypeAnnotation(node, opts) {
-    assert$1("UnionTypeAnnotation", node, opts);
+    assert("UnionTypeAnnotation", node, opts);
 }
 function assertVariance(node, opts) {
-    assert$1("Variance", node, opts);
+    assert("Variance", node, opts);
 }
 function assertVoidTypeAnnotation(node, opts) {
-    assert$1("VoidTypeAnnotation", node, opts);
+    assert("VoidTypeAnnotation", node, opts);
 }
 function assertEnumDeclaration(node, opts) {
-    assert$1("EnumDeclaration", node, opts);
+    assert("EnumDeclaration", node, opts);
 }
 function assertEnumBooleanBody(node, opts) {
-    assert$1("EnumBooleanBody", node, opts);
+    assert("EnumBooleanBody", node, opts);
 }
 function assertEnumNumberBody(node, opts) {
-    assert$1("EnumNumberBody", node, opts);
+    assert("EnumNumberBody", node, opts);
 }
 function assertEnumStringBody(node, opts) {
-    assert$1("EnumStringBody", node, opts);
+    assert("EnumStringBody", node, opts);
 }
 function assertEnumSymbolBody(node, opts) {
-    assert$1("EnumSymbolBody", node, opts);
+    assert("EnumSymbolBody", node, opts);
 }
 function assertEnumBooleanMember(node, opts) {
-    assert$1("EnumBooleanMember", node, opts);
+    assert("EnumBooleanMember", node, opts);
 }
 function assertEnumNumberMember(node, opts) {
-    assert$1("EnumNumberMember", node, opts);
+    assert("EnumNumberMember", node, opts);
 }
 function assertEnumStringMember(node, opts) {
-    assert$1("EnumStringMember", node, opts);
+    assert("EnumStringMember", node, opts);
 }
 function assertEnumDefaultedMember(node, opts) {
-    assert$1("EnumDefaultedMember", node, opts);
+    assert("EnumDefaultedMember", node, opts);
 }
 function assertIndexedAccessType(node, opts) {
-    assert$1("IndexedAccessType", node, opts);
+    assert("IndexedAccessType", node, opts);
 }
 function assertOptionalIndexedAccessType(node, opts) {
-    assert$1("OptionalIndexedAccessType", node, opts);
+    assert("OptionalIndexedAccessType", node, opts);
 }
 function assertJSXAttribute(node, opts) {
-    assert$1("JSXAttribute", node, opts);
+    assert("JSXAttribute", node, opts);
 }
 function assertJSXClosingElement(node, opts) {
-    assert$1("JSXClosingElement", node, opts);
+    assert("JSXClosingElement", node, opts);
 }
 function assertJSXElement(node, opts) {
-    assert$1("JSXElement", node, opts);
+    assert("JSXElement", node, opts);
 }
 function assertJSXEmptyExpression(node, opts) {
-    assert$1("JSXEmptyExpression", node, opts);
+    assert("JSXEmptyExpression", node, opts);
 }
 function assertJSXExpressionContainer(node, opts) {
-    assert$1("JSXExpressionContainer", node, opts);
+    assert("JSXExpressionContainer", node, opts);
 }
 function assertJSXSpreadChild(node, opts) {
-    assert$1("JSXSpreadChild", node, opts);
+    assert("JSXSpreadChild", node, opts);
 }
 function assertJSXIdentifier(node, opts) {
-    assert$1("JSXIdentifier", node, opts);
+    assert("JSXIdentifier", node, opts);
 }
 function assertJSXMemberExpression(node, opts) {
-    assert$1("JSXMemberExpression", node, opts);
+    assert("JSXMemberExpression", node, opts);
 }
 function assertJSXNamespacedName(node, opts) {
-    assert$1("JSXNamespacedName", node, opts);
+    assert("JSXNamespacedName", node, opts);
 }
 function assertJSXOpeningElement(node, opts) {
-    assert$1("JSXOpeningElement", node, opts);
+    assert("JSXOpeningElement", node, opts);
 }
 function assertJSXSpreadAttribute(node, opts) {
-    assert$1("JSXSpreadAttribute", node, opts);
+    assert("JSXSpreadAttribute", node, opts);
 }
 function assertJSXText(node, opts) {
-    assert$1("JSXText", node, opts);
+    assert("JSXText", node, opts);
 }
 function assertJSXFragment(node, opts) {
-    assert$1("JSXFragment", node, opts);
+    assert("JSXFragment", node, opts);
 }
 function assertJSXOpeningFragment(node, opts) {
-    assert$1("JSXOpeningFragment", node, opts);
+    assert("JSXOpeningFragment", node, opts);
 }
 function assertJSXClosingFragment(node, opts) {
-    assert$1("JSXClosingFragment", node, opts);
+    assert("JSXClosingFragment", node, opts);
 }
 function assertNoop(node, opts) {
-    assert$1("Noop", node, opts);
+    assert("Noop", node, opts);
 }
 function assertPlaceholder(node, opts) {
-    assert$1("Placeholder", node, opts);
+    assert("Placeholder", node, opts);
 }
 function assertV8IntrinsicIdentifier(node, opts) {
-    assert$1("V8IntrinsicIdentifier", node, opts);
+    assert("V8IntrinsicIdentifier", node, opts);
 }
 function assertArgumentPlaceholder(node, opts) {
-    assert$1("ArgumentPlaceholder", node, opts);
+    assert("ArgumentPlaceholder", node, opts);
 }
 function assertBindExpression(node, opts) {
-    assert$1("BindExpression", node, opts);
+    assert("BindExpression", node, opts);
 }
 function assertImportAttribute(node, opts) {
-    assert$1("ImportAttribute", node, opts);
+    assert("ImportAttribute", node, opts);
 }
 function assertDecorator(node, opts) {
-    assert$1("Decorator", node, opts);
+    assert("Decorator", node, opts);
 }
 function assertDoExpression(node, opts) {
-    assert$1("DoExpression", node, opts);
+    assert("DoExpression", node, opts);
 }
 function assertExportDefaultSpecifier(node, opts) {
-    assert$1("ExportDefaultSpecifier", node, opts);
+    assert("ExportDefaultSpecifier", node, opts);
 }
 function assertRecordExpression(node, opts) {
-    assert$1("RecordExpression", node, opts);
+    assert("RecordExpression", node, opts);
 }
 function assertTupleExpression(node, opts) {
-    assert$1("TupleExpression", node, opts);
+    assert("TupleExpression", node, opts);
 }
 function assertDecimalLiteral(node, opts) {
-    assert$1("DecimalLiteral", node, opts);
+    assert("DecimalLiteral", node, opts);
 }
 function assertModuleExpression(node, opts) {
-    assert$1("ModuleExpression", node, opts);
+    assert("ModuleExpression", node, opts);
 }
 function assertTopicReference(node, opts) {
-    assert$1("TopicReference", node, opts);
+    assert("TopicReference", node, opts);
 }
 function assertPipelineTopicExpression(node, opts) {
-    assert$1("PipelineTopicExpression", node, opts);
+    assert("PipelineTopicExpression", node, opts);
 }
 function assertPipelineBareFunction(node, opts) {
-    assert$1("PipelineBareFunction", node, opts);
+    assert("PipelineBareFunction", node, opts);
 }
 function assertPipelinePrimaryTopicReference(node, opts) {
-    assert$1("PipelinePrimaryTopicReference", node, opts);
+    assert("PipelinePrimaryTopicReference", node, opts);
 }
 function assertTSParameterProperty(node, opts) {
-    assert$1("TSParameterProperty", node, opts);
+    assert("TSParameterProperty", node, opts);
 }
 function assertTSDeclareFunction(node, opts) {
-    assert$1("TSDeclareFunction", node, opts);
+    assert("TSDeclareFunction", node, opts);
 }
 function assertTSDeclareMethod(node, opts) {
-    assert$1("TSDeclareMethod", node, opts);
+    assert("TSDeclareMethod", node, opts);
 }
 function assertTSQualifiedName(node, opts) {
-    assert$1("TSQualifiedName", node, opts);
+    assert("TSQualifiedName", node, opts);
 }
 function assertTSCallSignatureDeclaration(node, opts) {
-    assert$1("TSCallSignatureDeclaration", node, opts);
+    assert("TSCallSignatureDeclaration", node, opts);
 }
 function assertTSConstructSignatureDeclaration(node, opts) {
-    assert$1("TSConstructSignatureDeclaration", node, opts);
+    assert("TSConstructSignatureDeclaration", node, opts);
 }
 function assertTSPropertySignature(node, opts) {
-    assert$1("TSPropertySignature", node, opts);
+    assert("TSPropertySignature", node, opts);
 }
 function assertTSMethodSignature(node, opts) {
-    assert$1("TSMethodSignature", node, opts);
+    assert("TSMethodSignature", node, opts);
 }
 function assertTSIndexSignature(node, opts) {
-    assert$1("TSIndexSignature", node, opts);
+    assert("TSIndexSignature", node, opts);
 }
 function assertTSAnyKeyword(node, opts) {
-    assert$1("TSAnyKeyword", node, opts);
+    assert("TSAnyKeyword", node, opts);
 }
 function assertTSBooleanKeyword(node, opts) {
-    assert$1("TSBooleanKeyword", node, opts);
+    assert("TSBooleanKeyword", node, opts);
 }
 function assertTSBigIntKeyword(node, opts) {
-    assert$1("TSBigIntKeyword", node, opts);
+    assert("TSBigIntKeyword", node, opts);
 }
 function assertTSIntrinsicKeyword(node, opts) {
-    assert$1("TSIntrinsicKeyword", node, opts);
+    assert("TSIntrinsicKeyword", node, opts);
 }
 function assertTSNeverKeyword(node, opts) {
-    assert$1("TSNeverKeyword", node, opts);
+    assert("TSNeverKeyword", node, opts);
 }
 function assertTSNullKeyword(node, opts) {
-    assert$1("TSNullKeyword", node, opts);
+    assert("TSNullKeyword", node, opts);
 }
 function assertTSNumberKeyword(node, opts) {
-    assert$1("TSNumberKeyword", node, opts);
+    assert("TSNumberKeyword", node, opts);
 }
 function assertTSObjectKeyword(node, opts) {
-    assert$1("TSObjectKeyword", node, opts);
+    assert("TSObjectKeyword", node, opts);
 }
 function assertTSStringKeyword(node, opts) {
-    assert$1("TSStringKeyword", node, opts);
+    assert("TSStringKeyword", node, opts);
 }
 function assertTSSymbolKeyword(node, opts) {
-    assert$1("TSSymbolKeyword", node, opts);
+    assert("TSSymbolKeyword", node, opts);
 }
 function assertTSUndefinedKeyword(node, opts) {
-    assert$1("TSUndefinedKeyword", node, opts);
+    assert("TSUndefinedKeyword", node, opts);
 }
 function assertTSUnknownKeyword(node, opts) {
-    assert$1("TSUnknownKeyword", node, opts);
+    assert("TSUnknownKeyword", node, opts);
 }
 function assertTSVoidKeyword(node, opts) {
-    assert$1("TSVoidKeyword", node, opts);
+    assert("TSVoidKeyword", node, opts);
 }
 function assertTSThisType(node, opts) {
-    assert$1("TSThisType", node, opts);
+    assert("TSThisType", node, opts);
 }
 function assertTSFunctionType(node, opts) {
-    assert$1("TSFunctionType", node, opts);
+    assert("TSFunctionType", node, opts);
 }
 function assertTSConstructorType(node, opts) {
-    assert$1("TSConstructorType", node, opts);
+    assert("TSConstructorType", node, opts);
 }
 function assertTSTypeReference(node, opts) {
-    assert$1("TSTypeReference", node, opts);
+    assert("TSTypeReference", node, opts);
 }
 function assertTSTypePredicate(node, opts) {
-    assert$1("TSTypePredicate", node, opts);
+    assert("TSTypePredicate", node, opts);
 }
 function assertTSTypeQuery(node, opts) {
-    assert$1("TSTypeQuery", node, opts);
+    assert("TSTypeQuery", node, opts);
 }
 function assertTSTypeLiteral(node, opts) {
-    assert$1("TSTypeLiteral", node, opts);
+    assert("TSTypeLiteral", node, opts);
 }
 function assertTSArrayType(node, opts) {
-    assert$1("TSArrayType", node, opts);
+    assert("TSArrayType", node, opts);
 }
 function assertTSTupleType(node, opts) {
-    assert$1("TSTupleType", node, opts);
+    assert("TSTupleType", node, opts);
 }
 function assertTSOptionalType(node, opts) {
-    assert$1("TSOptionalType", node, opts);
+    assert("TSOptionalType", node, opts);
 }
 function assertTSRestType(node, opts) {
-    assert$1("TSRestType", node, opts);
+    assert("TSRestType", node, opts);
 }
 function assertTSNamedTupleMember(node, opts) {
-    assert$1("TSNamedTupleMember", node, opts);
+    assert("TSNamedTupleMember", node, opts);
 }
 function assertTSUnionType(node, opts) {
-    assert$1("TSUnionType", node, opts);
+    assert("TSUnionType", node, opts);
 }
 function assertTSIntersectionType(node, opts) {
-    assert$1("TSIntersectionType", node, opts);
+    assert("TSIntersectionType", node, opts);
 }
 function assertTSConditionalType(node, opts) {
-    assert$1("TSConditionalType", node, opts);
+    assert("TSConditionalType", node, opts);
 }
 function assertTSInferType(node, opts) {
-    assert$1("TSInferType", node, opts);
+    assert("TSInferType", node, opts);
 }
 function assertTSParenthesizedType(node, opts) {
-    assert$1("TSParenthesizedType", node, opts);
+    assert("TSParenthesizedType", node, opts);
 }
 function assertTSTypeOperator(node, opts) {
-    assert$1("TSTypeOperator", node, opts);
+    assert("TSTypeOperator", node, opts);
 }
 function assertTSIndexedAccessType(node, opts) {
-    assert$1("TSIndexedAccessType", node, opts);
+    assert("TSIndexedAccessType", node, opts);
 }
 function assertTSMappedType(node, opts) {
-    assert$1("TSMappedType", node, opts);
+    assert("TSMappedType", node, opts);
 }
 function assertTSLiteralType(node, opts) {
-    assert$1("TSLiteralType", node, opts);
+    assert("TSLiteralType", node, opts);
 }
 function assertTSExpressionWithTypeArguments(node, opts) {
-    assert$1("TSExpressionWithTypeArguments", node, opts);
+    assert("TSExpressionWithTypeArguments", node, opts);
 }
 function assertTSInterfaceDeclaration(node, opts) {
-    assert$1("TSInterfaceDeclaration", node, opts);
+    assert("TSInterfaceDeclaration", node, opts);
 }
 function assertTSInterfaceBody(node, opts) {
-    assert$1("TSInterfaceBody", node, opts);
+    assert("TSInterfaceBody", node, opts);
 }
 function assertTSTypeAliasDeclaration(node, opts) {
-    assert$1("TSTypeAliasDeclaration", node, opts);
+    assert("TSTypeAliasDeclaration", node, opts);
 }
 function assertTSInstantiationExpression(node, opts) {
-    assert$1("TSInstantiationExpression", node, opts);
+    assert("TSInstantiationExpression", node, opts);
 }
 function assertTSAsExpression(node, opts) {
-    assert$1("TSAsExpression", node, opts);
+    assert("TSAsExpression", node, opts);
 }
 function assertTSSatisfiesExpression(node, opts) {
-    assert$1("TSSatisfiesExpression", node, opts);
+    assert("TSSatisfiesExpression", node, opts);
 }
 function assertTSTypeAssertion(node, opts) {
-    assert$1("TSTypeAssertion", node, opts);
+    assert("TSTypeAssertion", node, opts);
 }
 function assertTSEnumDeclaration(node, opts) {
-    assert$1("TSEnumDeclaration", node, opts);
+    assert("TSEnumDeclaration", node, opts);
 }
 function assertTSEnumMember(node, opts) {
-    assert$1("TSEnumMember", node, opts);
+    assert("TSEnumMember", node, opts);
 }
 function assertTSModuleDeclaration(node, opts) {
-    assert$1("TSModuleDeclaration", node, opts);
+    assert("TSModuleDeclaration", node, opts);
 }
 function assertTSModuleBlock(node, opts) {
-    assert$1("TSModuleBlock", node, opts);
+    assert("TSModuleBlock", node, opts);
 }
 function assertTSImportType(node, opts) {
-    assert$1("TSImportType", node, opts);
+    assert("TSImportType", node, opts);
 }
 function assertTSImportEqualsDeclaration(node, opts) {
-    assert$1("TSImportEqualsDeclaration", node, opts);
+    assert("TSImportEqualsDeclaration", node, opts);
 }
 function assertTSExternalModuleReference(node, opts) {
-    assert$1("TSExternalModuleReference", node, opts);
+    assert("TSExternalModuleReference", node, opts);
 }
 function assertTSNonNullExpression(node, opts) {
-    assert$1("TSNonNullExpression", node, opts);
+    assert("TSNonNullExpression", node, opts);
 }
 function assertTSExportAssignment(node, opts) {
-    assert$1("TSExportAssignment", node, opts);
+    assert("TSExportAssignment", node, opts);
 }
 function assertTSNamespaceExportDeclaration(node, opts) {
-    assert$1("TSNamespaceExportDeclaration", node, opts);
+    assert("TSNamespaceExportDeclaration", node, opts);
 }
 function assertTSTypeAnnotation(node, opts) {
-    assert$1("TSTypeAnnotation", node, opts);
+    assert("TSTypeAnnotation", node, opts);
 }
 function assertTSTypeParameterInstantiation(node, opts) {
-    assert$1("TSTypeParameterInstantiation", node, opts);
+    assert("TSTypeParameterInstantiation", node, opts);
 }
 function assertTSTypeParameterDeclaration(node, opts) {
-    assert$1("TSTypeParameterDeclaration", node, opts);
+    assert("TSTypeParameterDeclaration", node, opts);
 }
 function assertTSTypeParameter(node, opts) {
-    assert$1("TSTypeParameter", node, opts);
+    assert("TSTypeParameter", node, opts);
 }
 function assertStandardized(node, opts) {
-    assert$1("Standardized", node, opts);
+    assert("Standardized", node, opts);
 }
 function assertExpression(node, opts) {
-    assert$1("Expression", node, opts);
+    assert("Expression", node, opts);
 }
 function assertBinary(node, opts) {
-    assert$1("Binary", node, opts);
+    assert("Binary", node, opts);
 }
 function assertScopable(node, opts) {
-    assert$1("Scopable", node, opts);
+    assert("Scopable", node, opts);
 }
 function assertBlockParent(node, opts) {
-    assert$1("BlockParent", node, opts);
+    assert("BlockParent", node, opts);
 }
 function assertBlock(node, opts) {
-    assert$1("Block", node, opts);
+    assert("Block", node, opts);
 }
 function assertStatement(node, opts) {
-    assert$1("Statement", node, opts);
+    assert("Statement", node, opts);
 }
 function assertTerminatorless(node, opts) {
-    assert$1("Terminatorless", node, opts);
+    assert("Terminatorless", node, opts);
 }
 function assertCompletionStatement(node, opts) {
-    assert$1("CompletionStatement", node, opts);
+    assert("CompletionStatement", node, opts);
 }
 function assertConditional(node, opts) {
-    assert$1("Conditional", node, opts);
+    assert("Conditional", node, opts);
 }
 function assertLoop(node, opts) {
-    assert$1("Loop", node, opts);
+    assert("Loop", node, opts);
 }
 function assertWhile(node, opts) {
-    assert$1("While", node, opts);
+    assert("While", node, opts);
 }
 function assertExpressionWrapper(node, opts) {
-    assert$1("ExpressionWrapper", node, opts);
+    assert("ExpressionWrapper", node, opts);
 }
 function assertFor(node, opts) {
-    assert$1("For", node, opts);
+    assert("For", node, opts);
 }
 function assertForXStatement(node, opts) {
-    assert$1("ForXStatement", node, opts);
+    assert("ForXStatement", node, opts);
 }
 function assertFunction(node, opts) {
-    assert$1("Function", node, opts);
+    assert("Function", node, opts);
 }
 function assertFunctionParent(node, opts) {
-    assert$1("FunctionParent", node, opts);
+    assert("FunctionParent", node, opts);
 }
 function assertPureish(node, opts) {
-    assert$1("Pureish", node, opts);
+    assert("Pureish", node, opts);
 }
 function assertDeclaration(node, opts) {
-    assert$1("Declaration", node, opts);
+    assert("Declaration", node, opts);
 }
 function assertPatternLike(node, opts) {
-    assert$1("PatternLike", node, opts);
+    assert("PatternLike", node, opts);
 }
 function assertLVal(node, opts) {
-    assert$1("LVal", node, opts);
+    assert("LVal", node, opts);
 }
 function assertTSEntityName(node, opts) {
-    assert$1("TSEntityName", node, opts);
+    assert("TSEntityName", node, opts);
 }
 function assertLiteral(node, opts) {
-    assert$1("Literal", node, opts);
+    assert("Literal", node, opts);
 }
 function assertImmutable(node, opts) {
-    assert$1("Immutable", node, opts);
+    assert("Immutable", node, opts);
 }
 function assertUserWhitespacable(node, opts) {
-    assert$1("UserWhitespacable", node, opts);
+    assert("UserWhitespacable", node, opts);
 }
 function assertMethod(node, opts) {
-    assert$1("Method", node, opts);
+    assert("Method", node, opts);
 }
 function assertObjectMember(node, opts) {
-    assert$1("ObjectMember", node, opts);
+    assert("ObjectMember", node, opts);
 }
 function assertProperty(node, opts) {
-    assert$1("Property", node, opts);
+    assert("Property", node, opts);
 }
 function assertUnaryLike(node, opts) {
-    assert$1("UnaryLike", node, opts);
+    assert("UnaryLike", node, opts);
 }
 function assertPattern(node, opts) {
-    assert$1("Pattern", node, opts);
+    assert("Pattern", node, opts);
 }
 function assertClass(node, opts) {
-    assert$1("Class", node, opts);
+    assert("Class", node, opts);
 }
 function assertImportOrExportDeclaration(node, opts) {
-    assert$1("ImportOrExportDeclaration", node, opts);
+    assert("ImportOrExportDeclaration", node, opts);
 }
 function assertExportDeclaration(node, opts) {
-    assert$1("ExportDeclaration", node, opts);
+    assert("ExportDeclaration", node, opts);
 }
 function assertModuleSpecifier(node, opts) {
-    assert$1("ModuleSpecifier", node, opts);
+    assert("ModuleSpecifier", node, opts);
 }
 function assertAccessor(node, opts) {
-    assert$1("Accessor", node, opts);
+    assert("Accessor", node, opts);
 }
 function assertPrivate(node, opts) {
-    assert$1("Private", node, opts);
+    assert("Private", node, opts);
 }
 function assertFlow(node, opts) {
-    assert$1("Flow", node, opts);
+    assert("Flow", node, opts);
 }
 function assertFlowType(node, opts) {
-    assert$1("FlowType", node, opts);
+    assert("FlowType", node, opts);
 }
 function assertFlowBaseAnnotation(node, opts) {
-    assert$1("FlowBaseAnnotation", node, opts);
+    assert("FlowBaseAnnotation", node, opts);
 }
 function assertFlowDeclaration(node, opts) {
-    assert$1("FlowDeclaration", node, opts);
+    assert("FlowDeclaration", node, opts);
 }
 function assertFlowPredicate(node, opts) {
-    assert$1("FlowPredicate", node, opts);
+    assert("FlowPredicate", node, opts);
 }
 function assertEnumBody(node, opts) {
-    assert$1("EnumBody", node, opts);
+    assert("EnumBody", node, opts);
 }
 function assertEnumMember(node, opts) {
-    assert$1("EnumMember", node, opts);
+    assert("EnumMember", node, opts);
 }
 function assertJSX(node, opts) {
-    assert$1("JSX", node, opts);
+    assert("JSX", node, opts);
 }
 function assertMiscellaneous(node, opts) {
-    assert$1("Miscellaneous", node, opts);
+    assert("Miscellaneous", node, opts);
 }
 function assertTypeScript(node, opts) {
-    assert$1("TypeScript", node, opts);
+    assert("TypeScript", node, opts);
 }
 function assertTSTypeElement(node, opts) {
-    assert$1("TSTypeElement", node, opts);
+    assert("TSTypeElement", node, opts);
 }
 function assertTSType(node, opts) {
-    assert$1("TSType", node, opts);
+    assert("TSType", node, opts);
 }
 function assertTSBaseType(node, opts) {
-    assert$1("TSBaseType", node, opts);
+    assert("TSBaseType", node, opts);
 }
 function assertNumberLiteral(node, opts) {
     deprecationWarning("assertNumberLiteral", "assertNumericLiteral");
-    assert$1("NumberLiteral", node, opts);
+    assert("NumberLiteral", node, opts);
 }
 function assertRegexLiteral(node, opts) {
     deprecationWarning("assertRegexLiteral", "assertRegExpLiteral");
-    assert$1("RegexLiteral", node, opts);
+    assert("RegexLiteral", node, opts);
 }
 function assertRestProperty(node, opts) {
     deprecationWarning("assertRestProperty", "assertRestElement");
-    assert$1("RestProperty", node, opts);
+    assert("RestProperty", node, opts);
 }
 function assertSpreadProperty(node, opts) {
     deprecationWarning("assertSpreadProperty", "assertSpreadElement");
-    assert$1("SpreadProperty", node, opts);
+    assert("SpreadProperty", node, opts);
 }
 function assertModuleDeclaration(node, opts) {
     deprecationWarning("assertModuleDeclaration", "assertImportOrExportDeclaration");
-    assert$1("ModuleDeclaration", node, opts);
+    assert("ModuleDeclaration", node, opts);
 }
 function createTypeAnnotationBasedOnTypeof(type) {
     switch(type){
@@ -23414,7 +23414,7 @@ function createTSUnionType(typeAnnotations) {
 function buildUndefinedNode() {
     return unaryExpression$1("void", numericLiteral(0), true);
 }
-var hasOwn$1 = Object.hasOwn;
+var hasOwn = Object.hasOwn;
 function cloneIfNode(obj, deep, withoutLoc, commentsCache) {
     if (obj && typeof obj.type === "string") {
         return cloneNodeInternal(obj, deep, withoutLoc, commentsCache);
@@ -23442,20 +23442,20 @@ function cloneNodeInternal(node) {
     };
     if (isIdentifier$a(node)) {
         newNode.name = node.name;
-        if (hasOwn$1(node, "optional") && typeof node.optional === "boolean") {
+        if (hasOwn(node, "optional") && typeof node.optional === "boolean") {
             newNode.optional = node.optional;
         }
-        if (hasOwn$1(node, "typeAnnotation")) {
+        if (hasOwn(node, "typeAnnotation")) {
             newNode.typeAnnotation = deep ? cloneIfNodeOrArray(node.typeAnnotation, true, withoutLoc, commentsCache) : node.typeAnnotation;
         }
-    } else if (!hasOwn$1(NODE_FIELDS, type)) {
+    } else if (!hasOwn(NODE_FIELDS, type)) {
         throw new Error('Unknown node type: "'.concat(type, '"'));
     } else {
         var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
         try {
             for(var _iterator = Object.keys(NODE_FIELDS[type])[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                 var field = _step.value;
-                if (hasOwn$1(node, field)) {
+                if (hasOwn(node, field)) {
                     if (deep) {
                         newNode[field] = isFile$2(node) && field === "comments" ? maybeCloneComments(node.comments, deep, withoutLoc, commentsCache) : cloneIfNodeOrArray(node[field], true, withoutLoc, commentsCache);
                     } else {
@@ -23478,23 +23478,23 @@ function cloneNodeInternal(node) {
             }
         }
     }
-    if (hasOwn$1(node, "loc")) {
+    if (hasOwn(node, "loc")) {
         if (withoutLoc) {
             newNode.loc = null;
         } else {
             newNode.loc = node.loc;
         }
     }
-    if (hasOwn$1(node, "leadingComments")) {
+    if (hasOwn(node, "leadingComments")) {
         newNode.leadingComments = maybeCloneComments(node.leadingComments, deep, withoutLoc, commentsCache);
     }
-    if (hasOwn$1(node, "innerComments")) {
+    if (hasOwn(node, "innerComments")) {
         newNode.innerComments = maybeCloneComments(node.innerComments, deep, withoutLoc, commentsCache);
     }
-    if (hasOwn$1(node, "trailingComments")) {
+    if (hasOwn(node, "trailingComments")) {
         newNode.trailingComments = maybeCloneComments(node.trailingComments, deep, withoutLoc, commentsCache);
     }
-    if (hasOwn$1(node, "extra")) {
+    if (hasOwn(node, "extra")) {
         newNode.extra = Object.assign({}, node.extra);
     }
     return newNode;
@@ -23700,7 +23700,7 @@ function toComputedKey(node) {
     return key;
 }
 function toExpression$1(node) {
-    if (isExpressionStatement$2(node)) {
+    if (isExpressionStatement$1(node)) {
         node = node.expression;
     }
     if (isExpression$2(node)) {
@@ -25483,7 +25483,7 @@ var TokContext = function TokContext(token, preserveSpace) {
     this.token = token;
     this.preserveSpace = !!preserveSpace;
 };
-var types$t = {
+var types$s = {
     brace: new TokContext("{"),
     j_oTag: new TokContext("<tag"),
     j_cTag: new TokContext("</tag"),
@@ -27639,7 +27639,7 @@ var State$2 = /*#__PURE__*/ function() {
         __publicField(this, "lastTokEndLoc", null);
         __publicField(this, "lastTokStartLoc", null);
         __publicField(this, "context", [
-            types$t.brace
+            types$s.brace
         ]);
         __publicField(this, "firstInvalidTemplateEscapePos", null);
         __publicField(this, "strictErrors", /* @__PURE__ */ new Map());
@@ -32250,7 +32250,7 @@ var flow$1 = function(superClass) {
                         if (!jsx2.error) return jsx2.node;
                         var context = this.state.context;
                         var currentContext = context[context.length - 1];
-                        if (currentContext === types$t.j_oTag || currentContext === types$t.j_expr) {
+                        if (currentContext === types$s.j_oTag || currentContext === types$s.j_expr) {
                             context.pop();
                         }
                     }
@@ -33467,9 +33467,9 @@ var jsx$3 = function(superClass) {
                     switch(this.state.type){
                         case 5:
                             node = this.startNode();
-                            this.setContext(types$t.brace);
+                            this.setContext(types$s.brace);
                             this.next();
-                            node = this.jsxParseExpressionContainer(node, types$t.j_oTag);
+                            node = this.jsxParseExpressionContainer(node, types$s.j_oTag);
                             if (node.expression.type === "JSXEmptyExpression") {
                                 this.raise(JsxErrors.AttributeIsEmpty, node);
                             }
@@ -33494,7 +33494,7 @@ var jsx$3 = function(superClass) {
                 value: function jsxParseSpreadChild(node) {
                     this.next();
                     node.expression = this.parseExpression();
-                    this.setContext(types$t.j_expr);
+                    this.setContext(types$s.j_expr);
                     this.state.canStartJSXElement = true;
                     this.expect(8);
                     return this.finishNode(node, "JSXSpreadChild");
@@ -33526,11 +33526,11 @@ var jsx$3 = function(superClass) {
                 value: function jsxParseAttribute() {
                     var node = this.startNode();
                     if (this.match(5)) {
-                        this.setContext(types$t.brace);
+                        this.setContext(types$s.brace);
                         this.next();
                         this.expect(21);
                         node.argument = this.parseMaybeAssignAllowIn();
-                        this.setContext(types$t.j_oTag);
+                        this.setContext(types$s.j_oTag);
                         this.state.canStartJSXElement = true;
                         this.expect(8);
                         return this.finishNode(node, "JSXSpreadAttribute");
@@ -33601,12 +33601,12 @@ var jsx$3 = function(superClass) {
                                 case 5:
                                     {
                                         var node2 = this.startNode();
-                                        this.setContext(types$t.brace);
+                                        this.setContext(types$s.brace);
                                         this.next();
                                         if (this.match(21)) {
                                             children.push(this.jsxParseSpreadChild(node2));
                                         } else {
-                                            children.push(this.jsxParseExpressionContainer(node2, types$t.j_expr));
+                                            children.push(this.jsxParseExpressionContainer(node2, types$s.j_expr));
                                         }
                                         break;
                                     }
@@ -33683,11 +33683,11 @@ var jsx$3 = function(superClass) {
                 key: "getTokenFromCode",
                 value: function getTokenFromCode(code2) {
                     var context = this.curContext();
-                    if (context === types$t.j_expr) {
+                    if (context === types$s.j_expr) {
                         this.jsxReadToken();
                         return;
                     }
-                    if (context === types$t.j_oTag || context === types$t.j_cTag) {
+                    if (context === types$s.j_oTag || context === types$s.j_cTag) {
                         if (isIdentifierStart2(code2)) {
                             this.jsxReadWord();
                             return;
@@ -33697,7 +33697,7 @@ var jsx$3 = function(superClass) {
                             this.finishToken(143);
                             return;
                         }
-                        if ((code2 === 34 || code2 === 39) && context === types$t.j_oTag) {
+                        if ((code2 === 34 || code2 === 39) && context === types$s.j_oTag) {
                             this.jsxReadString(code2);
                             return;
                         }
@@ -33715,17 +33715,17 @@ var jsx$3 = function(superClass) {
                 value: function updateContext(prevType) {
                     var _this_state = this.state, context = _this_state.context, type = _this_state.type;
                     if (type === 56 && prevType === 142) {
-                        context.splice(-2, 2, types$t.j_cTag);
+                        context.splice(-2, 2, types$s.j_cTag);
                         this.state.canStartJSXElement = false;
                     } else if (type === 142) {
-                        context.push(types$t.j_oTag);
+                        context.push(types$s.j_oTag);
                     } else if (type === 143) {
                         var out = context[context.length - 1];
-                        if (out === types$t.j_oTag && prevType === 56 || out === types$t.j_cTag) {
+                        if (out === types$s.j_oTag && prevType === 56 || out === types$s.j_cTag) {
                             context.pop();
-                            this.state.canStartJSXElement = context[context.length - 1] === types$t.j_expr;
+                            this.state.canStartJSXElement = context[context.length - 1] === types$s.j_expr;
                         } else {
-                            this.setContext(types$t.j_expr);
+                            this.setContext(types$s.j_expr);
                             this.state.canStartJSXElement = true;
                         }
                     } else {
@@ -36218,7 +36218,7 @@ var typescript$3 = function(superClass) {
                     });
                     if (node.params.length === 0) {
                         this.raise(TSErrors.EmptyTypeArguments, node);
-                    } else if (!this.state.inType && this.curContext() === types$t.brace) {
+                    } else if (!this.state.inType && this.curContext() === types$s.brace) {
                         this.reScan_lt_gt();
                     }
                     this.expect(48);
@@ -37026,7 +37026,7 @@ var typescript$3 = function(superClass) {
                         if (!jsx2.error) return jsx2.node;
                         var context = this.state.context;
                         var currentContext = context[context.length - 1];
-                        if (currentContext === types$t.j_oTag || currentContext === types$t.j_expr) {
+                        if (currentContext === types$s.j_oTag || currentContext === types$s.j_expr) {
                             context.pop();
                         }
                     }
@@ -42623,7 +42623,7 @@ function pluginsMap(plugins) {
     }
     return pluginMap;
 }
-function parse$5(input, options) {
+function parse$6(input, options) {
     if ((options === null || options === void 0 ? void 0 : options.sourceType) === "unambiguous") {
         options = Object.assign({}, options);
         try {
@@ -42653,7 +42653,7 @@ function parse$5(input, options) {
         return getParser$1(options, input).parse();
     }
 }
-function parseExpression$1(input, options) {
+function parseExpression(input, options) {
     var parser = getParser$1(options, input);
     if (parser.options.strictMode) {
         parser.state.strict = true;
@@ -43408,7 +43408,7 @@ function parseWithCodeFrame(code2, parserOpts, syntacticPlaceholders) {
         plugins: plugins
     });
     try {
-        return parse$5(code2, parserOpts);
+        return parse$6(code2, parserOpts);
     } catch (err) {
         var loc = err.loc;
         if (loc) {
@@ -52474,7 +52474,7 @@ function replaceWithSourceString(replacement) {
     var ast;
     try {
         replacement = "(".concat(replacement, ")");
-        ast = parse$5(replacement);
+        ast = parse$6(replacement);
     } catch (err) {
         var loc = err.loc;
         if (loc) {
@@ -56317,7 +56317,7 @@ var main = {};
 
 var fork = {exports: {}};
 
-var types$s = {exports: {}};
+var types$r = {exports: {}};
 
 var shared = {};
 
@@ -56417,12 +56417,12 @@ function requireShared () {
 	return shared;
 }
 
-types$s.exports;
+types$r.exports;
 
 var hasRequiredTypes;
 
 function requireTypes () {
-	if (hasRequiredTypes) return types$s.exports;
+	if (hasRequiredTypes) return types$r.exports;
 	hasRequiredTypes = 1;
 	(function (module, exports) {
 		Object.defineProperty(exports, "__esModule", { value: true });
@@ -57214,8 +57214,8 @@ function requireTypes () {
 		exports.default = typesPlugin;
 		(0, shared_1.maybeSetModuleExports)(function () { return module; });
 		
-	} (types$s, types$s.exports));
-	return types$s.exports;
+	} (types$r, types$r.exports));
+	return types$r.exports;
 }
 
 var pathVisitor = {exports: {}};
@@ -61323,487 +61323,31 @@ function requireMain () {
 
 var parser$5 = {};
 
-function compare$6(a, b) {
-  if (a === b) {
-    return 0;
-  }
-
-  var x = a.length;
-  var y = b.length;
-
-  for (var i = 0, len = Math.min(x, y); i < len; ++i) {
-    if (a[i] !== b[i]) {
-      x = a[i];
-      y = b[i];
-      break;
-    }
-  }
-
-  if (x < y) {
-    return -1;
-  }
-  if (y < x) {
-    return 1;
-  }
-  return 0;
-}
-var hasOwn = Object.prototype.hasOwnProperty;
-
-var objectKeys = Object.keys || function (obj) {
-  var keys = [];
-  for (var key in obj) {
-    if (hasOwn.call(obj, key)) keys.push(key);
-  }
-  return keys;
-};
-var pSlice = Array.prototype.slice;
-var _functionsHaveNames;
-function functionsHaveNames() {
-  if (typeof _functionsHaveNames !== 'undefined') {
-    return _functionsHaveNames;
-  }
-  return _functionsHaveNames = (function () {
-    return function foo() {}.name === 'foo';
-  }());
-}
-function pToString (obj) {
-  return Object.prototype.toString.call(obj);
-}
-function isView(arrbuf) {
-  if (isBuffer$1(arrbuf)) {
-    return false;
-  }
-  if (typeof global$1.ArrayBuffer !== 'function') {
-    return false;
-  }
-  if (typeof ArrayBuffer.isView === 'function') {
-    return ArrayBuffer.isView(arrbuf);
-  }
-  if (!arrbuf) {
-    return false;
-  }
-  if (arrbuf instanceof DataView) {
-    return true;
-  }
-  if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {
-    return true;
-  }
-  return false;
-}
-// 1. The assert module provides functions that throw
-// AssertionError's when particular conditions are not met. The
-// assert module must conform to the following interface.
-
-function assert(value, message) {
-  if (!value) fail(value, true, message, '==', ok);
-}
-
-// 2. The AssertionError is defined in assert.
-// new assert.AssertionError({ message: message,
-//                             actual: actual,
-//                             expected: expected })
-
-var regex = /\s*function\s+([^\(\s]*)\s*/;
-// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js
-function getName(func) {
-  if (!isFunction$3(func)) {
-    return;
-  }
-  if (functionsHaveNames()) {
-    return func.name;
-  }
-  var str = func.toString();
-  var match = str.match(regex);
-  return match && match[1];
-}
-assert.AssertionError = AssertionError;
-function AssertionError(options) {
-  this.name = 'AssertionError';
-  this.actual = options.actual;
-  this.expected = options.expected;
-  this.operator = options.operator;
-  if (options.message) {
-    this.message = options.message;
-    this.generatedMessage = false;
-  } else {
-    this.message = getMessage(this);
-    this.generatedMessage = true;
-  }
-  var stackStartFunction = options.stackStartFunction || fail;
-  if (Error.captureStackTrace) {
-    Error.captureStackTrace(this, stackStartFunction);
-  } else {
-    // non v8 browsers so we can have a stacktrace
-    var err = new Error();
-    if (err.stack) {
-      var out = err.stack;
-
-      // try to strip useless frames
-      var fn_name = getName(stackStartFunction);
-      var idx = out.indexOf('\n' + fn_name);
-      if (idx >= 0) {
-        // once we have located the function frame
-        // we need to strip out everything before it (and its line)
-        var next_line = out.indexOf('\n', idx + 1);
-        out = out.substring(next_line + 1);
-      }
-
-      this.stack = out;
-    }
-  }
-}
-
-// assert.AssertionError instanceof Error
-inherits$2(AssertionError, Error);
-
-function truncate(s, n) {
-  if (typeof s === 'string') {
-    return s.length < n ? s : s.slice(0, n);
-  } else {
-    return s;
-  }
-}
-function inspect(something) {
-  if (functionsHaveNames() || !isFunction$3(something)) {
-    return inspect$1(something);
-  }
-  var rawname = getName(something);
-  var name = rawname ? ': ' + rawname : '';
-  return '[Function' +  name + ']';
-}
-function getMessage(self) {
-  return truncate(inspect(self.actual), 128) + ' ' +
-         self.operator + ' ' +
-         truncate(inspect(self.expected), 128);
-}
-
-// At present only the three keys mentioned above are used and
-// understood by the spec. Implementations or sub modules can pass
-// other keys to the AssertionError's constructor - they will be
-// ignored.
-
-// 3. All of the following functions must throw an AssertionError
-// when a corresponding condition is not met, with a message that
-// may be undefined if not provided.  All assertion methods provide
-// both the actual and expected values to the assertion error for
-// display purposes.
-
-function fail(actual, expected, message, operator, stackStartFunction) {
-  throw new AssertionError({
-    message: message,
-    actual: actual,
-    expected: expected,
-    operator: operator,
-    stackStartFunction: stackStartFunction
-  });
-}
-
-// EXTENSION! allows for well behaved errors defined elsewhere.
-assert.fail = fail;
-
-// 4. Pure assertion tests whether a value is truthy, as determined
-// by !!guard.
-// assert.ok(guard, message_opt);
-// This statement is equivalent to assert.equal(true, !!guard,
-// message_opt);. To test strictly for the value true, use
-// assert.strictEqual(true, guard, message_opt);.
-
-function ok(value, message) {
-  if (!value) fail(value, true, message, '==', ok);
-}
-assert.ok = ok;
-
-// 5. The equality assertion tests shallow, coercive equality with
-// ==.
-// assert.equal(actual, expected, message_opt);
-assert.equal = equal;
-function equal(actual, expected, message) {
-  if (actual != expected) fail(actual, expected, message, '==', equal);
-}
-
-// 6. The non-equality assertion tests for whether two objects are not equal
-// with != assert.notEqual(actual, expected, message_opt);
-assert.notEqual = notEqual;
-function notEqual(actual, expected, message) {
-  if (actual == expected) {
-    fail(actual, expected, message, '!=', notEqual);
-  }
-}
-
-// 7. The equivalence assertion tests a deep equality relation.
-// assert.deepEqual(actual, expected, message_opt);
-assert.deepEqual = deepEqual;
-function deepEqual(actual, expected, message) {
-  if (!_deepEqual(actual, expected, false)) {
-    fail(actual, expected, message, 'deepEqual', deepEqual);
-  }
-}
-assert.deepStrictEqual = deepStrictEqual;
-function deepStrictEqual(actual, expected, message) {
-  if (!_deepEqual(actual, expected, true)) {
-    fail(actual, expected, message, 'deepStrictEqual', deepStrictEqual);
-  }
-}
-
-function _deepEqual(actual, expected, strict, memos) {
-  // 7.1. All identical values are equivalent, as determined by ===.
-  if (actual === expected) {
-    return true;
-  } else if (isBuffer$1(actual) && isBuffer$1(expected)) {
-    return compare$6(actual, expected) === 0;
-
-  // 7.2. If the expected value is a Date object, the actual value is
-  // equivalent if it is also a Date object that refers to the same time.
-  } else if (isDate(actual) && isDate(expected)) {
-    return actual.getTime() === expected.getTime();
-
-  // 7.3 If the expected value is a RegExp object, the actual value is
-  // equivalent if it is also a RegExp object with the same source and
-  // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
-  } else if (isRegExp$1(actual) && isRegExp$1(expected)) {
-    return actual.source === expected.source &&
-           actual.global === expected.global &&
-           actual.multiline === expected.multiline &&
-           actual.lastIndex === expected.lastIndex &&
-           actual.ignoreCase === expected.ignoreCase;
-
-  // 7.4. Other pairs that do not both pass typeof value == 'object',
-  // equivalence is determined by ==.
-  } else if ((actual === null || typeof actual !== 'object') &&
-             (expected === null || typeof expected !== 'object')) {
-    return strict ? actual === expected : actual == expected;
-
-  // If both values are instances of typed arrays, wrap their underlying
-  // ArrayBuffers in a Buffer each to increase performance
-  // This optimization requires the arrays to have the same type as checked by
-  // Object.prototype.toString (aka pToString). Never perform binary
-  // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their
-  // bit patterns are not identical.
-  } else if (isView(actual) && isView(expected) &&
-             pToString(actual) === pToString(expected) &&
-             !(actual instanceof Float32Array ||
-               actual instanceof Float64Array)) {
-    return compare$6(new Uint8Array(actual.buffer),
-                   new Uint8Array(expected.buffer)) === 0;
-
-  // 7.5 For all other Object pairs, including Array objects, equivalence is
-  // determined by having the same number of owned properties (as verified
-  // with Object.prototype.hasOwnProperty.call), the same set of keys
-  // (although not necessarily the same order), equivalent values for every
-  // corresponding key, and an identical 'prototype' property. Note: this
-  // accounts for both named and indexed properties on Arrays.
-  } else if (isBuffer$1(actual) !== isBuffer$1(expected)) {
-    return false;
-  } else {
-    memos = memos || {actual: [], expected: []};
-
-    var actualIndex = memos.actual.indexOf(actual);
-    if (actualIndex !== -1) {
-      if (actualIndex === memos.expected.indexOf(expected)) {
-        return true;
-      }
-    }
-
-    memos.actual.push(actual);
-    memos.expected.push(expected);
-
-    return objEquiv(actual, expected, strict, memos);
-  }
-}
-
-function isArguments(object) {
-  return Object.prototype.toString.call(object) == '[object Arguments]';
-}
-
-function objEquiv(a, b, strict, actualVisitedObjects) {
-  if (a === null || a === undefined || b === null || b === undefined)
-    return false;
-  // if one is a primitive, the other must be same
-  if (isPrimitive$1(a) || isPrimitive$1(b))
-    return a === b;
-  if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))
-    return false;
-  var aIsArgs = isArguments(a);
-  var bIsArgs = isArguments(b);
-  if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))
-    return false;
-  if (aIsArgs) {
-    a = pSlice.call(a);
-    b = pSlice.call(b);
-    return _deepEqual(a, b, strict);
-  }
-  var ka = objectKeys(a);
-  var kb = objectKeys(b);
-  var key, i;
-  // having the same number of owned properties (keys incorporates
-  // hasOwnProperty)
-  if (ka.length !== kb.length)
-    return false;
-  //the same set of keys (although not necessarily the same order),
-  ka.sort();
-  kb.sort();
-  //~~~cheap key test
-  for (i = ka.length - 1; i >= 0; i--) {
-    if (ka[i] !== kb[i])
-      return false;
-  }
-  //equivalent values for every corresponding key, and
-  //~~~possibly expensive deep test
-  for (i = ka.length - 1; i >= 0; i--) {
-    key = ka[i];
-    if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))
-      return false;
-  }
-  return true;
-}
+var tinyInvariant_cjs;
+var hasRequiredTinyInvariant_cjs;
 
-// 8. The non-equivalence assertion tests for any deep inequality.
-// assert.notDeepEqual(actual, expected, message_opt);
-assert.notDeepEqual = notDeepEqual;
-function notDeepEqual(actual, expected, message) {
-  if (_deepEqual(actual, expected, false)) {
-    fail(actual, expected, message, 'notDeepEqual', notDeepEqual);
-  }
-}
+function requireTinyInvariant_cjs () {
+	if (hasRequiredTinyInvariant_cjs) return tinyInvariant_cjs;
+	hasRequiredTinyInvariant_cjs = 1;
 
-assert.notDeepStrictEqual = notDeepStrictEqual;
-function notDeepStrictEqual(actual, expected, message) {
-  if (_deepEqual(actual, expected, true)) {
-    fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);
-  }
-}
-
-
-// 9. The strict equality assertion tests strict equality, as determined by ===.
-// assert.strictEqual(actual, expected, message_opt);
-assert.strictEqual = strictEqual;
-function strictEqual(actual, expected, message) {
-  if (actual !== expected) {
-    fail(actual, expected, message, '===', strictEqual);
-  }
-}
-
-// 10. The strict non-equality assertion tests for strict inequality, as
-// determined by !==.  assert.notStrictEqual(actual, expected, message_opt);
-assert.notStrictEqual = notStrictEqual;
-function notStrictEqual(actual, expected, message) {
-  if (actual === expected) {
-    fail(actual, expected, message, '!==', notStrictEqual);
-  }
-}
-
-function expectedException(actual, expected) {
-  if (!actual || !expected) {
-    return false;
-  }
-
-  if (Object.prototype.toString.call(expected) == '[object RegExp]') {
-    return expected.test(actual);
-  }
-
-  try {
-    if (actual instanceof expected) {
-      return true;
-    }
-  } catch (e) {
-    // Ignore.  The instanceof check doesn't work for arrow functions.
-  }
-
-  if (Error.isPrototypeOf(expected)) {
-    return false;
-  }
-
-  return expected.call({}, actual) === true;
-}
-
-function _tryBlock(block) {
-  var error;
-  try {
-    block();
-  } catch (e) {
-    error = e;
-  }
-  return error;
-}
-
-function _throws(shouldThrow, block, expected, message) {
-  var actual;
-
-  if (typeof block !== 'function') {
-    throw new TypeError('"block" argument must be a function');
-  }
-
-  if (typeof expected === 'string') {
-    message = expected;
-    expected = null;
-  }
-
-  actual = _tryBlock(block);
-
-  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
-            (message ? ' ' + message : '.');
-
-  if (shouldThrow && !actual) {
-    fail(actual, expected, 'Missing expected exception' + message);
-  }
-
-  var userProvidedMessage = typeof message === 'string';
-  var isUnwantedException = !shouldThrow && isError(actual);
-  var isUnexpectedException = !shouldThrow && actual && !expected;
-
-  if ((isUnwantedException &&
-      userProvidedMessage &&
-      expectedException(actual, expected)) ||
-      isUnexpectedException) {
-    fail(actual, expected, 'Got unwanted exception' + message);
-  }
-
-  if ((shouldThrow && actual && expected &&
-      !expectedException(actual, expected)) || (!shouldThrow && actual)) {
-    throw actual;
-  }
-}
-
-// 11. Expected to throw an error:
-// assert.throws(block, Error_opt, message_opt);
-assert.throws = throws;
-function throws(block, /*optional*/error, /*optional*/message) {
-  _throws(true, block, error, message);
-}
-
-// EXTENSION! This is annoying to write outside this module.
-assert.doesNotThrow = doesNotThrow;
-function doesNotThrow(block, /*optional*/error, /*optional*/message) {
-  _throws(false, block, error, message);
-}
+	var isProduction = browser$1$1.env.NODE_ENV === 'production';
+	var prefix = 'Invariant failed';
+	function invariant(condition, message) {
+	    if (condition) {
+	        return;
+	    }
+	    if (isProduction) {
+	        throw new Error(prefix);
+	    }
+	    var provided = typeof message === 'function' ? message() : message;
+	    var value = provided ? "".concat(prefix, ": ").concat(provided) : prefix;
+	    throw new Error(value);
+	}
 
-assert.ifError = ifError;
-function ifError(err) {
-  if (err) throw err;
+	tinyInvariant_cjs = invariant;
+	return tinyInvariant_cjs;
 }
 
-var _polyfillNode_assert = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	AssertionError: AssertionError,
-	assert: ok,
-	deepEqual: deepEqual,
-	deepStrictEqual: deepStrictEqual,
-	default: assert,
-	doesNotThrow: doesNotThrow,
-	equal: equal,
-	fail: fail,
-	ifError: ifError,
-	notDeepEqual: notDeepEqual,
-	notDeepStrictEqual: notDeepStrictEqual,
-	notEqual: notEqual,
-	notStrictEqual: notStrictEqual,
-	ok: ok,
-	strictEqual: strictEqual,
-	throws: throws
-});
-
-var require$$1$2 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_assert);
-
 var options$3 = {};
 
 var util$1 = {};
@@ -65052,7 +64596,7 @@ function requireUtil () {
 	Object.defineProperty(util$1, "__esModule", { value: true });
 	util$1.isTrailingCommaEnabled = util$1.getParentExportDeclaration = util$1.isExportDeclaration = util$1.fixFaultyLocations = util$1.getTrueLoc = util$1.composeSourceMaps = util$1.copyPos = util$1.comparePos = util$1.getUnionOfKeys = util$1.getOption = util$1.isBrowser = util$1.getLineTerminator = void 0;
 	var tslib_1 = require$$0$4;
-	var assert_1 = tslib_1.__importDefault(require$$1$2);
+	var tiny_invariant_1 = tslib_1.__importDefault(requireTinyInvariant_cjs());
 	var types = tslib_1.__importStar(requireMain());
 	var n = types.namedTypes;
 	var source_map_1 = tslib_1.__importDefault(requireSourceMap());
@@ -65303,8 +64847,8 @@ function requireUtil () {
 	        // First we need to exclude the opening ` from the .loc of the first
 	        // quasi element, in case the parser accidentally decided to include it.
 	        var afterLeftBackTickPos = copyPos(node.loc.start);
-	        assert_1.default.strictEqual(lines.charAt(afterLeftBackTickPos), "`");
-	        assert_1.default.ok(lines.nextPos(afterLeftBackTickPos));
+	        (0, tiny_invariant_1.default)(lines.charAt(afterLeftBackTickPos) === "`");
+	        (0, tiny_invariant_1.default)(lines.nextPos(afterLeftBackTickPos));
 	        var firstQuasi = node.quasis[0];
 	        if (comparePos(firstQuasi.loc.start, afterLeftBackTickPos) < 0) {
 	            firstQuasi.loc.start = afterLeftBackTickPos;
@@ -65312,8 +64856,8 @@ function requireUtil () {
 	        // Next we need to exclude the closing ` from the .loc of the last quasi
 	        // element, in case the parser accidentally decided to include it.
 	        var rightBackTickPos = copyPos(node.loc.end);
-	        assert_1.default.ok(lines.prevPos(rightBackTickPos));
-	        assert_1.default.strictEqual(lines.charAt(rightBackTickPos), "`");
+	        (0, tiny_invariant_1.default)(lines.prevPos(rightBackTickPos));
+	        (0, tiny_invariant_1.default)(lines.charAt(rightBackTickPos) === "`");
 	        var lastQuasi = node.quasis[node.quasis.length - 1];
 	        if (comparePos(rightBackTickPos, lastQuasi.loc.end) < 0) {
 	            lastQuasi.loc.end = rightBackTickPos;
@@ -65340,7 +64884,7 @@ function requireUtil () {
 	        // the expression in the .loc of the following quasi element.
 	        var rightCurlyPos = lines.skipSpaces(expr.loc.end, false, false);
 	        if (lines.charAt(rightCurlyPos) === "}") {
-	            assert_1.default.ok(lines.nextPos(rightCurlyPos));
+	            (0, tiny_invariant_1.default)(lines.nextPos(rightCurlyPos));
 	            // Now rightCurlyPos is technically the position just after the }.
 	            var quasiAfter = node.quasis[i + 1];
 	            if (comparePos(quasiAfter.loc.start, rightCurlyPos) < 0) {
@@ -72093,7 +71637,7 @@ function requireOptions () {
 	    useTabs: false,
 	    reuseWhitespace: true,
 	    lineTerminator: (0, util_1.getLineTerminator)(),
-	    wrapColumn: 74,
+	    wrapColumn: 74, // Aspirational for now.
 	    sourceFileName: null,
 	    sourceMapName: null,
 	    sourceRoot: null,
@@ -72152,7 +71696,7 @@ function requireMapping () {
 	hasRequiredMapping = 1;
 	Object.defineProperty(mapping, "__esModule", { value: true });
 	var tslib_1 = require$$0$4;
-	var assert_1 = tslib_1.__importDefault(require$$1$2);
+	var tiny_invariant_1 = tslib_1.__importDefault(requireTinyInvariant_cjs());
 	var util_1 = requireUtil();
 	var Mapping = /** @class */ (function () {
 	    function Mapping(sourceLines, sourceLoc, targetLoc) {
@@ -72174,7 +71718,7 @@ function requireMapping () {
 	                targetToPos = end;
 	            }
 	            else {
-	                assert_1.default.strictEqual(name, "start");
+	                (0, tiny_invariant_1.default)(name === "start");
 	            }
 	            return skipChars(sourceLines, sourceFromPos, lines, targetFromPos, targetToPos);
 	        }
@@ -72312,12 +71856,12 @@ function requireMapping () {
 	            targetCursor.column = 0;
 	        }
 	        else {
-	            assert_1.default.strictEqual(lineDiff, 0);
+	            (0, tiny_invariant_1.default)(lineDiff === 0);
 	        }
 	        while ((0, util_1.comparePos)(targetCursor, targetToPos) < 0 &&
 	            targetLines.nextPos(targetCursor, true)) {
-	            assert_1.default.ok(sourceLines.nextPos(sourceCursor, true));
-	            assert_1.default.strictEqual(sourceLines.charAt(sourceCursor), targetLines.charAt(targetCursor));
+	            (0, tiny_invariant_1.default)(sourceLines.nextPos(sourceCursor, true));
+	            (0, tiny_invariant_1.default)(sourceLines.charAt(sourceCursor) === targetLines.charAt(targetCursor));
 	        }
 	    }
 	    else {
@@ -72336,12 +71880,12 @@ function requireMapping () {
 	            targetCursor.column = targetLines.getLineLength(targetCursor.line);
 	        }
 	        else {
-	            assert_1.default.strictEqual(lineDiff, 0);
+	            (0, tiny_invariant_1.default)(lineDiff === 0);
 	        }
 	        while ((0, util_1.comparePos)(targetToPos, targetCursor) < 0 &&
 	            targetLines.prevPos(targetCursor, true)) {
-	            assert_1.default.ok(sourceLines.prevPos(sourceCursor, true));
-	            assert_1.default.strictEqual(sourceLines.charAt(sourceCursor), targetLines.charAt(targetCursor));
+	            (0, tiny_invariant_1.default)(sourceLines.prevPos(sourceCursor, true));
+	            (0, tiny_invariant_1.default)(sourceLines.charAt(sourceCursor) === targetLines.charAt(targetCursor));
 	        }
 	    }
 	    return sourceCursor;
@@ -72357,7 +71901,7 @@ function requireLines () {
 	Object.defineProperty(lines, "__esModule", { value: true });
 	lines.concat = lines.fromString = lines.countSpaces = lines.Lines = void 0;
 	var tslib_1 = require$$0$4;
-	var assert_1 = tslib_1.__importDefault(require$$1$2);
+	var tiny_invariant_1 = tslib_1.__importDefault(requireTinyInvariant_cjs());
 	var source_map_1 = tslib_1.__importDefault(requireSourceMap());
 	var options_1 = requireOptions();
 	var util_1 = requireUtil();
@@ -72369,7 +71913,7 @@ function requireLines () {
 	        this.mappings = [];
 	        this.cachedSourceMap = null;
 	        this.cachedTabWidth = void 0;
-	        assert_1.default.ok(infos.length > 0);
+	        (0, tiny_invariant_1.default)(infos.length > 0);
 	        this.length = infos.length;
 	        this.name = sourceFileName || null;
 	        if (this.name) {
@@ -72416,7 +71960,7 @@ function requireLines () {
 	                (0, util_1.comparePos)(targetCursor, mapping.targetLoc.end) < 0) {
 	                var sourceChar = mapping.sourceLines.charAt(sourceCursor);
 	                var targetChar = targetLines.charAt(targetCursor);
-	                assert_1.default.strictEqual(sourceChar, targetChar);
+	                (0, tiny_invariant_1.default)(sourceChar === targetChar);
 	                var sourceName = mapping.sourceLines.name;
 	                // Add mappings one character at a time for maximum resolution.
 	                smg.addMapping({
@@ -72437,9 +71981,9 @@ function requireLines () {
 	        return smg.toJSON();
 	    };
 	    Lines.prototype.bootstrapCharAt = function (pos) {
-	        assert_1.default.strictEqual(typeof pos, "object");
-	        assert_1.default.strictEqual(typeof pos.line, "number");
-	        assert_1.default.strictEqual(typeof pos.column, "number");
+	        (0, tiny_invariant_1.default)(typeof pos === "object");
+	        (0, tiny_invariant_1.default)(typeof pos.line === "number");
+	        (0, tiny_invariant_1.default)(typeof pos.column === "number");
 	        var line = pos.line, column = pos.column, strings = this.toString().split(lineTerminatorSeqExp), string = strings[line - 1];
 	        if (typeof string === "undefined")
 	            return "";
@@ -72450,9 +71994,9 @@ function requireLines () {
 	        return string.charAt(column);
 	    };
 	    Lines.prototype.charAt = function (pos) {
-	        assert_1.default.strictEqual(typeof pos, "object");
-	        assert_1.default.strictEqual(typeof pos.line, "number");
-	        assert_1.default.strictEqual(typeof pos.column, "number");
+	        (0, tiny_invariant_1.default)(typeof pos === "object");
+	        (0, tiny_invariant_1.default)(typeof pos.line === "number");
+	        (0, tiny_invariant_1.default)(typeof pos.column === "number");
 	        var line = pos.line, column = pos.column, secret = this, infos = secret.infos, info = infos[line - 1], c = column;
 	        if (typeof info === "undefined" || c < 0)
 	            return "";
@@ -72469,7 +72013,7 @@ function requireLines () {
 	    Lines.prototype.stripMargin = function (width, skipFirstLine) {
 	        if (width === 0)
 	            return this;
-	        assert_1.default.ok(width > 0, "negative margin: " + width);
+	        (0, tiny_invariant_1.default)(width > 0, "negative margin: " + width);
 	        if (skipFirstLine && this.length === 1)
 	            return this;
 	        var lines = new Lines(this.infos.map(function (info, i) {
@@ -72480,7 +72024,7 @@ function requireLines () {
 	        }));
 	        if (this.mappings.length > 0) {
 	            var newMappings_1 = lines.mappings;
-	            assert_1.default.strictEqual(newMappings_1.length, 0);
+	            (0, tiny_invariant_1.default)(newMappings_1.length === 0);
 	            this.mappings.forEach(function (mapping) {
 	                newMappings_1.push(mapping.indent(width, skipFirstLine, true));
 	            });
@@ -72499,7 +72043,7 @@ function requireLines () {
 	        }));
 	        if (this.mappings.length > 0) {
 	            var newMappings_2 = lines.mappings;
-	            assert_1.default.strictEqual(newMappings_2.length, 0);
+	            (0, tiny_invariant_1.default)(newMappings_2.length === 0);
 	            this.mappings.forEach(function (mapping) {
 	                newMappings_2.push(mapping.indent(by));
 	            });
@@ -72521,7 +72065,7 @@ function requireLines () {
 	        }));
 	        if (this.mappings.length > 0) {
 	            var newMappings_3 = lines.mappings;
-	            assert_1.default.strictEqual(newMappings_3.length, 0);
+	            (0, tiny_invariant_1.default)(newMappings_3.length === 0);
 	            this.mappings.forEach(function (mapping) {
 	                newMappings_3.push(mapping.indent(by, true));
 	            });
@@ -72535,7 +72079,7 @@ function requireLines () {
 	        return new Lines(this.infos.map(function (info, i) { return (tslib_1.__assign(tslib_1.__assign({}, info), { locked: i > 0 })); }));
 	    };
 	    Lines.prototype.getIndentAt = function (line) {
-	        assert_1.default.ok(line >= 1, "no line " + line + " (line numbers start from 1)");
+	        (0, tiny_invariant_1.default)(line >= 1, "no line " + line + " (line numbers start from 1)");
 	        return Math.max(this.infos[line - 1].indent, 0);
 	    };
 	    Lines.prototype.guessTabWidth = function () {
@@ -72735,14 +72279,14 @@ function requireLines () {
 	            sliced[0] = sliceInfo(sliced[0], start.column, end.column);
 	        }
 	        else {
-	            assert_1.default.ok(start.line < end.line);
+	            (0, tiny_invariant_1.default)(start.line < end.line);
 	            sliced[0] = sliceInfo(sliced[0], start.column);
 	            sliced.push(sliceInfo(sliced.pop(), 0, end.column));
 	        }
 	        var lines = new Lines(sliced);
 	        if (this.mappings.length > 0) {
 	            var newMappings_4 = lines.mappings;
-	            assert_1.default.strictEqual(newMappings_4.length, 0);
+	            (0, tiny_invariant_1.default)(newMappings_4.length === 0);
 	            this.mappings.forEach(function (mapping) {
 	                var sliced = mapping.slice(this, start, end);
 	                if (sliced) {
@@ -72876,7 +72420,7 @@ function requireLines () {
 	        }
 	        var list = [this];
 	        list.push.apply(list, args);
-	        assert_1.default.strictEqual(list.length, args.length + 1);
+	        (0, tiny_invariant_1.default)(list.length === args.length + 1);
 	        return emptyLines.join(list);
 	    };
 	    return Lines;
@@ -72892,8 +72436,8 @@ function requireLines () {
 	        switch (spaces.charCodeAt(i)) {
 	            case 9: {
 	                // '\t'
-	                assert_1.default.strictEqual(typeof tabWidth, "number");
-	                assert_1.default.ok(tabWidth > 0);
+	                (0, tiny_invariant_1.default)(typeof tabWidth === "number");
+	                (0, tiny_invariant_1.default)(tabWidth > 0);
 	                var next = Math.ceil(count / tabWidth) * tabWidth;
 	                if (next === count) {
 	                    count += tabWidth;
@@ -72932,7 +72476,7 @@ function requireLines () {
 	    var tabWidth = options && options.tabWidth;
 	    var tabless = string.indexOf("\t") < 0;
 	    var cacheable = !options && tabless && string.length <= maxCacheKeyLen;
-	    assert_1.default.ok(tabWidth || tabless, "No tab width specified but encountered tabs in string\n" + string);
+	    (0, tiny_invariant_1.default)(tabWidth || tabless, "No tab width specified but encountered tabs in string\n" + string);
 	    if (cacheable && hasOwn.call(fromStringCache, string))
 	        return fromStringCache[string];
 	    var lines = new Lines(string.split(lineTerminatorSeqExp).map(function (line) {
@@ -72983,9 +72527,9 @@ function requireLines () {
 	        indent = 0;
 	        sliceStart += startCol;
 	    }
-	    assert_1.default.ok(indent >= 0);
-	    assert_1.default.ok(sliceStart <= sliceEnd);
-	    assert_1.default.strictEqual(lineLength, indent + sliceEnd - sliceStart);
+	    (0, tiny_invariant_1.default)(indent >= 0);
+	    (0, tiny_invariant_1.default)(sliceStart <= sliceEnd);
+	    (0, tiny_invariant_1.default)(lineLength === indent + sliceEnd - sliceStart);
 	    if (info.indent === indent &&
 	        info.sliceStart === sliceStart &&
 	        info.sliceEnd === sliceEnd) {
@@ -73020,7 +72564,7 @@ function requireComments () {
 	Object.defineProperty(comments$1, "__esModule", { value: true });
 	comments$1.printComments = comments$1.attach = void 0;
 	var tslib_1 = require$$0$4;
-	var assert_1 = tslib_1.__importDefault(require$$1$2);
+	var tiny_invariant_1 = tslib_1.__importDefault(requireTinyInvariant_cjs());
 	var types = tslib_1.__importStar(requireMain());
 	var n = types.namedTypes;
 	var isArray = types.builtInTypes.array;
@@ -73142,7 +72686,8 @@ function requireComments () {
 	            var tieCount = tiesToBreak.length;
 	            if (tieCount > 0) {
 	                var lastTie = tiesToBreak[tieCount - 1];
-	                assert_1.default.strictEqual(lastTie.precedingNode === comment.precedingNode, lastTie.followingNode === comment.followingNode);
+	                (0, tiny_invariant_1.default)((lastTie.precedingNode === comment.precedingNode) ===
+	                    (lastTie.followingNode === comment.followingNode));
 	                if (lastTie.followingNode !== comment.followingNode) {
 	                    breakTies(tiesToBreak, lines);
 	                }
@@ -73196,8 +72741,8 @@ function requireComments () {
 	    var comment;
 	    for (; indexOfFirstLeadingComment > 0; --indexOfFirstLeadingComment) {
 	        comment = tiesToBreak[indexOfFirstLeadingComment - 1];
-	        assert_1.default.strictEqual(comment.precedingNode, pn);
-	        assert_1.default.strictEqual(comment.followingNode, fn);
+	        (0, tiny_invariant_1.default)(comment.precedingNode === pn);
+	        (0, tiny_invariant_1.default)(comment.followingNode === fn);
 	        var gap = lines.sliceString(comment.loc.end, gapEndPos);
 	        if (/\S/.test(gap)) {
 	            // The gap string contained something other than whitespace.
@@ -73339,7 +72884,7 @@ function requireParser () {
 	Object.defineProperty(parser$5, "__esModule", { value: true });
 	parser$5.parse = void 0;
 	var tslib_1 = require$$0$4;
-	var assert_1 = tslib_1.__importDefault(require$$1$2);
+	var tiny_invariant_1 = tslib_1.__importDefault(requireTinyInvariant_cjs());
 	var types = tslib_1.__importStar(requireMain());
 	var b = types.builders;
 	var isObject = types.builtInTypes.object;
@@ -73448,7 +72993,7 @@ function requireParser () {
 	}
 	parser$5.parse = parse;
 	var TreeCopier = function TreeCopier(lines, tokens) {
-	    assert_1.default.ok(this instanceof TreeCopier);
+	    (0, tiny_invariant_1.default)(this instanceof TreeCopier);
 	    this.lines = lines;
 	    this.tokens = tokens;
 	    this.startTokenIndex = 0;
@@ -73599,7 +73144,7 @@ function requireFastPath () {
 	hasRequiredFastPath = 1;
 	Object.defineProperty(fastPath, "__esModule", { value: true });
 	var tslib_1 = require$$0$4;
-	var assert_1 = tslib_1.__importDefault(require$$1$2);
+	var tiny_invariant_1 = tslib_1.__importDefault(requireTinyInvariant_cjs());
 	var types = tslib_1.__importStar(requireMain());
 	var util = tslib_1.__importStar(requireUtil());
 	var n = types.namedTypes;
@@ -73625,7 +73170,7 @@ function requireFastPath () {
 	    });
 	});
 	var FastPath = function FastPath(value) {
-	    assert_1.default.ok(this instanceof FastPath);
+	    (0, tiny_invariant_1.default)(this instanceof FastPath);
 	    this.stack = [value];
 	};
 	var FPp = FastPath.prototype;
@@ -73919,7 +73464,7 @@ function requireFastPath () {
 	                        return true;
 	                    }
 	                    if (pp === np && name === "right") {
-	                        assert_1.default.strictEqual(parent.right, node);
+	                        (0, tiny_invariant_1.default)(parent.right === node);
 	                        return true;
 	                    }
 	                    break;
@@ -74079,19 +73624,19 @@ function requireFastPath () {
 	        if (n.BlockStatement.check(parent) &&
 	            parentName === "body" &&
 	            childName === 0) {
-	            assert_1.default.strictEqual(parent.body[0], child);
+	            (0, tiny_invariant_1.default)(parent.body[0] === child);
 	            return true;
 	        }
 	        if (n.ExpressionStatement.check(parent) && childName === "expression") {
-	            assert_1.default.strictEqual(parent.expression, child);
+	            (0, tiny_invariant_1.default)(parent.expression === child);
 	            return true;
 	        }
 	        if (n.AssignmentExpression.check(parent) && childName === "left") {
-	            assert_1.default.strictEqual(parent.left, child);
+	            (0, tiny_invariant_1.default)(parent.left === child);
 	            return true;
 	        }
 	        if (n.ArrowFunctionExpression.check(parent) && childName === "body") {
-	            assert_1.default.strictEqual(parent.body, child);
+	            (0, tiny_invariant_1.default)(parent.body === child);
 	            return true;
 	        }
 	        // s[i + 1] and s[i + 2] represent the array between the parent
@@ -74099,29 +73644,29 @@ function requireFastPath () {
 	        if (n.SequenceExpression.check(parent) &&
 	            s[i + 1] === "expressions" &&
 	            childName === 0) {
-	            assert_1.default.strictEqual(parent.expressions[0], child);
+	            (0, tiny_invariant_1.default)(parent.expressions[0] === child);
 	            continue;
 	        }
 	        if (n.CallExpression.check(parent) && childName === "callee") {
-	            assert_1.default.strictEqual(parent.callee, child);
+	            (0, tiny_invariant_1.default)(parent.callee === child);
 	            continue;
 	        }
 	        if (n.MemberExpression.check(parent) && childName === "object") {
-	            assert_1.default.strictEqual(parent.object, child);
+	            (0, tiny_invariant_1.default)(parent.object === child);
 	            continue;
 	        }
 	        if (n.ConditionalExpression.check(parent) && childName === "test") {
-	            assert_1.default.strictEqual(parent.test, child);
+	            (0, tiny_invariant_1.default)(parent.test === child);
 	            continue;
 	        }
 	        if (isBinary(parent) && childName === "left") {
-	            assert_1.default.strictEqual(parent.left, child);
+	            (0, tiny_invariant_1.default)(parent.left === child);
 	            continue;
 	        }
 	        if (n.UnaryExpression.check(parent) &&
 	            !parent.prefix &&
 	            childName === "argument") {
-	            assert_1.default.strictEqual(parent.argument, child);
+	            (0, tiny_invariant_1.default)(parent.argument === child);
 	            continue;
 	        }
 	        return false;
@@ -74142,7 +73687,7 @@ function requirePatcher () {
 	Object.defineProperty(patcher, "__esModule", { value: true });
 	patcher.getReprinter = patcher.Patcher = void 0;
 	var tslib_1 = require$$0$4;
-	var assert_1 = tslib_1.__importDefault(require$$1$2);
+	var tiny_invariant_1 = tslib_1.__importDefault(requireTinyInvariant_cjs());
 	var linesModule = tslib_1.__importStar(requireLines());
 	var types = tslib_1.__importStar(requireMain());
 	var Printable = types.namedTypes.Printable;
@@ -74156,8 +73701,8 @@ function requirePatcher () {
 	var isString = types.builtInTypes.string;
 	var riskyAdjoiningCharExp = /[0-9a-z_$]/i;
 	var Patcher = function Patcher(lines) {
-	    assert_1.default.ok(this instanceof Patcher);
-	    assert_1.default.ok(lines instanceof linesModule.Lines);
+	    (0, tiny_invariant_1.default)(this instanceof Patcher);
+	    (0, tiny_invariant_1.default)(lines instanceof linesModule.Lines);
 	    var self = this, replacements = [];
 	    self.replace = function (loc, lines) {
 	        if (isString.check(lines))
@@ -74176,7 +73721,7 @@ function requirePatcher () {
 	        };
 	        var sliceFrom = loc.start, toConcat = [];
 	        function pushSlice(from, to) {
-	            assert_1.default.ok((0, util_1.comparePos)(from, to) <= 0);
+	            (0, tiny_invariant_1.default)((0, util_1.comparePos)(from, to) <= 0);
 	            toConcat.push(lines.slice(from, to));
 	        }
 	        replacements
@@ -74212,7 +73757,7 @@ function requirePatcher () {
 	    if (ableToReprintComments && reprints.length > 0) {
 	        reprints.forEach(function (reprint) {
 	            var oldComment = reprint.oldPath.getValue();
-	            assert_1.default.ok(oldComment.leading || oldComment.trailing);
+	            (0, tiny_invariant_1.default)(oldComment.leading || oldComment.trailing);
 	            patcher.replace(oldComment.loc, 
 	            // Comments can't have .comments, so it doesn't matter whether we
 	            // print with comments or without.
@@ -74260,7 +73805,7 @@ function requirePatcher () {
 	    });
 	};
 	function getReprinter(path) {
-	    assert_1.default.ok(path instanceof fast_path_1.default);
+	    (0, tiny_invariant_1.default)(path instanceof fast_path_1.default);
 	    // Make sure that this path refers specifically to a Node, rather than
 	    // some non-Node subproperty of a Node.
 	    var node = path.getValue();
@@ -74354,7 +73899,7 @@ function requirePatcher () {
 	    Printable.assert(newNode);
 	    var oldNode = newNode.original;
 	    Printable.assert(oldNode);
-	    assert_1.default.deepEqual(reprints, []);
+	    (0, tiny_invariant_1.default)(reprints.length === 0);
 	    if (newNode.type !== oldNode.type) {
 	        return false;
 	    }
@@ -74533,7 +74078,7 @@ function requirePrinter () {
 	Object.defineProperty(printer$1, "__esModule", { value: true });
 	printer$1.Printer = void 0;
 	var tslib_1 = require$$0$4;
-	var assert_1 = tslib_1.__importDefault(require$$1$2);
+	var tiny_invariant_1 = tslib_1.__importDefault(requireTinyInvariant_cjs());
 	var types = tslib_1.__importStar(requireMain());
 	var comments_1 = requireComments();
 	var fast_path_1 = tslib_1.__importDefault(requireFastPath());
@@ -74545,7 +74090,7 @@ function requirePrinter () {
 	var isString = types.builtInTypes.string;
 	var isObject = types.builtInTypes.object;
 	var PrintResult = function PrintResult(code, sourceMap) {
-	    assert_1.default.ok(this instanceof PrintResult);
+	    (0, tiny_invariant_1.default)(this instanceof PrintResult);
 	    isString.assert(code);
 	    this.code = code;
 	    if (sourceMap) {
@@ -74566,7 +74111,7 @@ function requirePrinter () {
 	};
 	var emptyPrintResult = new PrintResult("");
 	var Printer = function Printer(config) {
-	    assert_1.default.ok(this instanceof Printer);
+	    (0, tiny_invariant_1.default)(this instanceof Printer);
 	    var explicitTabWidth = config && config.tabWidth;
 	    config = (0, options_1.normalize)(config);
 	    // It's common for client code to pass the same options into both
@@ -74580,7 +74125,7 @@ function requirePrinter () {
 	        return function (path) { return print(path, options); };
 	    }
 	    function print(path, options) {
-	        assert_1.default.ok(path instanceof fast_path_1.default);
+	        (0, tiny_invariant_1.default)(path instanceof fast_path_1.default);
 	        options = options || {};
 	        if (options.includeComments) {
 	            return (0, comments_1.printComments)(path, makePrintFunctionWith(options, {
@@ -74648,7 +74193,7 @@ function requirePrinter () {
 	};
 	printer$1.Printer = Printer;
 	function genericPrint(path, config, options, printPath) {
-	    assert_1.default.ok(path instanceof fast_path_1.default);
+	    (0, tiny_invariant_1.default)(path instanceof fast_path_1.default);
 	    var node = path.getValue();
 	    var parts = [];
 	    var linesWithoutParens = genericPrintNoParens(path, config, printPath);
@@ -74845,7 +74390,7 @@ function requirePrinter () {
 	        case "ModuleDeclaration":
 	            parts.push("module", path.call(print, "id"));
 	            if (n.source) {
-	                assert_1.default.ok(!n.body);
+	                (0, tiny_invariant_1.default)(!n.body);
 	                parts.push("from", path.call(print, "source"));
 	            }
 	            else {
@@ -75255,9 +74800,9 @@ function requirePrinter () {
 	        case "UnaryExpression": {
 	            parts.push(n.operator);
 	            var argument = path.getValue().argument;
-	            var needsParens = argument.type === 'LogicalExpression';
-	            var parenLeft = needsParens ? '(' : '';
-	            var parenRight = needsParens ? ')' : '';
+	            var needsParens = argument.type === "LogicalExpression";
+	            var parenLeft = needsParens ? "(" : "";
+	            var parenRight = needsParens ? ")" : "";
 	            if (/[a-z]$/.test(n.operator))
 	                parts.push(" ");
 	            parts.push(parenLeft, path.call(print, "argument"), parenRight);
@@ -75508,7 +75053,7 @@ function requirePrinter () {
 	            var closingPropName = "closing" + (n.type === "JSXElement" ? "Element" : "Fragment");
 	            var openingLines = path.call(print, openingPropName);
 	            if (n[openingPropName].selfClosing) {
-	                assert_1.default.ok(!n[closingPropName], "unexpected " +
+	                (0, tiny_invariant_1.default)(!n[closingPropName], "unexpected " +
 	                    closingPropName +
 	                    " element in self-closing " +
 	                    n.type);
@@ -75541,7 +75086,7 @@ function requirePrinter () {
 	            if (needLineWrap) {
 	                attrParts_1.forEach(function (part, i) {
 	                    if (part === " ") {
-	                        assert_1.default.strictEqual(i % 2, 0);
+	                        (0, tiny_invariant_1.default)(i % 2 === 0);
 	                        attrParts_1[i] = "\n";
 	                    }
 	                });
@@ -75815,7 +75360,7 @@ function requirePrinter () {
 	        case "BooleanTypeAnnotation":
 	            return (0, lines_1.fromString)("boolean", options);
 	        case "BooleanLiteralTypeAnnotation":
-	            assert_1.default.strictEqual(typeof n.value, "boolean");
+	            (0, tiny_invariant_1.default)(typeof n.value === "boolean");
 	            return (0, lines_1.fromString)("" + n.value, options);
 	        case "InterfaceTypeAnnotation":
 	            parts.push("interface");
@@ -75995,7 +75540,7 @@ function requirePrinter () {
 	            return (0, lines_1.fromString)(nodeStr(n.value, options), options);
 	        case "NumberLiteralTypeAnnotation":
 	        case "NumericLiteralTypeAnnotation":
-	            assert_1.default.strictEqual(typeof n.value, "number");
+	            (0, tiny_invariant_1.default)(typeof n.value === "number");
 	            return (0, lines_1.fromString)(JSON.stringify(n.value), options);
 	        case "BigIntLiteralTypeAnnotation":
 	            return (0, lines_1.fromString)(n.raw, options);
@@ -76229,12 +75774,11 @@ function requirePrinter () {
 	        case "TSQualifiedName":
 	            return (0, lines_1.concat)([path.call(print, "left"), ".", path.call(print, "right")]);
 	        case "TSAsExpression":
-	        case "TSSatisfiesExpression":
-	            {
-	                var expression = path.call(print, "expression");
-	                parts.push(expression, n.type === "TSSatisfiesExpression" ? " satisfies " : " as ", path.call(print, "typeAnnotation"));
-	                return (0, lines_1.concat)(parts);
-	            }
+	        case "TSSatisfiesExpression": {
+	            var expression = path.call(print, "expression");
+	            parts.push(expression, n.type === "TSSatisfiesExpression" ? " satisfies " : " as ", path.call(print, "typeAnnotation"));
+	            return (0, lines_1.concat)(parts);
+	        }
 	        case "TSTypeCastExpression":
 	            return (0, lines_1.concat)([
 	                path.call(print, "expression"),
@@ -76540,7 +76084,7 @@ function requirePrinter () {
 	        });
 	    });
 	    if (sawComment) {
-	        assert_1.default.strictEqual(sawStatement, false, "Comments may appear as statements in otherwise empty statement " +
+	        (0, tiny_invariant_1.default)(sawStatement === false, "Comments may appear as statements in otherwise empty statement " +
 	            "lists, but may not coexist with non-Comment nodes.");
 	    }
 	    var prevTrailingSpace = null;
@@ -76773,12 +76317,14 @@ function requirePrinter () {
 	        else if (decl.specifiers.length === 0) {
 	            parts.push("{}");
 	        }
-	        else if (/^Export(Default|Namespace)Specifier$/.test(decl.specifiers[0].type)) {
+	        else if (decl.specifiers[0].type === "ExportDefaultSpecifier" ||
+	            decl.specifiers[0].type === "ExportNamespaceSpecifier") {
 	            var unbracedSpecifiers_2 = [];
 	            var bracedSpecifiers_2 = [];
 	            path.each(function (specifierPath) {
 	                var spec = specifierPath.getValue();
-	                if (/^Export(Namespace|Default)Specifier$/.test(spec.type)) {
+	                if (spec.type === "ExportDefaultSpecifier" ||
+	                    spec.type === "ExportNamespaceSpecifier") {
 	                    unbracedSpecifiers_2.push(print(specifierPath));
 	                }
 	                else {
@@ -76835,7 +76381,7 @@ function requirePrinter () {
 	function printFlowDeclaration(path, parts) {
 	    var parentExportDecl = util.getParentExportDeclaration(path);
 	    if (parentExportDecl) {
-	        assert_1.default.strictEqual(parentExportDecl.type, "DeclareExportDeclaration");
+	        (0, tiny_invariant_1.default)(parentExportDecl.type === "DeclareExportDeclaration");
 	    }
 	    else {
 	        // If the parent node has type DeclareExportDeclaration, then it
@@ -77011,9 +76557,9 @@ var fullstore$3 = (value) => {
     };
 };
 
-var types$r = {};
+var types$q = {};
 
-types$r.TYPES = {
+types$q.TYPES = {
     TOKEN: 'Token',
     NEWLINE: 'Newline',
     LINEBREAK: 'Linebreak',
@@ -77047,7 +76593,7 @@ const {
 const isParentProgram$1 = (path) => path.parentPath?.isProgram();
 const isParentBlock$3 = (path) => path.parentPath.isBlockStatement();
 
-const isNext$q = (path) => {
+const isNext$r = (path) => {
     const next = path.getNextSibling();
     
     if (!next.node)
@@ -77061,12 +76607,12 @@ const isPrev$1 = (path) => {
     return next.node;
 };
 
-const isNextParent$5 = (path) => isNext$q(path.parentPath);
-const isLast$d = (path) => isParentProgram$1(path) && !isNext$q(path);
+const isNextParent$5 = (path) => isNext$r(path.parentPath);
+const isLast$d = (path) => isParentProgram$1(path) && !isNext$r(path);
 
 is$3.isFirst = (path) => path.node === path.parentPath.node.body?.[0];
 is$3.isPrevBody = (path) => path.getPrevSibling().isBlockStatement();
-is$3.isNext = isNext$q;
+is$3.isNext = isNext$r;
 is$3.isPrev = isPrev$1;
 is$3.isNextParent = isNextParent$5;
 is$3.isParentProgram = isParentProgram$1;
@@ -77195,7 +76741,7 @@ maybeInsideFn$1.maybeInsideFn = (insideFn, {print, indent}) => {
     indent.dec();
 };
 
-const {types: types$q} = bundle;
+const {types: types$p} = bundle;
 const {
     hasTrailingComment: hasTrailingComment$3,
     satisfy: satisfy$4,
@@ -77211,7 +76757,7 @@ const {
     isClassProperty,
     isTSPropertySignature,
     isSpreadElement: isSpreadElement$2,
-} = types$q;
+} = types$p;
 
 const isProperty = satisfy$4([
     isObjectProperty$1,
@@ -77322,7 +76868,7 @@ const {
 const {
     isLast: isLast$c,
     isCoupleLines: isCoupleLines$9,
-    isNext: isNext$p,
+    isNext: isNext$q,
 } = is$3;
 
 const hasBody = (path) => path.node.body;
@@ -77406,7 +76952,7 @@ parseTrailingComments$2.parseTrailingComments = (path, {write, maybe}, semantics
             maybe.indent(!sameLine && !commentOnNextLine);
             
             if (hasBody(path)) {
-                maybe.write.breakline(!isNext$p(path));
+                maybe.write.breakline(!isNext$q(path));
                 maybe.write.breakline(!n);
             }
             
@@ -77427,7 +76973,7 @@ parseTrailingComments$2.parseTrailingComments = (path, {write, maybe}, semantics
 
 var parseComments$7 = {};
 
-const {isNext: isNext$o} = is$3;
+const {isNext: isNext$p} = is$3;
 
 parseComments$7.parseComments = (path, {write, maybe}, semantics) => {
     if (!semantics.comments)
@@ -77443,7 +76989,7 @@ parseComments$7.parseComments = (path, {write, maybe}, semantics) => {
     
     for (const [i, {type, value}] of comments.entries()) {
         if (type === 'CommentLine') {
-            maybe.write.breakline(isNext$o(path) || !program);
+            maybe.write.breakline(isNext$p(path) || !program);
             write('//');
             write(value);
             
@@ -77598,7 +77144,7 @@ arrowFunctionExpression.ArrowFunctionExpression = maybeParens$5((path, printer,
 var functionDeclaration = {};
 
 const {markAfter: markAfter$9} = mark;
-const {isNext: isNext$n, isNextParent: isNextParent$4} = is$3;
+const {isNext: isNext$o, isNextParent: isNextParent$4} = is$3;
 const {printParams: printParams$b} = params;
 
 functionDeclaration.FunctionDeclaration = {
@@ -77632,7 +77178,7 @@ functionDeclaration.FunctionDeclaration = {
         print.space();
         print('__body');
     },
-    afterSatisfy: () => [isNext$n, isNextParent$4],
+    afterSatisfy: () => [isNext$o, isNextParent$4],
     after(path, {write}) {
         write.newline();
         markAfter$9(path);
@@ -77671,7 +77217,7 @@ maybeDecorators$4.maybeDecorators = (visitor) => (path, printer, semantics, opti
     visitor(path, printer, semantics, options);
 };
 
-const {isNext: isNext$m} = is$3;
+const {isNext: isNext$n} = is$3;
 const {printParams: printParams$a} = params;
 const {maybeDecorators: maybeDecorators$3} = maybeDecorators$4;
 
@@ -77732,7 +77278,7 @@ const ClassMethod$1 = {
         print.space();
         print('__body');
     }),
-    afterSatisfy: () => [isNext$m],
+    afterSatisfy: () => [isNext$n],
     after(path, {print}) {
         print.linebreak();
     },
@@ -77838,7 +77384,7 @@ functions$1.ObjectMethod = ObjectMethod$1;
 
 var unaryExpressions$1 = {};
 
-const {isLast: isLast$b, isNext: isNext$l} = is$3;
+const {isLast: isLast$b, isNext: isNext$m} = is$3;
 
 const {maybeParens: maybeParens$3} = parens$1;
 
@@ -77882,7 +77428,7 @@ unaryExpressions$1.ThrowStatement = (path, {print, indent, maybe}) => {
     
     print(';');
     maybe.print.newline(!isLast$b(path));
-    maybe.print.breakline(isNext$l(path));
+    maybe.print.breakline(isNext$m(path));
 };
 
 function printUnary(path, name, {print}) {
@@ -78089,7 +77635,7 @@ maybeDeclare$6.maybeDeclare = (visit) => (path, printer, semantics) => {
     visit(path, printer, semantics);
 };
 
-const {isNext: isNext$k} = is$3;
+const {isNext: isNext$l} = is$3;
 const {markAfter: markAfter$8} = mark;
 
 //const {maybeDecorators} = require('../../maybe-get');
@@ -78159,7 +77705,7 @@ _class.ClassDeclaration = {
         classVisitor(path, printer, semantics);
     }),
     afterIf(path) {
-        if (!isNext$k(path))
+        if (!isNext$l(path))
             return false;
         
         return !isInsideExport(path);
@@ -78853,11 +78399,11 @@ var operate = {};
 
 var getBinding$2 = {};
 
-const {types: types$p} = bundle;
+const {types: types$o} = bundle;
 const {
     isIdentifier: isIdentifier$7,
     isMemberExpression: isMemberExpression$2,
-} = types$p;
+} = types$o;
 
 const isString$a = (a) => typeof a === 'string';
 
@@ -78884,13 +78430,13 @@ const parseName$1 = (node) => {
 
 var isSimple$2 = {};
 
-const {types: types$o} = bundle;
+const {types: types$n} = bundle;
 const {
     isOptionalMemberExpression,
     isMemberExpression: isMemberExpression$1,
     isIdentifier: isIdentifier$6,
     isLiteral: isLiteral$4,
-} = types$o;
+} = types$n;
 
 isSimple$2.isSimple = (a) => {
     if (isLiteral$4(a))
@@ -78907,7 +78453,7 @@ isSimple$2.isSimple = (a) => {
 
 var extract$6 = {};
 
-const {types: types$n} = bundle;
+const {types: types$m} = bundle;
 const {
     isArrayExpression: isArrayExpression$3,
     isLiteral: isLiteral$3,
@@ -78920,7 +78466,7 @@ const {
     isJSXText: isJSXText$2,
     isJSXAttribute: isJSXAttribute$1,
     isTSTypeReference: isTSTypeReference$2,
-} = types$n;
+} = types$m;
 
 extract$6.extract = extract$5;
 
@@ -79246,7 +78792,7 @@ setLiteralValue$2.setLiteralValue = (path, newValue) => {
     }
     
     if (raw) {
-        node.raw = raw.replace(value, newValue);
+        node.raw = `'` + String.raw`${newValue}` + `'`;
         return;
     }
     
@@ -79260,10 +78806,10 @@ var properties = {};
 
 var traverseProperties$3 = {};
 
-const {traverse: traverse$b, types: types$m} = bundle;
+const {traverse: traverse$b, types: types$l} = bundle;
 
 const {extract: extract$3} = extract$6;
-const {isObjectExpression: isObjectExpression$3} = types$m;
+const {isObjectExpression: isObjectExpression$3} = types$l;
 const nodeOrPath = (path) => path.node || path;
 
 function getNode(path) {
@@ -79354,7 +78900,7 @@ properties.getProperty = (path, name) => {
     return null;
 };
 
-const {types: types$l} = bundle;
+const {types: types$k} = bundle;
 
 const {getBinding, getBindingPath} = getBinding$2;
 const {isSimple: isSimple$1} = isSimple$2;
@@ -79382,7 +78928,7 @@ const {
     isExpression: isExpression$1,
     isStatement: isStatement$3,
     BlockStatement: BlockStatement$1,
-} = types$l;
+} = types$k;
 
 const {assign: assign$d} = Object;
 
@@ -79820,13 +79366,13 @@ newline.isCurrentNewLine = (path) => {
 
 var indent = {};
 
-const {types: types$k} = bundle;
+const {types: types$j} = bundle;
 const {isIndented} = is$3;
 
 const {
     isStringLiteral: isStringLiteral$3,
     isArrayExpression: isArrayExpression$1,
-} = types$k;
+} = types$j;
 
 const isInsideArray$1 = (path) => path.parentPath.isArrayExpression();
 
@@ -79868,7 +79414,7 @@ const isTwoLongStrings = ([a, b]) => {
     return a.node.value.length > LONG_STRING;
 };
 
-const {types: types$j} = bundle;
+const {types: types$i} = bundle;
 const {
     isCoupleLines: isCoupleLines$5,
     isStringAndIdentifier,
@@ -79892,7 +79438,7 @@ const {
     isObjectExpression: isObjectExpression$1,
     isSpreadElement,
     isStringLiteral: isStringLiteral$2,
-} = types$j;
+} = types$i;
 
 const isNextString = (path) => isStringLiteral$2(path.getNextSibling());
 const isPrevString = (path) => isStringLiteral$2(path.getPrevSibling());
@@ -80499,7 +80045,7 @@ var expressions$1 = {
 var expressionStatement = {};
 
 const {
-    isNext: isNext$j,
+    isNext: isNext$k,
     isLast: isLast$a,
     isParentBlock: isParentBlock$2,
     isParentLast,
@@ -80523,7 +80069,7 @@ const isBeforeElse = (path) => {
 const satisfyAfter = satisfy$1([
     isNotLastOrParentLast,
     isParentBlock$2,
-    isNext$j,
+    isNext$k,
     isNextUp,
 ]);
 
@@ -80540,12 +80086,12 @@ expressionStatement.ExpressionStatement = {
         print('__expression');
         print(';');
         
-        if (!isNext$j(path))
+        if (!isNext$k(path))
             return;
         
         if (shouldBreakline(path)) {
             print.newline();
-            maybe.indent(isNext$j(path) && noTrailingComment$2(path));
+            maybe.indent(isNext$k(path) && noTrailingComment$2(path));
             store(true);
         }
     },
@@ -80579,7 +80125,7 @@ function isNotLastOrParentLast(path) {
 }
 
 function isNextUp(path) {
-    return path.findParent(isNext$j);
+    return path.findParent(isNext$k);
 }
 
 function isStrictMode(path) {
@@ -80608,7 +80154,7 @@ maybeSpaceAfterKeyword$3.maybeSpaceAfterKeyword = (path, {write}) => {
 };
 
 const {
-    isNext: isNext$i,
+    isNext: isNext$j,
     isCoupleLines: isCoupleLines$3,
     isNewlineBetweenSiblings: isNewlineBetweenSiblings$1,
     exists: exists$7,
@@ -80694,7 +80240,7 @@ variableDeclaration.VariableDeclaration = {
             write.newline();
         }
         
-        if (isParentBlock$1(path) && isNext$i(path) && (noTrailingComment$1(path) || isNewlineBetweenSiblings$1(path))) {
+        if (isParentBlock$1(path) && isNext$j(path) && (noTrailingComment$1(path) || isNewlineBetweenSiblings$1(path))) {
             write.newline();
             wasNewline = true;
         }
@@ -80724,7 +80270,7 @@ variableDeclaration.VariableDeclaration = {
 };
 
 function noNextParentBlock(path) {
-    if (isNext$i(path))
+    if (isNext$j(path))
         return false;
     
     return path.parentPath.isBlockStatement();
@@ -80770,7 +80316,7 @@ function isNextCoupleLines(path) {
     return isCoupleLines$3(next);
 }
 
-const isLast$9 = (path) => path.parentPath?.isProgram() && !isNext$i(path);
+const isLast$9 = (path) => path.parentPath?.isProgram() && !isNext$j(path);
 
 function shouldAddNewlineBefore(path) {
     if (isFirst$1(path))
@@ -80813,7 +80359,7 @@ const isNextAssign = (path) => {
 var ifStatement = {};
 
 const {markAfter: markAfter$7} = mark;
-const {exists: exists$6, isNext: isNext$h} = is$3;
+const {exists: exists$6, isNext: isNext$i} = is$3;
 
 const isInside = ({parentPath}) => !parentPath.parentPath.isProgram();
 const isEmptyConsequent = (path) => path.get('consequent').isEmptyStatement();
@@ -80884,7 +80430,7 @@ ifStatement.IfStatement = {
         if (path === partOfAlternate && isInside(path))
             print.newline();
     },
-    afterSatisfy: () => [isNext$h],
+    afterSatisfy: () => [isNext$i],
     after: (path, {print}) => {
         print.linebreak();
         markAfter$7(path);
@@ -80902,7 +80448,7 @@ const {
 
 const {
     isFirst,
-    isNext: isNext$g,
+    isNext: isNext$h,
     isLast: isLast$8,
 } = is$3;
 
@@ -80939,7 +80485,7 @@ forOfStatement.ForOfStatement = {
             print('__body');
             
             const {length} = bodyPath.node.body;
-            maybe.print.newline(!length && !isLast$8(path) && !isNext$g(path));
+            maybe.print.newline(!length && !isLast$8(path) && !isNext$h(path));
             
             return;
         }
@@ -80951,7 +80497,7 @@ forOfStatement.ForOfStatement = {
         
         maybe.markAfter(isMarkedAfter$1(bodyPath), path);
     },
-    afterIf: isNext$g,
+    afterIf: isNext$h,
     after(path, {print}) {
         print.linebreak();
         markAfter$6(path);
@@ -80981,7 +80527,7 @@ var getDirectives$2 = {};
 getDirectives$2.getDirectives = (path) => !path.node.directives ? [] : path.get('directives');
 
 const {
-    isNext: isNext$f,
+    isNext: isNext$g,
     isParentProgram,
     isLast: isLast$7,
     exists: exists$4,
@@ -81061,10 +80607,10 @@ blockStatement.BlockStatement = {
 };
 
 const isTopLevelWithNoNext = (path) => {
-    if (isNext$f(path))
+    if (isNext$g(path))
         return false;
     
-    return !isNext$f(path.parentPath) && isParentProgram(path.parentPath);
+    return !isNext$g(path.parentPath) && isParentProgram(path.parentPath);
 };
 
 const isInsideIfWithoutElseInsideFn = (path) => {
@@ -81073,7 +80619,7 @@ const isInsideIfWithoutElseInsideFn = (path) => {
 
 const isEmptyBodyNoNext = (path) => {
     const {parentPath} = path;
-    return parentPath.isStatement() && !path.node.body.length && !isNext$f(parentPath);
+    return parentPath.isStatement() && !path.node.body.length && !isNext$g(parentPath);
 };
 
 const isLooksLikeInsideFn = ({parentPath}) => {
@@ -81128,7 +80674,7 @@ function isExportFunction(path) {
     if (!isExportDeclaration$2(path.parentPath?.parentPath))
         return false;
     
-    return !isNext$f(path.parentPath?.parentPath);
+    return !isNext$g(path.parentPath?.parentPath);
 }
 
 function isNextIfAlternate(path) {
@@ -81244,7 +80790,7 @@ function isJSXWithComment(path) {
 
 var tryStatements = {};
 
-const {isNext: isNext$e} = is$3;
+const {isNext: isNext$f} = is$3;
 
 tryStatements.TryStatement = {
     print(path, {print}) {
@@ -81262,7 +80808,7 @@ tryStatements.TryStatement = {
             print.newline();
         }
     },
-    afterSatisfy: () => [isNext$e],
+    afterSatisfy: () => [isNext$f],
     after(path, {maybe, print}) {
         maybe.print.newline(!path.node.finalizer);
         print.breakline();
@@ -81287,7 +80833,7 @@ tryStatements.CatchClause = (path, {print}) => {
 
 var debuggerStatement = {};
 
-const {isNext: isNext$d} = is$3;
+const {isNext: isNext$e} = is$3;
 const isInsideBlock = (path) => path.parentPath.isBlockStatement();
 const isInsideIf = (path) => path.parentPath.isIfStatement();
 
@@ -81297,7 +80843,7 @@ debuggerStatement.DebuggerStatement = {
         print('debugger;');
     },
     afterSatisfy: () => [
-        isNext$d,
+        isNext$e,
         isInsideBlock,
         isInsideIf,
     ],
@@ -81438,7 +80984,7 @@ function printAttributes(path, {write, traverse, keyword}) {
 const {parseImportSpecifiers} = parseImportSpecifiers$1;
 
 const {markAfter: markAfter$3} = mark;
-const {isLast: isLast$5, isNext: isNext$c} = is$3;
+const {isLast: isLast$5, isNext: isNext$d} = is$3;
 
 const {
     maybePrintAttributes,
@@ -81530,7 +81076,7 @@ importDeclaration.ImportDeclaration = {
         });
         print(';');
         
-        if (isNext$c(path))
+        if (isNext$d(path))
             print.newline();
     },
     afterIf(path) {
@@ -81550,7 +81096,7 @@ var exportDeclaration = {};
 const {
     isNewlineBetweenSiblings,
     exists: exists$2,
-    isNext: isNext$b,
+    isNext: isNext$c,
     isLast: isLast$4,
 } = is$3;
 
@@ -81640,7 +81186,7 @@ exportDeclaration.ExportNamedDeclaration = {
             }
             
             write(';');
-            maybe.write.newline(isNext$b(path) || isInsideNamespace(path));
+            maybe.write.newline(isNext$c(path) || isInsideNamespace(path));
             
             return;
         }
@@ -81680,7 +81226,7 @@ exportAllDeclaration.ExportAllDeclaration = (path, {print}) => {
 
 var whileStatement = {};
 
-const {isNext: isNext$a} = is$3;
+const {isNext: isNext$b} = is$3;
 const {markAfter: markAfter$1} = mark;
 
 whileStatement.WhileStatement = {
@@ -81701,7 +81247,7 @@ whileStatement.WhileStatement = {
         }
     },
     afterIf(path) {
-        return isNext$a(path);
+        return isNext$b(path);
     },
     after(path, {print}) {
         print.linebreak();
@@ -81712,7 +81258,7 @@ whileStatement.WhileStatement = {
 var switchStatement = {};
 
 const {
-    isNext: isNext$9,
+    isNext: isNext$a,
     exists: exists$1,
     isLast: isLast$3,
 } = is$3;
@@ -81778,10 +81324,10 @@ switchStatement.SwitchStatement = {
         print.indent();
         print('}');
         
-        if (!isNext$9(path) && !isLast$3(path))
+        if (!isNext$a(path) && !isLast$3(path))
             print.newline();
     },
-    afterSatisfy: () => [isNext$9],
+    afterSatisfy: () => [isNext$a],
     after(path, {print}) {
         print.breakline();
         print.newline();
@@ -81807,10 +81353,10 @@ forInStatement.ForInStatement = (path, {print}) => {
 
 var exportDefaultDeclaration = {};
 
-const {isNext: isNext$8} = is$3;
+const {isNext: isNext$9} = is$3;
 
 const notClass = (path) => {
-    if (!isNext$8(path))
+    if (!isNext$9(path))
         return false;
     
     return !path.get('declaration').isClass();
@@ -82158,7 +81704,7 @@ var tsTypeAliasDeclaration = {};
 
 const {
     isLast: isLast$1,
-    isNext: isNext$7,
+    isNext: isNext$8,
     isNextParent: isNextParent$2,
 } = is$3;
 
@@ -82191,7 +81737,7 @@ tsTypeAliasDeclaration.TSTypeAliasDeclaration = {
         if (last)
             return false;
         
-        if (!isNext$7(path) && !isNextParent$2(path))
+        if (!isNext$8(path) && !isNextParent$2(path))
             return false;
         
         return !isNextType(path);
@@ -82204,8 +81750,8 @@ tsTypeAliasDeclaration.TSTypeAliasDeclaration = {
 
 var tsMappedType = {};
 
-const {types: types$i} = bundle;
-const {isTSConditionalType} = types$i;
+const {types: types$h} = bundle;
+const {isTSConditionalType} = types$h;
 
 tsMappedType.TSMappedType = (path, {print, indent, maybe}) => {
     const {
@@ -82308,7 +81854,7 @@ tsTypeParameter.TSTypeParameter = (path, {write, traverse}) => {
 var tsDeclareFunction = {};
 
 const {printParams: printParams$7} = params;
-const {isNext: isNext$6} = is$3;
+const {isNext: isNext$7} = is$3;
 const {maybeDeclare: maybeDeclare$2} = maybeDeclare$6;
 
 const isInsideDefaultExport = (path) => {
@@ -82340,7 +81886,7 @@ tsDeclareFunction.TSDeclareFunction = {
     after: (path, {print}) => {
         print(';');
         
-        if (isNext$6(path) || isNext$6(path.parentPath) || isInsideNamedExport(path))
+        if (isNext$7(path) || isNext$7(path.parentPath) || isInsideNamedExport(path))
             print.newline();
     },
 };
@@ -82383,7 +81929,7 @@ tsDeclareMethod.TSDeclareMethod = (path, printer, semantics) => {
 
 var tsModuleDeclaration = {};
 
-const {isNext: isNext$5} = is$3;
+const {isNext: isNext$6} = is$3;
 const {maybeDeclare: maybeDeclare$1} = maybeDeclare$6;
 
 tsModuleDeclaration.TSModuleDeclaration = {
@@ -82399,7 +81945,7 @@ tsModuleDeclaration.TSModuleDeclaration = {
         print.space();
         print('__body');
     }),
-    afterSatisfy: () => [isNext$5],
+    afterSatisfy: () => [isNext$6],
     after(path, {print}) {
         print.newline();
         print.newline();
@@ -82426,7 +81972,7 @@ const {
     isExportDeclaration: isExportDeclaration$1,
 } = bundle.types;
 
-const {isNext: isNext$4, isNextParent: isNextParent$1} = is$3;
+const {isNext: isNext$5, isNextParent: isNextParent$1} = is$3;
 const {maybeDeclare} = maybeDeclare$6;
 
 tsInterfaceDeclaration.TSInterfaceDeclaration = {
@@ -82447,7 +81993,7 @@ tsInterfaceDeclaration.TSInterfaceDeclaration = {
         print('__typeParameters');
         print('__body');
     }),
-    afterSatisfy: () => [isNext$4, isNextParent$1],
+    afterSatisfy: () => [isNext$5, isNextParent$1],
     after(path, {print}) {
         print.breakline();
         
@@ -82520,7 +82066,7 @@ const {maybePrintTypeAnnotation: maybePrintTypeAnnotation$1} = maybeTypeAnnotati
 
 const {
     hasTrailingComment,
-    isNext: isNext$3,
+    isNext: isNext$4,
 } = is$3;
 
 tsPropertySignature.TSPropertySignature = (path, printer) => {
@@ -82543,7 +82089,7 @@ tsPropertySignature.TSPropertySignature = (path, printer) => {
         write.newline();
     }
     
-    if (isNext$3(path) && hasTrailingComment(path))
+    if (isNext$4(path) && hasTrailingComment(path))
         write.newline();
 };
 
@@ -82574,7 +82120,7 @@ tsFunctionType.TSFunctionType = maybeParens((path, printer, semantics) => {
 
 var tsEnumDeclaration = {};
 
-const {isNext: isNext$2, isNextParent} = is$3;
+const {isNext: isNext$3, isNextParent} = is$3;
 
 tsEnumDeclaration.TSEnumDeclaration = {
     beforeIf(path) {
@@ -82601,7 +82147,7 @@ tsEnumDeclaration.TSEnumDeclaration = {
         indent.dec();
         print('}');
     },
-    afterSatisfy: () => [isNext$2, isNextParent],
+    afterSatisfy: () => [isNext$3, isNextParent],
     after(path, {print}) {
         print.breakline();
     },
@@ -82747,10 +82293,18 @@ tsImportType.TSImportType = (path, printer, semantics) => {
 
 var tsExportAssignment = {};
 
-tsExportAssignment.TSExportAssignment = (path, {print}) => {
-    print('export = ');
-    print('__expression');
-    print(';');
+const {isNext: isNext$2} = is$3;
+
+tsExportAssignment.TSExportAssignment = {
+    print: (path, {print}) => {
+        print('export = ');
+        print('__expression');
+        print(';');
+    },
+    afterSatisfy: () => [isNext$2],
+    after: (path, {print}) => {
+        print.newline();
+    },
 };
 
 const {isNext: isNext$1} = is$3;
@@ -83287,7 +82841,7 @@ function snakeCase(str) {
 }
 
 const {stringify: stringify$8} = JSON;
-const {TYPES: TYPES$2} = types$r;
+const {TYPES: TYPES$2} = types$q;
 const toSnakeCase = justSnakeCase;
 
 const {codeFrameColumns: codeFrameColumns$1} = bundle;
@@ -83412,7 +82966,7 @@ const {round} = Math;
 const fullstore$2 = fullstore$3;
 const isObject$4 = (a) => a && typeof a === 'object';
 const babelTraverse$2 = bundle.traverse;
-const {TYPES: TYPES$1} = types$r;
+const {TYPES: TYPES$1} = types$q;
 const baseVisitors = visitors$1;
 
 const {
@@ -84305,7 +83859,7 @@ var getAst = (node) => {
     return ast;
 };
 
-const {traverse: traverse$a, types: types$h} = bundle;
+const {traverse: traverse$a, types: types$g} = bundle;
 
 const traverseObjectExpression = traverseObjectExpression$1;
 const setClassMethod = setClassMethod$1;
@@ -84332,7 +83886,7 @@ const getAST = getAst;
 const {
     isObjectExpression,
     isExportDeclaration,
-} = types$h;
+} = types$g;
 
 var estreeToBabel = (node) => {
     const ast = getAST(node);
@@ -92946,7 +92500,7 @@ function requireEspree () {
 	    };
 	};
 
-	const version$1 = "9.6.1";
+	const version$1 = "10.0.1";
 
 	/* eslint-disable jsdoc/no-multi-asterisks -- needed to preserve original formatting of licences */
 
@@ -104462,7 +104016,7 @@ function isAbsolute(path) {
 }
 
 // posix version
-function join$1() {
+function join$2() {
   var paths = Array.prototype.slice.call(arguments, 0);
   return normalize(filter$1(paths, function(p, index) {
     if (typeof p !== 'string') {
@@ -104557,7 +104111,7 @@ var _polyfillNode_path = {
   sep: sep,
   delimiter: delimiter,
   relative: relative$1,
-  join: join$1,
+  join: join$2,
   isAbsolute: isAbsolute,
   normalize: normalize,
   resolve: resolve
@@ -104588,7 +104142,7 @@ var _polyfillNode_path$1 = /*#__PURE__*/Object.freeze({
 	dirname: dirname$1,
 	extname: extname,
 	isAbsolute: isAbsolute,
-	join: join$1,
+	join: join$2,
 	normalize: normalize,
 	relative: relative$1,
 	resolve: resolve,
@@ -109731,11 +109285,11 @@ function customParse(source, {parser, isTS, isFlow, isJSX}) {
     return commonjsRequire(parser).parse(source);
 }
 
-const {types: types$g} = bundle;
+const {types: types$f} = bundle;
 const {
     StringLiteral: StringLiteral$3,
     ExpressionStatement,
-} = types$g;
+} = types$f;
 
 const {assign: assign$7} = Object;
 
@@ -109765,7 +109319,7 @@ const toBabel = estreeToBabel;
 const customParser = customParser$1;
 const moveOutDirectives = moveOutDirectives$1;
 
-var parse$4 = (source, options) => {
+var parse$5 = (source, options) => {
     const {
         parser,
         printer = 'putout',
@@ -109810,7 +109364,7 @@ function getParser({parser = 'babel', isTS, isFlow, isJSX, printer}) {
     };
 }
 
-parse$4.default;
+parse$5.default;
 
 const {generate: generate$4} = bundle;
 
@@ -109949,8 +109503,20 @@ var require$$0$1 = /*@__PURE__*/getAugmentedNamespace(nanoMemoize);
 	    ],
 	};
 
-	const {isExpressionStatement} = types;
-	const extractExpression = (a) => isExpressionStatement(a) ? a.expression : a;
+	const {
+	    isExpressionStatement,
+	    isTSExternalModuleReference,
+	} = types;
+
+	const extractExpression = (a) => {
+	    if (isExpressionStatement(a))
+	        return a.expression;
+	    
+	    if (isTSExternalModuleReference(a))
+	        return a.expression;
+	    
+	    return a;
+	};
 
 	module.exports = nanomemoize((value, options) => {
 	    const fn = template(value, {
@@ -109998,19 +109564,21 @@ var require$$0$1 = /*@__PURE__*/getAugmentedNamespace(nanoMemoize);
 	    });
 	    
 	    return extractExpression(result);
-	}; 
+	};
+
+	module.exports.extractExpression = extractExpression; 
 } (template$a));
 
 var templateExports$1 = template$a.exports;
 templateExports$1.default;
 
 const print$3 = print$4;
-const parse$3 = parse$4;
+const parse$4 = parse$5;
 const generate$3 = generate_1$1;
 const template$9 = templateExports$1;
 
 parser$6.print = print$3;
-parser$6.parse = parse$3;
+parser$6.parse = parse$4;
 parser$6.generate = generate$3;
 parser$6.template = template$9;
 
@@ -111773,7 +111341,7 @@ const {merge: merge$2} = traverse$9.visitors;
 
 const {assign: assign$3} = Object;
 
-const parse$2 = (name, plugin, options) => {
+const parse$3 = (name, plugin, options) => {
     const list = [];
     
     if (plugin[name])
@@ -111823,8 +111391,8 @@ var mergeVisitors$1 = (pluginsToMerge, {fix, shebang, template}) => {
             throw Error(`☝️ Visitors cannot be empty in "${rule}"`);
         
         assign$3(options, {
-            include: parse$2('include', plugin, options),
-            exclude: parse$2('exclude', plugin, options),
+            include: parse$3('include', plugin, options),
+            exclude: parse$3('exclude', plugin, options),
         });
         
         mergeItems.push(...template({
@@ -111896,7 +111464,7 @@ function getStore(plugin, {fix, rule, shebang, msg, options}) {
 
 mergeVisitors$1.default;
 
-const {traverse: babelTraverse$1, types: types$f} = bundle;
+const {traverse: babelTraverse$1, types: types$e} = bundle;
 
 const {generate: generate$1} = parser$6;
 const {merge: merge$1} = babelTraverse$1.visitors;
@@ -111915,7 +111483,7 @@ var superFind$1 = function superFind({rule, find, ast, options, template}) {
             template,
         }),
         generate: generate$1,
-        types: types$f,
+        types: types$e,
         push,
         options,
     });
@@ -112101,7 +111669,7 @@ function check$5(selector) {
 var is$2 = {};
 
 const {template: template$8} = parser$6;
-const {types: types$e} = bundle;
+const {types: types$d} = bundle;
 const {
     isBlockStatement: isBlockStatement$1,
     isBooleanLiteral,
@@ -112117,7 +111685,7 @@ const {
     isJSXIdentifier,
     isJSXAttribute,
     isTSTypeReference: isTSTypeReference$1,
-} = types$e;
+} = types$d;
 
 const isStr$1 = (a) => typeof a === 'string';
 
@@ -112418,7 +111986,7 @@ is$2.isInsideTypeReference = (path) => path.isIdentifier() && path.parentPath?.i
 
 const jessy = jessy$1;
 const nessy = nessy$1;
-const {traverse: traverse$7, types: types$d} = bundle;
+const {traverse: traverse$7, types: types$c} = bundle;
 const {template: template$7} = parser$6;
 
 const {replaceWith: replaceWith$3, extract} = operate;
@@ -112440,12 +112008,13 @@ const {
     isLiteral: isLiteral$1,
     isTemplateLiteral,
     TemplateElement,
-} = types$d;
+} = types$c;
+
+const {extractExpression: extractExpression$1} = template$7;
 
 const {entries: entries$6} = Object;
 const isNumber = (a) => typeof a === 'number';
 const isString$5 = (a) => typeof a === 'string';
-const parseExpression = (a) => a?.expression || a;
 
 const parseNode$1 = (a) => a.node || a;
 
@@ -112522,7 +112091,7 @@ function getValues$2({waysFrom, node}) {
             if (!isJSXElement(node))
                 way = way.replace(/\.expression$/, '');
             
-            result[name] = result[name] || parseExpression(jessy(way, node));
+            result[name] = result[name] || extractExpression$1(jessy(way, node));
         }
     }
     
@@ -112534,7 +112103,7 @@ const makeRaw = (a) => a.replace('`', '\\`');
 vars.setValues = setValues$2;
 
 function setValues$2({waysTo, values, path}) {
-    const node = parseExpression(path.node);
+    const node = extractExpression$1(path.node);
     
     for (const [name, ways] of entries$6(waysTo)) {
         for (let way of ways) {
@@ -112618,14 +112187,14 @@ function parseValue(a) {
 
 var logExports = log$4.exports;
 
-const {types: types$c} = bundle;
+const {types: types$b} = bundle;
 const {
     isIdentifier: isIdentifier$1,
     isLiteral,
     isStringLiteral: isStringLiteral$1,
     isTemplateElement: isTemplateElement$1,
     isTSTypeReference,
-} = types$c;
+} = types$b;
 
 const parseName = (node) => {
     node = node[0] || node;
@@ -112690,13 +112259,13 @@ const {
     isLinkedRegExp: isLinkedRegExp$1,
 } = is$2;
 
-const {types: types$b} = bundle;
+const {types: types$a} = bundle;
 const {
     isClassBody,
     isBlock,
     isJSXText,
     isTemplateElement,
-} = types$b;
+} = types$a;
 
 const isEmptyBlock = (a) => isBlock(a) && !a.body.length;
 const isPrimitive = (a) => typeof a !== 'object' || a === null;
@@ -112803,7 +112372,7 @@ function compareJSXTexts(node, template) {
 
 var topLevelComparators = {};
 
-const {types: types$a} = bundle;
+const {types: types$9} = bundle;
 const {
     isEqualBody,
     isEqualAnyObject,
@@ -112817,7 +112386,7 @@ const {
 const {
     isIdentifier,
     isStringLiteral,
-} = types$a;
+} = types$9;
 
 const comparators = [
     isEqualAnyObject,
@@ -112853,7 +112422,6 @@ function isLinkedAndStringLiteral(node, templateNode) {
 }
 
 const {template: template$6} = parser$6;
-const {types: types$9} = bundle;
 
 const {
     findVarsWays: findVarsWays$1,
@@ -112873,7 +112441,7 @@ const {
     parseTemplate: parseTemplate$2,
 } = is$2;
 
-const {isExpressionStatement: isExpressionStatement$1} = types$9;
+const {extractExpression} = template$6;
 
 const {keys: keys$2} = Object;
 const {isArray: isArray$4} = Array;
@@ -112881,7 +112449,6 @@ const noop$2 = () => {};
 const isEmptyArray = (a) => isArray$4(a) && !a.length;
 
 const compareType = (type) => (path) => path.type === type;
-const extractExpression = (a) => isExpressionStatement$1(a) ? a.expression : a;
 const superPush = (array) => (a, b) => array.push([a, b]);
 const maybeArray$3 = (a) => isArray$4(a) ? a : [a];
 
@@ -113225,7 +112792,7 @@ replace$1.exports.clearWatermark = (ast) => {
 
 const isFn$2 = (a) => typeof a === 'function';
 
-const fix$3 = (from, to, path) => {
+const fix$4 = (from, to, path) => {
     const nodeFrom = template$5.ast(from);
     const mark = watermark(from, to, path);
     
@@ -113276,7 +112843,7 @@ const fix$3 = (from, to, path) => {
 
 const getFix = (items) => (path) => {
     for (const [from, to] of entries$4(items))
-        fix$3(from, to, path);
+        fix$4(from, to, path);
 };
 
 const getFilter = (match = stubMatch, options) => (path) => {
@@ -113424,13 +112991,13 @@ const TS_EXCLUDE = [
 ];
 
 declare$2.declare = (declarations) => ({
-    report: report$3,
+    report: report$4,
     include: include$1,
-    fix: fix$2(declarations),
+    fix: fix$3(declarations),
     filter: filter(declarations),
 });
 
-const report$3 = (path) => {
+const report$4 = (path) => {
     const {name} = path.node;
     const peaceOfName = cutName(name);
     
@@ -113472,7 +113039,7 @@ const filter = (declarations) => (path, {options}) => {
     return parseCode(type, allDeclarations[name]);
 };
 
-const fix$2 = (declarations) => (path, {options}) => {
+const fix$3 = (declarations) => (path, {options}) => {
     const type = getModuleType(path);
     
     const allDeclarations = {
@@ -113657,7 +113224,7 @@ function deinit() {
     assign$2(maybeFS$1, defaultFS);
 }
 
-const {join, basename: basename$1} = require$$0$2;
+const {join: join$1, basename: basename$1} = require$$0$2;
 const tryCatch$1 = tryCatch$5;
 const {types: types$5} = bundle;
 
@@ -113716,9 +113283,9 @@ filesystem.getParentDirectory = (filePath) => {
     return parentPath;
 };
 
-filesystem.findFile = findFile$4;
+filesystem.findFile = findFile$5;
 
-function findFile$4(node, name) {
+function findFile$5(node, name) {
     checkName(name);
     
     const filePaths = [];
@@ -113747,7 +113314,7 @@ function getFilenamePath(filePath) {
     return filenamePath.get('value');
 }
 
-function getFilename$3(filePath) {
+function getFilename$4(filePath) {
     const {value} = getFilenamePath(filePath).node;
     return value;
 }
@@ -113770,10 +113337,10 @@ function getFileContent(filePath) {
     ];
 }
 
-filesystem.getFilename = getFilename$3;
+filesystem.getFilename = getFilename$4;
 
 filesystem.renameFile = (filePath, name) => {
-    const oldName = getFilename$3(filePath);
+    const oldName = getFilename$4(filePath);
     const valuePath = getFilenamePath(filePath);
     const baseName = oldName
         .split('/')
@@ -113790,7 +113357,7 @@ filesystem.renameFile = (filePath, name) => {
 };
 
 filesystem.removeFile = (filePath) => {
-    const filename = getFilename$3(filePath);
+    const filename = getFilename$4(filePath);
     
     filePath.remove();
     maybeFS.removeFile(filename);
@@ -113800,8 +113367,8 @@ filesystem.moveFile = (filePath, dirPath) => {
     if (filePath === dirPath)
         return;
     
-    const dirname = getFilename$3(dirPath);
-    const filename = getFilename$3(filePath);
+    const dirname = getFilename$4(dirPath);
+    const filename = getFilename$4(filePath);
     const dirPathFiles = getProperty$2(dirPath, 'files');
     const filenamePath = getProperty$2(filePath, 'filename');
     
@@ -113809,7 +113376,7 @@ filesystem.moveFile = (filePath, dirPath) => {
         .split('/')
         .pop();
     
-    const newFilename = join(dirname, basename);
+    const newFilename = join$1(dirname, basename);
     
     maybeRemoveFile(dirPath, newFilename);
     
@@ -113821,14 +113388,14 @@ filesystem.moveFile = (filePath, dirPath) => {
 };
 
 filesystem.copyFile = (filePath, dirPath) => {
-    const dirname = getFilename$3(dirPath);
-    const filename = getFilename$3(filePath);
+    const dirname = getFilename$4(dirPath);
+    const filename = getFilename$4(filePath);
     
     const basename = filename
         .split('/')
         .pop();
     
-    const newFilename = join(dirname, basename);
+    const newFilename = join$1(dirname, basename);
     const [hasContent, content] = getFileContent(filePath);
     
     const copiedFile = ObjectExpression$1([
@@ -113849,12 +113416,12 @@ function maybeRemoveFile(dirPath, filename) {
     const type = getFileType$2(dirPath);
     
     if (type !== 'directory') {
-        const filename = getFilename$3(dirPath);
+        const filename = getFilename$4(dirPath);
         throw Error(`☝️ Looks like '${filename}' is not a directory, but: '${type}'. Rename to '${filename}/'`);
     }
     
     const dirPathFiles = getProperty$2(dirPath, 'files');
-    const [fileToOverwrite] = findFile$4(dirPathFiles, filename);
+    const [fileToOverwrite] = findFile$5(dirPathFiles, filename);
     
     if (!fileToOverwrite)
         return;
@@ -113882,8 +113449,8 @@ filesystem.createFile = (dirPath, name, content) => {
     maybeRemoveFile(dirPath, name);
     
     const dirPathFiles = getFiles$1(dirPath);
-    const parentFilename = getFilename$3(dirPath);
-    const filename = join(parentFilename, name);
+    const parentFilename = getFilename$4(dirPath);
+    const filename = join$1(parentFilename, name);
     
     const typeProperty = createTypeProperty('file');
     const filenameProperty = createFilenameProperty(filename);
@@ -113912,8 +113479,8 @@ function getFiles$1(dirPath) {
 
 filesystem.createDirectory = (dirPath, name) => {
     const dirPathFiles = getFiles$1(dirPath);
-    const parentFilename = getFilename$3(dirPath);
-    const filename = join(parentFilename, name);
+    const parentFilename = getFilename$4(dirPath);
+    const filename = join$1(parentFilename, name);
     
     const typeProperty = createTypeProperty('directory');
     const filesProperty = createFilesProperty([]);
@@ -113943,7 +113510,7 @@ filesystem.readFileContent = (filePath) => {
     if (hasContent)
         return fromBase64(content);
     
-    const filename = getFilename$3(filePath);
+    const filename = getFilename$4(filePath);
     const fileContent = maybeFS.readFileContent(filename);
     
     const property = createContentProperty(toBase64(fileContent));
@@ -113961,7 +113528,7 @@ function writeFileContent$1(filePath, content) {
     if (fileType === 'directory')
         return;
     
-    const filename = getFilename$3(filePath);
+    const filename = getFilename$4(filePath);
     
     maybeFS.writeFileContent(filename, content);
     
@@ -113989,8 +113556,8 @@ const {basename, dirname} = require$$0$2;
 const {
     createDirectory,
     getFileType: getFileType$1,
-    getFilename: getFilename$2,
-    findFile: findFile$3,
+    getFilename: getFilename$3,
+    findFile: findFile$4,
 } = filesystem;
 
 const {__filesystem_name: __filesystem_name$2} = json;
@@ -114072,17 +113639,17 @@ const noTrailingSlash = (a) => {
 };
 
 function buildTree(path, list) {
-    const [root, ...files] = findFile$3(list, '*');
+    const [root, ...files] = findFile$4(list, '*');
     
     for (const filePath of files) {
-        const filename = getFilename$2(filePath);
+        const filename = getFilename$3(filePath);
         
         check$2(filename);
         
         const type = getFileType$1(filePath);
         const dir = dirname(filename);
         const name = basename(filename);
-        const [dirPath] = findFile$3(root, dir);
+        const [dirPath] = findFile$4(root, dir);
         
         if (!dirPath)
             throw Error(`☝️ Looks like directory '${dir}/' is missing`);
@@ -114111,8 +113678,8 @@ const {replaceWith, getProperty} = operate;
 const {__filesystem_name: __filesystem_name$1} = json;
 
 const {
-    findFile: findFile$2,
-    getFilename: getFilename$1,
+    findFile: findFile$3,
+    getFilename: getFilename$2,
     getFileType,
 } = filesystem;
 
@@ -114130,7 +113697,7 @@ convertFilesystemToSimpleFilesystem.fix = (root, {files}) => {
     const names = [];
     
     for (const file of files) {
-        const filename = getFilename$1(file);
+        const filename = getFilename$2(file);
         const type = getFileType(file);
         const contentPath = getProperty(file, 'content');
         const content = contentPath?.node?.value;
@@ -114168,7 +113735,7 @@ convertFilesystemToSimpleFilesystem.fix = (root, {files}) => {
 convertFilesystemToSimpleFilesystem.traverse = ({push}) => ({
     [`${__filesystem_name$1}(__object)`]: (path) => {
         const root = path.get('arguments.0');
-        const files = findFile$2(root, '*');
+        const files = findFile$3(root, '*');
         
         push(root, {
             files,
@@ -114181,7 +113748,7 @@ const {compare: compare$1} = compare$5;
 const {__filesystem_name} = json;
 
 const {
-    findFile: findFile$1,
+    findFile: findFile$2,
     pause,
     start,
 } = filesystem;
@@ -114236,7 +113803,7 @@ const createFileProgress = ({rule, progress}) => ({i, n}) => {
 };
 
 const createTrackFile = (fileProgress) => function*(...a) {
-    const files = findFile$1(...a);
+    const files = findFile$2(...a);
     const n = files.length;
     
     for (const [i, file] of files.entries()) {
@@ -114249,7 +113816,7 @@ const createTrackFile = (fileProgress) => function*(...a) {
 };
 
 const getTraverse = ({scan, rule, progress}) => ({push, options}) => ({
-    ['__putout_processor_filesystem(__)'](path) {
+    [`${__filesystem_name}(__)`](path) {
         log$1(rule);
         progress.start(rule);
         
@@ -115304,7 +114871,7 @@ findPlaces$2.findPlacesAsync = async (ast, source, opts) => {
 const {isArray} = Array;
 const noop = () => {};
 
-var report$2 = () => {
+var report$3 = () => {
     let filesCount = 0;
     let errorsCount = 0;
     
@@ -115354,7 +114921,7 @@ var report$2 = () => {
     };
 };
 
-report$2.default;
+report$3.default;
 
 var traverse$5 = {};
 
@@ -122577,15 +122144,15 @@ const isCall = (path) => {
     return isCallExpression(path.find(isCallOrStatement));
 };
 
-const report$1 = ({name}) => `Argument '${name}' is missing`;
+const report$2 = ({name}) => `Argument '${name}' is missing`;
 
 addArgs.addArgs = (args) => ({
-    report: report$1,
-    fix: fix$1,
+    report: report$2,
+    fix: fix$2,
     traverse: traverse$1(args),
 });
 
-const fix$1 = ({declaration, path, pattern, params, index}) => {
+const fix$2 = ({declaration, path, pattern, params, index}) => {
     const declarationNode = template$1.ast.fresh(declaration);
     
     if (isBlockStatement(declarationNode)) {
@@ -123348,7 +122915,7 @@ function mergeIgnores(ignores) {
 
 ignores$1.default;
 
-const {parse: parse$1, print: print$1} = parser$6;
+const {parse: parse$2, print: print$1} = parser$6;
 const {transform: transform$1} = transform$5;
 const {findPlaces: findPlaces$1} = findPlaces$2;
 const ignores = ignores$1;
@@ -123356,30 +122923,30 @@ const ignores = ignores$1;
 const {toJS, fromJS} = json;
 
 const {
-    readFileContent,
-    findFile,
+    readFileContent: readFileContent$1,
+    findFile: findFile$1,
     writeFileContent,
-    getFilename,
+    getFilename: getFilename$1,
     createFile,
-    getParentDirectory,
+    getParentDirectory: getParentDirectory$1,
 } = filesystem;
 
 const isObject = (a) => a && typeof a === 'object';
 const {entries} = Object;
-const report = (path, {message}) => message;
+const report$1 = (path, {message}) => message;
 
 matchFiles.matchFiles = (files) => {
     check$1(files);
     const scan = createScan(files);
     
     return {
-        fix,
+        fix: fix$1,
         scan,
-        report,
+        report: report$1,
     };
 };
 
-function fix(path, {outputFilename, matchedJS, matchedAST, plugins}) {
+function fix$1(path, {outputFilename, matchedJS, matchedAST, plugins}) {
     transform$1(matchedAST, matchedJS, {
         plugins,
     });
@@ -123391,15 +122958,15 @@ function fix(path, {outputFilename, matchedJS, matchedAST, plugins}) {
 
 const createScan = (files) => (path, {push, progress, options}) => {
     const allFiles = [];
-    const cwd = getFilename(path);
+    const cwd = getFilename$1(path);
     
     for (const [filename, plugin] of entries(files)) {
         const [matchInputFilename, outputFilename = matchInputFilename] = parseMatcher(filename, options);
-        const inputFiles = findFile(path, matchInputFilename);
+        const inputFiles = findFile$1(path, matchInputFilename);
         
         for (const inputFile of inputFiles) {
-            const dirPath = getParentDirectory(inputFile);
-            const inputFilename = getFilename(inputFile);
+            const dirPath = getParentDirectory$1(inputFile);
+            const inputFilename = getFilename$1(inputFile);
             const outputFile = getOutputFile(path, {
                 dirPath,
                 matchInputFilename,
@@ -123428,7 +122995,7 @@ const createScan = (files) => (path, {push, progress, options}) => {
             n,
         });
         
-        const fileContent = readFileContent(inputFile) || '{}';
+        const fileContent = readFileContent$1(inputFile) || '{}';
         const [matchedJS, matchedAST] = magicParse(inputFilename, fileContent);
         
         const name = `match-file: ${inputFilename}`;
@@ -123459,20 +123026,20 @@ const createScan = (files) => (path, {push, progress, options}) => {
 function magicParse(name, content) {
     if (/\.json$/.test(name)) {
         const js = toJS(content);
-        const ast = parse$1(js);
+        const ast = parse$2(js);
         
         return [js, ast];
     }
     
     if (/\.(c|m)?ts(x)?$/.test(name)) {
-        const ast = parse$1(content, {
+        const ast = parse$2(content, {
             isTS: true,
         });
         
         return [content, ast];
     }
     
-    return [content, parse$1(content)];
+    return [content, parse$2(content)];
 }
 
 function magicPrint(name, ast) {
@@ -123496,7 +123063,7 @@ function getOutputFile(path, {dirPath, matchInputFilename, outputFilename, input
     if (matchInputFilename === outputFilename)
         return inputFile;
     
-    const [outputFile] = findFile(dirPath, outputFilename);
+    const [outputFile] = findFile$1(dirPath, outputFilename);
     
     if (outputFile)
         return outputFile;
@@ -123517,6 +123084,83 @@ function parseMatcher(matcher, options) {
     return matcher.split(' -> ');
 }
 
+var renameFiles = {};
+
+const {join} = require$$0$2;
+
+const {
+    getParentDirectory,
+    getFilename,
+    readFileContent,
+    findFile,
+    renameFile,
+} = filesystem;
+
+const {parse: parse$1} = JSON;
+
+renameFiles.renameFiles = ({type, mask, rename}) => ({
+    report,
+    fix,
+    scan: scan({
+        type,
+        mask,
+        rename,
+    }),
+});
+
+const report = (file, {from, to}) => `Rename '${from}' to '${to}'`;
+
+const fix = (file, {to}) => {
+    renameFile(file, to);
+};
+
+const scan = ({type, mask, rename}) => (path, {push, trackFile}) => {
+    for (const file of trackFile(path, mask)) {
+        if (type && !checkType(type, file))
+            continue;
+        
+        const from = getFilename(file);
+        const to = rename(from);
+        
+        push(file, {
+            from,
+            to,
+        });
+    }
+};
+
+function checkType(type, file) {
+    const packagePath = findUpPackage(file);
+    
+    if (type === 'commonjs' && !packagePath)
+        return true;
+    
+    if (!packagePath)
+        return false;
+    
+    const packageContent = readFileContent(packagePath);
+    
+    if (!packageContent)
+        return false;
+    
+    const info = parse$1(packageContent);
+    const infoType = info.type || 'commonjs';
+    
+    return infoType === type;
+}
+
+function findUpPackage(file) {
+    let packageJSON;
+    let dirPath = getParentDirectory(file);
+    
+    do {
+        const dir = getFilename(dirPath);
+        [packageJSON] = findFile(dirPath, join(dir, 'package.json'));
+    } while (!packageJSON && (dirPath = getParentDirectory(dirPath)));
+    
+    return packageJSON;
+}
+
 const {codeFrameColumns} = bundle;
 
 var codeframe = ({source, error, highlightCode = true}) => {
@@ -123660,7 +123304,7 @@ var traverse_1 = putout.exports.traverse = traverse;
 var types_1 = putout.exports.types = types;
 var template_1 = putout.exports.template = template;
 var generate_1 = putout.exports.generate = generate;
-putout.exports.initReport = report$2;
+putout.exports.initReport = report$3;
 
 var operator = putout.exports.operator = {
     ...operate,
@@ -123672,6 +123316,7 @@ var operator = putout.exports.operator = {
     ...addArgs,
     ...filesystem,
     ...matchFiles,
+    ...renameFiles,
 };
 
 putout.exports.ignores = ignores$1;