@danielx/civet 0.6.86 → 0.6.88

package/dist/browser.js

@@ -1712,7 +1712,11 @@ var Civet = (() => {
       }
       case "Identifier":
       case "BindingProperty": {
-        const children = [pattern.name, pattern.delim];
+        const children = [
+          // { name: value } = ... declares value, not name
+          pattern.value ?? pattern.name,
+          pattern.delim
+        ];
         if (isWhitespaceOrEmpty(pattern.children[0])) {
           children.unshift(pattern.children[0]);
         }
@@ -2320,6 +2324,111 @@ var Civet = (() => {
       }
     }
   }
+  function dynamizeFromClause(from) {
+    from = from.slice(1);
+    from = insertTrimmingSpace(from, "");
+    if (from.at(-1)?.type === "ImportAssertion") {
+      const assert2 = from.pop();
+      from.push(", {", assert2.keyword, ":", assert2.object, "}");
+    }
+    return ["(", ...from, ")"];
+  }
+  function dynamizeImportDeclaration(decl) {
+    const { imports } = decl;
+    let { star, binding, specifiers } = imports;
+    const justDefault = binding && !specifiers && !star;
+    const pattern = (() => {
+      {
+        if (binding) {
+          if (specifiers) {
+            return makeRef();
+          } else {
+            return binding;
+          }
+        } else {
+          return convertNamedImportsToObject(imports, true);
+        }
+      }
+    })();
+    const c = "const";
+    const initializer = [
+      " = ",
+      justDefault ? "(" : void 0,
+      { type: "Await", children: ["await"] },
+      " ",
+      decl.children[0],
+      // import
+      dynamizeFromClause(decl.from),
+      justDefault ? ").default" : void 0
+    ];
+    const bindings = [{
+      type: "Binding",
+      names: pattern.names,
+      pattern,
+      initializer,
+      children: [pattern, initializer]
+    }];
+    if (binding && specifiers) {
+      const pattern2 = binding;
+      const initializer2 = [
+        " = ",
+        pattern,
+        ".default"
+      ];
+      bindings.push({
+        type: "Binding",
+        names: binding.names,
+        pattern: pattern2,
+        initializer: initializer2,
+        children: [pattern2, initializer2]
+      });
+      const pattern3 = convertNamedImportsToObject(imports.children.at(-1), true);
+      const initializer3 = [
+        " = ",
+        pattern
+      ];
+      bindings.push({
+        type: "Binding",
+        names: specifiers.names,
+        pattern: pattern3,
+        initializer: initializer3,
+        children: [pattern3, initializer3]
+      });
+    }
+    return {
+      type: "Declaration",
+      names: imports.names,
+      bindings,
+      decl: c,
+      children: [
+        c,
+        " ",
+        bindings.flatMap((binding2, i) => i > 0 ? [", ", binding2] : [binding2])
+      ]
+    };
+  }
+  function dynamizeImportDeclarationExpression($0) {
+    const [imp, ws1, named, ws2, from] = $0;
+    const object = convertNamedImportsToObject(named);
+    const dot = ".";
+    return processCallMemberExpression({
+      type: "CallExpression",
+      children: [
+        { type: "Await", children: "await" },
+        " ",
+        imp,
+        insertTrimmingSpace(ws2, ""),
+        dynamizeFromClause(from),
+        {
+          type: "PropertyGlob",
+          dot,
+          object,
+          children: [ws1, dot, object],
+          reversed: true
+        }
+      ]
+    });
+  }
   var init_declaration = __esm({
     "source/parser/declaration.civet"() {
       "use strict";
@@ -2329,6 +2438,7 @@ var Civet = (() => {
       init_util();
       init_function();
       init_binding();
+      init_lib();
     }
   });
 
@@ -3145,10 +3255,13 @@ var Civet = (() => {
     adjustIndexAccess: () => adjustIndexAccess,
     attachPostfixStatementAsExpression: () => attachPostfixStatementAsExpression,
     blockWithPrefix: () => blockWithPrefix,
+    convertNamedImportsToObject: () => convertNamedImportsToObject,
     convertObjectToJSXAttributes: () => convertObjectToJSXAttributes,
     dedentBlockString: () => dedentBlockString,
     dedentBlockSubstitutions: () => dedentBlockSubstitutions,
     deepCopy: () => deepCopy,
+    dynamizeImportDeclaration: () => dynamizeImportDeclaration,
+    dynamizeImportDeclarationExpression: () => dynamizeImportDeclarationExpression,
     expressionizeTypeIf: () => expressionizeTypeIf,
     forRange: () => forRange,
     gatherBindingCode: () => gatherBindingCode,
@@ -3207,8 +3320,11 @@ var Civet = (() => {
     return post;
   }
   function adjustIndexAccess(dot) {
-    if (gatherRecursive(dot, (node) => node.token === "?").length) {
-      dot = [...dot, "["];
+    if (dot.optional) {
+      return {
+        ...dot,
+        children: [...dot.children, "["]
+      };
     } else {
       dot = replaceNodes(
         deepCopy(dot),
@@ -3417,9 +3533,13 @@ var Civet = (() => {
             throw new Error(`Glob pattern must have call or member expression value, found ${JSON.stringify(part.value)}`);
           }
           let suppressPrefix = false;
-          let value = part.value ?? part.name;
+          let name = part.name;
+          let value = part.value ?? name;
           const wValue = getTrimmingSpace(part.value);
           [value, suppressPrefix] = handleThisPrivateShorthands(value);
+          if (glob.reversed) {
+            [name, value] = [value, name];
+          }
           if (!suppressPrefix) {
             value = prefix.concat(insertTrimmingSpace(value, ""));
           }
@@ -3437,13 +3557,13 @@ var Civet = (() => {
           } else {
             parts.push({
               type: part.type === "Identifier" ? "Property" : part.type,
-              name: part.name,
+              name,
               value,
               delim: part.delim,
               names: part.names,
               children: [
                 isWhitespaceOrEmpty(part.children[0]) && part.children[0],
-                part.name,
+                name,
                 isWhitespaceOrEmpty(part.children[2]) && part.children[2],
                 part.children[3]?.token === ":" ? part.children[3] : ":",
                 value,
@@ -3588,6 +3708,35 @@ var Civet = (() => {
       block
     };
   }
+  function convertNamedImportsToObject(node, pattern) {
+    const properties = node.specifiers.map((specifier) => {
+      if (specifier.ts) {
+        return { type: "Error", message: "cannot use `type` in dynamic import" };
+      } else {
+        const { source, binding } = specifier;
+        const delim = specifier.children.at(-1);
+        return {
+          type: pattern ? "BindingProperty" : "Property",
+          name: source,
+          value: !(source === binding) ? binding : void 0,
+          delim,
+          children: source === binding ? [source, delim] : [source, ":", binding, delim]
+        };
+      }
+    });
+    return {
+      type: pattern ? "ObjectBindingPattern" : "ObjectExpression",
+      names: node.names,
+      properties,
+      children: [
+        node.children[0],
+        // {
+        properties,
+        node.children.at(-1)
+        // }
+      ]
+    };
+  }
   function convertObjectToJSXAttributes(obj) {
     const { properties } = obj;
     const parts = [];
@@ -3729,108 +3878,231 @@ var Civet = (() => {
       if (pre.length)
         exp.children.unshift(...pre);
       if (post.length)
-        return exp.children.push(...post);
-      return;
-    });
-    replaceNodesRecursive(statements, (n) => n.type === "AssignmentExpression" && n.names === null, (exp) => {
-      let { lhs: $1, exp: $2 } = exp, tail = [], i = 0, len = $1.length;
-      let block;
-      if (exp.parent.type === "BlockStatement" && !$1.at(-1)?.at(-1)?.special) {
-        block = makeBlockFragment();
-        let ref4;
-        if (ref4 = prependStatementExpressionBlock([null, null, $2], block)) {
-          const ref = ref4;
-          exp.children = exp.children.map(function(c) {
-            if (c === $2)
-              return ref;
-            else
+        exp.children.push(...post);
+      if (exp.type === "UpdateExpression") {
+        const { assigned } = exp;
+        const ref = makeRef();
+        const newMemberExp = unchainOptionalMemberExpression(assigned, ref, (children) => {
+          return exp.children.map((c) => {
+            if (c === assigned) {
+              return children;
+            } else {
               return c;
+            }
           });
-          $2 = ref;
-        } else {
-          block = void 0;
+        });
+        if (newMemberExp !== assigned) {
+          if (newMemberExp.usesRef) {
+            newMemberExp.hoistDec = {
+              type: "Declaration",
+              children: ["let ", ref],
+              names: []
+            };
+          }
+          return replaceNode(exp, newMemberExp);
         }
+        ;
+        return;
       }
-      if ($1.some((left) => left[left.length - 1].special)) {
-        if ($1.length !== 1)
-          throw new Error("Only one assignment with id= is allowed");
-        const [, lhs, , op] = $1[0];
-        const { call, omitLhs } = op;
-        const index2 = exp.children.indexOf($2);
-        if (index2 < 0)
-          throw new Error("Assertion error: exp not in AssignmentExpression");
-        exp.children.splice(
-          index2,
-          1,
-          exp.exp = $2 = [call, "(", lhs, ", ", $2, ")"]
-        );
-        if (omitLhs) {
-          return $2;
+      ;
+      return;
+    });
+    replaceNodesRecursive(
+      statements,
+      (n) => n.type === "AssignmentExpression" && n.names === null,
+      (exp) => {
+        let { lhs: $1, exp: $2 } = exp, tail = [], i = 0, len = $1.length;
+        let block;
+        if (exp.parent.type === "BlockStatement" && !$1.at(-1)?.at(-1)?.special) {
+          block = makeBlockFragment();
+          let ref4;
+          if (ref4 = prependStatementExpressionBlock([null, null, $2], block)) {
+            const ref = ref4;
+            exp.children = exp.children.map(function(c) {
+              if (c === $2)
+                return ref;
+              else
+                return c;
+            });
+            $2 = ref;
+          } else {
+            block = void 0;
+          }
         }
-      }
-      let wrapped = false;
-      while (i < len) {
-        const lastAssignment = $1[i++];
-        const [, lhs, , op] = lastAssignment;
-        if (op.token !== "=")
-          continue;
-        if (lhs.type === "ObjectExpression" || lhs.type === "ObjectBindingPattern") {
-          if (!wrapped) {
-            wrapped = true;
-            lhs.children.splice(0, 0, "(");
-            tail.push(")");
+        if ($1.some((left) => left[left.length - 1].special)) {
+          if ($1.length !== 1)
+            throw new Error("Only one assignment with id= is allowed");
+          const [, lhs, , op] = $1[0];
+          const { call, omitLhs } = op;
+          const index2 = exp.children.indexOf($2);
+          if (index2 < 0)
+            throw new Error("Assertion error: exp not in AssignmentExpression");
+          exp.children.splice(
+            index2,
+            1,
+            exp.exp = $2 = [call, "(", lhs, ", ", $2, ")"]
+          );
+          if (omitLhs) {
+            return $2;
           }
         }
-      }
-      i = len - 1;
-      while (i >= 0) {
-        const lastAssignment = $1[i];
-        if (lastAssignment[3].token === "=") {
-          const lhs = lastAssignment[1];
-          if (lhs.type === "MemberExpression") {
-            const members = lhs.children;
-            const lastMember = members[members.length - 1];
-            if (lastMember.type === "SliceExpression") {
-              const { start, end, children: c } = lastMember;
-              c[0].token = ".splice(";
-              c[1] = start;
-              c[2] = ", ";
-              if (end) {
-                c[3] = [end, " - ", start];
-              } else {
-                c[3] = ["1/0"];
-              }
-              c[4] = [", ...", $2];
-              c[5] = ")";
-              lastAssignment.pop();
-              if (isWhitespaceOrEmpty(lastAssignment[2]))
+        let wrapped = false;
+        while (i < len) {
+          const lastAssignment = $1[i++];
+          const [, lhs, , op] = lastAssignment;
+          if (op.token !== "=")
+            continue;
+          if (lhs.type === "ObjectExpression" || lhs.type === "ObjectBindingPattern") {
+            if (!wrapped) {
+              wrapped = true;
+              lhs.children.splice(0, 0, "(");
+              tail.push(")");
+            }
+          }
+        }
+        i = len - 1;
+        while (i >= 0) {
+          const lastAssignment = $1[i];
+          if (lastAssignment[3].token === "=") {
+            const lhs = lastAssignment[1];
+            if (lhs.type === "MemberExpression") {
+              const members = lhs.children;
+              const lastMember = members[members.length - 1];
+              if (lastMember.type === "SliceExpression") {
+                const { start, end, children: c } = lastMember;
+                c[0].token = ".splice(";
+                c[1] = start;
+                c[2] = ", ";
+                if (end) {
+                  c[3] = [end, " - ", start];
+                } else {
+                  c[3] = ["1/0"];
+                }
+                c[4] = [", ...", $2];
+                c[5] = ")";
                 lastAssignment.pop();
-              if ($1.length > 1) {
-                throw new Error("Not implemented yet! TODO: Handle multiple splice assignments");
+                if (isWhitespaceOrEmpty(lastAssignment[2]))
+                  lastAssignment.pop();
+                if ($1.length > 1) {
+                  throw new Error("Not implemented yet! TODO: Handle multiple splice assignments");
+                }
+                exp.children = [$1];
+                exp.names = [];
+                return exp;
               }
-              exp.children = [$1];
-              exp.names = [];
-              return exp;
+            } else if (lhs.type === "ObjectBindingPattern" || lhs.type === "ArrayBindingPattern") {
+              processBindingPatternLHS(lhs, tail);
             }
-          } else if (lhs.type === "ObjectBindingPattern" || lhs.type === "ArrayBindingPattern") {
-            processBindingPatternLHS(lhs, tail);
           }
+          i--;
         }
-        i--;
+        i = len - 1;
+        const optionalChainRef = makeRef();
+        while (i >= 0) {
+          const assignment = $1[i];
+          const [ws1, lhs, ws2, op] = assignment;
+          if (lhs.type === "MemberExpression" || lhs.type === "CallExpression") {
+            const newMemberExp = unchainOptionalMemberExpression(lhs, optionalChainRef, (children) => {
+              const assigns = $1.splice(i + 1, len - 1 - i);
+              $1.pop();
+              return [ws1, ...children, ws2, op, ...assigns, $2];
+            });
+            if (newMemberExp !== lhs) {
+              if (newMemberExp.usesRef) {
+                exp.hoistDec = {
+                  type: "Declaration",
+                  children: ["let ", optionalChainRef],
+                  names: []
+                };
+              }
+              replaceNode($2, newMemberExp);
+              newMemberExp.parent = exp;
+              $2 = newMemberExp;
+            }
+          }
+          i--;
+        }
+        exp.names = $1.flatMap(([, l]) => l.names || []);
+        const index = exp.children.indexOf($2);
+        if (index < 0)
+          throw new Error("Assertion error: exp not in AssignmentExpression");
+        exp.children.splice(index + 1, 0, ...tail);
+        if (block) {
+          block.parent = exp.parent;
+          block.expressions.push(["", exp]);
+          exp.parent = block;
+          return block;
+        }
+        return exp;
       }
-      exp.names = $1.flatMap(([, l]) => l.names || []);
-      const index = exp.children.indexOf($2);
-      if (index < 0)
-        throw new Error("Assertion error: exp not in AssignmentExpression");
-      exp.children.splice(index + 1, 0, ...tail);
-      if (block) {
-        block.parent = exp.parent;
-        block.expressions.push(["", exp]);
-        exp.parent = block;
-        return block;
+    );
+  }
+  function unchainOptionalMemberExpression(exp, ref, innerExp) {
+    let j = 0;
+    const { children } = exp;
+    let usesRef = false;
+    const conditions = [];
+    while (j < children.length) {
+      const child = children[j];
+      const type = child?.type;
+      let hasOptional = false;
+      switch (type) {
+        case "PropertyAccess": {
+          if (child.dot?.optional) {
+            hasOptional = true;
+            child.dot.children.shift();
+            child.dot.optional = false;
+          }
+          ;
+          break;
+        }
+        case "Call":
+        case "Index": {
+          if (child.optional) {
+            hasOptional = true;
+            child.children.shift();
+            child.optional = void 0;
+          }
+          ;
+          break;
+        }
       }
+      if (hasOptional) {
+        let base;
+        if (j > 1 || needsRef(children[0])) {
+          usesRef = true;
+          base = makeLeftHandSideExpression({
+            type: "AssignmentExpression",
+            children: [ref, " = ", children.splice(0, j)]
+          });
+          base.parent = child;
+          children.unshift(ref);
+          j = 0;
+        } else {
+          base = children[0];
+        }
+        conditions.push([base, " != null"]);
+      }
+      j++;
+    }
+    let ref5;
+    if (ref5 = conditions.length) {
+      const l = ref5;
+      const cs = conditions.map((c, i) => {
+        if (i === l - 1) {
+          return c;
+        } else {
+          return [c, " && "];
+        }
+      });
+      return {
+        ...exp,
+        children: [...cs, " ? ", innerExp(children), " : void 0"],
+        usesRef
+      };
+    } else {
       return exp;
-    });
+    }
   }
   function attachPostfixStatementAsExpression(exp, post) {
     const postfixStatement = post[1];
@@ -3896,11 +4168,11 @@ var Civet = (() => {
       if (!(exp.children[0] === exp.statement)) {
         ws = exp.children[0];
       }
-      let ref5;
+      let ref6;
       switch (statement.type) {
         case "IfStatement": {
-          if (ref5 = expressionizeIfStatement(statement)) {
-            const expression = ref5;
+          if (ref6 = expressionizeIfStatement(statement)) {
+            const expression = ref6;
             exp.statement = expression;
             exp.children = [exp.statement];
           } else {
@@ -4205,9 +4477,9 @@ var Civet = (() => {
     }
   });
 
-  // ../Hera/dist/machine.js
+  // node_modules/@danielx/hera/dist/machine.js
   var require_machine = __commonJS({
-    "../Hera/dist/machine.js"(exports, module) {
+    "node_modules/@danielx/hera/dist/machine.js"(exports, module) {
       "use strict";
       var __defProp2 = Object.defineProperty;
       var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -4678,6 +4950,8 @@ ${input.slice(result.pos)}
         $TV,
         $Y,
         Parser,
+        ParserContext,
+        ParserOptions,
         Validator
       } = require_machine();
       var grammar = {
@@ -5182,6 +5456,7 @@ ${input.slice(result.pos)}
         OpenBracket,
         OpenParen,
         Operator,
+        Override,
         Own,
         Public,
         Private,
@@ -5579,59 +5854,60 @@ ${input.slice(result.pos)}
       var $L170 = $L("of");
       var $L171 = $L("[");
       var $L172 = $L("operator");
-      var $L173 = $L("own");
-      var $L174 = $L("public");
-      var $L175 = $L("private");
-      var $L176 = $L("protected");
-      var $L177 = $L("||>");
-      var $L178 = $L("|\u25B7");
-      var $L179 = $L("|>=");
-      var $L180 = $L("\u25B7=");
-      var $L181 = $L("|>");
-      var $L182 = $L("\u25B7");
-      var $L183 = $L("readonly");
-      var $L184 = $L("return");
-      var $L185 = $L("satisfies");
-      var $L186 = $L("'");
-      var $L187 = $L("static");
-      var $L188 = $L("${");
-      var $L189 = $L("super");
-      var $L190 = $L("switch");
-      var $L191 = $L("target");
-      var $L192 = $L("then");
-      var $L193 = $L("this");
-      var $L194 = $L("throw");
-      var $L195 = $L('"""');
-      var $L196 = $L("'''");
-      var $L197 = $L("///");
-      var $L198 = $L("```");
-      var $L199 = $L("try");
-      var $L200 = $L("typeof");
-      var $L201 = $L("unless");
-      var $L202 = $L("until");
-      var $L203 = $L("using");
-      var $L204 = $L("var");
-      var $L205 = $L("void");
-      var $L206 = $L("when");
-      var $L207 = $L("while");
-      var $L208 = $L("yield");
-      var $L209 = $L("/>");
-      var $L210 = $L("</");
-      var $L211 = $L("<>");
-      var $L212 = $L("</>");
-      var $L213 = $L("<!--");
-      var $L214 = $L("-->");
-      var $L215 = $L("type");
-      var $L216 = $L("enum");
-      var $L217 = $L("interface");
-      var $L218 = $L("global");
-      var $L219 = $L("module");
-      var $L220 = $L("namespace");
-      var $L221 = $L("asserts");
-      var $L222 = $L("keyof");
-      var $L223 = $L("???");
-      var $L224 = $L("[]");
-      var $L225 = $L("civet");
+      var $L173 = $L("override");
+      var $L174 = $L("own");
+      var $L175 = $L("public");
+      var $L176 = $L("private");
+      var $L177 = $L("protected");
+      var $L178 = $L("||>");
+      var $L179 = $L("|\u25B7");
+      var $L180 = $L("|>=");
+      var $L181 = $L("\u25B7=");
+      var $L182 = $L("|>");
+      var $L183 = $L("\u25B7");
+      var $L184 = $L("readonly");
+      var $L185 = $L("return");
+      var $L186 = $L("satisfies");
+      var $L187 = $L("'");
+      var $L188 = $L("static");
+      var $L189 = $L("${");
+      var $L190 = $L("super");
+      var $L191 = $L("switch");
+      var $L192 = $L("target");
+      var $L193 = $L("then");
+      var $L194 = $L("this");
+      var $L195 = $L("throw");
+      var $L196 = $L('"""');
+      var $L197 = $L("'''");
+      var $L198 = $L("///");
+      var $L199 = $L("```");
+      var $L200 = $L("try");
+      var $L201 = $L("typeof");
+      var $L202 = $L("unless");
+      var $L203 = $L("until");
+      var $L204 = $L("using");
+      var $L205 = $L("var");
+      var $L206 = $L("void");
+      var $L207 = $L("when");
+      var $L208 = $L("while");
+      var $L209 = $L("yield");
+      var $L210 = $L("/>");
+      var $L211 = $L("</");
+      var $L212 = $L("<>");
+      var $L213 = $L("</>");
+      var $L214 = $L("<!--");
+      var $L215 = $L("-->");
+      var $L216 = $L("type");
+      var $L217 = $L("enum");
+      var $L218 = $L("interface");
+      var $L219 = $L("global");
+      var $L220 = $L("module");
+      var $L221 = $L("namespace");
+      var $L222 = $L("asserts");
+      var $L223 = $L("keyof");
+      var $L224 = $L("???");
+      var $L225 = $L("[]");
+      var $L226 = $L("civet");
       var $R0 = $R(new RegExp("(?=async|debugger|if|unless|do|for|loop|until|while|switch|throw|try)", "suy"));
       var $R1 = $R(new RegExp("(as|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
       var $R2 = $R(new RegExp("[0-9]", "suy"));
@@ -6716,9 +6992,9 @@ ${input.slice(result.pos)}
       function NestedClassElement(ctx, state) {
         return $EVENT(ctx, state, "NestedClassElement", NestedClassElement$0);
       }
-      var ClassElement$0 = $TS($S($E(Decorators), $E(AccessModifier), $E($S(Static, $E(_))), ClassElementDefinition), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var ClassElement$0 = $TS($S($E(Decorators), $E(AccessModifier), $E($S(Static, $E(_))), $E($S(Override, $E(_))), ClassElementDefinition), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         var decorators = $1;
-        var definition = $4;
+        var definition = $5;
         if (definition.type === "MultiMethodDefinition") {
           return {
             ...definition,
@@ -6732,7 +7008,7 @@ ${input.slice(result.pos)}
         }
         return {
           ...definition,
-          children: [decorators, $2, $3, ...definition.children]
+          children: [decorators, $2, $3, $4, ...definition.children]
         };
       });
       var ClassElement$1 = $TS($S(Static, BracedBlock), function($skip, $loc, $0, $1, $2) {
@@ -6774,7 +7050,7 @@ ${input.slice(result.pos)}
       function NestedClassSignatureElement(ctx, state) {
         return $EVENT(ctx, state, "NestedClassSignatureElement", NestedClassSignatureElement$0);
       }
-      var ClassSignatureElement$0 = $S($E(Decorators), $E(AccessModifier), $E($S(Static, $E(_))), $C(MethodSignature, FieldDefinition));
+      var ClassSignatureElement$0 = $S($E(Decorators), $E(AccessModifier), $E($S(Static, $E(_))), $E($S(Override, $E(_))), $C(MethodSignature, FieldDefinition));
       var ClassSignatureElement$1 = $S(Static, ClassSignatureBody);
       var ClassSignatureElement$$ = [ClassSignatureElement$0, ClassSignatureElement$1];
       function ClassSignatureElement(ctx, state) {
@@ -6936,14 +7212,17 @@ ${input.slice(result.pos)}
           children: [$1, ...$2, ...rest.flat()]
         });
       });
-      var CallExpression$1 = $TS($S($EXPECT($L20, 'CallExpression "import"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
+      var CallExpression$1 = $TS($S(Import, _, NamedImports, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+        return dynamizeImportDeclarationExpression($0);
+      });
+      var CallExpression$2 = $TS($S($EXPECT($L20, 'CallExpression "import"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
         var rest = $3;
         return processCallMemberExpression({
           type: "CallExpression",
           children: [$1, ...$2, ...rest.flat()]
         });
       });
-      var CallExpression$2 = $TS($S(MemberExpression, AllowedTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
+      var CallExpression$3 = $TS($S(MemberExpression, AllowedTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
         var member = $1;
         var trailing = $2;
         var rest = $3;
@@ -6956,7 +7235,7 @@ ${input.slice(result.pos)}
         }
         return member;
       });
-      var CallExpression$$ = [CallExpression$0, CallExpression$1, CallExpression$2];
+      var CallExpression$$ = [CallExpression$0, CallExpression$1, CallExpression$2, CallExpression$3];
       function CallExpression(ctx, state) {
         return $EVENT_C(ctx, state, "CallExpression", CallExpression$$);
       }
@@ -6972,18 +7251,28 @@ ${input.slice(result.pos)}
         return literal;
       });
       var CallExpressionRest$3 = $TS($S($E(OptionalShorthand), ArgumentsWithTrailingMemberExpressions), function($skip, $loc, $0, $1, $2) {
-        if (!$1)
-          return $2;
-        return [$1, ...$2];
+        var optional = $1;
+        var argsWithTrailing = $2;
+        if (!optional)
+          return argsWithTrailing;
+        const call = argsWithTrailing[0];
+        return [{
+          ...call,
+          children: [optional, ...call.children],
+          optional
+        }, ...argsWithTrailing.slice(1)];
       });
       var CallExpressionRest$$ = [CallExpressionRest$0, CallExpressionRest$1, CallExpressionRest$2, CallExpressionRest$3];
       function CallExpressionRest(ctx, state) {
         return $EVENT_C(ctx, state, "CallExpressionRest", CallExpressionRest$$);
       }
       var OptionalShorthand$0 = $TS($S($EXPECT($R6, "OptionalShorthand /(?=[\\/?])/"), $Q(InlineComment), QuestionMark, OptionalDot), function($skip, $loc, $0, $1, $2, $3, $4) {
+        var comments = $2;
+        var q = $3;
+        var d = $4;
         return {
           type: "Optional",
-          children: $0
+          children: [...comments, q, d]
         };
       });
       function OptionalShorthand(ctx, state) {
@@ -7054,7 +7343,11 @@ ${input.slice(result.pos)}
           if (dot.type === "Optional" && content.type === "SliceExpression") {
             return [...dot.children.slice(0, -1), ...comments, content];
           }
-          return [dot, ...comments, content];
+          return {
+            ...content,
+            children: [dot, ...comments, ...content.children],
+            optional: dot
+          };
         }
         return [...comments, content];
       });
@@ -7158,9 +7451,14 @@ ${input.slice(result.pos)}
         return $EVENT_C(ctx, state, "SliceParameters", SliceParameters$$);
       }
       var AccessStart$0 = $TS($S($E(PropertyAccessModifier), Dot, $N(Dot)), function($skip, $loc, $0, $1, $2, $3) {
-        if ($1)
-          return [$1, $2];
-        return $2;
+        var modifier = $1;
+        var dot = $2;
+        let children = modifier ? [modifier, dot] : [dot];
+        return {
+          type: "AccessStart",
+          children,
+          optional: modifier?.token === "?"
+        };
       });
       function AccessStart(ctx, state) {
         return $EVENT(ctx, state, "AccessStart", AccessStart$0);
@@ -7203,13 +7501,14 @@ ${input.slice(result.pos)}
         };
       });
       var PropertyAccess$2 = $TS($S(AccessStart, $Q(InlineComment), $C(IdentifierName, PrivateIdentifier, LengthShorthand)), function($skip, $loc, $0, $1, $2, $3) {
-        var access = $1;
+        var dot = $1;
         var comments = $2;
         var id = $3;
-        const children = [access, ...comments, ...id.children];
+        const children = [dot, ...comments, ...id.children];
         return {
           type: "PropertyAccess",
           name: id.name,
+          dot,
           children
         };
       });
@@ -7217,16 +7516,20 @@ ${input.slice(result.pos)}
         var p = $2;
         var id = $3;
         if (id) {
+          const dot = { token: ".prototype.", $loc: p.$loc };
           return {
             type: "PropertyAccess",
             name: id.name,
-            children: [{ token: ".prototype.", $loc: p.$loc }, id]
+            dot,
+            children: [dot, id]
           };
         } else {
+          const dot = { token: ".prototype", $loc: p.$loc };
           return {
             type: "PropertyAccess",
             name: "prototype",
-            children: [{ token: ".prototype", $loc: p.$loc }]
+            dot,
+            children: [dot]
           };
         }
       });
@@ -11196,28 +11499,31 @@ ${input.slice(result.pos)}
         };
       });
       var ImportDeclaration$1 = $T($S(Import, __, TypeKeyword, __, ImportClause, __, FromClause), function(value) {
-        return { "type": "ImportDeclaration", "ts": true, "children": value };
+        var imports = value[4];
+        var from = value[6];
+        return { "type": "ImportDeclaration", "ts": true, "children": value, "imports": imports, "from": from };
       });
       var ImportDeclaration$2 = $T($S(Import, __, ImportClause, __, FromClause), function(value) {
-        return { "type": "ImportDeclaration", "children": value };
+        var imports = value[2];
+        var from = value[4];
+        return { "type": "ImportDeclaration", "children": value, "imports": imports, "from": from };
       });
       var ImportDeclaration$3 = $T($S(Import, __, ModuleSpecifier), function(value) {
-        return { "type": "ImportDeclaration", "children": value };
+        var module3 = value[2];
+        return { "type": "ImportDeclaration", "children": value, "module": module3 };
       });
       var ImportDeclaration$4 = $TS($S(ImpliedImport, $E($S(TypeKeyword, __)), ImportClause, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         var i = $1;
         var t = $2;
-        var c = $3;
+        var imports = $3;
         var w = $4;
-        var f = $5;
+        var from = $5;
         i.$loc = {
-          pos: f[0].$loc.pos - 1,
-          length: f[0].$loc.length + 1
+          pos: from[0].$loc.pos - 1,
+          length: from[0].$loc.length + 1
         };
-        const children = [i, t, c, w, f];
-        if (!t)
-          return children;
-        return { type: "ImportDeclaration", ts: true, children };
+        const children = [i, t, imports, w, from];
+        return { type: "ImportDeclaration", ts: !!t, children, imports, from };
       });
       var ImportDeclaration$$ = [ImportDeclaration$0, ImportDeclaration$1, ImportDeclaration$2, ImportDeclaration$3, ImportDeclaration$4];
       function ImportDeclaration(ctx, state) {
@@ -11235,14 +11541,17 @@ ${input.slice(result.pos)}
         if (rest) {
           return {
             type: "Declaration",
-            children: $0,
-            names: [...binding.names, ...rest[3].names]
+            children: [binding, ...rest],
+            names: [...binding.names, ...rest[3].names],
+            binding,
+            specifiers: rest[3].specifiers
           };
         }
         return {
           type: "Declaration",
-          children: $0,
-          names: binding.names
+          children: [binding],
+          names: binding.names,
+          binding
         };
       });
       var ImportClause$1 = NameSpaceImport;
@@ -11252,11 +11561,14 @@ ${input.slice(result.pos)}
         return $EVENT_C(ctx, state, "ImportClause", ImportClause$$);
       }
       var NameSpaceImport$0 = $TS($S(Star, ImportAsToken, __, ImportedBinding), function($skip, $loc, $0, $1, $2, $3, $4) {
+        var star = $1;
         var binding = $4;
         return {
           type: "Declaration",
           children: $0,
-          names: binding.names
+          names: binding.names,
+          binding,
+          star
         };
       });
       function NameSpaceImport(ctx, state) {
@@ -11268,17 +11580,32 @@ ${input.slice(result.pos)}
         return {
           type: "Declaration",
           children: $0,
-          names
+          names,
+          specifiers
         };
       });
       function NamedImports(ctx, state) {
         return $EVENT(ctx, state, "NamedImports", NamedImports$0);
       }
-      var FromClause$0 = $S(From, __, ModuleSpecifier);
+      var FromClause$0 = $TS($S(From, __, ModuleSpecifier), function($skip, $loc, $0, $1, $2, $3) {
+        var module3 = $3;
+        if (!Array.isArray(module3))
+          return $0;
+        return [$1, $2, ...module3];
+      });
       function FromClause(ctx, state) {
         return $EVENT(ctx, state, "FromClause", FromClause$0);
       }
-      var ImportAssertion$0 = $S($E(_), $C($EXPECT($L117, 'ImportAssertion "with"'), $EXPECT($L118, 'ImportAssertion "assert"')), NonIdContinue, $E(_), ObjectLiteral);
+      var ImportAssertion$0 = $TS($S($E(_), $C($EXPECT($L117, 'ImportAssertion "with"'), $EXPECT($L118, 'ImportAssertion "assert"')), NonIdContinue, $E(_), ObjectLiteral), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+        var keyword = $2;
+        var object = $5;
+        return {
+          type: "ImportAssertion",
+          keyword,
+          object,
+          children: $0
+        };
+      });
       function ImportAssertion(ctx, state) {
         return $EVENT(ctx, state, "ImportAssertion", ImportAssertion$0);
       }
@@ -11308,8 +11635,10 @@ ${input.slice(result.pos)}
         return $EVENT_C(ctx, state, "TypeAndImportSpecifier", TypeAndImportSpecifier$$);
       }
       var ImportSpecifier$0 = $TS($S(__, ModuleExportName, ImportAsToken, __, ImportedBinding, ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+        var source = $2;
         var binding = $5;
         return {
+          source,
           binding,
           children: $0
         };
@@ -11317,6 +11646,7 @@ ${input.slice(result.pos)}
       var ImportSpecifier$1 = $TS($S(__, ImportedBinding, ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3) {
         var binding = $2;
         return {
+          source: binding,
           binding,
           children: $0
         };
@@ -11508,9 +11838,18 @@ ${input.slice(result.pos)}
       function ImplicitExportSpecifier(ctx, state) {
         return $EVENT(ctx, state, "ImplicitExportSpecifier", ImplicitExportSpecifier$0);
       }
-      var Declaration$0 = HoistableDeclaration;
-      var Declaration$1 = ClassDeclaration;
-      var Declaration$2 = $TV(LexicalDeclaration, function($skip, $loc, $0, $1) {
+      var Declaration$0 = $TV(ImportDeclaration, function($skip, $loc, $0, $1) {
+        var decl = $0;
+        if (decl.ts || decl.module || !decl.imports || !decl.from)
+          return $skip;
+        const { imports } = decl;
+        if (!imports.binding && !imports.specifiers)
+          return $skip;
+        return dynamizeImportDeclaration(decl);
+      });
+      var Declaration$1 = HoistableDeclaration;
+      var Declaration$2 = ClassDeclaration;
+      var Declaration$3 = $TV(LexicalDeclaration, function($skip, $loc, $0, $1) {
         var d = $0;
         if (d.thisAssignments?.length)
           return {
@@ -11524,11 +11863,11 @@ ${input.slice(result.pos)}
           };
         return d;
       });
-      var Declaration$3 = TypeDeclaration;
-      var Declaration$4 = EnumDeclaration;
-      var Declaration$5 = OperatorDeclaration;
-      var Declaration$6 = UsingDeclaration;
-      var Declaration$$ = [Declaration$0, Declaration$1, Declaration$2, Declaration$3, Declaration$4, Declaration$5, Declaration$6];
+      var Declaration$4 = TypeDeclaration;
+      var Declaration$5 = EnumDeclaration;
+      var Declaration$6 = OperatorDeclaration;
+      var Declaration$7 = UsingDeclaration;
+      var Declaration$$ = [Declaration$0, Declaration$1, Declaration$2, Declaration$3, Declaration$4, Declaration$5, Declaration$6, Declaration$7];
       function Declaration(ctx, state) {
         return $EVENT_C(ctx, state, "Declaration", Declaration$$);
       }
@@ -12477,37 +12816,43 @@ ${input.slice(result.pos)}
       function Operator(ctx, state) {
         return $EVENT(ctx, state, "Operator", Operator$0);
       }
-      var Own$0 = $TS($S($EXPECT($L173, 'Own "own"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Override$0 = $TS($S($EXPECT($L173, 'Override "override"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+        return { $loc, token: $1, ts: true };
+      });
+      function Override(ctx, state) {
+        return $EVENT(ctx, state, "Override", Override$0);
+      }
+      var Own$0 = $TS($S($EXPECT($L174, 'Own "own"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Own(ctx, state) {
         return $EVENT(ctx, state, "Own", Own$0);
       }
-      var Public$0 = $TS($S($EXPECT($L174, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Public$0 = $TS($S($EXPECT($L175, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Public(ctx, state) {
         return $EVENT(ctx, state, "Public", Public$0);
       }
-      var Private$0 = $TS($S($EXPECT($L175, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Private$0 = $TS($S($EXPECT($L176, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Private(ctx, state) {
         return $EVENT(ctx, state, "Private", Private$0);
       }
-      var Protected$0 = $TS($S($EXPECT($L176, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Protected$0 = $TS($S($EXPECT($L177, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Protected(ctx, state) {
         return $EVENT(ctx, state, "Protected", Protected$0);
       }
-      var Pipe$0 = $TV($C($EXPECT($L177, 'Pipe "||>"'), $EXPECT($L178, 'Pipe "|\u25B7"')), function($skip, $loc, $0, $1) {
+      var Pipe$0 = $TV($C($EXPECT($L178, 'Pipe "||>"'), $EXPECT($L179, 'Pipe "|\u25B7"')), function($skip, $loc, $0, $1) {
         return { $loc, token: "||>" };
       });
-      var Pipe$1 = $TV($C($EXPECT($L179, 'Pipe "|>="'), $EXPECT($L180, 'Pipe "\u25B7="')), function($skip, $loc, $0, $1) {
+      var Pipe$1 = $TV($C($EXPECT($L180, 'Pipe "|>="'), $EXPECT($L181, 'Pipe "\u25B7="')), function($skip, $loc, $0, $1) {
         return { $loc, token: "|>=" };
       });
-      var Pipe$2 = $TV($C($EXPECT($L181, 'Pipe "|>"'), $EXPECT($L182, 'Pipe "\u25B7"')), function($skip, $loc, $0, $1) {
+      var Pipe$2 = $TV($C($EXPECT($L182, 'Pipe "|>"'), $EXPECT($L183, 'Pipe "\u25B7"')), function($skip, $loc, $0, $1) {
         return { $loc, token: "|>" };
       });
       var Pipe$$ = [Pipe$0, Pipe$1, Pipe$2];
@@ -12520,19 +12865,19 @@ ${input.slice(result.pos)}
       function QuestionMark(ctx, state) {
         return $EVENT(ctx, state, "QuestionMark", QuestionMark$0);
       }
-      var Readonly$0 = $TS($S($EXPECT($L183, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Readonly$0 = $TS($S($EXPECT($L184, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1, ts: true };
       });
       function Readonly(ctx, state) {
         return $EVENT(ctx, state, "Readonly", Readonly$0);
       }
-      var Return$0 = $TS($S($EXPECT($L184, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Return$0 = $TS($S($EXPECT($L185, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Return(ctx, state) {
         return $EVENT(ctx, state, "Return", Return$0);
       }
-      var Satisfies$0 = $TS($S($EXPECT($L185, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Satisfies$0 = $TS($S($EXPECT($L186, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Satisfies(ctx, state) {
@@ -12544,7 +12889,7 @@ ${input.slice(result.pos)}
       function Semicolon(ctx, state) {
         return $EVENT(ctx, state, "Semicolon", Semicolon$0);
       }
-      var SingleQuote$0 = $TV($EXPECT($L186, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
+      var SingleQuote$0 = $TV($EXPECT($L187, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function SingleQuote(ctx, state) {
@@ -12556,7 +12901,7 @@ ${input.slice(result.pos)}
       function Star(ctx, state) {
         return $EVENT(ctx, state, "Star", Star$0);
       }
-      var Static$0 = $TS($S($EXPECT($L187, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Static$0 = $TS($S($EXPECT($L188, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       var Static$1 = $TS($S($EXPECT($L129, 'Static "@"'), $N($C($EXPECT($L4, 'Static "("'), $EXPECT($L129, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
@@ -12566,127 +12911,127 @@ ${input.slice(result.pos)}
       function Static(ctx, state) {
         return $EVENT_C(ctx, state, "Static", Static$$);
       }
-      var SubstitutionStart$0 = $TV($EXPECT($L188, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
+      var SubstitutionStart$0 = $TV($EXPECT($L189, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function SubstitutionStart(ctx, state) {
         return $EVENT(ctx, state, "SubstitutionStart", SubstitutionStart$0);
       }
-      var Super$0 = $TS($S($EXPECT($L189, 'Super "super"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Super$0 = $TS($S($EXPECT($L190, 'Super "super"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Super(ctx, state) {
         return $EVENT(ctx, state, "Super", Super$0);
       }
-      var Switch$0 = $TS($S($EXPECT($L190, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Switch$0 = $TS($S($EXPECT($L191, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Switch(ctx, state) {
         return $EVENT(ctx, state, "Switch", Switch$0);
       }
-      var Target$0 = $TS($S($EXPECT($L191, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Target$0 = $TS($S($EXPECT($L192, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Target(ctx, state) {
         return $EVENT(ctx, state, "Target", Target$0);
       }
-      var Then$0 = $TS($S(__, $EXPECT($L192, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
+      var Then$0 = $TS($S(__, $EXPECT($L193, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
         return { $loc, token: "" };
       });
       function Then(ctx, state) {
         return $EVENT(ctx, state, "Then", Then$0);
       }
-      var This$0 = $TS($S($EXPECT($L193, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var This$0 = $TS($S($EXPECT($L194, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function This(ctx, state) {
         return $EVENT(ctx, state, "This", This$0);
       }
-      var Throw$0 = $TS($S($EXPECT($L194, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Throw$0 = $TS($S($EXPECT($L195, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Throw(ctx, state) {
         return $EVENT(ctx, state, "Throw", Throw$0);
       }
-      var TripleDoubleQuote$0 = $TV($EXPECT($L195, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
+      var TripleDoubleQuote$0 = $TV($EXPECT($L196, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
         return { $loc, token: "`" };
       });
       function TripleDoubleQuote(ctx, state) {
         return $EVENT(ctx, state, "TripleDoubleQuote", TripleDoubleQuote$0);
       }
-      var TripleSingleQuote$0 = $TV($EXPECT($L196, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
+      var TripleSingleQuote$0 = $TV($EXPECT($L197, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
         return { $loc, token: "`" };
       });
       function TripleSingleQuote(ctx, state) {
         return $EVENT(ctx, state, "TripleSingleQuote", TripleSingleQuote$0);
       }
-      var TripleSlash$0 = $TV($EXPECT($L197, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
+      var TripleSlash$0 = $TV($EXPECT($L198, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
         return { $loc, token: "/" };
       });
       function TripleSlash(ctx, state) {
         return $EVENT(ctx, state, "TripleSlash", TripleSlash$0);
       }
-      var TripleTick$0 = $TV($EXPECT($L198, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
+      var TripleTick$0 = $TV($EXPECT($L199, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
         return { $loc, token: "`" };
       });
       function TripleTick(ctx, state) {
         return $EVENT(ctx, state, "TripleTick", TripleTick$0);
       }
-      var Try$0 = $TS($S($EXPECT($L199, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Try$0 = $TS($S($EXPECT($L200, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Try(ctx, state) {
         return $EVENT(ctx, state, "Try", Try$0);
       }
-      var Typeof$0 = $TS($S($EXPECT($L200, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Typeof$0 = $TS($S($EXPECT($L201, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Typeof(ctx, state) {
         return $EVENT(ctx, state, "Typeof", Typeof$0);
       }
-      var Unless$0 = $TS($S($EXPECT($L201, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Unless$0 = $TS($S($EXPECT($L202, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1, negated: true };
       });
       function Unless(ctx, state) {
         return $EVENT(ctx, state, "Unless", Unless$0);
       }
-      var Until$0 = $TS($S($EXPECT($L202, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Until$0 = $TS($S($EXPECT($L203, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Until(ctx, state) {
         return $EVENT(ctx, state, "Until", Until$0);
       }
-      var Using$0 = $TS($S($EXPECT($L203, 'Using "using"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Using$0 = $TS($S($EXPECT($L204, 'Using "using"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Using(ctx, state) {
         return $EVENT(ctx, state, "Using", Using$0);
       }
-      var Var$0 = $TS($S($EXPECT($L204, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Var$0 = $TS($S($EXPECT($L205, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Var(ctx, state) {
         return $EVENT(ctx, state, "Var", Var$0);
       }
-      var Void$0 = $TS($S($EXPECT($L205, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Void$0 = $TS($S($EXPECT($L206, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Void(ctx, state) {
         return $EVENT(ctx, state, "Void", Void$0);
       }
-      var When$0 = $TS($S($EXPECT($L206, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var When$0 = $TS($S($EXPECT($L207, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: "case" };
       });
       function When(ctx, state) {
         return $EVENT(ctx, state, "When", When$0);
       }
-      var While$0 = $TS($S($EXPECT($L207, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var While$0 = $TS($S($EXPECT($L208, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function While(ctx, state) {
         return $EVENT(ctx, state, "While", While$0);
       }
-      var Yield$0 = $TS($S($EXPECT($L208, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Yield$0 = $TS($S($EXPECT($L209, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1, type: "Yield" };
       });
       function Yield(ctx, state) {
@@ -12765,7 +13110,7 @@ ${input.slice(result.pos)}
       function JSXElement(ctx, state) {
         return $EVENT_C(ctx, state, "JSXElement", JSXElement$$);
       }
-      var JSXSelfClosingElement$0 = $TS($S($EXPECT($L17, 'JSXSelfClosingElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L209, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+      var JSXSelfClosingElement$0 = $TS($S($EXPECT($L17, 'JSXSelfClosingElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L210, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
         return { type: "JSXElement", children: $0, tag: $2 };
       });
       function JSXSelfClosingElement(ctx, state) {
@@ -12799,7 +13144,7 @@ ${input.slice(result.pos)}
       function JSXOptionalClosingElement(ctx, state) {
         return $EVENT_C(ctx, state, "JSXOptionalClosingElement", JSXOptionalClosingElement$$);
       }
-      var JSXClosingElement$0 = $S($EXPECT($L210, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($L45, 'JSXClosingElement ">"'));
+      var JSXClosingElement$0 = $S($EXPECT($L211, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($L45, 'JSXClosingElement ">"'));
       function JSXClosingElement(ctx, state) {
         return $EVENT(ctx, state, "JSXClosingElement", JSXClosingElement$0);
       }
@@ -12820,7 +13165,7 @@ ${input.slice(result.pos)}
         ];
         return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
       });
-      var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L211, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L212, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         var children = $3;
         $0 = $0.slice(1);
         return {
@@ -12833,7 +13178,7 @@ ${input.slice(result.pos)}
       function JSXFragment(ctx, state) {
         return $EVENT_C(ctx, state, "JSXFragment", JSXFragment$$);
       }
-      var PushJSXOpeningFragment$0 = $TV($EXPECT($L211, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
+      var PushJSXOpeningFragment$0 = $TV($EXPECT($L212, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
         module.JSXTagStack.push("");
         return $1;
       });
@@ -12850,7 +13195,7 @@ ${input.slice(result.pos)}
       function JSXOptionalClosingFragment(ctx, state) {
         return $EVENT_C(ctx, state, "JSXOptionalClosingFragment", JSXOptionalClosingFragment$$);
       }
-      var JSXClosingFragment$0 = $EXPECT($L212, 'JSXClosingFragment "</>"');
+      var JSXClosingFragment$0 = $EXPECT($L213, 'JSXClosingFragment "</>"');
       function JSXClosingFragment(ctx, state) {
         return $EVENT(ctx, state, "JSXClosingFragment", JSXClosingFragment$0);
       }
@@ -13329,7 +13674,7 @@ ${input.slice(result.pos)}
       function JSXChild(ctx, state) {
         return $EVENT_C(ctx, state, "JSXChild", JSXChild$$);
       }
-      var JSXComment$0 = $TS($S($EXPECT($L213, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L214, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
+      var JSXComment$0 = $TS($S($EXPECT($L214, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L215, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
         return ["{/*", $2, "*/}"];
       });
       function JSXComment(ctx, state) {
@@ -13516,37 +13861,37 @@ ${input.slice(result.pos)}
       function InterfaceExtendsTarget(ctx, state) {
         return $EVENT(ctx, state, "InterfaceExtendsTarget", InterfaceExtendsTarget$0);
       }
-      var TypeKeyword$0 = $TS($S($EXPECT($L215, 'TypeKeyword "type"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var TypeKeyword$0 = $TS($S($EXPECT($L216, 'TypeKeyword "type"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function TypeKeyword(ctx, state) {
         return $EVENT(ctx, state, "TypeKeyword", TypeKeyword$0);
       }
-      var Enum$0 = $TS($S($EXPECT($L216, 'Enum "enum"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Enum$0 = $TS($S($EXPECT($L217, 'Enum "enum"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Enum(ctx, state) {
         return $EVENT(ctx, state, "Enum", Enum$0);
       }
-      var Interface$0 = $TS($S($EXPECT($L217, 'Interface "interface"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Interface$0 = $TS($S($EXPECT($L218, 'Interface "interface"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Interface(ctx, state) {
         return $EVENT(ctx, state, "Interface", Interface$0);
       }
-      var Global$0 = $TS($S($EXPECT($L218, 'Global "global"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Global$0 = $TS($S($EXPECT($L219, 'Global "global"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Global(ctx, state) {
         return $EVENT(ctx, state, "Global", Global$0);
       }
-      var Module$0 = $TS($S($EXPECT($L219, 'Module "module"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Module$0 = $TS($S($EXPECT($L220, 'Module "module"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Module(ctx, state) {
         return $EVENT(ctx, state, "Module", Module$0);
       }
-      var Namespace$0 = $TS($S($EXPECT($L220, 'Namespace "namespace"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Namespace$0 = $TS($S($EXPECT($L221, 'Namespace "namespace"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Namespace(ctx, state) {
@@ -13820,7 +14165,7 @@ ${input.slice(result.pos)}
       function ReturnTypeSuffix(ctx, state) {
         return $EVENT(ctx, state, "ReturnTypeSuffix", ReturnTypeSuffix$0);
       }
-      var ReturnType$0 = $TS($S($E($S(__, $EXPECT($L221, 'ReturnType "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2) {
+      var ReturnType$0 = $TS($S($E($S(__, $EXPECT($L222, 'ReturnType "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2) {
         var asserts = $1;
         var t = $2;
         if (asserts) {
@@ -13899,8 +14244,8 @@ ${input.slice(result.pos)}
       function TypeUnarySuffix(ctx, state) {
         return $EVENT_C(ctx, state, "TypeUnarySuffix", TypeUnarySuffix$$);
       }
-      var TypeUnaryOp$0 = $S($EXPECT($L222, 'TypeUnaryOp "keyof"'), NonIdContinue);
-      var TypeUnaryOp$1 = $S($EXPECT($L183, 'TypeUnaryOp "readonly"'), NonIdContinue);
+      var TypeUnaryOp$0 = $S($EXPECT($L223, 'TypeUnaryOp "keyof"'), NonIdContinue);
+      var TypeUnaryOp$1 = $S($EXPECT($L184, 'TypeUnaryOp "readonly"'), NonIdContinue);
       var TypeUnaryOp$$ = [TypeUnaryOp$0, TypeUnaryOp$1];
       function TypeUnaryOp(ctx, state) {
         return $EVENT_C(ctx, state, "TypeUnaryOp", TypeUnaryOp$$);
@@ -13930,7 +14275,7 @@ ${input.slice(result.pos)}
       function TypeIndexedAccess(ctx, state) {
         return $EVENT_C(ctx, state, "TypeIndexedAccess", TypeIndexedAccess$$);
       }
-      var UnknownAlias$0 = $TV($EXPECT($L223, 'UnknownAlias "???"'), function($skip, $loc, $0, $1) {
+      var UnknownAlias$0 = $TV($EXPECT($L224, 'UnknownAlias "???"'), function($skip, $loc, $0, $1) {
         return { $loc, token: "unknown" };
       });
       function UnknownAlias(ctx, state) {
@@ -14136,13 +14481,20 @@ ${input.slice(result.pos)}
       }
       var TypeLiteral$0 = TypeTemplateLiteral;
       var TypeLiteral$1 = Literal;
-      var TypeLiteral$2 = $TS($S($EXPECT($L205, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var TypeLiteral$2 = $TS($S($EXPECT($R17, "TypeLiteral /[+-]/"), NumericLiteral), function($skip, $loc, $0, $1, $2) {
+        var sign = $1;
+        var num = $2;
+        if (sign[0] === "+")
+          return num;
+        return $0;
+      });
+      var TypeLiteral$3 = $TS($S($EXPECT($L206, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { type: "VoidType", $loc, token: $1 };
       });
-      var TypeLiteral$3 = $TV($EXPECT($L224, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
+      var TypeLiteral$4 = $TV($EXPECT($L225, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
         return { $loc, token: "[]" };
       });
-      var TypeLiteral$$ = [TypeLiteral$0, TypeLiteral$1, TypeLiteral$2, TypeLiteral$3];
+      var TypeLiteral$$ = [TypeLiteral$0, TypeLiteral$1, TypeLiteral$2, TypeLiteral$3, TypeLiteral$4];
       function TypeLiteral(ctx, state) {
         return $EVENT_C(ctx, state, "TypeLiteral", TypeLiteral$$);
       }
@@ -14265,7 +14617,7 @@ ${input.slice(result.pos)}
       function CivetPrologue(ctx, state) {
         return $EVENT_C(ctx, state, "CivetPrologue", CivetPrologue$$);
       }
-      var CivetPrologueContent$0 = $TS($S($EXPECT($L225, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R86, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var CivetPrologueContent$0 = $TS($S($EXPECT($L226, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R86, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
         var options = $3;
         return {
           type: "CivetPrologue",
@@ -14851,9 +15203,9 @@ ${input.slice(result.pos)}
             }
           }
         });
-        if (typeof parse2 !== "undefined") {
-          Object.assign(module.config, parse2.config);
-          parse2.config = module.config;
+        if (typeof parse !== "undefined") {
+          Object.assign(module.config, parse.config);
+          parse.config = module.config;
         } else {
           Object.assign(module.config, exports.parse.config);
           exports.parse.config = module.config;
@@ -15004,7 +15356,7 @@ ${input.slice(result.pos)}
         };
       }();
       exports.default = parser;
-      var parse2 = exports.parse = parser.parse;
+      exports.parse = parser.parse;
       exports.Program = Program;
       exports.TopLevelStatements = TopLevelStatements;
       exports.NestedTopLevelStatements = NestedTopLevelStatements;
@@ -15506,6 +15858,7 @@ ${input.slice(result.pos)}
       exports.OpenBracket = OpenBracket;
       exports.OpenParen = OpenParen;
       exports.Operator = Operator;
+      exports.Override = Override;
       exports.Own = Own;
       exports.Public = Public;
       exports.Private = Private;