Ajout de promotion et de commande

node_modules/@babel/generator/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/@babel/generator/README.md

@@ -0,0 +1,19 @@
+# @babel/generator
+
+> Turns an AST into code.
+
+See our website [@babel/generator](https://babeljs.io/docs/babel-generator) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20generator%22+is%3Aopen) associated with this package.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/generator
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/generator --dev
+```

node_modules/@babel/generator/lib/buffer.js

@@ -0,0 +1,244 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const spaceIndents = [];
+for (let i = 0; i < 32; i++) {
+  spaceIndents.push(" ".repeat(i * 2));
+}
+class Buffer {
+  constructor(map, indentChar) {
+    this._map = null;
+    this._buf = "";
+    this._str = "";
+    this._appendCount = 0;
+    this._last = 0;
+    this._canMarkIdName = true;
+    this._indentChar = "";
+    this._queuedChar = 0;
+    this._position = {
+      line: 1,
+      column: 0
+    };
+    this._sourcePosition = {
+      identifierName: undefined,
+      identifierNamePos: undefined,
+      line: undefined,
+      column: undefined,
+      filename: undefined
+    };
+    this._map = map;
+    this._indentChar = indentChar;
+  }
+  get() {
+    const {
+      _map,
+      _last
+    } = this;
+    if (this._queuedChar !== 32) {
+      this._flush();
+    }
+    const code = _last === 10 ? (this._buf + this._str).trimRight() : this._buf + this._str;
+    if (_map === null) {
+      return {
+        code: code,
+        decodedMap: undefined,
+        map: null,
+        rawMappings: undefined
+      };
+    }
+    const result = {
+      code: code,
+      decodedMap: _map.getDecoded(),
+      get __mergedMap() {
+        return this.map;
+      },
+      get map() {
+        const resultMap = _map.get();
+        result.map = resultMap;
+        return resultMap;
+      },
+      set map(value) {
+        Object.defineProperty(result, "map", {
+          value,
+          writable: true
+        });
+      },
+      get rawMappings() {
+        const mappings = _map.getRawMappings();
+        result.rawMappings = mappings;
+        return mappings;
+      },
+      set rawMappings(value) {
+        Object.defineProperty(result, "rawMappings", {
+          value,
+          writable: true
+        });
+      }
+    };
+    return result;
+  }
+  append(str, maybeNewline) {
+    this._flush();
+    this._append(str, maybeNewline);
+  }
+  appendChar(char) {
+    this._flush();
+    this._appendChar(char, 1, true);
+  }
+  queue(char) {
+    this._flush();
+    this._queuedChar = char;
+  }
+  _flush() {
+    const queuedChar = this._queuedChar;
+    if (queuedChar !== 0) {
+      this._appendChar(queuedChar, 1, true);
+      this._queuedChar = 0;
+    }
+  }
+  _appendChar(char, repeat, useSourcePos) {
+    this._last = char;
+    if (char === -1) {
+      const indent = repeat >= 64 ? this._indentChar.repeat(repeat) : spaceIndents[repeat / 2];
+      this._str += indent;
+    } else {
+      this._str += repeat > 1 ? String.fromCharCode(char).repeat(repeat) : String.fromCharCode(char);
+    }
+    const isSpace = char === 32;
+    const position = this._position;
+    if (char !== 10) {
+      if (this._map) {
+        const sourcePos = this._sourcePosition;
+        if (useSourcePos && sourcePos) {
+          this._map.mark(position, sourcePos.line, sourcePos.column, isSpace ? undefined : sourcePos.identifierName, isSpace ? undefined : sourcePos.identifierNamePos, sourcePos.filename);
+          if (!isSpace && this._canMarkIdName) {
+            sourcePos.identifierName = undefined;
+            sourcePos.identifierNamePos = undefined;
+          }
+        } else {
+          this._map.mark(position);
+        }
+      }
+      position.column += repeat;
+    } else {
+      position.line++;
+      position.column = 0;
+    }
+  }
+  _append(str, maybeNewline) {
+    const len = str.length;
+    const position = this._position;
+    const sourcePos = this._sourcePosition;
+    this._last = -1;
+    if (++this._appendCount > 4096) {
+      +this._str;
+      this._buf += this._str;
+      this._str = str;
+      this._appendCount = 0;
+    } else {
+      this._str += str;
+    }
+    const hasMap = this._map !== null;
+    if (!maybeNewline && !hasMap) {
+      position.column += len;
+      return;
+    }
+    const {
+      column,
+      identifierName,
+      identifierNamePos,
+      filename
+    } = sourcePos;
+    let line = sourcePos.line;
+    if ((identifierName != null || identifierNamePos != null) && this._canMarkIdName) {
+      sourcePos.identifierName = undefined;
+      sourcePos.identifierNamePos = undefined;
+    }
+    let i = str.indexOf("\n");
+    let last = 0;
+    if (hasMap && i !== 0) {
+      this._map.mark(position, line, column, identifierName, identifierNamePos, filename);
+    }
+    while (i !== -1) {
+      position.line++;
+      position.column = 0;
+      last = i + 1;
+      if (last < len && line !== undefined) {
+        line++;
+        if (hasMap) {
+          this._map.mark(position, line, 0, undefined, undefined, filename);
+        }
+      }
+      i = str.indexOf("\n", last);
+    }
+    position.column += len - last;
+  }
+  removeLastSemicolon() {
+    if (this._queuedChar === 59) {
+      this._queuedChar = 0;
+    }
+  }
+  getLastChar(checkQueue) {
+    if (!checkQueue) {
+      return this._last;
+    }
+    const queuedChar = this._queuedChar;
+    return queuedChar !== 0 ? queuedChar : this._last;
+  }
+  getNewlineCount() {
+    return this._queuedChar === 0 && this._last === 10 ? 1 : 0;
+  }
+  hasContent() {
+    return this._last !== 0;
+  }
+  exactSource(loc, cb) {
+    if (!this._map) {
+      cb();
+      return;
+    }
+    this.source("start", loc);
+    const identifierName = loc.identifierName;
+    const sourcePos = this._sourcePosition;
+    if (identifierName != null) {
+      this._canMarkIdName = false;
+      sourcePos.identifierName = identifierName;
+    }
+    cb();
+    if (identifierName != null) {
+      this._canMarkIdName = true;
+      sourcePos.identifierName = undefined;
+      sourcePos.identifierNamePos = undefined;
+    }
+    this.source("end", loc);
+  }
+  source(prop, loc) {
+    if (!this._map) return;
+    this._normalizePosition(prop, loc, 0);
+  }
+  sourceWithOffset(prop, loc, columnOffset) {
+    if (!this._map) return;
+    this._normalizePosition(prop, loc, columnOffset);
+  }
+  _normalizePosition(prop, loc, columnOffset) {
+    this._flush();
+    const pos = loc[prop];
+    const target = this._sourcePosition;
+    if (pos) {
+      target.line = pos.line;
+      target.column = Math.max(pos.column + columnOffset, 0);
+      target.filename = loc.filename;
+    }
+  }
+  getCurrentColumn() {
+    return this._position.column + (this._queuedChar ? 1 : 0);
+  }
+  getCurrentLine() {
+    return this._position.line;
+  }
+}
+exports.default = Buffer;
+
+//# sourceMappingURL=buffer.js.map

node_modules/@babel/generator/lib/generators/base.js

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BlockStatement = BlockStatement;
+exports.Directive = Directive;
+exports.DirectiveLiteral = DirectiveLiteral;
+exports.File = File;
+exports.InterpreterDirective = InterpreterDirective;
+exports.Placeholder = Placeholder;
+exports.Program = Program;
+function File(node) {
+  if (node.program) {
+    this.print(node.program.interpreter);
+  }
+  this.print(node.program);
+}
+function Program(node) {
+  var _node$directives;
+  this.printInnerComments(false);
+  const directivesLen = (_node$directives = node.directives) == null ? void 0 : _node$directives.length;
+  if (directivesLen) {
+    var _node$directives$trai;
+    const newline = node.body.length ? 2 : 1;
+    this.printSequence(node.directives, undefined, undefined, newline);
+    if (!((_node$directives$trai = node.directives[directivesLen - 1].trailingComments) != null && _node$directives$trai.length)) {
+      this.newline(newline);
+    }
+  }
+  this.printSequence(node.body);
+}
+function BlockStatement(node) {
+  var _node$directives2;
+  this.tokenChar(123);
+  const oldNoLineTerminatorAfterNode = this.enterDelimited();
+  const directivesLen = (_node$directives2 = node.directives) == null ? void 0 : _node$directives2.length;
+  if (directivesLen) {
+    var _node$directives$trai2;
+    const newline = node.body.length ? 2 : 1;
+    this.printSequence(node.directives, true, true, newline);
+    if (!((_node$directives$trai2 = node.directives[directivesLen - 1].trailingComments) != null && _node$directives$trai2.length)) {
+      this.newline(newline);
+    }
+  }
+  this.printSequence(node.body, true, true);
+  this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+  this.rightBrace(node);
+}
+function Directive(node) {
+  this.print(node.value);
+  this.semicolon();
+}
+const unescapedSingleQuoteRE = /(?:^|[^\\])(?:\\\\)*'/;
+const unescapedDoubleQuoteRE = /(?:^|[^\\])(?:\\\\)*"/;
+function DirectiveLiteral(node) {
+  const raw = this.getPossibleRaw(node);
+  if (!this.format.minified && raw !== undefined) {
+    this.token(raw);
+    return;
+  }
+  const {
+    value
+  } = node;
+  if (!unescapedDoubleQuoteRE.test(value)) {
+    this.token(`"${value}"`);
+  } else if (!unescapedSingleQuoteRE.test(value)) {
+    this.token(`'${value}'`);
+  } else {
+    throw new Error("Malformed AST: it is not possible to print a directive containing" + " both unescaped single and double quotes.");
+  }
+}
+function InterpreterDirective(node) {
+  this.token(`#!${node.value}`);
+  this._newline();
+}
+function Placeholder(node) {
+  this.token("%%");
+  this.print(node.name);
+  this.token("%%");
+  if (node.expectedNode === "Statement") {
+    this.semicolon();
+  }
+}
+
+//# sourceMappingURL=base.js.map

node_modules/@babel/generator/lib/generators/classes.js

@@ -0,0 +1,215 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ClassAccessorProperty = ClassAccessorProperty;
+exports.ClassBody = ClassBody;
+exports.ClassExpression = exports.ClassDeclaration = ClassDeclaration;
+exports.ClassMethod = ClassMethod;
+exports.ClassPrivateMethod = ClassPrivateMethod;
+exports.ClassPrivateProperty = ClassPrivateProperty;
+exports.ClassProperty = ClassProperty;
+exports.StaticBlock = StaticBlock;
+exports._classMethodHead = _classMethodHead;
+var _t = require("@babel/types");
+var _expressions = require("./expressions.js");
+var _typescript = require("./typescript.js");
+var _flow = require("./flow.js");
+var _methods = require("./methods.js");
+const {
+  isExportDefaultDeclaration,
+  isExportNamedDeclaration
+} = _t;
+function ClassDeclaration(node, parent) {
+  const inExport = isExportDefaultDeclaration(parent) || isExportNamedDeclaration(parent);
+  if (!inExport || !_expressions._shouldPrintDecoratorsBeforeExport.call(this, parent)) {
+    this.printJoin(node.decorators);
+  }
+  if (node.declare) {
+    this.word("declare");
+    this.space();
+  }
+  if (node.abstract) {
+    this.word("abstract");
+    this.space();
+  }
+  this.word("class");
+  if (node.id) {
+    this.space();
+    this.print(node.id);
+  }
+  this.print(node.typeParameters);
+  if (node.superClass) {
+    this.space();
+    this.word("extends");
+    this.space();
+    this.print(node.superClass);
+    this.print(node.superTypeParameters);
+  }
+  if (node.implements) {
+    this.space();
+    this.word("implements");
+    this.space();
+    this.printList(node.implements);
+  }
+  this.space();
+  this.print(node.body);
+}
+function ClassBody(node) {
+  this.tokenChar(123);
+  if (node.body.length === 0) {
+    this.tokenChar(125);
+  } else {
+    const separator = classBodyEmptySemicolonsPrinter(this, node);
+    separator == null || separator(-1);
+    const oldNoLineTerminatorAfterNode = this.enterDelimited();
+    this.printJoin(node.body, true, true, separator, true, true);
+    this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+    if (!this.endsWith(10)) this.newline();
+    this.rightBrace(node);
+  }
+}
+function classBodyEmptySemicolonsPrinter(printer, node) {
+  if (!printer.tokenMap || node.start == null || node.end == null) {
+    return null;
+  }
+  const indexes = printer.tokenMap.getIndexes(node);
+  if (!indexes) return null;
+  let k = 1;
+  let occurrenceCount = 0;
+  let nextLocIndex = 0;
+  const advanceNextLocIndex = () => {
+    while (nextLocIndex < node.body.length && node.body[nextLocIndex].start == null) {
+      nextLocIndex++;
+    }
+  };
+  advanceNextLocIndex();
+  return i => {
+    if (nextLocIndex <= i) {
+      nextLocIndex = i + 1;
+      advanceNextLocIndex();
+    }
+    const end = nextLocIndex === node.body.length ? node.end : node.body[nextLocIndex].start;
+    let tok;
+    while (k < indexes.length && printer.tokenMap.matchesOriginal(tok = printer._tokens[indexes[k]], ";") && tok.start < end) {
+      printer.tokenChar(59, occurrenceCount++);
+      k++;
+    }
+  };
+}
+function ClassProperty(node) {
+  this.printJoin(node.decorators);
+  if (!node.static && !this.format.preserveFormat) {
+    var _node$key$loc;
+    const endLine = (_node$key$loc = node.key.loc) == null || (_node$key$loc = _node$key$loc.end) == null ? void 0 : _node$key$loc.line;
+    if (endLine) this.catchUp(endLine);
+  }
+  _typescript._tsPrintClassMemberModifiers.call(this, node);
+  if (node.computed) {
+    this.tokenChar(91);
+    this.print(node.key);
+    this.tokenChar(93);
+  } else {
+    _flow._variance.call(this, node);
+    this.print(node.key);
+  }
+  if (node.optional) {
+    this.tokenChar(63);
+  }
+  if (node.definite) {
+    this.tokenChar(33);
+  }
+  this.print(node.typeAnnotation);
+  if (node.value) {
+    this.space();
+    this.tokenChar(61);
+    this.space();
+    this.print(node.value);
+  }
+  this.semicolon();
+}
+function ClassAccessorProperty(node) {
+  var _node$key$loc2;
+  this.printJoin(node.decorators);
+  const endLine = (_node$key$loc2 = node.key.loc) == null || (_node$key$loc2 = _node$key$loc2.end) == null ? void 0 : _node$key$loc2.line;
+  if (endLine) this.catchUp(endLine);
+  _typescript._tsPrintClassMemberModifiers.call(this, node);
+  this.word("accessor", true);
+  this.space();
+  if (node.computed) {
+    this.tokenChar(91);
+    this.print(node.key);
+    this.tokenChar(93);
+  } else {
+    _flow._variance.call(this, node);
+    this.print(node.key);
+  }
+  if (node.optional) {
+    this.tokenChar(63);
+  }
+  if (node.definite) {
+    this.tokenChar(33);
+  }
+  this.print(node.typeAnnotation);
+  if (node.value) {
+    this.space();
+    this.tokenChar(61);
+    this.space();
+    this.print(node.value);
+  }
+  this.semicolon();
+}
+function ClassPrivateProperty(node) {
+  this.printJoin(node.decorators);
+  _typescript._tsPrintClassMemberModifiers.call(this, node);
+  this.print(node.key);
+  if (node.optional) {
+    this.tokenChar(63);
+  }
+  if (node.definite) {
+    this.tokenChar(33);
+  }
+  this.print(node.typeAnnotation);
+  if (node.value) {
+    this.space();
+    this.tokenChar(61);
+    this.space();
+    this.print(node.value);
+  }
+  this.semicolon();
+}
+function ClassMethod(node) {
+  _classMethodHead.call(this, node);
+  this.space();
+  this.print(node.body);
+}
+function ClassPrivateMethod(node) {
+  _classMethodHead.call(this, node);
+  this.space();
+  this.print(node.body);
+}
+function _classMethodHead(node) {
+  this.printJoin(node.decorators);
+  if (!this.format.preserveFormat) {
+    var _node$key$loc3;
+    const endLine = (_node$key$loc3 = node.key.loc) == null || (_node$key$loc3 = _node$key$loc3.end) == null ? void 0 : _node$key$loc3.line;
+    if (endLine) this.catchUp(endLine);
+  }
+  _typescript._tsPrintClassMemberModifiers.call(this, node);
+  _methods._methodHead.call(this, node);
+}
+function StaticBlock(node) {
+  this.word("static");
+  this.space();
+  this.tokenChar(123);
+  if (node.body.length === 0) {
+    this.tokenChar(125);
+  } else {
+    this.newline();
+    this.printSequence(node.body, true);
+    this.rightBrace(node);
+  }
+}
+
+//# sourceMappingURL=classes.js.map

node_modules/@babel/generator/lib/generators/deprecated.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DecimalLiteral = DecimalLiteral;
+exports.Noop = Noop;
+exports.RecordExpression = RecordExpression;
+exports.TSExpressionWithTypeArguments = TSExpressionWithTypeArguments;
+exports.TupleExpression = TupleExpression;
+function Noop() {}
+function TSExpressionWithTypeArguments(node) {
+  this.print(node.expression);
+  this.print(node.typeParameters);
+}
+function DecimalLiteral(node) {
+  const raw = this.getPossibleRaw(node);
+  if (!this.format.minified && raw !== undefined) {
+    this.word(raw);
+    return;
+  }
+  this.word(node.value + "m");
+}
+function RecordExpression(node) {
+  const props = node.properties;
+  let startToken;
+  let endToken;
+  if (this.format.recordAndTupleSyntaxType === "bar") {
+    startToken = "{|";
+    endToken = "|}";
+  } else if (this.format.recordAndTupleSyntaxType !== "hash" && this.format.recordAndTupleSyntaxType != null) {
+    throw new Error(`The "recordAndTupleSyntaxType" generator option must be "bar" or "hash" (${JSON.stringify(this.format.recordAndTupleSyntaxType)} received).`);
+  } else {
+    startToken = "#{";
+    endToken = "}";
+  }
+  this.token(startToken);
+  if (props.length) {
+    this.space();
+    this.printList(props, this.shouldPrintTrailingComma(endToken), true, true);
+    this.space();
+  }
+  this.token(endToken);
+}
+function TupleExpression(node) {
+  const elems = node.elements;
+  const len = elems.length;
+  let startToken;
+  let endToken;
+  if (this.format.recordAndTupleSyntaxType === "bar") {
+    startToken = "[|";
+    endToken = "|]";
+  } else if (this.format.recordAndTupleSyntaxType === "hash") {
+    startToken = "#[";
+    endToken = "]";
+  } else {
+    throw new Error(`${this.format.recordAndTupleSyntaxType} is not a valid recordAndTuple syntax type`);
+  }
+  this.token(startToken);
+  for (let i = 0; i < elems.length; i++) {
+    const elem = elems[i];
+    if (elem) {
+      if (i > 0) this.space();
+      this.print(elem);
+      if (i < len - 1 || this.shouldPrintTrailingComma(endToken)) {
+        this.token(",", false, i);
+      }
+    }
+  }
+  this.token(endToken);
+}
+
+//# sourceMappingURL=deprecated.js.map

node_modules/@babel/generator/lib/generators/expressions.js

@@ -0,0 +1,309 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LogicalExpression = exports.AssignmentExpression = AssignmentExpression;
+exports.AssignmentPattern = AssignmentPattern;
+exports.AwaitExpression = AwaitExpression;
+exports.BinaryExpression = BinaryExpression;
+exports.BindExpression = BindExpression;
+exports.CallExpression = CallExpression;
+exports.ConditionalExpression = ConditionalExpression;
+exports.Decorator = Decorator;
+exports.DoExpression = DoExpression;
+exports.EmptyStatement = EmptyStatement;
+exports.ExpressionStatement = ExpressionStatement;
+exports.Import = Import;
+exports.MemberExpression = MemberExpression;
+exports.MetaProperty = MetaProperty;
+exports.ModuleExpression = ModuleExpression;
+exports.NewExpression = NewExpression;
+exports.OptionalCallExpression = OptionalCallExpression;
+exports.OptionalMemberExpression = OptionalMemberExpression;
+exports.ParenthesizedExpression = ParenthesizedExpression;
+exports.PrivateName = PrivateName;
+exports.SequenceExpression = SequenceExpression;
+exports.Super = Super;
+exports.ThisExpression = ThisExpression;
+exports.UnaryExpression = UnaryExpression;
+exports.UpdateExpression = UpdateExpression;
+exports.V8IntrinsicIdentifier = V8IntrinsicIdentifier;
+exports.YieldExpression = YieldExpression;
+exports._shouldPrintDecoratorsBeforeExport = _shouldPrintDecoratorsBeforeExport;
+var _t = require("@babel/types");
+var _index = require("../node/index.js");
+const {
+  isCallExpression,
+  isLiteral,
+  isMemberExpression,
+  isNewExpression,
+  isPattern
+} = _t;
+function UnaryExpression(node) {
+  const {
+    operator
+  } = node;
+  const firstChar = operator.charCodeAt(0);
+  if (firstChar >= 97 && firstChar <= 122) {
+    this.word(operator);
+    this.space();
+  } else {
+    this.tokenChar(firstChar);
+  }
+  this.print(node.argument);
+}
+function DoExpression(node) {
+  if (node.async) {
+    this.word("async", true);
+    this.space();
+  }
+  this.word("do");
+  this.space();
+  this.print(node.body);
+}
+function ParenthesizedExpression(node) {
+  this.tokenChar(40);
+  const oldNoLineTerminatorAfterNode = this.enterDelimited();
+  this.print(node.expression, undefined, true);
+  this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+  this.rightParens(node);
+}
+function UpdateExpression(node) {
+  if (node.prefix) {
+    this.token(node.operator, false, 0, true);
+    this.print(node.argument);
+  } else {
+    this.print(node.argument, true);
+    this.token(node.operator, false, 0, true);
+  }
+}
+function ConditionalExpression(node) {
+  this.print(node.test);
+  this.space();
+  this.tokenChar(63);
+  this.space();
+  this.print(node.consequent);
+  this.space();
+  this.tokenChar(58);
+  this.space();
+  this.print(node.alternate);
+}
+function NewExpression(node, parent) {
+  this.word("new");
+  this.space();
+  this.print(node.callee);
+  if (this.format.minified && node.arguments.length === 0 && !node.optional && !isCallExpression(parent, {
+    callee: node
+  }) && !isMemberExpression(parent) && !isNewExpression(parent)) {
+    return;
+  }
+  this.print(node.typeArguments);
+  this.print(node.typeParameters);
+  if (node.optional) {
+    this.token("?.");
+  }
+  if (node.arguments.length === 0 && this.tokenMap && !this.tokenMap.endMatches(node, ")")) {
+    return;
+  }
+  this.tokenChar(40);
+  const oldNoLineTerminatorAfterNode = this.enterDelimited();
+  this.printList(node.arguments, this.shouldPrintTrailingComma(")"), undefined, undefined, undefined, true);
+  this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+  this.rightParens(node);
+}
+function SequenceExpression(node) {
+  this.printList(node.expressions);
+}
+function ThisExpression() {
+  this.word("this");
+}
+function Super() {
+  this.word("super");
+}
+function _shouldPrintDecoratorsBeforeExport(node) {
+  if (typeof this.format.decoratorsBeforeExport === "boolean") {
+    return this.format.decoratorsBeforeExport;
+  }
+  return typeof node.start === "number" && node.start === node.declaration.start;
+}
+function Decorator(node) {
+  this.tokenChar(64);
+  const {
+    expression
+  } = node;
+  this.print(expression);
+  this.newline();
+}
+function OptionalMemberExpression(node) {
+  let {
+    computed
+  } = node;
+  const {
+    optional,
+    property
+  } = node;
+  this.print(node.object);
+  if (!computed && isMemberExpression(property)) {
+    throw new TypeError("Got a MemberExpression for MemberExpression property");
+  }
+  if (isLiteral(property) && typeof property.value === "number") {
+    computed = true;
+  }
+  if (optional) {
+    this.token("?.");
+  }
+  if (computed) {
+    this.tokenChar(91);
+    this.print(property);
+    this.tokenChar(93);
+  } else {
+    if (!optional) {
+      this.tokenChar(46);
+    }
+    this.print(property);
+  }
+}
+function OptionalCallExpression(node) {
+  this.print(node.callee);
+  this.print(node.typeParameters);
+  if (node.optional) {
+    this.token("?.");
+  }
+  this.print(node.typeArguments);
+  this.tokenChar(40);
+  const oldNoLineTerminatorAfterNode = this.enterDelimited();
+  this.printList(node.arguments, undefined, undefined, undefined, undefined, true);
+  this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+  this.rightParens(node);
+}
+function CallExpression(node) {
+  this.print(node.callee);
+  this.print(node.typeArguments);
+  this.print(node.typeParameters);
+  this.tokenChar(40);
+  const oldNoLineTerminatorAfterNode = this.enterDelimited();
+  this.printList(node.arguments, this.shouldPrintTrailingComma(")"), undefined, undefined, undefined, true);
+  this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+  this.rightParens(node);
+}
+function Import() {
+  this.word("import");
+}
+function AwaitExpression(node) {
+  this.word("await");
+  this.space();
+  this.print(node.argument);
+}
+function YieldExpression(node) {
+  if (node.delegate) {
+    this.word("yield", true);
+    this.tokenChar(42);
+    if (node.argument) {
+      this.space();
+      this.print(node.argument);
+    }
+  } else if (node.argument) {
+    this.word("yield", true);
+    this.space();
+    this.print(node.argument);
+  } else {
+    this.word("yield");
+  }
+}
+function EmptyStatement() {
+  this.semicolon(true);
+}
+function ExpressionStatement(node) {
+  this.tokenContext |= _index.TokenContext.expressionStatement;
+  this.print(node.expression);
+  this.semicolon();
+}
+function AssignmentPattern(node) {
+  this.print(node.left);
+  if (node.left.type === "Identifier" || isPattern(node.left)) {
+    if (node.left.optional) this.tokenChar(63);
+    this.print(node.left.typeAnnotation);
+  }
+  this.space();
+  this.tokenChar(61);
+  this.space();
+  this.print(node.right);
+}
+function AssignmentExpression(node) {
+  this.print(node.left);
+  this.space();
+  this.token(node.operator, false, 0, true);
+  this.space();
+  this.print(node.right);
+}
+function BinaryExpression(node) {
+  this.print(node.left);
+  this.space();
+  const {
+    operator
+  } = node;
+  if (operator.charCodeAt(0) === 105) {
+    this.word(operator);
+  } else {
+    this.token(operator, false, 0, true);
+    this.setLastChar(operator.charCodeAt(operator.length - 1));
+  }
+  this.space();
+  this.print(node.right);
+}
+function BindExpression(node) {
+  this.print(node.object);
+  this.token("::");
+  this.print(node.callee);
+}
+function MemberExpression(node) {
+  this.print(node.object);
+  if (!node.computed && isMemberExpression(node.property)) {
+    throw new TypeError("Got a MemberExpression for MemberExpression property");
+  }
+  let computed = node.computed;
+  if (isLiteral(node.property) && typeof node.property.value === "number") {
+    computed = true;
+  }
+  if (computed) {
+    const oldNoLineTerminatorAfterNode = this.enterDelimited();
+    this.tokenChar(91);
+    this.print(node.property, undefined, true);
+    this.tokenChar(93);
+    this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+  } else {
+    this.tokenChar(46);
+    this.print(node.property);
+  }
+}
+function MetaProperty(node) {
+  this.print(node.meta);
+  this.tokenChar(46);
+  this.print(node.property);
+}
+function PrivateName(node) {
+  this.tokenChar(35);
+  this.print(node.id);
+}
+function V8IntrinsicIdentifier(node) {
+  this.tokenChar(37);
+  this.word(node.name);
+}
+function ModuleExpression(node) {
+  this.word("module", true);
+  this.space();
+  this.tokenChar(123);
+  this.indent();
+  const {
+    body
+  } = node;
+  if (body.body.length || body.directives.length) {
+    this.newline();
+  }
+  this.print(body);
+  this.dedent();
+  this.rightBrace(node);
+}
+
+//# sourceMappingURL=expressions.js.map

node_modules/@babel/generator/lib/generators/index.js

@@ -0,0 +1,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _templateLiterals = require("./template-literals.js");
+Object.keys(_templateLiterals).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _templateLiterals[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _templateLiterals[key];
+    }
+  });
+});
+var _expressions = require("./expressions.js");
+Object.keys(_expressions).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _expressions[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _expressions[key];
+    }
+  });
+});
+var _statements = require("./statements.js");
+Object.keys(_statements).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _statements[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _statements[key];
+    }
+  });
+});
+var _classes = require("./classes.js");
+Object.keys(_classes).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _classes[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _classes[key];
+    }
+  });
+});
+var _methods = require("./methods.js");
+Object.keys(_methods).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _methods[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _methods[key];
+    }
+  });
+});
+var _modules = require("./modules.js");
+Object.keys(_modules).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _modules[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _modules[key];
+    }
+  });
+});
+var _types = require("./types.js");
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _types[key];
+    }
+  });
+});
+var _flow = require("./flow.js");
+Object.keys(_flow).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _flow[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _flow[key];
+    }
+  });
+});
+var _base = require("./base.js");
+Object.keys(_base).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _base[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _base[key];
+    }
+  });
+});
+var _jsx = require("./jsx.js");
+Object.keys(_jsx).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _jsx[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _jsx[key];
+    }
+  });
+});
+var _typescript = require("./typescript.js");
+Object.keys(_typescript).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _typescript[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _typescript[key];
+    }
+  });
+});
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/generator/lib/generators/jsx.js

@@ -0,0 +1,124 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.JSXAttribute = JSXAttribute;
+exports.JSXClosingElement = JSXClosingElement;
+exports.JSXClosingFragment = JSXClosingFragment;
+exports.JSXElement = JSXElement;
+exports.JSXEmptyExpression = JSXEmptyExpression;
+exports.JSXExpressionContainer = JSXExpressionContainer;
+exports.JSXFragment = JSXFragment;
+exports.JSXIdentifier = JSXIdentifier;
+exports.JSXMemberExpression = JSXMemberExpression;
+exports.JSXNamespacedName = JSXNamespacedName;
+exports.JSXOpeningElement = JSXOpeningElement;
+exports.JSXOpeningFragment = JSXOpeningFragment;
+exports.JSXSpreadAttribute = JSXSpreadAttribute;
+exports.JSXSpreadChild = JSXSpreadChild;
+exports.JSXText = JSXText;
+function JSXAttribute(node) {
+  this.print(node.name);
+  if (node.value) {
+    this.tokenChar(61);
+    this.print(node.value);
+  }
+}
+function JSXIdentifier(node) {
+  this.word(node.name);
+}
+function JSXNamespacedName(node) {
+  this.print(node.namespace);
+  this.tokenChar(58);
+  this.print(node.name);
+}
+function JSXMemberExpression(node) {
+  this.print(node.object);
+  this.tokenChar(46);
+  this.print(node.property);
+}
+function JSXSpreadAttribute(node) {
+  this.tokenChar(123);
+  this.token("...");
+  this.print(node.argument);
+  this.rightBrace(node);
+}
+function JSXExpressionContainer(node) {
+  this.tokenChar(123);
+  this.print(node.expression);
+  this.rightBrace(node);
+}
+function JSXSpreadChild(node) {
+  this.tokenChar(123);
+  this.token("...");
+  this.print(node.expression);
+  this.rightBrace(node);
+}
+function JSXText(node) {
+  const raw = this.getPossibleRaw(node);
+  if (raw !== undefined) {
+    this.token(raw, true);
+  } else {
+    this.token(node.value, true);
+  }
+}
+function JSXElement(node) {
+  const open = node.openingElement;
+  this.print(open);
+  if (open.selfClosing) return;
+  this.indent();
+  for (const child of node.children) {
+    this.print(child);
+  }
+  this.dedent();
+  this.print(node.closingElement);
+}
+function spaceSeparator() {
+  this.space();
+}
+function JSXOpeningElement(node) {
+  this.tokenChar(60);
+  this.print(node.name);
+  if (node.typeArguments) {
+    this.print(node.typeArguments);
+  }
+  this.print(node.typeParameters);
+  if (node.attributes.length > 0) {
+    this.space();
+    this.printJoin(node.attributes, undefined, undefined, spaceSeparator);
+  }
+  if (node.selfClosing) {
+    this.space();
+    this.tokenChar(47);
+  }
+  this.tokenChar(62);
+}
+function JSXClosingElement(node) {
+  this.tokenChar(60);
+  this.tokenChar(47);
+  this.print(node.name);
+  this.tokenChar(62);
+}
+function JSXEmptyExpression() {
+  this.printInnerComments();
+}
+function JSXFragment(node) {
+  this.print(node.openingFragment);
+  this.indent();
+  for (const child of node.children) {
+    this.print(child);
+  }
+  this.dedent();
+  this.print(node.closingFragment);
+}
+function JSXOpeningFragment() {
+  this.tokenChar(60);
+  this.tokenChar(62);
+}
+function JSXClosingFragment() {
+  this.token("</");
+  this.tokenChar(62);
+}
+
+//# sourceMappingURL=jsx.js.map

node_modules/@babel/generator/lib/generators/methods.js

@@ -0,0 +1,207 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ArrowFunctionExpression = ArrowFunctionExpression;
+exports.FunctionDeclaration = exports.FunctionExpression = FunctionExpression;
+exports._functionHead = _functionHead;
+exports._methodHead = _methodHead;
+exports._param = _param;
+exports._parameters = _parameters;
+exports._params = _params;
+exports._predicate = _predicate;
+exports._shouldPrintArrowParamsParens = _shouldPrintArrowParamsParens;
+var _t = require("@babel/types");
+var _index = require("../node/index.js");
+const {
+  isIdentifier
+} = _t;
+function _params(node, noLineTerminator, idNode, parentNode) {
+  this.print(node.typeParameters);
+  if (idNode !== undefined || parentNode !== undefined) {
+    const nameInfo = _getFuncIdName.call(this, idNode, parentNode);
+    if (nameInfo) {
+      this.sourceIdentifierName(nameInfo.name, nameInfo.pos);
+    }
+  }
+  this.tokenChar(40);
+  _parameters.call(this, node.params, 41);
+  this.print(node.returnType, noLineTerminator);
+  this._noLineTerminator = noLineTerminator;
+}
+function _parameters(parameters, endToken) {
+  const oldNoLineTerminatorAfterNode = this.enterDelimited();
+  const trailingComma = this.shouldPrintTrailingComma(endToken);
+  const paramLength = parameters.length;
+  for (let i = 0; i < paramLength; i++) {
+    _param.call(this, parameters[i]);
+    if (trailingComma || i < paramLength - 1) {
+      this.tokenChar(44, i);
+      this.space();
+    }
+  }
+  this.tokenChar(endToken);
+  this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+}
+function _param(parameter) {
+  this.printJoin(parameter.decorators, undefined, undefined, undefined, undefined, true);
+  this.print(parameter, undefined, true);
+  if (parameter.optional) {
+    this.tokenChar(63);
+  }
+  this.print(parameter.typeAnnotation, undefined, true);
+}
+function _methodHead(node) {
+  const kind = node.kind;
+  const key = node.key;
+  if (kind === "get" || kind === "set") {
+    this.word(kind);
+    this.space();
+  }
+  if (node.async) {
+    this.word("async", true);
+    this.space();
+  }
+  if (kind === "method" || kind === "init") {
+    if (node.generator) {
+      this.tokenChar(42);
+    }
+  }
+  if (node.computed) {
+    this.tokenChar(91);
+    this.print(key);
+    this.tokenChar(93);
+  } else {
+    this.print(key);
+  }
+  if (node.optional) {
+    this.tokenChar(63);
+  }
+  if (this._buf._map) {
+    _params.call(this, node, false, node.computed && node.key.type !== "StringLiteral" ? undefined : node.key);
+  } else {
+    _params.call(this, node, false);
+  }
+}
+function _predicate(node, noLineTerminatorAfter) {
+  if (node.predicate) {
+    if (!node.returnType) {
+      this.tokenChar(58);
+    }
+    this.space();
+    this.print(node.predicate, noLineTerminatorAfter);
+  }
+}
+function _functionHead(node, parent, hasPredicate) {
+  if (node.async) {
+    this.word("async");
+    if (!this.format.preserveFormat) {
+      this._innerCommentsState = 0;
+    }
+    this.space();
+  }
+  this.word("function");
+  if (node.generator) {
+    if (!this.format.preserveFormat) {
+      this._innerCommentsState = 0;
+    }
+    this.tokenChar(42);
+  }
+  this.space();
+  if (node.id) {
+    this.print(node.id);
+  }
+  if (this._buf._map) {
+    _params.call(this, node, false, node.id, parent);
+  } else {
+    _params.call(this, node, false);
+  }
+  if (hasPredicate) {
+    _predicate.call(this, node);
+  }
+}
+function FunctionExpression(node, parent) {
+  _functionHead.call(this, node, parent, true);
+  this.space();
+  this.print(node.body);
+}
+function ArrowFunctionExpression(node, parent) {
+  if (node.async) {
+    this.word("async", true);
+    this.space();
+  }
+  if (_shouldPrintArrowParamsParens.call(this, node)) {
+    _params.call(this, node, true, undefined, this._buf._map ? parent : undefined);
+  } else {
+    this.print(node.params[0], true);
+  }
+  _predicate.call(this, node, true);
+  this.space();
+  this.printInnerComments();
+  this.token("=>");
+  this.space();
+  this.tokenContext |= _index.TokenContext.arrowBody;
+  this.print(node.body);
+}
+function _shouldPrintArrowParamsParens(node) {
+  var _firstParam$leadingCo, _firstParam$trailingC;
+  if (node.params.length !== 1) return true;
+  if (node.typeParameters || node.returnType || node.predicate) {
+    return true;
+  }
+  const firstParam = node.params[0];
+  if (!isIdentifier(firstParam) || firstParam.typeAnnotation || firstParam.optional || (_firstParam$leadingCo = firstParam.leadingComments) != null && _firstParam$leadingCo.length || (_firstParam$trailingC = firstParam.trailingComments) != null && _firstParam$trailingC.length) {
+    return true;
+  }
+  if (this.tokenMap) {
+    if (node.loc == null) return true;
+    if (this.tokenMap.findMatching(node, "(") !== null) return true;
+    const arrowToken = this.tokenMap.findMatching(node, "=>");
+    if ((arrowToken == null ? void 0 : arrowToken.loc) == null) return true;
+    return arrowToken.loc.start.line !== node.loc.start.line;
+  }
+  if (this.format.retainLines) return true;
+  return false;
+}
+function _getFuncIdName(idNode, parent) {
+  let id = idNode;
+  if (!id && parent) {
+    const parentType = parent.type;
+    if (parentType === "VariableDeclarator") {
+      id = parent.id;
+    } else if (parentType === "AssignmentExpression" || parentType === "AssignmentPattern") {
+      id = parent.left;
+    } else if (parentType === "ObjectProperty" || parentType === "ClassProperty") {
+      if (!parent.computed || parent.key.type === "StringLiteral") {
+        id = parent.key;
+      }
+    } else if (parentType === "ClassPrivateProperty" || parentType === "ClassAccessorProperty") {
+      id = parent.key;
+    }
+  }
+  if (!id) return;
+  let nameInfo;
+  if (id.type === "Identifier") {
+    var _id$loc, _id$loc2;
+    nameInfo = {
+      pos: (_id$loc = id.loc) == null ? void 0 : _id$loc.start,
+      name: ((_id$loc2 = id.loc) == null ? void 0 : _id$loc2.identifierName) || id.name
+    };
+  } else if (id.type === "PrivateName") {
+    var _id$loc3;
+    nameInfo = {
+      pos: (_id$loc3 = id.loc) == null ? void 0 : _id$loc3.start,
+      name: "#" + id.id.name
+    };
+  } else if (id.type === "StringLiteral") {
+    var _id$loc4;
+    nameInfo = {
+      pos: (_id$loc4 = id.loc) == null ? void 0 : _id$loc4.start,
+      name: id.value
+    };
+  }
+  return nameInfo;
+}
+
+//# sourceMappingURL=methods.js.map

node_modules/@babel/generator/lib/generators/modules.js

@@ -0,0 +1,290 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ExportAllDeclaration = ExportAllDeclaration;
+exports.ExportDefaultDeclaration = ExportDefaultDeclaration;
+exports.ExportDefaultSpecifier = ExportDefaultSpecifier;
+exports.ExportNamedDeclaration = ExportNamedDeclaration;
+exports.ExportNamespaceSpecifier = ExportNamespaceSpecifier;
+exports.ExportSpecifier = ExportSpecifier;
+exports.ImportAttribute = ImportAttribute;
+exports.ImportDeclaration = ImportDeclaration;
+exports.ImportDefaultSpecifier = ImportDefaultSpecifier;
+exports.ImportExpression = ImportExpression;
+exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier;
+exports.ImportSpecifier = ImportSpecifier;
+exports._printAttributes = _printAttributes;
+var _t = require("@babel/types");
+var _index = require("../node/index.js");
+var _expressions = require("./expressions.js");
+const {
+  isClassDeclaration,
+  isExportDefaultSpecifier,
+  isExportNamespaceSpecifier,
+  isImportDefaultSpecifier,
+  isImportNamespaceSpecifier,
+  isStatement
+} = _t;
+function ImportSpecifier(node) {
+  if (node.importKind === "type" || node.importKind === "typeof") {
+    this.word(node.importKind);
+    this.space();
+  }
+  this.print(node.imported);
+  if (node.local && node.local.name !== node.imported.name) {
+    this.space();
+    this.word("as");
+    this.space();
+    this.print(node.local);
+  }
+}
+function ImportDefaultSpecifier(node) {
+  this.print(node.local);
+}
+function ExportDefaultSpecifier(node) {
+  this.print(node.exported);
+}
+function ExportSpecifier(node) {
+  if (node.exportKind === "type") {
+    this.word("type");
+    this.space();
+  }
+  this.print(node.local);
+  if (node.exported && node.local.name !== node.exported.name) {
+    this.space();
+    this.word("as");
+    this.space();
+    this.print(node.exported);
+  }
+}
+function ExportNamespaceSpecifier(node) {
+  this.tokenChar(42);
+  this.space();
+  this.word("as");
+  this.space();
+  this.print(node.exported);
+}
+let warningShown = false;
+function _printAttributes(node, hasPreviousBrace) {
+  var _node$extra;
+  const {
+    attributes
+  } = node;
+  var {
+    assertions
+  } = node;
+  const {
+    importAttributesKeyword
+  } = this.format;
+  if (attributes && !importAttributesKeyword && node.extra && (node.extra.deprecatedAssertSyntax || node.extra.deprecatedWithLegacySyntax) && !warningShown) {
+    warningShown = true;
+    console.warn(`\
+You are using import attributes, without specifying the desired output syntax.
+Please specify the "importAttributesKeyword" generator option, whose value can be one of:
+ - "with"        : \`import { a } from "b" with { type: "json" };\`
+ - "assert"      : \`import { a } from "b" assert { type: "json" };\`
+ - "with-legacy" : \`import { a } from "b" with type: "json";\`
+`);
+  }
+  const useAssertKeyword = importAttributesKeyword === "assert" || !importAttributesKeyword && assertions;
+  this.word(useAssertKeyword ? "assert" : "with");
+  this.space();
+  if (!useAssertKeyword && (importAttributesKeyword === "with-legacy" || !importAttributesKeyword && (_node$extra = node.extra) != null && _node$extra.deprecatedWithLegacySyntax)) {
+    this.printList(attributes || assertions);
+    return;
+  }
+  const occurrenceCount = hasPreviousBrace ? 1 : 0;
+  this.token("{", undefined, occurrenceCount);
+  this.space();
+  this.printList(attributes || assertions, this.shouldPrintTrailingComma("}"));
+  this.space();
+  this.token("}", undefined, occurrenceCount);
+}
+function ExportAllDeclaration(node) {
+  var _node$attributes, _node$assertions;
+  this.word("export");
+  this.space();
+  if (node.exportKind === "type") {
+    this.word("type");
+    this.space();
+  }
+  this.tokenChar(42);
+  this.space();
+  this.word("from");
+  this.space();
+  if ((_node$attributes = node.attributes) != null && _node$attributes.length || (_node$assertions = node.assertions) != null && _node$assertions.length) {
+    this.print(node.source, true);
+    this.space();
+    _printAttributes.call(this, node, false);
+  } else {
+    this.print(node.source);
+  }
+  this.semicolon();
+}
+function maybePrintDecoratorsBeforeExport(printer, node) {
+  if (isClassDeclaration(node.declaration) && _expressions._shouldPrintDecoratorsBeforeExport.call(printer, node)) {
+    printer.printJoin(node.declaration.decorators);
+  }
+}
+function ExportNamedDeclaration(node) {
+  maybePrintDecoratorsBeforeExport(this, node);
+  this.word("export");
+  this.space();
+  if (node.declaration) {
+    const declar = node.declaration;
+    this.print(declar);
+    if (!isStatement(declar)) this.semicolon();
+  } else {
+    if (node.exportKind === "type") {
+      this.word("type");
+      this.space();
+    }
+    const specifiers = node.specifiers.slice(0);
+    let hasSpecial = false;
+    for (;;) {
+      const first = specifiers[0];
+      if (isExportDefaultSpecifier(first) || isExportNamespaceSpecifier(first)) {
+        hasSpecial = true;
+        this.print(specifiers.shift());
+        if (specifiers.length) {
+          this.tokenChar(44);
+          this.space();
+        }
+      } else {
+        break;
+      }
+    }
+    let hasBrace = false;
+    if (specifiers.length || !specifiers.length && !hasSpecial) {
+      hasBrace = true;
+      this.tokenChar(123);
+      if (specifiers.length) {
+        this.space();
+        this.printList(specifiers, this.shouldPrintTrailingComma("}"));
+        this.space();
+      }
+      this.tokenChar(125);
+    }
+    if (node.source) {
+      var _node$attributes2, _node$assertions2;
+      this.space();
+      this.word("from");
+      this.space();
+      if ((_node$attributes2 = node.attributes) != null && _node$attributes2.length || (_node$assertions2 = node.assertions) != null && _node$assertions2.length) {
+        this.print(node.source, true);
+        this.space();
+        _printAttributes.call(this, node, hasBrace);
+      } else {
+        this.print(node.source);
+      }
+    }
+    this.semicolon();
+  }
+}
+function ExportDefaultDeclaration(node) {
+  maybePrintDecoratorsBeforeExport(this, node);
+  this.word("export");
+  this.noIndentInnerCommentsHere();
+  this.space();
+  this.word("default");
+  this.space();
+  this.tokenContext |= _index.TokenContext.exportDefault;
+  const declar = node.declaration;
+  this.print(declar);
+  if (!isStatement(declar)) this.semicolon();
+}
+function ImportDeclaration(node) {
+  var _node$attributes3, _node$assertions3;
+  this.word("import");
+  this.space();
+  const isTypeKind = node.importKind === "type" || node.importKind === "typeof";
+  if (isTypeKind) {
+    this.noIndentInnerCommentsHere();
+    this.word(node.importKind);
+    this.space();
+  } else if (node.module) {
+    this.noIndentInnerCommentsHere();
+    this.word("module");
+    this.space();
+  } else if (node.phase) {
+    this.noIndentInnerCommentsHere();
+    this.word(node.phase);
+    this.space();
+  }
+  const specifiers = node.specifiers.slice(0);
+  const hasSpecifiers = !!specifiers.length;
+  while (hasSpecifiers) {
+    const first = specifiers[0];
+    if (isImportDefaultSpecifier(first) || isImportNamespaceSpecifier(first)) {
+      this.print(specifiers.shift());
+      if (specifiers.length) {
+        this.tokenChar(44);
+        this.space();
+      }
+    } else {
+      break;
+    }
+  }
+  let hasBrace = false;
+  if (specifiers.length) {
+    hasBrace = true;
+    this.tokenChar(123);
+    this.space();
+    this.printList(specifiers, this.shouldPrintTrailingComma("}"));
+    this.space();
+    this.tokenChar(125);
+  } else if (isTypeKind && !hasSpecifiers) {
+    hasBrace = true;
+    this.tokenChar(123);
+    this.tokenChar(125);
+  }
+  if (hasSpecifiers || isTypeKind) {
+    this.space();
+    this.word("from");
+    this.space();
+  }
+  if ((_node$attributes3 = node.attributes) != null && _node$attributes3.length || (_node$assertions3 = node.assertions) != null && _node$assertions3.length) {
+    this.print(node.source, true);
+    this.space();
+    _printAttributes.call(this, node, hasBrace);
+  } else {
+    this.print(node.source);
+  }
+  this.semicolon();
+}
+function ImportAttribute(node) {
+  this.print(node.key);
+  this.tokenChar(58);
+  this.space();
+  this.print(node.value);
+}
+function ImportNamespaceSpecifier(node) {
+  this.tokenChar(42);
+  this.space();
+  this.word("as");
+  this.space();
+  this.print(node.local);
+}
+function ImportExpression(node) {
+  this.word("import");
+  if (node.phase) {
+    this.tokenChar(46);
+    this.word(node.phase);
+  }
+  this.tokenChar(40);
+  const shouldPrintTrailingComma = this.shouldPrintTrailingComma(")");
+  this.print(node.source);
+  if (node.options != null) {
+    this.tokenChar(44);
+    this.space();
+    this.print(node.options);
+  }
+  if (shouldPrintTrailingComma) {
+    this.tokenChar(44);
+  }
+  this.rightParens(node);
+}
+
+//# sourceMappingURL=modules.js.map

node_modules/@babel/generator/lib/generators/statements.js

@@ -0,0 +1,297 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BreakStatement = BreakStatement;
+exports.CatchClause = CatchClause;
+exports.ContinueStatement = ContinueStatement;
+exports.DebuggerStatement = DebuggerStatement;
+exports.DoWhileStatement = DoWhileStatement;
+exports.ForInStatement = ForInStatement;
+exports.ForOfStatement = ForOfStatement;
+exports.ForStatement = ForStatement;
+exports.IfStatement = IfStatement;
+exports.LabeledStatement = LabeledStatement;
+exports.ReturnStatement = ReturnStatement;
+exports.SwitchCase = SwitchCase;
+exports.SwitchStatement = SwitchStatement;
+exports.ThrowStatement = ThrowStatement;
+exports.TryStatement = TryStatement;
+exports.VariableDeclaration = VariableDeclaration;
+exports.VariableDeclarator = VariableDeclarator;
+exports.WhileStatement = WhileStatement;
+exports.WithStatement = WithStatement;
+var _t = require("@babel/types");
+var _index = require("../node/index.js");
+const {
+  isFor,
+  isIfStatement,
+  isStatement
+} = _t;
+function WithStatement(node) {
+  this.word("with");
+  this.space();
+  this.tokenChar(40);
+  this.print(node.object);
+  this.tokenChar(41);
+  this.printBlock(node.body);
+}
+function IfStatement(node) {
+  this.word("if");
+  this.space();
+  this.tokenChar(40);
+  this.print(node.test);
+  this.tokenChar(41);
+  this.space();
+  const needsBlock = node.alternate && isIfStatement(getLastStatement(node.consequent));
+  if (needsBlock) {
+    this.tokenChar(123);
+    this.newline();
+    this.indent();
+  }
+  this.printAndIndentOnComments(node.consequent);
+  if (needsBlock) {
+    this.dedent();
+    this.newline();
+    this.tokenChar(125);
+  }
+  if (node.alternate) {
+    if (this.endsWith(125)) this.space();
+    this.word("else");
+    this.space();
+    this.printAndIndentOnComments(node.alternate);
+  }
+}
+function getLastStatement(statement) {
+  const {
+    body
+  } = statement;
+  if (isStatement(body) === false) {
+    return statement;
+  }
+  return getLastStatement(body);
+}
+function ForStatement(node) {
+  this.word("for");
+  this.space();
+  this.tokenChar(40);
+  this.tokenContext |= _index.TokenContext.forInitHead | _index.TokenContext.forInOrInitHeadAccumulate;
+  this.print(node.init);
+  this.tokenContext = _index.TokenContext.normal;
+  this.tokenChar(59);
+  if (node.test) {
+    this.space();
+    this.print(node.test);
+  }
+  this.tokenChar(59, 1);
+  if (node.update) {
+    this.space();
+    this.print(node.update);
+  }
+  this.tokenChar(41);
+  this.printBlock(node.body);
+}
+function WhileStatement(node) {
+  this.word("while");
+  this.space();
+  this.tokenChar(40);
+  this.print(node.test);
+  this.tokenChar(41);
+  this.printBlock(node.body);
+}
+function ForInStatement(node) {
+  this.word("for");
+  this.space();
+  this.noIndentInnerCommentsHere();
+  this.tokenChar(40);
+  this.tokenContext |= _index.TokenContext.forInHead | _index.TokenContext.forInOrInitHeadAccumulate;
+  this.print(node.left);
+  this.tokenContext = _index.TokenContext.normal;
+  this.space();
+  this.word("in");
+  this.space();
+  this.print(node.right);
+  this.tokenChar(41);
+  this.printBlock(node.body);
+}
+function ForOfStatement(node) {
+  this.word("for");
+  this.space();
+  if (node.await) {
+    this.word("await");
+    this.space();
+  }
+  this.noIndentInnerCommentsHere();
+  this.tokenChar(40);
+  this.tokenContext |= _index.TokenContext.forOfHead;
+  this.print(node.left);
+  this.space();
+  this.word("of");
+  this.space();
+  this.print(node.right);
+  this.tokenChar(41);
+  this.printBlock(node.body);
+}
+function DoWhileStatement(node) {
+  this.word("do");
+  this.space();
+  this.print(node.body);
+  this.space();
+  this.word("while");
+  this.space();
+  this.tokenChar(40);
+  this.print(node.test);
+  this.tokenChar(41);
+  this.semicolon();
+}
+function printStatementAfterKeyword(printer, node) {
+  if (node) {
+    printer.space();
+    printer.printTerminatorless(node);
+  }
+  printer.semicolon();
+}
+function BreakStatement(node) {
+  this.word("break");
+  printStatementAfterKeyword(this, node.label);
+}
+function ContinueStatement(node) {
+  this.word("continue");
+  printStatementAfterKeyword(this, node.label);
+}
+function ReturnStatement(node) {
+  this.word("return");
+  printStatementAfterKeyword(this, node.argument);
+}
+function ThrowStatement(node) {
+  this.word("throw");
+  printStatementAfterKeyword(this, node.argument);
+}
+function LabeledStatement(node) {
+  this.print(node.label);
+  this.tokenChar(58);
+  this.space();
+  this.print(node.body);
+}
+function TryStatement(node) {
+  this.word("try");
+  this.space();
+  this.print(node.block);
+  this.space();
+  if (node.handlers) {
+    this.print(node.handlers[0]);
+  } else {
+    this.print(node.handler);
+  }
+  if (node.finalizer) {
+    this.space();
+    this.word("finally");
+    this.space();
+    this.print(node.finalizer);
+  }
+}
+function CatchClause(node) {
+  this.word("catch");
+  this.space();
+  if (node.param) {
+    this.tokenChar(40);
+    this.print(node.param);
+    this.print(node.param.typeAnnotation);
+    this.tokenChar(41);
+    this.space();
+  }
+  this.print(node.body);
+}
+function SwitchStatement(node) {
+  this.word("switch");
+  this.space();
+  this.tokenChar(40);
+  this.print(node.discriminant);
+  this.tokenChar(41);
+  this.space();
+  this.tokenChar(123);
+  this.printSequence(node.cases, true);
+  this.rightBrace(node);
+}
+function SwitchCase(node) {
+  if (node.test) {
+    this.word("case");
+    this.space();
+    this.print(node.test);
+    this.tokenChar(58);
+  } else {
+    this.word("default");
+    this.tokenChar(58);
+  }
+  if (node.consequent.length) {
+    this.newline();
+    this.printSequence(node.consequent, true);
+  }
+}
+function DebuggerStatement() {
+  this.word("debugger");
+  this.semicolon();
+}
+function commaSeparatorWithNewline(occurrenceCount) {
+  this.tokenChar(44, occurrenceCount);
+  this.newline();
+}
+function VariableDeclaration(node, parent) {
+  if (node.declare) {
+    this.word("declare");
+    this.space();
+  }
+  const {
+    kind
+  } = node;
+  switch (kind) {
+    case "await using":
+      this.word("await");
+      this.space();
+    case "using":
+      this.word("using", true);
+      break;
+    default:
+      this.word(kind);
+  }
+  this.space();
+  let hasInits = false;
+  if (!isFor(parent)) {
+    for (const declar of node.declarations) {
+      if (declar.init) {
+        hasInits = true;
+        break;
+      }
+    }
+  }
+  this.printList(node.declarations, undefined, undefined, node.declarations.length > 1, hasInits ? commaSeparatorWithNewline : undefined);
+  if (parent != null) {
+    switch (parent.type) {
+      case "ForStatement":
+        if (parent.init === node) {
+          return;
+        }
+        break;
+      case "ForInStatement":
+      case "ForOfStatement":
+        if (parent.left === node) {
+          return;
+        }
+    }
+  }
+  this.semicolon();
+}
+function VariableDeclarator(node) {
+  this.print(node.id);
+  if (node.definite) this.tokenChar(33);
+  this.print(node.id.typeAnnotation);
+  if (node.init) {
+    this.space();
+    this.tokenChar(61);
+    this.space();
+    this.print(node.init);
+  }
+}
+
+//# sourceMappingURL=statements.js.map

node_modules/@babel/generator/lib/generators/template-literals.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TaggedTemplateExpression = TaggedTemplateExpression;
+exports.TemplateElement = TemplateElement;
+exports.TemplateLiteral = TemplateLiteral;
+exports._printTemplate = _printTemplate;
+function TaggedTemplateExpression(node) {
+  this.print(node.tag);
+  this.print(node.typeParameters);
+  this.print(node.quasi);
+}
+function TemplateElement() {
+  throw new Error("TemplateElement printing is handled in TemplateLiteral");
+}
+function _printTemplate(node, substitutions) {
+  const quasis = node.quasis;
+  let partRaw = "`";
+  for (let i = 0; i < quasis.length - 1; i++) {
+    partRaw += quasis[i].value.raw;
+    this.token(partRaw + "${", true);
+    this.print(substitutions[i]);
+    partRaw = "}";
+    if (this.tokenMap) {
+      const token = this.tokenMap.findMatching(node, "}", i);
+      if (token) this._catchUpTo(token.loc.start);
+    }
+  }
+  partRaw += quasis[quasis.length - 1].value.raw;
+  this.token(partRaw + "`", true);
+}
+function TemplateLiteral(node) {
+  _printTemplate.call(this, node, node.expressions);
+}
+
+//# sourceMappingURL=template-literals.js.map

node_modules/@babel/generator/lib/generators/types.js

@@ -0,0 +1,183 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ArgumentPlaceholder = ArgumentPlaceholder;
+exports.ArrayPattern = exports.ArrayExpression = ArrayExpression;
+exports.BigIntLiteral = BigIntLiteral;
+exports.BooleanLiteral = BooleanLiteral;
+exports.Identifier = Identifier;
+exports.NullLiteral = NullLiteral;
+exports.NumericLiteral = NumericLiteral;
+exports.ObjectPattern = exports.ObjectExpression = ObjectExpression;
+exports.ObjectMethod = ObjectMethod;
+exports.ObjectProperty = ObjectProperty;
+exports.PipelineBareFunction = PipelineBareFunction;
+exports.PipelinePrimaryTopicReference = PipelinePrimaryTopicReference;
+exports.PipelineTopicExpression = PipelineTopicExpression;
+exports.RegExpLiteral = RegExpLiteral;
+exports.SpreadElement = exports.RestElement = RestElement;
+exports.StringLiteral = StringLiteral;
+exports.TopicReference = TopicReference;
+exports.VoidPattern = VoidPattern;
+exports._getRawIdentifier = _getRawIdentifier;
+var _t = require("@babel/types");
+var _jsesc = require("jsesc");
+var _methods = require("./methods.js");
+const {
+  isAssignmentPattern,
+  isIdentifier
+} = _t;
+let lastRawIdentResult = "";
+function _getRawIdentifier(node) {
+  const {
+    name
+  } = node;
+  const token = this.tokenMap.find(node, tok => tok.value === name);
+  if (token) {
+    lastRawIdentResult = this._originalCode.slice(token.start, token.end);
+    return lastRawIdentResult;
+  }
+  return lastRawIdentResult = node.name;
+}
+function Identifier(node) {
+  if (this._buf._map) {
+    var _node$loc;
+    this.sourceIdentifierName(((_node$loc = node.loc) == null ? void 0 : _node$loc.identifierName) || node.name);
+  }
+  this.word(this.tokenMap ? lastRawIdentResult : node.name);
+}
+function ArgumentPlaceholder() {
+  this.tokenChar(63);
+}
+function RestElement(node) {
+  this.token("...");
+  this.print(node.argument);
+}
+function ObjectExpression(node) {
+  const props = node.properties;
+  this.tokenChar(123);
+  if (props.length) {
+    const oldNoLineTerminatorAfterNode = this.enterDelimited();
+    this.space();
+    this.printList(props, this.shouldPrintTrailingComma("}"), true, true, undefined, true);
+    this.space();
+    this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+  }
+  this.rightBrace(node);
+}
+function ObjectMethod(node) {
+  this.printJoin(node.decorators);
+  _methods._methodHead.call(this, node);
+  this.space();
+  this.print(node.body);
+}
+function ObjectProperty(node) {
+  this.printJoin(node.decorators);
+  if (node.computed) {
+    this.tokenChar(91);
+    this.print(node.key);
+    this.tokenChar(93);
+  } else {
+    if (isAssignmentPattern(node.value) && isIdentifier(node.key) && node.key.name === node.value.left.name) {
+      this.print(node.value);
+      return;
+    }
+    this.print(node.key);
+    if (node.shorthand && isIdentifier(node.key) && isIdentifier(node.value) && node.key.name === node.value.name) {
+      return;
+    }
+  }
+  this.tokenChar(58);
+  this.space();
+  this.print(node.value);
+}
+function ArrayExpression(node) {
+  const elems = node.elements;
+  const len = elems.length;
+  this.tokenChar(91);
+  const oldNoLineTerminatorAfterNode = this.enterDelimited();
+  for (let i = 0; i < elems.length; i++) {
+    const elem = elems[i];
+    if (elem) {
+      if (i > 0) this.space();
+      this.print(elem, undefined, true);
+      if (i < len - 1 || this.shouldPrintTrailingComma("]")) {
+        this.tokenChar(44, i);
+      }
+    } else {
+      this.tokenChar(44, i);
+    }
+  }
+  this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+  this.tokenChar(93);
+}
+function RegExpLiteral(node) {
+  this.word(`/${node.pattern}/${node.flags}`, false);
+}
+function BooleanLiteral(node) {
+  this.word(node.value ? "true" : "false");
+}
+function NullLiteral() {
+  this.word("null");
+}
+function NumericLiteral(node) {
+  const raw = this.getPossibleRaw(node);
+  const opts = this.format.jsescOption;
+  const value = node.value;
+  const str = value + "";
+  if (opts.numbers) {
+    this.number(_jsesc(value, opts), value);
+  } else if (raw == null) {
+    this.number(str, value);
+  } else if (this.format.minified) {
+    this.number(raw.length < str.length ? raw : str, value);
+  } else {
+    this.number(raw, value);
+  }
+}
+function StringLiteral(node) {
+  const raw = this.getPossibleRaw(node);
+  if (!this.format.minified && raw !== undefined) {
+    this.token(raw);
+    return;
+  }
+  const val = _jsesc(node.value, this.format.jsescOption);
+  this.token(val);
+}
+function BigIntLiteral(node) {
+  const raw = this.getPossibleRaw(node);
+  if (!this.format.minified && raw !== undefined) {
+    this.word(raw);
+    return;
+  }
+  this.word(node.value + "n");
+}
+const validTopicTokenSet = new Set(["^^", "@@", "^", "%", "#"]);
+function TopicReference() {
+  const {
+    topicToken
+  } = this.format;
+  if (validTopicTokenSet.has(topicToken)) {
+    this.token(topicToken);
+  } else {
+    const givenTopicTokenJSON = JSON.stringify(topicToken);
+    const validTopics = Array.from(validTopicTokenSet, v => JSON.stringify(v));
+    throw new Error(`The "topicToken" generator option must be one of ` + `${validTopics.join(", ")} (${givenTopicTokenJSON} received instead).`);
+  }
+}
+function PipelineTopicExpression(node) {
+  this.print(node.expression);
+}
+function PipelineBareFunction(node) {
+  this.print(node.callee);
+}
+function PipelinePrimaryTopicReference() {
+  this.tokenChar(35);
+}
+function VoidPattern() {
+  this.word("void");
+}
+
+//# sourceMappingURL=types.js.map

node_modules/@babel/generator/lib/index.js

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.generate = generate;
+var _sourceMap = require("./source-map.js");
+var _printer = require("./printer.js");
+function normalizeOptions(code, opts, ast) {
+  var _opts$recordAndTupleS;
+  if (opts.experimental_preserveFormat) {
+    if (typeof code !== "string") {
+      throw new Error("`experimental_preserveFormat` requires the original `code` to be passed to @babel/generator as a string");
+    }
+    if (!opts.retainLines) {
+      throw new Error("`experimental_preserveFormat` requires `retainLines` to be set to `true`");
+    }
+    if (opts.compact && opts.compact !== "auto") {
+      throw new Error("`experimental_preserveFormat` is not compatible with the `compact` option");
+    }
+    if (opts.minified) {
+      throw new Error("`experimental_preserveFormat` is not compatible with the `minified` option");
+    }
+    if (opts.jsescOption) {
+      throw new Error("`experimental_preserveFormat` is not compatible with the `jsescOption` option");
+    }
+    if (!Array.isArray(ast.tokens)) {
+      throw new Error("`experimental_preserveFormat` requires the AST to have attached the token of the input code. Make sure to enable the `tokens: true` parser option.");
+    }
+  }
+  const format = {
+    auxiliaryCommentBefore: opts.auxiliaryCommentBefore,
+    auxiliaryCommentAfter: opts.auxiliaryCommentAfter,
+    shouldPrintComment: opts.shouldPrintComment,
+    preserveFormat: opts.experimental_preserveFormat,
+    retainLines: opts.retainLines,
+    retainFunctionParens: opts.retainFunctionParens,
+    comments: opts.comments == null || opts.comments,
+    compact: opts.compact,
+    minified: opts.minified,
+    concise: opts.concise,
+    indent: {
+      adjustMultilineComment: true,
+      style: "  "
+    },
+    jsescOption: Object.assign({
+      quotes: "double",
+      wrap: true,
+      minimal: false
+    }, opts.jsescOption),
+    topicToken: opts.topicToken
+  };
+  format.decoratorsBeforeExport = opts.decoratorsBeforeExport;
+  format.jsescOption.json = opts.jsonCompatibleStrings;
+  format.recordAndTupleSyntaxType = (_opts$recordAndTupleS = opts.recordAndTupleSyntaxType) != null ? _opts$recordAndTupleS : "hash";
+  format.importAttributesKeyword = opts.importAttributesKeyword;
+  if (format.minified) {
+    format.compact = true;
+    format.shouldPrintComment = format.shouldPrintComment || (() => format.comments);
+  } else {
+    format.shouldPrintComment = format.shouldPrintComment || (value => format.comments || value.includes("@license") || value.includes("@preserve"));
+  }
+  if (format.compact === "auto") {
+    format.compact = typeof code === "string" && code.length > 500000;
+    if (format.compact) {
+      console.error("[BABEL] Note: The code generator has deoptimised the styling of " + `${opts.filename} as it exceeds the max of ${"500KB"}.`);
+    }
+  }
+  if (format.compact || format.preserveFormat) {
+    format.indent.adjustMultilineComment = false;
+  }
+  const {
+    auxiliaryCommentBefore,
+    auxiliaryCommentAfter,
+    shouldPrintComment
+  } = format;
+  if (auxiliaryCommentBefore && !shouldPrintComment(auxiliaryCommentBefore)) {
+    format.auxiliaryCommentBefore = undefined;
+  }
+  if (auxiliaryCommentAfter && !shouldPrintComment(auxiliaryCommentAfter)) {
+    format.auxiliaryCommentAfter = undefined;
+  }
+  return format;
+}
+exports.CodeGenerator = class CodeGenerator {
+  constructor(ast, opts = {}, code) {
+    this._ast = void 0;
+    this._format = void 0;
+    this._map = void 0;
+    this._ast = ast;
+    this._format = normalizeOptions(code, opts, ast);
+    this._map = opts.sourceMaps ? new _sourceMap.default(opts, code) : null;
+  }
+  generate() {
+    const printer = new _printer.default(this._format, this._map);
+    return printer.generate(this._ast);
+  }
+};
+function generate(ast, opts = {}, code) {
+  const format = normalizeOptions(code, opts, ast);
+  const map = opts.sourceMaps ? new _sourceMap.default(opts, code) : null;
+  const printer = new _printer.default(format, map, ast.tokens, typeof code === "string" ? code : null);
+  return printer.generate(ast);
+}
+var _default = exports.default = generate;
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/generator/lib/node/index.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TokenContext = void 0;
+exports.isLastChild = isLastChild;
+exports.parentNeedsParens = parentNeedsParens;
+var parens = require("./parentheses.js");
+var _t = require("@babel/types");
+var _nodes = require("../nodes.js");
+const {
+  VISITOR_KEYS
+} = _t;
+const TokenContext = exports.TokenContext = {
+  normal: 0,
+  expressionStatement: 1,
+  arrowBody: 2,
+  exportDefault: 4,
+  arrowFlowReturnType: 8,
+  forInitHead: 16,
+  forInHead: 32,
+  forOfHead: 64,
+  forInOrInitHeadAccumulate: 128,
+  forInOrInitHeadAccumulatePassThroughMask: 128
+};
+for (const type of Object.keys(parens)) {
+  const func = parens[type];
+  if (_nodes.generatorInfosMap.has(type)) {
+    _nodes.generatorInfosMap.get(type)[2] = func;
+  }
+}
+function isOrHasCallExpression(node) {
+  switch (node.type) {
+    case "CallExpression":
+      return true;
+    case "MemberExpression":
+      return isOrHasCallExpression(node.object);
+  }
+  return false;
+}
+function parentNeedsParens(node, parent, parentId) {
+  switch (parentId) {
+    case 112:
+      if (parent.callee === node) {
+        if (isOrHasCallExpression(node)) return true;
+      }
+      break;
+    case 42:
+      return !isDecoratorMemberExpression(node) && !(node.type === "CallExpression" && isDecoratorMemberExpression(node.callee)) && node.type !== "ParenthesizedExpression";
+  }
+  return false;
+}
+function isDecoratorMemberExpression(node) {
+  switch (node.type) {
+    case "Identifier":
+      return true;
+    case "MemberExpression":
+      return !node.computed && node.property.type === "Identifier" && isDecoratorMemberExpression(node.object);
+    default:
+      return false;
+  }
+}
+function isLastChild(parent, child) {
+  const visitorKeys = VISITOR_KEYS[parent.type];
+  for (let i = visitorKeys.length - 1; i >= 0; i--) {
+    const val = parent[visitorKeys[i]];
+    if (val === child) {
+      return true;
+    } else if (Array.isArray(val)) {
+      let j = val.length - 1;
+      while (j >= 0 && val[j] === null) j--;
+      return j >= 0 && val[j] === child;
+    } else if (val) {
+      return false;
+    }
+  }
+  return false;
+}
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/generator/lib/node/parentheses.js

@@ -0,0 +1,298 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AssignmentExpression = AssignmentExpression;
+exports.BinaryExpression = BinaryExpression;
+exports.ClassExpression = ClassExpression;
+exports.ArrowFunctionExpression = exports.ConditionalExpression = ConditionalExpression;
+exports.DoExpression = DoExpression;
+exports.FunctionExpression = FunctionExpression;
+exports.FunctionTypeAnnotation = FunctionTypeAnnotation;
+exports.Identifier = Identifier;
+exports.LogicalExpression = LogicalExpression;
+exports.NullableTypeAnnotation = NullableTypeAnnotation;
+exports.ObjectExpression = ObjectExpression;
+exports.OptionalIndexedAccessType = OptionalIndexedAccessType;
+exports.OptionalCallExpression = exports.OptionalMemberExpression = OptionalMemberExpression;
+exports.SequenceExpression = SequenceExpression;
+exports.TSSatisfiesExpression = exports.TSAsExpression = TSAsExpression;
+exports.TSConditionalType = TSConditionalType;
+exports.TSConstructorType = exports.TSFunctionType = TSFunctionType;
+exports.TSInferType = TSInferType;
+exports.TSInstantiationExpression = TSInstantiationExpression;
+exports.TSIntersectionType = TSIntersectionType;
+exports.SpreadElement = exports.UnaryExpression = exports.TSTypeAssertion = UnaryLike;
+exports.TSTypeOperator = TSTypeOperator;
+exports.TSUnionType = TSUnionType;
+exports.IntersectionTypeAnnotation = exports.UnionTypeAnnotation = UnionTypeAnnotation;
+exports.UpdateExpression = UpdateExpression;
+exports.AwaitExpression = exports.YieldExpression = YieldExpression;
+var _t = require("@babel/types");
+var _index = require("./index.js");
+const {
+  isMemberExpression,
+  isOptionalMemberExpression,
+  isYieldExpression,
+  isStatement
+} = _t;
+const PRECEDENCE = new Map([["||", 0], ["??", 1], ["&&", 2], ["|", 3], ["^", 4], ["&", 5], ["==", 6], ["===", 6], ["!=", 6], ["!==", 6], ["<", 7], [">", 7], ["<=", 7], [">=", 7], ["in", 7], ["instanceof", 7], [">>", 8], ["<<", 8], [">>>", 8], ["+", 9], ["-", 9], ["*", 10], ["/", 10], ["%", 10], ["**", 11]]);
+function isTSTypeExpression(nodeId) {
+  return nodeId === 156 || nodeId === 201 || nodeId === 209;
+}
+const isClassExtendsClause = (node, parent, parentId) => {
+  return (parentId === 21 || parentId === 22) && parent.superClass === node;
+};
+const hasPostfixPart = (node, parent, parentId) => {
+  switch (parentId) {
+    case 108:
+    case 132:
+      return parent.object === node;
+    case 17:
+    case 130:
+    case 112:
+      return parent.callee === node;
+    case 222:
+      return parent.tag === node;
+    case 191:
+      return true;
+  }
+  return false;
+};
+function NullableTypeAnnotation(node, parent, parentId) {
+  return parentId === 4;
+}
+function FunctionTypeAnnotation(node, parent, parentId, tokenContext) {
+  return (parentId === 239 || parentId === 90 || parentId === 4 || (tokenContext & _index.TokenContext.arrowFlowReturnType) > 0
+  );
+}
+function UpdateExpression(node, parent, parentId) {
+  return hasPostfixPart(node, parent, parentId) || isClassExtendsClause(node, parent, parentId);
+}
+function needsParenBeforeExpressionBrace(tokenContext) {
+  return (tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.arrowBody)) > 0;
+}
+function ObjectExpression(node, parent, parentId, tokenContext) {
+  return needsParenBeforeExpressionBrace(tokenContext);
+}
+function DoExpression(node, parent, parentId, tokenContext) {
+  return (tokenContext & _index.TokenContext.expressionStatement) > 0 && !node.async;
+}
+function BinaryLike(node, parent, parentId, nodeType) {
+  if (isClassExtendsClause(node, parent, parentId)) {
+    return true;
+  }
+  if (hasPostfixPart(node, parent, parentId) || parentId === 238 || parentId === 145 || parentId === 8) {
+    return true;
+  }
+  let parentPos;
+  switch (parentId) {
+    case 10:
+    case 107:
+      parentPos = PRECEDENCE.get(parent.operator);
+      break;
+    case 156:
+    case 201:
+      parentPos = 7;
+  }
+  if (parentPos !== undefined) {
+    const nodePos = nodeType === 2 ? 7 : PRECEDENCE.get(node.operator);
+    if (parentPos > nodePos) return true;
+    if (parentPos === nodePos && parentId === 10 && (nodePos === 11 ? parent.left === node : parent.right === node)) {
+      return true;
+    }
+    if (nodeType === 1 && parentId === 107 && (nodePos === 1 && parentPos !== 1 || parentPos === 1 && nodePos !== 1)) {
+      return true;
+    }
+  }
+  return false;
+}
+function UnionTypeAnnotation(node, parent, parentId) {
+  switch (parentId) {
+    case 4:
+    case 115:
+    case 90:
+    case 239:
+      return true;
+  }
+  return false;
+}
+function OptionalIndexedAccessType(node, parent, parentId) {
+  return parentId === 84 && parent.objectType === node;
+}
+function TSAsExpression(node, parent, parentId) {
+  if ((parentId === 6 || parentId === 7) && parent.left === node) {
+    return true;
+  }
+  if (parentId === 10 && (parent.operator === "|" || parent.operator === "&") && node === parent.left) {
+    return true;
+  }
+  return BinaryLike(node, parent, parentId, 2);
+}
+function TSConditionalType(node, parent, parentId) {
+  switch (parentId) {
+    case 155:
+    case 195:
+    case 211:
+    case 212:
+      return true;
+    case 175:
+      return parent.objectType === node;
+    case 181:
+    case 219:
+      return parent.types[0] === node;
+    case 161:
+      return parent.checkType === node || parent.extendsType === node;
+  }
+  return false;
+}
+function TSUnionType(node, parent, parentId) {
+  switch (parentId) {
+    case 181:
+    case 211:
+    case 155:
+    case 195:
+      return true;
+    case 175:
+      return parent.objectType === node;
+  }
+  return false;
+}
+function TSIntersectionType(node, parent, parentId) {
+  return parentId === 211 || TSTypeOperator(node, parent, parentId);
+}
+function TSInferType(node, parent, parentId) {
+  if (TSTypeOperator(node, parent, parentId)) {
+    return true;
+  }
+  if ((parentId === 181 || parentId === 219) && node.typeParameter.constraint && parent.types[0] === node) {
+    return true;
+  }
+  return false;
+}
+function TSTypeOperator(node, parent, parentId) {
+  switch (parentId) {
+    case 155:
+    case 195:
+      return true;
+    case 175:
+      if (parent.objectType === node) {
+        return true;
+      }
+  }
+  return false;
+}
+function TSInstantiationExpression(node, parent, parentId) {
+  switch (parentId) {
+    case 17:
+    case 130:
+    case 112:
+    case 177:
+      return (parent.typeParameters
+      ) != null;
+  }
+  return false;
+}
+function TSFunctionType(node, parent, parentId) {
+  if (TSUnionType(node, parent, parentId)) return true;
+  return parentId === 219 || parentId === 161 && (parent.checkType === node || parent.extendsType === node);
+}
+function BinaryExpression(node, parent, parentId, tokenContext) {
+  if (BinaryLike(node, parent, parentId, 0)) return true;
+  return (tokenContext & _index.TokenContext.forInOrInitHeadAccumulate) > 0 && node.operator === "in";
+}
+function LogicalExpression(node, parent, parentId) {
+  return BinaryLike(node, parent, parentId, 1);
+}
+function SequenceExpression(node, parent, parentId) {
+  if (parentId === 144 || parentId === 133 || parentId === 108 && parent.property === node || parentId === 132 && parent.property === node || parentId === 224) {
+    return false;
+  }
+  if (parentId === 21) {
+    return true;
+  }
+  if (parentId === 68) {
+    return parent.right === node;
+  }
+  if (parentId === 60) {
+    return true;
+  }
+  return !isStatement(parent);
+}
+function YieldExpression(node, parent, parentId) {
+  return parentId === 10 || parentId === 107 || parentId === 238 || parentId === 145 || hasPostfixPart(node, parent, parentId) || parentId === 8 && isYieldExpression(node) || parentId === 28 && node === parent.test || isClassExtendsClause(node, parent, parentId) || isTSTypeExpression(parentId);
+}
+function ClassExpression(node, parent, parentId, tokenContext) {
+  return (tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.exportDefault)) > 0;
+}
+function UnaryLike(node, parent, parentId) {
+  return hasPostfixPart(node, parent, parentId) || parentId === 10 && parent.operator === "**" && parent.left === node || isClassExtendsClause(node, parent, parentId);
+}
+function FunctionExpression(node, parent, parentId, tokenContext) {
+  return (tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.exportDefault)) > 0;
+}
+function ConditionalExpression(node, parent, parentId) {
+  switch (parentId) {
+    case 238:
+    case 145:
+    case 10:
+    case 107:
+    case 8:
+      return true;
+    case 28:
+      if (parent.test === node) {
+        return true;
+      }
+  }
+  if (isTSTypeExpression(parentId)) {
+    return true;
+  }
+  return UnaryLike(node, parent, parentId);
+}
+function OptionalMemberExpression(node, parent, parentId) {
+  switch (parentId) {
+    case 17:
+      return parent.callee === node;
+    case 108:
+      return parent.object === node;
+  }
+  return false;
+}
+function AssignmentExpression(node, parent, parentId, tokenContext) {
+  if (needsParenBeforeExpressionBrace(tokenContext) && node.left.type === "ObjectPattern") {
+    return true;
+  }
+  return ConditionalExpression(node, parent, parentId);
+}
+function Identifier(node, parent, parentId, tokenContext, getRawIdentifier) {
+  var _node$extra;
+  if (getRawIdentifier && getRawIdentifier(node) !== node.name) {
+    return false;
+  }
+  if (parentId === 6 && (_node$extra = node.extra) != null && _node$extra.parenthesized && parent.left === node) {
+    const rightType = parent.right.type;
+    if ((rightType === "FunctionExpression" || rightType === "ClassExpression") && parent.right.id == null) {
+      return true;
+    }
+  }
+  if (tokenContext & _index.TokenContext.forOfHead || (parentId === 108 || parentId === 132) && tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.forInitHead | _index.TokenContext.forInHead)) {
+    if (node.name === "let") {
+      const isFollowedByBracket = isMemberExpression(parent, {
+        object: node,
+        computed: true
+      }) || isOptionalMemberExpression(parent, {
+        object: node,
+        computed: true,
+        optional: false
+      });
+      if (isFollowedByBracket && tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.forInitHead | _index.TokenContext.forInHead)) {
+        return true;
+      }
+      return (tokenContext & _index.TokenContext.forOfHead) > 0;
+    }
+  }
+  return parentId === 68 && parent.left === node && node.name === "async" && !parent.await;
+}
+
+//# sourceMappingURL=parentheses.js.map

node_modules/@babel/generator/lib/nodes.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generatorInfosMap = void 0;
+var generatorFunctions = require("./generators/index.js");
+var deprecatedGeneratorFunctions = require("./generators/deprecated.js");
+const generatorInfosMap = exports.generatorInfosMap = new Map();
+let index = 0;
+for (const key of Object.keys(generatorFunctions).sort()) {
+  if (key.startsWith("_")) continue;
+  generatorInfosMap.set(key, [generatorFunctions[key], index++, undefined]);
+}
+for (const key of Object.keys(deprecatedGeneratorFunctions)) {
+  generatorInfosMap.set(key, [deprecatedGeneratorFunctions[key], index++, undefined]);
+}
+
+//# sourceMappingURL=nodes.js.map

node_modules/@babel/generator/lib/source-map.js

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _genMapping = require("@jridgewell/gen-mapping");
+var _traceMapping = require("@jridgewell/trace-mapping");
+class SourceMap {
+  constructor(opts, code) {
+    var _opts$sourceFileName;
+    this._map = void 0;
+    this._rawMappings = void 0;
+    this._sourceFileName = void 0;
+    this._lastGenLine = 0;
+    this._lastSourceLine = 0;
+    this._lastSourceColumn = 0;
+    this._inputMap = null;
+    const map = this._map = new _genMapping.GenMapping({
+      sourceRoot: opts.sourceRoot
+    });
+    this._sourceFileName = (_opts$sourceFileName = opts.sourceFileName) == null ? void 0 : _opts$sourceFileName.replace(/\\/g, "/");
+    this._rawMappings = undefined;
+    if (opts.inputSourceMap) {
+      this._inputMap = new _traceMapping.TraceMap(opts.inputSourceMap);
+      const resolvedSources = this._inputMap.resolvedSources;
+      if (resolvedSources.length) {
+        for (let i = 0; i < resolvedSources.length; i++) {
+          var _this$_inputMap$sourc;
+          (0, _genMapping.setSourceContent)(map, resolvedSources[i], (_this$_inputMap$sourc = this._inputMap.sourcesContent) == null ? void 0 : _this$_inputMap$sourc[i]);
+        }
+      }
+    }
+    if (typeof code === "string" && !opts.inputSourceMap) {
+      (0, _genMapping.setSourceContent)(map, this._sourceFileName, code);
+    } else if (typeof code === "object") {
+      for (const sourceFileName of Object.keys(code)) {
+        (0, _genMapping.setSourceContent)(map, sourceFileName.replace(/\\/g, "/"), code[sourceFileName]);
+      }
+    }
+  }
+  get() {
+    return (0, _genMapping.toEncodedMap)(this._map);
+  }
+  getDecoded() {
+    return (0, _genMapping.toDecodedMap)(this._map);
+  }
+  getRawMappings() {
+    return this._rawMappings || (this._rawMappings = (0, _genMapping.allMappings)(this._map));
+  }
+  mark(generated, line, column, identifierName, identifierNamePos, filename) {
+    var _originalMapping;
+    this._rawMappings = undefined;
+    let originalMapping;
+    if (line != null) {
+      if (this._inputMap) {
+        originalMapping = (0, _traceMapping.originalPositionFor)(this._inputMap, {
+          line,
+          column: column
+        });
+        if (!originalMapping.name && identifierNamePos) {
+          const originalIdentifierMapping = (0, _traceMapping.originalPositionFor)(this._inputMap, identifierNamePos);
+          if (originalIdentifierMapping.name) {
+            identifierName = originalIdentifierMapping.name;
+          }
+        }
+      } else {
+        originalMapping = {
+          name: null,
+          source: (filename == null ? void 0 : filename.replace(/\\/g, "/")) || this._sourceFileName,
+          line: line,
+          column: column
+        };
+      }
+    }
+    (0, _genMapping.maybeAddMapping)(this._map, {
+      name: identifierName,
+      generated,
+      source: (_originalMapping = originalMapping) == null ? void 0 : _originalMapping.source,
+      original: originalMapping
+    });
+  }
+}
+exports.default = SourceMap;
+
+//# sourceMappingURL=source-map.js.map

node_modules/@babel/generator/lib/token-map.js

@@ -0,0 +1,195 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TokenMap = void 0;
+var _t = require("@babel/types");
+const {
+  traverseFast,
+  VISITOR_KEYS
+} = _t;
+class TokenMap {
+  constructor(ast, tokens, source) {
+    this._tokens = void 0;
+    this._source = void 0;
+    this._nodesToTokenIndexes = new Map();
+    this._nodesOccurrencesCountCache = new Map();
+    this._tokensCache = new Map();
+    this._tokens = tokens;
+    this._source = source;
+    traverseFast(ast, node => {
+      const indexes = this._getTokensIndexesOfNode(node);
+      if (indexes.length > 0) this._nodesToTokenIndexes.set(node, indexes);
+    });
+    this._tokensCache.clear();
+  }
+  has(node) {
+    return this._nodesToTokenIndexes.has(node);
+  }
+  getIndexes(node) {
+    return this._nodesToTokenIndexes.get(node);
+  }
+  find(node, condition) {
+    const indexes = this._nodesToTokenIndexes.get(node);
+    if (indexes) {
+      for (let k = 0; k < indexes.length; k++) {
+        const index = indexes[k];
+        const tok = this._tokens[index];
+        if (condition(tok, index)) return tok;
+      }
+    }
+    return null;
+  }
+  findLastIndex(node, condition) {
+    const indexes = this._nodesToTokenIndexes.get(node);
+    if (indexes) {
+      for (let k = indexes.length - 1; k >= 0; k--) {
+        const index = indexes[k];
+        const tok = this._tokens[index];
+        if (condition(tok, index)) return index;
+      }
+    }
+    return -1;
+  }
+  findMatching(node, test, occurrenceCount = 0) {
+    const indexes = this._nodesToTokenIndexes.get(node);
+    if (indexes) {
+      if (typeof test === "number") {
+        test = String.fromCharCode(test);
+      }
+      let i = 0;
+      const count = occurrenceCount;
+      if (count > 1) {
+        const cache = this._nodesOccurrencesCountCache.get(node);
+        if ((cache == null ? void 0 : cache.test) === test && cache.count < count) {
+          i = cache.i + 1;
+          occurrenceCount -= cache.count + 1;
+        }
+      }
+      for (; i < indexes.length; i++) {
+        const tok = this._tokens[indexes[i]];
+        if (this.matchesOriginal(tok, test)) {
+          if (occurrenceCount === 0) {
+            if (count > 0) {
+              this._nodesOccurrencesCountCache.set(node, {
+                test,
+                count,
+                i
+              });
+            }
+            return tok;
+          }
+          occurrenceCount--;
+        }
+      }
+    }
+    return null;
+  }
+  matchesOriginal(token, test) {
+    if (token.end - token.start !== test.length) return false;
+    if (token.value != null) return token.value === test;
+    return this._source.startsWith(test, token.start);
+  }
+  startMatches(node, test) {
+    const indexes = this._nodesToTokenIndexes.get(node);
+    if (!indexes) return false;
+    const tok = this._tokens[indexes[0]];
+    if (tok.start !== node.start) return false;
+    return this.matchesOriginal(tok, test);
+  }
+  endMatches(node, test) {
+    const indexes = this._nodesToTokenIndexes.get(node);
+    if (!indexes) return false;
+    const tok = this._tokens[indexes[indexes.length - 1]];
+    if (tok.end !== node.end) return false;
+    return this.matchesOriginal(tok, test);
+  }
+  _getTokensIndexesOfNode(node) {
+    var _node$declaration;
+    if (node.start == null || node.end == null) return [];
+    const {
+      first,
+      last
+    } = this._findTokensOfNode(node, 0, this._tokens.length - 1);
+    let low = first;
+    const children = childrenIterator(node);
+    if ((node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration") && ((_node$declaration = node.declaration) == null ? void 0 : _node$declaration.type) === "ClassDeclaration") {
+      children.next();
+    }
+    const indexes = [];
+    for (const child of children) {
+      if (child == null) continue;
+      if (child.start == null || child.end == null) continue;
+      const childTok = this._findTokensOfNode(child, low, last);
+      const high = childTok.first;
+      for (let k = low; k < high; k++) indexes.push(k);
+      low = childTok.last + 1;
+    }
+    for (let k = low; k <= last; k++) indexes.push(k);
+    return indexes;
+  }
+  _findTokensOfNode(node, low, high) {
+    const cached = this._tokensCache.get(node);
+    if (cached) return cached;
+    const first = this._findFirstTokenOfNode(node.start, low, high);
+    const last = this._findLastTokenOfNode(node.end, first, high);
+    this._tokensCache.set(node, {
+      first,
+      last
+    });
+    return {
+      first,
+      last
+    };
+  }
+  _findFirstTokenOfNode(start, low, high) {
+    while (low <= high) {
+      const mid = high + low >> 1;
+      if (start < this._tokens[mid].start) {
+        high = mid - 1;
+      } else if (start > this._tokens[mid].start) {
+        low = mid + 1;
+      } else {
+        return mid;
+      }
+    }
+    return low;
+  }
+  _findLastTokenOfNode(end, low, high) {
+    while (low <= high) {
+      const mid = high + low >> 1;
+      if (end < this._tokens[mid].end) {
+        high = mid - 1;
+      } else if (end > this._tokens[mid].end) {
+        low = mid + 1;
+      } else {
+        return mid;
+      }
+    }
+    return high;
+  }
+}
+exports.TokenMap = TokenMap;
+function* childrenIterator(node) {
+  if (node.type === "TemplateLiteral") {
+    yield node.quasis[0];
+    for (let i = 1; i < node.quasis.length; i++) {
+      yield node.expressions[i - 1];
+      yield node.quasis[i];
+    }
+    return;
+  }
+  const keys = VISITOR_KEYS[node.type];
+  for (const key of keys) {
+    const child = node[key];
+    if (!child) continue;
+    if (Array.isArray(child)) {
+      yield* child;
+    } else {
+      yield child;
+    }
+  }
+}
+
+//# sourceMappingURL=token-map.js.map

node_modules/@babel/generator/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@babel/generator",
+  "version": "7.29.1",
+  "description": "Turns an AST into code.",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-generator"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-generator",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20generator%22+is%3Aopen",
+  "main": "./lib/index.js",
+  "files": [
+    "lib"
+  ],
+  "dependencies": {
+    "@babel/parser": "^7.29.0",
+    "@babel/types": "^7.29.0",
+    "@jridgewell/gen-mapping": "^0.3.12",
+    "@jridgewell/trace-mapping": "^0.3.28",
+    "jsesc": "^3.0.2"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.29.0",
+    "@babel/helper-fixtures": "^7.28.6",
+    "@babel/plugin-transform-typescript": "^7.28.6",
+    "@jridgewell/sourcemap-codec": "^1.5.3",
+    "charcodes": "^0.2.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "type": "commonjs"
+}