Initial commit: notification-elements-demo app

Interactive Angular 19 demo for @sda/notification-elements-ui with
6 sections: Bell & Feed, Notification Center, Inbox, Comments &
Threads, Mention Input, and Full-Featured layout. Includes mock
data, dark mode toggle, and real-time event log.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

node_modules/@babel/traverse/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/traverse/README.md

@@ -0,0 +1,19 @@
+# @babel/traverse
+
+> The Babel Traverse module maintains the overall tree state, and is responsible for replacing, removing, and adding nodes
+
+See our website [@babel/traverse](https://babeljs.io/docs/babel-traverse) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20traverse%22+is%3Aopen) associated with this package.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/traverse
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/traverse --dev
+```

node_modules/@babel/traverse/lib/cache.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clear = clear;
+exports.clearPath = clearPath;
+exports.clearScope = clearScope;
+exports.getCachedPaths = getCachedPaths;
+exports.getOrCreateCachedPaths = getOrCreateCachedPaths;
+exports.scope = exports.path = void 0;
+let pathsCache = exports.path = new WeakMap();
+let scope = exports.scope = new WeakMap();
+function clear() {
+  clearPath();
+  clearScope();
+}
+function clearPath() {
+  exports.path = pathsCache = new WeakMap();
+}
+function clearScope() {
+  exports.scope = scope = new WeakMap();
+}
+function getCachedPaths(path) {
+  const {
+    parent,
+    parentPath
+  } = path;
+  return pathsCache.get(parent);
+}
+function getOrCreateCachedPaths(node, parentPath) {
+  let paths = pathsCache.get(node);
+  if (!paths) pathsCache.set(node, paths = new Map());
+  return paths;
+}
+
+//# sourceMappingURL=cache.js.map

node_modules/@babel/traverse/lib/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["pathsCache","exports","path","WeakMap","scope","clear","clearPath","clearScope","getCachedPaths","parent","parentPath","get","getOrCreateCachedPaths","node","paths","set","Map"],"sources":["../src/cache.ts"],"sourcesContent":["import type { Node } from \"@babel/types\";\nimport type NodePath from \"./path/index.ts\";\nimport type Scope from \"./scope/index.ts\";\n\nlet pathsCache = new WeakMap<Node, Map<Node, NodePath>>();\nexport { pathsCache as path };\nexport let scope = new WeakMap<Node, Scope>();\n\nexport function clear() {\n  clearPath();\n  clearScope();\n}\n\nexport function clearPath() {\n  pathsCache = new WeakMap();\n}\n\nexport function clearScope() {\n  scope = new WeakMap();\n}\n\nexport function getCachedPaths(path: NodePath) {\n  const { parent, parentPath } = path;\n  return process.env.BABEL_8_BREAKING && parentPath\n    ? parentPath._store\n    : pathsCache.get(parent);\n}\n\nexport function getOrCreateCachedPaths(\n  node: Node,\n  parentPath?: NodePath | null,\n) {\n  if (process.env.BABEL_8_BREAKING && parentPath) {\n    return (parentPath._store ||= new Map());\n  }\n\n  let paths = pathsCache.get(node);\n  if (!paths) pathsCache.set(node, (paths = new Map()));\n\n  return paths;\n}\n"],"mappings":";;;;;;;;;;;AAIA,IAAIA,UAAU,GAAAC,OAAA,CAAAC,IAAA,GAAG,IAAIC,OAAO,CAA4B,CAAC;AAElD,IAAIC,KAAK,GAAAH,OAAA,CAAAG,KAAA,GAAG,IAAID,OAAO,CAAc,CAAC;AAEtC,SAASE,KAAKA,CAAA,EAAG;EACtBC,SAAS,CAAC,CAAC;EACXC,UAAU,CAAC,CAAC;AACd;AAEO,SAASD,SAASA,CAAA,EAAG;EAC1BL,OAAA,CAAAC,IAAA,GAAAF,UAAU,GAAG,IAAIG,OAAO,CAAC,CAAC;AAC5B;AAEO,SAASI,UAAUA,CAAA,EAAG;EAC3BN,OAAA,CAAAG,KAAA,GAAAA,KAAK,GAAG,IAAID,OAAO,CAAC,CAAC;AACvB;AAEO,SAASK,cAAcA,CAACN,IAAc,EAAE;EAC7C,MAAM;IAAEO,MAAM;IAAEC;EAAW,CAAC,GAAGR,IAAI;EACnC,OAEIF,UAAU,CAACW,GAAG,CAACF,MAAM,CAAC;AAC5B;AAEO,SAASG,sBAAsBA,CACpCC,IAAU,EACVH,UAA4B,EAC5B;EAKA,IAAII,KAAK,GAAGd,UAAU,CAACW,GAAG,CAACE,IAAI,CAAC;EAChC,IAAI,CAACC,KAAK,EAAEd,UAAU,CAACe,GAAG,CAACF,IAAI,EAAGC,KAAK,GAAG,IAAIE,GAAG,CAAC,CAAE,CAAC;EAErD,OAAOF,KAAK;AACd","ignoreList":[]}

node_modules/@babel/traverse/lib/context.js

@@ -0,0 +1,125 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _index = require("./path/index.js");
+var _t = require("@babel/types");
+var _context = require("./path/context.js");
+var _hub = require("./hub.js");
+const {
+  VISITOR_KEYS
+} = _t;
+class TraversalContext {
+  constructor(scope, opts, state, parentPath) {
+    this.queue = null;
+    this.priorityQueue = null;
+    this.parentPath = parentPath;
+    this.scope = scope;
+    this.state = state;
+    this.opts = opts;
+  }
+  shouldVisit(node) {
+    const opts = this.opts;
+    if (opts.enter || opts.exit) return true;
+    if (opts[node.type]) return true;
+    const keys = VISITOR_KEYS[node.type];
+    if (!(keys != null && keys.length)) return false;
+    for (const key of keys) {
+      if (node[key]) {
+        return true;
+      }
+    }
+    return false;
+  }
+  create(node, container, key, listKey) {
+    const {
+      parentPath
+    } = this;
+    const hub = parentPath == null ? node.type === "Program" || node.type === "File" ? new _hub.default() : undefined : parentPath.hub;
+    return _index.default.get({
+      parentPath,
+      parent: node,
+      container,
+      key: key,
+      listKey,
+      hub
+    });
+  }
+  maybeQueue(path, notPriority) {
+    if (this.queue) {
+      if (notPriority) {
+        this.queue.push(path);
+      } else {
+        this.priorityQueue.push(path);
+      }
+    }
+  }
+  visitMultiple(container, parent, listKey) {
+    if (container.length === 0) return false;
+    const queue = [];
+    for (let key = 0; key < container.length; key++) {
+      const node = container[key];
+      if (node && this.shouldVisit(node)) {
+        queue.push(this.create(parent, container, key, listKey));
+      }
+    }
+    return this.visitQueue(queue);
+  }
+  visitSingle(node, key) {
+    if (this.shouldVisit(node[key])) {
+      return this.visitQueue([this.create(node, node, key)]);
+    } else {
+      return false;
+    }
+  }
+  visitQueue(queue) {
+    this.queue = queue;
+    this.priorityQueue = [];
+    const visited = new WeakSet();
+    let stop = false;
+    let visitIndex = 0;
+    for (; visitIndex < queue.length;) {
+      const path = queue[visitIndex];
+      visitIndex++;
+      _context.resync.call(path);
+      if (path.contexts.length === 0 || path.contexts[path.contexts.length - 1] !== this) {
+        _context.pushContext.call(path, this);
+      }
+      if (path.key === null) continue;
+      const {
+        node
+      } = path;
+      if (visited.has(node)) continue;
+      if (node) visited.add(node);
+      if (path.visit()) {
+        stop = true;
+        break;
+      }
+      if (this.priorityQueue.length) {
+        stop = this.visitQueue(this.priorityQueue);
+        this.priorityQueue = [];
+        this.queue = queue;
+        if (stop) break;
+      }
+    }
+    for (let i = 0; i < visitIndex; i++) {
+      _context.popContext.call(queue[i]);
+    }
+    this.queue = null;
+    return stop;
+  }
+  visit(node, key) {
+    const nodes = node[key];
+    if (!nodes) return false;
+    if (Array.isArray(nodes)) {
+      return this.visitMultiple(nodes, node, key);
+    } else {
+      return this.visitSingle(node, key);
+    }
+  }
+}
+exports.default = TraversalContext;
+
+//# sourceMappingURL=context.js.map

node_modules/@babel/traverse/lib/hub.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+class Hub {
+  getCode() {}
+  getScope() {}
+  addHelper() {
+    throw new Error("Helpers are not supported by the default hub.");
+  }
+  buildError(node, msg, Error = TypeError) {
+    return new Error(msg);
+  }
+}
+exports.default = Hub;
+
+//# sourceMappingURL=hub.js.map

node_modules/@babel/traverse/lib/hub.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Hub","getCode","getScope","addHelper","Error","buildError","node","msg","TypeError","exports","default"],"sources":["../src/hub.ts"],"sourcesContent":["import type Scope from \"./scope/index.ts\";\nimport type { Node } from \"@babel/types\";\n\nexport interface HubInterface {\n  getCode(): string | void;\n  getScope(): Scope | void;\n  addHelper(name: string): any;\n  buildError(node: Node, msg: string, Error: new (msg: string) => Error): Error;\n}\n\nexport default class Hub implements HubInterface {\n  getCode() {}\n\n  getScope() {}\n\n  addHelper() {\n    throw new Error(\"Helpers are not supported by the default hub.\");\n  }\n\n  buildError(\n    node: Node,\n    msg: string,\n    Error: new (msg: string) => Error = TypeError,\n  ): Error {\n    return new Error(msg);\n  }\n}\n"],"mappings":";;;;;;AAUe,MAAMA,GAAG,CAAyB;EAC/CC,OAAOA,CAAA,EAAG,CAAC;EAEXC,QAAQA,CAAA,EAAG,CAAC;EAEZC,SAASA,CAAA,EAAG;IACV,MAAM,IAAIC,KAAK,CAAC,+CAA+C,CAAC;EAClE;EAEAC,UAAUA,CACRC,IAAU,EACVC,GAAW,EACXH,KAAiC,GAAGI,SAAS,EACtC;IACP,OAAO,IAAIJ,KAAK,CAACG,GAAG,CAAC;EACvB;AACF;AAACE,OAAA,CAAAC,OAAA,GAAAV,GAAA","ignoreList":[]}

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

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Hub", {
+  enumerable: true,
+  get: function () {
+    return _hub.default;
+  }
+});
+Object.defineProperty(exports, "NodePath", {
+  enumerable: true,
+  get: function () {
+    return _index.default;
+  }
+});
+Object.defineProperty(exports, "Scope", {
+  enumerable: true,
+  get: function () {
+    return _index2.default;
+  }
+});
+exports.visitors = exports.default = void 0;
+require("./path/context.js");
+var visitors = require("./visitors.js");
+exports.visitors = visitors;
+var _t = require("@babel/types");
+var cache = require("./cache.js");
+var _traverseNode = require("./traverse-node.js");
+var _index = require("./path/index.js");
+var _index2 = require("./scope/index.js");
+var _hub = require("./hub.js");
+const {
+  VISITOR_KEYS,
+  removeProperties,
+  traverseFast
+} = _t;
+function traverse(parent, opts = {}, scope, state, parentPath, visitSelf) {
+  if (!parent) return;
+  if (!opts.noScope && !scope) {
+    if (parent.type !== "Program" && parent.type !== "File") {
+      throw new Error("You must pass a scope and parentPath unless traversing a Program/File. " + `Instead of that you tried to traverse a ${parent.type} node without ` + "passing scope and parentPath.");
+    }
+  }
+  if (!parentPath && visitSelf) {
+    throw new Error("visitSelf can only be used when providing a NodePath.");
+  }
+  if (!VISITOR_KEYS[parent.type]) {
+    return;
+  }
+  visitors.explode(opts);
+  (0, _traverseNode.traverseNode)(parent, opts, scope, state, parentPath, undefined, visitSelf);
+}
+var _default = exports.default = traverse;
+traverse.visitors = visitors;
+traverse.verify = visitors.verify;
+traverse.explode = visitors.explode;
+traverse.cheap = function (node, enter) {
+  traverseFast(node, enter);
+  return;
+};
+traverse.node = function (node, opts, scope, state, path, skipKeys) {
+  (0, _traverseNode.traverseNode)(node, opts, scope, state, path, skipKeys);
+};
+traverse.clearNode = function (node, opts) {
+  removeProperties(node, opts);
+};
+traverse.removeProperties = function (tree, opts) {
+  traverseFast(tree, traverse.clearNode, opts);
+  return tree;
+};
+traverse.hasType = function (tree, type, denylistTypes) {
+  if (denylistTypes != null && denylistTypes.includes(tree.type)) return false;
+  if (tree.type === type) return true;
+  return traverseFast(tree, function (node) {
+    if (denylistTypes != null && denylistTypes.includes(node.type)) {
+      return traverseFast.skip;
+    }
+    if (node.type === type) {
+      return traverseFast.stop;
+    }
+  });
+};
+traverse.cache = cache;
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/traverse/lib/path/ancestry.js

@@ -0,0 +1,139 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.find = find;
+exports.findParent = findParent;
+exports.getAncestry = getAncestry;
+exports.getDeepestCommonAncestorFrom = getDeepestCommonAncestorFrom;
+exports.getEarliestCommonAncestorFrom = getEarliestCommonAncestorFrom;
+exports.getFunctionParent = getFunctionParent;
+exports.getStatementParent = getStatementParent;
+exports.inType = inType;
+exports.isAncestor = isAncestor;
+exports.isDescendant = isDescendant;
+var _t = require("@babel/types");
+const {
+  VISITOR_KEYS
+} = _t;
+function findParent(callback) {
+  let path = this;
+  while (path = path.parentPath) {
+    if (callback(path)) return path;
+  }
+  return null;
+}
+function find(callback) {
+  let path = this;
+  do {
+    if (callback(path)) return path;
+  } while (path = path.parentPath);
+  return null;
+}
+function getFunctionParent() {
+  return this.findParent(p => p.isFunction());
+}
+function getStatementParent() {
+  let path = this;
+  do {
+    if (!path.parentPath || Array.isArray(path.container) && path.isStatement()) {
+      break;
+    } else {
+      path = path.parentPath;
+    }
+  } while (path);
+  if (path && (path.isProgram() || path.isFile())) {
+    throw new Error("File/Program node, we can't possibly find a statement parent to this");
+  }
+  return path;
+}
+function getEarliestCommonAncestorFrom(paths) {
+  return this.getDeepestCommonAncestorFrom(paths, function (deepest, i, ancestries) {
+    let earliest;
+    const keys = VISITOR_KEYS[deepest.type];
+    for (const ancestry of ancestries) {
+      const path = ancestry[i + 1];
+      if (!earliest) {
+        earliest = path;
+        continue;
+      }
+      if (path.listKey && earliest.listKey === path.listKey) {
+        if (path.key < earliest.key) {
+          earliest = path;
+          continue;
+        }
+      }
+      const earliestKeyIndex = keys.indexOf(earliest.parentKey);
+      const currentKeyIndex = keys.indexOf(path.parentKey);
+      if (earliestKeyIndex > currentKeyIndex) {
+        earliest = path;
+      }
+    }
+    return earliest;
+  });
+}
+function getDeepestCommonAncestorFrom(paths, filter) {
+  if (!paths.length) {
+    return this;
+  }
+  if (paths.length === 1) {
+    return paths[0];
+  }
+  let minDepth = Infinity;
+  let lastCommonIndex, lastCommon;
+  const ancestries = paths.map(path => {
+    const ancestry = [];
+    do {
+      ancestry.unshift(path);
+    } while ((path = path.parentPath) && path !== this);
+    if (ancestry.length < minDepth) {
+      minDepth = ancestry.length;
+    }
+    return ancestry;
+  });
+  const first = ancestries[0];
+  depthLoop: for (let i = 0; i < minDepth; i++) {
+    const shouldMatch = first[i];
+    for (const ancestry of ancestries) {
+      if (ancestry[i] !== shouldMatch) {
+        break depthLoop;
+      }
+    }
+    lastCommonIndex = i;
+    lastCommon = shouldMatch;
+  }
+  if (lastCommon) {
+    if (filter) {
+      return filter(lastCommon, lastCommonIndex, ancestries);
+    } else {
+      return lastCommon;
+    }
+  } else {
+    throw new Error("Couldn't find intersection");
+  }
+}
+function getAncestry() {
+  let path = this;
+  const paths = [];
+  do {
+    paths.push(path);
+  } while (path = path.parentPath);
+  return paths;
+}
+function isAncestor(maybeDescendant) {
+  return maybeDescendant.isDescendant(this);
+}
+function isDescendant(maybeAncestor) {
+  return !!this.findParent(parent => parent === maybeAncestor);
+}
+function inType(...candidateTypes) {
+  let path = this;
+  while (path) {
+    if (candidateTypes.includes(path.node.type)) return true;
+    path = path.parentPath;
+  }
+  return false;
+}
+
+//# sourceMappingURL=ancestry.js.map

node_modules/@babel/traverse/lib/path/comments.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addComment = addComment;
+exports.addComments = addComments;
+exports.shareCommentsWithSiblings = shareCommentsWithSiblings;
+var _t = require("@babel/types");
+const {
+  addComment: _addComment,
+  addComments: _addComments
+} = _t;
+function shareCommentsWithSiblings() {
+  if (typeof this.key === "string") return;
+  const node = this.node;
+  if (!node) return;
+  const trailing = node.trailingComments;
+  const leading = node.leadingComments;
+  if (!trailing && !leading) return;
+  const prev = this.getSibling(this.key - 1);
+  const next = this.getSibling(this.key + 1);
+  const hasPrev = Boolean(prev.node);
+  const hasNext = Boolean(next.node);
+  if (hasPrev) {
+    if (leading) {
+      prev.addComments("trailing", removeIfExisting(leading, prev.node.trailingComments));
+    }
+    if (trailing && !hasNext) prev.addComments("trailing", trailing);
+  }
+  if (hasNext) {
+    if (trailing) {
+      next.addComments("leading", removeIfExisting(trailing, next.node.leadingComments));
+    }
+    if (leading && !hasPrev) next.addComments("leading", leading);
+  }
+}
+function removeIfExisting(list, toRemove) {
+  if (!(toRemove != null && toRemove.length)) return list;
+  const set = new Set(toRemove);
+  return list.filter(el => {
+    return !set.has(el);
+  });
+}
+function addComment(type, content, line) {
+  _addComment(this.node, type, content, line);
+}
+function addComments(type, comments) {
+  _addComments(this.node, type, comments);
+}
+
+//# sourceMappingURL=comments.js.map

node_modules/@babel/traverse/lib/path/comments.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_t","require","addComment","_addComment","addComments","_addComments","shareCommentsWithSiblings","key","node","trailing","trailingComments","leading","leadingComments","prev","getSibling","next","hasPrev","Boolean","hasNext","removeIfExisting","list","toRemove","length","set","Set","filter","el","has","type","content","line","comments"],"sources":["../../src/path/comments.ts"],"sourcesContent":["// This file contains methods responsible for dealing with comments.\nimport type * as t from \"@babel/types\";\nimport type NodePath from \"./index.ts\";\nimport {\n  addComment as _addComment,\n  addComments as _addComments,\n} from \"@babel/types\";\n\n/**\n * Share comments amongst siblings.\n */\n\nexport function shareCommentsWithSiblings(this: NodePath) {\n  // NOTE: this assumes numbered keys\n  if (typeof this.key === \"string\") return;\n\n  const node = this.node;\n  if (!node) return;\n\n  const trailing = node.trailingComments;\n  const leading = node.leadingComments;\n  if (!trailing && !leading) return;\n\n  const prev = this.getSibling(this.key! - 1);\n  const next = this.getSibling(this.key! + 1);\n  const hasPrev = Boolean(prev.node);\n  const hasNext = Boolean(next.node);\n\n  if (hasPrev) {\n    if (leading) {\n      prev.addComments(\n        \"trailing\",\n        removeIfExisting(leading, prev.node.trailingComments),\n      );\n    }\n    if (trailing && !hasNext) prev.addComments(\"trailing\", trailing);\n  }\n  if (hasNext) {\n    if (trailing) {\n      next.addComments(\n        \"leading\",\n        removeIfExisting(trailing, next.node.leadingComments),\n      );\n    }\n    if (leading && !hasPrev) next.addComments(\"leading\", leading);\n  }\n}\n\nfunction removeIfExisting<T>(list: T[], toRemove?: T[] | null): T[] {\n  if (!toRemove?.length) return list;\n  const set = new Set(toRemove);\n  return list.filter(el => {\n    return !set.has(el);\n  });\n}\n\nexport function addComment(\n  this: NodePath,\n  type: t.CommentTypeShorthand,\n  content: string,\n  line?: boolean,\n) {\n  _addComment(this.node, type, content, line);\n}\n\n/**\n * Give node `comments` of the specified `type`.\n */\n\nexport function addComments(\n  this: NodePath,\n  type: t.CommentTypeShorthand,\n  comments: t.Comment[],\n) {\n  _addComments(this.node, type, comments);\n}\n"],"mappings":";;;;;;;;AAGA,IAAAA,EAAA,GAAAC,OAAA;AAGsB;EAFpBC,UAAU,EAAIC,WAAW;EACzBC,WAAW,EAAIC;AAAY,IAAAL,EAAA;AAOtB,SAASM,yBAAyBA,CAAA,EAAiB;EAExD,IAAI,OAAO,IAAI,CAACC,GAAG,KAAK,QAAQ,EAAE;EAElC,MAAMC,IAAI,GAAG,IAAI,CAACA,IAAI;EACtB,IAAI,CAACA,IAAI,EAAE;EAEX,MAAMC,QAAQ,GAAGD,IAAI,CAACE,gBAAgB;EACtC,MAAMC,OAAO,GAAGH,IAAI,CAACI,eAAe;EACpC,IAAI,CAACH,QAAQ,IAAI,CAACE,OAAO,EAAE;EAE3B,MAAME,IAAI,GAAG,IAAI,CAACC,UAAU,CAAC,IAAI,CAACP,GAAG,GAAI,CAAC,CAAC;EAC3C,MAAMQ,IAAI,GAAG,IAAI,CAACD,UAAU,CAAC,IAAI,CAACP,GAAG,GAAI,CAAC,CAAC;EAC3C,MAAMS,OAAO,GAAGC,OAAO,CAACJ,IAAI,CAACL,IAAI,CAAC;EAClC,MAAMU,OAAO,GAAGD,OAAO,CAACF,IAAI,CAACP,IAAI,CAAC;EAElC,IAAIQ,OAAO,EAAE;IACX,IAAIL,OAAO,EAAE;MACXE,IAAI,CAACT,WAAW,CACd,UAAU,EACVe,gBAAgB,CAACR,OAAO,EAAEE,IAAI,CAACL,IAAI,CAACE,gBAAgB,CACtD,CAAC;IACH;IACA,IAAID,QAAQ,IAAI,CAACS,OAAO,EAAEL,IAAI,CAACT,WAAW,CAAC,UAAU,EAAEK,QAAQ,CAAC;EAClE;EACA,IAAIS,OAAO,EAAE;IACX,IAAIT,QAAQ,EAAE;MACZM,IAAI,CAACX,WAAW,CACd,SAAS,EACTe,gBAAgB,CAACV,QAAQ,EAAEM,IAAI,CAACP,IAAI,CAACI,eAAe,CACtD,CAAC;IACH;IACA,IAAID,OAAO,IAAI,CAACK,OAAO,EAAED,IAAI,CAACX,WAAW,CAAC,SAAS,EAAEO,OAAO,CAAC;EAC/D;AACF;AAEA,SAASQ,gBAAgBA,CAAIC,IAAS,EAAEC,QAAqB,EAAO;EAClE,IAAI,EAACA,QAAQ,YAARA,QAAQ,CAAEC,MAAM,GAAE,OAAOF,IAAI;EAClC,MAAMG,GAAG,GAAG,IAAIC,GAAG,CAACH,QAAQ,CAAC;EAC7B,OAAOD,IAAI,CAACK,MAAM,CAACC,EAAE,IAAI;IACvB,OAAO,CAACH,GAAG,CAACI,GAAG,CAACD,EAAE,CAAC;EACrB,CAAC,CAAC;AACJ;AAEO,SAASxB,UAAUA,CAExB0B,IAA4B,EAC5BC,OAAe,EACfC,IAAc,EACd;EACA3B,WAAW,CAAC,IAAI,CAACK,IAAI,EAAEoB,IAAI,EAAEC,OAAO,EAAEC,IAAI,CAAC;AAC7C;AAMO,SAAS1B,WAAWA,CAEzBwB,IAA4B,EAC5BG,QAAqB,EACrB;EACA1B,YAAY,CAAC,IAAI,CAACG,IAAI,EAAEoB,IAAI,EAAEG,QAAQ,CAAC;AACzC","ignoreList":[]}

node_modules/@babel/traverse/lib/path/context.js

@@ -0,0 +1,254 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._call = _call;
+exports._forceSetScope = _forceSetScope;
+exports._getQueueContexts = _getQueueContexts;
+exports._resyncKey = _resyncKey;
+exports._resyncList = _resyncList;
+exports._resyncParent = _resyncParent;
+exports._resyncRemoved = _resyncRemoved;
+exports.call = call;
+exports.isDenylisted = isDenylisted;
+exports.popContext = popContext;
+exports.pushContext = pushContext;
+exports.requeue = requeue;
+exports.requeueComputedKeyAndDecorators = requeueComputedKeyAndDecorators;
+exports.resync = resync;
+exports.setContext = setContext;
+exports.setKey = setKey;
+exports.setScope = setScope;
+exports.setup = setup;
+exports.skip = skip;
+exports.skipKey = skipKey;
+exports.stop = stop;
+exports.visit = visit;
+var _traverseNode = require("../traverse-node.js");
+var _index = require("./index.js");
+var _removal = require("./removal.js");
+var t = require("@babel/types");
+function call(key) {
+  const opts = this.opts;
+  this.debug(key);
+  if (this.node) {
+    if (_call.call(this, opts[key])) return true;
+  }
+  if (this.node) {
+    var _opts$this$node$type;
+    return _call.call(this, (_opts$this$node$type = opts[this.node.type]) == null ? void 0 : _opts$this$node$type[key]);
+  }
+  return false;
+}
+function _call(fns) {
+  if (!fns) return false;
+  for (const fn of fns) {
+    if (!fn) continue;
+    const node = this.node;
+    if (!node) return true;
+    const ret = fn.call(this.state, this, this.state);
+    if (ret && typeof ret === "object" && typeof ret.then === "function") {
+      throw new Error(`You appear to be using a plugin with an async traversal visitor, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, you may need to upgrade ` + `your @babel/core version.`);
+    }
+    if (ret) {
+      throw new Error(`Unexpected return value from visitor method ${fn}`);
+    }
+    if (this.node !== node) return true;
+    if (this._traverseFlags > 0) return true;
+  }
+  return false;
+}
+function isDenylisted() {
+  var _this$opts$denylist;
+  const denylist = (_this$opts$denylist = this.opts.denylist) != null ? _this$opts$denylist : this.opts.blacklist;
+  return denylist == null ? void 0 : denylist.includes(this.node.type);
+}
+exports.isBlacklisted = isDenylisted;
+function restoreContext(path, context) {
+  if (path.context !== context) {
+    path.context = context;
+    path.state = context.state;
+    path.opts = context.opts;
+  }
+}
+function visit() {
+  var _this$opts$shouldSkip, _this$opts;
+  if (!this.node) {
+    return false;
+  }
+  if (this.isDenylisted()) {
+    return false;
+  }
+  if ((_this$opts$shouldSkip = (_this$opts = this.opts).shouldSkip) != null && _this$opts$shouldSkip.call(_this$opts, this)) {
+    return false;
+  }
+  const currentContext = this.context;
+  if (this.shouldSkip || call.call(this, "enter")) {
+    this.debug("Skip...");
+    return this.shouldStop;
+  }
+  restoreContext(this, currentContext);
+  this.debug("Recursing into...");
+  this.shouldStop = (0, _traverseNode.traverseNode)(this.node, this.opts, this.scope, this.state, this, this.skipKeys);
+  restoreContext(this, currentContext);
+  call.call(this, "exit");
+  return this.shouldStop;
+}
+function skip() {
+  this.shouldSkip = true;
+}
+function skipKey(key) {
+  if (this.skipKeys == null) {
+    this.skipKeys = {};
+  }
+  this.skipKeys[key] = true;
+}
+function stop() {
+  this._traverseFlags |= _index.SHOULD_SKIP | _index.SHOULD_STOP;
+}
+function _forceSetScope() {
+  var _this$scope;
+  let path = this.parentPath;
+  if ((this.key === "key" || this.listKey === "decorators") && path.isMethod() || this.key === "discriminant" && path.isSwitchStatement()) {
+    path = path.parentPath;
+  }
+  let target;
+  while (path && !target) {
+    target = path.scope;
+    path = path.parentPath;
+  }
+  this.scope = this.getScope(target);
+  (_this$scope = this.scope) == null || _this$scope.init();
+}
+function setScope() {
+  var _this$opts2, _this$scope2;
+  if ((_this$opts2 = this.opts) != null && _this$opts2.noScope) return;
+  let path = this.parentPath;
+  if ((this.key === "key" || this.listKey === "decorators") && path.isMethod() || this.key === "discriminant" && path.isSwitchStatement()) {
+    path = path.parentPath;
+  }
+  let target;
+  while (path && !target) {
+    var _path$opts;
+    if ((_path$opts = path.opts) != null && _path$opts.noScope) return;
+    target = path.scope;
+    path = path.parentPath;
+  }
+  this.scope = this.getScope(target);
+  (_this$scope2 = this.scope) == null || _this$scope2.init();
+}
+function setContext(context) {
+  if (this.skipKeys != null) {
+    this.skipKeys = {};
+  }
+  this._traverseFlags = 0;
+  if (context) {
+    this.context = context;
+    this.state = context.state;
+    this.opts = context.opts;
+  }
+  setScope.call(this);
+  return this;
+}
+function resync() {
+  if (this.removed) return;
+  _resyncParent.call(this);
+  _resyncList.call(this);
+  _resyncKey.call(this);
+}
+function _resyncParent() {
+  if (this.parentPath) {
+    this.parent = this.parentPath.node;
+  }
+}
+function _resyncKey() {
+  if (!this.container) return;
+  if (this.node === this.container[this.key]) {
+    return;
+  }
+  if (Array.isArray(this.container)) {
+    for (let i = 0; i < this.container.length; i++) {
+      if (this.container[i] === this.node) {
+        setKey.call(this, i);
+        return;
+      }
+    }
+  } else {
+    for (const key of Object.keys(this.container)) {
+      if (this.container[key] === this.node) {
+        setKey.call(this, key);
+        return;
+      }
+    }
+  }
+  this.key = null;
+}
+function _resyncList() {
+  if (!this.parent || !this.inList) return;
+  const newContainer = this.parent[this.listKey];
+  if (this.container === newContainer) return;
+  this.container = newContainer || null;
+}
+function _resyncRemoved() {
+  if (this.key == null || !this.container || this.container[this.key] !== this.node) {
+    _removal._markRemoved.call(this);
+  }
+}
+function popContext() {
+  this.contexts.pop();
+  if (this.contexts.length > 0) {
+    this.setContext(this.contexts[this.contexts.length - 1]);
+  } else {
+    this.setContext(undefined);
+  }
+}
+function pushContext(context) {
+  this.contexts.push(context);
+  this.setContext(context);
+}
+function setup(parentPath, container, listKey, key) {
+  this.listKey = listKey;
+  this.container = container;
+  this.parentPath = parentPath || this.parentPath;
+  setKey.call(this, key);
+}
+function setKey(key) {
+  var _this$node;
+  this.key = key;
+  this.node = this.container[this.key];
+  this.type = (_this$node = this.node) == null ? void 0 : _this$node.type;
+}
+function requeue(pathToQueue = this) {
+  if (pathToQueue.removed) return;
+  const contexts = this.contexts;
+  for (const context of contexts) {
+    context.maybeQueue(pathToQueue);
+  }
+}
+function requeueComputedKeyAndDecorators() {
+  const {
+    context,
+    node
+  } = this;
+  if (!t.isPrivate(node) && node.computed) {
+    context.maybeQueue(this.get("key"));
+  }
+  if (node.decorators) {
+    for (const decorator of this.get("decorators")) {
+      context.maybeQueue(decorator);
+    }
+  }
+}
+function _getQueueContexts() {
+  let path = this;
+  let contexts = this.contexts;
+  while (!contexts.length) {
+    path = path.parentPath;
+    if (!path) break;
+    contexts = path.contexts;
+  }
+  return contexts;
+}
+
+//# sourceMappingURL=context.js.map

node_modules/@babel/traverse/lib/path/conversion.js

@@ -0,0 +1,608 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.arrowFunctionToExpression = arrowFunctionToExpression;
+exports.ensureBlock = ensureBlock;
+exports.ensureFunctionName = ensureFunctionName;
+exports.splitExportDeclaration = splitExportDeclaration;
+exports.toComputedKey = toComputedKey;
+exports.unwrapFunctionEnvironment = unwrapFunctionEnvironment;
+var _t = require("@babel/types");
+var _template = require("@babel/template");
+var _visitors = require("../visitors.js");
+var _context = require("./context.js");
+const {
+  arrowFunctionExpression,
+  assignmentExpression,
+  binaryExpression,
+  blockStatement,
+  callExpression,
+  conditionalExpression,
+  expressionStatement,
+  identifier,
+  isIdentifier,
+  jsxIdentifier,
+  logicalExpression,
+  LOGICAL_OPERATORS,
+  memberExpression,
+  metaProperty,
+  numericLiteral,
+  objectExpression,
+  restElement,
+  returnStatement,
+  sequenceExpression,
+  spreadElement,
+  stringLiteral,
+  super: _super,
+  thisExpression,
+  toExpression,
+  unaryExpression,
+  toBindingIdentifierName,
+  isFunction,
+  isAssignmentPattern,
+  isRestElement,
+  getFunctionName,
+  cloneNode,
+  variableDeclaration,
+  variableDeclarator,
+  exportNamedDeclaration,
+  exportSpecifier,
+  inherits
+} = _t;
+function toComputedKey() {
+  let key;
+  if (this.isMemberExpression()) {
+    key = this.node.property;
+  } else if (this.isProperty() || this.isMethod()) {
+    key = this.node.key;
+  } else {
+    throw new ReferenceError("todo");
+  }
+  if (!this.node.computed) {
+    if (isIdentifier(key)) key = stringLiteral(key.name);
+  }
+  return key;
+}
+function ensureBlock() {
+  const body = this.get("body");
+  const bodyNode = body.node;
+  if (Array.isArray(body)) {
+    throw new Error("Can't convert array path to a block statement");
+  }
+  if (!bodyNode) {
+    throw new Error("Can't convert node without a body");
+  }
+  if (body.isBlockStatement()) {
+    return bodyNode;
+  }
+  const statements = [];
+  let stringPath = "body";
+  let key;
+  let listKey;
+  if (body.isStatement()) {
+    listKey = "body";
+    key = 0;
+    statements.push(body.node);
+  } else {
+    stringPath += ".body.0";
+    if (this.isFunction()) {
+      key = "argument";
+      statements.push(returnStatement(body.node));
+    } else {
+      key = "expression";
+      statements.push(expressionStatement(body.node));
+    }
+  }
+  this.node.body = blockStatement(statements);
+  const parentPath = this.get(stringPath);
+  _context.setup.call(body, parentPath, listKey ? parentPath.node[listKey] : parentPath.node, listKey, key);
+  return this.node;
+}
+exports.arrowFunctionToShadowed = function () {
+  if (!this.isArrowFunctionExpression()) return;
+  this.arrowFunctionToExpression();
+};
+function unwrapFunctionEnvironment() {
+  if (!this.isArrowFunctionExpression() && !this.isFunctionExpression() && !this.isFunctionDeclaration()) {
+    throw this.buildCodeFrameError("Can only unwrap the environment of a function.");
+  }
+  hoistFunctionEnvironment(this);
+}
+function setType(path, type) {
+  path.node.type = type;
+}
+function arrowFunctionToExpression({
+  allowInsertArrow = true,
+  allowInsertArrowWithRest = allowInsertArrow,
+  noNewArrows = !(_arguments$ => (_arguments$ = arguments[0]) == null ? void 0 : _arguments$.specCompliant)()
+} = {}) {
+  if (!this.isArrowFunctionExpression()) {
+    throw this.buildCodeFrameError("Cannot convert non-arrow function to a function expression.");
+  }
+  let self = this;
+  if (!noNewArrows) {
+    var _self$ensureFunctionN;
+    self = (_self$ensureFunctionN = self.ensureFunctionName(false)) != null ? _self$ensureFunctionN : self;
+  }
+  const {
+    thisBinding,
+    fnPath: fn
+  } = hoistFunctionEnvironment(self, noNewArrows, allowInsertArrow, allowInsertArrowWithRest);
+  fn.ensureBlock();
+  setType(fn, "FunctionExpression");
+  if (!noNewArrows) {
+    const checkBinding = thisBinding ? null : fn.scope.generateUidIdentifier("arrowCheckId");
+    if (checkBinding) {
+      fn.parentPath.scope.push({
+        id: checkBinding,
+        init: objectExpression([])
+      });
+    }
+    fn.get("body").unshiftContainer("body", expressionStatement(callExpression(this.hub.addHelper("newArrowCheck"), [thisExpression(), checkBinding ? identifier(checkBinding.name) : identifier(thisBinding)])));
+    fn.replaceWith(callExpression(memberExpression(fn.node, identifier("bind")), [checkBinding ? identifier(checkBinding.name) : thisExpression()]));
+    return fn.get("callee.object");
+  }
+  return fn;
+}
+const getSuperCallsVisitor = (0, _visitors.environmentVisitor)({
+  CallExpression(child, {
+    allSuperCalls
+  }) {
+    if (!child.get("callee").isSuper()) return;
+    allSuperCalls.push(child);
+  }
+});
+function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow = true, allowInsertArrowWithRest = true) {
+  let arrowParent;
+  let thisEnvFn = fnPath.findParent(p => {
+    if (p.isArrowFunctionExpression()) {
+      arrowParent != null ? arrowParent : arrowParent = p;
+      return false;
+    }
+    return p.isFunction() || p.isProgram() || p.isClassProperty({
+      static: false
+    }) || p.isClassPrivateProperty({
+      static: false
+    });
+  });
+  const inConstructor = thisEnvFn.isClassMethod({
+    kind: "constructor"
+  });
+  if (thisEnvFn.isClassProperty() || thisEnvFn.isClassPrivateProperty()) {
+    if (arrowParent) {
+      thisEnvFn = arrowParent;
+    } else if (allowInsertArrow) {
+      fnPath.replaceWith(callExpression(arrowFunctionExpression([], toExpression(fnPath.node)), []));
+      thisEnvFn = fnPath.get("callee");
+      fnPath = thisEnvFn.get("body");
+    } else {
+      throw fnPath.buildCodeFrameError("Unable to transform arrow inside class property");
+    }
+  }
+  const {
+    thisPaths,
+    argumentsPaths,
+    newTargetPaths,
+    superProps,
+    superCalls
+  } = getScopeInformation(fnPath);
+  if (inConstructor && superCalls.length > 0) {
+    if (!allowInsertArrow) {
+      throw superCalls[0].buildCodeFrameError("When using '@babel/plugin-transform-arrow-functions', " + "it's not possible to compile `super()` in an arrow function without compiling classes.\n" + "Please add '@babel/plugin-transform-classes' to your Babel configuration.");
+    }
+    if (!allowInsertArrowWithRest) {
+      throw superCalls[0].buildCodeFrameError("When using '@babel/plugin-transform-parameters', " + "it's not possible to compile `super()` in an arrow function with default or rest parameters without compiling classes.\n" + "Please add '@babel/plugin-transform-classes' to your Babel configuration.");
+    }
+    const allSuperCalls = [];
+    thisEnvFn.traverse(getSuperCallsVisitor, {
+      allSuperCalls
+    });
+    const superBinding = getSuperBinding(thisEnvFn);
+    allSuperCalls.forEach(superCall => {
+      const callee = identifier(superBinding);
+      callee.loc = superCall.node.callee.loc;
+      superCall.get("callee").replaceWith(callee);
+    });
+  }
+  if (argumentsPaths.length > 0) {
+    const argumentsBinding = getBinding(thisEnvFn, "arguments", () => {
+      const args = () => identifier("arguments");
+      if (thisEnvFn.scope.path.isProgram()) {
+        return conditionalExpression(binaryExpression("===", unaryExpression("typeof", args()), stringLiteral("undefined")), thisEnvFn.scope.buildUndefinedNode(), args());
+      } else {
+        return args();
+      }
+    });
+    argumentsPaths.forEach(argumentsChild => {
+      const argsRef = identifier(argumentsBinding);
+      argsRef.loc = argumentsChild.node.loc;
+      argumentsChild.replaceWith(argsRef);
+    });
+  }
+  if (newTargetPaths.length > 0) {
+    const newTargetBinding = getBinding(thisEnvFn, "newtarget", () => metaProperty(identifier("new"), identifier("target")));
+    newTargetPaths.forEach(targetChild => {
+      const targetRef = identifier(newTargetBinding);
+      targetRef.loc = targetChild.node.loc;
+      targetChild.replaceWith(targetRef);
+    });
+  }
+  if (superProps.length > 0) {
+    if (!allowInsertArrow) {
+      throw superProps[0].buildCodeFrameError("When using '@babel/plugin-transform-arrow-functions', " + "it's not possible to compile `super.prop` in an arrow function without compiling classes.\n" + "Please add '@babel/plugin-transform-classes' to your Babel configuration.");
+    }
+    const flatSuperProps = superProps.reduce((acc, superProp) => acc.concat(standardizeSuperProperty(superProp)), []);
+    flatSuperProps.forEach(superProp => {
+      const key = superProp.node.computed ? "" : superProp.get("property").node.name;
+      const superParentPath = superProp.parentPath;
+      const isAssignment = superParentPath.isAssignmentExpression({
+        left: superProp.node
+      });
+      const isCall = superParentPath.isCallExpression({
+        callee: superProp.node
+      });
+      const isTaggedTemplate = superParentPath.isTaggedTemplateExpression({
+        tag: superProp.node
+      });
+      const superBinding = getSuperPropBinding(thisEnvFn, isAssignment, key);
+      const args = [];
+      if (superProp.node.computed) {
+        args.push(superProp.get("property").node);
+      }
+      if (isAssignment) {
+        const value = superParentPath.node.right;
+        args.push(value);
+      }
+      const call = callExpression(identifier(superBinding), args);
+      if (isCall) {
+        superParentPath.unshiftContainer("arguments", thisExpression());
+        superProp.replaceWith(memberExpression(call, identifier("call")));
+        thisPaths.push(superParentPath.get("arguments.0"));
+      } else if (isAssignment) {
+        superParentPath.replaceWith(call);
+      } else if (isTaggedTemplate) {
+        superProp.replaceWith(callExpression(memberExpression(call, identifier("bind"), false), [thisExpression()]));
+        thisPaths.push(superProp.get("arguments.0"));
+      } else {
+        superProp.replaceWith(call);
+      }
+    });
+  }
+  let thisBinding;
+  if (thisPaths.length > 0 || !noNewArrows) {
+    thisBinding = getThisBinding(thisEnvFn, inConstructor);
+    if (noNewArrows || inConstructor && hasSuperClass(thisEnvFn)) {
+      thisPaths.forEach(thisChild => {
+        const thisRef = thisChild.isJSX() ? jsxIdentifier(thisBinding) : identifier(thisBinding);
+        thisRef.loc = thisChild.node.loc;
+        thisChild.replaceWith(thisRef);
+      });
+      if (!noNewArrows) thisBinding = null;
+    }
+  }
+  return {
+    thisBinding: thisBinding,
+    fnPath
+  };
+}
+function isLogicalOp(op) {
+  return LOGICAL_OPERATORS.includes(op);
+}
+function standardizeSuperProperty(superProp) {
+  if (superProp.parentPath.isAssignmentExpression() && superProp.parentPath.node.operator !== "=") {
+    const assignmentPath = superProp.parentPath;
+    const op = assignmentPath.node.operator.slice(0, -1);
+    const value = assignmentPath.node.right;
+    const isLogicalAssignment = isLogicalOp(op);
+    if (superProp.node.computed) {
+      const tmp = superProp.scope.generateDeclaredUidIdentifier("tmp");
+      const {
+        object,
+        property
+      } = superProp.node;
+      assignmentPath.get("left").replaceWith(memberExpression(object, assignmentExpression("=", tmp, property), true));
+      assignmentPath.get("right").replaceWith(rightExpression(isLogicalAssignment ? "=" : op, memberExpression(object, identifier(tmp.name), true), value));
+    } else {
+      const object = superProp.node.object;
+      const property = superProp.node.property;
+      assignmentPath.get("left").replaceWith(memberExpression(object, property));
+      assignmentPath.get("right").replaceWith(rightExpression(isLogicalAssignment ? "=" : op, memberExpression(object, identifier(property.name)), value));
+    }
+    if (isLogicalAssignment) {
+      assignmentPath.replaceWith(logicalExpression(op, assignmentPath.node.left, assignmentPath.node.right));
+    } else {
+      assignmentPath.node.operator = "=";
+    }
+    return [assignmentPath.get("left"), assignmentPath.get("right").get("left")];
+  } else if (superProp.parentPath.isUpdateExpression()) {
+    const updateExpr = superProp.parentPath;
+    const tmp = superProp.scope.generateDeclaredUidIdentifier("tmp");
+    const computedKey = superProp.node.computed ? superProp.scope.generateDeclaredUidIdentifier("prop") : null;
+    const parts = [assignmentExpression("=", tmp, memberExpression(superProp.node.object, computedKey ? assignmentExpression("=", computedKey, superProp.node.property) : superProp.node.property, superProp.node.computed)), assignmentExpression("=", memberExpression(superProp.node.object, computedKey ? identifier(computedKey.name) : superProp.node.property, superProp.node.computed), binaryExpression(superProp.parentPath.node.operator[0], identifier(tmp.name), numericLiteral(1)))];
+    if (!superProp.parentPath.node.prefix) {
+      parts.push(identifier(tmp.name));
+    }
+    updateExpr.replaceWith(sequenceExpression(parts));
+    const left = updateExpr.get("expressions.0.right");
+    const right = updateExpr.get("expressions.1.left");
+    return [left, right];
+  }
+  return [superProp];
+  function rightExpression(op, left, right) {
+    if (op === "=") {
+      return assignmentExpression("=", left, right);
+    } else {
+      return binaryExpression(op, left, right);
+    }
+  }
+}
+function hasSuperClass(thisEnvFn) {
+  return thisEnvFn.isClassMethod() && !!thisEnvFn.parentPath.parentPath.node.superClass;
+}
+const assignSuperThisVisitor = (0, _visitors.environmentVisitor)({
+  CallExpression(child, {
+    supers,
+    thisBinding
+  }) {
+    if (!child.get("callee").isSuper()) return;
+    if (supers.has(child.node)) return;
+    supers.add(child.node);
+    child.replaceWithMultiple([child.node, assignmentExpression("=", identifier(thisBinding), identifier("this"))]);
+  }
+});
+function getThisBinding(thisEnvFn, inConstructor) {
+  return getBinding(thisEnvFn, "this", thisBinding => {
+    if (!inConstructor || !hasSuperClass(thisEnvFn)) return thisExpression();
+    thisEnvFn.traverse(assignSuperThisVisitor, {
+      supers: new WeakSet(),
+      thisBinding
+    });
+  });
+}
+function getSuperBinding(thisEnvFn) {
+  return getBinding(thisEnvFn, "supercall", () => {
+    const argsBinding = thisEnvFn.scope.generateUidIdentifier("args");
+    return arrowFunctionExpression([restElement(argsBinding)], callExpression(_super(), [spreadElement(identifier(argsBinding.name))]));
+  });
+}
+function getSuperPropBinding(thisEnvFn, isAssignment, propName) {
+  const op = isAssignment ? "set" : "get";
+  return getBinding(thisEnvFn, `superprop_${op}:${propName || ""}`, () => {
+    const argsList = [];
+    let fnBody;
+    if (propName) {
+      fnBody = memberExpression(_super(), identifier(propName));
+    } else {
+      const method = thisEnvFn.scope.generateUidIdentifier("prop");
+      argsList.unshift(method);
+      fnBody = memberExpression(_super(), identifier(method.name), true);
+    }
+    if (isAssignment) {
+      const valueIdent = thisEnvFn.scope.generateUidIdentifier("value");
+      argsList.push(valueIdent);
+      fnBody = assignmentExpression("=", fnBody, identifier(valueIdent.name));
+    }
+    return arrowFunctionExpression(argsList, fnBody);
+  });
+}
+function getBinding(thisEnvFn, key, init) {
+  const cacheKey = "binding:" + key;
+  let data = thisEnvFn.getData(cacheKey);
+  if (!data) {
+    const id = thisEnvFn.scope.generateUidIdentifier(key);
+    data = id.name;
+    thisEnvFn.setData(cacheKey, data);
+    thisEnvFn.scope.push({
+      id: id,
+      init: init(data)
+    });
+  }
+  return data;
+}
+const getScopeInformationVisitor = (0, _visitors.environmentVisitor)({
+  ThisExpression(child, {
+    thisPaths
+  }) {
+    thisPaths.push(child);
+  },
+  JSXIdentifier(child, {
+    thisPaths
+  }) {
+    if (child.node.name !== "this") return;
+    if (!child.parentPath.isJSXMemberExpression({
+      object: child.node
+    }) && !child.parentPath.isJSXOpeningElement({
+      name: child.node
+    })) {
+      return;
+    }
+    thisPaths.push(child);
+  },
+  CallExpression(child, {
+    superCalls
+  }) {
+    if (child.get("callee").isSuper()) superCalls.push(child);
+  },
+  MemberExpression(child, {
+    superProps
+  }) {
+    if (child.get("object").isSuper()) superProps.push(child);
+  },
+  Identifier(child, {
+    argumentsPaths
+  }) {
+    if (!child.isReferencedIdentifier({
+      name: "arguments"
+    })) return;
+    let curr = child.scope;
+    do {
+      if (curr.hasOwnBinding("arguments")) {
+        curr.rename("arguments");
+        return;
+      }
+      if (curr.path.isFunction() && !curr.path.isArrowFunctionExpression()) {
+        break;
+      }
+    } while (curr = curr.parent);
+    argumentsPaths.push(child);
+  },
+  MetaProperty(child, {
+    newTargetPaths
+  }) {
+    if (!child.get("meta").isIdentifier({
+      name: "new"
+    })) return;
+    if (!child.get("property").isIdentifier({
+      name: "target"
+    })) return;
+    newTargetPaths.push(child);
+  }
+});
+function getScopeInformation(fnPath) {
+  const thisPaths = [];
+  const argumentsPaths = [];
+  const newTargetPaths = [];
+  const superProps = [];
+  const superCalls = [];
+  fnPath.traverse(getScopeInformationVisitor, {
+    thisPaths,
+    argumentsPaths,
+    newTargetPaths,
+    superProps,
+    superCalls
+  });
+  return {
+    thisPaths,
+    argumentsPaths,
+    newTargetPaths,
+    superProps,
+    superCalls
+  };
+}
+function splitExportDeclaration() {
+  if (!this.isExportDeclaration() || this.isExportAllDeclaration()) {
+    throw new Error("Only default and named export declarations can be split.");
+  }
+  if (this.isExportNamedDeclaration() && this.get("specifiers").length > 0) {
+    throw new Error("It doesn't make sense to split exported specifiers.");
+  }
+  const declaration = this.get("declaration");
+  if (this.isExportDefaultDeclaration()) {
+    const standaloneDeclaration = declaration.isFunctionDeclaration() || declaration.isClassDeclaration();
+    const exportExpr = declaration.isFunctionExpression() || declaration.isClassExpression();
+    const scope = declaration.isScope() ? declaration.scope.parent : declaration.scope;
+    let id = declaration.node.id;
+    let needBindingRegistration = false;
+    if (!id) {
+      needBindingRegistration = true;
+      id = scope.generateUidIdentifier("default");
+      if (standaloneDeclaration || exportExpr) {
+        declaration.node.id = cloneNode(id);
+      }
+    } else if (exportExpr && scope.hasBinding(id.name)) {
+      needBindingRegistration = true;
+      id = scope.generateUidIdentifier(id.name);
+    }
+    const updatedDeclaration = standaloneDeclaration ? declaration.node : variableDeclaration("var", [variableDeclarator(cloneNode(id), declaration.node)]);
+    const updatedExportDeclaration = exportNamedDeclaration(null, [exportSpecifier(cloneNode(id), identifier("default"))]);
+    this.insertAfter(updatedExportDeclaration);
+    this.replaceWith(updatedDeclaration);
+    if (needBindingRegistration) {
+      scope.registerDeclaration(this);
+    }
+    return this;
+  } else if (this.get("specifiers").length > 0) {
+    throw new Error("It doesn't make sense to split exported specifiers.");
+  }
+  const bindingIdentifiers = declaration.getOuterBindingIdentifiers();
+  const specifiers = Object.keys(bindingIdentifiers).map(name => {
+    return exportSpecifier(identifier(name), identifier(name));
+  });
+  const aliasDeclar = exportNamedDeclaration(null, specifiers);
+  this.insertAfter(aliasDeclar);
+  this.replaceWith(declaration.node);
+  return this;
+}
+const refersOuterBindingVisitor = {
+  "ReferencedIdentifier|BindingIdentifier"(path, state) {
+    if (path.node.name !== state.name) return;
+    state.needsRename = true;
+    path.stop();
+  },
+  Scope(path, state) {
+    if (path.scope.hasOwnBinding(state.name)) {
+      path.skip();
+    }
+  }
+};
+function ensureFunctionName(supportUnicodeId) {
+  if (this.node.id) return this;
+  const res = getFunctionName(this.node, this.parent);
+  if (res == null) return this;
+  let {
+    name
+  } = res;
+  if (!supportUnicodeId && /[\uD800-\uDFFF]/.test(name)) {
+    return null;
+  }
+  if (name.startsWith("get ") || name.startsWith("set ")) {
+    return null;
+  }
+  name = toBindingIdentifierName(name.replace(/[/ ]/g, "_"));
+  const id = identifier(name);
+  inherits(id, res.originalNode);
+  const state = {
+    needsRename: false,
+    name
+  };
+  const {
+    scope
+  } = this;
+  const binding = scope.getOwnBinding(name);
+  if (binding) {
+    if (binding.kind === "param") {
+      state.needsRename = true;
+    } else {}
+  } else if (scope.parent.hasBinding(name) || scope.hasGlobal(name)) {
+    this.traverse(refersOuterBindingVisitor, state);
+  }
+  if (!state.needsRename) {
+    this.node.id = id;
+    scope.getProgramParent().references[id.name] = true;
+    return this;
+  }
+  if (scope.hasBinding(id.name) && !scope.hasGlobal(id.name)) {
+    scope.rename(id.name);
+    this.node.id = id;
+    scope.getProgramParent().references[id.name] = true;
+    return this;
+  }
+  if (!isFunction(this.node)) return null;
+  const key = scope.generateUidIdentifier(id.name);
+  const params = [];
+  for (let i = 0, len = getFunctionArity(this.node); i < len; i++) {
+    params.push(scope.generateUidIdentifier("x"));
+  }
+  const call = _template.default.expression.ast`
+    (function (${key}) {
+      function ${id}(${params}) {
+        return ${cloneNode(key)}.apply(this, arguments);
+      }
+
+      ${cloneNode(id)}.toString = function () {
+        return ${cloneNode(key)}.toString();
+      }
+
+      return ${cloneNode(id)};
+    })(${toExpression(this.node)})
+  `;
+  return this.replaceWith(call)[0].get("arguments.0");
+}
+function getFunctionArity(node) {
+  const count = node.params.findIndex(param => isAssignmentPattern(param) || isRestElement(param));
+  return count === -1 ? node.params.length : count;
+}
+
+//# sourceMappingURL=conversion.js.map

node_modules/@babel/traverse/lib/path/evaluation.js

@@ -0,0 +1,373 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.evaluate = evaluate;
+exports.evaluateTruthy = evaluateTruthy;
+const VALID_OBJECT_CALLEES = ["Number", "String", "Math"];
+const VALID_IDENTIFIER_CALLEES = ["isFinite", "isNaN", "parseFloat", "parseInt", "decodeURI", "decodeURIComponent", "encodeURI", "encodeURIComponent", null, null];
+const INVALID_METHODS = ["random"];
+function isValidObjectCallee(val) {
+  return VALID_OBJECT_CALLEES.includes(val);
+}
+function isValidIdentifierCallee(val) {
+  return VALID_IDENTIFIER_CALLEES.includes(val);
+}
+function isInvalidMethod(val) {
+  return INVALID_METHODS.includes(val);
+}
+function evaluateTruthy() {
+  const res = this.evaluate();
+  if (res.confident) return !!res.value;
+}
+function deopt(path, state) {
+  if (!state.confident) return;
+  state.deoptPath = path;
+  state.confident = false;
+}
+const Globals = new Map([["undefined", undefined], ["Infinity", Infinity], ["NaN", NaN]]);
+function evaluateCached(path, state) {
+  const {
+    node
+  } = path;
+  const {
+    seen
+  } = state;
+  if (seen.has(node)) {
+    const existing = seen.get(node);
+    if (existing.resolved) {
+      return existing.value;
+    } else {
+      deopt(path, state);
+      return;
+    }
+  } else {
+    const item = {
+      resolved: false
+    };
+    seen.set(node, item);
+    const val = _evaluate(path, state);
+    if (state.confident) {
+      item.resolved = true;
+      item.value = val;
+    }
+    return val;
+  }
+}
+function _evaluate(path, state) {
+  if (!state.confident) return;
+  if (path.isSequenceExpression()) {
+    const exprs = path.get("expressions");
+    return evaluateCached(exprs[exprs.length - 1], state);
+  }
+  if (path.isStringLiteral() || path.isNumericLiteral() || path.isBooleanLiteral()) {
+    return path.node.value;
+  }
+  if (path.isNullLiteral()) {
+    return null;
+  }
+  if (path.isTemplateLiteral()) {
+    return evaluateQuasis(path, path.node.quasis, state);
+  }
+  if (path.isTaggedTemplateExpression() && path.get("tag").isMemberExpression()) {
+    const object = path.get("tag.object");
+    const {
+      node: {
+        name
+      }
+    } = object;
+    const property = path.get("tag.property");
+    if (object.isIdentifier() && name === "String" && !path.scope.getBinding(name) && property.isIdentifier() && property.node.name === "raw") {
+      return evaluateQuasis(path, path.node.quasi.quasis, state, true);
+    }
+  }
+  if (path.isConditionalExpression()) {
+    const testResult = evaluateCached(path.get("test"), state);
+    if (!state.confident) return;
+    if (testResult) {
+      return evaluateCached(path.get("consequent"), state);
+    } else {
+      return evaluateCached(path.get("alternate"), state);
+    }
+  }
+  if (path.isExpressionWrapper()) {
+    return evaluateCached(path.get("expression"), state);
+  }
+  if (path.isMemberExpression() && !path.parentPath.isCallExpression({
+    callee: path.node
+  })) {
+    const property = path.get("property");
+    const object = path.get("object");
+    if (object.isLiteral()) {
+      const value = object.node.value;
+      const type = typeof value;
+      let key = null;
+      if (path.node.computed) {
+        key = evaluateCached(property, state);
+        if (!state.confident) return;
+      } else if (property.isIdentifier()) {
+        key = property.node.name;
+      }
+      if ((type === "number" || type === "string") && key != null && (typeof key === "number" || typeof key === "string")) {
+        return value[key];
+      }
+    }
+  }
+  if (path.isReferencedIdentifier()) {
+    const binding = path.scope.getBinding(path.node.name);
+    if (binding) {
+      if (binding.constantViolations.length > 0 || path.node.start < binding.path.node.end) {
+        deopt(binding.path, state);
+        return;
+      }
+      const bindingPathScope = binding.path.scope;
+      if (binding.kind === "var" && bindingPathScope !== binding.scope) {
+        let hasUnsafeBlock = !bindingPathScope.path.parentPath.isBlockStatement();
+        for (let scope = bindingPathScope.parent; scope; scope = scope.parent) {
+          var _scope$path$parentPat;
+          if (scope === path.scope) {
+            if (hasUnsafeBlock) {
+              deopt(binding.path, state);
+              return;
+            }
+            break;
+          }
+          if ((_scope$path$parentPat = scope.path.parentPath) != null && _scope$path$parentPat.isBlockStatement()) {
+            hasUnsafeBlock = true;
+          }
+        }
+      }
+      if (binding.hasValue) {
+        return binding.value;
+      }
+    }
+    const name = path.node.name;
+    if (Globals.has(name)) {
+      if (!binding) {
+        return Globals.get(name);
+      }
+      deopt(binding.path, state);
+      return;
+    }
+    if (!binding) {
+      deopt(path, state);
+      return;
+    }
+    const bindingPath = binding.path;
+    if (!bindingPath.isVariableDeclarator()) {
+      deopt(bindingPath, state);
+      return;
+    }
+    const initPath = bindingPath.get("init");
+    const value = evaluateCached(initPath, state);
+    if (typeof value === "object" && value !== null && binding.references > 1) {
+      deopt(initPath, state);
+      return;
+    }
+    return value;
+  }
+  if (path.isUnaryExpression({
+    prefix: true
+  })) {
+    if (path.node.operator === "void") {
+      return undefined;
+    }
+    const argument = path.get("argument");
+    if (path.node.operator === "typeof" && (argument.isFunction() || argument.isClass())) {
+      return "function";
+    }
+    const arg = evaluateCached(argument, state);
+    if (!state.confident) return;
+    switch (path.node.operator) {
+      case "!":
+        return !arg;
+      case "+":
+        return +arg;
+      case "-":
+        return -arg;
+      case "~":
+        return ~arg;
+      case "typeof":
+        return typeof arg;
+    }
+  }
+  if (path.isArrayExpression()) {
+    const arr = [];
+    const elems = path.get("elements");
+    for (const elem of elems) {
+      const elemValue = elem.evaluate();
+      if (elemValue.confident) {
+        arr.push(elemValue.value);
+      } else {
+        deopt(elemValue.deopt, state);
+        return;
+      }
+    }
+    return arr;
+  }
+  if (path.isObjectExpression()) {
+    const obj = {};
+    const props = path.get("properties");
+    for (const prop of props) {
+      if (prop.isObjectMethod() || prop.isSpreadElement()) {
+        deopt(prop, state);
+        return;
+      }
+      const keyPath = prop.get("key");
+      let key;
+      if (prop.node.computed) {
+        key = keyPath.evaluate();
+        if (!key.confident) {
+          deopt(key.deopt, state);
+          return;
+        }
+        key = key.value;
+      } else if (keyPath.isIdentifier()) {
+        key = keyPath.node.name;
+      } else {
+        key = keyPath.node.value;
+      }
+      const valuePath = prop.get("value");
+      let value = valuePath.evaluate();
+      if (!value.confident) {
+        deopt(value.deopt, state);
+        return;
+      }
+      value = value.value;
+      obj[key] = value;
+    }
+    return obj;
+  }
+  if (path.isLogicalExpression()) {
+    const wasConfident = state.confident;
+    const left = evaluateCached(path.get("left"), state);
+    const leftConfident = state.confident;
+    state.confident = wasConfident;
+    const right = evaluateCached(path.get("right"), state);
+    const rightConfident = state.confident;
+    switch (path.node.operator) {
+      case "||":
+        state.confident = leftConfident && (!!left || rightConfident);
+        if (!state.confident) return;
+        return left || right;
+      case "&&":
+        state.confident = leftConfident && (!left || rightConfident);
+        if (!state.confident) return;
+        return left && right;
+      case "??":
+        state.confident = leftConfident && (left != null || rightConfident);
+        if (!state.confident) return;
+        return left != null ? left : right;
+    }
+  }
+  if (path.isBinaryExpression()) {
+    const left = evaluateCached(path.get("left"), state);
+    if (!state.confident) return;
+    const right = evaluateCached(path.get("right"), state);
+    if (!state.confident) return;
+    switch (path.node.operator) {
+      case "-":
+        return left - right;
+      case "+":
+        return left + right;
+      case "/":
+        return left / right;
+      case "*":
+        return left * right;
+      case "%":
+        return left % right;
+      case "**":
+        return Math.pow(left, right);
+      case "<":
+        return left < right;
+      case ">":
+        return left > right;
+      case "<=":
+        return left <= right;
+      case ">=":
+        return left >= right;
+      case "==":
+        return left == right;
+      case "!=":
+        return left != right;
+      case "===":
+        return left === right;
+      case "!==":
+        return left !== right;
+      case "|":
+        return left | right;
+      case "&":
+        return left & right;
+      case "^":
+        return left ^ right;
+      case "<<":
+        return left << right;
+      case ">>":
+        return left >> right;
+      case ">>>":
+        return left >>> right;
+    }
+  }
+  if (path.isCallExpression()) {
+    const callee = path.get("callee");
+    let context;
+    let func;
+    if (callee.isIdentifier() && !path.scope.getBinding(callee.node.name) && (isValidObjectCallee(callee.node.name) || isValidIdentifierCallee(callee.node.name))) {
+      func = global[callee.node.name];
+    }
+    if (callee.isMemberExpression()) {
+      const object = callee.get("object");
+      const property = callee.get("property");
+      if (object.isIdentifier() && property.isIdentifier() && isValidObjectCallee(object.node.name) && !isInvalidMethod(property.node.name)) {
+        context = global[object.node.name];
+        const key = property.node.name;
+        if (hasOwnProperty.call(context, key)) {
+          func = context[key];
+        }
+      }
+      if (object.isLiteral() && property.isIdentifier()) {
+        const type = typeof object.node.value;
+        if (type === "string" || type === "number") {
+          context = object.node.value;
+          func = context[property.node.name];
+        }
+      }
+    }
+    if (func) {
+      const args = path.get("arguments").map(arg => evaluateCached(arg, state));
+      if (!state.confident) return;
+      return func.apply(context, args);
+    }
+  }
+  deopt(path, state);
+}
+function evaluateQuasis(path, quasis, state, raw = false) {
+  let str = "";
+  let i = 0;
+  const exprs = path.isTemplateLiteral() ? path.get("expressions") : path.get("quasi.expressions");
+  for (const elem of quasis) {
+    if (!state.confident) break;
+    str += raw ? elem.value.raw : elem.value.cooked;
+    const expr = exprs[i++];
+    if (expr) str += String(evaluateCached(expr, state));
+  }
+  if (!state.confident) return;
+  return str;
+}
+function evaluate() {
+  const state = {
+    confident: true,
+    deoptPath: null,
+    seen: new Map()
+  };
+  let value = evaluateCached(this, state);
+  if (!state.confident) value = undefined;
+  return {
+    confident: state.confident,
+    deopt: state.deoptPath,
+    value: value
+  };
+}
+
+//# sourceMappingURL=evaluation.js.map

node_modules/@babel/traverse/lib/path/family.js

@@ -0,0 +1,346 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._getKey = _getKey;
+exports._getPattern = _getPattern;
+exports.get = get;
+exports.getAllNextSiblings = getAllNextSiblings;
+exports.getAllPrevSiblings = getAllPrevSiblings;
+exports.getAssignmentIdentifiers = getAssignmentIdentifiers;
+exports.getBindingIdentifierPaths = getBindingIdentifierPaths;
+exports.getBindingIdentifiers = getBindingIdentifiers;
+exports.getCompletionRecords = getCompletionRecords;
+exports.getNextSibling = getNextSibling;
+exports.getOpposite = getOpposite;
+exports.getOuterBindingIdentifierPaths = getOuterBindingIdentifierPaths;
+exports.getOuterBindingIdentifiers = getOuterBindingIdentifiers;
+exports.getPrevSibling = getPrevSibling;
+exports.getSibling = getSibling;
+var _index = require("./index.js");
+var _t = require("@babel/types");
+const {
+  getAssignmentIdentifiers: _getAssignmentIdentifiers,
+  getBindingIdentifiers: _getBindingIdentifiers,
+  getOuterBindingIdentifiers: _getOuterBindingIdentifiers,
+  numericLiteral,
+  unaryExpression
+} = _t;
+const NORMAL_COMPLETION = 0;
+const BREAK_COMPLETION = 1;
+function NormalCompletion(path) {
+  return {
+    type: NORMAL_COMPLETION,
+    path
+  };
+}
+function BreakCompletion(path) {
+  return {
+    type: BREAK_COMPLETION,
+    path
+  };
+}
+function getOpposite() {
+  if (this.key === "left") {
+    return this.getSibling("right");
+  } else if (this.key === "right") {
+    return this.getSibling("left");
+  }
+  return null;
+}
+function addCompletionRecords(path, records, context) {
+  if (path) {
+    records.push(..._getCompletionRecords(path, context));
+  }
+  return records;
+}
+function completionRecordForSwitch(cases, records, context) {
+  let lastNormalCompletions = [];
+  for (let i = 0; i < cases.length; i++) {
+    const casePath = cases[i];
+    const caseCompletions = _getCompletionRecords(casePath, context);
+    const normalCompletions = [];
+    const breakCompletions = [];
+    for (const c of caseCompletions) {
+      if (c.type === NORMAL_COMPLETION) {
+        normalCompletions.push(c);
+      }
+      if (c.type === BREAK_COMPLETION) {
+        breakCompletions.push(c);
+      }
+    }
+    if (normalCompletions.length) {
+      lastNormalCompletions = normalCompletions;
+    }
+    records.push(...breakCompletions);
+  }
+  records.push(...lastNormalCompletions);
+  return records;
+}
+function normalCompletionToBreak(completions) {
+  completions.forEach(c => {
+    c.type = BREAK_COMPLETION;
+  });
+}
+function replaceBreakStatementInBreakCompletion(completions, reachable) {
+  completions.forEach(c => {
+    if (c.path.isBreakStatement({
+      label: null
+    })) {
+      if (reachable) {
+        c.path.replaceWith(unaryExpression("void", numericLiteral(0)));
+      } else {
+        c.path.remove();
+      }
+    }
+  });
+}
+function getStatementListCompletion(paths, context) {
+  const completions = [];
+  if (context.canHaveBreak) {
+    let lastNormalCompletions = [];
+    for (let i = 0; i < paths.length; i++) {
+      const path = paths[i];
+      const newContext = Object.assign({}, context, {
+        inCaseClause: false
+      });
+      if (path.isBlockStatement() && (context.inCaseClause || context.shouldPopulateBreak)) {
+        newContext.shouldPopulateBreak = true;
+      } else {
+        newContext.shouldPopulateBreak = false;
+      }
+      const statementCompletions = _getCompletionRecords(path, newContext);
+      if (statementCompletions.length > 0 && statementCompletions.every(c => c.type === BREAK_COMPLETION)) {
+        if (lastNormalCompletions.length > 0 && statementCompletions.every(c => c.path.isBreakStatement({
+          label: null
+        }))) {
+          normalCompletionToBreak(lastNormalCompletions);
+          completions.push(...lastNormalCompletions);
+          if (lastNormalCompletions.some(c => c.path.isDeclaration())) {
+            completions.push(...statementCompletions);
+            if (!context.shouldPreserveBreak) {
+              replaceBreakStatementInBreakCompletion(statementCompletions, true);
+            }
+          }
+          if (!context.shouldPreserveBreak) {
+            replaceBreakStatementInBreakCompletion(statementCompletions, false);
+          }
+        } else {
+          completions.push(...statementCompletions);
+          if (!context.shouldPopulateBreak && !context.shouldPreserveBreak) {
+            replaceBreakStatementInBreakCompletion(statementCompletions, true);
+          }
+        }
+        break;
+      }
+      if (i === paths.length - 1) {
+        completions.push(...statementCompletions);
+      } else {
+        lastNormalCompletions = [];
+        for (let i = 0; i < statementCompletions.length; i++) {
+          const c = statementCompletions[i];
+          if (c.type === BREAK_COMPLETION) {
+            completions.push(c);
+          }
+          if (c.type === NORMAL_COMPLETION) {
+            lastNormalCompletions.push(c);
+          }
+        }
+      }
+    }
+  } else if (paths.length) {
+    for (let i = paths.length - 1; i >= 0; i--) {
+      const pathCompletions = _getCompletionRecords(paths[i], context);
+      if (pathCompletions.length > 1 || pathCompletions.length === 1 && !pathCompletions[0].path.isVariableDeclaration() && !pathCompletions[0].path.isEmptyStatement()) {
+        completions.push(...pathCompletions);
+        break;
+      }
+    }
+  }
+  return completions;
+}
+function _getCompletionRecords(path, context) {
+  let records = [];
+  if (path.isIfStatement()) {
+    records = addCompletionRecords(path.get("consequent"), records, context);
+    records = addCompletionRecords(path.get("alternate"), records, context);
+  } else if (path.isDoExpression() || path.isFor() || path.isWhile() || path.isLabeledStatement()) {
+    return addCompletionRecords(path.get("body"), records, context);
+  } else if (path.isProgram() || path.isBlockStatement()) {
+    return getStatementListCompletion(path.get("body"), context);
+  } else if (path.isFunction()) {
+    return _getCompletionRecords(path.get("body"), context);
+  } else if (path.isTryStatement()) {
+    records = addCompletionRecords(path.get("block"), records, context);
+    records = addCompletionRecords(path.get("handler"), records, context);
+  } else if (path.isCatchClause()) {
+    return addCompletionRecords(path.get("body"), records, context);
+  } else if (path.isSwitchStatement()) {
+    return completionRecordForSwitch(path.get("cases"), records, context);
+  } else if (path.isSwitchCase()) {
+    return getStatementListCompletion(path.get("consequent"), {
+      canHaveBreak: true,
+      shouldPopulateBreak: false,
+      inCaseClause: true,
+      shouldPreserveBreak: context.shouldPreserveBreak
+    });
+  } else if (path.isBreakStatement()) {
+    records.push(BreakCompletion(path));
+  } else {
+    records.push(NormalCompletion(path));
+  }
+  return records;
+}
+function getCompletionRecords(shouldPreserveBreak = false) {
+  const records = _getCompletionRecords(this, {
+    canHaveBreak: false,
+    shouldPopulateBreak: false,
+    inCaseClause: false,
+    shouldPreserveBreak
+  });
+  return records.map(r => r.path);
+}
+function getSibling(key) {
+  return _index.default.get({
+    parentPath: this.parentPath,
+    parent: this.parent,
+    container: this.container,
+    listKey: this.listKey,
+    key: key
+  }).setContext(this.context);
+}
+function getPrevSibling() {
+  return this.getSibling(this.key - 1);
+}
+function getNextSibling() {
+  return this.getSibling(this.key + 1);
+}
+function getAllNextSiblings() {
+  let _key = this.key;
+  let sibling = this.getSibling(++_key);
+  const siblings = [];
+  while (sibling.node) {
+    siblings.push(sibling);
+    sibling = this.getSibling(++_key);
+  }
+  return siblings;
+}
+function getAllPrevSiblings() {
+  let _key = this.key;
+  let sibling = this.getSibling(--_key);
+  const siblings = [];
+  while (sibling.node) {
+    siblings.push(sibling);
+    sibling = this.getSibling(--_key);
+  }
+  return siblings;
+}
+function get(key, context = true) {
+  if (context === true) context = this.context;
+  const parts = key.split(".");
+  if (parts.length === 1) {
+    return _getKey.call(this, key, context);
+  } else {
+    return _getPattern.call(this, parts, context);
+  }
+}
+function _getKey(key, context) {
+  const node = this.node;
+  const container = node[key];
+  if (Array.isArray(container)) {
+    return container.map((_, i) => {
+      return _index.default.get({
+        listKey: key,
+        parentPath: this,
+        parent: node,
+        container: container,
+        key: i
+      }).setContext(context);
+    });
+  } else {
+    return _index.default.get({
+      parentPath: this,
+      parent: node,
+      container: node,
+      key: key
+    }).setContext(context);
+  }
+}
+function _getPattern(parts, context) {
+  let path = this;
+  for (const part of parts) {
+    if (part === ".") {
+      path = path.parentPath;
+    } else {
+      if (Array.isArray(path)) {
+        path = path[part];
+      } else {
+        path = path.get(part, context);
+      }
+    }
+  }
+  return path;
+}
+function getAssignmentIdentifiers() {
+  return _getAssignmentIdentifiers(this.node);
+}
+function getBindingIdentifiers(duplicates) {
+  return _getBindingIdentifiers(this.node, duplicates);
+}
+function getOuterBindingIdentifiers(duplicates) {
+  return _getOuterBindingIdentifiers(this.node, duplicates);
+}
+function getBindingIdentifierPaths(duplicates = false, outerOnly = false) {
+  const path = this;
+  const search = [path];
+  const ids = Object.create(null);
+  while (search.length) {
+    const id = search.shift();
+    if (!id) continue;
+    if (!id.node) continue;
+    const keys = _getBindingIdentifiers.keys[id.node.type];
+    if (id.isIdentifier()) {
+      if (duplicates) {
+        const _ids = ids[id.node.name] = ids[id.node.name] || [];
+        _ids.push(id);
+      } else {
+        ids[id.node.name] = id;
+      }
+      continue;
+    }
+    if (id.isExportDeclaration()) {
+      const declaration = id.get("declaration");
+      if (declaration.isDeclaration()) {
+        search.push(declaration);
+      }
+      continue;
+    }
+    if (outerOnly) {
+      if (id.isFunctionDeclaration()) {
+        search.push(id.get("id"));
+        continue;
+      }
+      if (id.isFunctionExpression()) {
+        continue;
+      }
+    }
+    if (keys) {
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const child = id.get(key);
+        if (Array.isArray(child)) {
+          search.push(...child);
+        } else if (child.node) {
+          search.push(child);
+        }
+      }
+    }
+  }
+  return ids;
+}
+function getOuterBindingIdentifierPaths(duplicates = false) {
+  return this.getBindingIdentifierPaths(duplicates, true);
+}
+
+//# sourceMappingURL=family.js.map

node_modules/@babel/traverse/lib/path/index.js

@@ -0,0 +1,288 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.SHOULD_STOP = exports.SHOULD_SKIP = exports.REMOVED = void 0;
+var virtualTypes = require("./lib/virtual-types.js");
+var _debug = require("debug");
+var _index = require("../index.js");
+var _index2 = require("../scope/index.js");
+var _t = require("@babel/types");
+var t = _t;
+var cache = require("../cache.js");
+var _generator = require("@babel/generator");
+var NodePath_ancestry = require("./ancestry.js");
+var NodePath_inference = require("./inference/index.js");
+var NodePath_replacement = require("./replacement.js");
+var NodePath_evaluation = require("./evaluation.js");
+var NodePath_conversion = require("./conversion.js");
+var NodePath_introspection = require("./introspection.js");
+var _context = require("./context.js");
+var NodePath_context = _context;
+var NodePath_removal = require("./removal.js");
+var NodePath_modification = require("./modification.js");
+var NodePath_family = require("./family.js");
+var NodePath_comments = require("./comments.js");
+var NodePath_virtual_types_validator = require("./lib/virtual-types-validator.js");
+const {
+  validate
+} = _t;
+const debug = _debug("babel");
+const REMOVED = exports.REMOVED = 1 << 0;
+const SHOULD_STOP = exports.SHOULD_STOP = 1 << 1;
+const SHOULD_SKIP = exports.SHOULD_SKIP = 1 << 2;
+const NodePath_Final = exports.default = class NodePath {
+  constructor(hub, parent) {
+    this.contexts = [];
+    this.state = null;
+    this._traverseFlags = 0;
+    this.skipKeys = null;
+    this.parentPath = null;
+    this.container = null;
+    this.listKey = null;
+    this.key = null;
+    this.node = null;
+    this.type = null;
+    this._store = null;
+    this.parent = parent;
+    this.hub = hub;
+    this.data = null;
+    this.context = null;
+    this.scope = null;
+  }
+  get removed() {
+    return (this._traverseFlags & 1) > 0;
+  }
+  set removed(v) {
+    if (v) this._traverseFlags |= 1;else this._traverseFlags &= -2;
+  }
+  get shouldStop() {
+    return (this._traverseFlags & 2) > 0;
+  }
+  set shouldStop(v) {
+    if (v) this._traverseFlags |= 2;else this._traverseFlags &= -3;
+  }
+  get shouldSkip() {
+    return (this._traverseFlags & 4) > 0;
+  }
+  set shouldSkip(v) {
+    if (v) this._traverseFlags |= 4;else this._traverseFlags &= -5;
+  }
+  static get({
+    hub,
+    parentPath,
+    parent,
+    container,
+    listKey,
+    key
+  }) {
+    if (!hub && parentPath) {
+      hub = parentPath.hub;
+    }
+    if (!parent) {
+      throw new Error("To get a node path the parent needs to exist");
+    }
+    const targetNode = container[key];
+    const paths = cache.getOrCreateCachedPaths(parent, parentPath);
+    let path = paths.get(targetNode);
+    if (!path) {
+      path = new NodePath(hub, parent);
+      if (targetNode) paths.set(targetNode, path);
+    }
+    _context.setup.call(path, parentPath, container, listKey, key);
+    return path;
+  }
+  getScope(scope) {
+    return this.isScope() ? new _index2.default(this) : scope;
+  }
+  setData(key, val) {
+    if (this.data == null) {
+      this.data = Object.create(null);
+    }
+    return this.data[key] = val;
+  }
+  getData(key, def) {
+    if (this.data == null) {
+      this.data = Object.create(null);
+    }
+    let val = this.data[key];
+    if (val === undefined && def !== undefined) val = this.data[key] = def;
+    return val;
+  }
+  hasNode() {
+    return this.node != null;
+  }
+  buildCodeFrameError(msg, Error = SyntaxError) {
+    return this.hub.buildError(this.node, msg, Error);
+  }
+  traverse(visitor, state) {
+    (0, _index.default)(this.node, visitor, this.scope, state, this);
+  }
+  set(key, node) {
+    validate(this.node, key, node);
+    this.node[key] = node;
+  }
+  getPathLocation() {
+    const parts = [];
+    let path = this;
+    do {
+      let key = path.key;
+      if (path.inList) key = `${path.listKey}[${key}]`;
+      parts.unshift(key);
+    } while (path = path.parentPath);
+    return parts.join(".");
+  }
+  debug(message) {
+    if (!debug.enabled) return;
+    debug(`${this.getPathLocation()} ${this.type}: ${message}`);
+  }
+  toString() {
+    return (0, _generator.default)(this.node).code;
+  }
+  get inList() {
+    return !!this.listKey;
+  }
+  set inList(inList) {
+    if (!inList) {
+      this.listKey = null;
+    }
+  }
+  get parentKey() {
+    return this.listKey || this.key;
+  }
+};
+const methods = {
+  findParent: NodePath_ancestry.findParent,
+  find: NodePath_ancestry.find,
+  getFunctionParent: NodePath_ancestry.getFunctionParent,
+  getStatementParent: NodePath_ancestry.getStatementParent,
+  getEarliestCommonAncestorFrom: NodePath_ancestry.getEarliestCommonAncestorFrom,
+  getDeepestCommonAncestorFrom: NodePath_ancestry.getDeepestCommonAncestorFrom,
+  getAncestry: NodePath_ancestry.getAncestry,
+  isAncestor: NodePath_ancestry.isAncestor,
+  isDescendant: NodePath_ancestry.isDescendant,
+  inType: NodePath_ancestry.inType,
+  getTypeAnnotation: NodePath_inference.getTypeAnnotation,
+  isBaseType: NodePath_inference.isBaseType,
+  couldBeBaseType: NodePath_inference.couldBeBaseType,
+  baseTypeStrictlyMatches: NodePath_inference.baseTypeStrictlyMatches,
+  isGenericType: NodePath_inference.isGenericType,
+  replaceWithMultiple: NodePath_replacement.replaceWithMultiple,
+  replaceWithSourceString: NodePath_replacement.replaceWithSourceString,
+  replaceWith: NodePath_replacement.replaceWith,
+  replaceExpressionWithStatements: NodePath_replacement.replaceExpressionWithStatements,
+  replaceInline: NodePath_replacement.replaceInline,
+  evaluateTruthy: NodePath_evaluation.evaluateTruthy,
+  evaluate: NodePath_evaluation.evaluate,
+  toComputedKey: NodePath_conversion.toComputedKey,
+  ensureBlock: NodePath_conversion.ensureBlock,
+  unwrapFunctionEnvironment: NodePath_conversion.unwrapFunctionEnvironment,
+  arrowFunctionToExpression: NodePath_conversion.arrowFunctionToExpression,
+  splitExportDeclaration: NodePath_conversion.splitExportDeclaration,
+  ensureFunctionName: NodePath_conversion.ensureFunctionName,
+  matchesPattern: NodePath_introspection.matchesPattern,
+  isStatic: NodePath_introspection.isStatic,
+  isNodeType: NodePath_introspection.isNodeType,
+  canHaveVariableDeclarationOrExpression: NodePath_introspection.canHaveVariableDeclarationOrExpression,
+  canSwapBetweenExpressionAndStatement: NodePath_introspection.canSwapBetweenExpressionAndStatement,
+  isCompletionRecord: NodePath_introspection.isCompletionRecord,
+  isStatementOrBlock: NodePath_introspection.isStatementOrBlock,
+  referencesImport: NodePath_introspection.referencesImport,
+  getSource: NodePath_introspection.getSource,
+  willIMaybeExecuteBefore: NodePath_introspection.willIMaybeExecuteBefore,
+  _guessExecutionStatusRelativeTo: NodePath_introspection._guessExecutionStatusRelativeTo,
+  resolve: NodePath_introspection.resolve,
+  isConstantExpression: NodePath_introspection.isConstantExpression,
+  isInStrictMode: NodePath_introspection.isInStrictMode,
+  isDenylisted: NodePath_context.isDenylisted,
+  visit: NodePath_context.visit,
+  skip: NodePath_context.skip,
+  skipKey: NodePath_context.skipKey,
+  stop: NodePath_context.stop,
+  setContext: NodePath_context.setContext,
+  requeue: NodePath_context.requeue,
+  requeueComputedKeyAndDecorators: NodePath_context.requeueComputedKeyAndDecorators,
+  remove: NodePath_removal.remove,
+  insertBefore: NodePath_modification.insertBefore,
+  insertAfter: NodePath_modification.insertAfter,
+  unshiftContainer: NodePath_modification.unshiftContainer,
+  pushContainer: NodePath_modification.pushContainer,
+  getOpposite: NodePath_family.getOpposite,
+  getCompletionRecords: NodePath_family.getCompletionRecords,
+  getSibling: NodePath_family.getSibling,
+  getPrevSibling: NodePath_family.getPrevSibling,
+  getNextSibling: NodePath_family.getNextSibling,
+  getAllNextSiblings: NodePath_family.getAllNextSiblings,
+  getAllPrevSiblings: NodePath_family.getAllPrevSiblings,
+  get: NodePath_family.get,
+  getAssignmentIdentifiers: NodePath_family.getAssignmentIdentifiers,
+  getBindingIdentifiers: NodePath_family.getBindingIdentifiers,
+  getOuterBindingIdentifiers: NodePath_family.getOuterBindingIdentifiers,
+  getBindingIdentifierPaths: NodePath_family.getBindingIdentifierPaths,
+  getOuterBindingIdentifierPaths: NodePath_family.getOuterBindingIdentifierPaths,
+  shareCommentsWithSiblings: NodePath_comments.shareCommentsWithSiblings,
+  addComment: NodePath_comments.addComment,
+  addComments: NodePath_comments.addComments
+};
+Object.assign(NodePath_Final.prototype, methods);
+NodePath_Final.prototype.arrowFunctionToShadowed = NodePath_conversion[String("arrowFunctionToShadowed")];
+Object.assign(NodePath_Final.prototype, {
+  has: NodePath_introspection[String("has")],
+  is: NodePath_introspection[String("is")],
+  isnt: NodePath_introspection[String("isnt")],
+  equals: NodePath_introspection[String("equals")],
+  hoist: NodePath_modification[String("hoist")],
+  updateSiblingKeys: NodePath_modification.updateSiblingKeys,
+  call: NodePath_context.call,
+  isBlacklisted: NodePath_context[String("isBlacklisted")],
+  setScope: NodePath_context.setScope,
+  resync: NodePath_context.resync,
+  popContext: NodePath_context.popContext,
+  pushContext: NodePath_context.pushContext,
+  setup: NodePath_context.setup,
+  setKey: NodePath_context.setKey
+});
+NodePath_Final.prototype._guessExecutionStatusRelativeToDifferentFunctions = NodePath_introspection._guessExecutionStatusRelativeTo;
+NodePath_Final.prototype._guessExecutionStatusRelativeToDifferentFunctions = NodePath_introspection._guessExecutionStatusRelativeTo;
+Object.assign(NodePath_Final.prototype, {
+  _getTypeAnnotation: NodePath_inference._getTypeAnnotation,
+  _replaceWith: NodePath_replacement._replaceWith,
+  _resolve: NodePath_introspection._resolve,
+  _call: NodePath_context._call,
+  _resyncParent: NodePath_context._resyncParent,
+  _resyncKey: NodePath_context._resyncKey,
+  _resyncList: NodePath_context._resyncList,
+  _resyncRemoved: NodePath_context._resyncRemoved,
+  _getQueueContexts: NodePath_context._getQueueContexts,
+  _removeFromScope: NodePath_removal._removeFromScope,
+  _callRemovalHooks: NodePath_removal._callRemovalHooks,
+  _remove: NodePath_removal._remove,
+  _markRemoved: NodePath_removal._markRemoved,
+  _assertUnremoved: NodePath_removal._assertUnremoved,
+  _containerInsert: NodePath_modification._containerInsert,
+  _containerInsertBefore: NodePath_modification._containerInsertBefore,
+  _containerInsertAfter: NodePath_modification._containerInsertAfter,
+  _verifyNodeList: NodePath_modification._verifyNodeList,
+  _getKey: NodePath_family._getKey,
+  _getPattern: NodePath_family._getPattern
+});
+for (const type of t.TYPES) {
+  const typeKey = `is${type}`;
+  const fn = t[typeKey];
+  NodePath_Final.prototype[typeKey] = function (opts) {
+    return fn(this.node, opts);
+  };
+  NodePath_Final.prototype[`assert${type}`] = function (opts) {
+    if (!fn(this.node, opts)) {
+      throw new TypeError(`Expected node path of type ${type}`);
+    }
+  };
+}
+Object.assign(NodePath_Final.prototype, NodePath_virtual_types_validator);
+for (const type of Object.keys(virtualTypes)) {
+  if (type.startsWith("_")) continue;
+  if (!t.TYPES.includes(type)) t.TYPES.push(type);
+}
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/traverse/lib/path/inference/index.js

@@ -0,0 +1,149 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._getTypeAnnotation = _getTypeAnnotation;
+exports.baseTypeStrictlyMatches = baseTypeStrictlyMatches;
+exports.couldBeBaseType = couldBeBaseType;
+exports.getTypeAnnotation = getTypeAnnotation;
+exports.isBaseType = isBaseType;
+exports.isGenericType = isGenericType;
+var inferers = require("./inferers.js");
+var _t = require("@babel/types");
+const {
+  anyTypeAnnotation,
+  isAnyTypeAnnotation,
+  isArrayTypeAnnotation,
+  isBooleanTypeAnnotation,
+  isEmptyTypeAnnotation,
+  isFlowBaseAnnotation,
+  isGenericTypeAnnotation,
+  isIdentifier,
+  isMixedTypeAnnotation,
+  isNumberTypeAnnotation,
+  isStringTypeAnnotation,
+  isTSArrayType,
+  isTSTypeAnnotation,
+  isTSTypeReference,
+  isTupleTypeAnnotation,
+  isTypeAnnotation,
+  isUnionTypeAnnotation,
+  isVoidTypeAnnotation,
+  stringTypeAnnotation,
+  voidTypeAnnotation
+} = _t;
+function getTypeAnnotation() {
+  let type = this.getData("typeAnnotation");
+  if (type != null) {
+    return type;
+  }
+  type = _getTypeAnnotation.call(this) || anyTypeAnnotation();
+  if (isTypeAnnotation(type) || isTSTypeAnnotation(type)) {
+    type = type.typeAnnotation;
+  }
+  this.setData("typeAnnotation", type);
+  return type;
+}
+const typeAnnotationInferringNodes = new WeakSet();
+function _getTypeAnnotation() {
+  const node = this.node;
+  if (!node) {
+    if (this.key === "init" && this.parentPath.isVariableDeclarator()) {
+      const declar = this.parentPath.parentPath;
+      const declarParent = declar.parentPath;
+      if (declar.key === "left" && declarParent.isForInStatement()) {
+        return stringTypeAnnotation();
+      }
+      if (declar.key === "left" && declarParent.isForOfStatement()) {
+        return anyTypeAnnotation();
+      }
+      return voidTypeAnnotation();
+    } else {
+      return;
+    }
+  }
+  if (node.typeAnnotation) {
+    return node.typeAnnotation;
+  }
+  if (typeAnnotationInferringNodes.has(node)) {
+    return;
+  }
+  typeAnnotationInferringNodes.add(node);
+  try {
+    var _inferer;
+    let inferer = inferers[node.type];
+    if (inferer) {
+      return inferer.call(this, node);
+    }
+    inferer = inferers[this.parentPath.type];
+    if ((_inferer = inferer) != null && _inferer.validParent) {
+      return this.parentPath.getTypeAnnotation();
+    }
+  } finally {
+    typeAnnotationInferringNodes.delete(node);
+  }
+}
+function isBaseType(baseName, soft) {
+  return _isBaseType(baseName, this.getTypeAnnotation(), soft);
+}
+function _isBaseType(baseName, type, soft) {
+  if (baseName === "string") {
+    return isStringTypeAnnotation(type);
+  } else if (baseName === "number") {
+    return isNumberTypeAnnotation(type);
+  } else if (baseName === "boolean") {
+    return isBooleanTypeAnnotation(type);
+  } else if (baseName === "any") {
+    return isAnyTypeAnnotation(type);
+  } else if (baseName === "mixed") {
+    return isMixedTypeAnnotation(type);
+  } else if (baseName === "empty") {
+    return isEmptyTypeAnnotation(type);
+  } else if (baseName === "void") {
+    return isVoidTypeAnnotation(type);
+  } else {
+    if (soft) {
+      return false;
+    } else {
+      throw new Error(`Unknown base type ${baseName}`);
+    }
+  }
+}
+function couldBeBaseType(name) {
+  const type = this.getTypeAnnotation();
+  if (isAnyTypeAnnotation(type)) return true;
+  if (isUnionTypeAnnotation(type)) {
+    for (const type2 of type.types) {
+      if (isAnyTypeAnnotation(type2) || _isBaseType(name, type2, true)) {
+        return true;
+      }
+    }
+    return false;
+  } else {
+    return _isBaseType(name, type, true);
+  }
+}
+function baseTypeStrictlyMatches(rightArg) {
+  const left = this.getTypeAnnotation();
+  const right = rightArg.getTypeAnnotation();
+  if (!isAnyTypeAnnotation(left) && isFlowBaseAnnotation(left)) {
+    return right.type === left.type;
+  }
+  return false;
+}
+function isGenericType(genericName) {
+  const type = this.getTypeAnnotation();
+  if (genericName === "Array") {
+    if (isTSArrayType(type) || isArrayTypeAnnotation(type) || isTupleTypeAnnotation(type)) {
+      return true;
+    }
+  }
+  return isGenericTypeAnnotation(type) && isIdentifier(type.id, {
+    name: genericName
+  }) || isTSTypeReference(type) && isIdentifier(type.typeName, {
+    name: genericName
+  });
+}
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/traverse/lib/path/inference/inferer-reference.js

@@ -0,0 +1,151 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _t = require("@babel/types");
+var _util = require("./util.js");
+const {
+  BOOLEAN_NUMBER_BINARY_OPERATORS,
+  createTypeAnnotationBasedOnTypeof,
+  numberTypeAnnotation,
+  voidTypeAnnotation
+} = _t;
+function _default(node) {
+  if (!this.isReferenced()) return;
+  const binding = this.scope.getBinding(node.name);
+  if (binding) {
+    if (binding.identifier.typeAnnotation) {
+      return binding.identifier.typeAnnotation;
+    } else {
+      return getTypeAnnotationBindingConstantViolations(binding, this, node.name);
+    }
+  }
+  if (node.name === "undefined") {
+    return voidTypeAnnotation();
+  } else if (node.name === "NaN" || node.name === "Infinity") {
+    return numberTypeAnnotation();
+  } else if (node.name === "arguments") {}
+}
+function getTypeAnnotationBindingConstantViolations(binding, path, name) {
+  const types = [];
+  const functionConstantViolations = [];
+  let constantViolations = getConstantViolationsBefore(binding, path, functionConstantViolations);
+  const testType = getConditionalAnnotation(binding, path, name);
+  if (testType) {
+    const testConstantViolations = getConstantViolationsBefore(binding, testType.ifStatement);
+    constantViolations = constantViolations.filter(path => !testConstantViolations.includes(path));
+    types.push(testType.typeAnnotation);
+  }
+  if (constantViolations.length) {
+    constantViolations.push(...functionConstantViolations);
+    for (const violation of constantViolations) {
+      types.push(violation.getTypeAnnotation());
+    }
+  }
+  if (!types.length) {
+    return;
+  }
+  return (0, _util.createUnionType)(types);
+}
+function getConstantViolationsBefore(binding, path, functions) {
+  const violations = binding.constantViolations.slice();
+  violations.unshift(binding.path);
+  return violations.filter(violation => {
+    violation = violation.resolve();
+    const status = violation._guessExecutionStatusRelativeTo(path);
+    if (functions && status === "unknown") functions.push(violation);
+    return status === "before";
+  });
+}
+function inferAnnotationFromBinaryExpression(name, path) {
+  const operator = path.node.operator;
+  const right = path.get("right").resolve();
+  const left = path.get("left").resolve();
+  let target;
+  if (left.isIdentifier({
+    name
+  })) {
+    target = right;
+  } else if (right.isIdentifier({
+    name
+  })) {
+    target = left;
+  }
+  if (target) {
+    if (operator === "===") {
+      return target.getTypeAnnotation();
+    }
+    if (BOOLEAN_NUMBER_BINARY_OPERATORS.includes(operator)) {
+      return numberTypeAnnotation();
+    }
+    return;
+  }
+  if (operator !== "===" && operator !== "==") return;
+  let typeofPath;
+  let typePath;
+  if (left.isUnaryExpression({
+    operator: "typeof"
+  })) {
+    typeofPath = left;
+    typePath = right;
+  } else if (right.isUnaryExpression({
+    operator: "typeof"
+  })) {
+    typeofPath = right;
+    typePath = left;
+  }
+  if (!typeofPath) return;
+  if (!typeofPath.get("argument").isIdentifier({
+    name
+  })) return;
+  typePath = typePath.resolve();
+  if (!typePath.isLiteral()) return;
+  const typeValue = typePath.node.value;
+  if (typeof typeValue !== "string") return;
+  return createTypeAnnotationBasedOnTypeof(typeValue);
+}
+function getParentConditionalPath(binding, path, name) {
+  let parentPath;
+  while (parentPath = path.parentPath) {
+    if (parentPath.isIfStatement() || parentPath.isConditionalExpression()) {
+      if (path.key === "test") {
+        return;
+      }
+      return parentPath;
+    }
+    if (parentPath.isFunction()) {
+      if (name == null || parentPath.parentPath.scope.getBinding(name) !== binding) return;
+    }
+    path = parentPath;
+  }
+}
+function getConditionalAnnotation(binding, path, name) {
+  const ifStatement = getParentConditionalPath(binding, path, name);
+  if (!ifStatement) return;
+  const test = ifStatement.get("test");
+  const paths = [test];
+  const types = [];
+  for (let i = 0; i < paths.length; i++) {
+    const path = paths[i];
+    if (path.isLogicalExpression()) {
+      if (path.node.operator === "&&") {
+        paths.push(path.get("left"));
+        paths.push(path.get("right"));
+      }
+    } else if (path.isBinaryExpression()) {
+      const type = inferAnnotationFromBinaryExpression(name, path);
+      if (type) types.push(type);
+    }
+  }
+  if (types.length) {
+    return {
+      typeAnnotation: (0, _util.createUnionType)(types),
+      ifStatement
+    };
+  }
+  return getConditionalAnnotation(binding, ifStatement, name);
+}
+
+//# sourceMappingURL=inferer-reference.js.map

node_modules/@babel/traverse/lib/path/inference/inferers.js

@@ -0,0 +1,207 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ArrayExpression = ArrayExpression;
+exports.AssignmentExpression = AssignmentExpression;
+exports.BinaryExpression = BinaryExpression;
+exports.BooleanLiteral = BooleanLiteral;
+exports.CallExpression = CallExpression;
+exports.ConditionalExpression = ConditionalExpression;
+exports.ClassDeclaration = exports.ClassExpression = exports.FunctionDeclaration = exports.ArrowFunctionExpression = exports.FunctionExpression = Func;
+Object.defineProperty(exports, "Identifier", {
+  enumerable: true,
+  get: function () {
+    return _infererReference.default;
+  }
+});
+exports.LogicalExpression = LogicalExpression;
+exports.NewExpression = NewExpression;
+exports.NullLiteral = NullLiteral;
+exports.NumericLiteral = NumericLiteral;
+exports.ObjectExpression = ObjectExpression;
+exports.ParenthesizedExpression = ParenthesizedExpression;
+exports.RegExpLiteral = RegExpLiteral;
+exports.RestElement = RestElement;
+exports.SequenceExpression = SequenceExpression;
+exports.StringLiteral = StringLiteral;
+exports.TSAsExpression = TSAsExpression;
+exports.TSNonNullExpression = TSNonNullExpression;
+exports.TaggedTemplateExpression = TaggedTemplateExpression;
+exports.TemplateLiteral = TemplateLiteral;
+exports.TypeCastExpression = TypeCastExpression;
+exports.UnaryExpression = UnaryExpression;
+exports.UpdateExpression = UpdateExpression;
+exports.VariableDeclarator = VariableDeclarator;
+var _t = require("@babel/types");
+var _infererReference = require("./inferer-reference.js");
+var _util = require("./util.js");
+const {
+  BOOLEAN_BINARY_OPERATORS,
+  BOOLEAN_UNARY_OPERATORS,
+  NUMBER_BINARY_OPERATORS,
+  NUMBER_UNARY_OPERATORS,
+  STRING_UNARY_OPERATORS,
+  anyTypeAnnotation,
+  arrayTypeAnnotation,
+  booleanTypeAnnotation,
+  buildMatchMemberExpression,
+  genericTypeAnnotation,
+  identifier,
+  nullLiteralTypeAnnotation,
+  numberTypeAnnotation,
+  stringTypeAnnotation,
+  tupleTypeAnnotation,
+  unionTypeAnnotation,
+  voidTypeAnnotation,
+  isIdentifier
+} = _t;
+function VariableDeclarator() {
+  if (!this.get("id").isIdentifier()) return;
+  return this.get("init").getTypeAnnotation();
+}
+function TypeCastExpression(node) {
+  return node.typeAnnotation;
+}
+TypeCastExpression.validParent = true;
+function TSAsExpression(node) {
+  return node.typeAnnotation;
+}
+TSAsExpression.validParent = true;
+function TSNonNullExpression() {
+  return this.get("expression").getTypeAnnotation();
+}
+function NewExpression(node) {
+  if (node.callee.type === "Identifier") {
+    return genericTypeAnnotation(node.callee);
+  }
+}
+function TemplateLiteral() {
+  return stringTypeAnnotation();
+}
+function UnaryExpression(node) {
+  const operator = node.operator;
+  if (operator === "void") {
+    return voidTypeAnnotation();
+  } else if (NUMBER_UNARY_OPERATORS.includes(operator)) {
+    return numberTypeAnnotation();
+  } else if (STRING_UNARY_OPERATORS.includes(operator)) {
+    return stringTypeAnnotation();
+  } else if (BOOLEAN_UNARY_OPERATORS.includes(operator)) {
+    return booleanTypeAnnotation();
+  }
+}
+function BinaryExpression(node) {
+  const operator = node.operator;
+  if (NUMBER_BINARY_OPERATORS.includes(operator)) {
+    return numberTypeAnnotation();
+  } else if (BOOLEAN_BINARY_OPERATORS.includes(operator)) {
+    return booleanTypeAnnotation();
+  } else if (operator === "+") {
+    const right = this.get("right");
+    const left = this.get("left");
+    if (left.isBaseType("number") && right.isBaseType("number")) {
+      return numberTypeAnnotation();
+    } else if (left.isBaseType("string") || right.isBaseType("string")) {
+      return stringTypeAnnotation();
+    }
+    return unionTypeAnnotation([stringTypeAnnotation(), numberTypeAnnotation()]);
+  }
+}
+function LogicalExpression() {
+  const argumentTypes = [this.get("left").getTypeAnnotation(), this.get("right").getTypeAnnotation()];
+  return (0, _util.createUnionType)(argumentTypes);
+}
+function ConditionalExpression() {
+  const argumentTypes = [this.get("consequent").getTypeAnnotation(), this.get("alternate").getTypeAnnotation()];
+  return (0, _util.createUnionType)(argumentTypes);
+}
+function SequenceExpression() {
+  return this.get("expressions").pop().getTypeAnnotation();
+}
+function ParenthesizedExpression() {
+  return this.get("expression").getTypeAnnotation();
+}
+function AssignmentExpression() {
+  return this.get("right").getTypeAnnotation();
+}
+function UpdateExpression(node) {
+  const operator = node.operator;
+  if (operator === "++" || operator === "--") {
+    return numberTypeAnnotation();
+  }
+}
+function StringLiteral() {
+  return stringTypeAnnotation();
+}
+function NumericLiteral() {
+  return numberTypeAnnotation();
+}
+function BooleanLiteral() {
+  return booleanTypeAnnotation();
+}
+function NullLiteral() {
+  return nullLiteralTypeAnnotation();
+}
+function RegExpLiteral() {
+  return genericTypeAnnotation(identifier("RegExp"));
+}
+function ObjectExpression() {
+  return genericTypeAnnotation(identifier("Object"));
+}
+function ArrayExpression() {
+  return genericTypeAnnotation(identifier("Array"));
+}
+function RestElement() {
+  return ArrayExpression();
+}
+RestElement.validParent = true;
+function Func() {
+  return genericTypeAnnotation(identifier("Function"));
+}
+const isArrayFrom = buildMatchMemberExpression("Array.from");
+const isObjectKeys = buildMatchMemberExpression("Object.keys");
+const isObjectValues = buildMatchMemberExpression("Object.values");
+const isObjectEntries = buildMatchMemberExpression("Object.entries");
+function CallExpression() {
+  const {
+    callee
+  } = this.node;
+  if (isObjectKeys(callee)) {
+    return arrayTypeAnnotation(stringTypeAnnotation());
+  } else if (isArrayFrom(callee) || isObjectValues(callee) || isIdentifier(callee, {
+    name: "Array"
+  })) {
+    return arrayTypeAnnotation(anyTypeAnnotation());
+  } else if (isObjectEntries(callee)) {
+    return arrayTypeAnnotation(tupleTypeAnnotation([stringTypeAnnotation(), anyTypeAnnotation()]));
+  }
+  return resolveCall(this.get("callee"));
+}
+function TaggedTemplateExpression() {
+  return resolveCall(this.get("tag"));
+}
+function resolveCall(callee) {
+  callee = callee.resolve();
+  if (callee.isFunction()) {
+    const {
+      node
+    } = callee;
+    if (node.async) {
+      if (node.generator) {
+        return genericTypeAnnotation(identifier("AsyncIterator"));
+      } else {
+        return genericTypeAnnotation(identifier("Promise"));
+      }
+    } else {
+      if (node.generator) {
+        return genericTypeAnnotation(identifier("Iterator"));
+      } else if (callee.node.returnType) {
+        return callee.node.returnType;
+      } else {}
+    }
+  }
+}
+
+//# sourceMappingURL=inferers.js.map

node_modules/@babel/traverse/lib/path/inference/util.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createUnionType = createUnionType;
+var _t = require("@babel/types");
+const {
+  createFlowUnionType,
+  createTSUnionType,
+  createUnionTypeAnnotation,
+  isFlowType,
+  isTSType
+} = _t;
+function createUnionType(types) {
+  if (types.every(v => isFlowType(v))) {
+    if (createFlowUnionType) {
+      return createFlowUnionType(types);
+    }
+    return createUnionTypeAnnotation(types);
+  } else if (types.every(v => isTSType(v))) {
+    if (createTSUnionType) {
+      return createTSUnionType(types);
+    }
+  }
+}
+
+//# sourceMappingURL=util.js.map

node_modules/@babel/traverse/lib/path/inference/util.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_t","require","createFlowUnionType","createTSUnionType","createUnionTypeAnnotation","isFlowType","isTSType","createUnionType","types","every","v"],"sources":["../../../src/path/inference/util.ts"],"sourcesContent":["import {\n  createFlowUnionType,\n  createTSUnionType,\n  createUnionTypeAnnotation,\n  isFlowType,\n  isTSType,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\n\nexport function createUnionType(\n  types: (t.FlowType | t.TSType)[],\n): t.FlowType | t.TSType | undefined {\n  if (process.env.BABEL_8_BREAKING) {\n    if (types.every(v => isFlowType(v))) {\n      return createFlowUnionType(types);\n    }\n    if (types.every(v => isTSType(v))) {\n      return createTSUnionType(types);\n    }\n  } else {\n    if (types.every(v => isFlowType(v))) {\n      if (createFlowUnionType) {\n        return createFlowUnionType(types);\n      }\n\n      return createUnionTypeAnnotation(types);\n    } else if (types.every(v => isTSType(v))) {\n      if (createTSUnionType) {\n        return createTSUnionType(types);\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,EAAA,GAAAC,OAAA;AAMsB;EALpBC,mBAAmB;EACnBC,iBAAiB;EACjBC,yBAAyB;EACzBC,UAAU;EACVC;AAAQ,IAAAN,EAAA;AAIH,SAASO,eAAeA,CAC7BC,KAAgC,EACG;EASjC,IAAIA,KAAK,CAACC,KAAK,CAACC,CAAC,IAAIL,UAAU,CAACK,CAAC,CAAC,CAAC,EAAE;IACnC,IAAIR,mBAAmB,EAAE;MACvB,OAAOA,mBAAmB,CAACM,KAAK,CAAC;IACnC;IAEA,OAAOJ,yBAAyB,CAACI,KAAK,CAAC;EACzC,CAAC,MAAM,IAAIA,KAAK,CAACC,KAAK,CAACC,CAAC,IAAIJ,QAAQ,CAACI,CAAC,CAAC,CAAC,EAAE;IACxC,IAAIP,iBAAiB,EAAE;MACrB,OAAOA,iBAAiB,CAACK,KAAK,CAAC;IACjC;EACF;AAEJ","ignoreList":[]}

node_modules/@babel/traverse/lib/path/introspection.js

@@ -0,0 +1,395 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._guessExecutionStatusRelativeTo = _guessExecutionStatusRelativeTo;
+exports._resolve = _resolve;
+exports.canHaveVariableDeclarationOrExpression = canHaveVariableDeclarationOrExpression;
+exports.canSwapBetweenExpressionAndStatement = canSwapBetweenExpressionAndStatement;
+exports.getSource = getSource;
+exports.isCompletionRecord = isCompletionRecord;
+exports.isConstantExpression = isConstantExpression;
+exports.isInStrictMode = isInStrictMode;
+exports.isNodeType = isNodeType;
+exports.isStatementOrBlock = isStatementOrBlock;
+exports.isStatic = isStatic;
+exports.matchesPattern = matchesPattern;
+exports.referencesImport = referencesImport;
+exports.resolve = resolve;
+exports.willIMaybeExecuteBefore = willIMaybeExecuteBefore;
+var _t = require("@babel/types");
+const {
+  STATEMENT_OR_BLOCK_KEYS,
+  VISITOR_KEYS,
+  isBlockStatement,
+  isExpression,
+  isIdentifier,
+  isLiteral,
+  isStringLiteral,
+  isType,
+  matchesPattern: _matchesPattern
+} = _t;
+function matchesPattern(pattern, allowPartial) {
+  return _matchesPattern(this.node, pattern, allowPartial);
+}
+exports.has = function has(key) {
+  var _this$node;
+  const val = (_this$node = this.node) == null ? void 0 : _this$node[key];
+  if (val && Array.isArray(val)) {
+    return !!val.length;
+  } else {
+    return !!val;
+  }
+};
+function isStatic() {
+  return this.scope.isStatic(this.node);
+}
+exports.is = exports.has;
+exports.isnt = function isnt(key) {
+  return !this.has(key);
+};
+exports.equals = function equals(key, value) {
+  return this.node[key] === value;
+};
+function isNodeType(type) {
+  return isType(this.type, type);
+}
+function canHaveVariableDeclarationOrExpression() {
+  return (this.key === "init" || this.key === "left") && this.parentPath.isFor();
+}
+function canSwapBetweenExpressionAndStatement(replacement) {
+  if (this.key !== "body" || !this.parentPath.isArrowFunctionExpression()) {
+    return false;
+  }
+  if (this.isExpression()) {
+    return isBlockStatement(replacement);
+  } else if (this.isBlockStatement()) {
+    return isExpression(replacement);
+  }
+  return false;
+}
+function isCompletionRecord(allowInsideFunction) {
+  let path = this;
+  let first = true;
+  do {
+    const {
+      type,
+      container
+    } = path;
+    if (!first && (path.isFunction() || type === "StaticBlock")) {
+      return !!allowInsideFunction;
+    }
+    first = false;
+    if (Array.isArray(container) && path.key !== container.length - 1) {
+      return false;
+    }
+  } while ((path = path.parentPath) && !path.isProgram() && !path.isDoExpression());
+  return true;
+}
+function isStatementOrBlock() {
+  if (this.parentPath.isLabeledStatement() || isBlockStatement(this.container)) {
+    return false;
+  } else {
+    return STATEMENT_OR_BLOCK_KEYS.includes(this.key);
+  }
+}
+function referencesImport(moduleSource, importName) {
+  if (!this.isReferencedIdentifier()) {
+    if (this.isJSXMemberExpression() && this.node.property.name === importName || (this.isMemberExpression() || this.isOptionalMemberExpression()) && (this.node.computed ? isStringLiteral(this.node.property, {
+      value: importName
+    }) : this.node.property.name === importName)) {
+      const object = this.get("object");
+      return object.isReferencedIdentifier() && object.referencesImport(moduleSource, "*");
+    }
+    return false;
+  }
+  const binding = this.scope.getBinding(this.node.name);
+  if ((binding == null ? void 0 : binding.kind) !== "module") return false;
+  const path = binding.path;
+  const parent = path.parentPath;
+  if (!parent.isImportDeclaration()) return false;
+  if (parent.node.source.value === moduleSource) {
+    if (!importName) return true;
+  } else {
+    return false;
+  }
+  if (path.isImportDefaultSpecifier() && importName === "default") {
+    return true;
+  }
+  if (path.isImportNamespaceSpecifier() && importName === "*") {
+    return true;
+  }
+  if (path.isImportSpecifier() && isIdentifier(path.node.imported, {
+    name: importName
+  })) {
+    return true;
+  }
+  return false;
+}
+function getSource() {
+  const node = this.node;
+  if (node.end) {
+    const code = this.hub.getCode();
+    if (code) return code.slice(node.start, node.end);
+  }
+  return "";
+}
+function willIMaybeExecuteBefore(target) {
+  return this._guessExecutionStatusRelativeTo(target) !== "after";
+}
+function getOuterFunction(path) {
+  return path.isProgram() ? path : (path.parentPath.scope.getFunctionParent() || path.parentPath.scope.getProgramParent()).path;
+}
+function isExecutionUncertain(type, key) {
+  switch (type) {
+    case "LogicalExpression":
+      return key === "right";
+    case "ConditionalExpression":
+    case "IfStatement":
+      return key === "consequent" || key === "alternate";
+    case "WhileStatement":
+    case "DoWhileStatement":
+    case "ForInStatement":
+    case "ForOfStatement":
+      return key === "body";
+    case "ForStatement":
+      return key === "body" || key === "update";
+    case "SwitchStatement":
+      return key === "cases";
+    case "TryStatement":
+      return key === "handler";
+    case "AssignmentPattern":
+      return key === "right";
+    case "OptionalMemberExpression":
+      return key === "property";
+    case "OptionalCallExpression":
+      return key === "arguments";
+    default:
+      return false;
+  }
+}
+function isExecutionUncertainInList(paths, maxIndex) {
+  for (let i = 0; i < maxIndex; i++) {
+    const path = paths[i];
+    if (isExecutionUncertain(path.parent.type, path.parentKey)) {
+      return true;
+    }
+  }
+  return false;
+}
+const SYMBOL_CHECKING = Symbol();
+function _guessExecutionStatusRelativeTo(target) {
+  return _guessExecutionStatusRelativeToCached(this, target, new Map());
+}
+function _guessExecutionStatusRelativeToCached(base, target, cache) {
+  const funcParent = {
+    this: getOuterFunction(base),
+    target: getOuterFunction(target)
+  };
+  if (funcParent.target.node !== funcParent.this.node) {
+    return _guessExecutionStatusRelativeToDifferentFunctionsCached(base, funcParent.target, cache);
+  }
+  const paths = {
+    target: target.getAncestry(),
+    this: base.getAncestry()
+  };
+  if (paths.target.includes(base)) return "after";
+  if (paths.this.includes(target)) return "before";
+  let commonPath;
+  const commonIndex = {
+    target: 0,
+    this: 0
+  };
+  while (!commonPath && commonIndex.this < paths.this.length) {
+    const path = paths.this[commonIndex.this];
+    commonIndex.target = paths.target.indexOf(path);
+    if (commonIndex.target >= 0) {
+      commonPath = path;
+    } else {
+      commonIndex.this++;
+    }
+  }
+  if (!commonPath) {
+    throw new Error("Internal Babel error - The two compared nodes" + " don't appear to belong to the same program.");
+  }
+  if (isExecutionUncertainInList(paths.this, commonIndex.this - 1) || isExecutionUncertainInList(paths.target, commonIndex.target - 1)) {
+    return "unknown";
+  }
+  const divergence = {
+    this: paths.this[commonIndex.this - 1],
+    target: paths.target[commonIndex.target - 1]
+  };
+  if (divergence.target.listKey && divergence.this.listKey && divergence.target.container === divergence.this.container) {
+    return divergence.target.key > divergence.this.key ? "before" : "after";
+  }
+  const keys = VISITOR_KEYS[commonPath.type];
+  const keyPosition = {
+    this: keys.indexOf(divergence.this.parentKey),
+    target: keys.indexOf(divergence.target.parentKey)
+  };
+  return keyPosition.target > keyPosition.this ? "before" : "after";
+}
+function _guessExecutionStatusRelativeToDifferentFunctionsInternal(base, target, cache) {
+  if (!target.isFunctionDeclaration()) {
+    if (_guessExecutionStatusRelativeToCached(base, target, cache) === "before") {
+      return "before";
+    }
+    return "unknown";
+  } else if (target.parentPath.isExportDeclaration()) {
+    return "unknown";
+  }
+  const binding = target.scope.getBinding(target.node.id.name);
+  if (!binding.references) return "before";
+  const referencePaths = binding.referencePaths;
+  let allStatus;
+  for (const path of referencePaths) {
+    const childOfFunction = !!path.find(path => path.node === target.node);
+    if (childOfFunction) continue;
+    if (path.key !== "callee" || !path.parentPath.isCallExpression()) {
+      return "unknown";
+    }
+    const status = _guessExecutionStatusRelativeToCached(base, path, cache);
+    if (allStatus && allStatus !== status) {
+      return "unknown";
+    } else {
+      allStatus = status;
+    }
+  }
+  return allStatus;
+}
+function _guessExecutionStatusRelativeToDifferentFunctionsCached(base, target, cache) {
+  let nodeMap = cache.get(base.node);
+  let cached;
+  if (!nodeMap) {
+    cache.set(base.node, nodeMap = new Map());
+  } else if (cached = nodeMap.get(target.node)) {
+    if (cached === SYMBOL_CHECKING) {
+      return "unknown";
+    }
+    return cached;
+  }
+  nodeMap.set(target.node, SYMBOL_CHECKING);
+  const result = _guessExecutionStatusRelativeToDifferentFunctionsInternal(base, target, cache);
+  nodeMap.set(target.node, result);
+  return result;
+}
+function resolve(dangerous, resolved) {
+  return _resolve.call(this, dangerous, resolved) || this;
+}
+function _resolve(dangerous, resolved) {
+  var _resolved;
+  if ((_resolved = resolved) != null && _resolved.includes(this)) return;
+  resolved = resolved || [];
+  resolved.push(this);
+  if (this.isVariableDeclarator()) {
+    if (this.get("id").isIdentifier()) {
+      return this.get("init").resolve(dangerous, resolved);
+    } else {}
+  } else if (this.isReferencedIdentifier()) {
+    const binding = this.scope.getBinding(this.node.name);
+    if (!binding) return;
+    if (!binding.constant) return;
+    if (binding.kind === "module") return;
+    if (binding.path !== this) {
+      const ret = binding.path.resolve(dangerous, resolved);
+      if (this.find(parent => parent.node === ret.node)) return;
+      return ret;
+    }
+  } else if (this.isTypeCastExpression()) {
+    return this.get("expression").resolve(dangerous, resolved);
+  } else if (dangerous && this.isMemberExpression()) {
+    const targetKey = this.toComputedKey();
+    if (!isLiteral(targetKey)) return;
+    const targetName = targetKey.value;
+    const target = this.get("object").resolve(dangerous, resolved);
+    if (target.isObjectExpression()) {
+      const props = target.get("properties");
+      for (const prop of props) {
+        if (!prop.isProperty()) continue;
+        const key = prop.get("key");
+        let match = prop.isnt("computed") && key.isIdentifier({
+          name: targetName
+        });
+        match = match || key.isLiteral({
+          value: targetName
+        });
+        if (match) return prop.get("value").resolve(dangerous, resolved);
+      }
+    } else if (target.isArrayExpression() && !isNaN(+targetName)) {
+      const elems = target.get("elements");
+      const elem = elems[targetName];
+      if (elem) return elem.resolve(dangerous, resolved);
+    }
+  }
+}
+function isConstantExpression() {
+  if (this.isIdentifier()) {
+    const binding = this.scope.getBinding(this.node.name);
+    if (!binding) return false;
+    return binding.constant;
+  }
+  if (this.isLiteral()) {
+    if (this.isRegExpLiteral()) {
+      return false;
+    }
+    if (this.isTemplateLiteral()) {
+      return this.get("expressions").every(expression => expression.isConstantExpression());
+    }
+    return true;
+  }
+  if (this.isUnaryExpression()) {
+    if (this.node.operator !== "void") {
+      return false;
+    }
+    return this.get("argument").isConstantExpression();
+  }
+  if (this.isBinaryExpression()) {
+    const {
+      operator
+    } = this.node;
+    return operator !== "in" && operator !== "instanceof" && this.get("left").isConstantExpression() && this.get("right").isConstantExpression();
+  }
+  if (this.isMemberExpression()) {
+    return !this.node.computed && this.get("object").isIdentifier({
+      name: "Symbol"
+    }) && !this.scope.hasBinding("Symbol", {
+      noGlobals: true
+    });
+  }
+  if (this.isCallExpression()) {
+    return this.node.arguments.length === 1 && this.get("callee").matchesPattern("Symbol.for") && !this.scope.hasBinding("Symbol", {
+      noGlobals: true
+    }) && this.get("arguments")[0].isStringLiteral();
+  }
+  return false;
+}
+function isInStrictMode() {
+  const start = this.isProgram() ? this : this.parentPath;
+  const strictParent = start.find(path => {
+    if (path.isProgram({
+      sourceType: "module"
+    })) return true;
+    if (path.isClass()) return true;
+    if (path.isArrowFunctionExpression() && !path.get("body").isBlockStatement()) {
+      return false;
+    }
+    let body;
+    if (path.isFunction()) {
+      body = path.node.body;
+    } else if (path.isProgram()) {
+      body = path.node;
+    } else {
+      return false;
+    }
+    for (const directive of body.directives) {
+      if (directive.value.value === "use strict") {
+        return true;
+      }
+    }
+    return false;
+  });
+  return !!strictParent;
+}
+
+//# sourceMappingURL=introspection.js.map

node_modules/@babel/traverse/lib/path/lib/hoister.js

@@ -0,0 +1,172 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _t = require("@babel/types");
+var _t2 = _t;
+const {
+  react
+} = _t;
+const {
+  cloneNode,
+  jsxExpressionContainer,
+  variableDeclaration,
+  variableDeclarator
+} = _t2;
+const referenceVisitor = {
+  ReferencedIdentifier(path, state) {
+    if (path.isJSXIdentifier() && react.isCompatTag(path.node.name) && !path.parentPath.isJSXMemberExpression()) {
+      return;
+    }
+    if (path.node.name === "this") {
+      let scope = path.scope;
+      do {
+        if (scope.path.isFunction() && !scope.path.isArrowFunctionExpression()) {
+          break;
+        }
+      } while (scope = scope.parent);
+      if (scope) state.breakOnScopePaths.push(scope.path);
+    }
+    const binding = path.scope.getBinding(path.node.name);
+    if (!binding) return;
+    for (const violation of binding.constantViolations) {
+      if (violation.scope !== binding.path.scope) {
+        state.mutableBinding = true;
+        path.stop();
+        return;
+      }
+    }
+    if (binding !== state.scope.getBinding(path.node.name)) return;
+    state.bindings[path.node.name] = binding;
+  }
+};
+class PathHoister {
+  constructor(path, scope) {
+    this.breakOnScopePaths = void 0;
+    this.bindings = void 0;
+    this.mutableBinding = void 0;
+    this.scopes = void 0;
+    this.scope = void 0;
+    this.path = void 0;
+    this.attachAfter = void 0;
+    this.breakOnScopePaths = [];
+    this.bindings = {};
+    this.mutableBinding = false;
+    this.scopes = [];
+    this.scope = scope;
+    this.path = path;
+    this.attachAfter = false;
+  }
+  isCompatibleScope(scope) {
+    for (const key of Object.keys(this.bindings)) {
+      const binding = this.bindings[key];
+      if (!scope.bindingIdentifierEquals(key, binding.identifier)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  getCompatibleScopes() {
+    let scope = this.path.scope;
+    do {
+      if (this.isCompatibleScope(scope)) {
+        this.scopes.push(scope);
+      } else {
+        break;
+      }
+      if (this.breakOnScopePaths.includes(scope.path)) {
+        break;
+      }
+    } while (scope = scope.parent);
+  }
+  getAttachmentPath() {
+    let path = this._getAttachmentPath();
+    if (!path) return;
+    let targetScope = path.scope;
+    if (targetScope.path === path) {
+      targetScope = path.scope.parent;
+    }
+    if (targetScope.path.isProgram() || targetScope.path.isFunction()) {
+      for (const name of Object.keys(this.bindings)) {
+        if (!targetScope.hasOwnBinding(name)) continue;
+        const binding = this.bindings[name];
+        if (binding.kind === "param" || binding.path.parentKey === "params") {
+          continue;
+        }
+        const bindingParentPath = this.getAttachmentParentForPath(binding.path);
+        if (bindingParentPath.key >= path.key) {
+          this.attachAfter = true;
+          path = binding.path;
+          for (const violationPath of binding.constantViolations) {
+            if (this.getAttachmentParentForPath(violationPath).key > path.key) {
+              path = violationPath;
+            }
+          }
+        }
+      }
+    }
+    return path;
+  }
+  _getAttachmentPath() {
+    const scopes = this.scopes;
+    const scope = scopes.pop();
+    if (!scope) return;
+    if (scope.path.isFunction()) {
+      if (this.hasOwnParamBindings(scope)) {
+        if (this.scope === scope) return;
+        const bodies = scope.path.get("body").get("body");
+        for (let i = 0; i < bodies.length; i++) {
+          if (bodies[i].node._blockHoist) continue;
+          return bodies[i];
+        }
+      } else {
+        return this.getNextScopeAttachmentParent();
+      }
+    } else if (scope.path.isProgram()) {
+      return this.getNextScopeAttachmentParent();
+    }
+  }
+  getNextScopeAttachmentParent() {
+    const scope = this.scopes.pop();
+    if (scope) return this.getAttachmentParentForPath(scope.path);
+  }
+  getAttachmentParentForPath(path) {
+    do {
+      if (!path.parentPath || Array.isArray(path.container) && path.isStatement()) {
+        return path;
+      }
+    } while (path = path.parentPath);
+    return path;
+  }
+  hasOwnParamBindings(scope) {
+    for (const name of Object.keys(this.bindings)) {
+      if (!scope.hasOwnBinding(name)) continue;
+      const binding = this.bindings[name];
+      if (binding.kind === "param" && binding.constant) return true;
+    }
+    return false;
+  }
+  run() {
+    this.path.traverse(referenceVisitor, this);
+    if (this.mutableBinding) return;
+    this.getCompatibleScopes();
+    const attachTo = this.getAttachmentPath();
+    if (!attachTo) return;
+    if (attachTo.getFunctionParent() === this.path.getFunctionParent()) return;
+    let uid = attachTo.scope.generateUidIdentifier("ref");
+    const declarator = variableDeclarator(uid, this.path.node);
+    const insertFn = this.attachAfter ? "insertAfter" : "insertBefore";
+    const [attached] = attachTo[insertFn]([attachTo.isVariableDeclarator() ? declarator : variableDeclaration("var", [declarator])]);
+    const parent = this.path.parentPath;
+    if (parent.isJSXElement() && this.path.container === parent.node.children) {
+      uid = jsxExpressionContainer(uid);
+    }
+    this.path.replaceWith(cloneNode(uid));
+    return attached.isVariableDeclarator() ? attached.get("init") : attached.get("declarations.0.init");
+  }
+}
+exports.default = PathHoister;
+
+//# sourceMappingURL=hoister.js.map

node_modules/@babel/traverse/lib/path/lib/removal-hooks.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hooks = void 0;
+const hooks = exports.hooks = [function (self, parent) {
+  const removeParent = self.key === "test" && (parent.isWhile() || parent.isSwitchCase()) || self.key === "declaration" && parent.isExportDeclaration() || self.key === "body" && parent.isLabeledStatement() || self.listKey === "declarations" && parent.isVariableDeclaration() && parent.node.declarations.length === 1 || self.key === "expression" && parent.isExpressionStatement();
+  if (removeParent) {
+    parent.remove();
+    return true;
+  }
+}, function (self, parent) {
+  if (parent.isSequenceExpression() && parent.node.expressions.length === 1) {
+    parent.replaceWith(parent.node.expressions[0]);
+    return true;
+  }
+}, function (self, parent) {
+  if (parent.isBinary()) {
+    if (self.key === "left") {
+      parent.replaceWith(parent.node.right);
+    } else {
+      parent.replaceWith(parent.node.left);
+    }
+    return true;
+  }
+}, function (self, parent) {
+  if (parent.isIfStatement() && self.key === "consequent" || self.key === "body" && (parent.isLoop() || parent.isArrowFunctionExpression())) {
+    self.replaceWith({
+      type: "BlockStatement",
+      directives: [],
+      body: []
+    });
+    return true;
+  }
+}];
+
+//# sourceMappingURL=removal-hooks.js.map

node_modules/@babel/traverse/lib/path/lib/removal-hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["hooks","exports","self","parent","removeParent","key","isWhile","isSwitchCase","isExportDeclaration","isLabeledStatement","listKey","isVariableDeclaration","node","declarations","length","isExpressionStatement","remove","isSequenceExpression","expressions","replaceWith","isBinary","right","left","isIfStatement","isLoop","isArrowFunctionExpression","type","directives","body"],"sources":["../../../src/path/lib/removal-hooks.ts"],"sourcesContent":["// this file contains hooks that handle ancestry cleanup of parent nodes when removing children\n\nimport type NodePath from \"../index.ts\";\nimport type * as t from \"@babel/types\";\n/**\n * Pre hooks should be used for either rejecting removal or delegating removal\n */\n\nexport const hooks = [\n  function (self: NodePath, parent: NodePath) {\n    const removeParent =\n      // while (NODE);\n      // removing the test of a while/switch, we can either just remove it entirely *or* turn the\n      // `test` into `true` unlikely that the latter will ever be what's wanted so we just remove\n      // the loop to avoid infinite recursion\n      (self.key === \"test\" && (parent.isWhile() || parent.isSwitchCase())) ||\n      // export NODE;\n      // just remove a declaration for an export as this is no longer valid\n      (self.key === \"declaration\" && parent.isExportDeclaration()) ||\n      // label: NODE\n      // stray labeled statement with no body\n      (self.key === \"body\" && parent.isLabeledStatement()) ||\n      // let NODE;\n      // remove an entire declaration if there are no declarators left\n      (self.listKey === \"declarations\" &&\n        parent.isVariableDeclaration() &&\n        parent.node.declarations.length === 1) ||\n      // NODE;\n      // remove the entire expression statement if there's no expression\n      (self.key === \"expression\" && parent.isExpressionStatement());\n\n    if (removeParent) {\n      parent.remove();\n      return true;\n    }\n  },\n\n  function (self: NodePath, parent: NodePath) {\n    if (parent.isSequenceExpression() && parent.node.expressions.length === 1) {\n      // (node, NODE);\n      // we've just removed the second element of a sequence expression so let's turn that sequence\n      // expression into a regular expression\n      parent.replaceWith(parent.node.expressions[0]);\n      return true;\n    }\n  },\n\n  function (self: NodePath, parent: NodePath) {\n    if (parent.isBinary()) {\n      // left + NODE;\n      // NODE + right;\n      // we're in a binary expression, better remove it and replace it with the last expression\n      if (self.key === \"left\") {\n        parent.replaceWith(parent.node.right);\n      } else {\n        // key === \"right\"\n        parent.replaceWith(parent.node.left);\n      }\n      return true;\n    }\n  },\n\n  function (self: NodePath, parent: NodePath) {\n    if (\n      (parent.isIfStatement() && self.key === \"consequent\") ||\n      (self.key === \"body\" &&\n        (parent.isLoop() || parent.isArrowFunctionExpression()))\n    ) {\n      self.replaceWith({\n        type: \"BlockStatement\",\n        directives: [],\n        body: [],\n      } satisfies t.BlockStatement);\n      return true;\n    }\n  },\n];\n"],"mappings":";;;;;;AAQO,MAAMA,KAAK,GAAAC,OAAA,CAAAD,KAAA,GAAG,CACnB,UAAUE,IAAc,EAAEC,MAAgB,EAAE;EAC1C,MAAMC,YAAY,GAKfF,IAAI,CAACG,GAAG,KAAK,MAAM,KAAKF,MAAM,CAACG,OAAO,CAAC,CAAC,IAAIH,MAAM,CAACI,YAAY,CAAC,CAAC,CAAC,IAGlEL,IAAI,CAACG,GAAG,KAAK,aAAa,IAAIF,MAAM,CAACK,mBAAmB,CAAC,CAAE,IAG3DN,IAAI,CAACG,GAAG,KAAK,MAAM,IAAIF,MAAM,CAACM,kBAAkB,CAAC,CAAE,IAGnDP,IAAI,CAACQ,OAAO,KAAK,cAAc,IAC9BP,MAAM,CAACQ,qBAAqB,CAAC,CAAC,IAC9BR,MAAM,CAACS,IAAI,CAACC,YAAY,CAACC,MAAM,KAAK,CAAE,IAGvCZ,IAAI,CAACG,GAAG,KAAK,YAAY,IAAIF,MAAM,CAACY,qBAAqB,CAAC,CAAE;EAE/D,IAAIX,YAAY,EAAE;IAChBD,MAAM,CAACa,MAAM,CAAC,CAAC;IACf,OAAO,IAAI;EACb;AACF,CAAC,EAED,UAAUd,IAAc,EAAEC,MAAgB,EAAE;EAC1C,IAAIA,MAAM,CAACc,oBAAoB,CAAC,CAAC,IAAId,MAAM,CAACS,IAAI,CAACM,WAAW,CAACJ,MAAM,KAAK,CAAC,EAAE;IAIzEX,MAAM,CAACgB,WAAW,CAAChB,MAAM,CAACS,IAAI,CAACM,WAAW,CAAC,CAAC,CAAC,CAAC;IAC9C,OAAO,IAAI;EACb;AACF,CAAC,EAED,UAAUhB,IAAc,EAAEC,MAAgB,EAAE;EAC1C,IAAIA,MAAM,CAACiB,QAAQ,CAAC,CAAC,EAAE;IAIrB,IAAIlB,IAAI,CAACG,GAAG,KAAK,MAAM,EAAE;MACvBF,MAAM,CAACgB,WAAW,CAAChB,MAAM,CAACS,IAAI,CAACS,KAAK,CAAC;IACvC,CAAC,MAAM;MAELlB,MAAM,CAACgB,WAAW,CAAChB,MAAM,CAACS,IAAI,CAACU,IAAI,CAAC;IACtC;IACA,OAAO,IAAI;EACb;AACF,CAAC,EAED,UAAUpB,IAAc,EAAEC,MAAgB,EAAE;EAC1C,IACGA,MAAM,CAACoB,aAAa,CAAC,CAAC,IAAIrB,IAAI,CAACG,GAAG,KAAK,YAAY,IACnDH,IAAI,CAACG,GAAG,KAAK,MAAM,KACjBF,MAAM,CAACqB,MAAM,CAAC,CAAC,IAAIrB,MAAM,CAACsB,yBAAyB,CAAC,CAAC,CAAE,EAC1D;IACAvB,IAAI,CAACiB,WAAW,CAAC;MACfO,IAAI,EAAE,gBAAgB;MACtBC,UAAU,EAAE,EAAE;MACdC,IAAI,EAAE;IACR,CAA4B,CAAC;IAC7B,OAAO,IAAI;EACb;AACF,CAAC,CACF","ignoreList":[]}

node_modules/@babel/traverse/lib/path/lib/virtual-types-validator.js

@@ -0,0 +1,162 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isBindingIdentifier = isBindingIdentifier;
+exports.isBlockScoped = isBlockScoped;
+exports.isExpression = isExpression;
+exports.isFlow = isFlow;
+exports.isForAwaitStatement = isForAwaitStatement;
+exports.isGenerated = isGenerated;
+exports.isPure = isPure;
+exports.isReferenced = isReferenced;
+exports.isReferencedIdentifier = isReferencedIdentifier;
+exports.isReferencedMemberExpression = isReferencedMemberExpression;
+exports.isRestProperty = isRestProperty;
+exports.isScope = isScope;
+exports.isSpreadProperty = isSpreadProperty;
+exports.isStatement = isStatement;
+exports.isUser = isUser;
+exports.isVar = isVar;
+var _t = require("@babel/types");
+const {
+  isBinding,
+  isBlockScoped: nodeIsBlockScoped,
+  isExportDeclaration,
+  isExpression: nodeIsExpression,
+  isFlow: nodeIsFlow,
+  isForStatement,
+  isForXStatement,
+  isIdentifier,
+  isImportDeclaration,
+  isImportSpecifier,
+  isJSXIdentifier,
+  isJSXMemberExpression,
+  isMemberExpression,
+  isRestElement: nodeIsRestElement,
+  isReferenced: nodeIsReferenced,
+  isScope: nodeIsScope,
+  isStatement: nodeIsStatement,
+  isVar: nodeIsVar,
+  isVariableDeclaration,
+  react,
+  isForOfStatement
+} = _t;
+const {
+  isCompatTag
+} = react;
+function isReferencedIdentifier(opts) {
+  const {
+    node,
+    parent
+  } = this;
+  if (isIdentifier(node, opts)) {
+    return nodeIsReferenced(node, parent, this.parentPath.parent);
+  } else if (isJSXIdentifier(node, opts)) {
+    if (!isJSXMemberExpression(parent) && isCompatTag(node.name)) return false;
+    return nodeIsReferenced(node, parent, this.parentPath.parent);
+  } else {
+    return false;
+  }
+}
+function isReferencedMemberExpression() {
+  const {
+    node,
+    parent
+  } = this;
+  return isMemberExpression(node) && nodeIsReferenced(node, parent);
+}
+function isBindingIdentifier() {
+  const {
+    node,
+    parent
+  } = this;
+  const grandparent = this.parentPath.parent;
+  return isIdentifier(node) && isBinding(node, parent, grandparent);
+}
+function isStatement() {
+  const {
+    node,
+    parent
+  } = this;
+  if (nodeIsStatement(node)) {
+    if (isVariableDeclaration(node)) {
+      if (isForXStatement(parent, {
+        left: node
+      })) return false;
+      if (isForStatement(parent, {
+        init: node
+      })) return false;
+    }
+    return true;
+  } else {
+    return false;
+  }
+}
+function isExpression() {
+  if (this.isIdentifier()) {
+    return this.isReferencedIdentifier();
+  } else {
+    return nodeIsExpression(this.node);
+  }
+}
+function isScope() {
+  return nodeIsScope(this.node, this.parent);
+}
+function isReferenced() {
+  return nodeIsReferenced(this.node, this.parent);
+}
+function isBlockScoped() {
+  return nodeIsBlockScoped(this.node);
+}
+function isVar() {
+  return nodeIsVar(this.node);
+}
+function isUser() {
+  var _this$node;
+  return !!((_this$node = this.node) != null && _this$node.loc);
+}
+function isGenerated() {
+  return !this.isUser();
+}
+function isPure(constantsOnly) {
+  return this.scope.isPure(this.node, constantsOnly);
+}
+function isFlow() {
+  const {
+    node
+  } = this;
+  if (nodeIsFlow(node)) {
+    return true;
+  } else if (isImportDeclaration(node)) {
+    return node.importKind === "type" || node.importKind === "typeof";
+  } else if (isExportDeclaration(node)) {
+    return node.exportKind === "type";
+  } else if (isImportSpecifier(node)) {
+    return node.importKind === "type" || node.importKind === "typeof";
+  } else {
+    return false;
+  }
+}
+function isRestProperty() {
+  var _this$parentPath;
+  return nodeIsRestElement(this.node) && ((_this$parentPath = this.parentPath) == null ? void 0 : _this$parentPath.isObjectPattern());
+}
+function isSpreadProperty() {
+  var _this$parentPath2;
+  return nodeIsRestElement(this.node) && ((_this$parentPath2 = this.parentPath) == null ? void 0 : _this$parentPath2.isObjectExpression());
+}
+function isForAwaitStatement() {
+  return isForOfStatement(this.node, {
+    await: true
+  });
+}
+exports.isExistentialTypeParam = function isExistentialTypeParam() {
+  throw new Error("`path.isExistentialTypeParam` has been renamed to `path.isExistsTypeAnnotation()` in Babel 7.");
+};
+exports.isNumericLiteralTypeAnnotation = function isNumericLiteralTypeAnnotation() {
+  throw new Error("`path.isNumericLiteralTypeAnnotation()` has been renamed to `path.isNumberLiteralTypeAnnotation()` in Babel 7.");
+};
+
+//# sourceMappingURL=virtual-types-validator.js.map

node_modules/@babel/traverse/lib/path/lib/virtual-types.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Var = exports.User = exports.Statement = exports.SpreadProperty = exports.Scope = exports.RestProperty = exports.ReferencedMemberExpression = exports.ReferencedIdentifier = exports.Referenced = exports.Pure = exports.NumericLiteralTypeAnnotation = exports.Generated = exports.ForAwaitStatement = exports.Flow = exports.Expression = exports.ExistentialTypeParam = exports.BlockScoped = exports.BindingIdentifier = void 0;
+const ReferencedIdentifier = exports.ReferencedIdentifier = ["Identifier", "JSXIdentifier"];
+const ReferencedMemberExpression = exports.ReferencedMemberExpression = ["MemberExpression"];
+const BindingIdentifier = exports.BindingIdentifier = ["Identifier"];
+const Statement = exports.Statement = ["Statement"];
+const Expression = exports.Expression = ["Expression"];
+const Scope = exports.Scope = ["Scopable", "Pattern"];
+const Referenced = exports.Referenced = null;
+const BlockScoped = exports.BlockScoped = ["FunctionDeclaration", "ClassDeclaration", "VariableDeclaration"];
+const Var = exports.Var = ["VariableDeclaration"];
+const User = exports.User = null;
+const Generated = exports.Generated = null;
+const Pure = exports.Pure = null;
+const Flow = exports.Flow = ["Flow", "ImportDeclaration", "ExportDeclaration", "ImportSpecifier"];
+const RestProperty = exports.RestProperty = ["RestElement"];
+const SpreadProperty = exports.SpreadProperty = ["RestElement"];
+const ExistentialTypeParam = exports.ExistentialTypeParam = ["ExistsTypeAnnotation"];
+const NumericLiteralTypeAnnotation = exports.NumericLiteralTypeAnnotation = ["NumberLiteralTypeAnnotation"];
+const ForAwaitStatement = exports.ForAwaitStatement = ["ForOfStatement"];
+
+//# sourceMappingURL=virtual-types.js.map

node_modules/@babel/traverse/lib/path/lib/virtual-types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ReferencedIdentifier","exports","ReferencedMemberExpression","BindingIdentifier","Statement","Expression","Scope","Referenced","BlockScoped","Var","User","Generated","Pure","Flow","RestProperty","SpreadProperty","ExistentialTypeParam","NumericLiteralTypeAnnotation","ForAwaitStatement"],"sources":["../../../src/path/lib/virtual-types.ts"],"sourcesContent":["import type * as t from \"@babel/types\";\n\nexport interface VirtualTypeAliases {\n  BindingIdentifier: t.Identifier;\n  BlockScoped:\n    | t.FunctionDeclaration\n    | t.ClassDeclaration\n    | t.VariableDeclaration;\n  ExistentialTypeParam: t.ExistsTypeAnnotation;\n  Expression: t.Expression;\n  Flow: t.Flow | t.ImportDeclaration | t.ExportDeclaration | t.ImportSpecifier;\n  ForAwaitStatement: t.ForOfStatement;\n  Generated: t.Node;\n  NumericLiteralTypeAnnotation: t.NumberLiteralTypeAnnotation;\n  Pure: t.Node;\n  Referenced: t.Node;\n  ReferencedIdentifier: t.Identifier | t.JSXIdentifier;\n  ReferencedMemberExpression: t.MemberExpression;\n  RestProperty: t.RestElement;\n  Scope: t.Scopable | t.Pattern;\n  SpreadProperty: t.RestElement;\n  Statement: t.Statement;\n  User: t.Node;\n  Var: t.VariableDeclaration;\n}\n\ntype VirtualTypeMapping = readonly (t.Node[\"type\"] | keyof t.Aliases)[] | null;\n\nexport const ReferencedIdentifier: VirtualTypeMapping = [\n  \"Identifier\",\n  \"JSXIdentifier\",\n] as const;\n\nexport const ReferencedMemberExpression: VirtualTypeMapping = [\n  \"MemberExpression\",\n] as const;\n\nexport const BindingIdentifier: VirtualTypeMapping = [\"Identifier\"] as const;\n\nexport const Statement: VirtualTypeMapping = [\"Statement\"] as const;\n\nexport const Expression: VirtualTypeMapping = [\"Expression\"] as const;\n\nexport const Scope: VirtualTypeMapping = [\"Scopable\", \"Pattern\"] as const;\n\nexport const Referenced: VirtualTypeMapping = null;\n\nexport const BlockScoped: VirtualTypeMapping = [\n  \"FunctionDeclaration\",\n  \"ClassDeclaration\",\n  \"VariableDeclaration\",\n] as const;\n\nexport const Var: VirtualTypeMapping = [\"VariableDeclaration\"];\n\nexport const User: VirtualTypeMapping = null;\n\nexport const Generated: VirtualTypeMapping = null;\n\nexport const Pure: VirtualTypeMapping = null;\n\nexport const Flow: VirtualTypeMapping = [\n  \"Flow\",\n  \"ImportDeclaration\",\n  \"ExportDeclaration\",\n  \"ImportSpecifier\",\n] as const;\n\n// TODO: 7.0 Backwards Compat\nexport const RestProperty: VirtualTypeMapping = [\"RestElement\"] as const;\n\nexport const SpreadProperty: VirtualTypeMapping = [\"RestElement\"] as const;\n\nexport const ExistentialTypeParam: VirtualTypeMapping = [\n  \"ExistsTypeAnnotation\",\n] as const;\n\nexport const NumericLiteralTypeAnnotation: VirtualTypeMapping = [\n  \"NumberLiteralTypeAnnotation\",\n] as const;\n\nexport const ForAwaitStatement: VirtualTypeMapping = [\n  \"ForOfStatement\",\n] as const;\n"],"mappings":";;;;;;AA4BO,MAAMA,oBAAwC,GAAAC,OAAA,CAAAD,oBAAA,GAAG,CACtD,YAAY,EACZ,eAAe,CACP;AAEH,MAAME,0BAA8C,GAAAD,OAAA,CAAAC,0BAAA,GAAG,CAC5D,kBAAkB,CACV;AAEH,MAAMC,iBAAqC,GAAAF,OAAA,CAAAE,iBAAA,GAAG,CAAC,YAAY,CAAU;AAErE,MAAMC,SAA6B,GAAAH,OAAA,CAAAG,SAAA,GAAG,CAAC,WAAW,CAAU;AAE5D,MAAMC,UAA8B,GAAAJ,OAAA,CAAAI,UAAA,GAAG,CAAC,YAAY,CAAU;AAE9D,MAAMC,KAAyB,GAAAL,OAAA,CAAAK,KAAA,GAAG,CAAC,UAAU,EAAE,SAAS,CAAU;AAElE,MAAMC,UAA8B,GAAAN,OAAA,CAAAM,UAAA,GAAG,IAAI;AAE3C,MAAMC,WAA+B,GAAAP,OAAA,CAAAO,WAAA,GAAG,CAC7C,qBAAqB,EACrB,kBAAkB,EAClB,qBAAqB,CACb;AAEH,MAAMC,GAAuB,GAAAR,OAAA,CAAAQ,GAAA,GAAG,CAAC,qBAAqB,CAAC;AAEvD,MAAMC,IAAwB,GAAAT,OAAA,CAAAS,IAAA,GAAG,IAAI;AAErC,MAAMC,SAA6B,GAAAV,OAAA,CAAAU,SAAA,GAAG,IAAI;AAE1C,MAAMC,IAAwB,GAAAX,OAAA,CAAAW,IAAA,GAAG,IAAI;AAErC,MAAMC,IAAwB,GAAAZ,OAAA,CAAAY,IAAA,GAAG,CACtC,MAAM,EACN,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,CACT;AAGH,MAAMC,YAAgC,GAAAb,OAAA,CAAAa,YAAA,GAAG,CAAC,aAAa,CAAU;AAEjE,MAAMC,cAAkC,GAAAd,OAAA,CAAAc,cAAA,GAAG,CAAC,aAAa,CAAU;AAEnE,MAAMC,oBAAwC,GAAAf,OAAA,CAAAe,oBAAA,GAAG,CACtD,sBAAsB,CACd;AAEH,MAAMC,4BAAgD,GAAAhB,OAAA,CAAAgB,4BAAA,GAAG,CAC9D,6BAA6B,CACrB;AAEH,MAAMC,iBAAqC,GAAAjB,OAAA,CAAAiB,iBAAA,GAAG,CACnD,gBAAgB,CACR","ignoreList":[]}

node_modules/@babel/traverse/lib/path/modification.js

@@ -0,0 +1,229 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._containerInsert = _containerInsert;
+exports._containerInsertAfter = _containerInsertAfter;
+exports._containerInsertBefore = _containerInsertBefore;
+exports._verifyNodeList = _verifyNodeList;
+exports.insertAfter = insertAfter;
+exports.insertBefore = insertBefore;
+exports.pushContainer = pushContainer;
+exports.unshiftContainer = unshiftContainer;
+exports.updateSiblingKeys = updateSiblingKeys;
+var _cache = require("../cache.js");
+var _index = require("./index.js");
+var _context = require("./context.js");
+var _removal = require("./removal.js");
+var _t = require("@babel/types");
+var _hoister = require("./lib/hoister.js");
+const {
+  arrowFunctionExpression,
+  assertExpression,
+  assignmentExpression,
+  blockStatement,
+  callExpression,
+  cloneNode,
+  expressionStatement,
+  isAssignmentExpression,
+  isCallExpression,
+  isExportNamedDeclaration,
+  isExpression,
+  isIdentifier,
+  isSequenceExpression,
+  isSuper,
+  thisExpression
+} = _t;
+function insertBefore(nodes_) {
+  _removal._assertUnremoved.call(this);
+  const nodes = _verifyNodeList.call(this, nodes_);
+  const {
+    parentPath,
+    parent
+  } = this;
+  if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || isExportNamedDeclaration(parent) || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) {
+    return parentPath.insertBefore(nodes);
+  } else if (this.isNodeType("Expression") && !this.isJSXElement() || parentPath.isForStatement() && this.key === "init") {
+    if (this.node) nodes.push(this.node);
+    return this.replaceExpressionWithStatements(nodes);
+  } else if (Array.isArray(this.container)) {
+    return _containerInsertBefore.call(this, nodes);
+  } else if (this.isStatementOrBlock()) {
+    const node = this.node;
+    const shouldInsertCurrentNode = node && (!this.isExpressionStatement() || node.expression != null);
+    const [blockPath] = this.replaceWith(blockStatement(shouldInsertCurrentNode ? [node] : []));
+    return blockPath.unshiftContainer("body", nodes);
+  } else {
+    throw new Error("We don't know what to do with this node type. " + "We were previously a Statement but we can't fit in here?");
+  }
+}
+function _containerInsert(from, nodes) {
+  updateSiblingKeys.call(this, from, nodes.length);
+  const paths = [];
+  this.container.splice(from, 0, ...nodes);
+  for (let i = 0; i < nodes.length; i++) {
+    var _this$context;
+    const to = from + i;
+    const path = this.getSibling(to);
+    paths.push(path);
+    if ((_this$context = this.context) != null && _this$context.queue) {
+      _context.pushContext.call(path, this.context);
+    }
+  }
+  const contexts = _context._getQueueContexts.call(this);
+  for (const path of paths) {
+    _context.setScope.call(path);
+    path.debug("Inserted.");
+    for (const context of contexts) {
+      context.maybeQueue(path, true);
+    }
+  }
+  return paths;
+}
+function _containerInsertBefore(nodes) {
+  return _containerInsert.call(this, this.key, nodes);
+}
+function _containerInsertAfter(nodes) {
+  return _containerInsert.call(this, this.key + 1, nodes);
+}
+const last = arr => arr[arr.length - 1];
+function isHiddenInSequenceExpression(path) {
+  return isSequenceExpression(path.parent) && (last(path.parent.expressions) !== path.node || isHiddenInSequenceExpression(path.parentPath));
+}
+function isAlmostConstantAssignment(node, scope) {
+  if (!isAssignmentExpression(node) || !isIdentifier(node.left)) {
+    return false;
+  }
+  const blockScope = scope.getBlockParent();
+  return blockScope.hasOwnBinding(node.left.name) && blockScope.getOwnBinding(node.left.name).constantViolations.length <= 1;
+}
+function insertAfter(nodes_) {
+  _removal._assertUnremoved.call(this);
+  if (this.isSequenceExpression()) {
+    return last(this.get("expressions")).insertAfter(nodes_);
+  }
+  const nodes = _verifyNodeList.call(this, nodes_);
+  const {
+    parentPath,
+    parent
+  } = this;
+  if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || isExportNamedDeclaration(parent) || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) {
+    return parentPath.insertAfter(nodes.map(node => {
+      return isExpression(node) ? expressionStatement(node) : node;
+    }));
+  } else if (this.isNodeType("Expression") && !this.isJSXElement() && !parentPath.isJSXElement() || parentPath.isForStatement() && this.key === "init") {
+    const self = this;
+    if (self.node) {
+      const node = self.node;
+      let {
+        scope
+      } = this;
+      if (scope.path.isPattern()) {
+        assertExpression(node);
+        self.replaceWith(callExpression(arrowFunctionExpression([], node), []));
+        self.get("callee.body").insertAfter(nodes);
+        return [self];
+      }
+      if (isHiddenInSequenceExpression(self)) {
+        nodes.unshift(node);
+      } else if (isCallExpression(node) && isSuper(node.callee)) {
+        nodes.unshift(node);
+        nodes.push(thisExpression());
+      } else if (isAlmostConstantAssignment(node, scope)) {
+        nodes.unshift(node);
+        nodes.push(cloneNode(node.left));
+      } else if (scope.isPure(node, true)) {
+        nodes.push(node);
+      } else {
+        if (parentPath.isMethod({
+          computed: true,
+          key: node
+        })) {
+          scope = scope.parent;
+        }
+        const temp = scope.generateDeclaredUidIdentifier();
+        nodes.unshift(expressionStatement(assignmentExpression("=", cloneNode(temp), node)));
+        nodes.push(expressionStatement(cloneNode(temp)));
+      }
+    }
+    return this.replaceExpressionWithStatements(nodes);
+  } else if (Array.isArray(this.container)) {
+    return _containerInsertAfter.call(this, nodes);
+  } else if (this.isStatementOrBlock()) {
+    const node = this.node;
+    const shouldInsertCurrentNode = node && (!this.isExpressionStatement() || node.expression != null);
+    const [blockPath] = this.replaceWith(blockStatement(shouldInsertCurrentNode ? [node] : []));
+    return blockPath.pushContainer("body", nodes);
+  } else {
+    throw new Error("We don't know what to do with this node type. " + "We were previously a Statement but we can't fit in here?");
+  }
+}
+function updateSiblingKeys(fromIndex, incrementBy) {
+  if (!this.parent) return;
+  const paths = (0, _cache.getCachedPaths)(this);
+  if (!paths) return;
+  for (const [, path] of paths) {
+    if (typeof path.key === "number" && path.container === this.container && path.key >= fromIndex) {
+      path.key += incrementBy;
+    }
+  }
+}
+function _verifyNodeList(nodes) {
+  if (!nodes) {
+    return [];
+  }
+  if (!Array.isArray(nodes)) {
+    nodes = [nodes];
+  }
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    let msg;
+    if (!node) {
+      msg = "has falsy node";
+    } else if (typeof node !== "object") {
+      msg = "contains a non-object node";
+    } else if (!node.type) {
+      msg = "without a type";
+    } else if (node instanceof _index.default) {
+      msg = "has a NodePath when it expected a raw object";
+    }
+    if (msg) {
+      const type = Array.isArray(node) ? "array" : typeof node;
+      throw new Error(`Node list ${msg} with the index of ${i} and type of ${type}`);
+    }
+  }
+  return nodes;
+}
+function unshiftContainer(listKey, nodes) {
+  _removal._assertUnremoved.call(this);
+  const verifiedNodes = _verifyNodeList.call(this, nodes);
+  const container = this.node[listKey];
+  const path = _index.default.get({
+    parentPath: this,
+    parent: this.node,
+    container,
+    listKey,
+    key: 0
+  }).setContext(this.context);
+  return _containerInsertBefore.call(path, verifiedNodes);
+}
+function pushContainer(listKey, nodes) {
+  _removal._assertUnremoved.call(this);
+  const verifiedNodes = _verifyNodeList.call(this, nodes);
+  const container = this.node[listKey];
+  const path = _index.default.get({
+    parentPath: this,
+    parent: this.node,
+    container,
+    listKey,
+    key: container.length
+  }).setContext(this.context);
+  return path.replaceWithMultiple(verifiedNodes);
+}
+exports.hoist = function hoist(scope = this.scope) {
+  const hoister = new _hoister.default(this, scope);
+  return hoister.run();
+};
+
+//# sourceMappingURL=modification.js.map

node_modules/@babel/traverse/lib/path/removal.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._assertUnremoved = _assertUnremoved;
+exports._callRemovalHooks = _callRemovalHooks;
+exports._markRemoved = _markRemoved;
+exports._remove = _remove;
+exports._removeFromScope = _removeFromScope;
+exports.remove = remove;
+var _removalHooks = require("./lib/removal-hooks.js");
+var _cache = require("../cache.js");
+var _replacement = require("./replacement.js");
+var _index = require("./index.js");
+var t = require("@babel/types");
+var _modification = require("./modification.js");
+var _context = require("./context.js");
+function remove() {
+  var _this$opts;
+  _assertUnremoved.call(this);
+  _context.resync.call(this);
+  if (_callRemovalHooks.call(this)) {
+    _markRemoved.call(this);
+    return;
+  }
+  if (!((_this$opts = this.opts) != null && _this$opts.noScope)) {
+    _removeFromScope.call(this);
+  }
+  this.shareCommentsWithSiblings();
+  _remove.call(this);
+  _markRemoved.call(this);
+}
+function _removeFromScope() {
+  const bindings = t.getBindingIdentifiers(this.node, false, false, true);
+  Object.keys(bindings).forEach(name => this.scope.removeBinding(name));
+}
+function _callRemovalHooks() {
+  if (this.parentPath) {
+    for (const fn of _removalHooks.hooks) {
+      if (fn(this, this.parentPath)) return true;
+    }
+  }
+}
+function _remove() {
+  if (Array.isArray(this.container)) {
+    this.container.splice(this.key, 1);
+    _modification.updateSiblingKeys.call(this, this.key, -1);
+  } else {
+    _replacement._replaceWith.call(this, null);
+  }
+}
+function _markRemoved() {
+  this._traverseFlags |= _index.SHOULD_SKIP | _index.REMOVED;
+  if (this.parent) {
+    var _getCachedPaths;
+    (_getCachedPaths = (0, _cache.getCachedPaths)(this)) == null || _getCachedPaths.delete(this.node);
+  }
+  this.node = null;
+}
+function _assertUnremoved() {
+  if (this.removed) {
+    throw this.buildCodeFrameError("NodePath has been removed so is read-only.");
+  }
+}
+
+//# sourceMappingURL=removal.js.map

node_modules/@babel/traverse/lib/path/removal.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_removalHooks","require","_cache","_replacement","_index","t","_modification","_context","remove","_this$opts","_assertUnremoved","call","resync","_callRemovalHooks","_markRemoved","opts","noScope","_removeFromScope","shareCommentsWithSiblings","_remove","bindings","getBindingIdentifiers","node","Object","keys","forEach","name","scope","removeBinding","parentPath","fn","hooks","Array","isArray","container","splice","key","updateSiblingKeys","_replaceWith","_traverseFlags","SHOULD_SKIP","REMOVED","parent","_getCachedPaths","getCachedPaths","delete","removed","buildCodeFrameError"],"sources":["../../src/path/removal.ts"],"sourcesContent":["// This file contains methods responsible for removing a node.\n\nimport { hooks } from \"./lib/removal-hooks.ts\";\nimport { getCachedPaths } from \"../cache.ts\";\nimport { _replaceWith } from \"./replacement.ts\";\nimport type NodePath from \"./index.ts\";\nimport { REMOVED, SHOULD_SKIP } from \"./index.ts\";\nimport * as t from \"@babel/types\";\nimport { updateSiblingKeys } from \"./modification.ts\";\nimport { resync } from \"./context.ts\";\n\nexport function remove(this: NodePath) {\n  _assertUnremoved.call(this);\n\n  resync.call(this);\n\n  if (_callRemovalHooks.call(this)) {\n    _markRemoved.call(this);\n    return;\n  }\n\n  if (!this.opts?.noScope) {\n    _removeFromScope.call(this);\n  }\n\n  this.shareCommentsWithSiblings();\n  _remove.call(this);\n  _markRemoved.call(this);\n}\n\nexport function _removeFromScope(this: NodePath) {\n  const bindings = t.getBindingIdentifiers(this.node, false, false, true);\n  Object.keys(bindings).forEach(name => this.scope.removeBinding(name));\n}\n\nexport function _callRemovalHooks(this: NodePath) {\n  if (this.parentPath) {\n    for (const fn of hooks) {\n      if (fn(this, this.parentPath)) return true;\n    }\n  }\n}\n\nexport function _remove(this: NodePath) {\n  if (Array.isArray(this.container)) {\n    this.container.splice(this.key as number, 1);\n    updateSiblingKeys.call(this, this.key as number, -1);\n  } else {\n    _replaceWith.call(this, null);\n  }\n}\n\nexport function _markRemoved(this: NodePath) {\n  // this.shouldSkip = true; this.removed = true;\n  this._traverseFlags |= SHOULD_SKIP | REMOVED;\n  if (this.parent) {\n    getCachedPaths(this)?.delete(this.node);\n  }\n  // @ts-expect-error TODO: better types\n  this.node = null;\n}\n\nexport function _assertUnremoved(this: NodePath) {\n  if (this.removed) {\n    throw this.buildCodeFrameError(\n      \"NodePath has been removed so is read-only.\",\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;AAEA,IAAAA,aAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AACA,IAAAE,YAAA,GAAAF,OAAA;AAEA,IAAAG,MAAA,GAAAH,OAAA;AACA,IAAAI,CAAA,GAAAJ,OAAA;AACA,IAAAK,aAAA,GAAAL,OAAA;AACA,IAAAM,QAAA,GAAAN,OAAA;AAEO,SAASO,MAAMA,CAAA,EAAiB;EAAA,IAAAC,UAAA;EACrCC,gBAAgB,CAACC,IAAI,CAAC,IAAI,CAAC;EAE3BC,eAAM,CAACD,IAAI,CAAC,IAAI,CAAC;EAEjB,IAAIE,iBAAiB,CAACF,IAAI,CAAC,IAAI,CAAC,EAAE;IAChCG,YAAY,CAACH,IAAI,CAAC,IAAI,CAAC;IACvB;EACF;EAEA,IAAI,GAAAF,UAAA,GAAC,IAAI,CAACM,IAAI,aAATN,UAAA,CAAWO,OAAO,GAAE;IACvBC,gBAAgB,CAACN,IAAI,CAAC,IAAI,CAAC;EAC7B;EAEA,IAAI,CAACO,yBAAyB,CAAC,CAAC;EAChCC,OAAO,CAACR,IAAI,CAAC,IAAI,CAAC;EAClBG,YAAY,CAACH,IAAI,CAAC,IAAI,CAAC;AACzB;AAEO,SAASM,gBAAgBA,CAAA,EAAiB;EAC/C,MAAMG,QAAQ,GAAGf,CAAC,CAACgB,qBAAqB,CAAC,IAAI,CAACC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC;EACvEC,MAAM,CAACC,IAAI,CAACJ,QAAQ,CAAC,CAACK,OAAO,CAACC,IAAI,IAAI,IAAI,CAACC,KAAK,CAACC,aAAa,CAACF,IAAI,CAAC,CAAC;AACvE;AAEO,SAASb,iBAAiBA,CAAA,EAAiB;EAChD,IAAI,IAAI,CAACgB,UAAU,EAAE;IACnB,KAAK,MAAMC,EAAE,IAAIC,mBAAK,EAAE;MACtB,IAAID,EAAE,CAAC,IAAI,EAAE,IAAI,CAACD,UAAU,CAAC,EAAE,OAAO,IAAI;IAC5C;EACF;AACF;AAEO,SAASV,OAAOA,CAAA,EAAiB;EACtC,IAAIa,KAAK,CAACC,OAAO,CAAC,IAAI,CAACC,SAAS,CAAC,EAAE;IACjC,IAAI,CAACA,SAAS,CAACC,MAAM,CAAC,IAAI,CAACC,GAAG,EAAY,CAAC,CAAC;IAC5CC,+BAAiB,CAAC1B,IAAI,CAAC,IAAI,EAAE,IAAI,CAACyB,GAAG,EAAY,CAAC,CAAC,CAAC;EACtD,CAAC,MAAM;IACLE,yBAAY,CAAC3B,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC;EAC/B;AACF;AAEO,SAASG,YAAYA,CAAA,EAAiB;EAE3C,IAAI,CAACyB,cAAc,IAAIC,kBAAW,GAAGC,cAAO;EAC5C,IAAI,IAAI,CAACC,MAAM,EAAE;IAAA,IAAAC,eAAA;IACf,CAAAA,eAAA,OAAAC,qBAAc,EAAC,IAAI,CAAC,aAApBD,eAAA,CAAsBE,MAAM,CAAC,IAAI,CAACvB,IAAI,CAAC;EACzC;EAEA,IAAI,CAACA,IAAI,GAAG,IAAI;AAClB;AAEO,SAASZ,gBAAgBA,CAAA,EAAiB;EAC/C,IAAI,IAAI,CAACoC,OAAO,EAAE;IAChB,MAAM,IAAI,CAACC,mBAAmB,CAC5B,4CACF,CAAC;EACH;AACF","ignoreList":[]}

node_modules/@babel/traverse/lib/path/replacement.js

@@ -0,0 +1,264 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._replaceWith = _replaceWith;
+exports.replaceExpressionWithStatements = replaceExpressionWithStatements;
+exports.replaceInline = replaceInline;
+exports.replaceWith = replaceWith;
+exports.replaceWithMultiple = replaceWithMultiple;
+exports.replaceWithSourceString = replaceWithSourceString;
+var _codeFrame = require("@babel/code-frame");
+var _index = require("../index.js");
+var _index2 = require("./index.js");
+var _cache = require("../cache.js");
+var _modification = require("./modification.js");
+var _parser = require("@babel/parser");
+var _t = require("@babel/types");
+var _context = require("./context.js");
+const {
+  FUNCTION_TYPES,
+  arrowFunctionExpression,
+  assignmentExpression,
+  awaitExpression,
+  blockStatement,
+  buildUndefinedNode,
+  callExpression,
+  cloneNode,
+  conditionalExpression,
+  expressionStatement,
+  getBindingIdentifiers,
+  identifier,
+  inheritLeadingComments,
+  inheritTrailingComments,
+  inheritsComments,
+  isBlockStatement,
+  isEmptyStatement,
+  isExpression,
+  isExpressionStatement,
+  isIfStatement,
+  isProgram,
+  isStatement,
+  isVariableDeclaration,
+  removeComments,
+  returnStatement,
+  sequenceExpression,
+  validate,
+  yieldExpression
+} = _t;
+function replaceWithMultiple(nodes) {
+  var _getCachedPaths;
+  _context.resync.call(this);
+  const verifiedNodes = _modification._verifyNodeList.call(this, nodes);
+  inheritLeadingComments(verifiedNodes[0], this.node);
+  inheritTrailingComments(verifiedNodes[verifiedNodes.length - 1], this.node);
+  (_getCachedPaths = (0, _cache.getCachedPaths)(this)) == null || _getCachedPaths.delete(this.node);
+  this.node = this.container[this.key] = null;
+  const paths = this.insertAfter(nodes);
+  if (this.node) {
+    this.requeue();
+  } else {
+    this.remove();
+  }
+  return paths;
+}
+function replaceWithSourceString(replacement) {
+  _context.resync.call(this);
+  let ast;
+  try {
+    replacement = `(${replacement})`;
+    ast = (0, _parser.parse)(replacement);
+  } catch (err) {
+    const loc = err.loc;
+    if (loc) {
+      err.message += " - make sure this is an expression.\n" + (0, _codeFrame.codeFrameColumns)(replacement, {
+        start: {
+          line: loc.line,
+          column: loc.column + 1
+        }
+      });
+      err.code = "BABEL_REPLACE_SOURCE_ERROR";
+    }
+    throw err;
+  }
+  const expressionAST = ast.program.body[0].expression;
+  _index.default.removeProperties(expressionAST);
+  return this.replaceWith(expressionAST);
+}
+function replaceWith(replacementPath) {
+  _context.resync.call(this);
+  if (this.removed) {
+    throw new Error("You can't replace this node, we've already removed it");
+  }
+  let replacement = replacementPath instanceof _index2.default ? replacementPath.node : replacementPath;
+  if (!replacement) {
+    throw new Error("You passed `path.replaceWith()` a falsy node, use `path.remove()` instead");
+  }
+  if (this.node === replacement) {
+    return [this];
+  }
+  if (this.isProgram() && !isProgram(replacement)) {
+    throw new Error("You can only replace a Program root node with another Program node");
+  }
+  if (Array.isArray(replacement)) {
+    throw new Error("Don't use `path.replaceWith()` with an array of nodes, use `path.replaceWithMultiple()`");
+  }
+  if (typeof replacement === "string") {
+    throw new Error("Don't use `path.replaceWith()` with a source string, use `path.replaceWithSourceString()`");
+  }
+  let nodePath = "";
+  if (this.isNodeType("Statement") && isExpression(replacement)) {
+    if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement) && !this.parentPath.isExportDefaultDeclaration()) {
+      replacement = expressionStatement(replacement);
+      nodePath = "expression";
+    }
+  }
+  if (this.isNodeType("Expression") && isStatement(replacement)) {
+    if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement)) {
+      return this.replaceExpressionWithStatements([replacement]);
+    }
+  }
+  const oldNode = this.node;
+  if (oldNode) {
+    inheritsComments(replacement, oldNode);
+    removeComments(oldNode);
+  }
+  _replaceWith.call(this, replacement);
+  this.type = replacement.type;
+  _context.setScope.call(this);
+  this.requeue();
+  return [nodePath ? this.get(nodePath) : this];
+}
+function _replaceWith(node) {
+  var _getCachedPaths2;
+  if (!this.container) {
+    throw new ReferenceError("Container is falsy");
+  }
+  if (this.inList) {
+    validate(this.parent, this.key, [node]);
+  } else {
+    validate(this.parent, this.key, node);
+  }
+  this.debug(`Replace with ${node == null ? void 0 : node.type}`);
+  (_getCachedPaths2 = (0, _cache.getCachedPaths)(this)) == null || _getCachedPaths2.set(node, this).delete(this.node);
+  this.node = node;
+  this.container[this.key] = node;
+}
+function replaceExpressionWithStatements(nodes) {
+  _context.resync.call(this);
+  const declars = [];
+  const nodesAsSingleExpression = gatherSequenceExpressions(nodes, declars);
+  if (nodesAsSingleExpression) {
+    for (const id of declars) this.scope.push({
+      id
+    });
+    return this.replaceWith(nodesAsSingleExpression)[0].get("expressions");
+  }
+  const functionParent = this.getFunctionParent();
+  const isParentAsync = functionParent == null ? void 0 : functionParent.node.async;
+  const isParentGenerator = functionParent == null ? void 0 : functionParent.node.generator;
+  const container = arrowFunctionExpression([], blockStatement(nodes));
+  this.replaceWith(callExpression(container, []));
+  const callee = this.get("callee");
+  callee.get("body").scope.hoistVariables(id => this.scope.push({
+    id
+  }));
+  const completionRecords = callee.getCompletionRecords();
+  for (const path of completionRecords) {
+    if (!path.isExpressionStatement()) continue;
+    const loop = path.findParent(path => path.isLoop());
+    if (loop) {
+      let uid = loop.getData("expressionReplacementReturnUid");
+      if (!uid) {
+        uid = callee.scope.generateDeclaredUidIdentifier("ret");
+        callee.get("body").pushContainer("body", returnStatement(cloneNode(uid)));
+        loop.setData("expressionReplacementReturnUid", uid);
+      } else {
+        uid = identifier(uid.name);
+      }
+      path.get("expression").replaceWith(assignmentExpression("=", cloneNode(uid), path.node.expression));
+    } else {
+      path.replaceWith(returnStatement(path.node.expression));
+    }
+  }
+  callee.arrowFunctionToExpression();
+  const newCallee = callee;
+  const needToAwaitFunction = isParentAsync && _index.default.hasType(newCallee.node.body, "AwaitExpression", FUNCTION_TYPES);
+  const needToYieldFunction = isParentGenerator && _index.default.hasType(newCallee.node.body, "YieldExpression", FUNCTION_TYPES);
+  if (needToAwaitFunction) {
+    newCallee.set("async", true);
+    if (!needToYieldFunction) {
+      this.replaceWith(awaitExpression(this.node));
+    }
+  }
+  if (needToYieldFunction) {
+    newCallee.set("generator", true);
+    this.replaceWith(yieldExpression(this.node, true));
+  }
+  return newCallee.get("body.body");
+}
+function gatherSequenceExpressions(nodes, declars) {
+  const exprs = [];
+  let ensureLastUndefined = true;
+  for (const node of nodes) {
+    if (!isEmptyStatement(node)) {
+      ensureLastUndefined = false;
+    }
+    if (isExpression(node)) {
+      exprs.push(node);
+    } else if (isExpressionStatement(node)) {
+      exprs.push(node.expression);
+    } else if (isVariableDeclaration(node)) {
+      if (node.kind !== "var") return;
+      for (const declar of node.declarations) {
+        const bindings = getBindingIdentifiers(declar);
+        for (const key of Object.keys(bindings)) {
+          declars.push(cloneNode(bindings[key]));
+        }
+        if (declar.init) {
+          exprs.push(assignmentExpression("=", declar.id, declar.init));
+        }
+      }
+      ensureLastUndefined = true;
+    } else if (isIfStatement(node)) {
+      const consequent = node.consequent ? gatherSequenceExpressions([node.consequent], declars) : buildUndefinedNode();
+      const alternate = node.alternate ? gatherSequenceExpressions([node.alternate], declars) : buildUndefinedNode();
+      if (!consequent || !alternate) return;
+      exprs.push(conditionalExpression(node.test, consequent, alternate));
+    } else if (isBlockStatement(node)) {
+      const body = gatherSequenceExpressions(node.body, declars);
+      if (!body) return;
+      exprs.push(body);
+    } else if (isEmptyStatement(node)) {
+      if (nodes.indexOf(node) === 0) {
+        ensureLastUndefined = true;
+      }
+    } else {
+      return;
+    }
+  }
+  if (ensureLastUndefined) exprs.push(buildUndefinedNode());
+  if (exprs.length === 1) {
+    return exprs[0];
+  } else {
+    return sequenceExpression(exprs);
+  }
+}
+function replaceInline(nodes) {
+  _context.resync.call(this);
+  if (Array.isArray(nodes)) {
+    if (Array.isArray(this.container)) {
+      nodes = _modification._verifyNodeList.call(this, nodes);
+      const paths = _modification._containerInsertAfter.call(this, nodes);
+      this.remove();
+      return paths;
+    } else {
+      return this.replaceWithMultiple(nodes);
+    }
+  } else {
+    return this.replaceWith(nodes);
+  }
+}
+
+//# sourceMappingURL=replacement.js.map

node_modules/@babel/traverse/lib/scope/binding.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+class Binding {
+  constructor({
+    identifier,
+    scope,
+    path,
+    kind
+  }) {
+    this.identifier = void 0;
+    this.scope = void 0;
+    this.path = void 0;
+    this.kind = void 0;
+    this.constantViolations = [];
+    this.constant = true;
+    this.referencePaths = [];
+    this.referenced = false;
+    this.references = 0;
+    this.identifier = identifier;
+    this.scope = scope;
+    this.path = path;
+    this.kind = kind;
+    if ((kind === "var" || kind === "hoisted") && isInitInLoop(path)) {
+      this.reassign(path);
+    }
+    this.clearValue();
+  }
+  deoptValue() {
+    this.clearValue();
+    this.hasDeoptedValue = true;
+  }
+  setValue(value) {
+    if (this.hasDeoptedValue) return;
+    this.hasValue = true;
+    this.value = value;
+  }
+  clearValue() {
+    this.hasDeoptedValue = false;
+    this.hasValue = false;
+    this.value = null;
+  }
+  reassign(path) {
+    this.constant = false;
+    if (this.constantViolations.includes(path)) {
+      return;
+    }
+    this.constantViolations.push(path);
+  }
+  reference(path) {
+    if (this.referencePaths.includes(path)) {
+      return;
+    }
+    this.referenced = true;
+    this.references++;
+    this.referencePaths.push(path);
+  }
+  dereference() {
+    this.references--;
+    this.referenced = !!this.references;
+  }
+}
+exports.default = Binding;
+function isInitInLoop(path) {
+  const isFunctionDeclarationOrHasInit = !path.isVariableDeclarator() || path.node.init;
+  for (let {
+    parentPath,
+    key
+  } = path; parentPath; {
+    parentPath,
+    key
+  } = parentPath) {
+    if (parentPath.isFunctionParent()) return false;
+    if (key === "left" && parentPath.isForXStatement() || isFunctionDeclarationOrHasInit && key === "body" && parentPath.isLoop()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+//# sourceMappingURL=binding.js.map

node_modules/@babel/traverse/lib/scope/lib/renamer.js

@@ -0,0 +1,132 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var t = require("@babel/types");
+var _t = t;
+var _traverseNode = require("../../traverse-node.js");
+var _visitors = require("../../visitors.js");
+var _context = require("../../path/context.js");
+const {
+  getAssignmentIdentifiers
+} = _t;
+const renameVisitor = {
+  ReferencedIdentifier({
+    node
+  }, state) {
+    if (node.name === state.oldName) {
+      node.name = state.newName;
+    }
+  },
+  Scope(path, state) {
+    if (!path.scope.bindingIdentifierEquals(state.oldName, state.binding.identifier)) {
+      path.skip();
+      if (path.isMethod()) {
+        if (!path.requeueComputedKeyAndDecorators) {
+          _context.requeueComputedKeyAndDecorators.call(path);
+        } else {
+          path.requeueComputedKeyAndDecorators();
+        }
+      }
+      if (path.isSwitchStatement()) {
+        path.context.maybeQueue(path.get("discriminant"));
+      }
+    }
+  },
+  ObjectProperty({
+    node,
+    scope
+  }, state) {
+    const {
+      name
+    } = node.key;
+    if (node.shorthand && (name === state.oldName || name === state.newName) && scope.getBindingIdentifier(name) === state.binding.identifier) {
+      var _node$extra;
+      node.shorthand = false;
+      if ((_node$extra = node.extra) != null && _node$extra.shorthand) node.extra.shorthand = false;
+    }
+  },
+  "AssignmentExpression|Declaration|VariableDeclarator"(path, state) {
+    if (path.isVariableDeclaration()) return;
+    const ids = path.isAssignmentExpression() ? getAssignmentIdentifiers(path.node) : path.getOuterBindingIdentifiers();
+    for (const name in ids) {
+      if (name === state.oldName) ids[name].name = state.newName;
+    }
+  }
+};
+class Renamer {
+  constructor(binding, oldName, newName) {
+    this.newName = newName;
+    this.oldName = oldName;
+    this.binding = binding;
+  }
+  maybeConvertFromExportDeclaration(parentDeclar) {
+    const maybeExportDeclar = parentDeclar.parentPath;
+    if (!maybeExportDeclar.isExportDeclaration()) {
+      return;
+    }
+    if (maybeExportDeclar.isExportDefaultDeclaration()) {
+      const {
+        declaration
+      } = maybeExportDeclar.node;
+      if (t.isDeclaration(declaration) && !declaration.id) {
+        return;
+      }
+    }
+    if (maybeExportDeclar.isExportAllDeclaration()) {
+      return;
+    }
+    maybeExportDeclar.splitExportDeclaration();
+  }
+  maybeConvertFromClassFunctionDeclaration(path) {
+    return path;
+  }
+  maybeConvertFromClassFunctionExpression(path) {
+    return path;
+  }
+  rename() {
+    const {
+      binding,
+      oldName,
+      newName
+    } = this;
+    const {
+      scope,
+      path
+    } = binding;
+    const parentDeclar = path.find(path => path.isDeclaration() || path.isFunctionExpression() || path.isClassExpression());
+    if (parentDeclar) {
+      const bindingIds = parentDeclar.getOuterBindingIdentifiers();
+      if (bindingIds[oldName] === binding.identifier) {
+        this.maybeConvertFromExportDeclaration(parentDeclar);
+      }
+    }
+    const blockToTraverse = arguments[0] || scope.block;
+    const skipKeys = {
+      discriminant: true
+    };
+    if (t.isMethod(blockToTraverse)) {
+      if (blockToTraverse.computed) {
+        skipKeys.key = true;
+      }
+      if (!t.isObjectMethod(blockToTraverse)) {
+        skipKeys.decorators = true;
+      }
+    }
+    (0, _traverseNode.traverseNode)(blockToTraverse, (0, _visitors.explode)(renameVisitor), scope, this, scope.path, skipKeys);
+    if (!arguments[0]) {
+      scope.removeOwnBinding(oldName);
+      scope.bindings[newName] = binding;
+      this.binding.identifier.name = newName;
+    }
+    if (parentDeclar) {
+      this.maybeConvertFromClassFunctionDeclaration(path);
+      this.maybeConvertFromClassFunctionExpression(path);
+    }
+  }
+}
+exports.default = Renamer;
+
+//# sourceMappingURL=renamer.js.map

node_modules/@babel/traverse/lib/scope/traverseForScope.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = traverseForScope;
+var _t = require("@babel/types");
+var _index = require("../index.js");
+var _visitors = require("../visitors.js");
+var _context = require("../path/context.js");
+const {
+  VISITOR_KEYS
+} = _t;
+function traverseForScope(path, visitors, state) {
+  const exploded = (0, _visitors.explode)(visitors);
+  if (exploded.enter || exploded.exit) {
+    throw new Error("Should not be used with enter/exit visitors.");
+  }
+  _traverse(path.parentPath, path.parent, path.node, path.container, path.key, path.listKey, path.hub, path);
+  function _traverse(parentPath, parent, node, container, key, listKey, hub, inPath) {
+    if (!node) {
+      return;
+    }
+    const path = inPath || _index.NodePath.get({
+      hub,
+      parentPath,
+      parent,
+      container,
+      listKey,
+      key
+    });
+    _context._forceSetScope.call(path);
+    const visitor = exploded[node.type];
+    if (visitor != null && visitor.enter) {
+      for (const visit of visitor.enter) {
+        visit.call(state, path, state);
+      }
+    }
+    if (path.shouldSkip) {
+      return;
+    }
+    const keys = VISITOR_KEYS[node.type];
+    if (!(keys != null && keys.length)) {
+      return;
+    }
+    for (const key of keys) {
+      const prop = node[key];
+      if (!prop) continue;
+      if (Array.isArray(prop)) {
+        for (let i = 0; i < prop.length; i++) {
+          const value = prop[i];
+          _traverse(path, node, value, prop, i, key);
+        }
+      } else {
+        _traverse(path, node, prop, node, key, null);
+      }
+    }
+    if (visitor != null && visitor.exit) {
+      for (const visit of visitor.exit) {
+        visit.call(state, path, state);
+      }
+    }
+  }
+}
+
+//# sourceMappingURL=traverseForScope.js.map

node_modules/@babel/traverse/lib/scope/traverseForScope.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_t","require","_index","_visitors","_context","VISITOR_KEYS","traverseForScope","path","visitors","state","exploded","explode","enter","exit","Error","_traverse","parentPath","parent","node","container","key","listKey","hub","inPath","NodePath","get","_forceSetScope","call","visitor","type","visit","shouldSkip","keys","length","prop","Array","isArray","i","value"],"sources":["../../src/scope/traverseForScope.ts"],"sourcesContent":["import { VISITOR_KEYS } from \"@babel/types\";\nimport type * as t from \"@babel/types\";\nimport type { HubInterface, Visitor } from \"../index.ts\";\nimport { NodePath } from \"../index.ts\";\nimport { explode } from \"../visitors.ts\";\nimport { _forceSetScope } from \"../path/context.ts\";\n\nexport default function traverseForScope(\n  path: NodePath,\n  visitors: Visitor,\n  state: any,\n) {\n  const exploded = explode(visitors);\n\n  if (exploded.enter || exploded.exit) {\n    throw new Error(\"Should not be used with enter/exit visitors.\");\n  }\n\n  _traverse(\n    path.parentPath,\n    path.parent,\n    path.node,\n    path.container!,\n    path.key!,\n    path.listKey,\n    path.hub,\n    path,\n  );\n\n  function _traverse(\n    parentPath: NodePath,\n    parent: t.Node,\n    node: t.Node,\n    container: t.Node | t.Node[],\n    key: string | number,\n    listKey: string | null | undefined,\n    hub?: HubInterface,\n    inPath?: NodePath,\n  ) {\n    if (!node) {\n      return;\n    }\n\n    const path =\n      inPath ||\n      NodePath.get({\n        hub,\n        parentPath,\n        parent,\n        container,\n        listKey,\n        key,\n      });\n\n    _forceSetScope.call(path);\n\n    const visitor = exploded[node.type];\n    if (visitor?.enter) {\n      for (const visit of visitor.enter) {\n        visit.call(state, path, state);\n      }\n    }\n\n    if (path.shouldSkip) {\n      return;\n    }\n\n    const keys = VISITOR_KEYS[node.type];\n    if (!keys?.length) {\n      return;\n    }\n\n    for (const key of keys) {\n      // @ts-expect-error key must present in node\n      const prop = node[key];\n      if (!prop) continue;\n      if (Array.isArray(prop)) {\n        for (let i = 0; i < prop.length; i++) {\n          const value = prop[i];\n          _traverse(path, node, value, prop, i, key);\n        }\n      } else {\n        _traverse(path, node, prop, node, key, null);\n      }\n    }\n\n    if (visitor?.exit) {\n      for (const visit of visitor.exit) {\n        visit.call(state, path, state);\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,EAAA,GAAAC,OAAA;AAGA,IAAAC,MAAA,GAAAD,OAAA;AACA,IAAAE,SAAA,GAAAF,OAAA;AACA,IAAAG,QAAA,GAAAH,OAAA;AAAoD;EAL3CI;AAAY,IAAAL,EAAA;AAON,SAASM,gBAAgBA,CACtCC,IAAc,EACdC,QAAiB,EACjBC,KAAU,EACV;EACA,MAAMC,QAAQ,GAAG,IAAAC,iBAAO,EAACH,QAAQ,CAAC;EAElC,IAAIE,QAAQ,CAACE,KAAK,IAAIF,QAAQ,CAACG,IAAI,EAAE;IACnC,MAAM,IAAIC,KAAK,CAAC,8CAA8C,CAAC;EACjE;EAEAC,SAAS,CACPR,IAAI,CAACS,UAAU,EACfT,IAAI,CAACU,MAAM,EACXV,IAAI,CAACW,IAAI,EACTX,IAAI,CAACY,SAAS,EACdZ,IAAI,CAACa,GAAG,EACRb,IAAI,CAACc,OAAO,EACZd,IAAI,CAACe,GAAG,EACRf,IACF,CAAC;EAED,SAASQ,SAASA,CAChBC,UAAoB,EACpBC,MAAc,EACdC,IAAY,EACZC,SAA4B,EAC5BC,GAAoB,EACpBC,OAAkC,EAClCC,GAAkB,EAClBC,MAAiB,EACjB;IACA,IAAI,CAACL,IAAI,EAAE;MACT;IACF;IAEA,MAAMX,IAAI,GACRgB,MAAM,IACNC,eAAQ,CAACC,GAAG,CAAC;MACXH,GAAG;MACHN,UAAU;MACVC,MAAM;MACNE,SAAS;MACTE,OAAO;MACPD;IACF,CAAC,CAAC;IAEJM,uBAAc,CAACC,IAAI,CAACpB,IAAI,CAAC;IAEzB,MAAMqB,OAAO,GAAGlB,QAAQ,CAACQ,IAAI,CAACW,IAAI,CAAC;IACnC,IAAID,OAAO,YAAPA,OAAO,CAAEhB,KAAK,EAAE;MAClB,KAAK,MAAMkB,KAAK,IAAIF,OAAO,CAAChB,KAAK,EAAE;QACjCkB,KAAK,CAACH,IAAI,CAAClB,KAAK,EAAEF,IAAI,EAAEE,KAAK,CAAC;MAChC;IACF;IAEA,IAAIF,IAAI,CAACwB,UAAU,EAAE;MACnB;IACF;IAEA,MAAMC,IAAI,GAAG3B,YAAY,CAACa,IAAI,CAACW,IAAI,CAAC;IACpC,IAAI,EAACG,IAAI,YAAJA,IAAI,CAAEC,MAAM,GAAE;MACjB;IACF;IAEA,KAAK,MAAMb,GAAG,IAAIY,IAAI,EAAE;MAEtB,MAAME,IAAI,GAAGhB,IAAI,CAACE,GAAG,CAAC;MACtB,IAAI,CAACc,IAAI,EAAE;MACX,IAAIC,KAAK,CAACC,OAAO,CAACF,IAAI,CAAC,EAAE;QACvB,KAAK,IAAIG,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGH,IAAI,CAACD,MAAM,EAAEI,CAAC,EAAE,EAAE;UACpC,MAAMC,KAAK,GAAGJ,IAAI,CAACG,CAAC,CAAC;UACrBtB,SAAS,CAACR,IAAI,EAAEW,IAAI,EAAEoB,KAAK,EAAEJ,IAAI,EAAEG,CAAC,EAAEjB,GAAG,CAAC;QAC5C;MACF,CAAC,MAAM;QACLL,SAAS,CAACR,IAAI,EAAEW,IAAI,EAAEgB,IAAI,EAAEhB,IAAI,EAAEE,GAAG,EAAE,IAAI,CAAC;MAC9C;IACF;IAEA,IAAIQ,OAAO,YAAPA,OAAO,CAAEf,IAAI,EAAE;MACjB,KAAK,MAAMiB,KAAK,IAAIF,OAAO,CAACf,IAAI,EAAE;QAChCiB,KAAK,CAACH,IAAI,CAAClB,KAAK,EAAEF,IAAI,EAAEE,KAAK,CAAC;MAChC;IACF;EACF;AACF","ignoreList":[]}

node_modules/@babel/traverse/lib/traverse-node.js

@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.traverseNode = traverseNode;
+var _context = require("./context.js");
+var _index = require("./path/index.js");
+var _t = require("@babel/types");
+var _context2 = require("./path/context.js");
+const {
+  VISITOR_KEYS
+} = _t;
+function _visitPaths(ctx, paths) {
+  ctx.queue = paths;
+  ctx.priorityQueue = [];
+  const visited = new Set();
+  let stop = false;
+  let visitIndex = 0;
+  for (; visitIndex < paths.length;) {
+    const path = paths[visitIndex];
+    visitIndex++;
+    _context2.resync.call(path);
+    if (path.contexts.length === 0 || path.contexts[path.contexts.length - 1] !== ctx) {
+      _context2.pushContext.call(path, ctx);
+    }
+    if (path.key === null) continue;
+    const {
+      node
+    } = path;
+    if (visited.has(node)) continue;
+    if (node) visited.add(node);
+    if (_visit(ctx, path)) {
+      stop = true;
+      break;
+    }
+    if (ctx.priorityQueue.length) {
+      stop = _visitPaths(ctx, ctx.priorityQueue);
+      ctx.priorityQueue = [];
+      ctx.queue = paths;
+      if (stop) break;
+    }
+  }
+  for (let i = 0; i < visitIndex; i++) {
+    _context2.popContext.call(paths[i]);
+  }
+  ctx.queue = null;
+  return stop;
+}
+function _visit(ctx, path) {
+  var _opts$denylist;
+  const node = path.node;
+  if (!node) {
+    return false;
+  }
+  const opts = ctx.opts;
+  const denylist = (_opts$denylist = opts.denylist) != null ? _opts$denylist : opts.blacklist;
+  if (denylist != null && denylist.includes(node.type)) {
+    return false;
+  }
+  if (opts.shouldSkip != null && opts.shouldSkip(path)) {
+    return false;
+  }
+  if (path.shouldSkip) return path.shouldStop;
+  if (_context2._call.call(path, opts.enter)) return path.shouldStop;
+  if (path.node) {
+    var _opts$node$type;
+    if (_context2._call.call(path, (_opts$node$type = opts[node.type]) == null ? void 0 : _opts$node$type.enter)) return path.shouldStop;
+  }
+  path.shouldStop = _traverse(path.node, opts, path.scope, ctx.state, path, path.skipKeys);
+  if (path.node) {
+    if (_context2._call.call(path, opts.exit)) return true;
+  }
+  if (path.node) {
+    var _opts$node$type2;
+    _context2._call.call(path, (_opts$node$type2 = opts[node.type]) == null ? void 0 : _opts$node$type2.exit);
+  }
+  return path.shouldStop;
+}
+function _traverse(node, opts, scope, state, path, skipKeys, visitSelf) {
+  const keys = VISITOR_KEYS[node.type];
+  if (!(keys != null && keys.length)) return false;
+  const ctx = new _context.default(scope, opts, state, path);
+  if (visitSelf) {
+    if (skipKeys != null && skipKeys[path.parentKey]) return false;
+    return _visitPaths(ctx, [path]);
+  }
+  for (const key of keys) {
+    if (skipKeys != null && skipKeys[key]) continue;
+    const prop = node[key];
+    if (!prop) continue;
+    if (Array.isArray(prop)) {
+      if (!prop.length) continue;
+      const paths = [];
+      for (let i = 0; i < prop.length; i++) {
+        const childPath = _index.default.get({
+          parentPath: path,
+          parent: node,
+          container: prop,
+          key: i,
+          listKey: key
+        });
+        paths.push(childPath);
+      }
+      if (_visitPaths(ctx, paths)) return true;
+    } else {
+      if (_visitPaths(ctx, [_index.default.get({
+        parentPath: path,
+        parent: node,
+        container: node,
+        key,
+        listKey: null
+      })])) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function traverseNode(node, opts, scope, state, path, skipKeys, visitSelf) {
+  const keys = VISITOR_KEYS[node.type];
+  if (!keys) return false;
+  const context = new _context.default(scope, opts, state, path);
+  if (visitSelf) {
+    if (skipKeys != null && skipKeys[path.parentKey]) return false;
+    return context.visitQueue([path]);
+  }
+  for (const key of keys) {
+    if (skipKeys != null && skipKeys[key]) continue;
+    if (context.visit(node, key)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+//# sourceMappingURL=traverse-node.js.map

node_modules/@babel/traverse/lib/types.js

@@ -0,0 +1,3 @@
+"use strict";
+
+//# sourceMappingURL=types.js.map

node_modules/@babel/traverse/lib/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["../src/types.ts"],"sourcesContent":["import type * as t from \"@babel/types\";\nimport type { NodePath } from \"./index.ts\";\nimport type { VirtualTypeAliases } from \"./path/lib/virtual-types.ts\";\nimport type {\n  ExplVisitorBase,\n  VisitorBaseNodes,\n  VisitorBaseAliases,\n} from \"./generated/visitor-types.d.ts\";\n\nexport type VisitPhase = \"enter\" | \"exit\";\n\ninterface VisitNodeObject<S, P extends t.Node> {\n  enter?: VisitNodeFunction<S, P>;\n  exit?: VisitNodeFunction<S, P>;\n}\n\nexport interface ExplVisitNode<S, P extends t.Node> {\n  enter?: VisitNodeFunction<S, P>[];\n  exit?: VisitNodeFunction<S, P>[];\n}\n\nexport interface ExplodedVisitor<S = unknown>\n  extends ExplVisitorBase<S>,\n    ExplVisitNode<S, t.Node> {\n  _exploded: true;\n  _verified: true;\n}\n\n// TODO: Assert that the keys of this are the keys of VirtualTypeAliases without\n// the keys of VisitorBaseNodes and VisitorBaseAliases\n// prettier-ignore\ninterface VisitorVirtualAliases<S> {\n  BindingIdentifier?: VisitNode<S, VirtualTypeAliases[\"BindingIdentifier\"]>;\n  BlockScoped?: VisitNode<S, VirtualTypeAliases[\"BlockScoped\"]>;\n  ExistentialTypeParam?: VisitNode<S, VirtualTypeAliases[\"ExistentialTypeParam\"]>;\n  Expression?: VisitNode<S, VirtualTypeAliases[\"Expression\"]>;\n  //Flow?: VisitNode<S, VirtualTypeAliases[\"Flow\"]>;\n  ForAwaitStatement?: VisitNode<S, VirtualTypeAliases[\"ForAwaitStatement\"]>;\n  Generated?: VisitNode<S, VirtualTypeAliases[\"Generated\"]>;\n  NumericLiteralTypeAnnotation?: VisitNode<S, VirtualTypeAliases[\"NumericLiteralTypeAnnotation\"]>;\n  Pure?: VisitNode<S, VirtualTypeAliases[\"Pure\"]>;\n  Referenced?: VisitNode<S, VirtualTypeAliases[\"Referenced\"]>;\n  ReferencedIdentifier?: VisitNode<S, VirtualTypeAliases[\"ReferencedIdentifier\"]>;\n  ReferencedMemberExpression?: VisitNode<S, VirtualTypeAliases[\"ReferencedMemberExpression\"]>;\n  //RestProperty?: VisitNode<S, VirtualTypeAliases[\"RestProperty\"]>;\n  Scope?: VisitNode<S, VirtualTypeAliases[\"Scope\"]>;\n  //SpreadProperty?: VisitNode<S, VirtualTypeAliases[\"SpreadProperty\"]>;\n  Statement?: VisitNode<S, VirtualTypeAliases[\"Statement\"]>;\n  User?: VisitNode<S, VirtualTypeAliases[\"User\"]>;\n  Var?: VisitNode<S, VirtualTypeAliases[\"Var\"]>;\n}\n\n// TODO: Do not export this? Or give it a better name?\nexport interface VisitorBase<S>\n  extends VisitNodeObject<S, t.Node>,\n    VisitorBaseNodes<S>,\n    VisitorBaseAliases<S>,\n    VisitorVirtualAliases<S>,\n    // Babel supports `NodeTypesWithoutComment | NodeTypesWithoutComment | ... ` but it is\n    // too complex for TS. So we type it as a general visitor only if the key contains `|`\n    // this is good enough for non-visitor traverse options e.g. `noScope`\n    Record<`${string}|${string}`, VisitNode<S, t.Node>> {}\n\nexport type Visitor<S = unknown> = VisitorBase<S> | ExplodedVisitor<S>;\n\nexport type VisitNode<S, P extends t.Node> =\n  | VisitNodeFunction<S, P>\n  | VisitNodeObject<S, P>;\n\nexport type VisitNodeFunction<S, P extends t.Node> = (\n  this: S,\n  path: NodePath<P>,\n  state: S,\n) => void;\n"],"mappings":"","ignoreList":[]}

node_modules/@babel/traverse/lib/visitors.js

@@ -0,0 +1,252 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.environmentVisitor = environmentVisitor;
+exports.explode = explode$1;
+exports.isExplodedVisitor = isExplodedVisitor;
+exports.merge = merge;
+exports.verify = verify$1;
+var virtualTypes = require("./path/lib/virtual-types.js");
+var virtualTypesValidators = require("./path/lib/virtual-types-validator.js");
+var _t = require("@babel/types");
+var _context = require("./path/context.js");
+const {
+  DEPRECATED_KEYS,
+  DEPRECATED_ALIASES,
+  FLIPPED_ALIAS_KEYS,
+  TYPES,
+  __internal__deprecationWarning: deprecationWarning
+} = _t;
+function isVirtualType(type) {
+  return type in virtualTypes;
+}
+function isExplodedVisitor(visitor) {
+  return visitor == null ? void 0 : visitor._exploded;
+}
+function explode$1(visitor) {
+  if (isExplodedVisitor(visitor)) return visitor;
+  visitor._exploded = true;
+  for (const nodeType of Object.keys(visitor)) {
+    if (shouldIgnoreKey(nodeType)) continue;
+    const parts = nodeType.split("|");
+    if (parts.length === 1) continue;
+    const fns = visitor[nodeType];
+    delete visitor[nodeType];
+    for (const part of parts) {
+      visitor[part] = fns;
+    }
+  }
+  verify$1(visitor);
+  delete visitor.__esModule;
+  ensureEntranceObjects(visitor);
+  ensureCallbackArrays(visitor);
+  for (const nodeType of Object.keys(visitor)) {
+    if (shouldIgnoreKey(nodeType)) continue;
+    if (!isVirtualType(nodeType)) continue;
+    const fns = visitor[nodeType];
+    for (const type of Object.keys(fns)) {
+      fns[type] = wrapCheck(nodeType, fns[type]);
+    }
+    delete visitor[nodeType];
+    const types = virtualTypes[nodeType];
+    if (types !== null) {
+      for (const type of types) {
+        var _visitor$type;
+        (_visitor$type = visitor[type]) != null ? _visitor$type : visitor[type] = {};
+        mergePair(visitor[type], fns);
+      }
+    } else {
+      mergePair(visitor, fns);
+    }
+  }
+  for (const nodeType of Object.keys(visitor)) {
+    if (shouldIgnoreKey(nodeType)) continue;
+    let aliases = FLIPPED_ALIAS_KEYS[nodeType];
+    if (nodeType in DEPRECATED_KEYS) {
+      const deprecatedKey = DEPRECATED_KEYS[nodeType];
+      deprecationWarning(nodeType, deprecatedKey, "Visitor ");
+      aliases = [deprecatedKey];
+    } else if (nodeType in DEPRECATED_ALIASES) {
+      const deprecatedAlias = DEPRECATED_ALIASES[nodeType];
+      deprecationWarning(nodeType, deprecatedAlias, "Visitor ");
+      aliases = FLIPPED_ALIAS_KEYS[deprecatedAlias];
+    }
+    if (!aliases) continue;
+    const fns = visitor[nodeType];
+    delete visitor[nodeType];
+    for (const alias of aliases) {
+      const existing = visitor[alias];
+      if (existing) {
+        mergePair(existing, fns);
+      } else {
+        visitor[alias] = Object.assign({}, fns);
+      }
+    }
+  }
+  for (const nodeType of Object.keys(visitor)) {
+    if (shouldIgnoreKey(nodeType)) continue;
+    ensureCallbackArrays(visitor[nodeType]);
+  }
+  return visitor;
+}
+function verify$1(visitor) {
+  if (visitor._verified) return;
+  if (typeof visitor === "function") {
+    throw new Error("You passed `traverse()` a function when it expected a visitor object, " + "are you sure you didn't mean `{ enter: Function }`?");
+  }
+  for (const nodeType of Object.keys(visitor)) {
+    if (nodeType === "enter" || nodeType === "exit") {
+      validateVisitorMethods(nodeType, visitor[nodeType]);
+    }
+    if (shouldIgnoreKey(nodeType)) continue;
+    if (!TYPES.includes(nodeType)) {
+      throw new Error(`You gave us a visitor for the node type ${nodeType} but it's not a valid type in @babel/traverse ${"7.29.0"}`);
+    }
+    const visitors = visitor[nodeType];
+    if (typeof visitors === "object") {
+      for (const visitorKey of Object.keys(visitors)) {
+        if (visitorKey === "enter" || visitorKey === "exit") {
+          validateVisitorMethods(`${nodeType}.${visitorKey}`, visitors[visitorKey]);
+        } else {
+          throw new Error("You passed `traverse()` a visitor object with the property " + `${nodeType} that has the invalid property ${visitorKey}`);
+        }
+      }
+    }
+  }
+  visitor._verified = true;
+}
+function validateVisitorMethods(path, val) {
+  const fns = [].concat(val);
+  for (const fn of fns) {
+    if (typeof fn !== "function") {
+      throw new TypeError(`Non-function found defined in ${path} with type ${typeof fn}`);
+    }
+  }
+}
+function merge(visitors, states = [], wrapper) {
+  const mergedVisitor = {
+    _verified: true,
+    _exploded: true
+  };
+  Object.defineProperty(mergedVisitor, "_exploded", {
+    enumerable: false
+  });
+  Object.defineProperty(mergedVisitor, "_verified", {
+    enumerable: false
+  });
+  for (let i = 0; i < visitors.length; i++) {
+    const visitor = explode$1(visitors[i]);
+    const state = states[i];
+    let topVisitor = visitor;
+    if (state || wrapper) {
+      topVisitor = wrapWithStateOrWrapper(topVisitor, state, wrapper);
+    }
+    mergePair(mergedVisitor, topVisitor);
+    for (const key of Object.keys(visitor)) {
+      if (shouldIgnoreKey(key)) continue;
+      let typeVisitor = visitor[key];
+      if (state || wrapper) {
+        typeVisitor = wrapWithStateOrWrapper(typeVisitor, state, wrapper);
+      }
+      const nodeVisitor = mergedVisitor[key] || (mergedVisitor[key] = {});
+      mergePair(nodeVisitor, typeVisitor);
+    }
+  }
+  return mergedVisitor;
+}
+function wrapWithStateOrWrapper(oldVisitor, state, wrapper) {
+  const newVisitor = {};
+  for (const phase of ["enter", "exit"]) {
+    let fns = oldVisitor[phase];
+    if (!Array.isArray(fns)) continue;
+    fns = fns.map(function (fn) {
+      let newFn = fn;
+      if (state) {
+        newFn = function (path) {
+          fn.call(state, path, state);
+        };
+      }
+      if (wrapper) {
+        newFn = wrapper(state == null ? void 0 : state.key, phase, newFn);
+      }
+      if (newFn !== fn) {
+        newFn.toString = () => fn.toString();
+      }
+      return newFn;
+    });
+    newVisitor[phase] = fns;
+  }
+  return newVisitor;
+}
+function ensureEntranceObjects(obj) {
+  for (const key of Object.keys(obj)) {
+    if (shouldIgnoreKey(key)) continue;
+    const fns = obj[key];
+    if (typeof fns === "function") {
+      obj[key] = {
+        enter: fns
+      };
+    }
+  }
+}
+function ensureCallbackArrays(obj) {
+  if (obj.enter && !Array.isArray(obj.enter)) obj.enter = [obj.enter];
+  if (obj.exit && !Array.isArray(obj.exit)) obj.exit = [obj.exit];
+}
+function wrapCheck(nodeType, fn) {
+  const fnKey = `is${nodeType}`;
+  const validator = virtualTypesValidators[fnKey];
+  const newFn = function (path) {
+    if (validator.call(path)) {
+      return fn.apply(this, arguments);
+    }
+  };
+  newFn.toString = () => fn.toString();
+  return newFn;
+}
+function shouldIgnoreKey(key) {
+  if (key.startsWith("_")) return true;
+  if (key === "enter" || key === "exit" || key === "shouldSkip") return true;
+  if (key === "denylist" || key === "noScope" || key === "skipKeys") {
+    return true;
+  }
+  if (key === "blacklist") {
+    return true;
+  }
+  return false;
+}
+function mergePair(dest, src) {
+  for (const phase of ["enter", "exit"]) {
+    if (!src[phase]) continue;
+    dest[phase] = [].concat(dest[phase] || [], src[phase]);
+  }
+}
+const _environmentVisitor = {
+  FunctionParent(path) {
+    if (path.isArrowFunctionExpression()) return;
+    path.skip();
+    if (path.isMethod()) {
+      if (!path.requeueComputedKeyAndDecorators) {
+        _context.requeueComputedKeyAndDecorators.call(path);
+      } else {
+        path.requeueComputedKeyAndDecorators();
+      }
+    }
+  },
+  Property(path) {
+    if (path.isObjectProperty()) return;
+    path.skip();
+    if (!path.requeueComputedKeyAndDecorators) {
+      _context.requeueComputedKeyAndDecorators.call(path);
+    } else {
+      path.requeueComputedKeyAndDecorators();
+    }
+  }
+};
+function environmentVisitor(visitor) {
+  return merge([_environmentVisitor, visitor]);
+}
+
+//# sourceMappingURL=visitors.js.map

node_modules/@babel/traverse/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/traverse/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/traverse/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/traverse/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/traverse/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/traverse/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/traverse/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/traverse/node_modules/@babel/generator/lib/generators/flow.js

@@ -0,0 +1,658 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AnyTypeAnnotation = AnyTypeAnnotation;
+exports.ArrayTypeAnnotation = ArrayTypeAnnotation;
+exports.BooleanLiteralTypeAnnotation = BooleanLiteralTypeAnnotation;
+exports.BooleanTypeAnnotation = BooleanTypeAnnotation;
+exports.DeclareClass = DeclareClass;
+exports.DeclareExportAllDeclaration = DeclareExportAllDeclaration;
+exports.DeclareExportDeclaration = DeclareExportDeclaration;
+exports.DeclareFunction = DeclareFunction;
+exports.DeclareInterface = DeclareInterface;
+exports.DeclareModule = DeclareModule;
+exports.DeclareModuleExports = DeclareModuleExports;
+exports.DeclareOpaqueType = DeclareOpaqueType;
+exports.DeclareTypeAlias = DeclareTypeAlias;
+exports.DeclareVariable = DeclareVariable;
+exports.DeclaredPredicate = DeclaredPredicate;
+exports.EmptyTypeAnnotation = EmptyTypeAnnotation;
+exports.EnumBooleanBody = EnumBooleanBody;
+exports.EnumBooleanMember = EnumBooleanMember;
+exports.EnumDeclaration = EnumDeclaration;
+exports.EnumDefaultedMember = EnumDefaultedMember;
+exports.EnumNumberBody = EnumNumberBody;
+exports.EnumNumberMember = EnumNumberMember;
+exports.EnumStringBody = EnumStringBody;
+exports.EnumStringMember = EnumStringMember;
+exports.EnumSymbolBody = EnumSymbolBody;
+exports.ExistsTypeAnnotation = ExistsTypeAnnotation;
+exports.FunctionTypeAnnotation = FunctionTypeAnnotation;
+exports.FunctionTypeParam = FunctionTypeParam;
+exports.IndexedAccessType = IndexedAccessType;
+exports.InferredPredicate = InferredPredicate;
+exports.InterfaceDeclaration = InterfaceDeclaration;
+exports.GenericTypeAnnotation = exports.ClassImplements = exports.InterfaceExtends = InterfaceExtends;
+exports.InterfaceTypeAnnotation = InterfaceTypeAnnotation;
+exports.IntersectionTypeAnnotation = IntersectionTypeAnnotation;
+exports.MixedTypeAnnotation = MixedTypeAnnotation;
+exports.NullLiteralTypeAnnotation = NullLiteralTypeAnnotation;
+exports.NullableTypeAnnotation = NullableTypeAnnotation;
+Object.defineProperty(exports, "NumberLiteralTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _types2.NumericLiteral;
+  }
+});
+exports.NumberTypeAnnotation = NumberTypeAnnotation;
+exports.ObjectTypeAnnotation = ObjectTypeAnnotation;
+exports.ObjectTypeCallProperty = ObjectTypeCallProperty;
+exports.ObjectTypeIndexer = ObjectTypeIndexer;
+exports.ObjectTypeInternalSlot = ObjectTypeInternalSlot;
+exports.ObjectTypeProperty = ObjectTypeProperty;
+exports.ObjectTypeSpreadProperty = ObjectTypeSpreadProperty;
+exports.OpaqueType = OpaqueType;
+exports.OptionalIndexedAccessType = OptionalIndexedAccessType;
+exports.QualifiedTypeIdentifier = QualifiedTypeIdentifier;
+Object.defineProperty(exports, "StringLiteralTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _types2.StringLiteral;
+  }
+});
+exports.StringTypeAnnotation = StringTypeAnnotation;
+exports.SymbolTypeAnnotation = SymbolTypeAnnotation;
+exports.ThisTypeAnnotation = ThisTypeAnnotation;
+exports.TupleTypeAnnotation = TupleTypeAnnotation;
+exports.TypeAlias = TypeAlias;
+exports.TypeAnnotation = TypeAnnotation;
+exports.TypeCastExpression = TypeCastExpression;
+exports.TypeParameter = TypeParameter;
+exports.TypeParameterDeclaration = exports.TypeParameterInstantiation = TypeParameterInstantiation;
+exports.TypeofTypeAnnotation = TypeofTypeAnnotation;
+exports.UnionTypeAnnotation = UnionTypeAnnotation;
+exports.Variance = Variance;
+exports.VoidTypeAnnotation = VoidTypeAnnotation;
+exports._interfaceish = _interfaceish;
+exports._variance = _variance;
+var _t = require("@babel/types");
+var _modules = require("./modules.js");
+var _index = require("../node/index.js");
+var _types2 = require("./types.js");
+const {
+  isDeclareExportDeclaration,
+  isStatement
+} = _t;
+function AnyTypeAnnotation() {
+  this.word("any");
+}
+function ArrayTypeAnnotation(node) {
+  this.print(node.elementType, true);
+  this.tokenChar(91);
+  this.tokenChar(93);
+}
+function BooleanTypeAnnotation() {
+  this.word("boolean");
+}
+function BooleanLiteralTypeAnnotation(node) {
+  this.word(node.value ? "true" : "false");
+}
+function NullLiteralTypeAnnotation() {
+  this.word("null");
+}
+function DeclareClass(node, parent) {
+  if (!isDeclareExportDeclaration(parent)) {
+    this.word("declare");
+    this.space();
+  }
+  this.word("class");
+  this.space();
+  _interfaceish.call(this, node);
+}
+function DeclareFunction(node, parent) {
+  if (!isDeclareExportDeclaration(parent)) {
+    this.word("declare");
+    this.space();
+  }
+  this.word("function");
+  this.space();
+  this.print(node.id);
+  this.print(node.id.typeAnnotation.typeAnnotation);
+  if (node.predicate) {
+    this.space();
+    this.print(node.predicate);
+  }
+  this.semicolon();
+}
+function InferredPredicate() {
+  this.tokenChar(37);
+  this.word("checks");
+}
+function DeclaredPredicate(node) {
+  this.tokenChar(37);
+  this.word("checks");
+  this.tokenChar(40);
+  this.print(node.value);
+  this.tokenChar(41);
+}
+function DeclareInterface(node) {
+  this.word("declare");
+  this.space();
+  InterfaceDeclaration.call(this, node);
+}
+function DeclareModule(node) {
+  this.word("declare");
+  this.space();
+  this.word("module");
+  this.space();
+  this.print(node.id);
+  this.space();
+  this.print(node.body);
+}
+function DeclareModuleExports(node) {
+  this.word("declare");
+  this.space();
+  this.word("module");
+  this.tokenChar(46);
+  this.word("exports");
+  this.print(node.typeAnnotation);
+}
+function DeclareTypeAlias(node) {
+  this.word("declare");
+  this.space();
+  TypeAlias.call(this, node);
+}
+function DeclareOpaqueType(node, parent) {
+  if (!isDeclareExportDeclaration(parent)) {
+    this.word("declare");
+    this.space();
+  }
+  OpaqueType.call(this, node);
+}
+function DeclareVariable(node, parent) {
+  if (!isDeclareExportDeclaration(parent)) {
+    this.word("declare");
+    this.space();
+  }
+  this.word("var");
+  this.space();
+  this.print(node.id);
+  this.print(node.id.typeAnnotation);
+  this.semicolon();
+}
+function DeclareExportDeclaration(node) {
+  this.word("declare");
+  this.space();
+  this.word("export");
+  this.space();
+  if (node.default) {
+    this.word("default");
+    this.space();
+  }
+  FlowExportDeclaration.call(this, node);
+}
+function DeclareExportAllDeclaration(node) {
+  this.word("declare");
+  this.space();
+  _modules.ExportAllDeclaration.call(this, node);
+}
+function EnumDeclaration(node) {
+  const {
+    id,
+    body
+  } = node;
+  this.word("enum");
+  this.space();
+  this.print(id);
+  this.print(body);
+}
+function enumExplicitType(context, name, hasExplicitType) {
+  if (hasExplicitType) {
+    context.space();
+    context.word("of");
+    context.space();
+    context.word(name);
+  }
+  context.space();
+}
+function enumBody(context, node) {
+  const {
+    members
+  } = node;
+  context.token("{");
+  context.indent();
+  context.newline();
+  for (const member of members) {
+    context.print(member);
+    context.newline();
+  }
+  if (node.hasUnknownMembers) {
+    context.token("...");
+    context.newline();
+  }
+  context.dedent();
+  context.token("}");
+}
+function EnumBooleanBody(node) {
+  const {
+    explicitType
+  } = node;
+  enumExplicitType(this, "boolean", explicitType);
+  enumBody(this, node);
+}
+function EnumNumberBody(node) {
+  const {
+    explicitType
+  } = node;
+  enumExplicitType(this, "number", explicitType);
+  enumBody(this, node);
+}
+function EnumStringBody(node) {
+  const {
+    explicitType
+  } = node;
+  enumExplicitType(this, "string", explicitType);
+  enumBody(this, node);
+}
+function EnumSymbolBody(node) {
+  enumExplicitType(this, "symbol", true);
+  enumBody(this, node);
+}
+function EnumDefaultedMember(node) {
+  const {
+    id
+  } = node;
+  this.print(id);
+  this.tokenChar(44);
+}
+function enumInitializedMember(context, node) {
+  context.print(node.id);
+  context.space();
+  context.token("=");
+  context.space();
+  context.print(node.init);
+  context.token(",");
+}
+function EnumBooleanMember(node) {
+  enumInitializedMember(this, node);
+}
+function EnumNumberMember(node) {
+  enumInitializedMember(this, node);
+}
+function EnumStringMember(node) {
+  enumInitializedMember(this, node);
+}
+function FlowExportDeclaration(node) {
+  if (node.declaration) {
+    const declar = node.declaration;
+    this.print(declar);
+    if (!isStatement(declar)) this.semicolon();
+  } else {
+    this.tokenChar(123);
+    if (node.specifiers.length) {
+      this.space();
+      this.printList(node.specifiers);
+      this.space();
+    }
+    this.tokenChar(125);
+    if (node.source) {
+      this.space();
+      this.word("from");
+      this.space();
+      this.print(node.source);
+    }
+    this.semicolon();
+  }
+}
+function ExistsTypeAnnotation() {
+  this.tokenChar(42);
+}
+function FunctionTypeAnnotation(node, parent) {
+  this.print(node.typeParameters);
+  this.tokenChar(40);
+  if (node.this) {
+    this.word("this");
+    this.tokenChar(58);
+    this.space();
+    this.print(node.this.typeAnnotation);
+    if (node.params.length || node.rest) {
+      this.tokenChar(44);
+      this.space();
+    }
+  }
+  this.printList(node.params);
+  if (node.rest) {
+    if (node.params.length) {
+      this.tokenChar(44);
+      this.space();
+    }
+    this.token("...");
+    this.print(node.rest);
+  }
+  this.tokenChar(41);
+  const type = parent == null ? void 0 : parent.type;
+  if (type != null && (type === "ObjectTypeCallProperty" || type === "ObjectTypeInternalSlot" || type === "DeclareFunction" || type === "ObjectTypeProperty" && parent.method)) {
+    this.tokenChar(58);
+  } else {
+    this.space();
+    this.token("=>");
+  }
+  this.space();
+  this.print(node.returnType);
+}
+function FunctionTypeParam(node) {
+  this.print(node.name);
+  if (node.optional) this.tokenChar(63);
+  if (node.name) {
+    this.tokenChar(58);
+    this.space();
+  }
+  this.print(node.typeAnnotation);
+}
+function InterfaceExtends(node) {
+  this.print(node.id);
+  this.print(node.typeParameters, true);
+}
+function _interfaceish(node) {
+  var _node$extends;
+  this.print(node.id);
+  this.print(node.typeParameters);
+  if ((_node$extends = node.extends) != null && _node$extends.length) {
+    this.space();
+    this.word("extends");
+    this.space();
+    this.printList(node.extends);
+  }
+  if (node.type === "DeclareClass") {
+    var _node$mixins, _node$implements;
+    if ((_node$mixins = node.mixins) != null && _node$mixins.length) {
+      this.space();
+      this.word("mixins");
+      this.space();
+      this.printList(node.mixins);
+    }
+    if ((_node$implements = node.implements) != null && _node$implements.length) {
+      this.space();
+      this.word("implements");
+      this.space();
+      this.printList(node.implements);
+    }
+  }
+  this.space();
+  this.print(node.body);
+}
+function _variance(node) {
+  var _node$variance;
+  const kind = (_node$variance = node.variance) == null ? void 0 : _node$variance.kind;
+  if (kind != null) {
+    if (kind === "plus") {
+      this.tokenChar(43);
+    } else if (kind === "minus") {
+      this.tokenChar(45);
+    }
+  }
+}
+function InterfaceDeclaration(node) {
+  this.word("interface");
+  this.space();
+  _interfaceish.call(this, node);
+}
+function andSeparator(occurrenceCount) {
+  this.space();
+  this.token("&", false, occurrenceCount);
+  this.space();
+}
+function InterfaceTypeAnnotation(node) {
+  var _node$extends2;
+  this.word("interface");
+  if ((_node$extends2 = node.extends) != null && _node$extends2.length) {
+    this.space();
+    this.word("extends");
+    this.space();
+    this.printList(node.extends);
+  }
+  this.space();
+  this.print(node.body);
+}
+function IntersectionTypeAnnotation(node) {
+  this.printJoin(node.types, undefined, undefined, andSeparator);
+}
+function MixedTypeAnnotation() {
+  this.word("mixed");
+}
+function EmptyTypeAnnotation() {
+  this.word("empty");
+}
+function NullableTypeAnnotation(node) {
+  this.tokenChar(63);
+  this.print(node.typeAnnotation);
+}
+function NumberTypeAnnotation() {
+  this.word("number");
+}
+function StringTypeAnnotation() {
+  this.word("string");
+}
+function ThisTypeAnnotation() {
+  this.word("this");
+}
+function TupleTypeAnnotation(node) {
+  this.tokenChar(91);
+  this.printList(node.types);
+  this.tokenChar(93);
+}
+function TypeofTypeAnnotation(node) {
+  this.word("typeof");
+  this.space();
+  this.print(node.argument);
+}
+function TypeAlias(node) {
+  this.word("type");
+  this.space();
+  this.print(node.id);
+  this.print(node.typeParameters);
+  this.space();
+  this.tokenChar(61);
+  this.space();
+  this.print(node.right);
+  this.semicolon();
+}
+function TypeAnnotation(node, parent) {
+  this.tokenChar(58);
+  this.space();
+  if (parent.type === "ArrowFunctionExpression") {
+    this.tokenContext |= _index.TokenContext.arrowFlowReturnType;
+  } else if (node.optional) {
+    this.tokenChar(63);
+  }
+  this.print(node.typeAnnotation);
+}
+function TypeParameterInstantiation(node) {
+  this.tokenChar(60);
+  this.printList(node.params);
+  this.tokenChar(62);
+}
+function TypeParameter(node) {
+  _variance.call(this, node);
+  this.word(node.name);
+  if (node.bound) {
+    this.print(node.bound);
+  }
+  if (node.default) {
+    this.space();
+    this.tokenChar(61);
+    this.space();
+    this.print(node.default);
+  }
+}
+function OpaqueType(node) {
+  this.word("opaque");
+  this.space();
+  this.word("type");
+  this.space();
+  this.print(node.id);
+  this.print(node.typeParameters);
+  if (node.supertype) {
+    this.tokenChar(58);
+    this.space();
+    this.print(node.supertype);
+  }
+  if (node.impltype) {
+    this.space();
+    this.tokenChar(61);
+    this.space();
+    this.print(node.impltype);
+  }
+  this.semicolon();
+}
+function ObjectTypeAnnotation(node) {
+  if (node.exact) {
+    this.token("{|");
+  } else {
+    this.tokenChar(123);
+  }
+  const props = [...node.properties, ...(node.callProperties || []), ...(node.indexers || []), ...(node.internalSlots || [])];
+  if (props.length) {
+    this.newline();
+    this.space();
+    this.printJoin(props, true, true, () => {
+      if (props.length !== 1 || node.inexact) {
+        this.tokenChar(44);
+        this.space();
+      }
+    }, true);
+    this.space();
+  }
+  if (node.inexact) {
+    this.indent();
+    this.token("...");
+    if (props.length) {
+      this.newline();
+    }
+    this.dedent();
+  }
+  if (node.exact) {
+    this.token("|}");
+  } else {
+    this.tokenChar(125);
+  }
+}
+function ObjectTypeInternalSlot(node) {
+  if (node.static) {
+    this.word("static");
+    this.space();
+  }
+  this.tokenChar(91);
+  this.tokenChar(91);
+  this.print(node.id);
+  this.tokenChar(93);
+  this.tokenChar(93);
+  if (node.optional) this.tokenChar(63);
+  if (!node.method) {
+    this.tokenChar(58);
+    this.space();
+  }
+  this.print(node.value);
+}
+function ObjectTypeCallProperty(node) {
+  if (node.static) {
+    this.word("static");
+    this.space();
+  }
+  this.print(node.value);
+}
+function ObjectTypeIndexer(node) {
+  if (node.static) {
+    this.word("static");
+    this.space();
+  }
+  _variance.call(this, node);
+  this.tokenChar(91);
+  if (node.id) {
+    this.print(node.id);
+    this.tokenChar(58);
+    this.space();
+  }
+  this.print(node.key);
+  this.tokenChar(93);
+  this.tokenChar(58);
+  this.space();
+  this.print(node.value);
+}
+function ObjectTypeProperty(node) {
+  if (node.proto) {
+    this.word("proto");
+    this.space();
+  }
+  if (node.static) {
+    this.word("static");
+    this.space();
+  }
+  if (node.kind === "get" || node.kind === "set") {
+    this.word(node.kind);
+    this.space();
+  }
+  _variance.call(this, node);
+  this.print(node.key);
+  if (node.optional) this.tokenChar(63);
+  if (!node.method) {
+    this.tokenChar(58);
+    this.space();
+  }
+  this.print(node.value);
+}
+function ObjectTypeSpreadProperty(node) {
+  this.token("...");
+  this.print(node.argument);
+}
+function QualifiedTypeIdentifier(node) {
+  this.print(node.qualification);
+  this.tokenChar(46);
+  this.print(node.id);
+}
+function SymbolTypeAnnotation() {
+  this.word("symbol");
+}
+function orSeparator(occurrenceCount) {
+  this.space();
+  this.token("|", false, occurrenceCount);
+  this.space();
+}
+function UnionTypeAnnotation(node) {
+  this.printJoin(node.types, undefined, undefined, orSeparator);
+}
+function TypeCastExpression(node) {
+  this.tokenChar(40);
+  this.print(node.expression);
+  this.print(node.typeAnnotation);
+  this.tokenChar(41);
+}
+function Variance(node) {
+  if (node.kind === "plus") {
+    this.tokenChar(43);
+  } else {
+    this.tokenChar(45);
+  }
+}
+function VoidTypeAnnotation() {
+  this.word("void");
+}
+function IndexedAccessType(node) {
+  this.print(node.objectType, true);
+  this.tokenChar(91);
+  this.print(node.indexType);
+  this.tokenChar(93);
+}
+function OptionalIndexedAccessType(node) {
+  this.print(node.objectType);
+  if (node.optional) {
+    this.token("?.");
+  }
+  this.tokenChar(91);
+  this.print(node.indexType);
+  this.tokenChar(93);
+}
+
+//# sourceMappingURL=flow.js.map

node_modules/@babel/traverse/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/traverse/node_modules/@babel/generator/lib/generators/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_templateLiterals","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get","_expressions","_statements","_classes","_methods","_modules","_types","_flow","_base","_jsx","_typescript"],"sources":["../../src/generators/index.ts"],"sourcesContent":["export * from \"./template-literals.ts\";\nexport * from \"./expressions.ts\";\nexport * from \"./statements.ts\";\nexport * from \"./classes.ts\";\nexport * from \"./methods.ts\";\nexport * from \"./modules.ts\";\nexport * from \"./types.ts\";\nexport * from \"./flow.ts\";\nexport * from \"./base.ts\";\nexport * from \"./jsx.ts\";\nexport * from \"./typescript.ts\";\n"],"mappings":";;;;;AAAA,IAAAA,iBAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,iBAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,iBAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAT,iBAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AACA,IAAAK,YAAA,GAAAT,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAO,YAAA,EAAAN,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAK,YAAA,CAAAL,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,YAAA,CAAAL,GAAA;IAAA;EAAA;AAAA;AACA,IAAAM,WAAA,GAAAV,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAQ,WAAA,EAAAP,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAM,WAAA,CAAAN,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAE,WAAA,CAAAN,GAAA;IAAA;EAAA;AAAA;AACA,IAAAO,QAAA,GAAAX,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAS,QAAA,EAAAR,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAO,QAAA,CAAAP,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAG,QAAA,CAAAP,GAAA;IAAA;EAAA;AAAA;AACA,IAAAQ,QAAA,GAAAZ,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAU,QAAA,EAAAT,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAQ,QAAA,CAAAR,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAI,QAAA,CAAAR,GAAA;IAAA;EAAA;AAAA;AACA,IAAAS,QAAA,GAAAb,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAW,QAAA,EAAAV,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAS,QAAA,CAAAT,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAK,QAAA,CAAAT,GAAA;IAAA;EAAA;AAAA;AACA,IAAAU,MAAA,GAAAd,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAY,MAAA,EAAAX,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAU,MAAA,CAAAV,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAM,MAAA,CAAAV,GAAA;IAAA;EAAA;AAAA;AACA,IAAAW,KAAA,GAAAf,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAa,KAAA,EAAAZ,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAW,KAAA,CAAAX,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAO,KAAA,CAAAX,GAAA;IAAA;EAAA;AAAA;AACA,IAAAY,KAAA,GAAAhB,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAc,KAAA,EAAAb,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAY,KAAA,CAAAZ,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAQ,KAAA,CAAAZ,GAAA;IAAA;EAAA;AAAA;AACA,IAAAa,IAAA,GAAAjB,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAe,IAAA,EAAAd,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAa,IAAA,CAAAb,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAS,IAAA,CAAAb,GAAA;IAAA;EAAA;AAAA;AACA,IAAAc,WAAA,GAAAlB,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAgB,WAAA,EAAAf,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAc,WAAA,CAAAd,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAU,WAAA,CAAAd,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}

node_modules/@babel/traverse/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/traverse/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/traverse/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/traverse/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/traverse/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/traverse/node_modules/@babel/generator/lib/generators/template-literals.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TaggedTemplateExpression","node","print","tag","typeParameters","quasi","TemplateElement","Error","_printTemplate","substitutions","quasis","partRaw","i","length","value","raw","token","tokenMap","findMatching","_catchUpTo","loc","start","TemplateLiteral","call","expressions"],"sources":["../../src/generators/template-literals.ts"],"sourcesContent":["import type Printer from \"../printer.ts\";\nimport type * as t from \"@babel/types\";\n\nexport function TaggedTemplateExpression(\n  this: Printer,\n  node: t.TaggedTemplateExpression,\n) {\n  this.print(node.tag);\n  if (process.env.BABEL_8_BREAKING) {\n    // @ts-ignore(Babel 7 vs Babel 8) Babel 8 AST\n    this.print(node.typeArguments);\n  } else {\n    // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST\n    this.print(node.typeParameters);\n  }\n  this.print(node.quasi);\n}\n\nexport function TemplateElement(this: Printer) {\n  throw new Error(\"TemplateElement printing is handled in TemplateLiteral\");\n}\n\nexport type TemplateLiteralBase = t.Node & {\n  quasis: t.TemplateElement[];\n};\n\nexport function _printTemplate<T extends t.Node>(\n  this: Printer,\n  node: TemplateLiteralBase,\n  substitutions: T[],\n) {\n  const quasis = node.quasis;\n  let partRaw = \"`\";\n  for (let i = 0; i < quasis.length - 1; i++) {\n    partRaw += quasis[i].value.raw;\n    this.token(partRaw + \"${\", true);\n    this.print(substitutions[i]);\n    partRaw = \"}\";\n\n    // In Babel 7 we have individual tokens for ${ and }, so the automatic\n    // catchup logic does not work. Manually look for those tokens.\n    if (!process.env.BABEL_8_BREAKING && this.tokenMap) {\n      const token = this.tokenMap.findMatching(node, \"}\", i);\n      if (token) this._catchUpTo(token.loc.start);\n    }\n  }\n  partRaw += quasis[quasis.length - 1].value.raw;\n  this.token(partRaw + \"`\", true);\n}\n\nexport function TemplateLiteral(this: Printer, node: t.TemplateLiteral) {\n  _printTemplate.call(this, node, node.expressions);\n}\n"],"mappings":";;;;;;;;;AAGO,SAASA,wBAAwBA,CAEtCC,IAAgC,EAChC;EACA,IAAI,CAACC,KAAK,CAACD,IAAI,CAACE,GAAG,CAAC;EAMlB,IAAI,CAACD,KAAK,CAACD,IAAI,CAACG,cAAc,CAAC;EAEjC,IAAI,CAACF,KAAK,CAACD,IAAI,CAACI,KAAK,CAAC;AACxB;AAEO,SAASC,eAAeA,CAAA,EAAgB;EAC7C,MAAM,IAAIC,KAAK,CAAC,wDAAwD,CAAC;AAC3E;AAMO,SAASC,cAAcA,CAE5BP,IAAyB,EACzBQ,aAAkB,EAClB;EACA,MAAMC,MAAM,GAAGT,IAAI,CAACS,MAAM;EAC1B,IAAIC,OAAO,GAAG,GAAG;EACjB,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,MAAM,CAACG,MAAM,GAAG,CAAC,EAAED,CAAC,EAAE,EAAE;IAC1CD,OAAO,IAAID,MAAM,CAACE,CAAC,CAAC,CAACE,KAAK,CAACC,GAAG;IAC9B,IAAI,CAACC,KAAK,CAACL,OAAO,GAAG,IAAI,EAAE,IAAI,CAAC;IAChC,IAAI,CAACT,KAAK,CAACO,aAAa,CAACG,CAAC,CAAC,CAAC;IAC5BD,OAAO,GAAG,GAAG;IAIb,IAAqC,IAAI,CAACM,QAAQ,EAAE;MAClD,MAAMD,KAAK,GAAG,IAAI,CAACC,QAAQ,CAACC,YAAY,CAACjB,IAAI,EAAE,GAAG,EAAEW,CAAC,CAAC;MACtD,IAAII,KAAK,EAAE,IAAI,CAACG,UAAU,CAACH,KAAK,CAACI,GAAG,CAACC,KAAK,CAAC;IAC7C;EACF;EACAV,OAAO,IAAID,MAAM,CAACA,MAAM,CAACG,MAAM,GAAG,CAAC,CAAC,CAACC,KAAK,CAACC,GAAG;EAC9C,IAAI,CAACC,KAAK,CAACL,OAAO,GAAG,GAAG,EAAE,IAAI,CAAC;AACjC;AAEO,SAASW,eAAeA,CAAgBrB,IAAuB,EAAE;EACtEO,cAAc,CAACe,IAAI,CAAC,IAAI,EAAEtB,IAAI,EAAEA,IAAI,CAACuB,WAAW,CAAC;AACnD","ignoreList":[]}

node_modules/@babel/traverse/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/traverse/node_modules/@babel/generator/lib/generators/typescript.js

@@ -0,0 +1,726 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TSAnyKeyword = TSAnyKeyword;
+exports.TSArrayType = TSArrayType;
+exports.TSAsExpression = TSAsExpression;
+exports.TSBigIntKeyword = TSBigIntKeyword;
+exports.TSBooleanKeyword = TSBooleanKeyword;
+exports.TSCallSignatureDeclaration = TSCallSignatureDeclaration;
+exports.TSInterfaceHeritage = exports.TSClassImplements = TSClassImplements;
+exports.TSConditionalType = TSConditionalType;
+exports.TSConstructSignatureDeclaration = TSConstructSignatureDeclaration;
+exports.TSConstructorType = TSConstructorType;
+exports.TSDeclareFunction = TSDeclareFunction;
+exports.TSDeclareMethod = TSDeclareMethod;
+exports.TSEnumBody = TSEnumBody;
+exports.TSEnumDeclaration = TSEnumDeclaration;
+exports.TSEnumMember = TSEnumMember;
+exports.TSExportAssignment = TSExportAssignment;
+exports.TSExternalModuleReference = TSExternalModuleReference;
+exports.TSFunctionType = TSFunctionType;
+exports.TSImportEqualsDeclaration = TSImportEqualsDeclaration;
+exports.TSImportType = TSImportType;
+exports.TSIndexSignature = TSIndexSignature;
+exports.TSIndexedAccessType = TSIndexedAccessType;
+exports.TSInferType = TSInferType;
+exports.TSInstantiationExpression = TSInstantiationExpression;
+exports.TSInterfaceBody = TSInterfaceBody;
+exports.TSInterfaceDeclaration = TSInterfaceDeclaration;
+exports.TSIntersectionType = TSIntersectionType;
+exports.TSIntrinsicKeyword = TSIntrinsicKeyword;
+exports.TSLiteralType = TSLiteralType;
+exports.TSMappedType = TSMappedType;
+exports.TSMethodSignature = TSMethodSignature;
+exports.TSModuleBlock = TSModuleBlock;
+exports.TSModuleDeclaration = TSModuleDeclaration;
+exports.TSNamedTupleMember = TSNamedTupleMember;
+exports.TSNamespaceExportDeclaration = TSNamespaceExportDeclaration;
+exports.TSNeverKeyword = TSNeverKeyword;
+exports.TSNonNullExpression = TSNonNullExpression;
+exports.TSNullKeyword = TSNullKeyword;
+exports.TSNumberKeyword = TSNumberKeyword;
+exports.TSObjectKeyword = TSObjectKeyword;
+exports.TSOptionalType = TSOptionalType;
+exports.TSParameterProperty = TSParameterProperty;
+exports.TSParenthesizedType = TSParenthesizedType;
+exports.TSPropertySignature = TSPropertySignature;
+exports.TSQualifiedName = TSQualifiedName;
+exports.TSRestType = TSRestType;
+exports.TSSatisfiesExpression = TSSatisfiesExpression;
+exports.TSStringKeyword = TSStringKeyword;
+exports.TSSymbolKeyword = TSSymbolKeyword;
+exports.TSTemplateLiteralType = TSTemplateLiteralType;
+exports.TSThisType = TSThisType;
+exports.TSTupleType = TSTupleType;
+exports.TSTypeAliasDeclaration = TSTypeAliasDeclaration;
+exports.TSTypeAnnotation = TSTypeAnnotation;
+exports.TSTypeAssertion = TSTypeAssertion;
+exports.TSTypeLiteral = TSTypeLiteral;
+exports.TSTypeOperator = TSTypeOperator;
+exports.TSTypeParameter = TSTypeParameter;
+exports.TSTypeParameterDeclaration = exports.TSTypeParameterInstantiation = TSTypeParameterInstantiation;
+exports.TSTypePredicate = TSTypePredicate;
+exports.TSTypeQuery = TSTypeQuery;
+exports.TSTypeReference = TSTypeReference;
+exports.TSUndefinedKeyword = TSUndefinedKeyword;
+exports.TSUnionType = TSUnionType;
+exports.TSUnknownKeyword = TSUnknownKeyword;
+exports.TSVoidKeyword = TSVoidKeyword;
+exports._tsPrintClassMemberModifiers = _tsPrintClassMemberModifiers;
+var _methods = require("./methods.js");
+var _classes = require("./classes.js");
+var _templateLiterals = require("./template-literals.js");
+function TSTypeAnnotation(node, parent) {
+  this.token((parent.type === "TSFunctionType" || parent.type === "TSConstructorType") && parent.typeAnnotation === node ? "=>" : ":");
+  this.space();
+  if (node.optional) this.tokenChar(63);
+  this.print(node.typeAnnotation);
+}
+function TSTypeParameterInstantiation(node, parent) {
+  this.tokenChar(60);
+  let printTrailingSeparator = parent.type === "ArrowFunctionExpression" && node.params.length === 1;
+  if (this.tokenMap && node.start != null && node.end != null) {
+    printTrailingSeparator && (printTrailingSeparator = !!this.tokenMap.find(node, t => this.tokenMap.matchesOriginal(t, ",")));
+    printTrailingSeparator || (printTrailingSeparator = this.shouldPrintTrailingComma(">"));
+  }
+  this.printList(node.params, printTrailingSeparator);
+  this.tokenChar(62);
+}
+function TSTypeParameter(node) {
+  if (node.const) {
+    this.word("const");
+    this.space();
+  }
+  if (node.in) {
+    this.word("in");
+    this.space();
+  }
+  if (node.out) {
+    this.word("out");
+    this.space();
+  }
+  this.word(node.name);
+  if (node.constraint) {
+    this.space();
+    this.word("extends");
+    this.space();
+    this.print(node.constraint);
+  }
+  if (node.default) {
+    this.space();
+    this.tokenChar(61);
+    this.space();
+    this.print(node.default);
+  }
+}
+function TSParameterProperty(node) {
+  if (node.accessibility) {
+    this.word(node.accessibility);
+    this.space();
+  }
+  if (node.readonly) {
+    this.word("readonly");
+    this.space();
+  }
+  _methods._param.call(this, node.parameter);
+}
+function TSDeclareFunction(node, parent) {
+  if (node.declare) {
+    this.word("declare");
+    this.space();
+  }
+  _methods._functionHead.call(this, node, parent, false);
+  this.semicolon();
+}
+function TSDeclareMethod(node) {
+  _classes._classMethodHead.call(this, node);
+  this.semicolon();
+}
+function TSQualifiedName(node) {
+  this.print(node.left);
+  this.tokenChar(46);
+  this.print(node.right);
+}
+function TSCallSignatureDeclaration(node) {
+  tsPrintSignatureDeclarationBase.call(this, node);
+  maybePrintTrailingCommaOrSemicolon(this, node);
+}
+function maybePrintTrailingCommaOrSemicolon(printer, node) {
+  if (!printer.tokenMap || !node.start || !node.end) {
+    printer.semicolon();
+    return;
+  }
+  if (printer.tokenMap.endMatches(node, ",")) {
+    printer.token(",");
+  } else if (printer.tokenMap.endMatches(node, ";")) {
+    printer.semicolon();
+  }
+}
+function TSConstructSignatureDeclaration(node) {
+  this.word("new");
+  this.space();
+  tsPrintSignatureDeclarationBase.call(this, node);
+  maybePrintTrailingCommaOrSemicolon(this, node);
+}
+function TSPropertySignature(node) {
+  const {
+    readonly
+  } = node;
+  if (readonly) {
+    this.word("readonly");
+    this.space();
+  }
+  tsPrintPropertyOrMethodName.call(this, node);
+  this.print(node.typeAnnotation);
+  maybePrintTrailingCommaOrSemicolon(this, node);
+}
+function tsPrintPropertyOrMethodName(node) {
+  if (node.computed) {
+    this.tokenChar(91);
+  }
+  this.print(node.key);
+  if (node.computed) {
+    this.tokenChar(93);
+  }
+  if (node.optional) {
+    this.tokenChar(63);
+  }
+}
+function TSMethodSignature(node) {
+  const {
+    kind
+  } = node;
+  if (kind === "set" || kind === "get") {
+    this.word(kind);
+    this.space();
+  }
+  tsPrintPropertyOrMethodName.call(this, node);
+  tsPrintSignatureDeclarationBase.call(this, node);
+  maybePrintTrailingCommaOrSemicolon(this, node);
+}
+function TSIndexSignature(node) {
+  const {
+    readonly,
+    static: isStatic
+  } = node;
+  if (isStatic) {
+    this.word("static");
+    this.space();
+  }
+  if (readonly) {
+    this.word("readonly");
+    this.space();
+  }
+  this.tokenChar(91);
+  _methods._parameters.call(this, node.parameters, 93);
+  this.print(node.typeAnnotation);
+  maybePrintTrailingCommaOrSemicolon(this, node);
+}
+function TSAnyKeyword() {
+  this.word("any");
+}
+function TSBigIntKeyword() {
+  this.word("bigint");
+}
+function TSUnknownKeyword() {
+  this.word("unknown");
+}
+function TSNumberKeyword() {
+  this.word("number");
+}
+function TSObjectKeyword() {
+  this.word("object");
+}
+function TSBooleanKeyword() {
+  this.word("boolean");
+}
+function TSStringKeyword() {
+  this.word("string");
+}
+function TSSymbolKeyword() {
+  this.word("symbol");
+}
+function TSVoidKeyword() {
+  this.word("void");
+}
+function TSUndefinedKeyword() {
+  this.word("undefined");
+}
+function TSNullKeyword() {
+  this.word("null");
+}
+function TSNeverKeyword() {
+  this.word("never");
+}
+function TSIntrinsicKeyword() {
+  this.word("intrinsic");
+}
+function TSThisType() {
+  this.word("this");
+}
+function TSFunctionType(node) {
+  tsPrintFunctionOrConstructorType.call(this, node);
+}
+function TSConstructorType(node) {
+  if (node.abstract) {
+    this.word("abstract");
+    this.space();
+  }
+  this.word("new");
+  this.space();
+  tsPrintFunctionOrConstructorType.call(this, node);
+}
+function tsPrintFunctionOrConstructorType(node) {
+  const {
+    typeParameters
+  } = node;
+  const parameters = node.parameters;
+  this.print(typeParameters);
+  this.tokenChar(40);
+  _methods._parameters.call(this, parameters, 41);
+  this.space();
+  const returnType = node.typeAnnotation;
+  this.print(returnType);
+}
+function TSTypeReference(node) {
+  const typeArguments = node.typeParameters;
+  this.print(node.typeName, !!typeArguments);
+  this.print(typeArguments);
+}
+function TSTypePredicate(node) {
+  if (node.asserts) {
+    this.word("asserts");
+    this.space();
+  }
+  this.print(node.parameterName);
+  if (node.typeAnnotation) {
+    this.space();
+    this.word("is");
+    this.space();
+    this.print(node.typeAnnotation.typeAnnotation);
+  }
+}
+function TSTypeQuery(node) {
+  this.word("typeof");
+  this.space();
+  this.print(node.exprName);
+  const typeArguments = node.typeParameters;
+  if (typeArguments) {
+    this.print(typeArguments);
+  }
+}
+function TSTypeLiteral(node) {
+  printBraced(this, node, () => this.printJoin(node.members, true, true, undefined, undefined, true));
+}
+function TSArrayType(node) {
+  this.print(node.elementType, true);
+  this.tokenChar(91);
+  this.tokenChar(93);
+}
+function TSTupleType(node) {
+  this.tokenChar(91);
+  this.printList(node.elementTypes, this.shouldPrintTrailingComma("]"));
+  this.tokenChar(93);
+}
+function TSOptionalType(node) {
+  this.print(node.typeAnnotation);
+  this.tokenChar(63);
+}
+function TSRestType(node) {
+  this.token("...");
+  this.print(node.typeAnnotation);
+}
+function TSNamedTupleMember(node) {
+  this.print(node.label);
+  if (node.optional) this.tokenChar(63);
+  this.tokenChar(58);
+  this.space();
+  this.print(node.elementType);
+}
+function TSUnionType(node) {
+  tsPrintUnionOrIntersectionType(this, node, "|");
+}
+function TSIntersectionType(node) {
+  tsPrintUnionOrIntersectionType(this, node, "&");
+}
+function tsPrintUnionOrIntersectionType(printer, node, sep) {
+  var _printer$tokenMap;
+  let hasLeadingToken = 0;
+  if ((_printer$tokenMap = printer.tokenMap) != null && _printer$tokenMap.startMatches(node, sep)) {
+    hasLeadingToken = 1;
+    printer.token(sep);
+  }
+  printer.printJoin(node.types, undefined, undefined, function (i) {
+    this.space();
+    this.token(sep, undefined, i + hasLeadingToken);
+    this.space();
+  });
+}
+function TSConditionalType(node) {
+  this.print(node.checkType);
+  this.space();
+  this.word("extends");
+  this.space();
+  this.print(node.extendsType);
+  this.space();
+  this.tokenChar(63);
+  this.space();
+  this.print(node.trueType);
+  this.space();
+  this.tokenChar(58);
+  this.space();
+  this.print(node.falseType);
+}
+function TSInferType(node) {
+  this.word("infer");
+  this.print(node.typeParameter);
+}
+function TSParenthesizedType(node) {
+  this.tokenChar(40);
+  this.print(node.typeAnnotation);
+  this.tokenChar(41);
+}
+function TSTypeOperator(node) {
+  this.word(node.operator);
+  this.space();
+  this.print(node.typeAnnotation);
+}
+function TSIndexedAccessType(node) {
+  this.print(node.objectType, true);
+  this.tokenChar(91);
+  this.print(node.indexType);
+  this.tokenChar(93);
+}
+function TSMappedType(node) {
+  const {
+    nameType,
+    optional,
+    readonly,
+    typeAnnotation
+  } = node;
+  this.tokenChar(123);
+  const oldNoLineTerminatorAfterNode = this.enterDelimited();
+  this.space();
+  if (readonly) {
+    tokenIfPlusMinus(this, readonly);
+    this.word("readonly");
+    this.space();
+  }
+  this.tokenChar(91);
+  this.word(node.typeParameter.name);
+  this.space();
+  this.word("in");
+  this.space();
+  this.print(node.typeParameter.constraint, undefined, true);
+  if (nameType) {
+    this.space();
+    this.word("as");
+    this.space();
+    this.print(nameType, undefined, true);
+  }
+  this.tokenChar(93);
+  if (optional) {
+    tokenIfPlusMinus(this, optional);
+    this.tokenChar(63);
+  }
+  if (typeAnnotation) {
+    this.tokenChar(58);
+    this.space();
+    this.print(typeAnnotation, undefined, true);
+  }
+  this.space();
+  this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+  this.tokenChar(125);
+}
+function tokenIfPlusMinus(self, tok) {
+  if (tok !== true) {
+    self.token(tok);
+  }
+}
+function TSTemplateLiteralType(node) {
+  _templateLiterals._printTemplate.call(this, node, node.types);
+}
+function TSLiteralType(node) {
+  this.print(node.literal);
+}
+function TSClassImplements(node) {
+  this.print(node.expression);
+  this.print(node.typeArguments);
+}
+function TSInterfaceDeclaration(node) {
+  const {
+    declare,
+    id,
+    typeParameters,
+    extends: extendz,
+    body
+  } = node;
+  if (declare) {
+    this.word("declare");
+    this.space();
+  }
+  this.word("interface");
+  this.space();
+  this.print(id);
+  this.print(typeParameters);
+  if (extendz != null && extendz.length) {
+    this.space();
+    this.word("extends");
+    this.space();
+    this.printList(extendz);
+  }
+  this.space();
+  this.print(body);
+}
+function TSInterfaceBody(node) {
+  printBraced(this, node, () => this.printJoin(node.body, true, true, undefined, undefined, true));
+}
+function TSTypeAliasDeclaration(node) {
+  const {
+    declare,
+    id,
+    typeParameters,
+    typeAnnotation
+  } = node;
+  if (declare) {
+    this.word("declare");
+    this.space();
+  }
+  this.word("type");
+  this.space();
+  this.print(id);
+  this.print(typeParameters);
+  this.space();
+  this.tokenChar(61);
+  this.space();
+  this.print(typeAnnotation);
+  this.semicolon();
+}
+function TSAsExpression(node) {
+  const {
+    expression,
+    typeAnnotation
+  } = node;
+  this.print(expression, true);
+  this.space();
+  this.word("as");
+  this.space();
+  this.print(typeAnnotation);
+}
+function TSSatisfiesExpression(node) {
+  const {
+    expression,
+    typeAnnotation
+  } = node;
+  this.print(expression, true);
+  this.space();
+  this.word("satisfies");
+  this.space();
+  this.print(typeAnnotation);
+}
+function TSTypeAssertion(node) {
+  const {
+    typeAnnotation,
+    expression
+  } = node;
+  this.tokenChar(60);
+  this.print(typeAnnotation);
+  this.tokenChar(62);
+  this.space();
+  this.print(expression);
+}
+function TSInstantiationExpression(node) {
+  this.print(node.expression);
+  this.print(node.typeParameters);
+}
+function TSEnumDeclaration(node) {
+  const {
+    declare,
+    const: isConst,
+    id
+  } = node;
+  if (declare) {
+    this.word("declare");
+    this.space();
+  }
+  if (isConst) {
+    this.word("const");
+    this.space();
+  }
+  this.word("enum");
+  this.space();
+  this.print(id);
+  this.space();
+  TSEnumBody.call(this, node);
+}
+function TSEnumBody(node) {
+  printBraced(this, node, () => {
+    var _this$shouldPrintTrai;
+    return this.printList(node.members, (_this$shouldPrintTrai = this.shouldPrintTrailingComma("}")) != null ? _this$shouldPrintTrai : true, true, true, undefined, true);
+  });
+}
+function TSEnumMember(node) {
+  const {
+    id,
+    initializer
+  } = node;
+  this.print(id);
+  if (initializer) {
+    this.space();
+    this.tokenChar(61);
+    this.space();
+    this.print(initializer);
+  }
+}
+function TSModuleDeclaration(node) {
+  const {
+    declare,
+    id,
+    kind
+  } = node;
+  if (declare) {
+    this.word("declare");
+    this.space();
+  }
+  if (!node.global) {
+    this.word(kind != null ? kind : id.type === "Identifier" ? "namespace" : "module");
+    this.space();
+  }
+  this.print(id);
+  if (!node.body) {
+    this.semicolon();
+    return;
+  }
+  let body = node.body;
+  while (body.type === "TSModuleDeclaration") {
+    this.tokenChar(46);
+    this.print(body.id);
+    body = body.body;
+  }
+  this.space();
+  this.print(body);
+}
+function TSModuleBlock(node) {
+  printBraced(this, node, () => this.printSequence(node.body, true, true));
+}
+function TSImportType(node) {
+  const {
+    qualifier,
+    options
+  } = node;
+  this.word("import");
+  this.tokenChar(40);
+  this.print(node.argument);
+  if (options) {
+    this.tokenChar(44);
+    this.print(options);
+  }
+  this.tokenChar(41);
+  if (qualifier) {
+    this.tokenChar(46);
+    this.print(qualifier);
+  }
+  const typeArguments = node.typeParameters;
+  if (typeArguments) {
+    this.print(typeArguments);
+  }
+}
+function TSImportEqualsDeclaration(node) {
+  const {
+    id,
+    moduleReference
+  } = node;
+  if (node.isExport) {
+    this.word("export");
+    this.space();
+  }
+  this.word("import");
+  this.space();
+  this.print(id);
+  this.space();
+  this.tokenChar(61);
+  this.space();
+  this.print(moduleReference);
+  this.semicolon();
+}
+function TSExternalModuleReference(node) {
+  this.token("require(");
+  this.print(node.expression);
+  this.tokenChar(41);
+}
+function TSNonNullExpression(node) {
+  this.print(node.expression);
+  this.tokenChar(33);
+  this.setLastChar(33);
+}
+function TSExportAssignment(node) {
+  this.word("export");
+  this.space();
+  this.tokenChar(61);
+  this.space();
+  this.print(node.expression);
+  this.semicolon();
+}
+function TSNamespaceExportDeclaration(node) {
+  this.word("export");
+  this.space();
+  this.word("as");
+  this.space();
+  this.word("namespace");
+  this.space();
+  this.print(node.id);
+  this.semicolon();
+}
+function tsPrintSignatureDeclarationBase(node) {
+  const {
+    typeParameters
+  } = node;
+  const parameters = node.parameters;
+  this.print(typeParameters);
+  this.tokenChar(40);
+  _methods._parameters.call(this, parameters, 41);
+  const returnType = node.typeAnnotation;
+  this.print(returnType);
+}
+function _tsPrintClassMemberModifiers(node) {
+  const isPrivateField = node.type === "ClassPrivateProperty";
+  const isPublicField = node.type === "ClassAccessorProperty" || node.type === "ClassProperty";
+  printModifiersList(this, node, [isPublicField && node.declare && "declare", !isPrivateField && node.accessibility]);
+  if (node.static) {
+    this.word("static");
+    this.space();
+  }
+  printModifiersList(this, node, [!isPrivateField && node.abstract && "abstract", !isPrivateField && node.override && "override", (isPublicField || isPrivateField) && node.readonly && "readonly"]);
+}
+function printBraced(printer, node, cb) {
+  printer.token("{");
+  const oldNoLineTerminatorAfterNode = printer.enterDelimited();
+  cb();
+  printer._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+  printer.rightBrace(node);
+}
+function printModifiersList(printer, node, modifiers) {
+  var _printer$tokenMap2;
+  const modifiersSet = new Set();
+  for (const modifier of modifiers) {
+    if (modifier) modifiersSet.add(modifier);
+  }
+  (_printer$tokenMap2 = printer.tokenMap) == null || _printer$tokenMap2.find(node, tok => {
+    if (modifiersSet.has(tok.value)) {
+      printer.token(tok.value);
+      printer.space();
+      modifiersSet.delete(tok.value);
+      return modifiersSet.size === 0;
+    }
+    return false;
+  });
+  for (const modifier of modifiersSet) {
+    printer.word(modifier);
+    printer.space();
+  }
+}
+
+//# sourceMappingURL=typescript.js.map

node_modules/@babel/traverse/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/traverse/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/traverse/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/traverse/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/traverse/node_modules/@babel/generator/lib/nodes.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["generatorFunctions","require","deprecatedGeneratorFunctions","generatorInfosMap","exports","Map","index","key","Object","keys","sort","startsWith","set","undefined"],"sources":["../src/nodes.ts"],"sourcesContent":["import type * as t from \"@babel/types\";\n\nimport * as generatorFunctions from \"./generators/index.ts\";\nimport * as deprecatedGeneratorFunctions from \"./generators/deprecated.ts\";\nimport type { NodeHandler } from \"./node/index.ts\";\nimport type Printer from \"./printer.ts\";\n\ndeclare global {\n  function __node(type: t.Node[\"type\"]): number;\n}\n\nconst generatorInfosMap = new Map<\n  string,\n  [\n    (this: Printer, node: t.Node, parent?: t.Node | null) => void,\n    number,\n    NodeHandler<boolean> | undefined,\n  ]\n>();\nlet index = 0;\n\nfor (const key of Object.keys(generatorFunctions).sort() as Exclude<\n  keyof typeof generatorFunctions,\n  `_${string}`\n>[]) {\n  if (key.startsWith(\"_\")) continue;\n  generatorInfosMap.set(key, [generatorFunctions[key], index++, undefined]);\n}\nif (!process.env.BABEL_8_BREAKING) {\n  for (const key of Object.keys(\n    deprecatedGeneratorFunctions,\n  ) as (keyof typeof deprecatedGeneratorFunctions)[]) {\n    generatorInfosMap.set(key, [\n      deprecatedGeneratorFunctions[key],\n      index++,\n      undefined,\n    ]);\n  }\n}\n\nexport { generatorInfosMap };\n"],"mappings":";;;;;;AAEA,IAAAA,kBAAA,GAAAC,OAAA;AACA,IAAAC,4BAAA,GAAAD,OAAA;AAQA,MAAME,iBAAiB,GAAAC,OAAA,CAAAD,iBAAA,GAAG,IAAIE,GAAG,CAO/B,CAAC;AACH,IAAIC,KAAK,GAAG,CAAC;AAEb,KAAK,MAAMC,GAAG,IAAIC,MAAM,CAACC,IAAI,CAACT,kBAAkB,CAAC,CAACU,IAAI,CAAC,CAAC,EAGnD;EACH,IAAIH,GAAG,CAACI,UAAU,CAAC,GAAG,CAAC,EAAE;EACzBR,iBAAiB,CAACS,GAAG,CAACL,GAAG,EAAE,CAACP,kBAAkB,CAACO,GAAG,CAAC,EAAED,KAAK,EAAE,EAAEO,SAAS,CAAC,CAAC;AAC3E;AAEE,KAAK,MAAMN,GAAG,IAAIC,MAAM,CAACC,IAAI,CAC3BP,4BACF,CAAC,EAAmD;EAClDC,iBAAiB,CAACS,GAAG,CAACL,GAAG,EAAE,CACzBL,4BAA4B,CAACK,GAAG,CAAC,EACjCD,KAAK,EAAE,EACPO,SAAS,CACV,CAAC;AACJ","ignoreList":[]}