Initial project upload

frontend/node_modules/@babel/code-frame/LICENSE

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

frontend/node_modules/@babel/code-frame/README.md

@@ -0,0 +1,19 @@
+# @babel/code-frame
+
+> Generate errors that contain a code frame that point to source locations.
+
+See our website [@babel/code-frame](https://babeljs.io/docs/babel-code-frame) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/code-frame
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/code-frame --dev
+```

frontend/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

frontend/node_modules/@babel/code-frame/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@babel/code-frame",
+  "version": "7.29.7",
+  "description": "Generate errors that contain a code frame that point to source locations.",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "homepage": "https://babel.dev/docs/en/next/babel-code-frame",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-code-frame"
+  },
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/helper-validator-identifier": "^7.29.7",
+    "js-tokens": "^4.0.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "charcodes": "^0.2.0",
+    "import-meta-resolve": "^4.1.0",
+    "strip-ansi": "^4.0.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "type": "commonjs"
+}

frontend/node_modules/@babel/generator/LICENSE

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

frontend/node_modules/@babel/generator/README.md

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

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

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

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

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

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

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

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

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

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

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

frontend/node_modules/@babel/generator/lib/generators/flow.js

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

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

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

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

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

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

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

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

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

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

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

frontend/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

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

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

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

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

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

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

frontend/node_modules/@babel/generator/lib/generators/typescript.js

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

frontend/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

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

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

frontend/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

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

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

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

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

frontend/node_modules/@babel/generator/lib/printer.js

@@ -0,0 +1,783 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _buffer = require("./buffer.js");
+var _index = require("./node/index.js");
+var _nodes = require("./nodes.js");
+var _t = require("@babel/types");
+var _tokenMap = require("./token-map.js");
+var _types2 = require("./generators/types.js");
+const {
+  isExpression,
+  isFunction,
+  isStatement,
+  isClassBody,
+  isTSInterfaceBody,
+  isTSEnumMember
+} = _t;
+const SCIENTIFIC_NOTATION = /e/i;
+const ZERO_DECIMAL_INTEGER = /\.0+$/;
+const HAS_NEWLINE = /[\n\r\u2028\u2029]/;
+const HAS_NEWLINE_OR_BlOCK_COMMENT_END = /[\n\r\u2028\u2029]|\*\//;
+function commentIsNewline(c) {
+  return c.type === "CommentLine" || HAS_NEWLINE.test(c.value);
+}
+class Printer {
+  constructor(format, map, tokens = null, originalCode = null) {
+    this.tokenContext = _index.TokenContext.normal;
+    this._tokens = null;
+    this._originalCode = null;
+    this._currentNode = null;
+    this._currentTypeId = null;
+    this._indent = 0;
+    this._indentRepeat = 0;
+    this._insideAux = false;
+    this._noLineTerminator = false;
+    this._noLineTerminatorAfterNode = null;
+    this._printAuxAfterOnNextUserNode = false;
+    this._printedComments = new Set();
+    this._lastCommentLine = 0;
+    this._innerCommentsState = 0;
+    this._flags = 0;
+    this.tokenMap = null;
+    this._boundGetRawIdentifier = null;
+    this._printSemicolonBeforeNextNode = -1;
+    this._printSemicolonBeforeNextToken = -1;
+    this.format = format;
+    this._tokens = tokens;
+    this._originalCode = originalCode;
+    this._indentRepeat = format.indent.style.length;
+    this._inputMap = (map == null ? void 0 : map._inputMap) || null;
+    this._buf = new _buffer.default(map, format.indent.style[0]);
+    const {
+      preserveFormat,
+      compact,
+      concise,
+      retainLines,
+      retainFunctionParens
+    } = format;
+    if (preserveFormat) {
+      this._flags |= 1;
+    }
+    if (compact) {
+      this._flags |= 2;
+    }
+    if (concise) {
+      this._flags |= 4;
+    }
+    if (retainLines) {
+      this._flags |= 8;
+    }
+    if (retainFunctionParens) {
+      this._flags |= 16;
+    }
+    if (format.auxiliaryCommentBefore || format.auxiliaryCommentAfter) {
+      this._flags |= 32;
+    }
+  }
+  enterDelimited() {
+    const oldNoLineTerminatorAfterNode = this._noLineTerminatorAfterNode;
+    if (oldNoLineTerminatorAfterNode !== null) {
+      this._noLineTerminatorAfterNode = null;
+    }
+    return oldNoLineTerminatorAfterNode;
+  }
+  generate(ast) {
+    if (this.format.preserveFormat) {
+      this.tokenMap = new _tokenMap.TokenMap(ast, this._tokens, this._originalCode);
+      this._boundGetRawIdentifier = _types2._getRawIdentifier.bind(this);
+    }
+    this.print(ast);
+    this._maybeAddAuxComment();
+    return this._buf.get();
+  }
+  indent(flags = this._flags) {
+    if (flags & (1 | 2 | 4)) {
+      return;
+    }
+    this._indent += this._indentRepeat;
+  }
+  dedent(flags = this._flags) {
+    if (flags & (1 | 2 | 4)) {
+      return;
+    }
+    this._indent -= this._indentRepeat;
+  }
+  semicolon(force = false) {
+    const flags = this._flags;
+    if (flags & 32) {
+      this._maybeAddAuxComment();
+    }
+    if (flags & 1) {
+      const node = this._currentNode;
+      if (node.start != null && node.end != null) {
+        if (!this.tokenMap.endMatches(node, ";")) {
+          this._printSemicolonBeforeNextNode = this._buf.getCurrentLine();
+          return;
+        }
+        const indexes = this.tokenMap.getIndexes(this._currentNode);
+        this._catchUpTo(this._tokens[indexes[indexes.length - 1]].loc.start);
+      }
+    }
+    if (force) {
+      this._appendChar(59);
+    } else {
+      this._queue(59);
+    }
+    this._noLineTerminator = false;
+  }
+  rightBrace(node) {
+    if (this.format.minified) {
+      this._buf.removeLastSemicolon();
+    }
+    this.sourceWithOffset("end", node.loc, -1);
+    this.tokenChar(125);
+  }
+  rightParens(node) {
+    this.sourceWithOffset("end", node.loc, -1);
+    this.tokenChar(41);
+  }
+  space(force = false) {
+    if (this._flags & (1 | 2)) {
+      return;
+    }
+    if (force) {
+      this._space();
+    } else {
+      const lastCp = this.getLastChar(true);
+      if (lastCp !== 0 && lastCp !== 32 && lastCp !== 10) {
+        this._space();
+      }
+    }
+  }
+  word(str, noLineTerminatorAfter = false) {
+    this.tokenContext &= _index.TokenContext.forInOrInitHeadAccumulatePassThroughMask;
+    this._maybePrintInnerComments(str);
+    const flags = this._flags;
+    if (flags & 32) {
+      this._maybeAddAuxComment();
+    }
+    if (flags & 1) this._catchUpToCurrentToken(str);
+    const lastChar = this.getLastChar();
+    if (lastChar === -2 || lastChar === -3 || lastChar === 47 && str.charCodeAt(0) === 47) {
+      this._space();
+    }
+    this._append(str, false);
+    this.setLastChar(-3);
+    this._noLineTerminator = noLineTerminatorAfter;
+  }
+  number(str, number) {
+    function isNonDecimalLiteral(str) {
+      if (str.length > 2 && str.charCodeAt(0) === 48) {
+        const secondChar = str.charCodeAt(1);
+        return secondChar === 98 || secondChar === 111 || secondChar === 120;
+      }
+      return false;
+    }
+    this.word(str);
+    if (Number.isInteger(number) && !isNonDecimalLiteral(str) && !SCIENTIFIC_NOTATION.test(str) && !ZERO_DECIMAL_INTEGER.test(str) && str.charCodeAt(str.length - 1) !== 46) {
+      this.setLastChar(-2);
+    }
+  }
+  token(str, maybeNewline = false, occurrenceCount = 0, mayNeedSpace = false) {
+    this.tokenContext &= _index.TokenContext.forInOrInitHeadAccumulatePassThroughMask;
+    this._maybePrintInnerComments(str, occurrenceCount);
+    const flags = this._flags;
+    if (flags & 32) {
+      this._maybeAddAuxComment();
+    }
+    if (flags & 1) {
+      this._catchUpToCurrentToken(str, occurrenceCount);
+    }
+    if (mayNeedSpace) {
+      const strFirst = str.charCodeAt(0);
+      if ((strFirst === 45 && str === "--" || strFirst === 61) && this.getLastChar() === 33 || strFirst === 43 && this.getLastChar() === 43 || strFirst === 45 && this.getLastChar() === 45 || strFirst === 46 && this.getLastChar() === -2) {
+        this._space();
+      }
+    }
+    this._append(str, maybeNewline);
+    this._noLineTerminator = false;
+  }
+  tokenChar(char, occurrenceCount = 0) {
+    this.tokenContext &= _index.TokenContext.forInOrInitHeadAccumulatePassThroughMask;
+    this._maybePrintInnerComments(char, occurrenceCount);
+    const flags = this._flags;
+    if (flags & 32) {
+      this._maybeAddAuxComment();
+    }
+    if (flags & 1) {
+      this._catchUpToCurrentToken(char, occurrenceCount);
+    }
+    if (char === 43 && this.getLastChar() === 43 || char === 45 && this.getLastChar() === 45 || char === 46 && this.getLastChar() === -2) {
+      this._space();
+    }
+    this._appendChar(char);
+    this._noLineTerminator = false;
+  }
+  newline(i = 1, flags = this._flags) {
+    if (i <= 0) return;
+    if (flags & (8 | 2)) {
+      return;
+    }
+    if (flags & 4) {
+      this.space();
+      return;
+    }
+    if (i > 2) i = 2;
+    i -= this._buf.getNewlineCount();
+    for (let j = 0; j < i; j++) {
+      this._newline();
+    }
+  }
+  endsWith(char) {
+    return this.getLastChar(true) === char;
+  }
+  getLastChar(checkQueue) {
+    return this._buf.getLastChar(checkQueue);
+  }
+  setLastChar(char) {
+    this._buf._last = char;
+  }
+  exactSource(loc, cb) {
+    if (!loc) {
+      cb();
+      return;
+    }
+    this._catchUp("start", loc);
+    this._buf.exactSource(loc, cb);
+  }
+  source(prop, loc) {
+    if (!loc) return;
+    this._catchUp(prop, loc);
+    this._buf.source(prop, loc);
+  }
+  sourceWithOffset(prop, loc, columnOffset) {
+    if (!loc || this.format.preserveFormat) return;
+    this._catchUp(prop, loc);
+    this._buf.sourceWithOffset(prop, loc, columnOffset);
+  }
+  sourceIdentifierName(identifierName, pos) {
+    if (!this._buf._canMarkIdName) return;
+    const sourcePosition = this._buf._sourcePosition;
+    sourcePosition.identifierNamePos = pos;
+    sourcePosition.identifierName = identifierName;
+  }
+  _space() {
+    this._queue(32);
+  }
+  _newline() {
+    if (this._buf._queuedChar === 32) this._buf._queuedChar = 0;
+    this._appendChar(10, true);
+  }
+  _catchUpToCurrentToken(str, occurrenceCount = 0) {
+    const token = this.tokenMap.findMatching(this._currentNode, str, occurrenceCount);
+    if (token) this._catchUpTo(token.loc.start);
+    if (this._printSemicolonBeforeNextToken !== -1 && this._printSemicolonBeforeNextToken === this._buf.getCurrentLine()) {
+      this._appendChar(59, true);
+    }
+    this._printSemicolonBeforeNextToken = -1;
+    this._printSemicolonBeforeNextNode = -1;
+  }
+  _append(str, maybeNewline) {
+    this._maybeIndent();
+    this._buf.append(str, maybeNewline);
+  }
+  _appendChar(char, noIndent) {
+    if (!noIndent) {
+      this._maybeIndent();
+    }
+    this._buf.appendChar(char);
+  }
+  _queue(char) {
+    this._buf.queue(char);
+    this.setLastChar(-1);
+  }
+  _maybeIndent() {
+    const indent = this._shouldIndent();
+    if (indent > 0) {
+      this._buf._appendChar(-1, indent, false);
+    }
+  }
+  _shouldIndent() {
+    return this.endsWith(10) ? this._indent : 0;
+  }
+  catchUp(line) {
+    if (!this.format.retainLines) return;
+    const count = line - this._buf.getCurrentLine();
+    for (let i = 0; i < count; i++) {
+      this._newline();
+    }
+  }
+  _catchUp(prop, loc) {
+    const flags = this._flags;
+    if ((flags & 1) === 0) {
+      if (flags & 8 && loc != null && loc[prop]) {
+        this.catchUp(loc[prop].line);
+      }
+      return;
+    }
+    const pos = loc == null ? void 0 : loc[prop];
+    if (pos != null) this._catchUpTo(pos);
+  }
+  _catchUpTo({
+    line,
+    column,
+    index
+  }) {
+    const count = line - this._buf.getCurrentLine();
+    if (count > 0 && this._noLineTerminator) {
+      return;
+    }
+    for (let i = 0; i < count; i++) {
+      this._newline();
+    }
+    const spacesCount = count > 0 ? column : column - this._buf.getCurrentColumn();
+    if (spacesCount > 0) {
+      const spaces = this._originalCode ? this._originalCode.slice(index - spacesCount, index).replace(/[^\t\x0B\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]/gu, " ") : " ".repeat(spacesCount);
+      this._buf.append(spaces, false, true);
+      this._buf.setSourcePosition(line, column);
+      this.setLastChar(32);
+    }
+  }
+  printTerminatorless(node) {
+    this._noLineTerminator = true;
+    this.print(node);
+  }
+  print(node, noLineTerminatorAfter = false, resetTokenContext = false, trailingCommentsLineOffset) {
+    var _node$leadingComments, _node$leadingComments2;
+    if (!node) return;
+    this._innerCommentsState = 0;
+    const {
+      type,
+      loc,
+      extra
+    } = node;
+    const flags = this._flags;
+    let changedFlags = false;
+    if (node._compact) {
+      this._flags |= 4;
+      changedFlags = true;
+    }
+    const nodeInfo = _nodes.generatorInfosMap.get(type);
+    if (nodeInfo === undefined) {
+      throw new ReferenceError(`unknown node of type ${JSON.stringify(type)} with constructor ${JSON.stringify(node.constructor.name)}`);
+    }
+    const [printMethod, nodeId, needsParens] = nodeInfo;
+    const parent = this._currentNode;
+    const parentId = this._currentTypeId;
+    this._currentNode = node;
+    this._currentTypeId = nodeId;
+    if (flags & 1) {
+      this._printSemicolonBeforeNextToken = this._printSemicolonBeforeNextNode;
+    }
+    let oldInAux;
+    if (flags & 32) {
+      oldInAux = this._insideAux;
+      this._insideAux = loc == null;
+      this._maybeAddAuxComment(this._insideAux && !oldInAux);
+    }
+    let oldTokenContext = 0;
+    if (resetTokenContext) {
+      oldTokenContext = this.tokenContext;
+      if (oldTokenContext & _index.TokenContext.forInOrInitHeadAccumulate) {
+        this.tokenContext = 0;
+      } else {
+        oldTokenContext = 0;
+      }
+    }
+    const parenthesized = extra != null && extra.parenthesized;
+    let shouldPrintParens = parenthesized && flags & 1 || parenthesized && flags & 16 && nodeId === 71 || parent && ((0, _index.parentNeedsParens)(node, parent, parentId) || needsParens != null && needsParens(node, parent, parentId, this.tokenContext, flags & 1 ? this._boundGetRawIdentifier : undefined));
+    if (!shouldPrintParens && parenthesized && (_node$leadingComments = node.leadingComments) != null && _node$leadingComments.length && node.leadingComments[0].type === "CommentBlock") {
+      switch (parentId) {
+        case 65:
+        case 243:
+        case 6:
+        case 143:
+          break;
+        case 17:
+        case 130:
+        case 112:
+          if (parent.callee !== node) break;
+        default:
+          shouldPrintParens = true;
+      }
+    }
+    let indentParenthesized = false;
+    if (!shouldPrintParens && this._noLineTerminator && ((_node$leadingComments2 = node.leadingComments) != null && _node$leadingComments2.some(commentIsNewline) || flags & 8 && loc && loc.start.line > this._buf.getCurrentLine())) {
+      shouldPrintParens = true;
+      indentParenthesized = true;
+    }
+    let oldNoLineTerminatorAfterNode;
+    if (!shouldPrintParens) {
+      noLineTerminatorAfter || (noLineTerminatorAfter = !!parent && this._noLineTerminatorAfterNode === parent && (0, _index.isLastChild)(parent, node));
+      if (noLineTerminatorAfter) {
+        var _node$trailingComment;
+        if ((_node$trailingComment = node.trailingComments) != null && _node$trailingComment.some(commentIsNewline)) {
+          if (isExpression(node)) shouldPrintParens = true;
+        } else {
+          oldNoLineTerminatorAfterNode = this._noLineTerminatorAfterNode;
+          this._noLineTerminatorAfterNode = node;
+        }
+      }
+    }
+    if (shouldPrintParens) {
+      this.tokenChar(40);
+      if (indentParenthesized) this.indent();
+      this._innerCommentsState = 0;
+      if (!resetTokenContext) {
+        oldTokenContext = this.tokenContext;
+      }
+      if (oldTokenContext & _index.TokenContext.forInOrInitHeadAccumulate) {
+        this.tokenContext = 0;
+      }
+      oldNoLineTerminatorAfterNode = this._noLineTerminatorAfterNode;
+      this._noLineTerminatorAfterNode = null;
+    }
+    this._printLeadingComments(node, parent);
+    this.exactSource(nodeId === 139 || nodeId === 66 ? null : loc, printMethod.bind(this, node, parent));
+    if (shouldPrintParens) {
+      this._printTrailingComments(node, parent);
+      if (indentParenthesized) {
+        this.dedent();
+        this.newline();
+      }
+      this.tokenChar(41);
+      this._noLineTerminator = noLineTerminatorAfter;
+    } else if (noLineTerminatorAfter && !this._noLineTerminator) {
+      this._noLineTerminator = true;
+      this._printTrailingComments(node, parent);
+    } else {
+      this._printTrailingComments(node, parent, trailingCommentsLineOffset);
+    }
+    if (oldTokenContext) this.tokenContext = oldTokenContext;
+    this._currentNode = parent;
+    this._currentTypeId = parentId;
+    if (changedFlags) {
+      this._flags = flags;
+    }
+    if (flags & 32) {
+      this._insideAux = oldInAux;
+    }
+    if (oldNoLineTerminatorAfterNode != null) {
+      this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+    }
+    this._innerCommentsState = 0;
+  }
+  _maybeAddAuxComment(enteredPositionlessNode) {
+    if (enteredPositionlessNode) this._printAuxBeforeComment();
+    if (!this._insideAux) this._printAuxAfterComment();
+  }
+  _printAuxBeforeComment() {
+    if (this._printAuxAfterOnNextUserNode) return;
+    this._printAuxAfterOnNextUserNode = true;
+    const comment = this.format.auxiliaryCommentBefore;
+    if (comment) {
+      this._printComment({
+        type: "CommentBlock",
+        value: comment
+      }, 0);
+    }
+  }
+  _printAuxAfterComment() {
+    if (!this._printAuxAfterOnNextUserNode) return;
+    this._printAuxAfterOnNextUserNode = false;
+    const comment = this.format.auxiliaryCommentAfter;
+    if (comment) {
+      this._printComment({
+        type: "CommentBlock",
+        value: comment
+      }, 0);
+    }
+  }
+  getPossibleRaw(node) {
+    const extra = node.extra;
+    if ((extra == null ? void 0 : extra.raw) != null && extra.rawValue != null && node.value === extra.rawValue) {
+      return extra.raw;
+    }
+  }
+  printJoin(nodes, statement, indent, separator, printTrailingSeparator, resetTokenContext, trailingCommentsLineOffset) {
+    if (!(nodes != null && nodes.length)) return;
+    const flags = this._flags;
+    if (indent == null && flags & 8) {
+      var _nodes$0$loc;
+      const startLine = (_nodes$0$loc = nodes[0].loc) == null ? void 0 : _nodes$0$loc.start.line;
+      if (startLine != null && startLine !== this._buf.getCurrentLine()) {
+        indent = true;
+      }
+    }
+    if (indent) this.indent(flags);
+    const len = nodes.length;
+    for (let i = 0; i < len; i++) {
+      const node = nodes[i];
+      if (!node) continue;
+      if (statement && i === 0 && this._buf.hasContent()) {
+        this.newline(1, flags);
+      }
+      this.print(node, false, resetTokenContext, trailingCommentsLineOffset || 0);
+      if (separator != null) {
+        if (i < len - 1) separator.call(this, i, false);else if (printTrailingSeparator) separator.call(this, i, true);
+      }
+      if (statement) {
+        if (i + 1 === len) {
+          this.newline(1, flags);
+        } else {
+          const lastCommentLine = this._lastCommentLine;
+          if (lastCommentLine > 0) {
+            var _nodes$loc;
+            const offset = (((_nodes$loc = nodes[i + 1].loc) == null ? void 0 : _nodes$loc.start.line) || 0) - lastCommentLine;
+            if (offset >= 0) {
+              this.newline(offset || 1, flags);
+              continue;
+            }
+          }
+          this.newline(1, flags);
+        }
+      }
+    }
+    if (indent) this.dedent(flags);
+  }
+  printAndIndentOnComments(node) {
+    const indent = node.leadingComments && node.leadingComments.length > 0;
+    if (indent) this.indent();
+    this.print(node);
+    if (indent) this.dedent();
+  }
+  printBlock(body) {
+    if (body.type !== "EmptyStatement") {
+      this.space();
+    }
+    this.print(body);
+  }
+  _printTrailingComments(node, parent, lineOffset) {
+    const {
+      innerComments,
+      trailingComments
+    } = node;
+    if (innerComments != null && innerComments.length) {
+      this._printComments(2, innerComments, node, parent, lineOffset);
+    }
+    if (trailingComments != null && trailingComments.length) {
+      this._printComments(2, trailingComments, node, parent, lineOffset);
+    } else {
+      this._lastCommentLine = 0;
+    }
+  }
+  _printLeadingComments(node, parent) {
+    const comments = node.leadingComments;
+    if (!(comments != null && comments.length)) return;
+    this._printComments(0, comments, node, parent);
+  }
+  _maybePrintInnerComments(nextTokenStr, nextTokenOccurrenceCount) {
+    var _this$tokenMap;
+    const state = this._innerCommentsState;
+    switch (state & 3) {
+      case 0:
+        this._innerCommentsState = 1 | 4;
+        return;
+      case 1:
+        this.printInnerComments((state & 4) > 0, (_this$tokenMap = this.tokenMap) == null ? void 0 : _this$tokenMap.findMatching(this._currentNode, nextTokenStr, nextTokenOccurrenceCount));
+    }
+  }
+  printInnerComments(indent = true, nextToken) {
+    const node = this._currentNode;
+    const comments = node.innerComments;
+    if (!(comments != null && comments.length)) {
+      this._innerCommentsState = 2;
+      return;
+    }
+    const hasSpace = this.endsWith(32);
+    if (indent) this.indent();
+    switch (this._printComments(1, comments, node, undefined, undefined, nextToken)) {
+      case 2:
+        this._innerCommentsState = 2;
+      case 1:
+        if (hasSpace) this.space();
+    }
+    if (indent) this.dedent();
+  }
+  noIndentInnerCommentsHere() {
+    this._innerCommentsState &= ~4;
+  }
+  printSequence(nodes, indent, resetTokenContext, trailingCommentsLineOffset) {
+    this.printJoin(nodes, true, indent != null ? indent : false, undefined, undefined, resetTokenContext, trailingCommentsLineOffset);
+  }
+  printList(items, printTrailingSeparator, statement, indent, separator, resetTokenContext) {
+    this.printJoin(items, statement, indent, separator != null ? separator : commaSeparator, printTrailingSeparator, resetTokenContext);
+  }
+  shouldPrintTrailingComma(listEnd) {
+    if (!this.tokenMap) return null;
+    const listEndIndex = this.tokenMap.findLastIndex(this._currentNode, token => this.tokenMap.matchesOriginal(token, typeof listEnd === "number" ? String.fromCharCode(listEnd) : listEnd));
+    if (listEndIndex <= 0) return null;
+    return this.tokenMap.matchesOriginal(this._tokens[listEndIndex - 1], ",");
+  }
+  _shouldPrintComment(comment, nextToken) {
+    if (comment.ignore) return 0;
+    if (this._printedComments.has(comment)) return 0;
+    if (this._noLineTerminator && HAS_NEWLINE_OR_BlOCK_COMMENT_END.test(comment.value)) {
+      return 2;
+    }
+    if (nextToken && this.tokenMap) {
+      const commentTok = this.tokenMap.find(this._currentNode, token => token.value === comment.value);
+      if (commentTok && commentTok.start > nextToken.start) {
+        return 2;
+      }
+    }
+    this._printedComments.add(comment);
+    if (!this.format.shouldPrintComment(comment.value)) {
+      return 0;
+    }
+    return 1;
+  }
+  _printComment(comment, skipNewLines) {
+    const noLineTerminator = this._noLineTerminator;
+    const isBlockComment = comment.type === "CommentBlock";
+    const printNewLines = isBlockComment && skipNewLines !== 1 && !noLineTerminator;
+    if (printNewLines && this._buf.hasContent() && skipNewLines !== 2) {
+      this.newline(1);
+    }
+    switch (this.getLastChar(true)) {
+      case 47:
+        this._space();
+      case 91:
+      case 123:
+      case 40:
+        break;
+      default:
+        this.space();
+    }
+    let val;
+    if (isBlockComment) {
+      val = `/*${comment.value}*/`;
+      if (this.format.indent.adjustMultilineComment) {
+        var _comment$loc;
+        const offset = (_comment$loc = comment.loc) == null ? void 0 : _comment$loc.start.column;
+        if (offset) {
+          const newlineRegex = new RegExp("\\n\\s{1," + offset + "}", "g");
+          val = val.replace(newlineRegex, "\n");
+        }
+        if (this._flags & 4) {
+          val = val.replace(/\n(?!$)/g, `\n`);
+        } else {
+          let indentSize = this.format.retainLines ? 0 : this._buf.getCurrentColumn();
+          if (this._shouldIndent() || this.format.retainLines) {
+            indentSize += this._indent;
+          }
+          val = val.replace(/\n(?!$)/g, `\n${" ".repeat(indentSize)}`);
+        }
+      }
+    } else if (!noLineTerminator) {
+      val = `//${comment.value}`;
+    } else {
+      val = `/*${comment.value}*/`;
+    }
+    this.source("start", comment.loc);
+    this._append(val, isBlockComment);
+    if (!isBlockComment && !noLineTerminator) {
+      this._newline();
+    }
+    if (printNewLines && skipNewLines !== 3) {
+      this.newline(1);
+    }
+  }
+  _printComments(type, comments, node, parent, lineOffset = 0, nextToken) {
+    const nodeLoc = node.loc;
+    const len = comments.length;
+    let hasLoc = !!nodeLoc;
+    const nodeStartLine = hasLoc ? nodeLoc.start.line : 0;
+    const nodeEndLine = hasLoc ? nodeLoc.end.line : 0;
+    let lastLine = 0;
+    let leadingCommentNewline = 0;
+    const {
+      _noLineTerminator,
+      _flags
+    } = this;
+    for (let i = 0; i < len; i++) {
+      const comment = comments[i];
+      const shouldPrint = this._shouldPrintComment(comment, nextToken);
+      if (shouldPrint === 2) {
+        return i === 0 ? 0 : 1;
+      }
+      if (hasLoc && comment.loc && shouldPrint === 1) {
+        const commentStartLine = comment.loc.start.line;
+        const commentEndLine = comment.loc.end.line;
+        if (type === 0) {
+          let offset = 0;
+          if (i === 0) {
+            if (this._buf.hasContent() && (comment.type === "CommentLine" || commentStartLine !== commentEndLine)) {
+              offset = leadingCommentNewline = 1;
+            }
+          } else {
+            offset = commentStartLine - lastLine;
+          }
+          lastLine = commentEndLine;
+          if (offset > 0 && !_noLineTerminator) {
+            this.newline(offset, _flags);
+          }
+          this._printComment(comment, 1);
+          if (i + 1 === len) {
+            const count = Math.max(nodeStartLine - lastLine, leadingCommentNewline);
+            if (count > 0 && !_noLineTerminator) {
+              this.newline(count, _flags);
+            }
+            lastLine = nodeStartLine;
+          }
+        } else if (type === 1) {
+          const offset = commentStartLine - (i === 0 ? nodeStartLine : lastLine);
+          lastLine = commentEndLine;
+          if (offset > 0 && !_noLineTerminator) {
+            this.newline(offset, _flags);
+          }
+          this._printComment(comment, 1);
+          if (i + 1 === len) {
+            const count = Math.min(1, nodeEndLine - lastLine);
+            if (count > 0 && !_noLineTerminator) {
+              this.newline(count, _flags);
+            }
+            lastLine = nodeEndLine;
+          }
+        } else {
+          const offset = commentStartLine - (i === 0 ? nodeEndLine - lineOffset : lastLine);
+          lastLine = commentEndLine;
+          if (offset > 0 && !_noLineTerminator) {
+            this.newline(offset, _flags);
+          }
+          this._printComment(comment, 1);
+        }
+      } else {
+        hasLoc = false;
+        if (shouldPrint !== 1) {
+          continue;
+        }
+        if (len === 1) {
+          const singleLine = comment.loc ? comment.loc.start.line === comment.loc.end.line : !HAS_NEWLINE.test(comment.value);
+          const shouldSkipNewline = singleLine && !isStatement(node) && !isClassBody(parent) && !isTSInterfaceBody(parent) && !isTSEnumMember(node);
+          if (type === 0) {
+            this._printComment(comment, shouldSkipNewline && node.type !== "ObjectExpression" || singleLine && isFunction(parent) && parent.body === node ? 1 : 0);
+          } else if (shouldSkipNewline && type === 2) {
+            this._printComment(comment, 1);
+          } else {
+            this._printComment(comment, 0);
+          }
+        } else if (type === 1 && !(node.type === "ObjectExpression" && node.properties.length > 1) && node.type !== "ClassBody" && node.type !== "TSInterfaceBody") {
+          this._printComment(comment, i === 0 ? 2 : i === len - 1 ? 3 : 0);
+        } else {
+          this._printComment(comment, 0);
+        }
+      }
+    }
+    if (type === 2 && hasLoc && lastLine) {
+      this._lastCommentLine = lastLine;
+    }
+    return 2;
+  }
+}
+var _default = exports.default = Printer;
+function commaSeparator(occurrenceCount, last) {
+  this.tokenChar(44, occurrenceCount);
+  if (!last) this.space();
+}
+
+//# sourceMappingURL=printer.js.map

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

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

frontend/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

frontend/node_modules/@babel/generator/package.json

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

frontend/node_modules/@babel/helper-globals/LICENSE

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

frontend/node_modules/@babel/helper-globals/README.md

@@ -0,0 +1,19 @@
+# @babel/helper-globals
+
+> A collection of JavaScript globals for Babel internal usage
+
+See our website [@babel/helper-globals](https://babeljs.io/docs/babel-helper-globals) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-globals
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-globals
+```

frontend/node_modules/@babel/helper-globals/data/browser-upper.json

@@ -0,0 +1,911 @@
+[
+  "AbortController",
+  "AbortSignal",
+  "AbsoluteOrientationSensor",
+  "AbstractRange",
+  "Accelerometer",
+  "AI",
+  "AICreateMonitor",
+  "AITextSession",
+  "AnalyserNode",
+  "Animation",
+  "AnimationEffect",
+  "AnimationEvent",
+  "AnimationPlaybackEvent",
+  "AnimationTimeline",
+  "AsyncDisposableStack",
+  "Attr",
+  "Audio",
+  "AudioBuffer",
+  "AudioBufferSourceNode",
+  "AudioContext",
+  "AudioData",
+  "AudioDecoder",
+  "AudioDestinationNode",
+  "AudioEncoder",
+  "AudioListener",
+  "AudioNode",
+  "AudioParam",
+  "AudioParamMap",
+  "AudioProcessingEvent",
+  "AudioScheduledSourceNode",
+  "AudioSinkInfo",
+  "AudioWorklet",
+  "AudioWorkletGlobalScope",
+  "AudioWorkletNode",
+  "AudioWorkletProcessor",
+  "AuthenticatorAssertionResponse",
+  "AuthenticatorAttestationResponse",
+  "AuthenticatorResponse",
+  "BackgroundFetchManager",
+  "BackgroundFetchRecord",
+  "BackgroundFetchRegistration",
+  "BarcodeDetector",
+  "BarProp",
+  "BaseAudioContext",
+  "BatteryManager",
+  "BeforeUnloadEvent",
+  "BiquadFilterNode",
+  "Blob",
+  "BlobEvent",
+  "Bluetooth",
+  "BluetoothCharacteristicProperties",
+  "BluetoothDevice",
+  "BluetoothRemoteGATTCharacteristic",
+  "BluetoothRemoteGATTDescriptor",
+  "BluetoothRemoteGATTServer",
+  "BluetoothRemoteGATTService",
+  "BluetoothUUID",
+  "BroadcastChannel",
+  "BrowserCaptureMediaStreamTrack",
+  "ByteLengthQueuingStrategy",
+  "Cache",
+  "CacheStorage",
+  "CanvasCaptureMediaStream",
+  "CanvasCaptureMediaStreamTrack",
+  "CanvasGradient",
+  "CanvasPattern",
+  "CanvasRenderingContext2D",
+  "CaptureController",
+  "CaretPosition",
+  "CDATASection",
+  "ChannelMergerNode",
+  "ChannelSplitterNode",
+  "ChapterInformation",
+  "CharacterBoundsUpdateEvent",
+  "CharacterData",
+  "Clipboard",
+  "ClipboardEvent",
+  "ClipboardItem",
+  "CloseEvent",
+  "CloseWatcher",
+  "CommandEvent",
+  "Comment",
+  "CompositionEvent",
+  "CompressionStream",
+  "ConstantSourceNode",
+  "ContentVisibilityAutoStateChangeEvent",
+  "ConvolverNode",
+  "CookieChangeEvent",
+  "CookieDeprecationLabel",
+  "CookieStore",
+  "CookieStoreManager",
+  "CountQueuingStrategy",
+  "Credential",
+  "CredentialsContainer",
+  "CropTarget",
+  "Crypto",
+  "CryptoKey",
+  "CSPViolationReportBody",
+  "CSS",
+  "CSSAnimation",
+  "CSSConditionRule",
+  "CSSContainerRule",
+  "CSSCounterStyleRule",
+  "CSSFontFaceRule",
+  "CSSFontFeatureValuesRule",
+  "CSSFontPaletteValuesRule",
+  "CSSGroupingRule",
+  "CSSImageValue",
+  "CSSImportRule",
+  "CSSKeyframeRule",
+  "CSSKeyframesRule",
+  "CSSKeywordValue",
+  "CSSLayerBlockRule",
+  "CSSLayerStatementRule",
+  "CSSMarginRule",
+  "CSSMathClamp",
+  "CSSMathInvert",
+  "CSSMathMax",
+  "CSSMathMin",
+  "CSSMathNegate",
+  "CSSMathProduct",
+  "CSSMathSum",
+  "CSSMathValue",
+  "CSSMatrixComponent",
+  "CSSMediaRule",
+  "CSSNamespaceRule",
+  "CSSNestedDeclarations",
+  "CSSNumericArray",
+  "CSSNumericValue",
+  "CSSPageDescriptors",
+  "CSSPageRule",
+  "CSSPerspective",
+  "CSSPositionTryDescriptors",
+  "CSSPositionTryRule",
+  "CSSPositionValue",
+  "CSSPropertyRule",
+  "CSSRotate",
+  "CSSRule",
+  "CSSRuleList",
+  "CSSScale",
+  "CSSScopeRule",
+  "CSSSkew",
+  "CSSSkewX",
+  "CSSSkewY",
+  "CSSStartingStyleRule",
+  "CSSStyleDeclaration",
+  "CSSStyleRule",
+  "CSSStyleSheet",
+  "CSSStyleValue",
+  "CSSSupportsRule",
+  "CSSTransformComponent",
+  "CSSTransformValue",
+  "CSSTransition",
+  "CSSTranslate",
+  "CSSUnitValue",
+  "CSSUnparsedValue",
+  "CSSVariableReferenceValue",
+  "CSSViewTransitionRule",
+  "CustomElementRegistry",
+  "CustomEvent",
+  "CustomStateSet",
+  "DataTransfer",
+  "DataTransferItem",
+  "DataTransferItemList",
+  "DecompressionStream",
+  "DelayNode",
+  "DelegatedInkTrailPresenter",
+  "DeviceMotionEvent",
+  "DeviceMotionEventAcceleration",
+  "DeviceMotionEventRotationRate",
+  "DeviceOrientationEvent",
+  "DevicePosture",
+  "DisposableStack",
+  "Document",
+  "DocumentFragment",
+  "DocumentPictureInPicture",
+  "DocumentPictureInPictureEvent",
+  "DocumentTimeline",
+  "DocumentType",
+  "DOMError",
+  "DOMException",
+  "DOMImplementation",
+  "DOMMatrix",
+  "DOMMatrixReadOnly",
+  "DOMParser",
+  "DOMPoint",
+  "DOMPointReadOnly",
+  "DOMQuad",
+  "DOMRect",
+  "DOMRectList",
+  "DOMRectReadOnly",
+  "DOMStringList",
+  "DOMStringMap",
+  "DOMTokenList",
+  "DragEvent",
+  "DynamicsCompressorNode",
+  "EditContext",
+  "Element",
+  "ElementInternals",
+  "EncodedAudioChunk",
+  "EncodedVideoChunk",
+  "ErrorEvent",
+  "Event",
+  "EventCounts",
+  "EventSource",
+  "EventTarget",
+  "External",
+  "EyeDropper",
+  "FeaturePolicy",
+  "FederatedCredential",
+  "Fence",
+  "FencedFrameConfig",
+  "FetchLaterResult",
+  "File",
+  "FileList",
+  "FileReader",
+  "FileSystem",
+  "FileSystemDirectoryEntry",
+  "FileSystemDirectoryHandle",
+  "FileSystemDirectoryReader",
+  "FileSystemEntry",
+  "FileSystemFileEntry",
+  "FileSystemFileHandle",
+  "FileSystemHandle",
+  "FileSystemObserver",
+  "FileSystemWritableFileStream",
+  "FocusEvent",
+  "FontData",
+  "FontFace",
+  "FontFaceSet",
+  "FontFaceSetLoadEvent",
+  "FormData",
+  "FormDataEvent",
+  "FragmentDirective",
+  "GainNode",
+  "Gamepad",
+  "GamepadAxisMoveEvent",
+  "GamepadButton",
+  "GamepadButtonEvent",
+  "GamepadEvent",
+  "GamepadHapticActuator",
+  "GamepadPose",
+  "Geolocation",
+  "GeolocationCoordinates",
+  "GeolocationPosition",
+  "GeolocationPositionError",
+  "GPU",
+  "GPUAdapter",
+  "GPUAdapterInfo",
+  "GPUBindGroup",
+  "GPUBindGroupLayout",
+  "GPUBuffer",
+  "GPUBufferUsage",
+  "GPUCanvasContext",
+  "GPUColorWrite",
+  "GPUCommandBuffer",
+  "GPUCommandEncoder",
+  "GPUCompilationInfo",
+  "GPUCompilationMessage",
+  "GPUComputePassEncoder",
+  "GPUComputePipeline",
+  "GPUDevice",
+  "GPUDeviceLostInfo",
+  "GPUError",
+  "GPUExternalTexture",
+  "GPUInternalError",
+  "GPUMapMode",
+  "GPUOutOfMemoryError",
+  "GPUPipelineError",
+  "GPUPipelineLayout",
+  "GPUQuerySet",
+  "GPUQueue",
+  "GPURenderBundle",
+  "GPURenderBundleEncoder",
+  "GPURenderPassEncoder",
+  "GPURenderPipeline",
+  "GPUSampler",
+  "GPUShaderModule",
+  "GPUShaderStage",
+  "GPUSupportedFeatures",
+  "GPUSupportedLimits",
+  "GPUTexture",
+  "GPUTextureUsage",
+  "GPUTextureView",
+  "GPUUncapturedErrorEvent",
+  "GPUValidationError",
+  "GravitySensor",
+  "Gyroscope",
+  "HashChangeEvent",
+  "Headers",
+  "HID",
+  "HIDConnectionEvent",
+  "HIDDevice",
+  "HIDInputReportEvent",
+  "Highlight",
+  "HighlightRegistry",
+  "History",
+  "HTMLAllCollection",
+  "HTMLAnchorElement",
+  "HTMLAreaElement",
+  "HTMLAudioElement",
+  "HTMLBaseElement",
+  "HTMLBodyElement",
+  "HTMLBRElement",
+  "HTMLButtonElement",
+  "HTMLCanvasElement",
+  "HTMLCollection",
+  "HTMLDataElement",
+  "HTMLDataListElement",
+  "HTMLDetailsElement",
+  "HTMLDialogElement",
+  "HTMLDirectoryElement",
+  "HTMLDivElement",
+  "HTMLDListElement",
+  "HTMLDocument",
+  "HTMLElement",
+  "HTMLEmbedElement",
+  "HTMLFencedFrameElement",
+  "HTMLFieldSetElement",
+  "HTMLFontElement",
+  "HTMLFormControlsCollection",
+  "HTMLFormElement",
+  "HTMLFrameElement",
+  "HTMLFrameSetElement",
+  "HTMLHeadElement",
+  "HTMLHeadingElement",
+  "HTMLHRElement",
+  "HTMLHtmlElement",
+  "HTMLIFrameElement",
+  "HTMLImageElement",
+  "HTMLInputElement",
+  "HTMLLabelElement",
+  "HTMLLegendElement",
+  "HTMLLIElement",
+  "HTMLLinkElement",
+  "HTMLMapElement",
+  "HTMLMarqueeElement",
+  "HTMLMediaElement",
+  "HTMLMenuElement",
+  "HTMLMetaElement",
+  "HTMLMeterElement",
+  "HTMLModElement",
+  "HTMLObjectElement",
+  "HTMLOListElement",
+  "HTMLOptGroupElement",
+  "HTMLOptionElement",
+  "HTMLOptionsCollection",
+  "HTMLOutputElement",
+  "HTMLParagraphElement",
+  "HTMLParamElement",
+  "HTMLPictureElement",
+  "HTMLPreElement",
+  "HTMLProgressElement",
+  "HTMLQuoteElement",
+  "HTMLScriptElement",
+  "HTMLSelectedContentElement",
+  "HTMLSelectElement",
+  "HTMLSlotElement",
+  "HTMLSourceElement",
+  "HTMLSpanElement",
+  "HTMLStyleElement",
+  "HTMLTableCaptionElement",
+  "HTMLTableCellElement",
+  "HTMLTableColElement",
+  "HTMLTableElement",
+  "HTMLTableRowElement",
+  "HTMLTableSectionElement",
+  "HTMLTemplateElement",
+  "HTMLTextAreaElement",
+  "HTMLTimeElement",
+  "HTMLTitleElement",
+  "HTMLTrackElement",
+  "HTMLUListElement",
+  "HTMLUnknownElement",
+  "HTMLVideoElement",
+  "IDBCursor",
+  "IDBCursorWithValue",
+  "IDBDatabase",
+  "IDBFactory",
+  "IDBIndex",
+  "IDBKeyRange",
+  "IDBObjectStore",
+  "IDBOpenDBRequest",
+  "IDBRequest",
+  "IDBTransaction",
+  "IDBVersionChangeEvent",
+  "IdentityCredential",
+  "IdentityCredentialError",
+  "IdentityProvider",
+  "IdleDeadline",
+  "IdleDetector",
+  "IIRFilterNode",
+  "Image",
+  "ImageBitmap",
+  "ImageBitmapRenderingContext",
+  "ImageCapture",
+  "ImageData",
+  "ImageDecoder",
+  "ImageTrack",
+  "ImageTrackList",
+  "Ink",
+  "InputDeviceCapabilities",
+  "InputDeviceInfo",
+  "InputEvent",
+  "IntersectionObserver",
+  "IntersectionObserverEntry",
+  "Keyboard",
+  "KeyboardEvent",
+  "KeyboardLayoutMap",
+  "KeyframeEffect",
+  "LanguageDetector",
+  "LargestContentfulPaint",
+  "LaunchParams",
+  "LaunchQueue",
+  "LayoutShift",
+  "LayoutShiftAttribution",
+  "LinearAccelerationSensor",
+  "Location",
+  "Lock",
+  "LockManager",
+  "MathMLElement",
+  "MediaCapabilities",
+  "MediaCapabilitiesInfo",
+  "MediaDeviceInfo",
+  "MediaDevices",
+  "MediaElementAudioSourceNode",
+  "MediaEncryptedEvent",
+  "MediaError",
+  "MediaKeyError",
+  "MediaKeyMessageEvent",
+  "MediaKeys",
+  "MediaKeySession",
+  "MediaKeyStatusMap",
+  "MediaKeySystemAccess",
+  "MediaList",
+  "MediaMetadata",
+  "MediaQueryList",
+  "MediaQueryListEvent",
+  "MediaRecorder",
+  "MediaRecorderErrorEvent",
+  "MediaSession",
+  "MediaSource",
+  "MediaSourceHandle",
+  "MediaStream",
+  "MediaStreamAudioDestinationNode",
+  "MediaStreamAudioSourceNode",
+  "MediaStreamEvent",
+  "MediaStreamTrack",
+  "MediaStreamTrackAudioSourceNode",
+  "MediaStreamTrackAudioStats",
+  "MediaStreamTrackEvent",
+  "MediaStreamTrackGenerator",
+  "MediaStreamTrackProcessor",
+  "MediaStreamTrackVideoStats",
+  "MessageChannel",
+  "MessageEvent",
+  "MessagePort",
+  "MIDIAccess",
+  "MIDIConnectionEvent",
+  "MIDIInput",
+  "MIDIInputMap",
+  "MIDIMessageEvent",
+  "MIDIOutput",
+  "MIDIOutputMap",
+  "MIDIPort",
+  "MimeType",
+  "MimeTypeArray",
+  "ModelGenericSession",
+  "ModelManager",
+  "MouseEvent",
+  "MutationEvent",
+  "MutationObserver",
+  "MutationRecord",
+  "NamedNodeMap",
+  "NavigateEvent",
+  "Navigation",
+  "NavigationActivation",
+  "NavigationCurrentEntryChangeEvent",
+  "NavigationDestination",
+  "NavigationHistoryEntry",
+  "NavigationPreloadManager",
+  "NavigationTransition",
+  "Navigator",
+  "NavigatorLogin",
+  "NavigatorManagedData",
+  "NavigatorUAData",
+  "NetworkInformation",
+  "Node",
+  "NodeFilter",
+  "NodeIterator",
+  "NodeList",
+  "Notification",
+  "NotifyPaintEvent",
+  "NotRestoredReasonDetails",
+  "NotRestoredReasons",
+  "Observable",
+  "OfflineAudioCompletionEvent",
+  "OfflineAudioContext",
+  "OffscreenCanvas",
+  "OffscreenCanvasRenderingContext2D",
+  "Option",
+  "OrientationSensor",
+  "OscillatorNode",
+  "OTPCredential",
+  "OverconstrainedError",
+  "PageRevealEvent",
+  "PageSwapEvent",
+  "PageTransitionEvent",
+  "PannerNode",
+  "PasswordCredential",
+  "Path2D",
+  "PaymentAddress",
+  "PaymentManager",
+  "PaymentMethodChangeEvent",
+  "PaymentRequest",
+  "PaymentRequestUpdateEvent",
+  "PaymentResponse",
+  "Performance",
+  "PerformanceElementTiming",
+  "PerformanceEntry",
+  "PerformanceEventTiming",
+  "PerformanceLongAnimationFrameTiming",
+  "PerformanceLongTaskTiming",
+  "PerformanceMark",
+  "PerformanceMeasure",
+  "PerformanceNavigation",
+  "PerformanceNavigationTiming",
+  "PerformanceObserver",
+  "PerformanceObserverEntryList",
+  "PerformancePaintTiming",
+  "PerformanceResourceTiming",
+  "PerformanceScriptTiming",
+  "PerformanceServerTiming",
+  "PerformanceTiming",
+  "PeriodicSyncManager",
+  "PeriodicWave",
+  "Permissions",
+  "PermissionStatus",
+  "PERSISTENT",
+  "PictureInPictureEvent",
+  "PictureInPictureWindow",
+  "Plugin",
+  "PluginArray",
+  "PointerEvent",
+  "PopStateEvent",
+  "Presentation",
+  "PresentationAvailability",
+  "PresentationConnection",
+  "PresentationConnectionAvailableEvent",
+  "PresentationConnectionCloseEvent",
+  "PresentationConnectionList",
+  "PresentationReceiver",
+  "PresentationRequest",
+  "PressureObserver",
+  "PressureRecord",
+  "ProcessingInstruction",
+  "Profiler",
+  "ProgressEvent",
+  "PromiseRejectionEvent",
+  "ProtectedAudience",
+  "PublicKeyCredential",
+  "PushManager",
+  "PushSubscription",
+  "PushSubscriptionOptions",
+  "RadioNodeList",
+  "Range",
+  "ReadableByteStreamController",
+  "ReadableStream",
+  "ReadableStreamBYOBReader",
+  "ReadableStreamBYOBRequest",
+  "ReadableStreamDefaultController",
+  "ReadableStreamDefaultReader",
+  "RelativeOrientationSensor",
+  "RemotePlayback",
+  "ReportBody",
+  "ReportingObserver",
+  "Request",
+  "ResizeObserver",
+  "ResizeObserverEntry",
+  "ResizeObserverSize",
+  "Response",
+  "RestrictionTarget",
+  "RTCCertificate",
+  "RTCDataChannel",
+  "RTCDataChannelEvent",
+  "RTCDtlsTransport",
+  "RTCDTMFSender",
+  "RTCDTMFToneChangeEvent",
+  "RTCEncodedAudioFrame",
+  "RTCEncodedVideoFrame",
+  "RTCError",
+  "RTCErrorEvent",
+  "RTCIceCandidate",
+  "RTCIceTransport",
+  "RTCPeerConnection",
+  "RTCPeerConnectionIceErrorEvent",
+  "RTCPeerConnectionIceEvent",
+  "RTCRtpReceiver",
+  "RTCRtpScriptTransform",
+  "RTCRtpSender",
+  "RTCRtpTransceiver",
+  "RTCSctpTransport",
+  "RTCSessionDescription",
+  "RTCStatsReport",
+  "RTCTrackEvent",
+  "Scheduler",
+  "Scheduling",
+  "Screen",
+  "ScreenDetailed",
+  "ScreenDetails",
+  "ScreenOrientation",
+  "ScriptProcessorNode",
+  "ScrollTimeline",
+  "SecurityPolicyViolationEvent",
+  "Selection",
+  "Sensor",
+  "SensorErrorEvent",
+  "Serial",
+  "SerialPort",
+  "ServiceWorker",
+  "ServiceWorkerContainer",
+  "ServiceWorkerRegistration",
+  "ShadowRoot",
+  "SharedStorage",
+  "SharedStorageAppendMethod",
+  "SharedStorageClearMethod",
+  "SharedStorageDeleteMethod",
+  "SharedStorageModifierMethod",
+  "SharedStorageSetMethod",
+  "SharedStorageWorklet",
+  "SharedWorker",
+  "SnapEvent",
+  "SourceBuffer",
+  "SourceBufferList",
+  "SpeechSynthesis",
+  "SpeechSynthesisErrorEvent",
+  "SpeechSynthesisEvent",
+  "SpeechSynthesisUtterance",
+  "SpeechSynthesisVoice",
+  "StaticRange",
+  "StereoPannerNode",
+  "Storage",
+  "StorageBucket",
+  "StorageBucketManager",
+  "StorageEvent",
+  "StorageManager",
+  "StylePropertyMap",
+  "StylePropertyMapReadOnly",
+  "StyleSheet",
+  "StyleSheetList",
+  "SubmitEvent",
+  "Subscriber",
+  "SubtleCrypto",
+  "SuppressedError",
+  "SVGAElement",
+  "SVGAngle",
+  "SVGAnimatedAngle",
+  "SVGAnimatedBoolean",
+  "SVGAnimatedEnumeration",
+  "SVGAnimatedInteger",
+  "SVGAnimatedLength",
+  "SVGAnimatedLengthList",
+  "SVGAnimatedNumber",
+  "SVGAnimatedNumberList",
+  "SVGAnimatedPreserveAspectRatio",
+  "SVGAnimatedRect",
+  "SVGAnimatedString",
+  "SVGAnimatedTransformList",
+  "SVGAnimateElement",
+  "SVGAnimateMotionElement",
+  "SVGAnimateTransformElement",
+  "SVGAnimationElement",
+  "SVGCircleElement",
+  "SVGClipPathElement",
+  "SVGComponentTransferFunctionElement",
+  "SVGDefsElement",
+  "SVGDescElement",
+  "SVGElement",
+  "SVGEllipseElement",
+  "SVGFEBlendElement",
+  "SVGFEColorMatrixElement",
+  "SVGFEComponentTransferElement",
+  "SVGFECompositeElement",
+  "SVGFEConvolveMatrixElement",
+  "SVGFEDiffuseLightingElement",
+  "SVGFEDisplacementMapElement",
+  "SVGFEDistantLightElement",
+  "SVGFEDropShadowElement",
+  "SVGFEFloodElement",
+  "SVGFEFuncAElement",
+  "SVGFEFuncBElement",
+  "SVGFEFuncGElement",
+  "SVGFEFuncRElement",
+  "SVGFEGaussianBlurElement",
+  "SVGFEImageElement",
+  "SVGFEMergeElement",
+  "SVGFEMergeNodeElement",
+  "SVGFEMorphologyElement",
+  "SVGFEOffsetElement",
+  "SVGFEPointLightElement",
+  "SVGFESpecularLightingElement",
+  "SVGFESpotLightElement",
+  "SVGFETileElement",
+  "SVGFETurbulenceElement",
+  "SVGFilterElement",
+  "SVGForeignObjectElement",
+  "SVGGElement",
+  "SVGGeometryElement",
+  "SVGGradientElement",
+  "SVGGraphicsElement",
+  "SVGImageElement",
+  "SVGLength",
+  "SVGLengthList",
+  "SVGLinearGradientElement",
+  "SVGLineElement",
+  "SVGMarkerElement",
+  "SVGMaskElement",
+  "SVGMatrix",
+  "SVGMetadataElement",
+  "SVGMPathElement",
+  "SVGNumber",
+  "SVGNumberList",
+  "SVGPathElement",
+  "SVGPatternElement",
+  "SVGPoint",
+  "SVGPointList",
+  "SVGPolygonElement",
+  "SVGPolylineElement",
+  "SVGPreserveAspectRatio",
+  "SVGRadialGradientElement",
+  "SVGRect",
+  "SVGRectElement",
+  "SVGScriptElement",
+  "SVGSetElement",
+  "SVGStopElement",
+  "SVGStringList",
+  "SVGStyleElement",
+  "SVGSVGElement",
+  "SVGSwitchElement",
+  "SVGSymbolElement",
+  "SVGTextContentElement",
+  "SVGTextElement",
+  "SVGTextPathElement",
+  "SVGTextPositioningElement",
+  "SVGTitleElement",
+  "SVGTransform",
+  "SVGTransformList",
+  "SVGTSpanElement",
+  "SVGUnitTypes",
+  "SVGUseElement",
+  "SVGViewElement",
+  "SyncManager",
+  "TaskAttributionTiming",
+  "TaskController",
+  "TaskPriorityChangeEvent",
+  "TaskSignal",
+  "TEMPORARY",
+  "Text",
+  "TextDecoder",
+  "TextDecoderStream",
+  "TextEncoder",
+  "TextEncoderStream",
+  "TextEvent",
+  "TextFormat",
+  "TextFormatUpdateEvent",
+  "TextMetrics",
+  "TextTrack",
+  "TextTrackCue",
+  "TextTrackCueList",
+  "TextTrackList",
+  "TextUpdateEvent",
+  "TimeEvent",
+  "TimeRanges",
+  "ToggleEvent",
+  "Touch",
+  "TouchEvent",
+  "TouchList",
+  "TrackEvent",
+  "TransformStream",
+  "TransformStreamDefaultController",
+  "TransitionEvent",
+  "TreeWalker",
+  "TrustedHTML",
+  "TrustedScript",
+  "TrustedScriptURL",
+  "TrustedTypePolicy",
+  "TrustedTypePolicyFactory",
+  "UIEvent",
+  "URL",
+  "URLPattern",
+  "URLSearchParams",
+  "USB",
+  "USBAlternateInterface",
+  "USBConfiguration",
+  "USBConnectionEvent",
+  "USBDevice",
+  "USBEndpoint",
+  "USBInterface",
+  "USBInTransferResult",
+  "USBIsochronousInTransferPacket",
+  "USBIsochronousInTransferResult",
+  "USBIsochronousOutTransferPacket",
+  "USBIsochronousOutTransferResult",
+  "USBOutTransferResult",
+  "UserActivation",
+  "ValidityState",
+  "VideoColorSpace",
+  "VideoDecoder",
+  "VideoEncoder",
+  "VideoFrame",
+  "VideoPlaybackQuality",
+  "ViewTimeline",
+  "ViewTransition",
+  "ViewTransitionTypeSet",
+  "VirtualKeyboard",
+  "VirtualKeyboardGeometryChangeEvent",
+  "VisibilityStateEntry",
+  "VisualViewport",
+  "VTTCue",
+  "VTTRegion",
+  "WakeLock",
+  "WakeLockSentinel",
+  "WaveShaperNode",
+  "WebAssembly",
+  "WebGL2RenderingContext",
+  "WebGLActiveInfo",
+  "WebGLBuffer",
+  "WebGLContextEvent",
+  "WebGLFramebuffer",
+  "WebGLObject",
+  "WebGLProgram",
+  "WebGLQuery",
+  "WebGLRenderbuffer",
+  "WebGLRenderingContext",
+  "WebGLSampler",
+  "WebGLShader",
+  "WebGLShaderPrecisionFormat",
+  "WebGLSync",
+  "WebGLTexture",
+  "WebGLTransformFeedback",
+  "WebGLUniformLocation",
+  "WebGLVertexArrayObject",
+  "WebSocket",
+  "WebSocketError",
+  "WebSocketStream",
+  "WebTransport",
+  "WebTransportBidirectionalStream",
+  "WebTransportDatagramDuplexStream",
+  "WebTransportError",
+  "WebTransportReceiveStream",
+  "WebTransportSendStream",
+  "WGSLLanguageFeatures",
+  "WheelEvent",
+  "Window",
+  "WindowControlsOverlay",
+  "WindowControlsOverlayGeometryChangeEvent",
+  "Worker",
+  "Worklet",
+  "WorkletGlobalScope",
+  "WritableStream",
+  "WritableStreamDefaultController",
+  "WritableStreamDefaultWriter",
+  "XMLDocument",
+  "XMLHttpRequest",
+  "XMLHttpRequestEventTarget",
+  "XMLHttpRequestUpload",
+  "XMLSerializer",
+  "XPathEvaluator",
+  "XPathExpression",
+  "XPathResult",
+  "XRAnchor",
+  "XRAnchorSet",
+  "XRBoundedReferenceSpace",
+  "XRCamera",
+  "XRCPUDepthInformation",
+  "XRDepthInformation",
+  "XRDOMOverlayState",
+  "XRFrame",
+  "XRHand",
+  "XRHitTestResult",
+  "XRHitTestSource",
+  "XRInputSource",
+  "XRInputSourceArray",
+  "XRInputSourceEvent",
+  "XRInputSourcesChangeEvent",
+  "XRJointPose",
+  "XRJointSpace",
+  "XRLayer",
+  "XRLightEstimate",
+  "XRLightProbe",
+  "XRPose",
+  "XRRay",
+  "XRReferenceSpace",
+  "XRReferenceSpaceEvent",
+  "XRRenderState",
+  "XRRigidTransform",
+  "XRSession",
+  "XRSessionEvent",
+  "XRSpace",
+  "XRSystem",
+  "XRTransientInputHitTestResult",
+  "XRTransientInputHitTestSource",
+  "XRView",
+  "XRViewerPose",
+  "XRViewport",
+  "XRWebGLBinding",
+  "XRWebGLDepthInformation",
+  "XRWebGLLayer",
+  "XSLTProcessor"
+]

frontend/node_modules/@babel/helper-globals/data/builtin-lower.json

@@ -0,0 +1,15 @@
+[
+  "decodeURI",
+  "decodeURIComponent",
+  "encodeURI",
+  "encodeURIComponent",
+  "escape",
+  "eval",
+  "globalThis",
+  "isFinite",
+  "isNaN",
+  "parseFloat",
+  "parseInt",
+  "undefined",
+  "unescape"
+]

frontend/node_modules/@babel/helper-globals/data/builtin-upper.json

@@ -0,0 +1,51 @@
+[
+  "AggregateError",
+  "Array",
+  "ArrayBuffer",
+  "Atomics",
+  "BigInt",
+  "BigInt64Array",
+  "BigUint64Array",
+  "Boolean",
+  "DataView",
+  "Date",
+  "Error",
+  "EvalError",
+  "FinalizationRegistry",
+  "Float16Array",
+  "Float32Array",
+  "Float64Array",
+  "Function",
+  "Infinity",
+  "Int16Array",
+  "Int32Array",
+  "Int8Array",
+  "Intl",
+  "Iterator",
+  "JSON",
+  "Map",
+  "Math",
+  "NaN",
+  "Number",
+  "Object",
+  "Promise",
+  "Proxy",
+  "RangeError",
+  "ReferenceError",
+  "Reflect",
+  "RegExp",
+  "Set",
+  "SharedArrayBuffer",
+  "String",
+  "Symbol",
+  "SyntaxError",
+  "TypeError",
+  "Uint16Array",
+  "Uint32Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "URIError",
+  "WeakMap",
+  "WeakRef",
+  "WeakSet"
+]

frontend/node_modules/@babel/helper-globals/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@babel/helper-globals",
+  "version": "7.29.7",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "license": "MIT",
+  "description": "A collection of JavaScript globals for Babel internal usage",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-globals"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    "./data/browser-upper.json": "./data/browser-upper.json",
+    "./data/builtin-lower.json": "./data/builtin-lower.json",
+    "./data/builtin-upper.json": "./data/builtin-upper.json",
+    "./package.json": "./package.json"
+  },
+  "keywords": [
+    "babel",
+    "globals"
+  ],
+  "devDependencies": {
+    "globals": "^16.1.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "type": "commonjs"
+}

frontend/node_modules/@babel/helper-module-imports/LICENSE

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

frontend/node_modules/@babel/helper-module-imports/README.md

@@ -0,0 +1,19 @@
+# @babel/helper-module-imports
+
+> Babel helper functions for inserting module loads
+
+See our website [@babel/helper-module-imports](https://babeljs.io/docs/babel-helper-module-imports) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-module-imports
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-module-imports
+```

frontend/node_modules/@babel/helper-module-imports/lib/import-builder.js

@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _assert = require("assert");
+var _t = require("@babel/types");
+const {
+  callExpression,
+  cloneNode,
+  expressionStatement,
+  identifier,
+  importDeclaration,
+  importDefaultSpecifier,
+  importNamespaceSpecifier,
+  importSpecifier,
+  memberExpression,
+  stringLiteral,
+  variableDeclaration,
+  variableDeclarator
+} = _t;
+class ImportBuilder {
+  constructor(importedSource, scope, hub) {
+    this._statements = [];
+    this._resultName = null;
+    this._importedSource = void 0;
+    this._scope = scope;
+    this._hub = hub;
+    this._importedSource = importedSource;
+  }
+  done() {
+    return {
+      statements: this._statements,
+      resultName: this._resultName
+    };
+  }
+  import() {
+    this._statements.push(importDeclaration([], stringLiteral(this._importedSource)));
+    return this;
+  }
+  require() {
+    this._statements.push(expressionStatement(callExpression(identifier("require"), [stringLiteral(this._importedSource)])));
+    return this;
+  }
+  namespace(name = "namespace") {
+    const local = this._scope.generateUidIdentifier(name);
+    const statement = this._statements[this._statements.length - 1];
+    _assert(statement.type === "ImportDeclaration");
+    _assert(statement.specifiers.length === 0);
+    statement.specifiers = [importNamespaceSpecifier(local)];
+    this._resultName = cloneNode(local);
+    return this;
+  }
+  default(name) {
+    const id = this._scope.generateUidIdentifier(name);
+    const statement = this._statements[this._statements.length - 1];
+    _assert(statement.type === "ImportDeclaration");
+    _assert(statement.specifiers.length === 0);
+    statement.specifiers = [importDefaultSpecifier(id)];
+    this._resultName = cloneNode(id);
+    return this;
+  }
+  named(name, importName) {
+    if (importName === "default") return this.default(name);
+    const id = this._scope.generateUidIdentifier(name);
+    const statement = this._statements[this._statements.length - 1];
+    _assert(statement.type === "ImportDeclaration");
+    _assert(statement.specifiers.length === 0);
+    statement.specifiers = [importSpecifier(id, identifier(importName))];
+    this._resultName = cloneNode(id);
+    return this;
+  }
+  var(name) {
+    const id = this._scope.generateUidIdentifier(name);
+    let statement = this._statements[this._statements.length - 1];
+    if (statement.type !== "ExpressionStatement") {
+      _assert(this._resultName);
+      statement = expressionStatement(this._resultName);
+      this._statements.push(statement);
+    }
+    this._statements[this._statements.length - 1] = variableDeclaration("var", [variableDeclarator(id, statement.expression)]);
+    this._resultName = cloneNode(id);
+    return this;
+  }
+  defaultInterop() {
+    return this._interop(this._hub.addHelper("interopRequireDefault"));
+  }
+  wildcardInterop() {
+    return this._interop(this._hub.addHelper("interopRequireWildcard"));
+  }
+  _interop(callee) {
+    const statement = this._statements[this._statements.length - 1];
+    if (statement.type === "ExpressionStatement") {
+      statement.expression = callExpression(callee, [statement.expression]);
+    } else if (statement.type === "VariableDeclaration") {
+      _assert(statement.declarations.length === 1);
+      statement.declarations[0].init = callExpression(callee, [statement.declarations[0].init]);
+    } else {
+      _assert.fail("Unexpected type.");
+    }
+    return this;
+  }
+  prop(name) {
+    const statement = this._statements[this._statements.length - 1];
+    if (statement.type === "ExpressionStatement") {
+      statement.expression = memberExpression(statement.expression, identifier(name));
+    } else if (statement.type === "VariableDeclaration") {
+      _assert(statement.declarations.length === 1);
+      statement.declarations[0].init = memberExpression(statement.declarations[0].init, identifier(name));
+    } else {
+      _assert.fail("Unexpected type:" + statement.type);
+    }
+    return this;
+  }
+  read(name) {
+    this._resultName = memberExpression(this._resultName, identifier(name));
+  }
+}
+exports.default = ImportBuilder;
+
+//# sourceMappingURL=import-builder.js.map

frontend/node_modules/@babel/helper-module-imports/lib/import-injector.js

@@ -0,0 +1,304 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _assert = require("assert");
+var _t = require("@babel/types");
+var _importBuilder = require("./import-builder.js");
+var _isModule = require("./is-module.js");
+const {
+  identifier,
+  importSpecifier,
+  numericLiteral,
+  sequenceExpression,
+  isImportDeclaration
+} = _t;
+class ImportInjector {
+  constructor(path, importedSource, opts) {
+    this._defaultOpts = {
+      importedSource: null,
+      importedType: "commonjs",
+      importedInterop: "babel",
+      importingInterop: "babel",
+      ensureLiveReference: false,
+      ensureNoContext: false,
+      importPosition: "before"
+    };
+    const programPath = path.find(p => p.isProgram());
+    this._programPath = programPath;
+    this._programScope = programPath.scope;
+    this._hub = programPath.hub;
+    this._defaultOpts = this._applyDefaults(importedSource, opts, true);
+  }
+  addDefault(importedSourceIn, opts) {
+    return this.addNamed("default", importedSourceIn, opts);
+  }
+  addNamed(importName, importedSourceIn, opts) {
+    _assert(typeof importName === "string");
+    return this._generateImport(this._applyDefaults(importedSourceIn, opts), importName);
+  }
+  addNamespace(importedSourceIn, opts) {
+    return this._generateImport(this._applyDefaults(importedSourceIn, opts), null);
+  }
+  addSideEffect(importedSourceIn, opts) {
+    return this._generateImport(this._applyDefaults(importedSourceIn, opts), void 0);
+  }
+  _applyDefaults(importedSource, opts, isInit = false) {
+    let newOpts;
+    if (typeof importedSource === "string") {
+      newOpts = Object.assign({}, this._defaultOpts, {
+        importedSource
+      }, opts);
+    } else {
+      _assert(!opts, "Unexpected secondary arguments.");
+      newOpts = Object.assign({}, this._defaultOpts, importedSource);
+    }
+    if (!isInit && opts) {
+      if (opts.nameHint !== undefined) newOpts.nameHint = opts.nameHint;
+      if (opts.blockHoist !== undefined) newOpts.blockHoist = opts.blockHoist;
+    }
+    return newOpts;
+  }
+  _generateImport(opts, importName) {
+    const isDefault = importName === "default";
+    const isNamed = !!importName && !isDefault;
+    const isNamespace = importName === null;
+    const {
+      importedSource,
+      importedType,
+      importedInterop,
+      importingInterop,
+      ensureLiveReference,
+      ensureNoContext,
+      nameHint,
+      importPosition,
+      blockHoist
+    } = opts;
+    let name = nameHint || importName;
+    const isMod = (0, _isModule.default)(this._programPath);
+    const isModuleForNode = isMod && importingInterop === "node";
+    const isModuleForBabel = isMod && importingInterop === "babel";
+    if (importPosition === "after" && !isMod) {
+      throw new Error(`"importPosition": "after" is only supported in modules`);
+    }
+    const builder = new _importBuilder.default(importedSource, this._programScope, this._hub);
+    if (importedType === "es6") {
+      if (!isModuleForNode && !isModuleForBabel) {
+        throw new Error("Cannot import an ES6 module from CommonJS");
+      }
+      builder.import();
+      if (isNamespace) {
+        builder.namespace(nameHint || importedSource);
+      } else if (isDefault || isNamed) {
+        builder.named(name, importName);
+      }
+    } else if (importedType !== "commonjs") {
+      throw new Error(`Unexpected interopType "${importedType}"`);
+    } else if (importedInterop === "babel") {
+      if (isModuleForNode) {
+        name = name !== "default" ? name : importedSource;
+        const es6Default = `${importedSource}$es6Default`;
+        builder.import();
+        if (isNamespace) {
+          builder.default(es6Default).var(name || importedSource).wildcardInterop();
+        } else if (isDefault) {
+          if (ensureLiveReference) {
+            builder.default(es6Default).var(name || importedSource).defaultInterop().read("default");
+          } else {
+            builder.default(es6Default).var(name).defaultInterop().prop(importName);
+          }
+        } else if (isNamed) {
+          builder.default(es6Default).read(importName);
+        }
+      } else if (isModuleForBabel) {
+        builder.import();
+        if (isNamespace) {
+          builder.namespace(name || importedSource);
+        } else if (isDefault || isNamed) {
+          builder.named(name, importName);
+        }
+      } else {
+        builder.require();
+        if (isNamespace) {
+          builder.var(name || importedSource).wildcardInterop();
+        } else if ((isDefault || isNamed) && ensureLiveReference) {
+          if (isDefault) {
+            name = name !== "default" ? name : importedSource;
+            builder.var(name).read(importName);
+            builder.defaultInterop();
+          } else {
+            builder.var(importedSource).read(importName);
+          }
+        } else if (isDefault) {
+          builder.var(name).defaultInterop().prop(importName);
+        } else if (isNamed) {
+          builder.var(name).prop(importName);
+        }
+      }
+    } else if (importedInterop === "compiled") {
+      if (isModuleForNode) {
+        builder.import();
+        if (isNamespace) {
+          builder.default(name || importedSource);
+        } else if (isDefault || isNamed) {
+          builder.default(importedSource).read(name);
+        }
+      } else if (isModuleForBabel) {
+        builder.import();
+        if (isNamespace) {
+          builder.namespace(name || importedSource);
+        } else if (isDefault || isNamed) {
+          builder.named(name, importName);
+        }
+      } else {
+        builder.require();
+        if (isNamespace) {
+          builder.var(name || importedSource);
+        } else if (isDefault || isNamed) {
+          if (ensureLiveReference) {
+            builder.var(importedSource).read(name);
+          } else {
+            builder.prop(importName).var(name);
+          }
+        }
+      }
+    } else if (importedInterop === "uncompiled") {
+      if (isDefault && ensureLiveReference) {
+        throw new Error("No live reference for commonjs default");
+      }
+      if (isModuleForNode) {
+        builder.import();
+        if (isNamespace) {
+          builder.default(name || importedSource);
+        } else if (isDefault) {
+          builder.default(name);
+        } else if (isNamed) {
+          builder.default(importedSource).read(name);
+        }
+      } else if (isModuleForBabel) {
+        builder.import();
+        if (isNamespace) {
+          builder.default(name || importedSource);
+        } else if (isDefault) {
+          builder.default(name);
+        } else if (isNamed) {
+          builder.named(name, importName);
+        }
+      } else {
+        builder.require();
+        if (isNamespace) {
+          builder.var(name || importedSource);
+        } else if (isDefault) {
+          builder.var(name);
+        } else if (isNamed) {
+          if (ensureLiveReference) {
+            builder.var(importedSource).read(name);
+          } else {
+            builder.var(name).prop(importName);
+          }
+        }
+      }
+    } else {
+      throw new Error(`Unknown importedInterop "${importedInterop}".`);
+    }
+    const {
+      statements,
+      resultName
+    } = builder.done();
+    this._insertStatements(statements, importPosition, blockHoist);
+    if ((isDefault || isNamed) && ensureNoContext && resultName.type !== "Identifier") {
+      return sequenceExpression([numericLiteral(0), resultName]);
+    }
+    return resultName;
+  }
+  _insertStatements(statements, importPosition = "before", blockHoist = 3) {
+    if (importPosition === "after") {
+      if (this._insertStatementsAfter(statements)) return;
+    } else {
+      if (this._insertStatementsBefore(statements, blockHoist)) return;
+    }
+    this._programPath.unshiftContainer("body", statements);
+  }
+  _insertStatementsBefore(statements, blockHoist) {
+    if (statements.length === 1 && isImportDeclaration(statements[0]) && isValueImport(statements[0])) {
+      const firstImportDecl = this._programPath.get("body").find(p => {
+        return p.isImportDeclaration() && isValueImport(p.node);
+      });
+      if ((firstImportDecl == null ? void 0 : firstImportDecl.node.source.value) === statements[0].source.value && maybeAppendImportSpecifiers(firstImportDecl.node, statements[0])) {
+        return true;
+      }
+    }
+    statements.forEach(node => {
+      node._blockHoist = blockHoist;
+    });
+    const targetPath = this._programPath.get("body").find(p => {
+      const val = p.node._blockHoist;
+      return Number.isFinite(val) && val < 4;
+    });
+    if (targetPath) {
+      targetPath.insertBefore(statements);
+      return true;
+    }
+    return false;
+  }
+  _insertStatementsAfter(statements) {
+    const statementsSet = new Set(statements);
+    const importDeclarations = new Map();
+    for (const statement of statements) {
+      if (isImportDeclaration(statement) && isValueImport(statement)) {
+        const source = statement.source.value;
+        if (!importDeclarations.has(source)) importDeclarations.set(source, []);
+        importDeclarations.get(source).push(statement);
+      }
+    }
+    let lastImportPath = null;
+    for (const bodyStmt of this._programPath.get("body")) {
+      if (bodyStmt.isImportDeclaration() && isValueImport(bodyStmt.node)) {
+        lastImportPath = bodyStmt;
+        const source = bodyStmt.node.source.value;
+        const newImports = importDeclarations.get(source);
+        if (!newImports) continue;
+        for (const decl of newImports) {
+          if (!statementsSet.has(decl)) continue;
+          if (maybeAppendImportSpecifiers(bodyStmt.node, decl)) {
+            statementsSet.delete(decl);
+          }
+        }
+      }
+    }
+    if (statementsSet.size === 0) return true;
+    if (lastImportPath) lastImportPath.insertAfter(Array.from(statementsSet));
+    return !!lastImportPath;
+  }
+}
+exports.default = ImportInjector;
+function isValueImport(node) {
+  return node.importKind !== "type" && node.importKind !== "typeof";
+}
+function hasNamespaceImport(node) {
+  return node.specifiers.length === 1 && node.specifiers[0].type === "ImportNamespaceSpecifier" || node.specifiers.length === 2 && node.specifiers[1].type === "ImportNamespaceSpecifier";
+}
+function hasDefaultImport(node) {
+  return node.specifiers.length > 0 && node.specifiers[0].type === "ImportDefaultSpecifier";
+}
+function maybeAppendImportSpecifiers(target, source) {
+  if (!target.specifiers.length) {
+    target.specifiers = source.specifiers;
+    return true;
+  }
+  if (!source.specifiers.length) return true;
+  if (hasNamespaceImport(target) || hasNamespaceImport(source)) return false;
+  if (hasDefaultImport(source)) {
+    if (hasDefaultImport(target)) {
+      source.specifiers[0] = importSpecifier(source.specifiers[0].local, identifier("default"));
+    } else {
+      target.specifiers.unshift(source.specifiers.shift());
+    }
+  }
+  target.specifiers.push(...source.specifiers);
+  return true;
+}
+
+//# sourceMappingURL=import-injector.js.map

frontend/node_modules/@babel/helper-module-imports/lib/index.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ImportInjector", {
+  enumerable: true,
+  get: function () {
+    return _importInjector.default;
+  }
+});
+exports.addDefault = addDefault;
+exports.addNamed = addNamed;
+exports.addNamespace = addNamespace;
+exports.addSideEffect = addSideEffect;
+Object.defineProperty(exports, "isModule", {
+  enumerable: true,
+  get: function () {
+    return _isModule.default;
+  }
+});
+var _importInjector = require("./import-injector.js");
+var _isModule = require("./is-module.js");
+function addDefault(path, importedSource, opts) {
+  return new _importInjector.default(path).addDefault(importedSource, opts);
+}
+function addNamed(path, name, importedSource, opts) {
+  return new _importInjector.default(path).addNamed(name, importedSource, opts);
+}
+function addNamespace(path, importedSource, opts) {
+  return new _importInjector.default(path).addNamespace(importedSource, opts);
+}
+function addSideEffect(path, importedSource, opts) {
+  return new _importInjector.default(path).addSideEffect(importedSource, opts);
+}
+
+//# sourceMappingURL=index.js.map

frontend/node_modules/@babel/helper-module-imports/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_importInjector","require","_isModule","addDefault","path","importedSource","opts","ImportInjector","addNamed","name","addNamespace","addSideEffect"],"sources":["../src/index.ts"],"sourcesContent":["import ImportInjector, { type ImportOptions } from \"./import-injector.ts\";\nimport type { NodePath } from \"@babel/traverse\";\nimport type * as t from \"@babel/types\";\n\nexport { ImportInjector };\n\nexport { default as isModule } from \"./is-module.ts\";\n\nexport function addDefault(\n  path: NodePath,\n  importedSource: string,\n  opts?: Partial<ImportOptions>,\n) {\n  return new ImportInjector(path).addDefault(importedSource, opts);\n}\n\nfunction addNamed(\n  path: NodePath,\n  name: string,\n  importedSource: string,\n  opts?: Omit<\n    Partial<ImportOptions>,\n    \"ensureLiveReference\" | \"ensureNoContext\"\n  >,\n): t.Identifier;\nfunction addNamed(\n  path: NodePath,\n  name: string,\n  importedSource: string,\n  opts?: Omit<Partial<ImportOptions>, \"ensureLiveReference\"> & {\n    ensureLiveReference: true;\n  },\n): t.MemberExpression;\nfunction addNamed(\n  path: NodePath,\n  name: string,\n  importedSource: string,\n  opts?: Omit<Partial<ImportOptions>, \"ensureNoContext\"> & {\n    ensureNoContext: true;\n  },\n): t.SequenceExpression;\n/**\n * add a named import to the program path of given path\n *\n * @export\n * @param {NodePath} path The starting path to find a program path\n * @param {string} name The name of the generated binding. Babel will prefix it with `_`\n * @param {string} importedSource The source of the import\n * @param {Partial<ImportOptions>} [opts]\n * @returns {t.Identifier | t.MemberExpression | t.SequenceExpression} If opts.ensureNoContext is true, returns a SequenceExpression,\n *   else if opts.ensureLiveReference is true, returns a MemberExpression, else returns an Identifier\n */\nfunction addNamed(\n  path: NodePath,\n  name: string,\n  importedSource: string,\n  opts?: Partial<ImportOptions>,\n) {\n  return new ImportInjector(path).addNamed(name, importedSource, opts);\n}\nexport { addNamed };\n\nexport function addNamespace(\n  path: NodePath,\n  importedSource: string,\n  opts?: Partial<ImportOptions>,\n) {\n  return new ImportInjector(path).addNamespace(importedSource, opts);\n}\n\nexport function addSideEffect(\n  path: NodePath,\n  importedSource: string,\n  opts?: Partial<ImportOptions>,\n) {\n  return new ImportInjector(path).addSideEffect(importedSource, opts);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,eAAA,GAAAC,OAAA;AAMA,IAAAC,SAAA,GAAAD,OAAA;AAEO,SAASE,UAAUA,CACxBC,IAAc,EACdC,cAAsB,EACtBC,IAA6B,EAC7B;EACA,OAAO,IAAIC,uBAAc,CAACH,IAAI,CAAC,CAACD,UAAU,CAACE,cAAc,EAAEC,IAAI,CAAC;AAClE;AAsCA,SAASE,QAAQA,CACfJ,IAAc,EACdK,IAAY,EACZJ,cAAsB,EACtBC,IAA6B,EAC7B;EACA,OAAO,IAAIC,uBAAc,CAACH,IAAI,CAAC,CAACI,QAAQ,CAACC,IAAI,EAAEJ,cAAc,EAAEC,IAAI,CAAC;AACtE;AAGO,SAASI,YAAYA,CAC1BN,IAAc,EACdC,cAAsB,EACtBC,IAA6B,EAC7B;EACA,OAAO,IAAIC,uBAAc,CAACH,IAAI,CAAC,CAACM,YAAY,CAACL,cAAc,EAAEC,IAAI,CAAC;AACpE;AAEO,SAASK,aAAaA,CAC3BP,IAAc,EACdC,cAAsB,EACtBC,IAA6B,EAC7B;EACA,OAAO,IAAIC,uBAAc,CAACH,IAAI,CAAC,CAACO,aAAa,CAACN,cAAc,EAAEC,IAAI,CAAC;AACrE","ignoreList":[]}

frontend/node_modules/@babel/helper-module-imports/lib/is-module.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isModule;
+function isModule(path) {
+  return path.node.sourceType === "module";
+}
+
+//# sourceMappingURL=is-module.js.map

frontend/node_modules/@babel/helper-module-imports/lib/is-module.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["isModule","path","node","sourceType"],"sources":["../src/is-module.ts"],"sourcesContent":["import type { NodePath } from \"@babel/traverse\";\nimport type * as t from \"@babel/types\";\n\n/**\n * A small utility to check if a file qualifies as a module.\n */\nexport default function isModule(path: NodePath<t.Program>) {\n  return path.node.sourceType === \"module\";\n}\n"],"mappings":";;;;;;AAMe,SAASA,QAAQA,CAACC,IAAyB,EAAE;EAC1D,OAAOA,IAAI,CAACC,IAAI,CAACC,UAAU,KAAK,QAAQ;AAC1C","ignoreList":[]}

frontend/node_modules/@babel/helper-module-imports/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@babel/helper-module-imports",
+  "version": "7.29.7",
+  "description": "Babel helper functions for inserting module loads",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "homepage": "https://babel.dev/docs/en/next/babel-helper-module-imports",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-module-imports"
+  },
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/traverse": "^7.29.7",
+    "@babel/types": "^7.29.7"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.29.7"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "type": "commonjs"
+}

frontend/node_modules/@babel/helper-string-parser/LICENSE

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

frontend/node_modules/@babel/helper-string-parser/README.md

@@ -0,0 +1,19 @@
+# @babel/helper-string-parser
+
+> A utility package to parse strings
+
+See our website [@babel/helper-string-parser](https://babeljs.io/docs/babel-helper-string-parser) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-string-parser
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-string-parser
+```

frontend/node_modules/@babel/helper-string-parser/lib/index.js

@@ -0,0 +1,295 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readCodePoint = readCodePoint;
+exports.readInt = readInt;
+exports.readStringContents = readStringContents;
+var _isDigit = function isDigit(code) {
+  return code >= 48 && code <= 57;
+};
+const forbiddenNumericSeparatorSiblings = {
+  decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
+  hex: new Set([46, 88, 95, 120])
+};
+const isAllowedNumericSeparatorSibling = {
+  bin: ch => ch === 48 || ch === 49,
+  oct: ch => ch >= 48 && ch <= 55,
+  dec: ch => ch >= 48 && ch <= 57,
+  hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
+};
+function readStringContents(type, input, pos, lineStart, curLine, errors) {
+  const initialPos = pos;
+  const initialLineStart = lineStart;
+  const initialCurLine = curLine;
+  let out = "";
+  let firstInvalidLoc = null;
+  let chunkStart = pos;
+  const {
+    length
+  } = input;
+  for (;;) {
+    if (pos >= length) {
+      errors.unterminated(initialPos, initialLineStart, initialCurLine);
+      out += input.slice(chunkStart, pos);
+      break;
+    }
+    const ch = input.charCodeAt(pos);
+    if (isStringEnd(type, ch, input, pos)) {
+      out += input.slice(chunkStart, pos);
+      break;
+    }
+    if (ch === 92) {
+      out += input.slice(chunkStart, pos);
+      const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors);
+      if (res.ch === null && !firstInvalidLoc) {
+        firstInvalidLoc = {
+          pos,
+          lineStart,
+          curLine
+        };
+      } else {
+        out += res.ch;
+      }
+      ({
+        pos,
+        lineStart,
+        curLine
+      } = res);
+      chunkStart = pos;
+    } else if (ch === 8232 || ch === 8233) {
+      ++pos;
+      ++curLine;
+      lineStart = pos;
+    } else if (ch === 10 || ch === 13) {
+      if (type === "template") {
+        out += input.slice(chunkStart, pos) + "\n";
+        ++pos;
+        if (ch === 13 && input.charCodeAt(pos) === 10) {
+          ++pos;
+        }
+        ++curLine;
+        chunkStart = lineStart = pos;
+      } else {
+        errors.unterminated(initialPos, initialLineStart, initialCurLine);
+      }
+    } else {
+      ++pos;
+    }
+  }
+  return {
+    pos,
+    str: out,
+    firstInvalidLoc,
+    lineStart,
+    curLine,
+    containsInvalid: !!firstInvalidLoc
+  };
+}
+function isStringEnd(type, ch, input, pos) {
+  if (type === "template") {
+    return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
+  }
+  return ch === (type === "double" ? 34 : 39);
+}
+function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
+  const throwOnInvalid = !inTemplate;
+  pos++;
+  const res = ch => ({
+    pos,
+    ch,
+    lineStart,
+    curLine
+  });
+  const ch = input.charCodeAt(pos++);
+  switch (ch) {
+    case 110:
+      return res("\n");
+    case 114:
+      return res("\r");
+    case 120:
+      {
+        let code;
+        ({
+          code,
+          pos
+        } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
+        return res(code === null ? null : String.fromCharCode(code));
+      }
+    case 117:
+      {
+        let code;
+        ({
+          code,
+          pos
+        } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));
+        return res(code === null ? null : String.fromCodePoint(code));
+      }
+    case 116:
+      return res("\t");
+    case 98:
+      return res("\b");
+    case 118:
+      return res("\u000b");
+    case 102:
+      return res("\f");
+    case 13:
+      if (input.charCodeAt(pos) === 10) {
+        ++pos;
+      }
+    case 10:
+      lineStart = pos;
+      ++curLine;
+    case 8232:
+    case 8233:
+      return res("");
+    case 56:
+    case 57:
+      if (inTemplate) {
+        return res(null);
+      } else {
+        errors.strictNumericEscape(pos - 1, lineStart, curLine);
+      }
+    default:
+      if (ch >= 48 && ch <= 55) {
+        const startPos = pos - 1;
+        const match = /^[0-7]+/.exec(input.slice(startPos, pos + 2));
+        let octalStr = match[0];
+        let octal = parseInt(octalStr, 8);
+        if (octal > 255) {
+          octalStr = octalStr.slice(0, -1);
+          octal = parseInt(octalStr, 8);
+        }
+        pos += octalStr.length - 1;
+        const next = input.charCodeAt(pos);
+        if (octalStr !== "0" || next === 56 || next === 57) {
+          if (inTemplate) {
+            return res(null);
+          } else {
+            errors.strictNumericEscape(startPos, lineStart, curLine);
+          }
+        }
+        return res(String.fromCharCode(octal));
+      }
+      return res(String.fromCharCode(ch));
+  }
+}
+function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
+  const initialPos = pos;
+  let n;
+  ({
+    n,
+    pos
+  } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
+  if (n === null) {
+    if (throwOnInvalid) {
+      errors.invalidEscapeSequence(initialPos, lineStart, curLine);
+    } else {
+      pos = initialPos - 1;
+    }
+  }
+  return {
+    code: n,
+    pos
+  };
+}
+function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
+  const start = pos;
+  const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
+  const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
+  let invalid = false;
+  let total = 0;
+  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+    const code = input.charCodeAt(pos);
+    let val;
+    if (code === 95 && allowNumSeparator !== "bail") {
+      const prev = input.charCodeAt(pos - 1);
+      const next = input.charCodeAt(pos + 1);
+      if (!allowNumSeparator) {
+        if (bailOnError) return {
+          n: null,
+          pos
+        };
+        errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
+      } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
+        if (bailOnError) return {
+          n: null,
+          pos
+        };
+        errors.unexpectedNumericSeparator(pos, lineStart, curLine);
+      }
+      ++pos;
+      continue;
+    }
+    if (code >= 97) {
+      val = code - 97 + 10;
+    } else if (code >= 65) {
+      val = code - 65 + 10;
+    } else if (_isDigit(code)) {
+      val = code - 48;
+    } else {
+      val = Infinity;
+    }
+    if (val >= radix) {
+      if (val <= 9 && bailOnError) {
+        return {
+          n: null,
+          pos
+        };
+      } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {
+        val = 0;
+      } else if (forceLen) {
+        val = 0;
+        invalid = true;
+      } else {
+        break;
+      }
+    }
+    ++pos;
+    total = total * radix + val;
+  }
+  if (pos === start || len != null && pos - start !== len || invalid) {
+    return {
+      n: null,
+      pos
+    };
+  }
+  return {
+    n: total,
+    pos
+  };
+}
+function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
+  const ch = input.charCodeAt(pos);
+  let code;
+  if (ch === 123) {
+    ++pos;
+    ({
+      code,
+      pos
+    } = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
+    ++pos;
+    if (code !== null && code > 0x10ffff) {
+      if (throwOnInvalid) {
+        errors.invalidCodePoint(pos, lineStart, curLine);
+      } else {
+        return {
+          code: null,
+          pos
+        };
+      }
+    }
+  } else {
+    ({
+      code,
+      pos
+    } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
+  }
+  return {
+    code,
+    pos
+  };
+}
+
+//# sourceMappingURL=index.js.map

frontend/node_modules/@babel/helper-string-parser/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@babel/helper-string-parser",
+  "version": "7.29.7",
+  "description": "A utility package to parse strings",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-string-parser"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-helper-string-parser",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "devDependencies": {
+    "charcodes": "^0.2.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "type": "commonjs"
+}

frontend/node_modules/@babel/helper-validator-identifier/LICENSE

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

frontend/node_modules/@babel/helper-validator-identifier/README.md

@@ -0,0 +1,19 @@
+# @babel/helper-validator-identifier
+
+> Validate identifier/keywords name
+
+See our website [@babel/helper-validator-identifier](https://babeljs.io/docs/babel-helper-validator-identifier) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-validator-identifier
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-validator-identifier
+```

frontend/node_modules/@babel/helper-validator-identifier/lib/identifier.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isIdentifierChar = isIdentifierChar;
+exports.isIdentifierName = isIdentifierName;
+exports.isIdentifierStart = isIdentifierStart;
+let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088f\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5c\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdc-\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c8a\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7dc\ua7f1-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+let nonASCIIidentifierChars = "\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0897-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0cf3\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1add\u1ae0-\u1aeb\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\u30fb\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f\uff65";
+const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
+const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 4, 51, 13, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 7, 25, 39, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 39, 27, 10, 22, 251, 41, 7, 1, 17, 5, 57, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 31, 9, 2, 0, 3, 0, 2, 37, 2, 0, 26, 0, 2, 0, 45, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 200, 32, 32, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 24, 43, 261, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 26, 3994, 6, 582, 6842, 29, 1763, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 433, 44, 212, 63, 33, 24, 3, 24, 45, 74, 6, 0, 67, 12, 65, 1, 2, 0, 15, 4, 10, 7381, 42, 31, 98, 114, 8702, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 229, 29, 3, 0, 208, 30, 2, 2, 2, 1, 2, 6, 3, 4, 10, 1, 225, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4381, 3, 5773, 3, 7472, 16, 621, 2467, 541, 1507, 4938, 6, 8489];
+const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 7, 9, 32, 4, 318, 1, 78, 5, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 68, 8, 2, 0, 3, 0, 2, 3, 2, 4, 2, 0, 15, 1, 83, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 7, 19, 58, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 199, 7, 137, 9, 54, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 55, 9, 266, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 10, 5350, 0, 7, 14, 11465, 27, 2343, 9, 87, 9, 39, 4, 60, 6, 26, 9, 535, 9, 470, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4178, 9, 519, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 245, 1, 2, 9, 233, 0, 3, 0, 8, 1, 6, 0, 475, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
+function isInAstralSet(code, set) {
+  let pos = 0x10000;
+  for (let i = 0, length = set.length; i < length; i += 2) {
+    pos += set[i];
+    if (pos > code) return false;
+    pos += set[i + 1];
+    if (pos >= code) return true;
+  }
+  return false;
+}
+function isIdentifierStart(code) {
+  if (code < 65) return code === 36;
+  if (code <= 90) return true;
+  if (code < 97) return code === 95;
+  if (code <= 122) return true;
+  if (code <= 0xffff) {
+    return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+  }
+  return isInAstralSet(code, astralIdentifierStartCodes);
+}
+function isIdentifierChar(code) {
+  if (code < 48) return code === 36;
+  if (code < 58) return true;
+  if (code < 65) return false;
+  if (code <= 90) return true;
+  if (code < 97) return code === 95;
+  if (code <= 122) return true;
+  if (code <= 0xffff) {
+    return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+  }
+  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
+}
+function isIdentifierName(name) {
+  let isFirst = true;
+  for (let i = 0; i < name.length; i++) {
+    let cp = name.charCodeAt(i);
+    if ((cp & 0xfc00) === 0xd800 && i + 1 < name.length) {
+      const trail = name.charCodeAt(++i);
+      if ((trail & 0xfc00) === 0xdc00) {
+        cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff);
+      }
+    }
+    if (isFirst) {
+      isFirst = false;
+      if (!isIdentifierStart(cp)) {
+        return false;
+      }
+    } else if (!isIdentifierChar(cp)) {
+      return false;
+    }
+  }
+  return !isFirst;
+}
+
+//# sourceMappingURL=identifier.js.map

frontend/node_modules/@babel/helper-validator-identifier/lib/index.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "isIdentifierChar", {
+  enumerable: true,
+  get: function () {
+    return _identifier.isIdentifierChar;
+  }
+});
+Object.defineProperty(exports, "isIdentifierName", {
+  enumerable: true,
+  get: function () {
+    return _identifier.isIdentifierName;
+  }
+});
+Object.defineProperty(exports, "isIdentifierStart", {
+  enumerable: true,
+  get: function () {
+    return _identifier.isIdentifierStart;
+  }
+});
+Object.defineProperty(exports, "isKeyword", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isKeyword;
+  }
+});
+Object.defineProperty(exports, "isReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isReservedWord;
+  }
+});
+Object.defineProperty(exports, "isStrictBindOnlyReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isStrictBindOnlyReservedWord;
+  }
+});
+Object.defineProperty(exports, "isStrictBindReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isStrictBindReservedWord;
+  }
+});
+Object.defineProperty(exports, "isStrictReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isStrictReservedWord;
+  }
+});
+var _identifier = require("./identifier.js");
+var _keyword = require("./keyword.js");
+
+//# sourceMappingURL=index.js.map

frontend/node_modules/@babel/helper-validator-identifier/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_identifier","require","_keyword"],"sources":["../src/index.ts"],"sourcesContent":["export {\n  isIdentifierName,\n  isIdentifierChar,\n  isIdentifierStart,\n} from \"./identifier.ts\";\nexport {\n  isReservedWord,\n  isStrictBindOnlyReservedWord,\n  isStrictBindReservedWord,\n  isStrictReservedWord,\n  isKeyword,\n} from \"./keyword.ts\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,WAAA,GAAAC,OAAA;AAKA,IAAAC,QAAA,GAAAD,OAAA","ignoreList":[]}

frontend/node_modules/@babel/helper-validator-identifier/lib/keyword.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isKeyword = isKeyword;
+exports.isReservedWord = isReservedWord;
+exports.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord;
+exports.isStrictBindReservedWord = isStrictBindReservedWord;
+exports.isStrictReservedWord = isStrictReservedWord;
+const reservedWords = {
+  keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
+  strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
+  strictBind: ["eval", "arguments"]
+};
+const keywords = new Set(reservedWords.keyword);
+const reservedWordsStrictSet = new Set(reservedWords.strict);
+const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
+function isReservedWord(word, inModule) {
+  return inModule && word === "await" || word === "enum";
+}
+function isStrictReservedWord(word, inModule) {
+  return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
+}
+function isStrictBindOnlyReservedWord(word) {
+  return reservedWordsStrictBindSet.has(word);
+}
+function isStrictBindReservedWord(word, inModule) {
+  return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
+}
+function isKeyword(word) {
+  return keywords.has(word);
+}
+
+//# sourceMappingURL=keyword.js.map

frontend/node_modules/@babel/helper-validator-identifier/lib/keyword.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["reservedWords","keyword","strict","strictBind","keywords","Set","reservedWordsStrictSet","reservedWordsStrictBindSet","isReservedWord","word","inModule","isStrictReservedWord","has","isStrictBindOnlyReservedWord","isStrictBindReservedWord","isKeyword"],"sources":["../src/keyword.ts"],"sourcesContent":["const reservedWords = {\n  keyword: [\n    \"break\",\n    \"case\",\n    \"catch\",\n    \"continue\",\n    \"debugger\",\n    \"default\",\n    \"do\",\n    \"else\",\n    \"finally\",\n    \"for\",\n    \"function\",\n    \"if\",\n    \"return\",\n    \"switch\",\n    \"throw\",\n    \"try\",\n    \"var\",\n    \"const\",\n    \"while\",\n    \"with\",\n    \"new\",\n    \"this\",\n    \"super\",\n    \"class\",\n    \"extends\",\n    \"export\",\n    \"import\",\n    \"null\",\n    \"true\",\n    \"false\",\n    \"in\",\n    \"instanceof\",\n    \"typeof\",\n    \"void\",\n    \"delete\",\n  ],\n  strict: [\n    \"implements\",\n    \"interface\",\n    \"let\",\n    \"package\",\n    \"private\",\n    \"protected\",\n    \"public\",\n    \"static\",\n    \"yield\",\n  ],\n  strictBind: [\"eval\", \"arguments\"],\n};\nconst keywords = new Set(reservedWords.keyword);\nconst reservedWordsStrictSet = new Set(reservedWords.strict);\nconst reservedWordsStrictBindSet = new Set(reservedWords.strictBind);\n\n/**\n * Checks if word is a reserved word in non-strict mode\n */\nexport function isReservedWord(word: string, inModule: boolean): boolean {\n  return (inModule && word === \"await\") || word === \"enum\";\n}\n\n/**\n * Checks if word is a reserved word in non-binding strict mode\n *\n * Includes non-strict reserved words\n */\nexport function isStrictReservedWord(word: string, inModule: boolean): boolean {\n  return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);\n}\n\n/**\n * Checks if word is a reserved word in binding strict mode, but it is allowed as\n * a normal identifier.\n */\nexport function isStrictBindOnlyReservedWord(word: string): boolean {\n  return reservedWordsStrictBindSet.has(word);\n}\n\n/**\n * Checks if word is a reserved word in binding strict mode\n *\n * Includes non-strict reserved words and non-binding strict reserved words\n */\nexport function isStrictBindReservedWord(\n  word: string,\n  inModule: boolean,\n): boolean {\n  return (\n    isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word)\n  );\n}\n\nexport function isKeyword(word: string): boolean {\n  return keywords.has(word);\n}\n"],"mappings":";;;;;;;;;;AAAA,MAAMA,aAAa,GAAG;EACpBC,OAAO,EAAE,CACP,OAAO,EACP,MAAM,EACN,OAAO,EACP,UAAU,EACV,UAAU,EACV,SAAS,EACT,IAAI,EACJ,MAAM,EACN,SAAS,EACT,KAAK,EACL,UAAU,EACV,IAAI,EACJ,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,KAAK,EACL,KAAK,EACL,OAAO,EACP,OAAO,EACP,MAAM,EACN,KAAK,EACL,MAAM,EACN,OAAO,EACP,OAAO,EACP,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,MAAM,EACN,OAAO,EACP,IAAI,EACJ,YAAY,EACZ,QAAQ,EACR,MAAM,EACN,QAAQ,CACT;EACDC,MAAM,EAAE,CACN,YAAY,EACZ,WAAW,EACX,KAAK,EACL,SAAS,EACT,SAAS,EACT,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,OAAO,CACR;EACDC,UAAU,EAAE,CAAC,MAAM,EAAE,WAAW;AAClC,CAAC;AACD,MAAMC,QAAQ,GAAG,IAAIC,GAAG,CAACL,aAAa,CAACC,OAAO,CAAC;AAC/C,MAAMK,sBAAsB,GAAG,IAAID,GAAG,CAACL,aAAa,CAACE,MAAM,CAAC;AAC5D,MAAMK,0BAA0B,GAAG,IAAIF,GAAG,CAACL,aAAa,CAACG,UAAU,CAAC;AAK7D,SAASK,cAAcA,CAACC,IAAY,EAAEC,QAAiB,EAAW;EACvE,OAAQA,QAAQ,IAAID,IAAI,KAAK,OAAO,IAAKA,IAAI,KAAK,MAAM;AAC1D;AAOO,SAASE,oBAAoBA,CAACF,IAAY,EAAEC,QAAiB,EAAW;EAC7E,OAAOF,cAAc,CAACC,IAAI,EAAEC,QAAQ,CAAC,IAAIJ,sBAAsB,CAACM,GAAG,CAACH,IAAI,CAAC;AAC3E;AAMO,SAASI,4BAA4BA,CAACJ,IAAY,EAAW;EAClE,OAAOF,0BAA0B,CAACK,GAAG,CAACH,IAAI,CAAC;AAC7C;AAOO,SAASK,wBAAwBA,CACtCL,IAAY,EACZC,QAAiB,EACR;EACT,OACEC,oBAAoB,CAACF,IAAI,EAAEC,QAAQ,CAAC,IAAIG,4BAA4B,CAACJ,IAAI,CAAC;AAE9E;AAEO,SAASM,SAASA,CAACN,IAAY,EAAW;EAC/C,OAAOL,QAAQ,CAACQ,GAAG,CAACH,IAAI,CAAC;AAC3B","ignoreList":[]}

frontend/node_modules/@babel/helper-validator-identifier/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@babel/helper-validator-identifier",
+  "version": "7.29.7",
+  "description": "Validate identifier/keywords name",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-validator-identifier"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "devDependencies": {
+    "@unicode/unicode-17.0.0": "^1.6.10",
+    "charcodes": "^0.2.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}

frontend/node_modules/@babel/parser/LICENSE

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

frontend/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
+```

frontend/node_modules/@babel/parser/bin/babel-parser.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/* eslint-disable no-var, unicorn/prefer-node-protocol */
+
+var parser = require("..");
+var fs = require("fs");
+
+var filename = process.argv[2];
+if (!filename) {
+  console.error("no filename specified");
+} else {
+  var file = fs.readFileSync(filename, "utf8");
+  var ast = parser.parse(file);
+
+  console.log(JSON.stringify(ast, null, "  "));
+}

frontend/node_modules/@babel/parser/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@babel/parser",
+  "version": "7.29.7",
+  "description": "A JavaScript parser",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "homepage": "https://babel.dev/docs/en/next/babel-parser",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A+parser+%28babylon%29%22+is%3Aopen",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "babel",
+    "javascript",
+    "parser",
+    "tc39",
+    "ecmascript",
+    "@babel/parser"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-parser"
+  },
+  "main": "./lib/index.js",
+  "types": "./typings/babel-parser.d.ts",
+  "files": [
+    "bin",
+    "lib",
+    "typings/babel-parser.d.ts",
+    "index.cjs"
+  ],
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "# dependencies": "This package doesn't actually have runtime dependencies. @babel/types is only needed for type definitions.",
+  "dependencies": {
+    "@babel/types": "^7.29.7"
+  },
+  "devDependencies": {
+    "@babel/code-frame": "^7.29.7",
+    "@babel/helper-check-duplicate-nodes": "^7.29.7",
+    "@babel/helper-fixtures": "^7.29.7",
+    "@babel/helper-string-parser": "^7.29.7",
+    "@babel/helper-validator-identifier": "^7.29.7",
+    "charcodes": "^0.2.0"
+  },
+  "bin": "./bin/babel-parser.js",
+  "type": "commonjs"
+}

frontend/node_modules/@babel/parser/typings/babel-parser.d.ts

@@ -0,0 +1,262 @@
+// This file is auto-generated! Do not modify it directly.
+// Run `yarn gulp bundle-dts` to re-generate it.
+/* eslint-disable @typescript-eslint/consistent-type-imports, @typescript-eslint/no-redundant-type-constituents */
+import { File, Expression } from '@babel/types';
+
+declare class Position {
+    line: number;
+    column: number;
+    index: number;
+    constructor(line: number, col: number, index: number);
+}
+
+type SyntaxPlugin = "flow" | "typescript" | "jsx" | "pipelineOperator" | "placeholders";
+type ParseErrorCode = "BABEL_PARSER_SYNTAX_ERROR" | "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED";
+interface ParseErrorSpecification<ErrorDetails> {
+    code: ParseErrorCode;
+    reasonCode: string;
+    syntaxPlugin?: SyntaxPlugin;
+    missingPlugin?: string | string[];
+    loc: Position;
+    details: ErrorDetails;
+    pos: number;
+}
+type ParseError$1<ErrorDetails> = SyntaxError & ParseErrorSpecification<ErrorDetails>;
+
+type BABEL_8_BREAKING = false;
+type IF_BABEL_7<V> = false extends BABEL_8_BREAKING ? V : never;
+
+type Plugin$1 =
+  | "asyncDoExpressions"
+  | IF_BABEL_7<"asyncGenerators">
+  | IF_BABEL_7<"bigInt">
+  | IF_BABEL_7<"classPrivateMethods">
+  | IF_BABEL_7<"classPrivateProperties">
+  | IF_BABEL_7<"classProperties">
+  | IF_BABEL_7<"classStaticBlock">
+  | IF_BABEL_7<"decimal">
+  | "decorators-legacy"
+  | "deferredImportEvaluation"
+  | "decoratorAutoAccessors"
+  | "destructuringPrivate"
+  | IF_BABEL_7<"deprecatedImportAssert">
+  | "doExpressions"
+  | IF_BABEL_7<"dynamicImport">
+  | IF_BABEL_7<"explicitResourceManagement">
+  | "exportDefaultFrom"
+  | IF_BABEL_7<"exportNamespaceFrom">
+  | "flow"
+  | "flowComments"
+  | "functionBind"
+  | "functionSent"
+  | "importMeta"
+  | "jsx"
+  | IF_BABEL_7<"jsonStrings">
+  | IF_BABEL_7<"logicalAssignment">
+  | IF_BABEL_7<"importAssertions">
+  | IF_BABEL_7<"importReflection">
+  | "moduleBlocks"
+  | IF_BABEL_7<"moduleStringNames">
+  | IF_BABEL_7<"nullishCoalescingOperator">
+  | IF_BABEL_7<"numericSeparator">
+  | IF_BABEL_7<"objectRestSpread">
+  | IF_BABEL_7<"optionalCatchBinding">
+  | IF_BABEL_7<"optionalChaining">
+  | "partialApplication"
+  | "placeholders"
+  | IF_BABEL_7<"privateIn">
+  | IF_BABEL_7<"regexpUnicodeSets">
+  | "sourcePhaseImports"
+  | "throwExpressions"
+  | IF_BABEL_7<"topLevelAwait">
+  | "v8intrinsic"
+  | ParserPluginWithOptions[0];
+
+type ParserPluginWithOptions =
+  | ["decorators", DecoratorsPluginOptions]
+  | ["discardBinding", { syntaxType: "void" }]
+  | ["estree", { classFeatures?: boolean }]
+  | IF_BABEL_7<["importAttributes", { deprecatedAssertSyntax: boolean }]>
+  | IF_BABEL_7<["moduleAttributes", { version: "may-2020" }]>
+  | ["optionalChainingAssign", { version: "2023-07" }]
+  | ["pipelineOperator", PipelineOperatorPluginOptions]
+  | ["recordAndTuple", RecordAndTuplePluginOptions]
+  | ["flow", FlowPluginOptions]
+  | ["typescript", TypeScriptPluginOptions];
+
+type PluginConfig = Plugin$1 | ParserPluginWithOptions;
+
+interface DecoratorsPluginOptions {
+  decoratorsBeforeExport?: boolean;
+  allowCallParenthesized?: boolean;
+}
+
+interface PipelineOperatorPluginOptions {
+  proposal: BABEL_8_BREAKING extends false
+    ? "minimal" | "fsharp" | "hack" | "smart"
+    : "fsharp" | "hack";
+  topicToken?: "%" | "#" | "@@" | "^^" | "^";
+}
+
+interface RecordAndTuplePluginOptions {
+  syntaxType: "bar" | "hash";
+}
+
+type FlowPluginOptions = BABEL_8_BREAKING extends true
+  ? {
+      all?: boolean;
+      enums?: boolean;
+    }
+  : {
+      all?: boolean;
+    };
+
+interface TypeScriptPluginOptions {
+  dts?: boolean;
+  disallowAmbiguousJSXLike?: boolean;
+}
+
+type Plugin = PluginConfig;
+
+type SourceType = "script" | "commonjs" | "module" | "unambiguous";
+interface Options {
+    /**
+     * By default, import and export declarations can only appear at a program's top level.
+     * Setting this option to true allows them anywhere where a statement is allowed.
+     */
+    allowImportExportEverywhere?: boolean;
+    /**
+     * By default, await use is not allowed outside of an async function.
+     * Set this to true to accept such code.
+     */
+    allowAwaitOutsideFunction?: boolean;
+    /**
+     * By default, a return statement at the top level raises an error.
+     * Set this to true to accept such code.
+     */
+    allowReturnOutsideFunction?: boolean;
+    /**
+     * By default, new.target use is not allowed outside of a function or class.
+     * Set this to true to accept such code.
+     */
+    allowNewTargetOutsideFunction?: boolean;
+    /**
+     * By default, super calls are not allowed outside of a method.
+     * Set this to true to accept such code.
+     */
+    allowSuperOutsideMethod?: boolean;
+    /**
+     * By default, exported identifiers must refer to a declared variable.
+     * Set this to true to allow export statements to reference undeclared variables.
+     */
+    allowUndeclaredExports?: boolean;
+    /**
+     * By default, yield use is not allowed outside of a generator function.
+     * Set this to true to accept such code.
+     */
+    allowYieldOutsideFunction?: boolean;
+    /**
+     * By default, Babel parser JavaScript code according to Annex B syntax.
+     * Set this to `false` to disable such behavior.
+     */
+    annexB?: boolean;
+    /**
+     * By default, Babel attaches comments to adjacent AST nodes.
+     * When this option is set to false, comments are not attached.
+     * It can provide up to 30% performance improvement when the input code has many comments.
+     * @babel/eslint-parser will set it for you.
+     * It is not recommended to use attachComment: false with Babel transform,
+     * as doing so removes all the comments in output code, and renders annotations such as
+     * /* istanbul ignore next *\/ nonfunctional.
+     */
+    attachComment?: boolean;
+    /**
+     * By default, Babel always throws an error when it finds some invalid code.
+     * When this option is set to true, it will store the parsing error and
+     * try to continue parsing the invalid input file.
+     */
+    errorRecovery?: boolean;
+    /**
+     * Indicate the mode the code should be parsed in.
+     * Can be one of "script", "commonjs", "module", or "unambiguous". Defaults to "script".
+     * "unambiguous" will make @babel/parser attempt to guess, based on the presence
+     * of ES6 import or export statements.
+     * Files with ES6 imports and exports are considered "module" and are otherwise "script".
+     *
+     * Use "commonjs" to parse code that is intended to be run in a CommonJS environment such as Node.js.
+     */
+    sourceType?: SourceType;
+    /**
+     * Correlate output AST nodes with their source filename.
+     * Useful when generating code and source maps from the ASTs of multiple input files.
+     */
+    sourceFilename?: string;
+    /**
+     * By default, all source indexes start from 0.
+     * You can provide a start index to alternatively start with.
+     * Useful for integration with other source tools.
+     */
+    startIndex?: number;
+    /**
+     * By default, the first line of code parsed is treated as line 1.
+     * You can provide a line number to alternatively start with.
+     * Useful for integration with other source tools.
+     */
+    startLine?: number;
+    /**
+     * By default, the parsed code is treated as if it starts from line 1, column 0.
+     * You can provide a column number to alternatively start with.
+     * Useful for integration with other source tools.
+     */
+    startColumn?: number;
+    /**
+     * Array containing the plugins that you want to enable.
+     */
+    plugins?: Plugin[];
+    /**
+     * Should the parser work in strict mode.
+     * Defaults to true if sourceType === 'module'. Otherwise, false.
+     */
+    strictMode?: boolean;
+    /**
+     * Adds a ranges property to each node: [node.start, node.end]
+     */
+    ranges?: boolean;
+    /**
+     * Adds all parsed tokens to a tokens property on the File node.
+     */
+    tokens?: boolean;
+    /**
+     * By default, the parser adds information about parentheses by setting
+     * `extra.parenthesized` to `true` as needed.
+     * When this option is `true` the parser creates `ParenthesizedExpression`
+     * AST nodes instead of using the `extra` property.
+     */
+    createParenthesizedExpressions?: boolean;
+    /**
+     * The default is false in Babel 7 and true in Babel 8
+     * Set this to true to parse it as an `ImportExpression` node.
+     * Otherwise `import(foo)` is parsed as `CallExpression(Import, [Identifier(foo)])`.
+     */
+    createImportExpressions?: boolean;
+}
+
+type ParserOptions = Partial<Options>;
+type ParseError = ParseError$1<object>;
+type ParseResult<Result extends File | Expression = File> = Result & {
+    comments: File["comments"];
+    errors: null | ParseError[];
+    tokens?: File["tokens"];
+};
+/**
+ * Parse the provided code as an entire ECMAScript program.
+ */
+declare function parse(input: string, options?: ParserOptions): ParseResult<File>;
+declare function parseExpression(input: string, options?: ParserOptions): ParseResult<Expression>;
+
+declare const tokTypes: {
+  // todo(flow->ts) real token type
+  [name: string]: any;
+};
+
+export { DecoratorsPluginOptions, FlowPluginOptions, ParseError, ParseResult, ParserOptions, PluginConfig as ParserPlugin, ParserPluginWithOptions, PipelineOperatorPluginOptions, RecordAndTuplePluginOptions, TypeScriptPluginOptions, parse, parseExpression, tokTypes };

frontend/node_modules/@babel/runtime/LICENSE

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

frontend/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
+```

frontend/node_modules/@babel/runtime/helpers/AwaitValue.js

@@ -0,0 +1,4 @@
+function _AwaitValue(t) {
+  this.wrapped = t;
+}
+module.exports = _AwaitValue, module.exports.__esModule = true, module.exports["default"] = module.exports;

frontend/node_modules/@babel/runtime/helpers/OverloadYield.js

@@ -0,0 +1,4 @@
+function _OverloadYield(e, d) {
+  this.v = e, this.k = d;
+}
+module.exports = _OverloadYield, module.exports.__esModule = true, module.exports["default"] = module.exports;

frontend/node_modules/@babel/runtime/helpers/applyDecoratedDescriptor.js

@@ -0,0 +1,9 @@
+function _applyDecoratedDescriptor(i, e, r, n, l) {
+  var a = {};
+  return Object.keys(n).forEach(function (i) {
+    a[i] = n[i];
+  }), a.enumerable = !!a.enumerable, a.configurable = !!a.configurable, ("value" in a || a.initializer) && (a.writable = !0), a = r.slice().reverse().reduce(function (r, n) {
+    return n(i, e, r) || r;
+  }, a), l && void 0 !== a.initializer && (a.value = a.initializer ? a.initializer.call(l) : void 0, a.initializer = void 0), void 0 === a.initializer ? (Object.defineProperty(i, e, a), null) : a;
+}
+module.exports = _applyDecoratedDescriptor, module.exports.__esModule = true, module.exports["default"] = module.exports;

frontend/node_modules/@babel/runtime/helpers/applyDecs.js

@@ -0,0 +1,236 @@
+var _typeof = require("./typeof.js")["default"];
+var setFunctionName = require("./setFunctionName.js");
+var toPropertyKey = require("./toPropertyKey.js");
+function old_createMetadataMethodsForProperty(e, t, a, r) {
+  return {
+    getMetadata: function getMetadata(o) {
+      old_assertNotFinished(r, "getMetadata"), old_assertMetadataKey(o);
+      var i = e[o];
+      if (void 0 !== i) if (1 === t) {
+        var n = i["public"];
+        if (void 0 !== n) return n[a];
+      } else if (2 === t) {
+        var l = i["private"];
+        if (void 0 !== l) return l.get(a);
+      } else if (Object.hasOwnProperty.call(i, "constructor")) return i.constructor;
+    },
+    setMetadata: function setMetadata(o, i) {
+      old_assertNotFinished(r, "setMetadata"), old_assertMetadataKey(o);
+      var n = e[o];
+      if (void 0 === n && (n = e[o] = {}), 1 === t) {
+        var l = n["public"];
+        void 0 === l && (l = n["public"] = {}), l[a] = i;
+      } else if (2 === t) {
+        var s = n.priv;
+        void 0 === s && (s = n["private"] = new Map()), s.set(a, i);
+      } else n.constructor = i;
+    }
+  };
+}
+function old_convertMetadataMapToFinal(e, t) {
+  var a = e[Symbol.metadata || Symbol["for"]("Symbol.metadata")],
+    r = Object.getOwnPropertySymbols(t);
+  if (0 !== r.length) {
+    for (var o = 0; o < r.length; o++) {
+      var i = r[o],
+        n = t[i],
+        l = a ? a[i] : null,
+        s = n["public"],
+        c = l ? l["public"] : null;
+      s && c && Object.setPrototypeOf(s, c);
+      var d = n["private"];
+      if (d) {
+        var u = Array.from(d.values()),
+          f = l ? l["private"] : null;
+        f && (u = u.concat(f)), n["private"] = u;
+      }
+      l && Object.setPrototypeOf(n, l);
+    }
+    a && Object.setPrototypeOf(t, a), e[Symbol.metadata || Symbol["for"]("Symbol.metadata")] = t;
+  }
+}
+function old_createAddInitializerMethod(e, t) {
+  return function (a) {
+    old_assertNotFinished(t, "addInitializer"), old_assertCallable(a, "An initializer"), e.push(a);
+  };
+}
+function old_memberDec(e, t, a, r, o, i, n, l, s) {
+  var c;
+  switch (i) {
+    case 1:
+      c = "accessor";
+      break;
+    case 2:
+      c = "method";
+      break;
+    case 3:
+      c = "getter";
+      break;
+    case 4:
+      c = "setter";
+      break;
+    default:
+      c = "field";
+  }
+  var d,
+    u,
+    f = {
+      kind: c,
+      name: l ? "#" + t : toPropertyKey(t),
+      isStatic: n,
+      isPrivate: l
+    },
+    p = {
+      v: !1
+    };
+  if (0 !== i && (f.addInitializer = old_createAddInitializerMethod(o, p)), l) {
+    d = 2, u = Symbol(t);
+    var v = {};
+    0 === i ? (v.get = a.get, v.set = a.set) : 2 === i ? v.get = function () {
+      return a.value;
+    } : (1 !== i && 3 !== i || (v.get = function () {
+      return a.get.call(this);
+    }), 1 !== i && 4 !== i || (v.set = function (e) {
+      a.set.call(this, e);
+    })), f.access = v;
+  } else d = 1, u = t;
+  try {
+    return e(s, Object.assign(f, old_createMetadataMethodsForProperty(r, d, u, p)));
+  } finally {
+    p.v = !0;
+  }
+}
+function old_assertNotFinished(e, t) {
+  if (e.v) throw Error("attempted to call " + t + " after decoration was finished");
+}
+function old_assertMetadataKey(e) {
+  if ("symbol" != _typeof(e)) throw new TypeError("Metadata keys must be symbols, received: " + e);
+}
+function old_assertCallable(e, t) {
+  if ("function" != typeof e) throw new TypeError(t + " must be a function");
+}
+function old_assertValidReturnValue(e, t) {
+  var a = _typeof(t);
+  if (1 === e) {
+    if ("object" !== a || null === t) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+    void 0 !== t.get && old_assertCallable(t.get, "accessor.get"), void 0 !== t.set && old_assertCallable(t.set, "accessor.set"), void 0 !== t.init && old_assertCallable(t.init, "accessor.init"), void 0 !== t.initializer && old_assertCallable(t.initializer, "accessor.initializer");
+  } else if ("function" !== a) throw new TypeError((0 === e ? "field" : 10 === e ? "class" : "method") + " decorators must return a function or void 0");
+}
+function old_getInit(e) {
+  var t;
+  return null == (t = e.init) && (t = e.initializer) && void 0 !== console && console.warn(".initializer has been renamed to .init as of March 2022"), t;
+}
+function old_applyMemberDec(e, t, a, r, o, i, n, l, s) {
+  var c,
+    d,
+    u,
+    f,
+    p,
+    v,
+    y,
+    h = a[0];
+  if (n ? (0 === o || 1 === o ? (c = {
+    get: a[3],
+    set: a[4]
+  }, u = "get") : 3 === o ? (c = {
+    get: a[3]
+  }, u = "get") : 4 === o ? (c = {
+    set: a[3]
+  }, u = "set") : c = {
+    value: a[3]
+  }, 0 !== o && (1 === o && setFunctionName(a[4], "#" + r, "set"), setFunctionName(a[3], "#" + r, u))) : 0 !== o && (c = Object.getOwnPropertyDescriptor(t, r)), 1 === o ? f = {
+    get: c.get,
+    set: c.set
+  } : 2 === o ? f = c.value : 3 === o ? f = c.get : 4 === o && (f = c.set), "function" == typeof h) void 0 !== (p = old_memberDec(h, r, c, l, s, o, i, n, f)) && (old_assertValidReturnValue(o, p), 0 === o ? d = p : 1 === o ? (d = old_getInit(p), v = p.get || f.get, y = p.set || f.set, f = {
+    get: v,
+    set: y
+  }) : f = p);else for (var m = h.length - 1; m >= 0; m--) {
+    var b;
+    void 0 !== (p = old_memberDec(h[m], r, c, l, s, o, i, n, f)) && (old_assertValidReturnValue(o, p), 0 === o ? b = p : 1 === o ? (b = old_getInit(p), v = p.get || f.get, y = p.set || f.set, f = {
+      get: v,
+      set: y
+    }) : f = p, void 0 !== b && (void 0 === d ? d = b : "function" == typeof d ? d = [d, b] : d.push(b)));
+  }
+  if (0 === o || 1 === o) {
+    if (void 0 === d) d = function d(e, t) {
+      return t;
+    };else if ("function" != typeof d) {
+      var g = d;
+      d = function d(e, t) {
+        for (var a = t, r = 0; r < g.length; r++) a = g[r].call(e, a);
+        return a;
+      };
+    } else {
+      var _ = d;
+      d = function d(e, t) {
+        return _.call(e, t);
+      };
+    }
+    e.push(d);
+  }
+  0 !== o && (1 === o ? (c.get = f.get, c.set = f.set) : 2 === o ? c.value = f : 3 === o ? c.get = f : 4 === o && (c.set = f), n ? 1 === o ? (e.push(function (e, t) {
+    return f.get.call(e, t);
+  }), e.push(function (e, t) {
+    return f.set.call(e, t);
+  })) : 2 === o ? e.push(f) : e.push(function (e, t) {
+    return f.call(e, t);
+  }) : Object.defineProperty(t, r, c));
+}
+function old_applyMemberDecs(e, t, a, r, o) {
+  for (var i, n, l = new Map(), s = new Map(), c = 0; c < o.length; c++) {
+    var d = o[c];
+    if (Array.isArray(d)) {
+      var u,
+        f,
+        p,
+        v = d[1],
+        y = d[2],
+        h = d.length > 3,
+        m = v >= 5;
+      if (m ? (u = t, f = r, 0 != (v -= 5) && (p = n = n || [])) : (u = t.prototype, f = a, 0 !== v && (p = i = i || [])), 0 !== v && !h) {
+        var b = m ? s : l,
+          g = b.get(y) || 0;
+        if (!0 === g || 3 === g && 4 !== v || 4 === g && 3 !== v) throw 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: " + y);
+        !g && v > 2 ? b.set(y, v) : b.set(y, !0);
+      }
+      old_applyMemberDec(e, u, d, y, v, m, h, f, p);
+    }
+  }
+  old_pushInitializers(e, i), old_pushInitializers(e, n);
+}
+function old_pushInitializers(e, t) {
+  t && e.push(function (e) {
+    for (var a = 0; a < t.length; a++) t[a].call(e);
+    return e;
+  });
+}
+function old_applyClassDecs(e, t, a, r) {
+  if (r.length > 0) {
+    for (var o = [], i = t, n = t.name, l = r.length - 1; l >= 0; l--) {
+      var s = {
+        v: !1
+      };
+      try {
+        var c = Object.assign({
+            kind: "class",
+            name: n,
+            addInitializer: old_createAddInitializerMethod(o, s)
+          }, old_createMetadataMethodsForProperty(a, 0, n, s)),
+          d = r[l](i, c);
+      } finally {
+        s.v = !0;
+      }
+      void 0 !== d && (old_assertValidReturnValue(10, d), i = d);
+    }
+    e.push(i, function () {
+      for (var e = 0; e < o.length; e++) o[e].call(i);
+    });
+  }
+}
+function applyDecs(e, t, a) {
+  var r = [],
+    o = {},
+    i = {};
+  return old_applyMemberDecs(r, e, i, o, t), old_convertMetadataMapToFinal(e.prototype, i), old_applyClassDecs(r, e, o, a), old_convertMetadataMapToFinal(e, o), r;
+}
+module.exports = applyDecs, module.exports.__esModule = true, module.exports["default"] = module.exports;

frontend/node_modules/@babel/runtime/helpers/applyDecs2203.js

@@ -0,0 +1,184 @@
+var _typeof = require("./typeof.js")["default"];
+function applyDecs2203Factory() {
+  function createAddInitializerMethod(e, t) {
+    return function (r) {
+      !function (e) {
+        if (e.v) throw Error("attempted to call addInitializer after decoration was finished");
+      }(t), assertCallable(r, "An initializer"), e.push(r);
+    };
+  }
+  function memberDec(e, t, r, a, n, i, s, o) {
+    var c;
+    switch (n) {
+      case 1:
+        c = "accessor";
+        break;
+      case 2:
+        c = "method";
+        break;
+      case 3:
+        c = "getter";
+        break;
+      case 4:
+        c = "setter";
+        break;
+      default:
+        c = "field";
+    }
+    var l,
+      u,
+      f = {
+        kind: c,
+        name: s ? "#" + t : t,
+        "static": i,
+        "private": s
+      },
+      p = {
+        v: !1
+      };
+    0 !== n && (f.addInitializer = createAddInitializerMethod(a, p)), 0 === n ? s ? (l = r.get, u = r.set) : (l = function l() {
+      return this[t];
+    }, u = function u(e) {
+      this[t] = e;
+    }) : 2 === n ? l = function l() {
+      return r.value;
+    } : (1 !== n && 3 !== n || (l = function l() {
+      return r.get.call(this);
+    }), 1 !== n && 4 !== n || (u = function u(e) {
+      r.set.call(this, e);
+    })), f.access = l && u ? {
+      get: l,
+      set: u
+    } : l ? {
+      get: l
+    } : {
+      set: u
+    };
+    try {
+      return e(o, f);
+    } finally {
+      p.v = !0;
+    }
+  }
+  function assertCallable(e, t) {
+    if ("function" != typeof e) throw new TypeError(t + " must be a function");
+  }
+  function assertValidReturnValue(e, t) {
+    var r = _typeof(t);
+    if (1 === e) {
+      if ("object" !== r || null === t) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+      void 0 !== t.get && assertCallable(t.get, "accessor.get"), void 0 !== t.set && assertCallable(t.set, "accessor.set"), void 0 !== t.init && assertCallable(t.init, "accessor.init");
+    } else if ("function" !== r) throw new TypeError((0 === e ? "field" : 10 === e ? "class" : "method") + " decorators must return a function or void 0");
+  }
+  function applyMemberDec(e, t, r, a, n, i, s, o) {
+    var c,
+      l,
+      u,
+      f,
+      p,
+      d,
+      h = r[0];
+    if (s ? c = 0 === n || 1 === n ? {
+      get: r[3],
+      set: r[4]
+    } : 3 === n ? {
+      get: r[3]
+    } : 4 === n ? {
+      set: r[3]
+    } : {
+      value: r[3]
+    } : 0 !== n && (c = Object.getOwnPropertyDescriptor(t, a)), 1 === n ? u = {
+      get: c.get,
+      set: c.set
+    } : 2 === n ? u = c.value : 3 === n ? u = c.get : 4 === n && (u = c.set), "function" == typeof h) void 0 !== (f = memberDec(h, a, c, o, n, i, s, u)) && (assertValidReturnValue(n, f), 0 === n ? l = f : 1 === n ? (l = f.init, p = f.get || u.get, d = f.set || u.set, u = {
+      get: p,
+      set: d
+    }) : u = f);else for (var v = h.length - 1; v >= 0; v--) {
+      var g;
+      void 0 !== (f = memberDec(h[v], a, c, o, n, i, s, u)) && (assertValidReturnValue(n, f), 0 === n ? g = f : 1 === n ? (g = f.init, p = f.get || u.get, d = f.set || u.set, u = {
+        get: p,
+        set: d
+      }) : u = f, void 0 !== g && (void 0 === l ? l = g : "function" == typeof l ? l = [l, g] : l.push(g)));
+    }
+    if (0 === n || 1 === n) {
+      if (void 0 === l) l = function l(e, t) {
+        return t;
+      };else if ("function" != typeof l) {
+        var y = l;
+        l = function l(e, t) {
+          for (var r = t, a = 0; a < y.length; a++) r = y[a].call(e, r);
+          return r;
+        };
+      } else {
+        var m = l;
+        l = function l(e, t) {
+          return m.call(e, t);
+        };
+      }
+      e.push(l);
+    }
+    0 !== n && (1 === n ? (c.get = u.get, c.set = u.set) : 2 === n ? c.value = u : 3 === n ? c.get = u : 4 === n && (c.set = u), s ? 1 === n ? (e.push(function (e, t) {
+      return u.get.call(e, t);
+    }), e.push(function (e, t) {
+      return u.set.call(e, t);
+    })) : 2 === n ? e.push(u) : e.push(function (e, t) {
+      return u.call(e, t);
+    }) : Object.defineProperty(t, a, c));
+  }
+  function pushInitializers(e, t) {
+    t && e.push(function (e) {
+      for (var r = 0; r < t.length; r++) t[r].call(e);
+      return e;
+    });
+  }
+  return function (e, t, r) {
+    var a = [];
+    return function (e, t, r) {
+      for (var a, n, i = new Map(), s = new Map(), o = 0; o < r.length; o++) {
+        var c = r[o];
+        if (Array.isArray(c)) {
+          var l,
+            u,
+            f = c[1],
+            p = c[2],
+            d = c.length > 3,
+            h = f >= 5;
+          if (h ? (l = t, 0 != (f -= 5) && (u = n = n || [])) : (l = t.prototype, 0 !== f && (u = a = a || [])), 0 !== f && !d) {
+            var v = h ? s : i,
+              g = v.get(p) || 0;
+            if (!0 === g || 3 === g && 4 !== f || 4 === g && 3 !== f) throw 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: " + p);
+            !g && f > 2 ? v.set(p, f) : v.set(p, !0);
+          }
+          applyMemberDec(e, l, c, p, f, h, d, u);
+        }
+      }
+      pushInitializers(e, a), pushInitializers(e, n);
+    }(a, e, t), function (e, t, r) {
+      if (r.length > 0) {
+        for (var a = [], n = t, i = t.name, s = r.length - 1; s >= 0; s--) {
+          var o = {
+            v: !1
+          };
+          try {
+            var c = r[s](n, {
+              kind: "class",
+              name: i,
+              addInitializer: createAddInitializerMethod(a, o)
+            });
+          } finally {
+            o.v = !0;
+          }
+          void 0 !== c && (assertValidReturnValue(10, c), n = c);
+        }
+        e.push(n, function () {
+          for (var e = 0; e < a.length; e++) a[e].call(n);
+        });
+      }
+    }(a, e, r), a;
+  };
+}
+var applyDecs2203Impl;
+function applyDecs2203(e, t, r) {
+  return (applyDecs2203Impl = applyDecs2203Impl || applyDecs2203Factory())(e, t, r);
+}
+module.exports = applyDecs2203, module.exports.__esModule = true, module.exports["default"] = module.exports;

frontend/node_modules/@babel/runtime/helpers/applyDecs2203R.js

@@ -0,0 +1,191 @@
+var _typeof = require("./typeof.js")["default"];
+var setFunctionName = require("./setFunctionName.js");
+var toPropertyKey = require("./toPropertyKey.js");
+function applyDecs2203RFactory() {
+  function createAddInitializerMethod(e, t) {
+    return function (r) {
+      !function (e) {
+        if (e.v) throw Error("attempted to call addInitializer after decoration was finished");
+      }(t), assertCallable(r, "An initializer"), e.push(r);
+    };
+  }
+  function memberDec(e, t, r, n, a, i, o, s) {
+    var c;
+    switch (a) {
+      case 1:
+        c = "accessor";
+        break;
+      case 2:
+        c = "method";
+        break;
+      case 3:
+        c = "getter";
+        break;
+      case 4:
+        c = "setter";
+        break;
+      default:
+        c = "field";
+    }
+    var l,
+      u,
+      f = {
+        kind: c,
+        name: o ? "#" + t : toPropertyKey(t),
+        "static": i,
+        "private": o
+      },
+      p = {
+        v: !1
+      };
+    0 !== a && (f.addInitializer = createAddInitializerMethod(n, p)), 0 === a ? o ? (l = r.get, u = r.set) : (l = function l() {
+      return this[t];
+    }, u = function u(e) {
+      this[t] = e;
+    }) : 2 === a ? l = function l() {
+      return r.value;
+    } : (1 !== a && 3 !== a || (l = function l() {
+      return r.get.call(this);
+    }), 1 !== a && 4 !== a || (u = function u(e) {
+      r.set.call(this, e);
+    })), f.access = l && u ? {
+      get: l,
+      set: u
+    } : l ? {
+      get: l
+    } : {
+      set: u
+    };
+    try {
+      return e(s, f);
+    } finally {
+      p.v = !0;
+    }
+  }
+  function assertCallable(e, t) {
+    if ("function" != typeof e) throw new TypeError(t + " must be a function");
+  }
+  function assertValidReturnValue(e, t) {
+    var r = _typeof(t);
+    if (1 === e) {
+      if ("object" !== r || null === t) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+      void 0 !== t.get && assertCallable(t.get, "accessor.get"), void 0 !== t.set && assertCallable(t.set, "accessor.set"), void 0 !== t.init && assertCallable(t.init, "accessor.init");
+    } else if ("function" !== r) throw new TypeError((0 === e ? "field" : 10 === e ? "class" : "method") + " decorators must return a function or void 0");
+  }
+  function applyMemberDec(e, t, r, n, a, i, o, s) {
+    var c,
+      l,
+      u,
+      f,
+      p,
+      d,
+      h,
+      v = r[0];
+    if (o ? (0 === a || 1 === a ? (c = {
+      get: r[3],
+      set: r[4]
+    }, u = "get") : 3 === a ? (c = {
+      get: r[3]
+    }, u = "get") : 4 === a ? (c = {
+      set: r[3]
+    }, u = "set") : c = {
+      value: r[3]
+    }, 0 !== a && (1 === a && setFunctionName(r[4], "#" + n, "set"), setFunctionName(r[3], "#" + n, u))) : 0 !== a && (c = Object.getOwnPropertyDescriptor(t, n)), 1 === a ? f = {
+      get: c.get,
+      set: c.set
+    } : 2 === a ? f = c.value : 3 === a ? f = c.get : 4 === a && (f = c.set), "function" == typeof v) void 0 !== (p = memberDec(v, n, c, s, a, i, o, f)) && (assertValidReturnValue(a, p), 0 === a ? l = p : 1 === a ? (l = p.init, d = p.get || f.get, h = p.set || f.set, f = {
+      get: d,
+      set: h
+    }) : f = p);else for (var g = v.length - 1; g >= 0; g--) {
+      var y;
+      void 0 !== (p = memberDec(v[g], n, c, s, a, i, o, f)) && (assertValidReturnValue(a, p), 0 === a ? y = p : 1 === a ? (y = p.init, d = p.get || f.get, h = p.set || f.set, f = {
+        get: d,
+        set: h
+      }) : f = p, void 0 !== y && (void 0 === l ? l = y : "function" == typeof l ? l = [l, y] : l.push(y)));
+    }
+    if (0 === a || 1 === a) {
+      if (void 0 === l) l = function l(e, t) {
+        return t;
+      };else if ("function" != typeof l) {
+        var m = l;
+        l = function l(e, t) {
+          for (var r = t, n = 0; n < m.length; n++) r = m[n].call(e, r);
+          return r;
+        };
+      } else {
+        var b = l;
+        l = function l(e, t) {
+          return b.call(e, t);
+        };
+      }
+      e.push(l);
+    }
+    0 !== a && (1 === a ? (c.get = f.get, c.set = f.set) : 2 === a ? c.value = f : 3 === a ? c.get = f : 4 === a && (c.set = f), o ? 1 === a ? (e.push(function (e, t) {
+      return f.get.call(e, t);
+    }), e.push(function (e, t) {
+      return f.set.call(e, t);
+    })) : 2 === a ? e.push(f) : e.push(function (e, t) {
+      return f.call(e, t);
+    }) : Object.defineProperty(t, n, c));
+  }
+  function applyMemberDecs(e, t) {
+    for (var r, n, a = [], i = new Map(), o = new Map(), s = 0; s < t.length; s++) {
+      var c = t[s];
+      if (Array.isArray(c)) {
+        var l,
+          u,
+          f = c[1],
+          p = c[2],
+          d = c.length > 3,
+          h = f >= 5;
+        if (h ? (l = e, 0 != (f -= 5) && (u = n = n || [])) : (l = e.prototype, 0 !== f && (u = r = r || [])), 0 !== f && !d) {
+          var v = h ? o : i,
+            g = v.get(p) || 0;
+          if (!0 === g || 3 === g && 4 !== f || 4 === g && 3 !== f) throw 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: " + p);
+          !g && f > 2 ? v.set(p, f) : v.set(p, !0);
+        }
+        applyMemberDec(a, l, c, p, f, h, d, u);
+      }
+    }
+    return pushInitializers(a, r), pushInitializers(a, n), a;
+  }
+  function pushInitializers(e, t) {
+    t && e.push(function (e) {
+      for (var r = 0; r < t.length; r++) t[r].call(e);
+      return e;
+    });
+  }
+  return function (e, t, r) {
+    return {
+      e: applyMemberDecs(e, t),
+      get c() {
+        return function (e, t) {
+          if (t.length > 0) {
+            for (var r = [], n = e, a = e.name, i = t.length - 1; i >= 0; i--) {
+              var o = {
+                v: !1
+              };
+              try {
+                var s = t[i](n, {
+                  kind: "class",
+                  name: a,
+                  addInitializer: createAddInitializerMethod(r, o)
+                });
+              } finally {
+                o.v = !0;
+              }
+              void 0 !== s && (assertValidReturnValue(10, s), n = s);
+            }
+            return [n, function () {
+              for (var e = 0; e < r.length; e++) r[e].call(n);
+            }];
+          }
+        }(e, r);
+      }
+    };
+  };
+}
+function applyDecs2203R(e, t, r) {
+  return (module.exports = applyDecs2203R = applyDecs2203RFactory(), module.exports.__esModule = true, module.exports["default"] = module.exports)(e, t, r);
+}
+module.exports = applyDecs2203R, module.exports.__esModule = true, module.exports["default"] = module.exports;

frontend/node_modules/@babel/runtime/helpers/applyDecs2301.js

@@ -0,0 +1,222 @@
+var _typeof = require("./typeof.js")["default"];
+var checkInRHS = require("./checkInRHS.js");
+var setFunctionName = require("./setFunctionName.js");
+var toPropertyKey = require("./toPropertyKey.js");
+function applyDecs2301Factory() {
+  function createAddInitializerMethod(e, t) {
+    return function (r) {
+      !function (e) {
+        if (e.v) throw Error("attempted to call addInitializer after decoration was finished");
+      }(t), assertCallable(r, "An initializer"), e.push(r);
+    };
+  }
+  function assertInstanceIfPrivate(e, t) {
+    if (!e(t)) throw new TypeError("Attempted to access private element on non-instance");
+  }
+  function memberDec(e, t, r, n, a, i, s, o, c) {
+    var u;
+    switch (a) {
+      case 1:
+        u = "accessor";
+        break;
+      case 2:
+        u = "method";
+        break;
+      case 3:
+        u = "getter";
+        break;
+      case 4:
+        u = "setter";
+        break;
+      default:
+        u = "field";
+    }
+    var l,
+      f,
+      p = {
+        kind: u,
+        name: s ? "#" + t : toPropertyKey(t),
+        "static": i,
+        "private": s
+      },
+      d = {
+        v: !1
+      };
+    if (0 !== a && (p.addInitializer = createAddInitializerMethod(n, d)), s || 0 !== a && 2 !== a) {
+      if (2 === a) l = function l(e) {
+        return assertInstanceIfPrivate(c, e), r.value;
+      };else {
+        var h = 0 === a || 1 === a;
+        (h || 3 === a) && (l = s ? function (e) {
+          return assertInstanceIfPrivate(c, e), r.get.call(e);
+        } : function (e) {
+          return r.get.call(e);
+        }), (h || 4 === a) && (f = s ? function (e, t) {
+          assertInstanceIfPrivate(c, e), r.set.call(e, t);
+        } : function (e, t) {
+          r.set.call(e, t);
+        });
+      }
+    } else l = function l(e) {
+      return e[t];
+    }, 0 === a && (f = function f(e, r) {
+      e[t] = r;
+    });
+    var v = s ? c.bind() : function (e) {
+      return t in e;
+    };
+    p.access = l && f ? {
+      get: l,
+      set: f,
+      has: v
+    } : l ? {
+      get: l,
+      has: v
+    } : {
+      set: f,
+      has: v
+    };
+    try {
+      return e(o, p);
+    } finally {
+      d.v = !0;
+    }
+  }
+  function assertCallable(e, t) {
+    if ("function" != typeof e) throw new TypeError(t + " must be a function");
+  }
+  function assertValidReturnValue(e, t) {
+    var r = _typeof(t);
+    if (1 === e) {
+      if ("object" !== r || null === t) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+      void 0 !== t.get && assertCallable(t.get, "accessor.get"), void 0 !== t.set && assertCallable(t.set, "accessor.set"), void 0 !== t.init && assertCallable(t.init, "accessor.init");
+    } else if ("function" !== r) throw new TypeError((0 === e ? "field" : 10 === e ? "class" : "method") + " decorators must return a function or void 0");
+  }
+  function curryThis2(e) {
+    return function (t) {
+      e(this, t);
+    };
+  }
+  function applyMemberDec(e, t, r, n, a, i, s, o, c) {
+    var u,
+      l,
+      f,
+      p,
+      d,
+      h,
+      v,
+      y,
+      g = r[0];
+    if (s ? (0 === a || 1 === a ? (u = {
+      get: (d = r[3], function () {
+        return d(this);
+      }),
+      set: curryThis2(r[4])
+    }, f = "get") : 3 === a ? (u = {
+      get: r[3]
+    }, f = "get") : 4 === a ? (u = {
+      set: r[3]
+    }, f = "set") : u = {
+      value: r[3]
+    }, 0 !== a && (1 === a && setFunctionName(u.set, "#" + n, "set"), setFunctionName(u[f || "value"], "#" + n, f))) : 0 !== a && (u = Object.getOwnPropertyDescriptor(t, n)), 1 === a ? p = {
+      get: u.get,
+      set: u.set
+    } : 2 === a ? p = u.value : 3 === a ? p = u.get : 4 === a && (p = u.set), "function" == typeof g) void 0 !== (h = memberDec(g, n, u, o, a, i, s, p, c)) && (assertValidReturnValue(a, h), 0 === a ? l = h : 1 === a ? (l = h.init, v = h.get || p.get, y = h.set || p.set, p = {
+      get: v,
+      set: y
+    }) : p = h);else for (var m = g.length - 1; m >= 0; m--) {
+      var b;
+      void 0 !== (h = memberDec(g[m], n, u, o, a, i, s, p, c)) && (assertValidReturnValue(a, h), 0 === a ? b = h : 1 === a ? (b = h.init, v = h.get || p.get, y = h.set || p.set, p = {
+        get: v,
+        set: y
+      }) : p = h, void 0 !== b && (void 0 === l ? l = b : "function" == typeof l ? l = [l, b] : l.push(b)));
+    }
+    if (0 === a || 1 === a) {
+      if (void 0 === l) l = function l(e, t) {
+        return t;
+      };else if ("function" != typeof l) {
+        var I = l;
+        l = function l(e, t) {
+          for (var r = t, n = 0; n < I.length; n++) r = I[n].call(e, r);
+          return r;
+        };
+      } else {
+        var w = l;
+        l = function l(e, t) {
+          return w.call(e, t);
+        };
+      }
+      e.push(l);
+    }
+    0 !== a && (1 === a ? (u.get = p.get, u.set = p.set) : 2 === a ? u.value = p : 3 === a ? u.get = p : 4 === a && (u.set = p), s ? 1 === a ? (e.push(function (e, t) {
+      return p.get.call(e, t);
+    }), e.push(function (e, t) {
+      return p.set.call(e, t);
+    })) : 2 === a ? e.push(p) : e.push(function (e, t) {
+      return p.call(e, t);
+    }) : Object.defineProperty(t, n, u));
+  }
+  function applyMemberDecs(e, t, r) {
+    for (var n, a, i, s = [], o = new Map(), c = new Map(), u = 0; u < t.length; u++) {
+      var l = t[u];
+      if (Array.isArray(l)) {
+        var f,
+          p,
+          d = l[1],
+          h = l[2],
+          v = l.length > 3,
+          y = d >= 5,
+          g = r;
+        if (y ? (f = e, 0 != (d -= 5) && (p = a = a || []), v && !i && (i = function i(t) {
+          return checkInRHS(t) === e;
+        }), g = i) : (f = e.prototype, 0 !== d && (p = n = n || [])), 0 !== d && !v) {
+          var m = y ? c : o,
+            b = m.get(h) || 0;
+          if (!0 === b || 3 === b && 4 !== d || 4 === b && 3 !== d) throw 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: " + h);
+          !b && d > 2 ? m.set(h, d) : m.set(h, !0);
+        }
+        applyMemberDec(s, f, l, h, d, y, v, p, g);
+      }
+    }
+    return pushInitializers(s, n), pushInitializers(s, a), s;
+  }
+  function pushInitializers(e, t) {
+    t && e.push(function (e) {
+      for (var r = 0; r < t.length; r++) t[r].call(e);
+      return e;
+    });
+  }
+  return function (e, t, r, n) {
+    return {
+      e: applyMemberDecs(e, t, n),
+      get c() {
+        return function (e, t) {
+          if (t.length > 0) {
+            for (var r = [], n = e, a = e.name, i = t.length - 1; i >= 0; i--) {
+              var s = {
+                v: !1
+              };
+              try {
+                var o = t[i](n, {
+                  kind: "class",
+                  name: a,
+                  addInitializer: createAddInitializerMethod(r, s)
+                });
+              } finally {
+                s.v = !0;
+              }
+              void 0 !== o && (assertValidReturnValue(10, o), n = o);
+            }
+            return [n, function () {
+              for (var e = 0; e < r.length; e++) r[e].call(n);
+            }];
+          }
+        }(e, r);
+      }
+    };
+  };
+}
+function applyDecs2301(e, t, r, n) {
+  return (module.exports = applyDecs2301 = applyDecs2301Factory(), module.exports.__esModule = true, module.exports["default"] = module.exports)(e, t, r, n);
+}
+module.exports = applyDecs2301, module.exports.__esModule = true, module.exports["default"] = module.exports;

frontend/node_modules/@babel/runtime/helpers/applyDecs2305.js

@@ -0,0 +1,133 @@
+var _typeof = require("./typeof.js")["default"];
+var checkInRHS = require("./checkInRHS.js");
+var setFunctionName = require("./setFunctionName.js");
+var toPropertyKey = require("./toPropertyKey.js");
+function applyDecs2305(e, t, r, n, o, a) {
+  function i(e, t, r) {
+    return function (n, o) {
+      return r && r(n), e[t].call(n, o);
+    };
+  }
+  function c(e, t) {
+    for (var r = 0; r < e.length; r++) e[r].call(t);
+    return t;
+  }
+  function s(e, t, r, n) {
+    if ("function" != typeof e && (n || void 0 !== e)) throw new TypeError(t + " must " + (r || "be") + " a function" + (n ? "" : " or undefined"));
+    return e;
+  }
+  function applyDec(e, t, r, n, o, a, c, u, l, f, p, d, h) {
+    function m(e) {
+      if (!h(e)) throw new TypeError("Attempted to access private element on non-instance");
+    }
+    var y,
+      v = t[0],
+      g = t[3],
+      b = !u;
+    if (!b) {
+      r || Array.isArray(v) || (v = [v]);
+      var w = {},
+        S = [],
+        A = 3 === o ? "get" : 4 === o || d ? "set" : "value";
+      f ? (p || d ? w = {
+        get: setFunctionName(function () {
+          return g(this);
+        }, n, "get"),
+        set: function set(e) {
+          t[4](this, e);
+        }
+      } : w[A] = g, p || setFunctionName(w[A], n, 2 === o ? "" : A)) : p || (w = Object.getOwnPropertyDescriptor(e, n));
+    }
+    for (var P = e, j = v.length - 1; j >= 0; j -= r ? 2 : 1) {
+      var D = v[j],
+        E = r ? v[j - 1] : void 0,
+        I = {},
+        O = {
+          kind: ["field", "accessor", "method", "getter", "setter", "class"][o],
+          name: n,
+          metadata: a,
+          addInitializer: function (e, t) {
+            if (e.v) throw Error("attempted to call addInitializer after decoration was finished");
+            s(t, "An initializer", "be", !0), c.push(t);
+          }.bind(null, I)
+        };
+      try {
+        if (b) (y = s(D.call(E, P, O), "class decorators", "return")) && (P = y);else {
+          var k, F;
+          O["static"] = l, O["private"] = f, f ? 2 === o ? k = function k(e) {
+            return m(e), w.value;
+          } : (o < 4 && (k = i(w, "get", m)), 3 !== o && (F = i(w, "set", m))) : (k = function k(e) {
+            return e[n];
+          }, (o < 2 || 4 === o) && (F = function F(e, t) {
+            e[n] = t;
+          }));
+          var N = O.access = {
+            has: f ? h.bind() : function (e) {
+              return n in e;
+            }
+          };
+          if (k && (N.get = k), F && (N.set = F), P = D.call(E, d ? {
+            get: w.get,
+            set: w.set
+          } : w[A], O), d) {
+            if ("object" == _typeof(P) && P) (y = s(P.get, "accessor.get")) && (w.get = y), (y = s(P.set, "accessor.set")) && (w.set = y), (y = s(P.init, "accessor.init")) && S.push(y);else if (void 0 !== P) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+          } else s(P, (p ? "field" : "method") + " decorators", "return") && (p ? S.push(P) : w[A] = P);
+        }
+      } finally {
+        I.v = !0;
+      }
+    }
+    return (p || d) && u.push(function (e, t) {
+      for (var r = S.length - 1; r >= 0; r--) t = S[r].call(e, t);
+      return t;
+    }), p || b || (f ? d ? u.push(i(w, "get"), i(w, "set")) : u.push(2 === o ? w[A] : i.call.bind(w[A])) : Object.defineProperty(e, n, w)), P;
+  }
+  function u(e, t) {
+    return Object.defineProperty(e, Symbol.metadata || Symbol["for"]("Symbol.metadata"), {
+      configurable: !0,
+      enumerable: !0,
+      value: t
+    });
+  }
+  if (arguments.length >= 6) var l = a[Symbol.metadata || Symbol["for"]("Symbol.metadata")];
+  var f = Object.create(null == l ? null : l),
+    p = function (e, t, r, n) {
+      var o,
+        a,
+        i = [],
+        s = function s(t) {
+          return checkInRHS(t) === e;
+        },
+        u = new Map();
+      function l(e) {
+        e && i.push(c.bind(null, e));
+      }
+      for (var f = 0; f < t.length; f++) {
+        var p = t[f];
+        if (Array.isArray(p)) {
+          var d = p[1],
+            h = p[2],
+            m = p.length > 3,
+            y = 16 & d,
+            v = !!(8 & d),
+            g = 0 == (d &= 7),
+            b = h + "/" + v;
+          if (!g && !m) {
+            var w = u.get(b);
+            if (!0 === w || 3 === w && 4 !== d || 4 === w && 3 !== d) throw 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: " + h);
+            u.set(b, !(d > 2) || d);
+          }
+          applyDec(v ? e : e.prototype, p, y, m ? "#" + h : toPropertyKey(h), d, n, v ? a = a || [] : o = o || [], i, v, m, g, 1 === d, v && m ? s : r);
+        }
+      }
+      return l(o), l(a), i;
+    }(e, t, o, f);
+  return r.length || u(e, f), {
+    e: p,
+    get c() {
+      var t = [];
+      return r.length && [u(applyDec(e, [r], n, e.name, 5, f, t), f), c.bind(null, t, e)];
+    }
+  };
+}
+module.exports = applyDecs2305, module.exports.__esModule = true, module.exports["default"] = module.exports;

frontend/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;