init 3

2026-03-13 19:23:37 +03:00
parent 8917f1631f
commit cc7403191a
5113 changed files with 168404 additions and 0 deletions
--- a/ATTRIBUTIONS.md
+++ b/ATTRIBUTIONS.md
@@ -0,0 +1,3 @@
+This Figma Make file includes components from [shadcn/ui](https://ui.shadcn.com/) used under [MIT license](https://github.com/shadcn-ui/ui/blob/main/LICENSE.md).
+
+This Figma Make file includes photos from [Unsplash](https://unsplash.com) used under [license](https://unsplash.com/license).
--- a/README.md
+++ b/README.md
@@ -0,0 +1,11 @@
+
+  # Одностраничный сайт профсоюза
+
+  This is a code bundle for Одностраничный сайт профсоюза. The original project is available at https://www.figma.com/design/DeVWoIGH1fexPOeg18cY6y/%D0%9E%D0%B4%D0%BD%D0%BE%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%87%D0%BD%D1%8B%D0%B9-%D1%81%D0%B0%D0%B9%D1%82-%D0%BF%D1%80%D0%BE%D1%84%D1%81%D0%BE%D1%8E%D0%B7%D0%B0.
+
+  ## Running the code
+
+  Run `npm i` to install the dependencies.
+
+  Run `npm run dev` to start the development server.
+  
--- a/guidelines/Guidelines.md
+++ b/guidelines/Guidelines.md
@@ -0,0 +1,61 @@
+**Add your own guidelines here**
+<!--
+
+System Guidelines
+
+Use this file to provide the AI with rules and guidelines you want it to follow.
+This template outlines a few examples of things you can add. You can add your own sections and format it to suit your needs
+
+TIP: More context isn't always better. It can confuse the LLM. Try and add the most important rules you need
+
+# General guidelines
+
+Any general rules you want the AI to follow.
+For example:
+
+* Only use absolute positioning when necessary. Opt for responsive and well structured layouts that use flexbox and grid by default
+* Refactor code as you go to keep code clean
+* Keep file sizes small and put helper functions and components in their own files.
+
+--------------
+
+# Design system guidelines
+Rules for how the AI should make generations look like your company's design system
+
+Additionally, if you select a design system to use in the prompt box, you can reference
+your design system's components, tokens, variables and components.
+For example:
+
+* Use a base font-size of 14px
+* Date formats should always be in the format “Jun 10”
+* The bottom toolbar should only ever have a maximum of 4 items
+* Never use the floating action button with the bottom toolbar
+* Chips should always come in sets of 3 or more
+* Don't use a dropdown if there are 2 or fewer options
+
+You can also create sub sections and add more specific details
+For example:
+
+
+## Button
+The Button component is a fundamental interactive element in our design system, designed to trigger actions or navigate
+users through the application. It provides visual feedback and clear affordances to enhance user experience.
+
+### Usage
+Buttons should be used for important actions that users need to take, such as form submissions, confirming choices,
+or initiating processes. They communicate interactivity and should have clear, action-oriented labels.
+
+### Variants
+* Primary Button
+  * Purpose : Used for the main action in a section or page
+  * Visual Style : Bold, filled with the primary brand color
+  * Usage : One primary button per section to guide users toward the most important action
+* Secondary Button
+  * Purpose : Used for alternative or supporting actions
+  * Visual Style : Outlined with the primary color, transparent background
+  * Usage : Can appear alongside a primary button for less important actions
+* Tertiary Button
+  * Purpose : Used for the least important actions
+  * Visual Style : Text-only with no border, using primary color
+  * Usage : For actions that should be available but not emphasized
+-->
--- a/index.html
+++ b/index.html
@@ -0,0 +1,15 @@
+
+  <!DOCTYPE html>
+  <html lang="en">
+    <head>
+      <meta charset="UTF-8" />
+      <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+      <title>Одностраничный сайт профсоюза</title>
+    </head>
+
+    <body>
+      <div id="root"></div>
+      <script type="module" src="/src/main.tsx"></script>
+    </body>
+  </html>
+  
--- a/node_modules/.bin/rollup
+++ b/node_modules/.bin/rollup
@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../rollup/dist/bin/rollup" "$@"
+else 
+  exec node  "$basedir/../rollup/dist/bin/rollup" "$@"
+fi
--- a/node_modules/.bin/vite
+++ b/node_modules/.bin/vite
@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../vite/bin/vite.js" "$@"
+else 
+  exec node  "$basedir/../vite/bin/vite.js" "$@"
+fi
--- a/node_modules/@babel/code-frame/lib/index.js
+++ b/node_modules/@babel/code-frame/lib/index.js
@@ -0,0 +1,217 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var picocolors = require('picocolors');
+var jsTokens = require('js-tokens');
+var helperValidatorIdentifier = require('@babel/helper-validator-identifier');
+
+function isColorSupported() {
+  return (typeof process === "object" && (process.env.FORCE_COLOR === "0" || process.env.FORCE_COLOR === "false") ? false : picocolors.isColorSupported
+  );
+}
+const compose = (f, g) => v => f(g(v));
+function buildDefs(colors) {
+  return {
+    keyword: colors.cyan,
+    capitalized: colors.yellow,
+    jsxIdentifier: colors.yellow,
+    punctuator: colors.yellow,
+    number: colors.magenta,
+    string: colors.green,
+    regex: colors.magenta,
+    comment: colors.gray,
+    invalid: compose(compose(colors.white, colors.bgRed), colors.bold),
+    gutter: colors.gray,
+    marker: compose(colors.red, colors.bold),
+    message: compose(colors.red, colors.bold),
+    reset: colors.reset
+  };
+}
+const defsOn = buildDefs(picocolors.createColors(true));
+const defsOff = buildDefs(picocolors.createColors(false));
+function getDefs(enabled) {
+  return enabled ? defsOn : defsOff;
+}
+
+const sometimesKeywords = new Set(["as", "async", "from", "get", "of", "set"]);
+const NEWLINE$1 = /\r\n|[\n\r\u2028\u2029]/;
+const BRACKET = /^[()[\]{}]$/;
+let tokenize;
+const JSX_TAG = /^[a-z][\w-]*$/i;
+const getTokenType = function (token, offset, text) {
+  if (token.type === "name") {
+    const tokenValue = token.value;
+    if (helperValidatorIdentifier.isKeyword(tokenValue) || helperValidatorIdentifier.isStrictReservedWord(tokenValue, true) || sometimesKeywords.has(tokenValue)) {
+      return "keyword";
+    }
+    if (JSX_TAG.test(tokenValue) && (text[offset - 1] === "<" || text.slice(offset - 2, offset) === "</")) {
+      return "jsxIdentifier";
+    }
+    const firstChar = String.fromCodePoint(tokenValue.codePointAt(0));
+    if (firstChar !== firstChar.toLowerCase()) {
+      return "capitalized";
+    }
+  }
+  if (token.type === "punctuator" && BRACKET.test(token.value)) {
+    return "bracket";
+  }
+  if (token.type === "invalid" && (token.value === "@" || token.value === "#")) {
+    return "punctuator";
+  }
+  return token.type;
+};
+tokenize = function* (text) {
+  let match;
+  while (match = jsTokens.default.exec(text)) {
+    const token = jsTokens.matchToToken(match);
+    yield {
+      type: getTokenType(token, match.index, text),
+      value: token.value
+    };
+  }
+};
+function highlight(text) {
+  if (text === "") return "";
+  const defs = getDefs(true);
+  let highlighted = "";
+  for (const {
+    type,
+    value
+  } of tokenize(text)) {
+    if (type in defs) {
+      highlighted += value.split(NEWLINE$1).map(str => defs[type](str)).join("\n");
+    } else {
+      highlighted += value;
+    }
+  }
+  return highlighted;
+}
+
+let deprecationWarningShown = false;
+const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+function getMarkerLines(loc, source, opts, startLineBaseZero) {
+  const startLoc = Object.assign({
+    column: 0,
+    line: -1
+  }, loc.start);
+  const endLoc = Object.assign({}, startLoc, loc.end);
+  const {
+    linesAbove = 2,
+    linesBelow = 3
+  } = opts || {};
+  const startLine = startLoc.line - startLineBaseZero;
+  const startColumn = startLoc.column;
+  const endLine = endLoc.line - startLineBaseZero;
+  const endColumn = endLoc.column;
+  let start = Math.max(startLine - (linesAbove + 1), 0);
+  let end = Math.min(source.length, endLine + linesBelow);
+  if (startLine === -1) {
+    start = 0;
+  }
+  if (endLine === -1) {
+    end = source.length;
+  }
+  const lineDiff = endLine - startLine;
+  const markerLines = {};
+  if (lineDiff) {
+    for (let i = 0; i <= lineDiff; i++) {
+      const lineNumber = i + startLine;
+      if (!startColumn) {
+        markerLines[lineNumber] = true;
+      } else if (i === 0) {
+        const sourceLength = source[lineNumber - 1].length;
+        markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
+      } else if (i === lineDiff) {
+        markerLines[lineNumber] = [0, endColumn];
+      } else {
+        const sourceLength = source[lineNumber - i].length;
+        markerLines[lineNumber] = [0, sourceLength];
+      }
+    }
+  } else {
+    if (startColumn === endColumn) {
+      if (startColumn) {
+        markerLines[startLine] = [startColumn, 0];
+      } else {
+        markerLines[startLine] = true;
+      }
+    } else {
+      markerLines[startLine] = [startColumn, endColumn - startColumn];
+    }
+  }
+  return {
+    start,
+    end,
+    markerLines
+  };
+}
+function codeFrameColumns(rawLines, loc, opts = {}) {
+  const shouldHighlight = opts.forceColor || isColorSupported() && opts.highlightCode;
+  const startLineBaseZero = (opts.startLine || 1) - 1;
+  const defs = getDefs(shouldHighlight);
+  const lines = rawLines.split(NEWLINE);
+  const {
+    start,
+    end,
+    markerLines
+  } = getMarkerLines(loc, lines, opts, startLineBaseZero);
+  const hasColumns = loc.start && typeof loc.start.column === "number";
+  const numberMaxWidth = String(end + startLineBaseZero).length;
+  const highlightedLines = shouldHighlight ? highlight(rawLines) : rawLines;
+  let frame = highlightedLines.split(NEWLINE, end).slice(start, end).map((line, index) => {
+    const number = start + 1 + index;
+    const paddedNumber = ` ${number + startLineBaseZero}`.slice(-numberMaxWidth);
+    const gutter = ` ${paddedNumber} |`;
+    const hasMarker = markerLines[number];
+    const lastMarkerLine = !markerLines[number + 1];
+    if (hasMarker) {
+      let markerLine = "";
+      if (Array.isArray(hasMarker)) {
+        const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
+        const numberOfMarkers = hasMarker[1] || 1;
+        markerLine = ["\n ", defs.gutter(gutter.replace(/\d/g, " ")), " ", markerSpacing, defs.marker("^").repeat(numberOfMarkers)].join("");
+        if (lastMarkerLine && opts.message) {
+          markerLine += " " + defs.message(opts.message);
+        }
+      }
+      return [defs.marker(">"), defs.gutter(gutter), line.length > 0 ? ` ${line}` : "", markerLine].join("");
+    } else {
+      return ` ${defs.gutter(gutter)}${line.length > 0 ? ` ${line}` : ""}`;
+    }
+  }).join("\n");
+  if (opts.message && !hasColumns) {
+    frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
+  }
+  if (shouldHighlight) {
+    return defs.reset(frame);
+  } else {
+    return frame;
+  }
+}
+function index (rawLines, lineNumber, colNumber, opts = {}) {
+  if (!deprecationWarningShown) {
+    deprecationWarningShown = true;
+    const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.";
+    if (process.emitWarning) {
+      process.emitWarning(message, "DeprecationWarning");
+    } else {
+      const deprecationError = new Error(message);
+      deprecationError.name = "DeprecationWarning";
+      console.warn(new Error(message));
+    }
+  }
+  colNumber = Math.max(colNumber, 0);
+  const location = {
+    start: {
+      column: colNumber,
+      line: lineNumber
+    }
+  };
+  return codeFrameColumns(rawLines, location, opts);
+}
+
+exports.codeFrameColumns = codeFrameColumns;
+exports.default = index;
+exports.highlight = highlight;
+//# sourceMappingURL=index.js.map
--- a/node_modules/@babel/core/lib/config/cache-contexts.js.map
+++ b/node_modules/@babel/core/lib/config/cache-contexts.js.map
@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["../../src/config/cache-contexts.ts"],"sourcesContent":["import type { ConfigContext } from \"./config-chain.ts\";\nimport type {\n  CallerMetadata,\n  TargetsListOrObject,\n} from \"./validation/options.ts\";\n\nexport type { ConfigContext as FullConfig };\n\nexport type FullPreset = {\n  targets: TargetsListOrObject;\n} & ConfigContext;\nexport type FullPlugin = {\n  assumptions: Record<string, boolean>;\n} & FullPreset;\n\n// Context not including filename since it is used in places that cannot\n// process 'ignore'/'only' and other filename-based logic.\nexport type SimpleConfig = {\n  envName: string;\n  caller: CallerMetadata | undefined;\n};\nexport type SimplePreset = {\n  targets: TargetsListOrObject;\n} & SimpleConfig;\nexport type SimplePlugin = {\n  assumptions: Record<string, boolean>;\n} & SimplePreset;\n"],"mappings":"","ignoreList":[]}
--- a/node_modules/@babel/core/lib/config/config-chain.js
+++ b/node_modules/@babel/core/lib/config/config-chain.js
@@ -0,0 +1,469 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildPresetChain = buildPresetChain;
+exports.buildPresetChainWalker = void 0;
+exports.buildRootChain = buildRootChain;
+function _path() {
+  const data = require("path");
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _debug() {
+  const data = require("debug");
+  _debug = function () {
+    return data;
+  };
+  return data;
+}
+var _options = require("./validation/options.js");
+var _patternToRegex = require("./pattern-to-regex.js");
+var _printer = require("./printer.js");
+var _rewriteStackTrace = require("../errors/rewrite-stack-trace.js");
+var _configError = require("../errors/config-error.js");
+var _index = require("./files/index.js");
+var _caching = require("./caching.js");
+var _configDescriptors = require("./config-descriptors.js");
+const debug = _debug()("babel:config:config-chain");
+function* buildPresetChain(arg, context) {
+  const chain = yield* buildPresetChainWalker(arg, context);
+  if (!chain) return null;
+  return {
+    plugins: dedupDescriptors(chain.plugins),
+    presets: dedupDescriptors(chain.presets),
+    options: chain.options.map(o => createConfigChainOptions(o)),
+    files: new Set()
+  };
+}
+const buildPresetChainWalker = exports.buildPresetChainWalker = makeChainWalker({
+  root: preset => loadPresetDescriptors(preset),
+  env: (preset, envName) => loadPresetEnvDescriptors(preset)(envName),
+  overrides: (preset, index) => loadPresetOverridesDescriptors(preset)(index),
+  overridesEnv: (preset, index, envName) => loadPresetOverridesEnvDescriptors(preset)(index)(envName),
+  createLogger: () => () => {}
+});
+const loadPresetDescriptors = (0, _caching.makeWeakCacheSync)(preset => buildRootDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors));
+const loadPresetEnvDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(envName => buildEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, envName)));
+const loadPresetOverridesDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(index => buildOverrideDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index)));
+const loadPresetOverridesEnvDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(index => (0, _caching.makeStrongCacheSync)(envName => buildOverrideEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index, envName))));
+function* buildRootChain(opts, context) {
+  let configReport, babelRcReport;
+  const programmaticLogger = new _printer.ConfigPrinter();
+  const programmaticChain = yield* loadProgrammaticChain({
+    options: opts,
+    dirname: context.cwd
+  }, context, undefined, programmaticLogger);
+  if (!programmaticChain) return null;
+  const programmaticReport = yield* programmaticLogger.output();
+  let configFile;
+  if (typeof opts.configFile === "string") {
+    configFile = yield* (0, _index.loadConfig)(opts.configFile, context.cwd, context.envName, context.caller);
+  } else if (opts.configFile !== false) {
+    configFile = yield* (0, _index.findRootConfig)(context.root, context.envName, context.caller);
+  }
+  let {
+    babelrc,
+    babelrcRoots
+  } = opts;
+  let babelrcRootsDirectory = context.cwd;
+  const configFileChain = emptyChain();
+  const configFileLogger = new _printer.ConfigPrinter();
+  if (configFile) {
+    const validatedFile = validateConfigFile(configFile);
+    const result = yield* loadFileChain(validatedFile, context, undefined, configFileLogger);
+    if (!result) return null;
+    configReport = yield* configFileLogger.output();
+    if (babelrc === undefined) {
+      babelrc = validatedFile.options.babelrc;
+    }
+    if (babelrcRoots === undefined) {
+      babelrcRootsDirectory = validatedFile.dirname;
+      babelrcRoots = validatedFile.options.babelrcRoots;
+    }
+    mergeChain(configFileChain, result);
+  }
+  let ignoreFile, babelrcFile;
+  let isIgnored = false;
+  const fileChain = emptyChain();
+  if ((babelrc === true || babelrc === undefined) && typeof context.filename === "string") {
+    const pkgData = yield* (0, _index.findPackageData)(context.filename);
+    if (pkgData && babelrcLoadEnabled(context, pkgData, babelrcRoots, babelrcRootsDirectory)) {
+      ({
+        ignore: ignoreFile,
+        config: babelrcFile
+      } = yield* (0, _index.findRelativeConfig)(pkgData, context.envName, context.caller));
+      if (ignoreFile) {
+        fileChain.files.add(ignoreFile.filepath);
+      }
+      if (ignoreFile && shouldIgnore(context, ignoreFile.ignore, null, ignoreFile.dirname)) {
+        isIgnored = true;
+      }
+      if (babelrcFile && !isIgnored) {
+        const validatedFile = validateBabelrcFile(babelrcFile);
+        const babelrcLogger = new _printer.ConfigPrinter();
+        const result = yield* loadFileChain(validatedFile, context, undefined, babelrcLogger);
+        if (!result) {
+          isIgnored = true;
+        } else {
+          babelRcReport = yield* babelrcLogger.output();
+          mergeChain(fileChain, result);
+        }
+      }
+      if (babelrcFile && isIgnored) {
+        fileChain.files.add(babelrcFile.filepath);
+      }
+    }
+  }
+  if (context.showConfig) {
+    console.log(`Babel configs on "${context.filename}" (ascending priority):\n` + [configReport, babelRcReport, programmaticReport].filter(x => !!x).join("\n\n") + "\n-----End Babel configs-----");
+  }
+  const chain = mergeChain(mergeChain(mergeChain(emptyChain(), configFileChain), fileChain), programmaticChain);
+  return {
+    plugins: isIgnored ? [] : dedupDescriptors(chain.plugins),
+    presets: isIgnored ? [] : dedupDescriptors(chain.presets),
+    options: isIgnored ? [] : chain.options.map(o => createConfigChainOptions(o)),
+    fileHandling: isIgnored ? "ignored" : "transpile",
+    ignore: ignoreFile || undefined,
+    babelrc: babelrcFile || undefined,
+    config: configFile || undefined,
+    files: chain.files
+  };
+}
+function babelrcLoadEnabled(context, pkgData, babelrcRoots, babelrcRootsDirectory) {
+  if (typeof babelrcRoots === "boolean") return babelrcRoots;
+  const absoluteRoot = context.root;
+  if (babelrcRoots === undefined) {
+    return pkgData.directories.includes(absoluteRoot);
+  }
+  let babelrcPatterns = babelrcRoots;
+  if (!Array.isArray(babelrcPatterns)) {
+    babelrcPatterns = [babelrcPatterns];
+  }
+  babelrcPatterns = babelrcPatterns.map(pat => {
+    return typeof pat === "string" ? _path().resolve(babelrcRootsDirectory, pat) : pat;
+  });
+  if (babelrcPatterns.length === 1 && babelrcPatterns[0] === absoluteRoot) {
+    return pkgData.directories.includes(absoluteRoot);
+  }
+  return babelrcPatterns.some(pat => {
+    if (typeof pat === "string") {
+      pat = (0, _patternToRegex.default)(pat, babelrcRootsDirectory);
+    }
+    return pkgData.directories.some(directory => {
+      return matchPattern(pat, babelrcRootsDirectory, directory, context);
+    });
+  });
+}
+const validateConfigFile = (0, _caching.makeWeakCacheSync)(file => ({
+  filepath: file.filepath,
+  dirname: file.dirname,
+  options: (0, _options.validate)("configfile", file.options, file.filepath)
+}));
+const validateBabelrcFile = (0, _caching.makeWeakCacheSync)(file => ({
+  filepath: file.filepath,
+  dirname: file.dirname,
+  options: (0, _options.validate)("babelrcfile", file.options, file.filepath)
+}));
+const validateExtendFile = (0, _caching.makeWeakCacheSync)(file => ({
+  filepath: file.filepath,
+  dirname: file.dirname,
+  options: (0, _options.validate)("extendsfile", file.options, file.filepath)
+}));
+const loadProgrammaticChain = makeChainWalker({
+  root: input => buildRootDescriptors(input, "base", _configDescriptors.createCachedDescriptors),
+  env: (input, envName) => buildEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, envName),
+  overrides: (input, index) => buildOverrideDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index),
+  overridesEnv: (input, index, envName) => buildOverrideEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index, envName),
+  createLogger: (input, context, baseLogger) => buildProgrammaticLogger(input, context, baseLogger)
+});
+const loadFileChainWalker = makeChainWalker({
+  root: file => loadFileDescriptors(file),
+  env: (file, envName) => loadFileEnvDescriptors(file)(envName),
+  overrides: (file, index) => loadFileOverridesDescriptors(file)(index),
+  overridesEnv: (file, index, envName) => loadFileOverridesEnvDescriptors(file)(index)(envName),
+  createLogger: (file, context, baseLogger) => buildFileLogger(file.filepath, context, baseLogger)
+});
+function* loadFileChain(input, context, files, baseLogger) {
+  const chain = yield* loadFileChainWalker(input, context, files, baseLogger);
+  chain == null || chain.files.add(input.filepath);
+  return chain;
+}
+const loadFileDescriptors = (0, _caching.makeWeakCacheSync)(file => buildRootDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors));
+const loadFileEnvDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(envName => buildEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, envName)));
+const loadFileOverridesDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(index => buildOverrideDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index)));
+const loadFileOverridesEnvDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(index => (0, _caching.makeStrongCacheSync)(envName => buildOverrideEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index, envName))));
+function buildFileLogger(filepath, context, baseLogger) {
+  if (!baseLogger) {
+    return () => {};
+  }
+  return baseLogger.configure(context.showConfig, _printer.ChainFormatter.Config, {
+    filepath
+  });
+}
+function buildRootDescriptors({
+  dirname,
+  options
+}, alias, descriptors) {
+  return descriptors(dirname, options, alias);
+}
+function buildProgrammaticLogger(_, context, baseLogger) {
+  var _context$caller;
+  if (!baseLogger) {
+    return () => {};
+  }
+  return baseLogger.configure(context.showConfig, _printer.ChainFormatter.Programmatic, {
+    callerName: (_context$caller = context.caller) == null ? void 0 : _context$caller.name
+  });
+}
+function buildEnvDescriptors({
+  dirname,
+  options
+}, alias, descriptors, envName) {
+  var _options$env;
+  const opts = (_options$env = options.env) == null ? void 0 : _options$env[envName];
+  return opts ? descriptors(dirname, opts, `${alias}.env["${envName}"]`) : null;
+}
+function buildOverrideDescriptors({
+  dirname,
+  options
+}, alias, descriptors, index) {
+  var _options$overrides;
+  const opts = (_options$overrides = options.overrides) == null ? void 0 : _options$overrides[index];
+  if (!opts) throw new Error("Assertion failure - missing override");
+  return descriptors(dirname, opts, `${alias}.overrides[${index}]`);
+}
+function buildOverrideEnvDescriptors({
+  dirname,
+  options
+}, alias, descriptors, index, envName) {
+  var _options$overrides2, _override$env;
+  const override = (_options$overrides2 = options.overrides) == null ? void 0 : _options$overrides2[index];
+  if (!override) throw new Error("Assertion failure - missing override");
+  const opts = (_override$env = override.env) == null ? void 0 : _override$env[envName];
+  return opts ? descriptors(dirname, opts, `${alias}.overrides[${index}].env["${envName}"]`) : null;
+}
+function makeChainWalker({
+  root,
+  env,
+  overrides,
+  overridesEnv,
+  createLogger
+}) {
+  return function* chainWalker(input, context, files = new Set(), baseLogger) {
+    const {
+      dirname
+    } = input;
+    const flattenedConfigs = [];
+    const rootOpts = root(input);
+    if (configIsApplicable(rootOpts, dirname, context, input.filepath)) {
+      flattenedConfigs.push({
+        config: rootOpts,
+        envName: undefined,
+        index: undefined
+      });
+      const envOpts = env(input, context.envName);
+      if (envOpts && configIsApplicable(envOpts, dirname, context, input.filepath)) {
+        flattenedConfigs.push({
+          config: envOpts,
+          envName: context.envName,
+          index: undefined
+        });
+      }
+      (rootOpts.options.overrides || []).forEach((_, index) => {
+        const overrideOps = overrides(input, index);
+        if (configIsApplicable(overrideOps, dirname, context, input.filepath)) {
+          flattenedConfigs.push({
+            config: overrideOps,
+            index,
+            envName: undefined
+          });
+          const overrideEnvOpts = overridesEnv(input, index, context.envName);
+          if (overrideEnvOpts && configIsApplicable(overrideEnvOpts, dirname, context, input.filepath)) {
+            flattenedConfigs.push({
+              config: overrideEnvOpts,
+              index,
+              envName: context.envName
+            });
+          }
+        }
+      });
+    }
+    if (flattenedConfigs.some(({
+      config: {
+        options: {
+          ignore,
+          only
+        }
+      }
+    }) => shouldIgnore(context, ignore, only, dirname))) {
+      return null;
+    }
+    const chain = emptyChain();
+    const logger = createLogger(input, context, baseLogger);
+    for (const {
+      config,
+      index,
+      envName
+    } of flattenedConfigs) {
+      if (!(yield* mergeExtendsChain(chain, config.options, dirname, context, files, baseLogger))) {
+        return null;
+      }
+      logger(config, index, envName);
+      yield* mergeChainOpts(chain, config);
+    }
+    return chain;
+  };
+}
+function* mergeExtendsChain(chain, opts, dirname, context, files, baseLogger) {
+  if (opts.extends === undefined) return true;
+  const file = yield* (0, _index.loadConfig)(opts.extends, dirname, context.envName, context.caller);
+  if (files.has(file)) {
+    throw new Error(`Configuration cycle detected loading ${file.filepath}.\n` + `File already loaded following the config chain:\n` + Array.from(files, file => ` - ${file.filepath}`).join("\n"));
+  }
+  files.add(file);
+  const fileChain = yield* loadFileChain(validateExtendFile(file), context, files, baseLogger);
+  files.delete(file);
+  if (!fileChain) return false;
+  mergeChain(chain, fileChain);
+  return true;
+}
+function mergeChain(target, source) {
+  target.options.push(...source.options);
+  target.plugins.push(...source.plugins);
+  target.presets.push(...source.presets);
+  for (const file of source.files) {
+    target.files.add(file);
+  }
+  return target;
+}
+function* mergeChainOpts(target, {
+  options,
+  plugins,
+  presets
+}) {
+  target.options.push(options);
+  target.plugins.push(...(yield* plugins()));
+  target.presets.push(...(yield* presets()));
+  return target;
+}
+function emptyChain() {
+  return {
+    options: [],
+    presets: [],
+    plugins: [],
+    files: new Set()
+  };
+}
+function createConfigChainOptions(opts) {
+  const options = Object.assign({}, opts);
+  delete options.extends;
+  delete options.env;
+  delete options.overrides;
+  delete options.plugins;
+  delete options.presets;
+  delete options.passPerPreset;
+  delete options.ignore;
+  delete options.only;
+  delete options.test;
+  delete options.include;
+  delete options.exclude;
+  if (hasOwnProperty.call(options, "sourceMap")) {
+    options.sourceMaps = options.sourceMap;
+    delete options.sourceMap;
+  }
+  return options;
+}
+function dedupDescriptors(items) {
+  const map = new Map();
+  const descriptors = [];
+  for (const item of items) {
+    if (typeof item.value === "function") {
+      const fnKey = item.value;
+      let nameMap = map.get(fnKey);
+      if (!nameMap) {
+        nameMap = new Map();
+        map.set(fnKey, nameMap);
+      }
+      let desc = nameMap.get(item.name);
+      if (!desc) {
+        desc = {
+          value: item
+        };
+        descriptors.push(desc);
+        if (!item.ownPass) nameMap.set(item.name, desc);
+      } else {
+        desc.value = item;
+      }
+    } else {
+      descriptors.push({
+        value: item
+      });
+    }
+  }
+  return descriptors.reduce((acc, desc) => {
+    acc.push(desc.value);
+    return acc;
+  }, []);
+}
+function configIsApplicable({
+  options
+}, dirname, context, configName) {
+  return (options.test === undefined || configFieldIsApplicable(context, options.test, dirname, configName)) && (options.include === undefined || configFieldIsApplicable(context, options.include, dirname, configName)) && (options.exclude === undefined || !configFieldIsApplicable(context, options.exclude, dirname, configName));
+}
+function configFieldIsApplicable(context, test, dirname, configName) {
+  const patterns = Array.isArray(test) ? test : [test];
+  return matchesPatterns(context, patterns, dirname, configName);
+}
+function ignoreListReplacer(_key, value) {
+  if (value instanceof RegExp) {
+    return String(value);
+  }
+  return value;
+}
+function shouldIgnore(context, ignore, only, dirname) {
+  if (ignore && matchesPatterns(context, ignore, dirname)) {
+    var _context$filename;
+    const message = `No config is applied to "${(_context$filename = context.filename) != null ? _context$filename : "(unknown)"}" because it matches one of \`ignore: ${JSON.stringify(ignore, ignoreListReplacer)}\` from "${dirname}"`;
+    debug(message);
+    if (context.showConfig) {
+      console.log(message);
+    }
+    return true;
+  }
+  if (only && !matchesPatterns(context, only, dirname)) {
+    var _context$filename2;
+    const message = `No config is applied to "${(_context$filename2 = context.filename) != null ? _context$filename2 : "(unknown)"}" because it fails to match one of \`only: ${JSON.stringify(only, ignoreListReplacer)}\` from "${dirname}"`;
+    debug(message);
+    if (context.showConfig) {
+      console.log(message);
+    }
+    return true;
+  }
+  return false;
+}
+function matchesPatterns(context, patterns, dirname, configName) {
+  return patterns.some(pattern => matchPattern(pattern, dirname, context.filename, context, configName));
+}
+function matchPattern(pattern, dirname, pathToTest, context, configName) {
+  if (typeof pattern === "function") {
+    return !!(0, _rewriteStackTrace.endHiddenCallStack)(pattern)(pathToTest, {
+      dirname,
+      envName: context.envName,
+      caller: context.caller
+    });
+  }
+  if (typeof pathToTest !== "string") {
+    throw new _configError.default(`Configuration contains string/RegExp pattern, but no filename was passed to Babel`, configName);
+  }
+  if (typeof pattern === "string") {
+    pattern = (0, _patternToRegex.default)(pattern, dirname);
+  }
+  return pattern.test(pathToTest);
+}
+0 && 0;
+
+//# sourceMappingURL=config-chain.js.map
--- a/node_modules/@babel/core/lib/config/files/plugins.js
+++ b/node_modules/@babel/core/lib/config/files/plugins.js
@@ -0,0 +1,220 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadPlugin = loadPlugin;
+exports.loadPreset = loadPreset;
+exports.resolvePreset = exports.resolvePlugin = void 0;
+function _debug() {
+  const data = require("debug");
+  _debug = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = require("path");
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+var _async = require("../../gensync-utils/async.js");
+var _moduleTypes = require("./module-types.js");
+function _url() {
+  const data = require("url");
+  _url = function () {
+    return data;
+  };
+  return data;
+}
+var _importMetaResolve = require("../../vendor/import-meta-resolve.js");
+require("module");
+function _fs() {
+  const data = require("fs");
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+const debug = _debug()("babel:config:loading:files:plugins");
+const EXACT_RE = /^module:/;
+const BABEL_PLUGIN_PREFIX_RE = /^(?!@|module:|[^/]+\/|babel-plugin-)/;
+const BABEL_PRESET_PREFIX_RE = /^(?!@|module:|[^/]+\/|babel-preset-)/;
+const BABEL_PLUGIN_ORG_RE = /^(@babel\/)(?!plugin-|[^/]+\/)/;
+const BABEL_PRESET_ORG_RE = /^(@babel\/)(?!preset-|[^/]+\/)/;
+const OTHER_PLUGIN_ORG_RE = /^(@(?!babel\/)[^/]+\/)(?![^/]*babel-plugin(?:-|\/|$)|[^/]+\/)/;
+const OTHER_PRESET_ORG_RE = /^(@(?!babel\/)[^/]+\/)(?![^/]*babel-preset(?:-|\/|$)|[^/]+\/)/;
+const OTHER_ORG_DEFAULT_RE = /^(@(?!babel$)[^/]+)$/;
+const resolvePlugin = exports.resolvePlugin = resolveStandardizedName.bind(null, "plugin");
+const resolvePreset = exports.resolvePreset = resolveStandardizedName.bind(null, "preset");
+function* loadPlugin(name, dirname) {
+  const {
+    filepath,
+    loader
+  } = resolvePlugin(name, dirname, yield* (0, _async.isAsync)());
+  const value = yield* requireModule("plugin", loader, filepath);
+  debug("Loaded plugin %o from %o.", name, dirname);
+  return {
+    filepath,
+    value
+  };
+}
+function* loadPreset(name, dirname) {
+  const {
+    filepath,
+    loader
+  } = resolvePreset(name, dirname, yield* (0, _async.isAsync)());
+  const value = yield* requireModule("preset", loader, filepath);
+  debug("Loaded preset %o from %o.", name, dirname);
+  return {
+    filepath,
+    value
+  };
+}
+function standardizeName(type, name) {
+  if (_path().isAbsolute(name)) return name;
+  const isPreset = type === "preset";
+  return name.replace(isPreset ? BABEL_PRESET_PREFIX_RE : BABEL_PLUGIN_PREFIX_RE, `babel-${type}-`).replace(isPreset ? BABEL_PRESET_ORG_RE : BABEL_PLUGIN_ORG_RE, `$1${type}-`).replace(isPreset ? OTHER_PRESET_ORG_RE : OTHER_PLUGIN_ORG_RE, `$1babel-${type}-`).replace(OTHER_ORG_DEFAULT_RE, `$1/babel-${type}`).replace(EXACT_RE, "");
+}
+function* resolveAlternativesHelper(type, name) {
+  const standardizedName = standardizeName(type, name);
+  const {
+    error,
+    value
+  } = yield standardizedName;
+  if (!error) return value;
+  if (error.code !== "MODULE_NOT_FOUND") throw error;
+  if (standardizedName !== name && !(yield name).error) {
+    error.message += `\n- If you want to resolve "${name}", use "module:${name}"`;
+  }
+  if (!(yield standardizeName(type, "@babel/" + name)).error) {
+    error.message += `\n- Did you mean "@babel/${name}"?`;
+  }
+  const oppositeType = type === "preset" ? "plugin" : "preset";
+  if (!(yield standardizeName(oppositeType, name)).error) {
+    error.message += `\n- Did you accidentally pass a ${oppositeType} as a ${type}?`;
+  }
+  if (type === "plugin") {
+    const transformName = standardizedName.replace("-proposal-", "-transform-");
+    if (transformName !== standardizedName && !(yield transformName).error) {
+      error.message += `\n- Did you mean "${transformName}"?`;
+    }
+  }
+  error.message += `\n
+Make sure that all the Babel plugins and presets you are using
+are defined as dependencies or devDependencies in your package.json
+file. It's possible that the missing plugin is loaded by a preset
+you are using that forgot to add the plugin to its dependencies: you
+can workaround this problem by explicitly adding the missing package
+to your top-level package.json.
+`;
+  throw error;
+}
+function tryRequireResolve(id, dirname) {
+  try {
+    if (dirname) {
+      return {
+        error: null,
+        value: (((v, w) => (v = v.split("."), w = w.split("."), +v[0] > +w[0] || v[0] == w[0] && +v[1] >= +w[1]))(process.versions.node, "8.9") ? require.resolve : (r, {
+          paths: [b]
+        }, M = require("module")) => {
+          let f = M._findPath(r, M._nodeModulePaths(b).concat(b));
+          if (f) return f;
+          f = new Error(`Cannot resolve module '${r}'`);
+          f.code = "MODULE_NOT_FOUND";
+          throw f;
+        })(id, {
+          paths: [dirname]
+        })
+      };
+    } else {
+      return {
+        error: null,
+        value: require.resolve(id)
+      };
+    }
+  } catch (error) {
+    return {
+      error,
+      value: null
+    };
+  }
+}
+function tryImportMetaResolve(id, options) {
+  try {
+    return {
+      error: null,
+      value: (0, _importMetaResolve.resolve)(id, options)
+    };
+  } catch (error) {
+    return {
+      error,
+      value: null
+    };
+  }
+}
+function resolveStandardizedNameForRequire(type, name, dirname) {
+  const it = resolveAlternativesHelper(type, name);
+  let res = it.next();
+  while (!res.done) {
+    res = it.next(tryRequireResolve(res.value, dirname));
+  }
+  return {
+    loader: "require",
+    filepath: res.value
+  };
+}
+function resolveStandardizedNameForImport(type, name, dirname) {
+  const parentUrl = (0, _url().pathToFileURL)(_path().join(dirname, "./babel-virtual-resolve-base.js")).href;
+  const it = resolveAlternativesHelper(type, name);
+  let res = it.next();
+  while (!res.done) {
+    res = it.next(tryImportMetaResolve(res.value, parentUrl));
+  }
+  return {
+    loader: "auto",
+    filepath: (0, _url().fileURLToPath)(res.value)
+  };
+}
+function resolveStandardizedName(type, name, dirname, allowAsync) {
+  if (!_moduleTypes.supportsESM || !allowAsync) {
+    return resolveStandardizedNameForRequire(type, name, dirname);
+  }
+  try {
+    const resolved = resolveStandardizedNameForImport(type, name, dirname);
+    if (!(0, _fs().existsSync)(resolved.filepath)) {
+      throw Object.assign(new Error(`Could not resolve "${name}" in file ${dirname}.`), {
+        type: "MODULE_NOT_FOUND"
+      });
+    }
+    return resolved;
+  } catch (e) {
+    try {
+      return resolveStandardizedNameForRequire(type, name, dirname);
+    } catch (e2) {
+      if (e.type === "MODULE_NOT_FOUND") throw e;
+      if (e2.type === "MODULE_NOT_FOUND") throw e2;
+      throw e;
+    }
+  }
+}
+var LOADING_MODULES = new Set();
+function* requireModule(type, loader, name) {
+  if (!(yield* (0, _async.isAsync)()) && LOADING_MODULES.has(name)) {
+    throw new Error(`Reentrant ${type} detected trying to load "${name}". This module is not ignored ` + "and is trying to load itself while compiling itself, leading to a dependency cycle. " + 'We recommend adding it to your "ignore" list in your babelrc, or to a .babelignore.');
+  }
+  try {
+    LOADING_MODULES.add(name);
+    return yield* (0, _moduleTypes.default)(name, loader, `You appear to be using a native ECMAScript module ${type}, ` + "which is only supported when running Babel asynchronously " + "or when using the Node.js `--experimental-require-module` flag.", `You appear to be using a ${type} that contains top-level await, ` + "which is only supported when running Babel asynchronously.", true);
+  } catch (err) {
+    err.message = `[BABEL]: ${err.message} (While processing: ${name})`;
+    throw err;
+  } finally {
+    LOADING_MODULES.delete(name);
+  }
+}
+0 && 0;
+
+//# sourceMappingURL=plugins.js.map
--- a/node_modules/@babel/core/lib/config/files/utils.js
+++ b/node_modules/@babel/core/lib/config/files/utils.js
@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeStaticFileCache = makeStaticFileCache;
+var _caching = require("../caching.js");
+var fs = require("../../gensync-utils/fs.js");
+function _fs2() {
+  const data = require("fs");
+  _fs2 = function () {
+    return data;
+  };
+  return data;
+}
+function makeStaticFileCache(fn) {
+  return (0, _caching.makeStrongCache)(function* (filepath, cache) {
+    const cached = cache.invalidate(() => fileMtime(filepath));
+    if (cached === null) {
+      return null;
+    }
+    return fn(filepath, yield* fs.readFile(filepath, "utf8"));
+  });
+}
+function fileMtime(filepath) {
+  if (!_fs2().existsSync(filepath)) return null;
+  try {
+    return +_fs2().statSync(filepath).mtime;
+  } catch (e) {
+    if (e.code !== "ENOENT" && e.code !== "ENOTDIR") throw e;
+  }
+  return null;
+}
+0 && 0;
+
+//# sourceMappingURL=utils.js.map
--- a/node_modules/@babel/core/lib/config/index.js
+++ b/node_modules/@babel/core/lib/config/index.js
@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createConfigItem = createConfigItem;
+exports.createConfigItemAsync = createConfigItemAsync;
+exports.createConfigItemSync = createConfigItemSync;
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _full.default;
+  }
+});
+exports.loadOptions = loadOptions;
+exports.loadOptionsAsync = loadOptionsAsync;
+exports.loadOptionsSync = loadOptionsSync;
+exports.loadPartialConfig = loadPartialConfig;
+exports.loadPartialConfigAsync = loadPartialConfigAsync;
+exports.loadPartialConfigSync = loadPartialConfigSync;
+function _gensync() {
+  const data = require("gensync");
+  _gensync = function () {
+    return data;
+  };
+  return data;
+}
+var _full = require("./full.js");
+var _partial = require("./partial.js");
+var _item = require("./item.js");
+var _rewriteStackTrace = require("../errors/rewrite-stack-trace.js");
+const loadPartialConfigRunner = _gensync()(_partial.loadPartialConfig);
+function loadPartialConfigAsync(...args) {
+  return (0, _rewriteStackTrace.beginHiddenCallStack)(loadPartialConfigRunner.async)(...args);
+}
+function loadPartialConfigSync(...args) {
+  return (0, _rewriteStackTrace.beginHiddenCallStack)(loadPartialConfigRunner.sync)(...args);
+}
+function loadPartialConfig(opts, callback) {
+  if (callback !== undefined) {
+    (0, _rewriteStackTrace.beginHiddenCallStack)(loadPartialConfigRunner.errback)(opts, callback);
+  } else if (typeof opts === "function") {
+    (0, _rewriteStackTrace.beginHiddenCallStack)(loadPartialConfigRunner.errback)(undefined, opts);
+  } else {
+    return loadPartialConfigSync(opts);
+  }
+}
+function* loadOptionsImpl(opts) {
+  var _config$options;
+  const config = yield* (0, _full.default)(opts);
+  return (_config$options = config == null ? void 0 : config.options) != null ? _config$options : null;
+}
+const loadOptionsRunner = _gensync()(loadOptionsImpl);
+function loadOptionsAsync(...args) {
+  return (0, _rewriteStackTrace.beginHiddenCallStack)(loadOptionsRunner.async)(...args);
+}
+function loadOptionsSync(...args) {
+  return (0, _rewriteStackTrace.beginHiddenCallStack)(loadOptionsRunner.sync)(...args);
+}
+function loadOptions(opts, callback) {
+  if (callback !== undefined) {
+    (0, _rewriteStackTrace.beginHiddenCallStack)(loadOptionsRunner.errback)(opts, callback);
+  } else if (typeof opts === "function") {
+    (0, _rewriteStackTrace.beginHiddenCallStack)(loadOptionsRunner.errback)(undefined, opts);
+  } else {
+    return loadOptionsSync(opts);
+  }
+}
+const createConfigItemRunner = _gensync()(_item.createConfigItem);
+function createConfigItemAsync(...args) {
+  return (0, _rewriteStackTrace.beginHiddenCallStack)(createConfigItemRunner.async)(...args);
+}
+function createConfigItemSync(...args) {
+  return (0, _rewriteStackTrace.beginHiddenCallStack)(createConfigItemRunner.sync)(...args);
+}
+function createConfigItem(target, options, callback) {
+  if (callback !== undefined) {
+    (0, _rewriteStackTrace.beginHiddenCallStack)(createConfigItemRunner.errback)(target, options, callback);
+  } else if (typeof options === "function") {
+    (0, _rewriteStackTrace.beginHiddenCallStack)(createConfigItemRunner.errback)(target, undefined, callback);
+  } else {
+    return createConfigItemSync(target, options);
+  }
+}
+0 && 0;
+
+//# sourceMappingURL=index.js.map
--- a/node_modules/@babel/core/lib/config/partial.js.map
+++ b/node_modules/@babel/core/lib/config/partial.js.map
--- a/node_modules/@babel/core/lib/config/plugin.js
+++ b/node_modules/@babel/core/lib/config/plugin.js
@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _deepArray = require("./helpers/deep-array.js");
+class Plugin {
+  constructor(plugin, options, key, externalDependencies = (0, _deepArray.finalize)([])) {
+    this.key = void 0;
+    this.manipulateOptions = void 0;
+    this.post = void 0;
+    this.pre = void 0;
+    this.visitor = void 0;
+    this.parserOverride = void 0;
+    this.generatorOverride = void 0;
+    this.options = void 0;
+    this.externalDependencies = void 0;
+    this.key = plugin.name || key;
+    this.manipulateOptions = plugin.manipulateOptions;
+    this.post = plugin.post;
+    this.pre = plugin.pre;
+    this.visitor = plugin.visitor || {};
+    this.parserOverride = plugin.parserOverride;
+    this.generatorOverride = plugin.generatorOverride;
+    this.options = options;
+    this.externalDependencies = externalDependencies;
+  }
+}
+exports.default = Plugin;
+0 && 0;
+
+//# sourceMappingURL=plugin.js.map
--- a/node_modules/@babel/core/lib/gensync-utils/fs.js.map
+++ b/node_modules/@babel/core/lib/gensync-utils/fs.js.map
@@ -0,0 +1 @@
+{"version":3,"names":["_fs","data","require","_gensync","readFile","exports","gensync","sync","fs","readFileSync","errback","stat","statSync"],"sources":["../../src/gensync-utils/fs.ts"],"sourcesContent":["import fs from \"node:fs\";\nimport gensync from \"gensync\";\n\nexport const readFile = gensync<[filepath: string, encoding: \"utf8\"], string>({\n  sync: fs.readFileSync,\n  errback: fs.readFile,\n});\n\nexport const stat = gensync({\n  sync: fs.statSync,\n  errback: fs.stat,\n});\n"],"mappings":";;;;;;AAAA,SAAAA,IAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,GAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,SAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,QAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEO,MAAMG,QAAQ,GAAAC,OAAA,CAAAD,QAAA,GAAGE,SAAMA,CAAC,CAA+C;EAC5EC,IAAI,EAAEC,IAACA,CAAC,CAACC,YAAY;EACrBC,OAAO,EAAEF,IAACA,CAAC,CAACJ;AACd,CAAC,CAAC;AAEK,MAAMO,IAAI,GAAAN,OAAA,CAAAM,IAAA,GAAGL,SAAMA,CAAC,CAAC;EAC1BC,IAAI,EAAEC,IAACA,CAAC,CAACI,QAAQ;EACjBF,OAAO,EAAEF,IAACA,CAAC,CAACG;AACd,CAAC,CAAC;AAAC","ignoreList":[]}
--- a/node_modules/@babel/core/lib/transformation/file/file.js.map
+++ b/node_modules/@babel/core/lib/transformation/file/file.js.map
--- a/node_modules/@babel/core/lib/transformation/file/merge-map.js.map
+++ b/node_modules/@babel/core/lib/transformation/file/merge-map.js.map
@@ -0,0 +1 @@
+{"version":3,"names":["_remapping","data","require","mergeSourceMap","inputMap","map","sourceFileName","source","replace","found","result","remapping","rootless","s","ctx","sourceRoot","Object","assign"],"sources":["../../../src/transformation/file/merge-map.ts"],"sourcesContent":["type SourceMap = any;\nimport remapping from \"@jridgewell/remapping\";\n\nexport default function mergeSourceMap(\n  inputMap: SourceMap,\n  map: SourceMap,\n  sourceFileName: string,\n): SourceMap {\n  // On win32 machines, the sourceFileName uses backslash paths like\n  // `C:\\foo\\bar.js`. But sourcemaps are always posix paths, so we need to\n  // normalize to regular slashes before we can merge (else we won't find the\n  // source associated with our input map).\n  // This mirrors code done while generating the output map at\n  // https://github.com/babel/babel/blob/5c2fcadc9ae34fd20dd72b1111d5cf50476d700d/packages/babel-generator/src/source-map.ts#L102\n  const source = sourceFileName.replace(/\\\\/g, \"/\");\n\n  // Prevent an infinite recursion if one of the input map's sources has the\n  // same resolved path as the input map. In the case, it would keep find the\n  // input map, then get it's sources which will include a path like the input\n  // map, on and on.\n  let found = false;\n  const result = remapping(rootless(map), (s, ctx) => {\n    if (s === source && !found) {\n      found = true;\n      // We empty the source location, which will prevent the sourcemap from\n      // becoming relative to the input's location. Eg, if we're transforming a\n      // file 'foo/bar.js', and it is a transformation of a `baz.js` file in the\n      // same directory, the expected output is just `baz.js`. Without this step,\n      // it would become `foo/baz.js`.\n      ctx.source = \"\";\n\n      return rootless(inputMap);\n    }\n\n    return null;\n  });\n\n  if (typeof inputMap.sourceRoot === \"string\") {\n    result.sourceRoot = inputMap.sourceRoot;\n  }\n\n  // remapping returns a SourceMap class type, but this breaks code downstream in\n  // @babel/traverse and @babel/types that relies on data being plain objects.\n  // When it encounters the sourcemap type it outputs a \"don't know how to turn\n  // this value into a node\" error. As a result, we are converting the merged\n  // sourcemap to a plain js object.\n  return { ...result };\n}\n\nfunction rootless(map: SourceMap): SourceMap {\n  return {\n    ...map,\n\n    // This is a bit hack. Remapping will create absolute sources in our\n    // sourcemap, but we want to maintain sources relative to the sourceRoot.\n    // We'll re-add the sourceRoot after remapping.\n    sourceRoot: null,\n  };\n}\n"],"mappings":";;;;;;AACA,SAAAA,WAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,UAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEe,SAASE,cAAcA,CACpCC,QAAmB,EACnBC,GAAc,EACdC,cAAsB,EACX;EAOX,MAAMC,MAAM,GAAGD,cAAc,CAACE,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;EAMjD,IAAIC,KAAK,GAAG,KAAK;EACjB,MAAMC,MAAM,GAAGC,WAAQA,CAAC,CAACC,QAAQ,CAACP,GAAG,CAAC,EAAE,CAACQ,CAAC,EAAEC,GAAG,KAAK;IAClD,IAAID,CAAC,KAAKN,MAAM,IAAI,CAACE,KAAK,EAAE;MAC1BA,KAAK,GAAG,IAAI;MAMZK,GAAG,CAACP,MAAM,GAAG,EAAE;MAEf,OAAOK,QAAQ,CAACR,QAAQ,CAAC;IAC3B;IAEA,OAAO,IAAI;EACb,CAAC,CAAC;EAEF,IAAI,OAAOA,QAAQ,CAACW,UAAU,KAAK,QAAQ,EAAE;IAC3CL,MAAM,CAACK,UAAU,GAAGX,QAAQ,CAACW,UAAU;EACzC;EAOA,OAAAC,MAAA,CAAAC,MAAA,KAAYP,MAAM;AACpB;AAEA,SAASE,QAAQA,CAACP,GAAc,EAAa;EAC3C,OAAAW,MAAA,CAAAC,MAAA,KACKZ,GAAG;IAKNU,UAAU,EAAE;EAAI;AAEpB;AAAC","ignoreList":[]}
--- a/node_modules/@babel/core/lib/transformation/util/clone-deep.js.map
+++ b/node_modules/@babel/core/lib/transformation/util/clone-deep.js.map
@@ -0,0 +1 @@
+{"version":3,"names":["circleSet","Set","depth","deepClone","value","cache","allowCircle","has","get","clear","Error","add","cloned","Array","isArray","length","set","i","keys","Object","key","delete","_default","Map","_","structuredClone"],"sources":["../../../src/transformation/util/clone-deep.ts"],"sourcesContent":["const circleSet = new Set();\nlet depth = 0;\n// https://github.com/babel/babel/pull/14583#discussion_r882828856\nfunction deepClone(\n  value: any,\n  cache: Map<any, any>,\n  allowCircle: boolean,\n): any {\n  if (value !== null) {\n    if (allowCircle) {\n      if (cache.has(value)) return cache.get(value);\n    } else if (++depth > 250) {\n      if (circleSet.has(value)) {\n        depth = 0;\n        circleSet.clear();\n        throw new Error(\"Babel-deepClone: Cycles are not allowed in AST\");\n      }\n      circleSet.add(value);\n    }\n    let cloned: any;\n    if (Array.isArray(value)) {\n      cloned = new Array(value.length);\n      if (allowCircle) cache.set(value, cloned);\n      for (let i = 0; i < value.length; i++) {\n        cloned[i] =\n          typeof value[i] !== \"object\"\n            ? value[i]\n            : deepClone(value[i], cache, allowCircle);\n      }\n    } else {\n      cloned = {};\n      if (allowCircle) cache.set(value, cloned);\n      const keys = Object.keys(value);\n      for (let i = 0; i < keys.length; i++) {\n        const key = keys[i];\n        cloned[key] =\n          typeof value[key] !== \"object\"\n            ? value[key]\n            : deepClone(\n                value[key],\n                cache,\n                allowCircle ||\n                  key === \"leadingComments\" ||\n                  key === \"innerComments\" ||\n                  key === \"trailingComments\" ||\n                  key === \"extra\",\n              );\n      }\n    }\n    if (!allowCircle) {\n      if (depth-- > 250) circleSet.delete(value);\n    }\n    return cloned;\n  }\n  return value;\n}\n\nexport default function <T>(value: T): T {\n  if (typeof value !== \"object\") return value;\n\n  if (process.env.BABEL_8_BREAKING) {\n    if (!process.env.IS_PUBLISH && depth > 0) {\n      throw new Error(\"depth > 0\");\n    }\n    return deepClone(value, new Map(), false);\n  } else {\n    try {\n      return deepClone(value, new Map(), true);\n    } catch (_) {\n      return structuredClone(value);\n    }\n  }\n}\n"],"mappings":";;;;;;AAAA,MAAMA,SAAS,GAAG,IAAIC,GAAG,CAAC,CAAC;AAC3B,IAAIC,KAAK,GAAG,CAAC;AAEb,SAASC,SAASA,CAChBC,KAAU,EACVC,KAAoB,EACpBC,WAAoB,EACf;EACL,IAAIF,KAAK,KAAK,IAAI,EAAE;IAClB,IAAIE,WAAW,EAAE;MACf,IAAID,KAAK,CAACE,GAAG,CAACH,KAAK,CAAC,EAAE,OAAOC,KAAK,CAACG,GAAG,CAACJ,KAAK,CAAC;IAC/C,CAAC,MAAM,IAAI,EAAEF,KAAK,GAAG,GAAG,EAAE;MACxB,IAAIF,SAAS,CAACO,GAAG,CAACH,KAAK,CAAC,EAAE;QACxBF,KAAK,GAAG,CAAC;QACTF,SAAS,CAACS,KAAK,CAAC,CAAC;QACjB,MAAM,IAAIC,KAAK,CAAC,gDAAgD,CAAC;MACnE;MACAV,SAAS,CAACW,GAAG,CAACP,KAAK,CAAC;IACtB;IACA,IAAIQ,MAAW;IACf,IAAIC,KAAK,CAACC,OAAO,CAACV,KAAK,CAAC,EAAE;MACxBQ,MAAM,GAAG,IAAIC,KAAK,CAACT,KAAK,CAACW,MAAM,CAAC;MAChC,IAAIT,WAAW,EAAED,KAAK,CAACW,GAAG,CAACZ,KAAK,EAAEQ,MAAM,CAAC;MACzC,KAAK,IAAIK,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGb,KAAK,CAACW,MAAM,EAAEE,CAAC,EAAE,EAAE;QACrCL,MAAM,CAACK,CAAC,CAAC,GACP,OAAOb,KAAK,CAACa,CAAC,CAAC,KAAK,QAAQ,GACxBb,KAAK,CAACa,CAAC,CAAC,GACRd,SAAS,CAACC,KAAK,CAACa,CAAC,CAAC,EAAEZ,KAAK,EAAEC,WAAW,CAAC;MAC/C;IACF,CAAC,MAAM;MACLM,MAAM,GAAG,CAAC,CAAC;MACX,IAAIN,WAAW,EAAED,KAAK,CAACW,GAAG,CAACZ,KAAK,EAAEQ,MAAM,CAAC;MACzC,MAAMM,IAAI,GAAGC,MAAM,CAACD,IAAI,CAACd,KAAK,CAAC;MAC/B,KAAK,IAAIa,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGC,IAAI,CAACH,MAAM,EAAEE,CAAC,EAAE,EAAE;QACpC,MAAMG,GAAG,GAAGF,IAAI,CAACD,CAAC,CAAC;QACnBL,MAAM,CAACQ,GAAG,CAAC,GACT,OAAOhB,KAAK,CAACgB,GAAG,CAAC,KAAK,QAAQ,GAC1BhB,KAAK,CAACgB,GAAG,CAAC,GACVjB,SAAS,CACPC,KAAK,CAACgB,GAAG,CAAC,EACVf,KAAK,EACLC,WAAW,IACTc,GAAG,KAAK,iBAAiB,IACzBA,GAAG,KAAK,eAAe,IACvBA,GAAG,KAAK,kBAAkB,IAC1BA,GAAG,KAAK,OACZ,CAAC;MACT;IACF;IACA,IAAI,CAACd,WAAW,EAAE;MAChB,IAAIJ,KAAK,EAAE,GAAG,GAAG,EAAEF,SAAS,CAACqB,MAAM,CAACjB,KAAK,CAAC;IAC5C;IACA,OAAOQ,MAAM;EACf;EACA,OAAOR,KAAK;AACd;AAEe,SAAAkB,SAAalB,KAAQ,EAAK;EACvC,IAAI,OAAOA,KAAK,KAAK,QAAQ,EAAE,OAAOA,KAAK;EAQzC,IAAI;IACF,OAAOD,SAAS,CAACC,KAAK,EAAE,IAAImB,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC;EAC1C,CAAC,CAAC,OAAOC,CAAC,EAAE;IACV,OAAOC,eAAe,CAACrB,KAAK,CAAC;EAC/B;AAEJ;AAAC","ignoreList":[]}
--- a/node_modules/@babel/core/node_modules/convert-source-map/index.js
+++ b/node_modules/@babel/core/node_modules/convert-source-map/index.js
@@ -0,0 +1,233 @@
+'use strict';
+
+Object.defineProperty(exports, 'commentRegex', {
+  get: function getCommentRegex () {
+    // Groups: 1: media type, 2: MIME type, 3: charset, 4: encoding, 5: data.
+    return /^\s*?\/[\/\*][@#]\s+?sourceMappingURL=data:(((?:application|text)\/json)(?:;charset=([^;,]+?)?)?)?(?:;(base64))?,(.*?)$/mg;
+  }
+});
+
+
+Object.defineProperty(exports, 'mapFileCommentRegex', {
+  get: function getMapFileCommentRegex () {
+    // Matches sourceMappingURL in either // or /* comment styles.
+    return /(?:\/\/[@#][ \t]+?sourceMappingURL=([^\s'"`]+?)[ \t]*?$)|(?:\/\*[@#][ \t]+sourceMappingURL=([^*]+?)[ \t]*?(?:\*\/){1}[ \t]*?$)/mg;
+  }
+});
+
+var decodeBase64;
+if (typeof Buffer !== 'undefined') {
+  if (typeof Buffer.from === 'function') {
+    decodeBase64 = decodeBase64WithBufferFrom;
+  } else {
+    decodeBase64 = decodeBase64WithNewBuffer;
+  }
+} else {
+  decodeBase64 = decodeBase64WithAtob;
+}
+
+function decodeBase64WithBufferFrom(base64) {
+  return Buffer.from(base64, 'base64').toString();
+}
+
+function decodeBase64WithNewBuffer(base64) {
+  if (typeof value === 'number') {
+    throw new TypeError('The value to decode must not be of type number.');
+  }
+  return new Buffer(base64, 'base64').toString();
+}
+
+function decodeBase64WithAtob(base64) {
+  return decodeURIComponent(escape(atob(base64)));
+}
+
+function stripComment(sm) {
+  return sm.split(',').pop();
+}
+
+function readFromFileMap(sm, read) {
+  var r = exports.mapFileCommentRegex.exec(sm);
+  // for some odd reason //# .. captures in 1 and /* .. */ in 2
+  var filename = r[1] || r[2];
+
+  try {
+    var sm = read(filename);
+    if (sm != null && typeof sm.catch === 'function') {
+      return sm.catch(throwError);
+    } else {
+      return sm;
+    }
+  } catch (e) {
+    throwError(e);
+  }
+
+  function throwError(e) {
+    throw new Error('An error occurred while trying to read the map file at ' + filename + '\n' + e.stack);
+  }
+}
+
+function Converter (sm, opts) {
+  opts = opts || {};
+
+  if (opts.hasComment) {
+    sm = stripComment(sm);
+  }
+
+  if (opts.encoding === 'base64') {
+    sm = decodeBase64(sm);
+  } else if (opts.encoding === 'uri') {
+    sm = decodeURIComponent(sm);
+  }
+
+  if (opts.isJSON || opts.encoding) {
+    sm = JSON.parse(sm);
+  }
+
+  this.sourcemap = sm;
+}
+
+Converter.prototype.toJSON = function (space) {
+  return JSON.stringify(this.sourcemap, null, space);
+};
+
+if (typeof Buffer !== 'undefined') {
+  if (typeof Buffer.from === 'function') {
+    Converter.prototype.toBase64 = encodeBase64WithBufferFrom;
+  } else {
+    Converter.prototype.toBase64 = encodeBase64WithNewBuffer;
+  }
+} else {
+  Converter.prototype.toBase64 = encodeBase64WithBtoa;
+}
+
+function encodeBase64WithBufferFrom() {
+  var json = this.toJSON();
+  return Buffer.from(json, 'utf8').toString('base64');
+}
+
+function encodeBase64WithNewBuffer() {
+  var json = this.toJSON();
+  if (typeof json === 'number') {
+    throw new TypeError('The json to encode must not be of type number.');
+  }
+  return new Buffer(json, 'utf8').toString('base64');
+}
+
+function encodeBase64WithBtoa() {
+  var json = this.toJSON();
+  return btoa(unescape(encodeURIComponent(json)));
+}
+
+Converter.prototype.toURI = function () {
+  var json = this.toJSON();
+  return encodeURIComponent(json);
+};
+
+Converter.prototype.toComment = function (options) {
+  var encoding, content, data;
+  if (options != null && options.encoding === 'uri') {
+    encoding = '';
+    content = this.toURI();
+  } else {
+    encoding = ';base64';
+    content = this.toBase64();
+  }
+  data = 'sourceMappingURL=data:application/json;charset=utf-8' + encoding + ',' + content;
+  return options != null && options.multiline ? '/*# ' + data + ' */' : '//# ' + data;
+};
+
+// returns copy instead of original
+Converter.prototype.toObject = function () {
+  return JSON.parse(this.toJSON());
+};
+
+Converter.prototype.addProperty = function (key, value) {
+  if (this.sourcemap.hasOwnProperty(key)) throw new Error('property "' + key + '" already exists on the sourcemap, use set property instead');
+  return this.setProperty(key, value);
+};
+
+Converter.prototype.setProperty = function (key, value) {
+  this.sourcemap[key] = value;
+  return this;
+};
+
+Converter.prototype.getProperty = function (key) {
+  return this.sourcemap[key];
+};
+
+exports.fromObject = function (obj) {
+  return new Converter(obj);
+};
+
+exports.fromJSON = function (json) {
+  return new Converter(json, { isJSON: true });
+};
+
+exports.fromURI = function (uri) {
+  return new Converter(uri, { encoding: 'uri' });
+};
+
+exports.fromBase64 = function (base64) {
+  return new Converter(base64, { encoding: 'base64' });
+};
+
+exports.fromComment = function (comment) {
+  var m, encoding;
+  comment = comment
+    .replace(/^\/\*/g, '//')
+    .replace(/\*\/$/g, '');
+  m = exports.commentRegex.exec(comment);
+  encoding = m && m[4] || 'uri';
+  return new Converter(comment, { encoding: encoding, hasComment: true });
+};
+
+function makeConverter(sm) {
+  return new Converter(sm, { isJSON: true });
+}
+
+exports.fromMapFileComment = function (comment, read) {
+  if (typeof read === 'string') {
+    throw new Error(
+      'String directory paths are no longer supported with `fromMapFileComment`\n' +
+      'Please review the Upgrading documentation at https://github.com/thlorenz/convert-source-map#upgrading'
+    )
+  }
+
+  var sm = readFromFileMap(comment, read);
+  if (sm != null && typeof sm.then === 'function') {
+    return sm.then(makeConverter);
+  } else {
+    return makeConverter(sm);
+  }
+};
+
+// Finds last sourcemap comment in file or returns null if none was found
+exports.fromSource = function (content) {
+  var m = content.match(exports.commentRegex);
+  return m ? exports.fromComment(m.pop()) : null;
+};
+
+// Finds last sourcemap comment in file or returns null if none was found
+exports.fromMapFileSource = function (content, read) {
+  if (typeof read === 'string') {
+    throw new Error(
+      'String directory paths are no longer supported with `fromMapFileSource`\n' +
+      'Please review the Upgrading documentation at https://github.com/thlorenz/convert-source-map#upgrading'
+    )
+  }
+  var m = content.match(exports.mapFileCommentRegex);
+  return m ? exports.fromMapFileComment(m.pop(), read) : null;
+};
+
+exports.removeComments = function (src) {
+  return src.replace(exports.commentRegex, '');
+};
+
+exports.removeMapFileComments = function (src) {
+  return src.replace(exports.mapFileCommentRegex, '');
+};
+
+exports.generateMapFileComment = function (file, options) {
+  var data = 'sourceMappingURL=' + file;
+  return options && options.multiline ? '/*# ' + data + ' */' : '//# ' + data;
+};
--- a/node_modules/@babel/core/src/transform-file.ts
+++ b/node_modules/@babel/core/src/transform-file.ts
@@ -0,0 +1,56 @@
+import gensync, { type Handler } from "gensync";
+
+import loadConfig from "./config/index.ts";
+import type { InputOptions, ResolvedConfig } from "./config/index.ts";
+import { run } from "./transformation/index.ts";
+import type { FileResult, FileResultCallback } from "./transformation/index.ts";
+import * as fs from "./gensync-utils/fs.ts";
+
+type transformFileBrowserType = typeof import("./transform-file-browser");
+type transformFileType = typeof import("./transform-file");
+
+// Kind of gross, but essentially asserting that the exports of this module are the same as the
+// exports of transform-file-browser, since this file may be replaced at bundle time with
+// transform-file-browser.
+// eslint-disable-next-line @typescript-eslint/no-unused-expressions
+({}) as any as transformFileBrowserType as transformFileType;
+
+const transformFileRunner = gensync(function* (
+  filename: string,
+  opts?: InputOptions,
+): Handler<FileResult | null> {
+  const options = { ...opts, filename };
+
+  const config: ResolvedConfig | null = yield* loadConfig(options);
+  if (config === null) return null;
+
+  const code = yield* fs.readFile(filename, "utf8");
+  return yield* run(config, code);
+});
+
+// @ts-expect-error TS doesn't detect that this signature is compatible
+export function transformFile(
+  filename: string,
+  callback: FileResultCallback,
+): void;
+export function transformFile(
+  filename: string,
+  opts: InputOptions | undefined | null,
+  callback: FileResultCallback,
+): void;
+export function transformFile(
+  ...args: Parameters<typeof transformFileRunner.errback>
+) {
+  transformFileRunner.errback(...args);
+}
+
+export function transformFileSync(
+  ...args: Parameters<typeof transformFileRunner.sync>
+) {
+  return transformFileRunner.sync(...args);
+}
+export function transformFileAsync(
+  ...args: Parameters<typeof transformFileRunner.async>
+) {
+  return transformFileRunner.async(...args);
+}
--- a/node_modules/@babel/generator/lib/generators/expressions.js.map
+++ b/node_modules/@babel/generator/lib/generators/expressions.js.map
--- a/node_modules/@babel/generator/lib/generators/statements.js
+++ b/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
--- a/node_modules/@babel/generator/lib/index.js
+++ b/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
--- a/node_modules/@babel/generator/lib/node/parentheses.js
+++ b/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
--- a/node_modules/@babel/generator/lib/source-map.js.map
+++ b/node_modules/@babel/generator/lib/source-map.js.map
--- a/node_modules/@babel/generator/lib/token-map.js
+++ b/node_modules/@babel/generator/lib/token-map.js
@@ -0,0 +1,195 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TokenMap = void 0;
+var _t = require("@babel/types");
+const {
+  traverseFast,
+  VISITOR_KEYS
+} = _t;
+class TokenMap {
+  constructor(ast, tokens, source) {
+    this._tokens = void 0;
+    this._source = void 0;
+    this._nodesToTokenIndexes = new Map();
+    this._nodesOccurrencesCountCache = new Map();
+    this._tokensCache = new Map();
+    this._tokens = tokens;
+    this._source = source;
+    traverseFast(ast, node => {
+      const indexes = this._getTokensIndexesOfNode(node);
+      if (indexes.length > 0) this._nodesToTokenIndexes.set(node, indexes);
+    });
+    this._tokensCache.clear();
+  }
+  has(node) {
+    return this._nodesToTokenIndexes.has(node);
+  }
+  getIndexes(node) {
+    return this._nodesToTokenIndexes.get(node);
+  }
+  find(node, condition) {
+    const indexes = this._nodesToTokenIndexes.get(node);
+    if (indexes) {
+      for (let k = 0; k < indexes.length; k++) {
+        const index = indexes[k];
+        const tok = this._tokens[index];
+        if (condition(tok, index)) return tok;
+      }
+    }
+    return null;
+  }
+  findLastIndex(node, condition) {
+    const indexes = this._nodesToTokenIndexes.get(node);
+    if (indexes) {
+      for (let k = indexes.length - 1; k >= 0; k--) {
+        const index = indexes[k];
+        const tok = this._tokens[index];
+        if (condition(tok, index)) return index;
+      }
+    }
+    return -1;
+  }
+  findMatching(node, test, occurrenceCount = 0) {
+    const indexes = this._nodesToTokenIndexes.get(node);
+    if (indexes) {
+      if (typeof test === "number") {
+        test = String.fromCharCode(test);
+      }
+      let i = 0;
+      const count = occurrenceCount;
+      if (count > 1) {
+        const cache = this._nodesOccurrencesCountCache.get(node);
+        if ((cache == null ? void 0 : cache.test) === test && cache.count < count) {
+          i = cache.i + 1;
+          occurrenceCount -= cache.count + 1;
+        }
+      }
+      for (; i < indexes.length; i++) {
+        const tok = this._tokens[indexes[i]];
+        if (this.matchesOriginal(tok, test)) {
+          if (occurrenceCount === 0) {
+            if (count > 0) {
+              this._nodesOccurrencesCountCache.set(node, {
+                test,
+                count,
+                i
+              });
+            }
+            return tok;
+          }
+          occurrenceCount--;
+        }
+      }
+    }
+    return null;
+  }
+  matchesOriginal(token, test) {
+    if (token.end - token.start !== test.length) return false;
+    if (token.value != null) return token.value === test;
+    return this._source.startsWith(test, token.start);
+  }
+  startMatches(node, test) {
+    const indexes = this._nodesToTokenIndexes.get(node);
+    if (!indexes) return false;
+    const tok = this._tokens[indexes[0]];
+    if (tok.start !== node.start) return false;
+    return this.matchesOriginal(tok, test);
+  }
+  endMatches(node, test) {
+    const indexes = this._nodesToTokenIndexes.get(node);
+    if (!indexes) return false;
+    const tok = this._tokens[indexes[indexes.length - 1]];
+    if (tok.end !== node.end) return false;
+    return this.matchesOriginal(tok, test);
+  }
+  _getTokensIndexesOfNode(node) {
+    var _node$declaration;
+    if (node.start == null || node.end == null) return [];
+    const {
+      first,
+      last
+    } = this._findTokensOfNode(node, 0, this._tokens.length - 1);
+    let low = first;
+    const children = childrenIterator(node);
+    if ((node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration") && ((_node$declaration = node.declaration) == null ? void 0 : _node$declaration.type) === "ClassDeclaration") {
+      children.next();
+    }
+    const indexes = [];
+    for (const child of children) {
+      if (child == null) continue;
+      if (child.start == null || child.end == null) continue;
+      const childTok = this._findTokensOfNode(child, low, last);
+      const high = childTok.first;
+      for (let k = low; k < high; k++) indexes.push(k);
+      low = childTok.last + 1;
+    }
+    for (let k = low; k <= last; k++) indexes.push(k);
+    return indexes;
+  }
+  _findTokensOfNode(node, low, high) {
+    const cached = this._tokensCache.get(node);
+    if (cached) return cached;
+    const first = this._findFirstTokenOfNode(node.start, low, high);
+    const last = this._findLastTokenOfNode(node.end, first, high);
+    this._tokensCache.set(node, {
+      first,
+      last
+    });
+    return {
+      first,
+      last
+    };
+  }
+  _findFirstTokenOfNode(start, low, high) {
+    while (low <= high) {
+      const mid = high + low >> 1;
+      if (start < this._tokens[mid].start) {
+        high = mid - 1;
+      } else if (start > this._tokens[mid].start) {
+        low = mid + 1;
+      } else {
+        return mid;
+      }
+    }
+    return low;
+  }
+  _findLastTokenOfNode(end, low, high) {
+    while (low <= high) {
+      const mid = high + low >> 1;
+      if (end < this._tokens[mid].end) {
+        high = mid - 1;
+      } else if (end > this._tokens[mid].end) {
+        low = mid + 1;
+      } else {
+        return mid;
+      }
+    }
+    return high;
+  }
+}
+exports.TokenMap = TokenMap;
+function* childrenIterator(node) {
+  if (node.type === "TemplateLiteral") {
+    yield node.quasis[0];
+    for (let i = 1; i < node.quasis.length; i++) {
+      yield node.expressions[i - 1];
+      yield node.quasis[i];
+    }
+    return;
+  }
+  const keys = VISITOR_KEYS[node.type];
+  for (const key of keys) {
+    const child = node[key];
+    if (!child) continue;
+    if (Array.isArray(child)) {
+      yield* child;
+    } else {
+      yield child;
+    }
+  }
+}
+
+//# sourceMappingURL=token-map.js.map
--- a/node_modules/@babel/helper-compilation-targets/lib/options.js.map
+++ b/node_modules/@babel/helper-compilation-targets/lib/options.js.map
@@ -0,0 +1 @@
+{"version":3,"names":["TargetNames","exports","node","deno","chrome","opera","edge","firefox","safari","ie","ios","android","electron","samsung","rhino","opera_mobile"],"sources":["../src/options.ts"],"sourcesContent":["export const TargetNames = {\n  node: \"node\",\n  deno: \"deno\",\n  chrome: \"chrome\",\n  opera: \"opera\",\n  edge: \"edge\",\n  firefox: \"firefox\",\n  safari: \"safari\",\n  ie: \"ie\",\n  ios: \"ios\",\n  android: \"android\",\n  electron: \"electron\",\n  samsung: \"samsung\",\n  rhino: \"rhino\",\n  opera_mobile: \"opera_mobile\",\n};\n"],"mappings":";;;;;;AAAO,MAAMA,WAAW,GAAAC,OAAA,CAAAD,WAAA,GAAG;EACzBE,IAAI,EAAE,MAAM;EACZC,IAAI,EAAE,MAAM;EACZC,MAAM,EAAE,QAAQ;EAChBC,KAAK,EAAE,OAAO;EACdC,IAAI,EAAE,MAAM;EACZC,OAAO,EAAE,SAAS;EAClBC,MAAM,EAAE,QAAQ;EAChBC,EAAE,EAAE,IAAI;EACRC,GAAG,EAAE,KAAK;EACVC,OAAO,EAAE,SAAS;EAClBC,QAAQ,EAAE,UAAU;EACpBC,OAAO,EAAE,SAAS;EAClBC,KAAK,EAAE,OAAO;EACdC,YAAY,EAAE;AAChB,CAAC","ignoreList":[]}
--- a/node_modules/@babel/helper-module-transforms/lib/lazy-modules.js.map
+++ b/node_modules/@babel/helper-module-transforms/lib/lazy-modules.js.map
@@ -0,0 +1 @@
+{"version":3,"names":["_core","require","_normalizeAndLoadMetadata","toGetWrapperPayload","lazy","source","metadata","isSideEffectImport","reexportAll","includes","Array","isArray","Error","wrapReference","ref","payload","t","callExpression"],"sources":["../src/lazy-modules.ts"],"sourcesContent":["// TODO: Move `lazy` implementation logic into the CommonJS plugin, since other\n// modules systems do not support `lazy`.\n\nimport { types as t } from \"@babel/core\";\nimport {\n  type SourceModuleMetadata,\n  isSideEffectImport,\n} from \"./normalize-and-load-metadata.ts\";\n\nexport type Lazy = boolean | string[] | ((source: string) => boolean);\n\nexport function toGetWrapperPayload(lazy: Lazy) {\n  return (source: string, metadata: SourceModuleMetadata): null | \"lazy\" => {\n    if (lazy === false) return null;\n    if (isSideEffectImport(metadata) || metadata.reexportAll) return null;\n    if (lazy === true) {\n      // 'true' means that local relative files are eagerly loaded and\n      // dependency modules are loaded lazily.\n      return source.includes(\".\") ? null : \"lazy\";\n    }\n    if (Array.isArray(lazy)) {\n      return !lazy.includes(source) ? null : \"lazy\";\n    }\n    if (typeof lazy === \"function\") {\n      return lazy(source) ? \"lazy\" : null;\n    }\n    throw new Error(`.lazy must be a boolean, string array, or function`);\n  };\n}\n\nexport function wrapReference(\n  ref: t.Identifier,\n  payload: unknown,\n): t.Expression | null {\n  if (payload === \"lazy\") return t.callExpression(ref, []);\n  return null;\n}\n"],"mappings":";;;;;;;AAGA,IAAAA,KAAA,GAAAC,OAAA;AACA,IAAAC,yBAAA,GAAAD,OAAA;AAOO,SAASE,mBAAmBA,CAACC,IAAU,EAAE;EAC9C,OAAO,CAACC,MAAc,EAAEC,QAA8B,KAAoB;IACxE,IAAIF,IAAI,KAAK,KAAK,EAAE,OAAO,IAAI;IAC/B,IAAI,IAAAG,4CAAkB,EAACD,QAAQ,CAAC,IAAIA,QAAQ,CAACE,WAAW,EAAE,OAAO,IAAI;IACrE,IAAIJ,IAAI,KAAK,IAAI,EAAE;MAGjB,OAAOC,MAAM,CAACI,QAAQ,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,MAAM;IAC7C;IACA,IAAIC,KAAK,CAACC,OAAO,CAACP,IAAI,CAAC,EAAE;MACvB,OAAO,CAACA,IAAI,CAACK,QAAQ,CAACJ,MAAM,CAAC,GAAG,IAAI,GAAG,MAAM;IAC/C;IACA,IAAI,OAAOD,IAAI,KAAK,UAAU,EAAE;MAC9B,OAAOA,IAAI,CAACC,MAAM,CAAC,GAAG,MAAM,GAAG,IAAI;IACrC;IACA,MAAM,IAAIO,KAAK,CAAC,oDAAoD,CAAC;EACvE,CAAC;AACH;AAEO,SAASC,aAAaA,CAC3BC,GAAiB,EACjBC,OAAgB,EACK;EACrB,IAAIA,OAAO,KAAK,MAAM,EAAE,OAAOC,WAAC,CAACC,cAAc,CAACH,GAAG,EAAE,EAAE,CAAC;EACxD,OAAO,IAAI;AACb","ignoreList":[]}
--- a/node_modules/@babel/helper-plugin-utils/lib/index.js.map
+++ b/node_modules/@babel/helper-plugin-utils/lib/index.js.map
--- a/node_modules/@babel/helper-validator-option/README.md
+++ b/node_modules/@babel/helper-validator-option/README.md
@@ -0,0 +1,19 @@
+# @babel/helper-validator-option
+
+> Validate plugin/preset options
+
+See our website [@babel/helper-validator-option](https://babeljs.io/docs/babel-helper-validator-option) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-validator-option
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-validator-option
+```
--- a/node_modules/@babel/helper-validator-option/lib/validator.js.map
+++ b/node_modules/@babel/helper-validator-option/lib/validator.js.map
@@ -0,0 +1 @@
+{"version":3,"names":["_findSuggestion","require","OptionValidator","constructor","descriptor","validateTopLevelOptions","options","TopLevelOptionShape","validOptionNames","Object","keys","option","includes","Error","formatMessage","findSuggestion","validateBooleanOption","name","value","defaultValue","undefined","invariant","validateStringOption","condition","message","exports"],"sources":["../src/validator.ts"],"sourcesContent":["import { findSuggestion } from \"./find-suggestion.ts\";\n\nexport class OptionValidator {\n  declare descriptor: string;\n  constructor(descriptor: string) {\n    this.descriptor = descriptor;\n  }\n\n  /**\n   * Validate if the given `options` follow the name of keys defined in the `TopLevelOptionShape`\n   *\n   * @param {Object} options\n   * @param {Object} TopLevelOptionShape\n   *   An object with all the valid key names that `options` should be allowed to have\n   *   The property values of `TopLevelOptionShape` can be arbitrary\n   * @memberof OptionValidator\n   */\n  validateTopLevelOptions(options: object, TopLevelOptionShape: object): void {\n    const validOptionNames = Object.keys(TopLevelOptionShape);\n    for (const option of Object.keys(options)) {\n      if (!validOptionNames.includes(option)) {\n        throw new Error(\n          this.formatMessage(`'${option}' is not a valid top-level option.\n- Did you mean '${findSuggestion(option, validOptionNames)}'?`),\n        );\n      }\n    }\n  }\n\n  // note: we do not consider rewrite them to high order functions\n  // until we have to support `validateNumberOption`.\n  validateBooleanOption<T extends boolean>(\n    name: string,\n    value?: boolean,\n    defaultValue?: T,\n  ): boolean | T {\n    if (value === undefined) {\n      return defaultValue;\n    } else {\n      this.invariant(\n        typeof value === \"boolean\",\n        `'${name}' option must be a boolean.`,\n      );\n    }\n    return value;\n  }\n\n  validateStringOption<T extends string>(\n    name: string,\n    value?: string,\n    defaultValue?: T,\n  ): string | T {\n    if (value === undefined) {\n      return defaultValue;\n    } else {\n      this.invariant(\n        typeof value === \"string\",\n        `'${name}' option must be a string.`,\n      );\n    }\n    return value;\n  }\n  /**\n   * A helper interface copied from the `invariant` npm package.\n   * It throws given `message` when `condition` is not met\n   *\n   * @param {boolean} condition\n   * @param {string} message\n   * @memberof OptionValidator\n   */\n  invariant(condition: boolean, message: string): void {\n    if (!condition) {\n      throw new Error(this.formatMessage(message));\n    }\n  }\n\n  formatMessage(message: string): string {\n    return `${this.descriptor}: ${message}`;\n  }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,eAAA,GAAAC,OAAA;AAEO,MAAMC,eAAe,CAAC;EAE3BC,WAAWA,CAACC,UAAkB,EAAE;IAC9B,IAAI,CAACA,UAAU,GAAGA,UAAU;EAC9B;EAWAC,uBAAuBA,CAACC,OAAe,EAAEC,mBAA2B,EAAQ;IAC1E,MAAMC,gBAAgB,GAAGC,MAAM,CAACC,IAAI,CAACH,mBAAmB,CAAC;IACzD,KAAK,MAAMI,MAAM,IAAIF,MAAM,CAACC,IAAI,CAACJ,OAAO,CAAC,EAAE;MACzC,IAAI,CAACE,gBAAgB,CAACI,QAAQ,CAACD,MAAM,CAAC,EAAE;QACtC,MAAM,IAAIE,KAAK,CACb,IAAI,CAACC,aAAa,CAAC,IAAIH,MAAM;AACvC,kBAAkB,IAAAI,8BAAc,EAACJ,MAAM,EAAEH,gBAAgB,CAAC,IAAI,CACtD,CAAC;MACH;IACF;EACF;EAIAQ,qBAAqBA,CACnBC,IAAY,EACZC,KAAe,EACfC,YAAgB,EACH;IACb,IAAID,KAAK,KAAKE,SAAS,EAAE;MACvB,OAAOD,YAAY;IACrB,CAAC,MAAM;MACL,IAAI,CAACE,SAAS,CACZ,OAAOH,KAAK,KAAK,SAAS,EAC1B,IAAID,IAAI,6BACV,CAAC;IACH;IACA,OAAOC,KAAK;EACd;EAEAI,oBAAoBA,CAClBL,IAAY,EACZC,KAAc,EACdC,YAAgB,EACJ;IACZ,IAAID,KAAK,KAAKE,SAAS,EAAE;MACvB,OAAOD,YAAY;IACrB,CAAC,MAAM;MACL,IAAI,CAACE,SAAS,CACZ,OAAOH,KAAK,KAAK,QAAQ,EACzB,IAAID,IAAI,4BACV,CAAC;IACH;IACA,OAAOC,KAAK;EACd;EASAG,SAASA,CAACE,SAAkB,EAAEC,OAAe,EAAQ;IACnD,IAAI,CAACD,SAAS,EAAE;MACd,MAAM,IAAIV,KAAK,CAAC,IAAI,CAACC,aAAa,CAACU,OAAO,CAAC,CAAC;IAC9C;EACF;EAEAV,aAAaA,CAACU,OAAe,EAAU;IACrC,OAAO,GAAG,IAAI,CAACpB,UAAU,KAAKoB,OAAO,EAAE;EACzC;AACF;AAACC,OAAA,CAAAvB,eAAA,GAAAA,eAAA","ignoreList":[]}
--- a/node_modules/@babel/helper-validator-option/package.json
+++ b/node_modules/@babel/helper-validator-option/package.json
@@ -0,0 +1,27 @@
+{
+  "name": "@babel/helper-validator-option",
+  "version": "7.27.1",
+  "description": "Validate plugin/preset options",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-validator-option"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}
--- a/node_modules/@babel/helpers/lib/helpers/applyDecs2301.js
+++ b/node_modules/@babel/helpers/lib/helpers/applyDecs2301.js
@@ -0,0 +1,421 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = applyDecs2301;
+var _checkInRHS = require("checkInRHS");
+var _setFunctionName = require("setFunctionName");
+var _toPropertyKey = require("toPropertyKey");
+function applyDecs2301Factory() {
+  function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+    return function addInitializer(initializer) {
+      assertNotFinished(decoratorFinishedRef, "addInitializer");
+      assertCallable(initializer, "An initializer");
+      initializers.push(initializer);
+    };
+  }
+  function assertInstanceIfPrivate(has, target) {
+    if (!has(target)) {
+      throw new TypeError("Attempted to access private element on non-instance");
+    }
+  }
+  function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, value, hasPrivateBrand) {
+    var kindStr;
+    switch (kind) {
+      case 1:
+        kindStr = "accessor";
+        break;
+      case 2:
+        kindStr = "method";
+        break;
+      case 3:
+        kindStr = "getter";
+        break;
+      case 4:
+        kindStr = "setter";
+        break;
+      default:
+        kindStr = "field";
+    }
+    var ctx = {
+      kind: kindStr,
+      name: isPrivate ? "#" + name : _toPropertyKey(name),
+      static: isStatic,
+      private: isPrivate
+    };
+    var decoratorFinishedRef = {
+      v: false
+    };
+    if (kind !== 0) {
+      ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+    }
+    var get, set;
+    if (!isPrivate && (kind === 0 || kind === 2)) {
+      get = function (target) {
+        return target[name];
+      };
+      if (kind === 0) {
+        set = function (target, v) {
+          target[name] = v;
+        };
+      }
+    } else if (kind === 2) {
+      get = function (target) {
+        assertInstanceIfPrivate(hasPrivateBrand, target);
+        return desc.value;
+      };
+    } else {
+      var t = kind === 0 || kind === 1;
+      if (t || kind === 3) {
+        if (isPrivate) {
+          get = function (target) {
+            assertInstanceIfPrivate(hasPrivateBrand, target);
+            return desc.get.call(target);
+          };
+        } else {
+          get = function (target) {
+            return desc.get.call(target);
+          };
+        }
+      }
+      if (t || kind === 4) {
+        if (isPrivate) {
+          set = function (target, value) {
+            assertInstanceIfPrivate(hasPrivateBrand, target);
+            desc.set.call(target, value);
+          };
+        } else {
+          set = function (target, value) {
+            desc.set.call(target, value);
+          };
+        }
+      }
+    }
+    var has = isPrivate ? hasPrivateBrand.bind() : function (target) {
+      return name in target;
+    };
+    ctx.access = get && set ? {
+      get: get,
+      set: set,
+      has: has
+    } : get ? {
+      get: get,
+      has: has
+    } : {
+      set: set,
+      has: has
+    };
+    try {
+      return dec(value, ctx);
+    } finally {
+      decoratorFinishedRef.v = true;
+    }
+  }
+  function assertNotFinished(decoratorFinishedRef, fnName) {
+    if (decoratorFinishedRef.v) {
+      throw new Error("attempted to call " + fnName + " after decoration was finished");
+    }
+  }
+  function assertCallable(fn, hint) {
+    if (typeof fn !== "function") {
+      throw new TypeError(hint + " must be a function");
+    }
+  }
+  function assertValidReturnValue(kind, value) {
+    var type = typeof value;
+    if (kind === 1) {
+      if (type !== "object" || value === null) {
+        throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+      }
+      if (value.get !== undefined) {
+        assertCallable(value.get, "accessor.get");
+      }
+      if (value.set !== undefined) {
+        assertCallable(value.set, "accessor.set");
+      }
+      if (value.init !== undefined) {
+        assertCallable(value.init, "accessor.init");
+      }
+    } else if (type !== "function") {
+      var hint;
+      if (kind === 0) {
+        hint = "field";
+      } else if (kind === 10) {
+        hint = "class";
+      } else {
+        hint = "method";
+      }
+      throw new TypeError(hint + " decorators must return a function or void 0");
+    }
+  }
+  function curryThis1(fn) {
+    return function () {
+      return fn(this);
+    };
+  }
+  function curryThis2(fn) {
+    return function (value) {
+      fn(this, value);
+    };
+  }
+  function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, hasPrivateBrand) {
+    var decs = decInfo[0];
+    var desc, init, prefix, value;
+    if (isPrivate) {
+      if (kind === 0 || kind === 1) {
+        desc = {
+          get: curryThis1(decInfo[3]),
+          set: curryThis2(decInfo[4])
+        };
+        prefix = "get";
+      } else {
+        if (kind === 3) {
+          desc = {
+            get: decInfo[3]
+          };
+          prefix = "get";
+        } else if (kind === 4) {
+          desc = {
+            set: decInfo[3]
+          };
+          prefix = "set";
+        } else {
+          desc = {
+            value: decInfo[3]
+          };
+        }
+      }
+      if (kind !== 0) {
+        if (kind === 1) {
+          _setFunctionName(desc.set, "#" + name, "set");
+        }
+        _setFunctionName(desc[prefix || "value"], "#" + name, prefix);
+      }
+    } else if (kind !== 0) {
+      desc = Object.getOwnPropertyDescriptor(base, name);
+    }
+    if (kind === 1) {
+      value = {
+        get: desc.get,
+        set: desc.set
+      };
+    } else if (kind === 2) {
+      value = desc.value;
+    } else if (kind === 3) {
+      value = desc.get;
+    } else if (kind === 4) {
+      value = desc.set;
+    }
+    var newValue, get, set;
+    if (typeof decs === "function") {
+      newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, value, hasPrivateBrand);
+      if (newValue !== void 0) {
+        assertValidReturnValue(kind, newValue);
+        if (kind === 0) {
+          init = newValue;
+        } else if (kind === 1) {
+          init = newValue.init;
+          get = newValue.get || value.get;
+          set = newValue.set || value.set;
+          value = {
+            get: get,
+            set: set
+          };
+        } else {
+          value = newValue;
+        }
+      }
+    } else {
+      for (var i = decs.length - 1; i >= 0; i--) {
+        var dec = decs[i];
+        newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, value, hasPrivateBrand);
+        if (newValue !== void 0) {
+          assertValidReturnValue(kind, newValue);
+          var newInit;
+          if (kind === 0) {
+            newInit = newValue;
+          } else if (kind === 1) {
+            newInit = newValue.init;
+            get = newValue.get || value.get;
+            set = newValue.set || value.set;
+            value = {
+              get: get,
+              set: set
+            };
+          } else {
+            value = newValue;
+          }
+          if (newInit !== void 0) {
+            if (init === void 0) {
+              init = newInit;
+            } else if (typeof init === "function") {
+              init = [init, newInit];
+            } else {
+              init.push(newInit);
+            }
+          }
+        }
+      }
+    }
+    if (kind === 0 || kind === 1) {
+      if (init === void 0) {
+        init = function (instance, init) {
+          return init;
+        };
+      } else if (typeof init !== "function") {
+        var ownInitializers = init;
+        init = function (instance, init) {
+          var value = init;
+          for (var i = 0; i < ownInitializers.length; i++) {
+            value = ownInitializers[i].call(instance, value);
+          }
+          return value;
+        };
+      } else {
+        var originalInitializer = init;
+        init = function (instance, init) {
+          return originalInitializer.call(instance, init);
+        };
+      }
+      ret.push(init);
+    }
+    if (kind !== 0) {
+      if (kind === 1) {
+        desc.get = value.get;
+        desc.set = value.set;
+      } else if (kind === 2) {
+        desc.value = value;
+      } else if (kind === 3) {
+        desc.get = value;
+      } else if (kind === 4) {
+        desc.set = value;
+      }
+      if (isPrivate) {
+        if (kind === 1) {
+          ret.push(function (instance, args) {
+            return value.get.call(instance, args);
+          });
+          ret.push(function (instance, args) {
+            return value.set.call(instance, args);
+          });
+        } else if (kind === 2) {
+          ret.push(value);
+        } else {
+          ret.push(function (instance, args) {
+            return value.call(instance, args);
+          });
+        }
+      } else {
+        Object.defineProperty(base, name, desc);
+      }
+    }
+  }
+  function applyMemberDecs(Class, decInfos, instanceBrand) {
+    var ret = [];
+    var protoInitializers;
+    var staticInitializers;
+    var staticBrand;
+    var existingProtoNonFields = new Map();
+    var existingStaticNonFields = new Map();
+    for (var i = 0; i < decInfos.length; i++) {
+      var decInfo = decInfos[i];
+      if (!Array.isArray(decInfo)) continue;
+      var kind = decInfo[1];
+      var name = decInfo[2];
+      var isPrivate = decInfo.length > 3;
+      var isStatic = kind >= 5;
+      var base;
+      var initializers;
+      var hasPrivateBrand = instanceBrand;
+      if (isStatic) {
+        base = Class;
+        kind = kind - 5;
+        if (kind !== 0) {
+          staticInitializers = staticInitializers || [];
+          initializers = staticInitializers;
+        }
+        if (isPrivate && !staticBrand) {
+          staticBrand = function (_) {
+            return _checkInRHS(_) === Class;
+          };
+        }
+        hasPrivateBrand = staticBrand;
+      } else {
+        base = Class.prototype;
+        if (kind !== 0) {
+          protoInitializers = protoInitializers || [];
+          initializers = protoInitializers;
+        }
+      }
+      if (kind !== 0 && !isPrivate) {
+        var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+        var existingKind = existingNonFields.get(name) || 0;
+        if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) {
+          throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+        } else if (!existingKind && kind > 2) {
+          existingNonFields.set(name, kind);
+        } else {
+          existingNonFields.set(name, true);
+        }
+      }
+      applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, hasPrivateBrand);
+    }
+    pushInitializers(ret, protoInitializers);
+    pushInitializers(ret, staticInitializers);
+    return ret;
+  }
+  function pushInitializers(ret, initializers) {
+    if (initializers) {
+      ret.push(function (instance) {
+        for (var i = 0; i < initializers.length; i++) {
+          initializers[i].call(instance);
+        }
+        return instance;
+      });
+    }
+  }
+  function applyClassDecs(targetClass, classDecs) {
+    if (classDecs.length > 0) {
+      var initializers = [];
+      var newClass = targetClass;
+      var name = targetClass.name;
+      for (var i = classDecs.length - 1; i >= 0; i--) {
+        var decoratorFinishedRef = {
+          v: false
+        };
+        try {
+          var nextNewClass = classDecs[i](newClass, {
+            kind: "class",
+            name: name,
+            addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef)
+          });
+        } finally {
+          decoratorFinishedRef.v = true;
+        }
+        if (nextNewClass !== undefined) {
+          assertValidReturnValue(10, nextNewClass);
+          newClass = nextNewClass;
+        }
+      }
+      return [newClass, function () {
+        for (var i = 0; i < initializers.length; i++) {
+          initializers[i].call(newClass);
+        }
+      }];
+    }
+  }
+  return function applyDecs2301(targetClass, memberDecs, classDecs, instanceBrand) {
+    return {
+      e: applyMemberDecs(targetClass, memberDecs, instanceBrand),
+      get c() {
+        return applyClassDecs(targetClass, classDecs);
+      }
+    };
+  };
+}
+function applyDecs2301(targetClass, memberDecs, classDecs, instanceBrand) {
+  return (exports.default = applyDecs2301 = applyDecs2301Factory())(targetClass, memberDecs, classDecs, instanceBrand);
+}
+
+//# sourceMappingURL=applyDecs2301.js.map
--- a/node_modules/@babel/helpers/lib/helpers/awaitAsyncGenerator.js.map
+++ b/node_modules/@babel/helpers/lib/helpers/awaitAsyncGenerator.js.map
@@ -0,0 +1 @@
+{"version":3,"names":["_OverloadYield","require","_awaitAsyncGenerator","value","OverloadYield"],"sources":["../../src/helpers/awaitAsyncGenerator.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nimport OverloadYield from \"./OverloadYield.ts\";\n\nexport default function _awaitAsyncGenerator<T>(value: T) {\n  return new OverloadYield<T>(value, /* kind: await */ 0);\n}\n"],"mappings":";;;;;;AAEA,IAAAA,cAAA,GAAAC,OAAA;AAEe,SAASC,oBAAoBA,CAAIC,KAAQ,EAAE;EACxD,OAAO,IAAIC,sBAAa,CAAID,KAAK,EAAoB,CAAC,CAAC;AACzD","ignoreList":[]}
--- a/node_modules/@babel/helpers/lib/helpers/checkPrivateRedeclaration.js
+++ b/node_modules/@babel/helpers/lib/helpers/checkPrivateRedeclaration.js
@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _checkPrivateRedeclaration;
+function _checkPrivateRedeclaration(obj, privateCollection) {
+  if (privateCollection.has(obj)) {
+    throw new TypeError("Cannot initialize the same private elements twice on an object");
+  }
+}
+
+//# sourceMappingURL=checkPrivateRedeclaration.js.map
--- a/node_modules/@babel/helpers/lib/helpers/classCheckPrivateStaticAccess.js
+++ b/node_modules/@babel/helpers/lib/helpers/classCheckPrivateStaticAccess.js
@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _classCheckPrivateStaticAccess;
+var _assertClassBrand = require("assertClassBrand");
+function _classCheckPrivateStaticAccess(receiver, classConstructor, returnValue) {
+  return _assertClassBrand(classConstructor, receiver, returnValue);
+}
+
+//# sourceMappingURL=classCheckPrivateStaticAccess.js.map
--- a/node_modules/@babel/helpers/lib/helpers/classPrivateFieldSet2.js
+++ b/node_modules/@babel/helpers/lib/helpers/classPrivateFieldSet2.js
@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _classPrivateFieldSet2;
+var _assertClassBrand = require("./assertClassBrand.js");
+function _classPrivateFieldSet2(privateMap, receiver, value) {
+  privateMap.set((0, _assertClassBrand.default)(privateMap, receiver), value);
+  return value;
+}
+
+//# sourceMappingURL=classPrivateFieldSet2.js.map
--- a/node_modules/@babel/helpers/lib/helpers/classStaticPrivateMethodGet.js
+++ b/node_modules/@babel/helpers/lib/helpers/classStaticPrivateMethodGet.js
@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _classStaticPrivateMethodGet;
+var _assertClassBrand = require("./assertClassBrand.js");
+function _classStaticPrivateMethodGet(receiver, classConstructor, method) {
+  (0, _assertClassBrand.default)(classConstructor, receiver);
+  return method;
+}
+
+//# sourceMappingURL=classStaticPrivateMethodGet.js.map
--- a/node_modules/@babel/helpers/lib/helpers/inheritsLoose.js
+++ b/node_modules/@babel/helpers/lib/helpers/inheritsLoose.js
@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _inheritsLoose;
+var _setPrototypeOf = require("./setPrototypeOf.js");
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  (0, _setPrototypeOf.default)(subClass, superClass);
+}
+
+//# sourceMappingURL=inheritsLoose.js.map
--- a/node_modules/@babel/helpers/lib/helpers/initializerDefineProperty.js
+++ b/node_modules/@babel/helpers/lib/helpers/initializerDefineProperty.js
@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _initializerDefineProperty;
+function _initializerDefineProperty(target, property, descriptor, context) {
+  if (!descriptor) return;
+  Object.defineProperty(target, property, {
+    enumerable: descriptor.enumerable,
+    configurable: descriptor.configurable,
+    writable: descriptor.writable,
+    value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
+  });
+}
+
+//# sourceMappingURL=initializerDefineProperty.js.map
--- a/node_modules/@babel/helpers/lib/helpers/initializerDefineProperty.js.map
+++ b/node_modules/@babel/helpers/lib/helpers/initializerDefineProperty.js.map
@@ -0,0 +1 @@
+{"version":3,"names":["_initializerDefineProperty","target","property","descriptor","context","Object","defineProperty","enumerable","configurable","writable","value","initializer","call"],"sources":["../../src/helpers/initializerDefineProperty.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\ninterface DescriptorWithInitializer extends PropertyDescriptor {\n  initializer?: () => any;\n}\n\nexport default function _initializerDefineProperty<T>(\n  target: T,\n  property: PropertyKey,\n  descriptor: DescriptorWithInitializer | undefined,\n  context: DecoratorContext,\n): void {\n  if (!descriptor) return;\n\n  Object.defineProperty(target, property, {\n    enumerable: descriptor.enumerable,\n    configurable: descriptor.configurable,\n    writable: descriptor.writable,\n    value: descriptor.initializer\n      ? descriptor.initializer.call(context)\n      : void 0,\n  });\n}\n"],"mappings":";;;;;;AAMe,SAASA,0BAA0BA,CAChDC,MAAS,EACTC,QAAqB,EACrBC,UAAiD,EACjDC,OAAyB,EACnB;EACN,IAAI,CAACD,UAAU,EAAE;EAEjBE,MAAM,CAACC,cAAc,CAACL,MAAM,EAAEC,QAAQ,EAAE;IACtCK,UAAU,EAAEJ,UAAU,CAACI,UAAU;IACjCC,YAAY,EAAEL,UAAU,CAACK,YAAY;IACrCC,QAAQ,EAAEN,UAAU,CAACM,QAAQ;IAC7BC,KAAK,EAAEP,UAAU,CAACQ,WAAW,GACzBR,UAAU,CAACQ,WAAW,CAACC,IAAI,CAACR,OAAO,CAAC,GACpC,KAAK;EACX,CAAC,CAAC;AACJ","ignoreList":[]}
--- a/node_modules/@babel/helpers/lib/helpers/iterableToArray.js
+++ b/node_modules/@babel/helpers/lib/helpers/iterableToArray.js
@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _iterableToArray;
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+    return Array.from(iter);
+  }
+}
+
+//# sourceMappingURL=iterableToArray.js.map
--- a/node_modules/@babel/helpers/lib/helpers/iterableToArrayLimit.js.map
+++ b/node_modules/@babel/helpers/lib/helpers/iterableToArrayLimit.js.map
@@ -0,0 +1 @@
+{"version":3,"names":["_iterableToArrayLimit","arr","i","iterator","Symbol","_arr","iteratorNormalCompletion","didIteratorError","step","iteratorError","next","_return","call","Object","done","push","value","length","err"],"sources":["../../src/helpers/iterableToArrayLimit.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _iterableToArrayLimit<T>(arr: Iterable<T>, i: number) {\n  // this is an expanded form of \\`for...of\\` that properly supports abrupt completions of\n  // iterators etc.\n\n  var iterator: Iterator<T> =\n    arr == null\n      ? null\n      : (typeof Symbol !== \"undefined\" && arr[Symbol.iterator]) ||\n        (arr as any)[\"@@iterator\"];\n  if (iterator == null) return;\n\n  var _arr: T[] = [];\n  var iteratorNormalCompletion = true;\n  var didIteratorError = false;\n  var step, iteratorError, next, _return;\n  try {\n    next = (iterator = (iterator as unknown as Function).call(arr)).next;\n    if (i === 0) {\n      if (Object(iterator) !== iterator) return;\n      iteratorNormalCompletion = false;\n    } else {\n      for (\n        ;\n        !(iteratorNormalCompletion = (step = next.call(iterator)).done);\n        iteratorNormalCompletion = true\n      ) {\n        _arr.push(step.value);\n        if (_arr.length === i) break;\n      }\n    }\n  } catch (err) {\n    didIteratorError = true;\n    iteratorError = err;\n  } finally {\n    try {\n      if (!iteratorNormalCompletion && iterator[\"return\"] != null) {\n        _return = iterator[\"return\"]();\n        // eslint-disable-next-line no-unsafe-finally\n        if (Object(_return) !== _return) return;\n      }\n    } finally {\n      // eslint-disable-next-line no-unsafe-finally\n      if (didIteratorError) throw iteratorError;\n    }\n  }\n  return _arr;\n}\n"],"mappings":";;;;;;AAEe,SAASA,qBAAqBA,CAAIC,GAAgB,EAAEC,CAAS,EAAE;EAI5E,IAAIC,QAAqB,GACvBF,GAAG,IAAI,IAAI,GACP,IAAI,GACH,OAAOG,MAAM,KAAK,WAAW,IAAIH,GAAG,CAACG,MAAM,CAACD,QAAQ,CAAC,IACrDF,GAAG,CAAS,YAAY,CAAC;EAChC,IAAIE,QAAQ,IAAI,IAAI,EAAE;EAEtB,IAAIE,IAAS,GAAG,EAAE;EAClB,IAAIC,wBAAwB,GAAG,IAAI;EACnC,IAAIC,gBAAgB,GAAG,KAAK;EAC5B,IAAIC,IAAI,EAAEC,aAAa,EAAEC,IAAI,EAAEC,OAAO;EACtC,IAAI;IACFD,IAAI,GAAG,CAACP,QAAQ,GAAIA,QAAQ,CAAyBS,IAAI,CAACX,GAAG,CAAC,EAAES,IAAI;IACpE,IAAIR,CAAC,KAAK,CAAC,EAAE;MACX,IAAIW,MAAM,CAACV,QAAQ,CAAC,KAAKA,QAAQ,EAAE;MACnCG,wBAAwB,GAAG,KAAK;IAClC,CAAC,MAAM;MACL,OAEE,EAAEA,wBAAwB,GAAG,CAACE,IAAI,GAAGE,IAAI,CAACE,IAAI,CAACT,QAAQ,CAAC,EAAEW,IAAI,CAAC,EAC/DR,wBAAwB,GAAG,IAAI,EAC/B;QACAD,IAAI,CAACU,IAAI,CAACP,IAAI,CAACQ,KAAK,CAAC;QACrB,IAAIX,IAAI,CAACY,MAAM,KAAKf,CAAC,EAAE;MACzB;IACF;EACF,CAAC,CAAC,OAAOgB,GAAG,EAAE;IACZX,gBAAgB,GAAG,IAAI;IACvBE,aAAa,GAAGS,GAAG;EACrB,CAAC,SAAS;IACR,IAAI;MACF,IAAI,CAACZ,wBAAwB,IAAIH,QAAQ,CAAC,QAAQ,CAAC,IAAI,IAAI,EAAE;QAC3DQ,OAAO,GAAGR,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;QAE9B,IAAIU,MAAM,CAACF,OAAO,CAAC,KAAKA,OAAO,EAAE;MACnC;IACF,CAAC,SAAS;MAER,IAAIJ,gBAAgB,EAAE,MAAME,aAAa;IAC3C;EACF;EACA,OAAOJ,IAAI;AACb","ignoreList":[]}
--- a/node_modules/@babel/helpers/lib/helpers/nonIterableRest.js.map
+++ b/node_modules/@babel/helpers/lib/helpers/nonIterableRest.js.map
@@ -0,0 +1 @@
+{"version":3,"names":["_nonIterableRest","TypeError"],"sources":["../../src/helpers/nonIterableRest.js"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _nonIterableRest() {\n  throw new TypeError(\n    \"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\",\n  );\n}\n"],"mappings":";;;;;;AAEe,SAASA,gBAAgBA,CAAA,EAAG;EACzC,MAAM,IAAIC,SAAS,CACjB,2IACF,CAAC;AACH","ignoreList":[]}
--- a/node_modules/@babel/helpers/lib/helpers/objectWithoutProperties.js
+++ b/node_modules/@babel/helpers/lib/helpers/objectWithoutProperties.js
@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _objectWithoutProperties;
+var _objectWithoutPropertiesLoose = require("./objectWithoutPropertiesLoose.js");
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+  var target = (0, _objectWithoutPropertiesLoose.default)(source, excluded);
+  var key, i;
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) !== -1) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+
+//# sourceMappingURL=objectWithoutProperties.js.map
--- a/node_modules/@babel/helpers/lib/helpers/objectWithoutPropertiesLoose.js.map
+++ b/node_modules/@babel/helpers/lib/helpers/objectWithoutPropertiesLoose.js.map
@@ -0,0 +1 @@
+{"version":3,"names":["_objectWithoutPropertiesLoose","source","excluded","target","key","Object","prototype","hasOwnProperty","call","indexOf"],"sources":["../../src/helpers/objectWithoutPropertiesLoose.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _objectWithoutPropertiesLoose<\n  T extends object,\n  K extends PropertyKey[],\n>(\n  source: T | null | undefined,\n  excluded: K,\n): Pick<T, Exclude<keyof T, K[number]>>;\nexport default function _objectWithoutPropertiesLoose<\n  T extends object,\n  K extends (keyof T)[],\n>(source: T | null | undefined, excluded: K): Omit<T, K[number]>;\nexport default function _objectWithoutPropertiesLoose<T extends object>(\n  source: T | null | undefined,\n  excluded: PropertyKey[],\n): Partial<T> {\n  if (source == null) return {};\n\n  var target: Partial<T> = {};\n\n  for (var key in source) {\n    if (Object.prototype.hasOwnProperty.call(source, key)) {\n      if (excluded.indexOf(key) !== -1) continue;\n      target[key] = source[key];\n    }\n  }\n\n  return target;\n}\n"],"mappings":";;;;;;AAae,SAASA,6BAA6BA,CACnDC,MAA4B,EAC5BC,QAAuB,EACX;EACZ,IAAID,MAAM,IAAI,IAAI,EAAE,OAAO,CAAC,CAAC;EAE7B,IAAIE,MAAkB,GAAG,CAAC,CAAC;EAE3B,KAAK,IAAIC,GAAG,IAAIH,MAAM,EAAE;IACtB,IAAII,MAAM,CAACC,SAAS,CAACC,cAAc,CAACC,IAAI,CAACP,MAAM,EAAEG,GAAG,CAAC,EAAE;MACrD,IAAIF,QAAQ,CAACO,OAAO,CAACL,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE;MAClCD,MAAM,CAACC,GAAG,CAAC,GAAGH,MAAM,CAACG,GAAG,CAAC;IAC3B;EACF;EAEA,OAAOD,MAAM;AACf","ignoreList":[]}
--- a/node_modules/@babel/helpers/lib/helpers/regeneratorAsyncGen.js
+++ b/node_modules/@babel/helpers/lib/helpers/regeneratorAsyncGen.js
@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _regeneratorAsyncGen;
+var _regenerator = require("./regenerator.js");
+var _regeneratorAsyncIterator = require("./regeneratorAsyncIterator.js");
+function _regeneratorAsyncGen(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+  return new _regeneratorAsyncIterator.default((0, _regenerator.default)().w(innerFn, outerFn, self, tryLocsList), PromiseImpl || Promise);
+}
+
+//# sourceMappingURL=regeneratorAsyncGen.js.map
--- a/node_modules/@babel/helpers/lib/helpers/regeneratorAsyncGen.js.map
+++ b/node_modules/@babel/helpers/lib/helpers/regeneratorAsyncGen.js.map
@@ -0,0 +1 @@
+{"version":3,"names":["_regenerator","require","_regeneratorAsyncIterator","_regeneratorAsyncGen","innerFn","outerFn","self","tryLocsList","PromiseImpl","regeneratorAsyncIterator","regenerator","w","Promise"],"sources":["../../src/helpers/regeneratorAsyncGen.ts"],"sourcesContent":["/* @minVersion 7.27.0 */\n/* @mangleFns */\n\nimport regenerator from \"./regenerator.ts\";\nimport regeneratorAsyncIterator from \"./regeneratorAsyncIterator.ts\";\n\nexport default /* @no-mangle */ function _regeneratorAsyncGen(\n  innerFn: Function,\n  outerFn: Function,\n  self: any,\n  tryLocsList: any[],\n  PromiseImpl: PromiseConstructor | undefined,\n) {\n  return new (regeneratorAsyncIterator as any)(\n    regenerator().w(innerFn as any, outerFn, self, tryLocsList),\n    PromiseImpl || Promise,\n  );\n}\n"],"mappings":";;;;;;AAGA,IAAAA,YAAA,GAAAC,OAAA;AACA,IAAAC,yBAAA,GAAAD,OAAA;AAEgC,SAASE,oBAAoBA,CAC3DC,OAAiB,EACjBC,OAAiB,EACjBC,IAAS,EACTC,WAAkB,EAClBC,WAA2C,EAC3C;EACA,OAAO,IAAKC,iCAAwB,CAClC,IAAAC,oBAAW,EAAC,CAAC,CAACC,CAAC,CAACP,OAAO,EAASC,OAAO,EAAEC,IAAI,EAAEC,WAAW,CAAC,EAC3DC,WAAW,IAAII,OACjB,CAAC;AACH","ignoreList":[]}
--- a/node_modules/@babel/helpers/lib/helpers/regeneratorAsyncIterator.js
+++ b/node_modules/@babel/helpers/lib/helpers/regeneratorAsyncIterator.js
@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = AsyncIterator;
+var _OverloadYield = require("./OverloadYield.js");
+var _regeneratorDefine = require("./regeneratorDefine.js");
+function AsyncIterator(generator, PromiseImpl) {
+  if (!this.next) {
+    (0, _regeneratorDefine.default)(AsyncIterator.prototype);
+    (0, _regeneratorDefine.default)(AsyncIterator.prototype, typeof Symbol === "function" && Symbol.asyncIterator || "@asyncIterator", function () {
+      return this;
+    });
+  }
+  function invoke(method, arg, resolve, reject) {
+    try {
+      var result = generator[method](arg);
+      var value = result.value;
+      if (value instanceof _OverloadYield.default) {
+        return PromiseImpl.resolve(value.v).then(function (value) {
+          invoke("next", value, resolve, reject);
+        }, function (err) {
+          invoke("throw", err, resolve, reject);
+        });
+      }
+      return PromiseImpl.resolve(value).then(function (unwrapped) {
+        result.value = unwrapped;
+        resolve(result);
+      }, function (error) {
+        return invoke("throw", error, resolve, reject);
+      });
+    } catch (error) {
+      reject(error);
+    }
+  }
+  var previousPromise;
+  function enqueue(method, i, arg) {
+    function callInvokeWithMethodAndArg() {
+      return new PromiseImpl(function (resolve, reject) {
+        invoke(method, arg, resolve, reject);
+      });
+    }
+    return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+  }
+  (0, _regeneratorDefine.default)(this, "_invoke", enqueue, true);
+}
+
+//# sourceMappingURL=regeneratorAsyncIterator.js.map
--- a/node_modules/@babel/helpers/lib/helpers/regeneratorRuntime.js.map
+++ b/node_modules/@babel/helpers/lib/helpers/regeneratorRuntime.js.map
--- a/node_modules/@babel/helpers/lib/helpers/skipFirstGeneratorNext.js.map
+++ b/node_modules/@babel/helpers/lib/helpers/skipFirstGeneratorNext.js.map
@@ -0,0 +1 @@
+{"version":3,"names":["_skipFirstGeneratorNext","fn","it","apply","arguments","next"],"sources":["../../src/helpers/skipFirstGeneratorNext.js"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _skipFirstGeneratorNext(fn) {\n  return function () {\n    var it = fn.apply(this, arguments);\n    it.next();\n    return it;\n  };\n}\n"],"mappings":";;;;;;AAEe,SAASA,uBAAuBA,CAACC,EAAE,EAAE;EAClD,OAAO,YAAY;IACjB,IAAIC,EAAE,GAAGD,EAAE,CAACE,KAAK,CAAC,IAAI,EAAEC,SAAS,CAAC;IAClCF,EAAE,CAACG,IAAI,CAAC,CAAC;IACT,OAAOH,EAAE;EACX,CAAC;AACH","ignoreList":[]}
--- a/node_modules/@babel/helpers/lib/helpers/toArray.js
+++ b/node_modules/@babel/helpers/lib/helpers/toArray.js
@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _toArray;
+var _arrayWithHoles = require("./arrayWithHoles.js");
+var _iterableToArray = require("./iterableToArray.js");
+var _unsupportedIterableToArray = require("./unsupportedIterableToArray.js");
+var _nonIterableRest = require("./nonIterableRest.js");
+function _toArray(arr) {
+  return (0, _arrayWithHoles.default)(arr) || (0, _iterableToArray.default)(arr) || (0, _unsupportedIterableToArray.default)(arr) || (0, _nonIterableRest.default)();
+}
+
+//# sourceMappingURL=toArray.js.map
--- a/node_modules/@babel/helpers/lib/helpers/toPrimitive.js.map
+++ b/node_modules/@babel/helpers/lib/helpers/toPrimitive.js.map
@@ -0,0 +1 @@
+{"version":3,"names":["toPrimitive","input","hint","prim","Symbol","undefined","res","call","TypeError","String","Number"],"sources":["../../src/helpers/toPrimitive.ts"],"sourcesContent":["/* @minVersion 7.1.5 */\n\n// https://tc39.es/ecma262/#sec-toprimitive\nexport default function toPrimitive(\n  input: unknown,\n  hint?: \"default\" | \"string\" | \"number\",\n) {\n  if (typeof input !== \"object\" || !input) return input;\n  // @ts-expect-error Symbol.toPrimitive might not index {}\n  var prim = input[Symbol.toPrimitive];\n  if (prim !== undefined) {\n    var res = prim.call(input, hint || \"default\");\n    if (typeof res !== \"object\") return res;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (hint === \"string\" ? String : Number)(input);\n}\n"],"mappings":";;;;;;AAGe,SAASA,WAAWA,CACjCC,KAAc,EACdC,IAAsC,EACtC;EACA,IAAI,OAAOD,KAAK,KAAK,QAAQ,IAAI,CAACA,KAAK,EAAE,OAAOA,KAAK;EAErD,IAAIE,IAAI,GAAGF,KAAK,CAACG,MAAM,CAACJ,WAAW,CAAC;EACpC,IAAIG,IAAI,KAAKE,SAAS,EAAE;IACtB,IAAIC,GAAG,GAAGH,IAAI,CAACI,IAAI,CAACN,KAAK,EAAEC,IAAI,IAAI,SAAS,CAAC;IAC7C,IAAI,OAAOI,GAAG,KAAK,QAAQ,EAAE,OAAOA,GAAG;IACvC,MAAM,IAAIE,SAAS,CAAC,8CAA8C,CAAC;EACrE;EACA,OAAO,CAACN,IAAI,KAAK,QAAQ,GAAGO,MAAM,GAAGC,MAAM,EAAET,KAAK,CAAC;AACrD","ignoreList":[]}
--- a/node_modules/@babel/helpers/lib/helpers/typeof.js
+++ b/node_modules/@babel/helpers/lib/helpers/typeof.js
@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _typeof;
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    exports.default = _typeof = function (obj) {
+      return typeof obj;
+    };
+  } else {
+    exports.default = _typeof = function (obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    };
+  }
+  return _typeof(obj);
+}
+
+//# sourceMappingURL=typeof.js.map
--- a/node_modules/@babel/helpers/lib/helpers/usingCtx.js
+++ b/node_modules/@babel/helpers/lib/helpers/usingCtx.js
@@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _usingCtx;
+function _usingCtx() {
+  var _disposeSuppressedError = typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed) {
+      var err = new Error();
+      err.name = "SuppressedError";
+      err.error = error;
+      err.suppressed = suppressed;
+      return err;
+    },
+    empty = {},
+    stack = [];
+  function using(isAwait, value) {
+    if (value != null) {
+      if (Object(value) !== value) {
+        throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+      }
+      if (isAwait) {
+        var dispose = value[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+      }
+      if (dispose === undefined) {
+        dispose = value[Symbol.dispose || Symbol["for"]("Symbol.dispose")];
+        if (isAwait) {
+          var inner = dispose;
+        }
+      }
+      if (typeof dispose !== "function") {
+        throw new TypeError("Object is not disposable.");
+      }
+      if (inner) {
+        dispose = function () {
+          try {
+            inner.call(value);
+          } catch (e) {
+            return Promise.reject(e);
+          }
+        };
+      }
+      stack.push({
+        v: value,
+        d: dispose,
+        a: isAwait
+      });
+    } else if (isAwait) {
+      stack.push({
+        d: value,
+        a: isAwait
+      });
+    }
+    return value;
+  }
+  return {
+    e: empty,
+    u: using.bind(null, false),
+    a: using.bind(null, true),
+    d: function () {
+      var error = this.e,
+        state = 0,
+        resource;
+      function next() {
+        while (resource = stack.pop()) {
+          try {
+            if (!resource.a && state === 1) {
+              state = 0;
+              stack.push(resource);
+              return Promise.resolve().then(next);
+            }
+            if (resource.d) {
+              var disposalResult = resource.d.call(resource.v);
+              if (resource.a) {
+                state |= 2;
+                return Promise.resolve(disposalResult).then(next, err);
+              }
+            } else {
+              state |= 1;
+            }
+          } catch (e) {
+            return err(e);
+          }
+        }
+        if (state === 1) {
+          if (error !== empty) {
+            return Promise.reject(error);
+          } else {
+            return Promise.resolve();
+          }
+        }
+        if (error !== empty) throw error;
+      }
+      function err(e) {
+        error = error !== empty ? new _disposeSuppressedError(e, error) : e;
+        return next();
+      }
+      return next();
+    }
+  };
+}
+
+//# sourceMappingURL=usingCtx.js.map
--- a/node_modules/@babel/helpers/lib/helpers/wrapRegExp.js
+++ b/node_modules/@babel/helpers/lib/helpers/wrapRegExp.js
@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _wrapRegExp;
+var _setPrototypeOf = require("./setPrototypeOf.js");
+var _inherits = require("./inherits.js");
+function _wrapRegExp() {
+  exports.default = _wrapRegExp = function (re, groups) {
+    return new BabelRegExp(re, undefined, groups);
+  };
+  var _super = RegExp.prototype;
+  var _groups = new WeakMap();
+  function BabelRegExp(re, flags, groups) {
+    var _this = new RegExp(re, flags);
+    _groups.set(_this, groups || _groups.get(re));
+    return (0, _setPrototypeOf.default)(_this, BabelRegExp.prototype);
+  }
+  (0, _inherits.default)(BabelRegExp, RegExp);
+  BabelRegExp.prototype.exec = function (str) {
+    var result = _super.exec.call(this, str);
+    if (result) {
+      result.groups = buildGroups(result, this);
+      var indices = result.indices;
+      if (indices) indices.groups = buildGroups(indices, this);
+    }
+    return result;
+  };
+  BabelRegExp.prototype[Symbol.replace] = function (str, substitution) {
+    if (typeof substitution === "string") {
+      var groups = _groups.get(this);
+      return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)(>|$)/g, function (match, name, end) {
+        if (end === "") {
+          return match;
+        } else {
+          var group = groups[name];
+          return Array.isArray(group) ? "$" + group.join("$") : typeof group === "number" ? "$" + group : "";
+        }
+      }));
+    } else if (typeof substitution === "function") {
+      var _this = this;
+      return _super[Symbol.replace].call(this, str, function () {
+        var args = arguments;
+        if (typeof args[args.length - 1] !== "object") {
+          args = [].slice.call(args);
+          args.push(buildGroups(args, _this));
+        }
+        return substitution.apply(this, args);
+      });
+    } else {
+      return _super[Symbol.replace].call(this, str, substitution);
+    }
+  };
+  function buildGroups(result, re) {
+    var g = _groups.get(re);
+    return Object.keys(g).reduce(function (groups, name) {
+      var i = g[name];
+      if (typeof i === "number") groups[name] = result[i];else {
+        var k = 0;
+        while (result[i[k]] === undefined && k + 1 < i.length) {
+          k++;
+        }
+        groups[name] = result[i[k]];
+      }
+      return groups;
+    }, Object.create(null));
+  }
+  return _wrapRegExp.apply(this, arguments);
+}
+
+//# sourceMappingURL=wrapRegExp.js.map
--- a/node_modules/@babel/helpers/lib/index.js
+++ b/node_modules/@babel/helpers/lib/index.js
@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.get = get;
+exports.getDependencies = getDependencies;
+exports.isInternal = isInternal;
+exports.list = void 0;
+exports.minVersion = minVersion;
+var _t = require("@babel/types");
+var _helpersGenerated = require("./helpers-generated.js");
+const {
+  cloneNode,
+  identifier
+} = _t;
+function deep(obj, path, value) {
+  try {
+    const parts = path.split(".");
+    let last = parts.shift();
+    while (parts.length > 0) {
+      obj = obj[last];
+      last = parts.shift();
+    }
+    if (arguments.length > 2) {
+      obj[last] = value;
+    } else {
+      return obj[last];
+    }
+  } catch (e) {
+    e.message += ` (when accessing ${path})`;
+    throw e;
+  }
+}
+function permuteHelperAST(ast, metadata, bindingName, localBindings, getDependency, adjustAst) {
+  const {
+    locals,
+    dependencies,
+    exportBindingAssignments,
+    exportName
+  } = metadata;
+  const bindings = new Set(localBindings || []);
+  if (bindingName) bindings.add(bindingName);
+  for (const [name, paths] of (Object.entries || (o => Object.keys(o).map(k => [k, o[k]])))(locals)) {
+    let newName = name;
+    if (bindingName && name === exportName) {
+      newName = bindingName;
+    } else {
+      while (bindings.has(newName)) newName = "_" + newName;
+    }
+    if (newName !== name) {
+      for (const path of paths) {
+        deep(ast, path, identifier(newName));
+      }
+    }
+  }
+  for (const [name, paths] of (Object.entries || (o => Object.keys(o).map(k => [k, o[k]])))(dependencies)) {
+    const ref = typeof getDependency === "function" && getDependency(name) || identifier(name);
+    for (const path of paths) {
+      deep(ast, path, cloneNode(ref));
+    }
+  }
+  adjustAst == null || adjustAst(ast, exportName, map => {
+    exportBindingAssignments.forEach(p => deep(ast, p, map(deep(ast, p))));
+  });
+}
+const helperData = Object.create(null);
+function loadHelper(name) {
+  if (!helperData[name]) {
+    const helper = _helpersGenerated.default[name];
+    if (!helper) {
+      throw Object.assign(new ReferenceError(`Unknown helper ${name}`), {
+        code: "BABEL_HELPER_UNKNOWN",
+        helper: name
+      });
+    }
+    helperData[name] = {
+      minVersion: helper.minVersion,
+      build(getDependency, bindingName, localBindings, adjustAst) {
+        const ast = helper.ast();
+        permuteHelperAST(ast, helper.metadata, bindingName, localBindings, getDependency, adjustAst);
+        return {
+          nodes: ast.body,
+          globals: helper.metadata.globals
+        };
+      },
+      getDependencies() {
+        return Object.keys(helper.metadata.dependencies);
+      }
+    };
+  }
+  return helperData[name];
+}
+function get(name, getDependency, bindingName, localBindings, adjustAst) {
+  if (typeof bindingName === "object") {
+    const id = bindingName;
+    if ((id == null ? void 0 : id.type) === "Identifier") {
+      bindingName = id.name;
+    } else {
+      bindingName = undefined;
+    }
+  }
+  return loadHelper(name).build(getDependency, bindingName, localBindings, adjustAst);
+}
+function minVersion(name) {
+  return loadHelper(name).minVersion;
+}
+function getDependencies(name) {
+  return loadHelper(name).getDependencies();
+}
+function isInternal(name) {
+  var _helpers$name;
+  return (_helpers$name = _helpersGenerated.default[name]) == null ? void 0 : _helpers$name.metadata.internal;
+}
+exports.ensure = name => {
+  loadHelper(name);
+};
+const list = exports.list = Object.keys(_helpersGenerated.default).map(name => name.replace(/^_/, ""));
+var _default = exports.default = get;
+
+//# sourceMappingURL=index.js.map
--- a/node_modules/@babel/parser/README.md
+++ b/node_modules/@babel/parser/README.md
@@ -0,0 +1,19 @@
+# @babel/parser
+
+> A JavaScript parser
+
+See our website [@babel/parser](https://babeljs.io/docs/babel-parser) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20parser%22+is%3Aopen) associated with this package.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/parser
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/parser --dev
+```
--- a/node_modules/@babel/runtime/README.md
+++ b/node_modules/@babel/runtime/README.md
@@ -0,0 +1,19 @@
+# @babel/runtime
+
+> babel's modular runtime helpers
+
+See our website [@babel/runtime](https://babeljs.io/docs/babel-runtime) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/runtime
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/runtime
+```
--- a/node_modules/@babel/runtime/helpers/applyDecs2311.js
+++ b/node_modules/@babel/runtime/helpers/applyDecs2311.js
@@ -0,0 +1,124 @@
+var _typeof = require("./typeof.js")["default"];
+var checkInRHS = require("./checkInRHS.js");
+var setFunctionName = require("./setFunctionName.js");
+var toPropertyKey = require("./toPropertyKey.js");
+function applyDecs2311(e, t, n, r, o, i) {
+  var a,
+    c,
+    u,
+    s,
+    f,
+    l,
+    p,
+    d = Symbol.metadata || Symbol["for"]("Symbol.metadata"),
+    m = Object.defineProperty,
+    h = Object.create,
+    y = [h(null), h(null)],
+    v = t.length;
+  function g(t, n, r) {
+    return function (o, i) {
+      n && (i = o, o = e);
+      for (var a = 0; a < t.length; a++) i = t[a].apply(o, r ? [i] : []);
+      return r ? i : o;
+    };
+  }
+  function b(e, t, n, r) {
+    if ("function" != typeof e && (r || void 0 !== e)) throw new TypeError(t + " must " + (n || "be") + " a function" + (r ? "" : " or undefined"));
+    return e;
+  }
+  function applyDec(e, t, n, r, o, i, u, s, f, l, p) {
+    function d(e) {
+      if (!p(e)) throw new TypeError("Attempted to access private element on non-instance");
+    }
+    var h = [].concat(t[0]),
+      v = t[3],
+      w = !u,
+      D = 1 === o,
+      S = 3 === o,
+      j = 4 === o,
+      E = 2 === o;
+    function I(t, n, r) {
+      return function (o, i) {
+        return n && (i = o, o = e), r && r(o), P[t].call(o, i);
+      };
+    }
+    if (!w) {
+      var P = {},
+        k = [],
+        F = S ? "get" : j || D ? "set" : "value";
+      if (f ? (l || D ? P = {
+        get: setFunctionName(function () {
+          return v(this);
+        }, r, "get"),
+        set: function set(e) {
+          t[4](this, e);
+        }
+      } : P[F] = v, l || setFunctionName(P[F], r, E ? "" : F)) : l || (P = Object.getOwnPropertyDescriptor(e, r)), !l && !f) {
+        if ((c = y[+s][r]) && 7 !== (c ^ o)) throw Error("Decorating two elements with the same name (" + P[F].name + ") is not supported yet");
+        y[+s][r] = o < 3 ? 1 : o;
+      }
+    }
+    for (var N = e, O = h.length - 1; O >= 0; O -= n ? 2 : 1) {
+      var T = b(h[O], "A decorator", "be", !0),
+        z = n ? h[O - 1] : void 0,
+        A = {},
+        H = {
+          kind: ["field", "accessor", "method", "getter", "setter", "class"][o],
+          name: r,
+          metadata: a,
+          addInitializer: function (e, t) {
+            if (e.v) throw new TypeError("attempted to call addInitializer after decoration was finished");
+            b(t, "An initializer", "be", !0), i.push(t);
+          }.bind(null, A)
+        };
+      if (w) c = T.call(z, N, H), A.v = 1, b(c, "class decorators", "return") && (N = c);else if (H["static"] = s, H["private"] = f, c = H.access = {
+        has: f ? p.bind() : function (e) {
+          return r in e;
+        }
+      }, j || (c.get = f ? E ? function (e) {
+        return d(e), P.value;
+      } : I("get", 0, d) : function (e) {
+        return e[r];
+      }), E || S || (c.set = f ? I("set", 0, d) : function (e, t) {
+        e[r] = t;
+      }), N = T.call(z, D ? {
+        get: P.get,
+        set: P.set
+      } : P[F], H), A.v = 1, D) {
+        if ("object" == _typeof(N) && N) (c = b(N.get, "accessor.get")) && (P.get = c), (c = b(N.set, "accessor.set")) && (P.set = c), (c = b(N.init, "accessor.init")) && k.unshift(c);else if (void 0 !== N) throw new TypeError("accessor decorators must return an object with get, set, or init properties or undefined");
+      } else b(N, (l ? "field" : "method") + " decorators", "return") && (l ? k.unshift(N) : P[F] = N);
+    }
+    return o < 2 && u.push(g(k, s, 1), g(i, s, 0)), l || w || (f ? D ? u.splice(-1, 0, I("get", s), I("set", s)) : u.push(E ? P[F] : b.call.bind(P[F])) : m(e, r, P)), N;
+  }
+  function w(e) {
+    return m(e, d, {
+      configurable: !0,
+      enumerable: !0,
+      value: a
+    });
+  }
+  return void 0 !== i && (a = i[d]), a = h(null == a ? null : a), f = [], l = function l(e) {
+    e && f.push(g(e));
+  }, p = function p(t, r) {
+    for (var i = 0; i < n.length; i++) {
+      var a = n[i],
+        c = a[1],
+        l = 7 & c;
+      if ((8 & c) == t && !l == r) {
+        var p = a[2],
+          d = !!a[3],
+          m = 16 & c;
+        applyDec(t ? e : e.prototype, a, m, d ? "#" + p : toPropertyKey(p), l, l < 2 ? [] : t ? s = s || [] : u = u || [], f, !!t, d, r, t && d ? function (t) {
+          return checkInRHS(t) === e;
+        } : o);
+      }
+    }
+  }, p(8, 0), p(0, 0), p(8, 1), p(0, 1), l(u), l(s), c = f, v || w(e), {
+    e: c,
+    get c() {
+      var n = [];
+      return v && [w(e = applyDec(e, [t], r, e.name, 5, n)), g(n, 1)];
+    }
+  };
+}
+module.exports = applyDecs2311, module.exports.__esModule = true, module.exports["default"] = module.exports;
--- a/node_modules/@babel/runtime/helpers/arrayLikeToArray.js
+++ b/node_modules/@babel/runtime/helpers/arrayLikeToArray.js
@@ -0,0 +1,6 @@
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+module.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
--- a/node_modules/@babel/runtime/helpers/classPrivateFieldGet.js
+++ b/node_modules/@babel/runtime/helpers/classPrivateFieldGet.js
@@ -0,0 +1,7 @@
+var classApplyDescriptorGet = require("./classApplyDescriptorGet.js");
+var classPrivateFieldGet2 = require("./classPrivateFieldGet2.js");
+function _classPrivateFieldGet(e, t) {
+  var r = classPrivateFieldGet2(t, e);
+  return classApplyDescriptorGet(e, r);
+}
+module.exports = _classPrivateFieldGet, module.exports.__esModule = true, module.exports["default"] = module.exports;
--- a/node_modules/@babel/runtime/helpers/classStaticPrivateFieldSpecGet.js
+++ b/node_modules/@babel/runtime/helpers/classStaticPrivateFieldSpecGet.js
@@ -0,0 +1,7 @@
+var classApplyDescriptorGet = require("./classApplyDescriptorGet.js");
+var assertClassBrand = require("./assertClassBrand.js");
+var classCheckPrivateStaticFieldDescriptor = require("./classCheckPrivateStaticFieldDescriptor.js");
+function _classStaticPrivateFieldSpecGet(t, s, r) {
+  return assertClassBrand(s, t), classCheckPrivateStaticFieldDescriptor(r, "get"), classApplyDescriptorGet(t, r);
+}
+module.exports = _classStaticPrivateFieldSpecGet, module.exports.__esModule = true, module.exports["default"] = module.exports;
--- a/node_modules/@babel/runtime/helpers/createForOfIteratorHelper.js
+++ b/node_modules/@babel/runtime/helpers/createForOfIteratorHelper.js
@@ -0,0 +1,50 @@
+var unsupportedIterableToArray = require("./unsupportedIterableToArray.js");
+function _createForOfIteratorHelper(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+      t && (r = t);
+      var _n = 0,
+        F = function F() {};
+      return {
+        s: F,
+        n: function n() {
+          return _n >= r.length ? {
+            done: !0
+          } : {
+            done: !1,
+            value: r[_n++]
+          };
+        },
+        e: function e(r) {
+          throw r;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var o,
+    a = !0,
+    u = !1;
+  return {
+    s: function s() {
+      t = t.call(r);
+    },
+    n: function n() {
+      var r = t.next();
+      return a = r.done, r;
+    },
+    e: function e(r) {
+      u = !0, o = r;
+    },
+    f: function f() {
+      try {
+        a || null == t["return"] || t["return"]();
+      } finally {
+        if (u) throw o;
+      }
+    }
+  };
+}
+module.exports = _createForOfIteratorHelper, module.exports.__esModule = true, module.exports["default"] = module.exports;
--- a/node_modules/@babel/runtime/helpers/dispose.js
+++ b/node_modules/@babel/runtime/helpers/dispose.js
@@ -0,0 +1,28 @@
+function dispose_SuppressedError(r, e) {
+  return "undefined" != typeof SuppressedError ? dispose_SuppressedError = SuppressedError : (dispose_SuppressedError = function dispose_SuppressedError(r, e) {
+    this.suppressed = e, this.error = r, this.stack = Error().stack;
+  }, dispose_SuppressedError.prototype = Object.create(Error.prototype, {
+    constructor: {
+      value: dispose_SuppressedError,
+      writable: !0,
+      configurable: !0
+    }
+  })), new dispose_SuppressedError(r, e);
+}
+function _dispose(r, e, s) {
+  function next() {
+    for (; r.length > 0;) try {
+      var o = r.pop(),
+        p = o.d.call(o.v);
+      if (o.a) return Promise.resolve(p).then(next, err);
+    } catch (r) {
+      return err(r);
+    }
+    if (s) throw e;
+  }
+  function err(r) {
+    return e = s ? new dispose_SuppressedError(e, r) : r, s = !0, next();
+  }
+  return next();
+}
+module.exports = _dispose, module.exports.__esModule = true, module.exports["default"] = module.exports;
--- a/node_modules/@babel/runtime/helpers/esm/OverloadYield.js
+++ b/node_modules/@babel/runtime/helpers/esm/OverloadYield.js
@@ -0,0 +1,4 @@
+function _OverloadYield(e, d) {
+  this.v = e, this.k = d;
+}
+export { _OverloadYield as default };
--- a/node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js
+++ b/node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js
@@ -0,0 +1,26 @@
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+  try {
+    var i = n[a](c),
+      u = i.value;
+  } catch (n) {
+    return void e(n);
+  }
+  i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+  return function () {
+    var t = this,
+      e = arguments;
+    return new Promise(function (r, o) {
+      var a = n.apply(t, e);
+      function _next(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+      }
+      function _throw(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+      }
+      _next(void 0);
+    });
+  };
+}
+export { _asyncToGenerator as default };
--- a/node_modules/@babel/runtime/helpers/esm/classPrivateFieldGet.js
+++ b/node_modules/@babel/runtime/helpers/esm/classPrivateFieldGet.js
@@ -0,0 +1,7 @@
+import classApplyDescriptorGet from "./classApplyDescriptorGet.js";
+import classPrivateFieldGet2 from "./classPrivateFieldGet2.js";
+function _classPrivateFieldGet(e, t) {
+  var r = classPrivateFieldGet2(t, e);
+  return classApplyDescriptorGet(e, r);
+}
+export { _classPrivateFieldGet as default };
--- a/node_modules/@babel/runtime/helpers/esm/classPrivateFieldLooseBase.js
+++ b/node_modules/@babel/runtime/helpers/esm/classPrivateFieldLooseBase.js
@@ -0,0 +1,5 @@
+function _classPrivateFieldBase(e, t) {
+  if (!{}.hasOwnProperty.call(e, t)) throw new TypeError("attempted to use private field on non-instance");
+  return e;
+}
+export { _classPrivateFieldBase as default };
--- a/node_modules/@babel/runtime/helpers/esm/createSuper.js
+++ b/node_modules/@babel/runtime/helpers/esm/createSuper.js
@@ -0,0 +1,16 @@
+import getPrototypeOf from "./getPrototypeOf.js";
+import isNativeReflectConstruct from "./isNativeReflectConstruct.js";
+import possibleConstructorReturn from "./possibleConstructorReturn.js";
+function _createSuper(t) {
+  var r = isNativeReflectConstruct();
+  return function () {
+    var e,
+      o = getPrototypeOf(t);
+    if (r) {
+      var s = getPrototypeOf(this).constructor;
+      e = Reflect.construct(o, arguments, s);
+    } else e = o.apply(this, arguments);
+    return possibleConstructorReturn(this, e);
+  };
+}
+export { _createSuper as default };
--- a/node_modules/@babel/runtime/helpers/esm/defineProperty.js
+++ b/node_modules/@babel/runtime/helpers/esm/defineProperty.js
@@ -0,0 +1,10 @@
+import toPropertyKey from "./toPropertyKey.js";
+function _defineProperty(e, r, t) {
+  return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
+export { _defineProperty as default };
--- a/node_modules/@babel/runtime/helpers/esm/regeneratorDefine.js
+++ b/node_modules/@babel/runtime/helpers/esm/regeneratorDefine.js
@@ -0,0 +1,22 @@
+function _regeneratorDefine(e, r, n, t) {
+  var i = Object.defineProperty;
+  try {
+    i({}, "", {});
+  } catch (e) {
+    i = 0;
+  }
+  _regeneratorDefine = function regeneratorDefine(e, r, n, t) {
+    function o(r, n) {
+      _regeneratorDefine(e, r, function (e) {
+        return this._invoke(r, n, e);
+      });
+    }
+    r ? i ? i(e, r, {
+      value: n,
+      enumerable: !t,
+      configurable: !t,
+      writable: !t
+    }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2));
+  }, _regeneratorDefine(e, r, n, t);
+}
+export { _regeneratorDefine as default };
--- a/node_modules/@babel/runtime/helpers/esm/regeneratorValues.js
+++ b/node_modules/@babel/runtime/helpers/esm/regeneratorValues.js
@@ -0,0 +1,19 @@
+import _typeof from "./typeof.js";
+function _regeneratorValues(e) {
+  if (null != e) {
+    var t = e["function" == typeof Symbol && Symbol.iterator || "@@iterator"],
+      r = 0;
+    if (t) return t.call(e);
+    if ("function" == typeof e.next) return e;
+    if (!isNaN(e.length)) return {
+      next: function next() {
+        return e && r >= e.length && (e = void 0), {
+          value: e && e[r++],
+          done: !e
+        };
+      }
+    };
+  }
+  throw new TypeError(_typeof(e) + " is not iterable");
+}
+export { _regeneratorValues as default };
--- a/node_modules/@babel/runtime/helpers/esm/toArray.js
+++ b/node_modules/@babel/runtime/helpers/esm/toArray.js
@@ -0,0 +1,8 @@
+import arrayWithHoles from "./arrayWithHoles.js";
+import iterableToArray from "./iterableToArray.js";
+import unsupportedIterableToArray from "./unsupportedIterableToArray.js";
+import nonIterableRest from "./nonIterableRest.js";
+function _toArray(r) {
+  return arrayWithHoles(r) || iterableToArray(r) || unsupportedIterableToArray(r) || nonIterableRest();
+}
+export { _toArray as default };
--- a/node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+++ b/node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
@@ -0,0 +1,7 @@
+import _typeof from "./typeof.js";
+import toPrimitive from "./toPrimitive.js";
+function toPropertyKey(t) {
+  var i = toPrimitive(t, "string");
+  return "symbol" == _typeof(i) ? i : i + "";
+}
+export { toPropertyKey as default };
--- a/node_modules/@babel/runtime/helpers/jsx.js
+++ b/node_modules/@babel/runtime/helpers/jsx.js
@@ -0,0 +1,22 @@
+var REACT_ELEMENT_TYPE;
+function _createRawReactElement(e, r, E, l) {
+  REACT_ELEMENT_TYPE || (REACT_ELEMENT_TYPE = "function" == typeof Symbol && Symbol["for"] && Symbol["for"]("react.element") || 60103);
+  var o = e && e.defaultProps,
+    n = arguments.length - 3;
+  if (r || 0 === n || (r = {
+    children: void 0
+  }), 1 === n) r.children = l;else if (n > 1) {
+    for (var t = Array(n), f = 0; f < n; f++) t[f] = arguments[f + 3];
+    r.children = t;
+  }
+  if (r && o) for (var i in o) void 0 === r[i] && (r[i] = o[i]);else r || (r = o || {});
+  return {
+    $$typeof: REACT_ELEMENT_TYPE,
+    type: e,
+    key: void 0 === E ? null : "" + E,
+    ref: null,
+    props: r,
+    _owner: null
+  };
+}
+module.exports = _createRawReactElement, module.exports.__esModule = true, module.exports["default"] = module.exports;
--- a/node_modules/@babel/runtime/helpers/maybeArrayLike.js
+++ b/node_modules/@babel/runtime/helpers/maybeArrayLike.js
@@ -0,0 +1,9 @@
+var arrayLikeToArray = require("./arrayLikeToArray.js");
+function _maybeArrayLike(r, a, e) {
+  if (a && !Array.isArray(a) && "number" == typeof a.length) {
+    var y = a.length;
+    return arrayLikeToArray(a, void 0 !== e && e < y ? e : y);
+  }
+  return r(a, e);
+}
+module.exports = _maybeArrayLike, module.exports.__esModule = true, module.exports["default"] = module.exports;
--- a/node_modules/@babel/runtime/helpers/readOnlyError.js
+++ b/node_modules/@babel/runtime/helpers/readOnlyError.js
@@ -0,0 +1,4 @@
+function _readOnlyError(r) {
+  throw new TypeError('"' + r + '" is read-only');
+}
+module.exports = _readOnlyError, module.exports.__esModule = true, module.exports["default"] = module.exports;
--- a/node_modules/@babel/runtime/helpers/regeneratorDefine.js
+++ b/node_modules/@babel/runtime/helpers/regeneratorDefine.js
@@ -0,0 +1,22 @@
+function _regeneratorDefine(e, r, n, t) {
+  var i = Object.defineProperty;
+  try {
+    i({}, "", {});
+  } catch (e) {
+    i = 0;
+  }
+  module.exports = _regeneratorDefine = function regeneratorDefine(e, r, n, t) {
+    function o(r, n) {
+      _regeneratorDefine(e, r, function (e) {
+        return this._invoke(r, n, e);
+      });
+    }
+    r ? i ? i(e, r, {
+      value: n,
+      enumerable: !t,
+      configurable: !t,
+      writable: !t
+    }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2));
+  }, module.exports.__esModule = true, module.exports["default"] = module.exports, _regeneratorDefine(e, r, n, t);
+}
+module.exports = _regeneratorDefine, module.exports.__esModule = true, module.exports["default"] = module.exports;
--- a/node_modules/@babel/runtime/helpers/superPropGet.js
+++ b/node_modules/@babel/runtime/helpers/superPropGet.js
@@ -0,0 +1,9 @@
+var get = require("./get.js");
+var getPrototypeOf = require("./getPrototypeOf.js");
+function _superPropGet(t, o, e, r) {
+  var p = get(getPrototypeOf(1 & r ? t.prototype : t), o, e);
+  return 2 & r && "function" == typeof p ? function (t) {
+    return p.apply(e, t);
+  } : p;
+}
+module.exports = _superPropGet, module.exports.__esModule = true, module.exports["default"] = module.exports;
--- a/node_modules/@babel/runtime/helpers/toSetter.js
+++ b/node_modules/@babel/runtime/helpers/toSetter.js
@@ -0,0 +1,10 @@
+function _toSetter(t, e, n) {
+  e || (e = []);
+  var r = e.length++;
+  return Object.defineProperty({}, "_", {
+    set: function set(o) {
+      e[r] = o, t.apply(n, e);
+    }
+  });
+}
+module.exports = _toSetter, module.exports.__esModule = true, module.exports["default"] = module.exports;
--- a/node_modules/@babel/template/lib/builder.js.map
+++ b/node_modules/@babel/template/lib/builder.js.map
--- a/node_modules/@babel/traverse/README.md
+++ b/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
+```
--- a/node_modules/@babel/traverse/lib/context.js
+++ b/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
--- a/node_modules/@babel/traverse/lib/context.js.map
+++ b/node_modules/@babel/traverse/lib/context.js.map
--- a/node_modules/@babel/traverse/lib/path/lib/hoister.js
+++ b/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
--- a/node_modules/@babel/traverse/lib/path/lib/hoister.js.map
+++ b/node_modules/@babel/traverse/lib/path/lib/hoister.js.map
--- a/node_modules/@babel/traverse/lib/path/lib/removal-hooks.js
+++ b/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
--- a/node_modules/@babel/traverse/lib/path/lib/virtual-types-validator.js
+++ b/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
--- a/node_modules/@babel/traverse/lib/path/lib/virtual-types.js
+++ b/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
--- a/node_modules/@babel/traverse/lib/path/lib/virtual-types.js.map
+++ b/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":[]}
--- a/node_modules/@babel/types/lib/ast-types/generated/index.js.map
+++ b/node_modules/@babel/types/lib/ast-types/generated/index.js.map
--- a/node_modules/@babel/types/lib/clone/clone.js.map
+++ b/node_modules/@babel/types/lib/clone/clone.js.map
@@ -0,0 +1 @@
+{"version":3,"names":["_cloneNode","require","clone","node","cloneNode"],"sources":["../../src/clone/clone.ts"],"sourcesContent":["import cloneNode from \"./cloneNode.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Create a shallow clone of a `node`, including only\n * properties belonging to the node.\n * @deprecated Use t.cloneNode instead.\n */\nexport default function clone<T extends t.Node>(node: T): T {\n  return cloneNode(node, /* deep */ false);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AAQe,SAASC,KAAKA,CAAmBC,IAAO,EAAK;EAC1D,OAAO,IAAAC,kBAAS,EAACD,IAAI,EAAa,KAAK,CAAC;AAC1C","ignoreList":[]}
--- a/node_modules/@babel/types/lib/converters/gatherSequenceExpressions.js.map
+++ b/node_modules/@babel/types/lib/converters/gatherSequenceExpressions.js.map
--- a/node_modules/@babel/types/lib/converters/valueToNode.js.map
+++ b/node_modules/@babel/types/lib/converters/valueToNode.js.map
--- a/node_modules/@babel/types/lib/definitions/deprecated-aliases.js.map
+++ b/node_modules/@babel/types/lib/definitions/deprecated-aliases.js.map
@@ -0,0 +1 @@
+{"version":3,"names":["DEPRECATED_ALIASES","exports","ModuleDeclaration"],"sources":["../../src/definitions/deprecated-aliases.ts"],"sourcesContent":["export const DEPRECATED_ALIASES = {\n  ModuleDeclaration: \"ImportOrExportDeclaration\",\n};\n"],"mappings":";;;;;;AAAO,MAAMA,kBAAkB,GAAAC,OAAA,CAAAD,kBAAA,GAAG;EAChCE,iBAAiB,EAAE;AACrB,CAAC","ignoreList":[]}
--- a/node_modules/@babel/types/lib/definitions/experimental.js
+++ b/node_modules/@babel/types/lib/definitions/experimental.js
@@ -0,0 +1,124 @@
+"use strict";
+
+var _utils = require("./utils.js");
+(0, _utils.default)("ArgumentPlaceholder", {});
+(0, _utils.default)("BindExpression", {
+  visitor: ["object", "callee"],
+  aliases: ["Expression"],
+  fields: !process.env.BABEL_TYPES_8_BREAKING ? {
+    object: {
+      validate: Object.assign(() => {}, {
+        oneOfNodeTypes: ["Expression"]
+      })
+    },
+    callee: {
+      validate: Object.assign(() => {}, {
+        oneOfNodeTypes: ["Expression"]
+      })
+    }
+  } : {
+    object: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    callee: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  }
+});
+(0, _utils.default)("Decorator", {
+  visitor: ["expression"],
+  fields: {
+    expression: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  }
+});
+(0, _utils.default)("DoExpression", {
+  visitor: ["body"],
+  builder: ["body", "async"],
+  aliases: ["Expression"],
+  fields: {
+    body: {
+      validate: (0, _utils.assertNodeType)("BlockStatement")
+    },
+    async: {
+      validate: (0, _utils.assertValueType)("boolean"),
+      default: false
+    }
+  }
+});
+(0, _utils.default)("ExportDefaultSpecifier", {
+  visitor: ["exported"],
+  aliases: ["ModuleSpecifier"],
+  fields: {
+    exported: {
+      validate: (0, _utils.assertNodeType)("Identifier")
+    }
+  }
+});
+(0, _utils.default)("RecordExpression", {
+  visitor: ["properties"],
+  aliases: ["Expression"],
+  fields: {
+    properties: (0, _utils.validateArrayOfType)("ObjectProperty", "SpreadElement")
+  }
+});
+(0, _utils.default)("TupleExpression", {
+  fields: {
+    elements: {
+      validate: (0, _utils.arrayOfType)("Expression", "SpreadElement"),
+      default: []
+    }
+  },
+  visitor: ["elements"],
+  aliases: ["Expression"]
+});
+(0, _utils.default)("DecimalLiteral", {
+  builder: ["value"],
+  fields: {
+    value: {
+      validate: (0, _utils.assertValueType)("string")
+    }
+  },
+  aliases: ["Expression", "Pureish", "Literal", "Immutable"]
+});
+(0, _utils.default)("ModuleExpression", {
+  visitor: ["body"],
+  fields: {
+    body: {
+      validate: (0, _utils.assertNodeType)("Program")
+    }
+  },
+  aliases: ["Expression"]
+});
+(0, _utils.default)("TopicReference", {
+  aliases: ["Expression"]
+});
+(0, _utils.default)("PipelineTopicExpression", {
+  builder: ["expression"],
+  visitor: ["expression"],
+  fields: {
+    expression: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  },
+  aliases: ["Expression"]
+});
+(0, _utils.default)("PipelineBareFunction", {
+  builder: ["callee"],
+  visitor: ["callee"],
+  fields: {
+    callee: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  },
+  aliases: ["Expression"]
+});
+(0, _utils.default)("PipelinePrimaryTopicReference", {
+  aliases: ["Expression"]
+});
+(0, _utils.default)("VoidPattern", {
+  aliases: ["Pattern", "PatternLike", "FunctionParameter"]
+});
+
+//# sourceMappingURL=experimental.js.map
--- a/node_modules/@babel/types/lib/definitions/experimental.js.map
+++ b/node_modules/@babel/types/lib/definitions/experimental.js.map
--- a/node_modules/@babel/types/lib/definitions/flow.js.map
+++ b/node_modules/@babel/types/lib/definitions/flow.js.map
--- a/node_modules/@babel/types/lib/definitions/placeholders.js
+++ b/node_modules/@babel/types/lib/definitions/placeholders.js
@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PLACEHOLDERS_FLIPPED_ALIAS = exports.PLACEHOLDERS_ALIAS = exports.PLACEHOLDERS = void 0;
+var _utils = require("./utils.js");
+const PLACEHOLDERS = exports.PLACEHOLDERS = ["Identifier", "StringLiteral", "Expression", "Statement", "Declaration", "BlockStatement", "ClassBody", "Pattern"];
+const PLACEHOLDERS_ALIAS = exports.PLACEHOLDERS_ALIAS = {
+  Declaration: ["Statement"],
+  Pattern: ["PatternLike", "LVal"]
+};
+for (const type of PLACEHOLDERS) {
+  const alias = _utils.ALIAS_KEYS[type];
+  if (alias != null && alias.length) PLACEHOLDERS_ALIAS[type] = alias;
+}
+const PLACEHOLDERS_FLIPPED_ALIAS = exports.PLACEHOLDERS_FLIPPED_ALIAS = {};
+Object.keys(PLACEHOLDERS_ALIAS).forEach(type => {
+  PLACEHOLDERS_ALIAS[type].forEach(alias => {
+    if (!hasOwnProperty.call(PLACEHOLDERS_FLIPPED_ALIAS, alias)) {
+      PLACEHOLDERS_FLIPPED_ALIAS[alias] = [];
+    }
+    PLACEHOLDERS_FLIPPED_ALIAS[alias].push(type);
+  });
+});
+
+//# sourceMappingURL=placeholders.js.map
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				{"version":3,"names":[],"sources":["../../src/config/cache-contexts.ts"],"sourcesContent":["import type { ConfigContext } from \"./config-chain.ts\";\nimport type {\n CallerMetadata,\n TargetsListOrObject,\n} from \"./validation/options.ts\";\n\nexport type { ConfigContext as FullConfig };\n\nexport type FullPreset = {\n targets: TargetsListOrObject;\n} & ConfigContext;\nexport type FullPlugin = {\n assumptions: Record<string, boolean>;\n} & FullPreset;\n\n// Context not including filename since it is used in places that cannot\n// process 'ignore'/'only' and other filename-based logic.\nexport type SimpleConfig = {\n envName: string;\n caller: CallerMetadata \| undefined;\n};\nexport type SimplePreset = {\n targets: TargetsListOrObject;\n} & SimpleConfig;\nexport type SimplePlugin = {\n assumptions: Record<string, boolean>;\n} & SimplePreset;\n"],"mappings":"","ignoreList":[]}
				`@@ -0,0 +1 @@`
				{"version":3,"names":["_fs","data","require","_gensync","readFile","exports","gensync","sync","fs","readFileSync","errback","stat","statSync"],"sources":["../../src/gensync-utils/fs.ts"],"sourcesContent":["import fs from \"node:fs\";\nimport gensync from \"gensync\";\n\nexport const readFile = gensync<[filepath: string, encoding: \"utf8\"], string>({\n sync: fs.readFileSync,\n errback: fs.readFile,\n});\n\nexport const stat = gensync({\n sync: fs.statSync,\n errback: fs.stat,\n});\n"],"mappings":";;;;;;AAAA,SAAAA,IAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,GAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,SAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,QAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEO,MAAMG,QAAQ,GAAAC,OAAA,CAAAD,QAAA,GAAGE,SAAMA,CAAC,CAA+C;EAC5EC,IAAI,EAAEC,IAACA,CAAC,CAACC,YAAY;EACrBC,OAAO,EAAEF,IAACA,CAAC,CAACJ;AACd,CAAC,CAAC;AAEK,MAAMO,IAAI,GAAAN,OAAA,CAAAM,IAAA,GAAGL,SAAMA,CAAC,CAAC;EAC1BC,IAAI,EAAEC,IAACA,CAAC,CAACI,QAAQ;EACjBF,OAAO,EAAEF,IAACA,CAAC,CAACG;AACd,CAAC,CAAC;AAAC","ignoreList":[]}
				`@@ -0,0 +1 @@`
				{"version":3,"names":["_remapping","data","require","mergeSourceMap","inputMap","map","sourceFileName","source","replace","found","result","remapping","rootless","s","ctx","sourceRoot","Object","assign"],"sources":["../../../src/transformation/file/merge-map.ts"],"sourcesContent":["type SourceMap = any;\nimport remapping from \"@jridgewell/remapping\";\n\nexport default function mergeSourceMap(\n inputMap: SourceMap,\n map: SourceMap,\n sourceFileName: string,\n): SourceMap {\n // On win32 machines, the sourceFileName uses backslash paths like\n // `C:\\foo\\bar.js`. But sourcemaps are always posix paths, so we need to\n // normalize to regular slashes before we can merge (else we won't find the\n // source associated with our input map).\n // This mirrors code done while generating the output map at\n // https://github.com/babel/babel/blob/5c2fcadc9ae34fd20dd72b1111d5cf50476d700d/packages/babel-generator/src/source-map.ts#L102\n const source = sourceFileName.replace(/\\\\/g, \"/\");\n\n // Prevent an infinite recursion if one of the input map's sources has the\n // same resolved path as the input map. In the case, it would keep find the\n // input map, then get it's sources which will include a path like the input\n // map, on and on.\n let found = false;\n const result = remapping(rootless(map), (s, ctx) => {\n if (s === source && !found) {\n found = true;\n // We empty the source location, which will prevent the sourcemap from\n // becoming relative to the input's location. Eg, if we're transforming a\n // file 'foo/bar.js', and it is a transformation of a `baz.js` file in the\n // same directory, the expected output is just `baz.js`. Without this step,\n // it would become `foo/baz.js`.\n ctx.source = \"\";\n\n return rootless(inputMap);\n }\n\n return null;\n });\n\n if (typeof inputMap.sourceRoot === \"string\") {\n result.sourceRoot = inputMap.sourceRoot;\n }\n\n // remapping returns a SourceMap class type, but this breaks code downstream in\n // @babel/traverse and @babel/types that relies on data being plain objects.\n // When it encounters the sourcemap type it outputs a \"don't know how to turn\n // this value into a node\" error. As a result, we are converting the merged\n // sourcemap to a plain js object.\n return { ...result };\n}\n\nfunction rootless(map: SourceMap): SourceMap {\n return {\n ...map,\n\n // This is a bit hack. Remapping will create absolute sources in our\n // sourcemap, but we want to maintain sources relative to the sourceRoot.\n // We'll re-add the sourceRoot after remapping.\n sourceRoot: null,\n };\n}\n"],"mappings":";;;;;;AACA,SAAAA,WAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,UAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEe,SAASE,cAAcA,CACpCC,QAAmB,EACnBC,GAAc,EACdC,cAAsB,EACX;EAOX,MAAMC,MAAM,GAAGD,cAAc,CAACE,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;EAMjD,IAAIC,KAAK,GAAG,KAAK;EACjB,MAAMC,MAAM,GAAGC,WAAQA,CAAC,CAACC,QAAQ,CAACP,GAAG,CAAC,EAAE,CAACQ,CAAC,EAAEC,GAAG,KAAK;IAClD,IAAID,CAAC,KAAKN,MAAM,IAAI,CAACE,KAAK,EAAE;MAC1BA,KAAK,GAAG,IAAI;MAMZK,GAAG,CAACP,MAAM,GAAG,EAAE;MAEf,OAAOK,QAAQ,CAACR,QAAQ,CAAC;IAC3B;IAEA,OAAO,IAAI;EACb,CAAC,CAAC;EAEF,IAAI,OAAOA,QAAQ,CAACW,UAAU,KAAK,QAAQ,EAAE;IAC3CL,MAAM,CAACK,UAAU,GAAGX,QAAQ,CAACW,UAAU;EACzC;EAOA,OAAAC,MAAA,CAAAC,MAAA,KAAYP,MAAM;AACpB;AAEA,SAASE,QAAQA,CAACP,GAAc,EAAa;EAC3C,OAAAW,MAAA,CAAAC,MAAA,KACKZ,GAAG;IAKNU,UAAU,EAAE;EAAI;AAEpB;AAAC","ignoreList":[]}
				`@@ -0,0 +1 @@`
				{"version":3,"names":["circleSet","Set","depth","deepClone","value","cache","allowCircle","has","get","clear","Error","add","cloned","Array","isArray","length","set","i","keys","Object","key","delete","_default","Map","_","structuredClone"],"sources":["../../../src/transformation/util/clone-deep.ts"],"sourcesContent":["const circleSet = new Set();\nlet depth = 0;\n// https://github.com/babel/babel/pull/14583#discussion_r882828856\nfunction deepClone(\n value: any,\n cache: Map<any, any>,\n allowCircle: boolean,\n): any {\n if (value !== null) {\n if (allowCircle) {\n if (cache.has(value)) return cache.get(value);\n } else if (++depth > 250) {\n if (circleSet.has(value)) {\n depth = 0;\n circleSet.clear();\n throw new Error(\"Babel-deepClone: Cycles are not allowed in AST\");\n }\n circleSet.add(value);\n }\n let cloned: any;\n if (Array.isArray(value)) {\n cloned = new Array(value.length);\n if (allowCircle) cache.set(value, cloned);\n for (let i = 0; i < value.length; i++) {\n cloned[i] =\n typeof value[i] !== \"object\"\n ? value[i]\n : deepClone(value[i], cache, allowCircle);\n }\n } else {\n cloned = {};\n if (allowCircle) cache.set(value, cloned);\n const keys = Object.keys(value);\n for (let i = 0; i < keys.length; i++) {\n const key = keys[i];\n cloned[key] =\n typeof value[key] !== \"object\"\n ? value[key]\n : deepClone(\n value[key],\n cache,\n allowCircle \|\|\n key === \"leadingComments\" \|\|\n key === \"innerComments\" \|\|\n key === \"trailingComments\" \|\|\n key === \"extra\",\n );\n }\n }\n if (!allowCircle) {\n if (depth-- > 250) circleSet.delete(value);\n }\n return cloned;\n }\n return value;\n}\n\nexport default function <T>(value: T): T {\n if (typeof value !== \"object\") return value;\n\n if (process.env.BABEL_8_BREAKING) {\n if (!process.env.IS_PUBLISH && depth > 0) {\n throw new Error(\"depth > 0\");\n }\n return deepClone(value, new Map(), false);\n } else {\n try {\n return deepClone(value, new Map(), true);\n } catch (_) {\n return structuredClone(value);\n }\n }\n}\n"],"mappings":";;;;;;AAAA,MAAMA,SAAS,GAAG,IAAIC,GAAG,CAAC,CAAC;AAC3B,IAAIC,KAAK,GAAG,CAAC;AAEb,SAASC,SAASA,CAChBC,KAAU,EACVC,KAAoB,EACpBC,WAAoB,EACf;EACL,IAAIF,KAAK,KAAK,IAAI,EAAE;IAClB,IAAIE,WAAW,EAAE;MACf,IAAID,KAAK,CAACE,GAAG,CAACH,KAAK,CAAC,EAAE,OAAOC,KAAK,CAACG,GAAG,CAACJ,KAAK,CAAC;IAC/C,CAAC,MAAM,IAAI,EAAEF,KAAK,GAAG,GAAG,EAAE;MACxB,IAAIF,SAAS,CAACO,GAAG,CAACH,KAAK,CAAC,EAAE;QACxBF,KAAK,GAAG,CAAC;QACTF,SAAS,CAACS,KAAK,CAAC,CAAC;QACjB,MAAM,IAAIC,KAAK,CAAC,gDAAgD,CAAC;MACnE;MACAV,SAAS,CAACW,GAAG,CAACP,KAAK,CAAC;IACtB;IACA,IAAIQ,MAAW;IACf,IAAIC,KAAK,CAACC,OAAO,CAACV,KAAK,CAAC,EAAE;MACxBQ,MAAM,GAAG,IAAIC,KAAK,CAACT,KAAK,CAACW,MAAM,CAAC;MAChC,IAAIT,WAAW,EAAED,KAAK,CAACW,GAAG,CAACZ,KAAK,EAAEQ,MAAM,CAAC;MACzC,KAAK,IAAIK,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGb,KAAK,CAACW,MAAM,EAAEE,CAAC,EAAE,EAAE;QACrCL,MAAM,CAACK,CAAC,CAAC,GACP,OAAOb,KAAK,CAACa,CAAC,CAAC,KAAK,QAAQ,GACxBb,KAAK,CAACa,CAAC,CAAC,GACRd,SAAS,CAACC,KAAK,CAACa,CAAC,CAAC,EAAEZ,KAAK,EAAEC,WAAW,CAAC;MAC/C;IACF,CAAC,MAAM;MACLM,MAAM,GAAG,CAAC,CAAC;MACX,IAAIN,WAAW,EAAED,KAAK,CAACW,GAAG,CAACZ,KAAK,EAAEQ,MAAM,CAAC;MACzC,MAAMM,IAAI,GAAGC,MAAM,CAACD,IAAI,CAACd,KAAK,CAAC;MAC/B,KAAK,IAAIa,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGC,IAAI,CAACH,MAAM,EAAEE,CAAC,EAAE,EAAE;QACpC,MAAMG,GAAG,GAAGF,IAAI,CAACD,CAAC,CAAC;QACnBL,MAAM,CAACQ,GAAG,CAAC,GACT,OAAOhB,KAAK,CAACgB,GAAG,CAAC,KAAK,QAAQ,GAC1BhB,KAAK,CAACgB,GAAG,CAAC,GACVjB,SAAS,CACPC,KAAK,CAACgB,GAAG,CAAC,EACVf,KAAK,EACLC,WAAW,IACTc,GAAG,KAAK,iBAAiB,IACzBA,GAAG,KAAK,eAAe,IACvBA,GAAG,KAAK,kBAAkB,IAC1BA,GAAG,KAAK,OACZ,CAAC;MACT;IACF;IACA,IAAI,CAACd,WAAW,EAAE;MAChB,IAAIJ,KAAK,EAAE,GAAG,GAAG,EAAEF,SAAS,CAACqB,MAAM,CAACjB,KAAK,CAAC;IAC5C;IACA,OAAOQ,MAAM;EACf;EACA,OAAOR,KAAK;AACd;AAEe,SAAAkB,SAAalB,KAAQ,EAAK;EACvC,IAAI,OAAOA,KAAK,KAAK,QAAQ,EAAE,OAAOA,KAAK;EAQzC,IAAI;IACF,OAAOD,SAAS,CAACC,KAAK,EAAE,IAAImB,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC;EAC1C,CAAC,CAAC,OAAOC,CAAC,EAAE;IACV,OAAOC,eAAe,CAACrB,KAAK,CAAC;EAC/B;AAEJ;AAAC","ignoreList":[]}
				`@@ -0,0 +1 @@`
				{"version":3,"names":["TargetNames","exports","node","deno","chrome","opera","edge","firefox","safari","ie","ios","android","electron","samsung","rhino","opera_mobile"],"sources":["../src/options.ts"],"sourcesContent":["export const TargetNames = {\n node: \"node\",\n deno: \"deno\",\n chrome: \"chrome\",\n opera: \"opera\",\n edge: \"edge\",\n firefox: \"firefox\",\n safari: \"safari\",\n ie: \"ie\",\n ios: \"ios\",\n android: \"android\",\n electron: \"electron\",\n samsung: \"samsung\",\n rhino: \"rhino\",\n opera_mobile: \"opera_mobile\",\n};\n"],"mappings":";;;;;;AAAO,MAAMA,WAAW,GAAAC,OAAA,CAAAD,WAAA,GAAG;EACzBE,IAAI,EAAE,MAAM;EACZC,IAAI,EAAE,MAAM;EACZC,MAAM,EAAE,QAAQ;EAChBC,KAAK,EAAE,OAAO;EACdC,IAAI,EAAE,MAAM;EACZC,OAAO,EAAE,SAAS;EAClBC,MAAM,EAAE,QAAQ;EAChBC,EAAE,EAAE,IAAI;EACRC,GAAG,EAAE,KAAK;EACVC,OAAO,EAAE,SAAS;EAClBC,QAAQ,EAAE,UAAU;EACpBC,OAAO,EAAE,SAAS;EAClBC,KAAK,EAAE,OAAO;EACdC,YAAY,EAAE;AAChB,CAAC","ignoreList":[]}
				`@@ -0,0 +1 @@`
				{"version":3,"names":["_core","require","_normalizeAndLoadMetadata","toGetWrapperPayload","lazy","source","metadata","isSideEffectImport","reexportAll","includes","Array","isArray","Error","wrapReference","ref","payload","t","callExpression"],"sources":["../src/lazy-modules.ts"],"sourcesContent":["// TODO: Move `lazy` implementation logic into the CommonJS plugin, since other\n// modules systems do not support `lazy`.\n\nimport { types as t } from \"@babel/core\";\nimport {\n type SourceModuleMetadata,\n isSideEffectImport,\n} from \"./normalize-and-load-metadata.ts\";\n\nexport type Lazy = boolean \| string[] \| ((source: string) => boolean);\n\nexport function toGetWrapperPayload(lazy: Lazy) {\n return (source: string, metadata: SourceModuleMetadata): null \| \"lazy\" => {\n if (lazy === false) return null;\n if (isSideEffectImport(metadata) \|\| metadata.reexportAll) return null;\n if (lazy === true) {\n // 'true' means that local relative files are eagerly loaded and\n // dependency modules are loaded lazily.\n return source.includes(\".\") ? null : \"lazy\";\n }\n if (Array.isArray(lazy)) {\n return !lazy.includes(source) ? null : \"lazy\";\n }\n if (typeof lazy === \"function\") {\n return lazy(source) ? \"lazy\" : null;\n }\n throw new Error(`.lazy must be a boolean, string array, or function`);\n };\n}\n\nexport function wrapReference(\n ref: t.Identifier,\n payload: unknown,\n): t.Expression \| null {\n if (payload === \"lazy\") return t.callExpression(ref, []);\n return null;\n}\n"],"mappings":";;;;;;;AAGA,IAAAA,KAAA,GAAAC,OAAA;AACA,IAAAC,yBAAA,GAAAD,OAAA;AAOO,SAASE,mBAAmBA,CAACC,IAAU,EAAE;EAC9C,OAAO,CAACC,MAAc,EAAEC,QAA8B,KAAoB;IACxE,IAAIF,IAAI,KAAK,KAAK,EAAE,OAAO,IAAI;IAC/B,IAAI,IAAAG,4CAAkB,EAACD,QAAQ,CAAC,IAAIA,QAAQ,CAACE,WAAW,EAAE,OAAO,IAAI;IACrE,IAAIJ,IAAI,KAAK,IAAI,EAAE;MAGjB,OAAOC,MAAM,CAACI,QAAQ,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,MAAM;IAC7C;IACA,IAAIC,KAAK,CAACC,OAAO,CAACP,IAAI,CAAC,EAAE;MACvB,OAAO,CAACA,IAAI,CAACK,QAAQ,CAACJ,MAAM,CAAC,GAAG,IAAI,GAAG,MAAM;IAC/C;IACA,IAAI,OAAOD,IAAI,KAAK,UAAU,EAAE;MAC9B,OAAOA,IAAI,CAACC,MAAM,CAAC,GAAG,MAAM,GAAG,IAAI;IACrC;IACA,MAAM,IAAIO,KAAK,CAAC,oDAAoD,CAAC;EACvE,CAAC;AACH;AAEO,SAASC,aAAaA,CAC3BC,GAAiB,EACjBC,OAAgB,EACK;EACrB,IAAIA,OAAO,KAAK,MAAM,EAAE,OAAOC,WAAC,CAACC,cAAc,CAACH,GAAG,EAAE,EAAE,CAAC;EACxD,OAAO,IAAI;AACb","ignoreList":[]}
				`@@ -0,0 +1 @@`
				{"version":3,"names":["_findSuggestion","require","OptionValidator","constructor","descriptor","validateTopLevelOptions","options","TopLevelOptionShape","validOptionNames","Object","keys","option","includes","Error","formatMessage","findSuggestion","validateBooleanOption","name","value","defaultValue","undefined","invariant","validateStringOption","condition","message","exports"],"sources":["../src/validator.ts"],"sourcesContent":["import { findSuggestion } from \"./find-suggestion.ts\";\n\nexport class OptionValidator {\n declare descriptor: string;\n constructor(descriptor: string) {\n this.descriptor = descriptor;\n }\n\n /*\n Validate if the given `options` follow the name of keys defined in the `TopLevelOptionShape`\n \n @param {Object} options\n * @param {Object} TopLevelOptionShape\n * An object with all the valid key names that `options` should be allowed to have\n * The property values of `TopLevelOptionShape` can be arbitrary\n * @memberof OptionValidator\n /\n validateTopLevelOptions(options: object, TopLevelOptionShape: object): void {\n const validOptionNames = Object.keys(TopLevelOptionShape);\n for (const option of Object.keys(options)) {\n if (!validOptionNames.includes(option)) {\n throw new Error(\n this.formatMessage(`'${option}' is not a valid top-level option.\n- Did you mean '${findSuggestion(option, validOptionNames)}'?`),\n );\n }\n }\n }\n\n // note: we do not consider rewrite them to high order functions\n // until we have to support `validateNumberOption`.\n validateBooleanOption<T extends boolean>(\n name: string,\n value?: boolean,\n defaultValue?: T,\n ): boolean \| T {\n if (value === undefined) {\n return defaultValue;\n } else {\n this.invariant(\n typeof value === \"boolean\",\n `'${name}' option must be a boolean.`,\n );\n }\n return value;\n }\n\n validateStringOption<T extends string>(\n name: string,\n value?: string,\n defaultValue?: T,\n ): string \| T {\n if (value === undefined) {\n return defaultValue;\n } else {\n this.invariant(\n typeof value === \"string\",\n `'${name}' option must be a string.`,\n );\n }\n return value;\n }\n /\n A helper interface copied from the `invariant` npm package.\n * It throws given `message` when `condition` is not met\n \n @param {boolean} condition\n * @param {string} message\n * @memberof OptionValidator\n */\n invariant(condition: boolean, message: string): void {\n if (!condition) {\n throw new Error(this.formatMessage(message));\n }\n }\n\n formatMessage(message: string): string {\n return `${this.descriptor}: ${message}`;\n }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,eAAA,GAAAC,OAAA;AAEO,MAAMC,eAAe,CAAC;EAE3BC,WAAWA,CAACC,UAAkB,EAAE;IAC9B,IAAI,CAACA,UAAU,GAAGA,UAAU;EAC9B;EAWAC,uBAAuBA,CAACC,OAAe,EAAEC,mBAA2B,EAAQ;IAC1E,MAAMC,gBAAgB,GAAGC,MAAM,CAACC,IAAI,CAACH,mBAAmB,CAAC;IACzD,KAAK,MAAMI,MAAM,IAAIF,MAAM,CAACC,IAAI,CAACJ,OAAO,CAAC,EAAE;MACzC,IAAI,CAACE,gBAAgB,CAACI,QAAQ,CAACD,MAAM,CAAC,EAAE;QACtC,MAAM,IAAIE,KAAK,CACb,IAAI,CAACC,aAAa,CAAC,IAAIH,MAAM;AACvC,kBAAkB,IAAAI,8BAAc,EAACJ,MAAM,EAAEH,gBAAgB,CAAC,IAAI,CACtD,CAAC;MACH;IACF;EACF;EAIAQ,qBAAqBA,CACnBC,IAAY,EACZC,KAAe,EACfC,YAAgB,EACH;IACb,IAAID,KAAK,KAAKE,SAAS,EAAE;MACvB,OAAOD,YAAY;IACrB,CAAC,MAAM;MACL,IAAI,CAACE,SAAS,CACZ,OAAOH,KAAK,KAAK,SAAS,EAC1B,IAAID,IAAI,6BACV,CAAC;IACH;IACA,OAAOC,KAAK;EACd;EAEAI,oBAAoBA,CAClBL,IAAY,EACZC,KAAc,EACdC,YAAgB,EACJ;IACZ,IAAID,KAAK,KAAKE,SAAS,EAAE;MACvB,OAAOD,YAAY;IACrB,CAAC,MAAM;MACL,IAAI,CAACE,SAAS,CACZ,OAAOH,KAAK,KAAK,QAAQ,EACzB,IAAID,IAAI,4BACV,CAAC;IACH;IACA,OAAOC,KAAK;EACd;EASAG,SAASA,CAACE,SAAkB,EAAEC,OAAe,EAAQ;IACnD,IAAI,CAACD,SAAS,EAAE;MACd,MAAM,IAAIV,KAAK,CAAC,IAAI,CAACC,aAAa,CAACU,OAAO,CAAC,CAAC;IAC9C;EACF;EAEAV,aAAaA,CAACU,OAAe,EAAU;IACrC,OAAO,GAAG,IAAI,CAACpB,UAAU,KAAKoB,OAAO,EAAE;EACzC;AACF;AAACC,OAAA,CAAAvB,eAAA,GAAAA,eAAA","ignoreList":[]}
				`@@ -0,0 +1 @@`
				{"version":3,"names":["_OverloadYield","require","_awaitAsyncGenerator","value","OverloadYield"],"sources":["../../src/helpers/awaitAsyncGenerator.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 /\n\nimport OverloadYield from \"./OverloadYield.ts\";\n\nexport default function _awaitAsyncGenerator<T>(value: T) {\n return new OverloadYield<T>(value, / kind: await */ 0);\n}\n"],"mappings":";;;;;;AAEA,IAAAA,cAAA,GAAAC,OAAA;AAEe,SAASC,oBAAoBA,CAAIC,KAAQ,EAAE;EACxD,OAAO,IAAIC,sBAAa,CAAID,KAAK,EAAoB,CAAC,CAAC;AACzD","ignoreList":[]}
				`@@ -0,0 +1 @@`
				{"version":3,"names":["_initializerDefineProperty","target","property","descriptor","context","Object","defineProperty","enumerable","configurable","writable","value","initializer","call"],"sources":["../../src/helpers/initializerDefineProperty.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\ninterface DescriptorWithInitializer extends PropertyDescriptor {\n initializer?: () => any;\n}\n\nexport default function _initializerDefineProperty<T>(\n target: T,\n property: PropertyKey,\n descriptor: DescriptorWithInitializer \| undefined,\n context: DecoratorContext,\n): void {\n if (!descriptor) return;\n\n Object.defineProperty(target, property, {\n enumerable: descriptor.enumerable,\n configurable: descriptor.configurable,\n writable: descriptor.writable,\n value: descriptor.initializer\n ? descriptor.initializer.call(context)\n : void 0,\n });\n}\n"],"mappings":";;;;;;AAMe,SAASA,0BAA0BA,CAChDC,MAAS,EACTC,QAAqB,EACrBC,UAAiD,EACjDC,OAAyB,EACnB;EACN,IAAI,CAACD,UAAU,EAAE;EAEjBE,MAAM,CAACC,cAAc,CAACL,MAAM,EAAEC,QAAQ,EAAE;IACtCK,UAAU,EAAEJ,UAAU,CAACI,UAAU;IACjCC,YAAY,EAAEL,UAAU,CAACK,YAAY;IACrCC,QAAQ,EAAEN,UAAU,CAACM,QAAQ;IAC7BC,KAAK,EAAEP,UAAU,CAACQ,WAAW,GACzBR,UAAU,CAACQ,WAAW,CAACC,IAAI,CAACR,OAAO,CAAC,GACpC,KAAK;EACX,CAAC,CAAC;AACJ","ignoreList":[]}
				`@@ -0,0 +1 @@`
				{"version":3,"names":["_iterableToArrayLimit","arr","i","iterator","Symbol","_arr","iteratorNormalCompletion","didIteratorError","step","iteratorError","next","_return","call","Object","done","push","value","length","err"],"sources":["../../src/helpers/iterableToArrayLimit.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _iterableToArrayLimit<T>(arr: Iterable<T>, i: number) {\n // this is an expanded form of \\`for...of\\` that properly supports abrupt completions of\n // iterators etc.\n\n var iterator: Iterator<T> =\n arr == null\n ? null\n : (typeof Symbol !== \"undefined\" && arr[Symbol.iterator]) \|\|\n (arr as any)[\"@@iterator\"];\n if (iterator == null) return;\n\n var _arr: T[] = [];\n var iteratorNormalCompletion = true;\n var didIteratorError = false;\n var step, iteratorError, next, _return;\n try {\n next = (iterator = (iterator as unknown as Function).call(arr)).next;\n if (i === 0) {\n if (Object(iterator) !== iterator) return;\n iteratorNormalCompletion = false;\n } else {\n for (\n ;\n !(iteratorNormalCompletion = (step = next.call(iterator)).done);\n iteratorNormalCompletion = true\n ) {\n _arr.push(step.value);\n if (_arr.length === i) break;\n }\n }\n } catch (err) {\n didIteratorError = true;\n iteratorError = err;\n } finally {\n try {\n if (!iteratorNormalCompletion && iterator[\"return\"] != null) {\n _return = iterator[\"return\"]();\n // eslint-disable-next-line no-unsafe-finally\n if (Object(_return) !== _return) return;\n }\n } finally {\n // eslint-disable-next-line no-unsafe-finally\n if (didIteratorError) throw iteratorError;\n }\n }\n return _arr;\n}\n"],"mappings":";;;;;;AAEe,SAASA,qBAAqBA,CAAIC,GAAgB,EAAEC,CAAS,EAAE;EAI5E,IAAIC,QAAqB,GACvBF,GAAG,IAAI,IAAI,GACP,IAAI,GACH,OAAOG,MAAM,KAAK,WAAW,IAAIH,GAAG,CAACG,MAAM,CAACD,QAAQ,CAAC,IACrDF,GAAG,CAAS,YAAY,CAAC;EAChC,IAAIE,QAAQ,IAAI,IAAI,EAAE;EAEtB,IAAIE,IAAS,GAAG,EAAE;EAClB,IAAIC,wBAAwB,GAAG,IAAI;EACnC,IAAIC,gBAAgB,GAAG,KAAK;EAC5B,IAAIC,IAAI,EAAEC,aAAa,EAAEC,IAAI,EAAEC,OAAO;EACtC,IAAI;IACFD,IAAI,GAAG,CAACP,QAAQ,GAAIA,QAAQ,CAAyBS,IAAI,CAACX,GAAG,CAAC,EAAES,IAAI;IACpE,IAAIR,CAAC,KAAK,CAAC,EAAE;MACX,IAAIW,MAAM,CAACV,QAAQ,CAAC,KAAKA,QAAQ,EAAE;MACnCG,wBAAwB,GAAG,KAAK;IAClC,CAAC,MAAM;MACL,OAEE,EAAEA,wBAAwB,GAAG,CAACE,IAAI,GAAGE,IAAI,CAACE,IAAI,CAACT,QAAQ,CAAC,EAAEW,IAAI,CAAC,EAC/DR,wBAAwB,GAAG,IAAI,EAC/B;QACAD,IAAI,CAACU,IAAI,CAACP,IAAI,CAACQ,KAAK,CAAC;QACrB,IAAIX,IAAI,CAACY,MAAM,KAAKf,CAAC,EAAE;MACzB;IACF;EACF,CAAC,CAAC,OAAOgB,GAAG,EAAE;IACZX,gBAAgB,GAAG,IAAI;IACvBE,aAAa,GAAGS,GAAG;EACrB,CAAC,SAAS;IACR,IAAI;MACF,IAAI,CAACZ,wBAAwB,IAAIH,QAAQ,CAAC,QAAQ,CAAC,IAAI,IAAI,EAAE;QAC3DQ,OAAO,GAAGR,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;QAE9B,IAAIU,MAAM,CAACF,OAAO,CAAC,KAAKA,OAAO,EAAE;MACnC;IACF,CAAC,SAAS;MAER,IAAIJ,gBAAgB,EAAE,MAAME,aAAa;IAC3C;EACF;EACA,OAAOJ,IAAI;AACb","ignoreList":[]}