@danielx/civet 0.6.17 → 0.6.19

package/dist/browser.js

@@ -157,15 +157,8 @@ var Civet = (() => {
         }
       }
       function arrayElementHasTrailingComma(elementNode) {
-        const { children } = elementNode, { length } = children;
-        const lastChild = children[length - 1];
-        if (lastChild) {
-          const l2 = lastChild.length;
-          if (lastChild[l2 - 1]?.token === ",") {
-            return true;
-          }
-        }
-        return false;
+        const lastChild = elementNode.children.at(-1);
+        return lastChild && lastChild[lastChild.length - 1]?.token === ",";
       }
       var assert = {
         equal(a, b, msg) {
@@ -592,7 +585,15 @@ var Civet = (() => {
           case "EmptyStatement":
           case "ReturnStatement":
           case "ThrowStatement":
+            return;
           case "Declaration":
+            exp.children.push(["", [
+              ";",
+              ref,
+              ".push(",
+              patternAsValue(exp.bindings.at(-1).pattern),
+              ")"
+            ]]);
             return;
           case "ForStatement":
           case "IterationStatement":
@@ -845,6 +846,39 @@ var Civet = (() => {
         const indent = expressions[index][0];
         expressions.splice(index, 0, [indent, dec, ";"]);
       }
+      function patternAsValue(pattern) {
+        switch (pattern.type) {
+          case "ArrayBindingPattern": {
+            const children = [...pattern.children];
+            const index = children.indexOf(pattern.elements);
+            if (index < 0)
+              throw new Error("failed to find elements in ArrayBindingPattern");
+            children[index] = pattern.elements.map((el) => {
+              const [ws, e, delim] = el.children;
+              return { ...el, children: [ws, patternAsValue(e), delim] };
+            });
+            return { ...pattern, children };
+          }
+          case "ObjectBindingPattern": {
+            const children = [...pattern.children];
+            const index = children.indexOf(pattern.properties);
+            if (index < 0)
+              throw new Error("failed to find properties in ArrayBindingPattern");
+            children[index] = pattern.properties.map(patternAsValue);
+            return { ...pattern, children };
+          }
+          case "Identifier":
+          case "BindingProperty": {
+            const children = [pattern.name, pattern.delim];
+            if (isWhitespaceOrEmpty(pattern.children[0])) {
+              children.unshift(pattern.children[0]);
+            }
+            return { ...pattern, children };
+          }
+          default:
+            return pattern;
+        }
+      }
       function insertReturn(node) {
         if (!node)
           return;
@@ -886,7 +920,12 @@ var Civet = (() => {
           case "EmptyStatement":
           case "ReturnStatement":
           case "ThrowStatement":
+            return;
           case "Declaration":
+            exp.children.push(["", {
+              type: "ReturnStatement",
+              children: [";return ", patternAsValue(exp.bindings.at(-1).pattern)]
+            }]);
             return;
           case "ForStatement":
           case "IterationStatement":
@@ -1301,72 +1340,59 @@ var Civet = (() => {
           children: [s, parts, e]
         };
       }
-      function processConstAssignmentDeclaration(c, id, suffix, ws, ca, e) {
-        c = {
-          ...c,
+      function processAssignmentDeclaration(decl, id, suffix, ws, assign, e) {
+        decl = {
+          ...decl,
           $loc: {
-            pos: ca.$loc.pos - 1,
-            length: ca.$loc.length + 1
+            pos: assign.$loc.pos - 1,
+            length: assign.$loc.length + 1
           }
         };
-        let exp;
-        if (e.type === "FunctionExpression") {
-          exp = e;
-        } else {
-          exp = e[1];
-        }
-        if (exp?.children?.[0]?.token?.match(/^\s+$/))
-          exp.children.shift();
-        if (id.type === "Identifier" && exp?.type === "FunctionExpression" && !exp.id) {
-          const i = exp.children.findIndex((c2) => c2?.token === "function") + 1;
-          exp = {
-            ...exp,
-            children: [...exp.children.slice(0, i), " ", id, suffix, ws, ...exp.children.slice(i)]
-          };
-          return {
-            type: "Declaration",
-            children: [exp],
-            names: id.names
-          };
+        if (decl.token.startsWith("const")) {
+          let exp;
+          if (e.type === "FunctionExpression") {
+            exp = e;
+          } else {
+            exp = e[1];
+          }
+          if (exp?.children?.[0]?.token?.match(/^\s+$/))
+            exp.children.shift();
+          if (id.type === "Identifier" && exp?.type === "FunctionExpression" && !exp.id) {
+            const i = exp.children.findIndex((c) => c?.token === "function") + 1;
+            exp = {
+              ...exp,
+              children: [...exp.children.slice(0, i), " ", id, suffix, ws, ...exp.children.slice(i)]
+            };
+            return {
+              type: "Declaration",
+              decl,
+              children: [exp],
+              names: id.names
+            };
+          }
         }
         let [splices, thisAssignments] = gatherBindingCode(id);
         splices = splices.map((s) => [", ", s]);
         thisAssignments = thisAssignments.map((a) => ["", a, ";"]);
-        const binding = [c, id, suffix, ...ws];
-        const initializer = [ca, e];
-        const children = [binding, initializer];
-        return {
-          type: "Declaration",
-          names: id.names,
-          children,
-          binding,
+        const initializer = [ws, assign, e];
+        const binding = {
+          type: "Binding",
+          pattern: id,
           initializer,
           splices,
-          thisAssignments
-        };
-      }
-      function processLetAssignmentDeclaration(l, id, suffix, ws, la, e) {
-        l = {
-          ...l,
-          $loc: {
-            pos: la.$loc.pos - 1,
-            length: la.$loc.length + 1
-          }
+          suffix,
+          thisAssignments,
+          children: [id, suffix, initializer]
         };
-        let [splices, thisAssignments] = gatherBindingCode(id);
-        splices = splices.map((s) => [", ", s]);
-        thisAssignments = thisAssignments.map((a) => ["", a, ";"]);
-        const binding = [l, id, suffix, ...ws];
-        const initializer = [la, e];
-        const children = [binding, initializer];
+        const children = [decl, binding];
         return {
           type: "Declaration",
           names: id.names,
-          children,
-          binding,
-          initializer,
+          decl,
+          bindings: [binding],
           splices,
-          thisAssignments
+          thisAssignments,
+          children
         };
       }
       function implicitFunctionBlock(f) {
@@ -1577,9 +1603,9 @@ var Civet = (() => {
               const subRef = [ref, "[", i.toString(), "]"];
               getPatternConditions(e, subRef, conditions);
             });
-            const postRest = pattern.children.find((c) => c?.blockPrefix);
-            if (postRest) {
-              const postElements = postRest.blockPrefix.children[1], { length: postLength } = postElements;
+            const { blockPrefix } = pattern;
+            if (blockPrefix) {
+              const postElements = blockPrefix.children[1], { length: postLength } = postElements;
               postElements.forEach(({ children: [, e] }, i) => {
                 const subRef = [ref, "[", ref, ".length - ", (postLength + i).toString(), "]"];
                 getPatternConditions(e, subRef, conditions);
@@ -1666,15 +1692,15 @@ var Civet = (() => {
           if (el.type === "BindingRestElement") {
             return ["", el, void 0];
           }
-          const { children: [ws, e, sep] } = el;
+          const { children: [ws, e, delim] } = el;
           switch (e.type) {
             case "Literal":
             case "RegularExpressionLiteral":
             case "StringLiteral":
             case "PinPattern":
-              return sep;
+              return delim;
             default:
-              return [ws, nonMatcherBindings(e), sep];
+              return [ws, nonMatcherBindings(e), delim];
           }
         });
       }
@@ -1684,13 +1710,12 @@ var Civet = (() => {
             case "BindingProperty": {
               const { children, name, value } = p;
               const [ws] = children;
-              const sep = children[children.length - 1];
               switch (value && value.type) {
                 case "ArrayBindingPattern":
                 case "ObjectBindingPattern":
                   return {
                     ...p,
-                    children: [ws, name, ": ", nonMatcherBindings(value)]
+                    children: [ws, name, ": ", nonMatcherBindings(value), p.delim]
                   };
                 case "Identifier":
                   return p;
@@ -1700,7 +1725,7 @@ var Civet = (() => {
                 default:
                   return {
                     ...p,
-                    children: [ws, name, sep]
+                    children: [ws, name, p.delim]
                   };
               }
             }
@@ -2370,9 +2395,20 @@ var Civet = (() => {
           let rest = props[restIndex];
           props = props.slice(0, restIndex);
           if (after.length) {
-            const [restDelim] = rest.children.slice(-1), lastAfterProp = after[after.length - 1], lastAfterChildren = lastAfterProp.children, [lastDelim] = lastAfterChildren.slice(-1);
-            rest = { ...rest, children: [...rest.children.slice(0, -1), lastDelim] };
-            after = [...after.slice(0, -1), { ...lastAfterProp, children: [...lastAfterChildren.slice(0, -1), restDelim] }];
+            const { delim: restDelim } = rest, lastAfterProp = after[after.length - 1], { delim: lastDelim, children: lastAfterChildren } = lastAfterProp;
+            rest = {
+              ...rest,
+              delim: lastDelim,
+              children: [...rest.children.slice(0, -1), lastDelim]
+            };
+            after = [
+              ...after.slice(0, -1),
+              {
+                ...lastAfterProp,
+                delim: restDelim,
+                children: [...lastAfterChildren.slice(0, -1), restDelim]
+              }
+            ];
           }
           const children = [...props, ...after, rest];
           return {
@@ -2552,8 +2588,7 @@ var Civet = (() => {
         processBinaryOpExpression,
         processCallMemberExpression,
         processCoffeeInterpolation,
-        processConstAssignmentDeclaration,
-        processLetAssignmentDeclaration,
+        processAssignmentDeclaration,
         processParams,
         processProgram,
         processReturnValue,
@@ -3094,7 +3129,6 @@ ${input.slice(result.pos)}
         BindingProperty,
         BindingRestProperty,
         NestedBindingElements,
-        NestedBindingElement,
         BindingElement,
         BindingRestElement,
         EmptyBindingPattern,
@@ -3316,7 +3350,6 @@ ${input.slice(result.pos)}
         Initializer,
         VariableStatement,
         VariableDeclarationList,
-        VariableDeclaration,
         NumericLiteral,
         NumericLiteralKind,
         DecimalBigIntegerLiteral,
@@ -3884,23 +3917,24 @@ ${input.slice(result.pos)}
       var $R46 = $R(new RegExp("[^\\r\\n]", "suy"));
       var $R47 = $R(new RegExp("[ \\t]+", "suy"));
       var $R48 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
-      var $R49 = $R(new RegExp("\\s", "suy"));
-      var $R50 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
-      var $R51 = $R(new RegExp("[\\s>]|\\/>", "suy"));
-      var $R52 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
-      var $R53 = $R(new RegExp(`"[^"]*"|'[^']*'`, "suy"));
-      var $R54 = $R(new RegExp("[<>]", "suy"));
-      var $R55 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
-      var $R56 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
-      var $R57 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
-      var $R58 = $R(new RegExp("[+-]?", "suy"));
-      var $R59 = $R(new RegExp("[+-]", "suy"));
-      var $R60 = $R(new RegExp("#![^\\r\\n]*", "suy"));
-      var $R61 = $R(new RegExp("[\\t ]*", "suy"));
-      var $R62 = $R(new RegExp("[\\s]*", "suy"));
-      var $R63 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
-      var $R64 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
-      var $R65 = $R(new RegExp("[ \\t]*", "suy"));
+      var $R49 = $R(new RegExp("['\u2019]s", "suy"));
+      var $R50 = $R(new RegExp("\\s", "suy"));
+      var $R51 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
+      var $R52 = $R(new RegExp("[\\s>]|\\/>", "suy"));
+      var $R53 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
+      var $R54 = $R(new RegExp(`"[^"]*"|'[^']*'`, "suy"));
+      var $R55 = $R(new RegExp("[<>]", "suy"));
+      var $R56 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
+      var $R57 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
+      var $R58 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
+      var $R59 = $R(new RegExp("[+-]?", "suy"));
+      var $R60 = $R(new RegExp("[+-]", "suy"));
+      var $R61 = $R(new RegExp("#![^\\r\\n]*", "suy"));
+      var $R62 = $R(new RegExp("[\\t ]*", "suy"));
+      var $R63 = $R(new RegExp("[\\s]*", "suy"));
+      var $R64 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
+      var $R65 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
+      var $R66 = $R(new RegExp("[ \\t]*", "suy"));
       var Program$0 = $TS($S(Reset, Init, $E(EOS), TopLevelStatements, __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         var statements = $4;
         processProgram({
@@ -6648,6 +6682,8 @@ ${input.slice(result.pos)}
       var MemberBracketContent$1 = $TS($S(Dot, $C(TemplateLiteral, StringLiteral)), function($skip, $loc, $0, $1, $2) {
         var dot = $1;
         var str = $2;
+        if (Array.isArray(dot))
+          dot = dot[0];
         return {
           type: "Index",
           children: [
@@ -6660,6 +6696,8 @@ ${input.slice(result.pos)}
       var MemberBracketContent$2 = $TS($S(Dot, IntegerLiteral), function($skip, $loc, $0, $1, $2) {
         var dot = $1;
         var num = $2;
+        if (Array.isArray(dot))
+          dot = dot[0];
         return {
           type: "Index",
           children: [
@@ -7337,7 +7375,7 @@ ${input.slice(result.pos)}
         var c = $3;
         return {
           type: "ObjectBindingPattern",
-          children: $0,
+          children: [$1, $2, c.children, $4, $5],
           names: c.names,
           properties: c.children
         };
@@ -7398,6 +7436,7 @@ ${input.slice(result.pos)}
         return props.map(([prop, delim]) => {
           return {
             ...prop,
+            delim,
             children: [...prop.children, delim]
           };
         });
@@ -7427,11 +7466,10 @@ ${input.slice(result.pos)}
       var ArrayBindingPattern$0 = $TS($S($E(_), OpenBracket, ArrayBindingPatternContent, __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         var c = $3;
         return {
+          ...c,
           type: "ArrayBindingPattern",
-          children: $0,
-          names: c.names,
           elements: c.children,
-          length: c.length
+          children: [$1, $2, c.children, $4, $5]
         };
       });
       function ArrayBindingPattern(state) {
@@ -7517,14 +7555,14 @@ ${input.slice(result.pos)}
         }
       }
       var NestedBindingElementList$0 = $TS($S(Nested, BindingElementList), function($skip, $loc, $0, $1, $2) {
-        var ws = $1;
+        var indent = $1;
         var elements = $2;
         return elements.map((element, i) => {
           if (i > 0)
             return element;
           return {
             ...element,
-            children: [ws, ...element.children]
+            children: [indent, ...element.children.slice(1)]
           };
         });
       });
@@ -7639,13 +7677,13 @@ ${input.slice(result.pos)}
       var BindingProperty$1 = $TS($S($E(_), PropertyName, $E(_), Colon, $E(_), $C(BindingIdentifier, BindingPattern), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
         var name = $2;
         var value = $6;
-        var init = $7;
+        var initializer = $7;
         return {
           type: "BindingProperty",
           children: $0,
           name,
           value,
-          init,
+          initializer,
           names: value.names
         };
       });
@@ -7653,14 +7691,14 @@ ${input.slice(result.pos)}
         var ws = $1;
         var pin = $2;
         var binding = $3;
-        var init = $4;
+        var initializer = $4;
         if (binding.type === "AtBinding") {
           return {
             type: "AtBindingProperty",
             children: $0,
             binding,
             ref: binding.ref,
-            init,
+            initializer,
             names: []
           };
         }
@@ -7680,7 +7718,7 @@ ${input.slice(result.pos)}
           children: $0,
           name: binding,
           value: void 0,
-          init,
+          initializer,
           names: binding.names,
           identifier: binding
         };
@@ -7777,36 +7815,6 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var NestedBindingElement$0 = $TS($S(Nested, BindingElement), function($skip, $loc, $0, $1, $2) {
-        var indent = $1;
-        var element = $2;
-        return {
-          ...element,
-          children: [indent, ...element.children]
-        };
-      });
-      function NestedBindingElement(state) {
-        let eventData;
-        if (state.events) {
-          const result = state.events.enter?.("NestedBindingElement", state);
-          if (result) {
-            if (result.cache)
-              return result.cache;
-            eventData = result.data;
-          }
-        }
-        if (state.tokenize) {
-          const result = $TOKEN("NestedBindingElement", state, NestedBindingElement$0(state));
-          if (state.events)
-            state.events.exit?.("NestedBindingElement", state, result, eventData);
-          return result;
-        } else {
-          const result = NestedBindingElement$0(state);
-          if (state.events)
-            state.events.exit?.("NestedBindingElement", state, result, eventData);
-          return result;
-        }
-      }
       var BindingElement$0 = BindingRestElement;
       var BindingElement$1 = $TS($S($E(_), $C(BindingIdentifier, BindingPattern), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3) {
         var ws = $1;
@@ -7815,6 +7823,7 @@ ${input.slice(result.pos)}
         if (binding.children) {
           binding = {
             ...binding,
+            initializer,
             children: [...binding.children, initializer]
           };
         }
@@ -7860,7 +7869,7 @@ ${input.slice(result.pos)}
         var binding = $3;
         return {
           type: "BindingRestElement",
-          children: [...ws || [], dots, binding],
+          children: [ws, [dots, binding]],
           binding,
           name: binding.name,
           names: binding.names,
@@ -9905,10 +9914,24 @@ ${input.slice(result.pos)}
       var NestedPropertyDefinition$0 = $TS($S(Nested, $P($S(PropertyDefinition, ObjectPropertyDelimiter))), function($skip, $loc, $0, $1, $2) {
         var ws = $1;
         var inlineProps = $2;
-        return inlineProps.map(([prop, delimiter], i) => ({
-          ...prop,
-          children: [...i === 0 ? ws : [], ...prop.children, delimiter]
-        }));
+        return inlineProps.flatMap(([prop, delim], i) => {
+          if (!Array.isArray(prop))
+            prop = [prop];
+          if (i === 0) {
+            const [first, ...rest] = prop;
+            prop = [{ ...first, children: [...ws, ...first.children] }, ...rest];
+          }
+          const last = prop[prop.length - 1];
+          prop = [
+            ...prop.slice(0, prop.length - 1),
+            {
+              ...last,
+              delim,
+              children: [...last.children, delim]
+            }
+          ];
+          return prop;
+        });
       });
       function NestedPropertyDefinition(state) {
         let eventData;
@@ -10019,12 +10042,15 @@ ${input.slice(result.pos)}
         }
       }
       var PropertyDefinitionList$0 = $TV($P($S(PropertyDefinition, ObjectPropertyDelimiter)), function($skip, $loc, $0, $1) {
-        return $0.map(([prop, delim]) => {
-          return {
-            ...prop,
+        return $0.flatMap(([prop, delim]) => {
+          prop = Array.isArray(prop) ? prop : [prop];
+          let last = prop[prop.length - 1];
+          last = {
+            ...last,
             delim,
-            children: [...prop.children, delim]
+            children: [...last.children, delim]
           };
+          return [...prop.slice(0, prop.length - 1), last];
         });
       });
       function PropertyDefinitionList(state) {
@@ -10108,8 +10134,19 @@ ${input.slice(result.pos)}
       var PropertyDefinition$5 = $TS($S(__, CallExpression), function($skip, $loc, $0, $1, $2) {
         var ws = $1;
         var value = $2;
-        if (value.type === "Identifier") {
-          return { ...value, children: [ws, ...value.children] };
+        switch (value.type) {
+          case "Identifier":
+            return { ...value, children: [ws, ...value.children] };
+          case "ObjectExpression":
+            let first = value.properties[0];
+            if (first) {
+              first = {
+                ...first,
+                children: [ws, ...first.children],
+                hoistDec: value.hoistDec
+              };
+            }
+            return [first, ...value.properties.slice(1)];
         }
         const last = lastAccessInCallExpression(value);
         if (!last)
@@ -13443,17 +13480,19 @@ ${input.slice(result.pos)}
           type: "Ref",
           base: "ref"
         };
-        const { binding, initializer, splices, thisAssignments } = dec;
+        const { decl, bindings } = dec;
+        const binding = bindings[0];
+        const { pattern, suffix, initializer, splices, thisAssignments } = binding;
         const initCondition = {
           type: "AssignmentExpression",
-          children: [ref, " ", initializer],
+          children: [ref, initializer],
           hoistDec: {
             type: "Declaration",
-            children: ["let ", ref],
+            children: ["let ", ref, suffix],
             names: []
           },
           blockPrefix: [
-            ["", [binding, "= ", ref, ...splices], ";"],
+            ["", [decl, pattern, suffix, " = ", ref, ...splices], ";"],
             ...thisAssignments
           ]
         };
@@ -15152,26 +15191,23 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var LexicalDeclaration$0 = $TS($S(LetOrConst, LexicalBinding, $Q($S(__, Comma, LexicalBinding))), function($skip, $loc, $0, $1, $2, $3) {
-        var d = $1;
+      var LexicalDeclaration$0 = $TS($S(LetOrConst, LexicalBinding, $Q($S(__, Comma, __, LexicalBinding))), function($skip, $loc, $0, $1, $2, $3) {
+        var decl = $1;
         var binding = $2;
         var tail = $3;
-        const { splices, thisAssignments } = binding;
+        const bindings = [binding].concat(tail.map(([, , , b]) => b));
         return {
           type: "Declaration",
           children: $0,
-          names: [...binding.names].concat(tail.flatMap(([, , b]) => b.names)),
-          binding: {
-            ...binding.binding,
-            children: [d, ...binding.binding.children]
-          },
-          initializer: binding.initializer,
-          splices,
-          thisAssignments
+          names: bindings.flatMap((b) => b.names),
+          bindings,
+          decl,
+          splices: bindings.flatMap((b) => b.splices),
+          thisAssignments: bindings.flatMap((b) => b.thisAssignments)
         };
       });
       var LexicalDeclaration$1 = $TS($S(InsertConst, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
-        return processConstAssignmentDeclaration(...$0);
+        return processAssignmentDeclaration(...$0);
       });
       var LexicalDeclaration$2 = $TS($S(InsertLet, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, LetAssignment, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
         var l = $1;
@@ -15180,7 +15216,7 @@ ${input.slice(result.pos)}
         var ws = $4;
         var la = $5;
         var e = $6;
-        return processLetAssignmentDeclaration(...$0);
+        return processAssignmentDeclaration(...$0);
       });
       function LexicalDeclaration(state) {
         let eventData;
@@ -15254,48 +15290,32 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var LexicalBinding$0 = $TS($S(BindingPattern, $E(TypeSuffix), $E(_), Initializer), function($skip, $loc, $0, $1, $2, $3, $4) {
-        var binding = $1;
+      var LexicalBinding$0 = $TS($S(BindingPattern, $E(TypeSuffix), Initializer), function($skip, $loc, $0, $1, $2, $3) {
+        var pattern = $1;
         var suffix = $2;
-        var ws = $3;
-        var initializer = $4;
-        const bindingChildren = [...binding.children];
-        if (suffix)
-          bindingChildren.push(suffix);
-        if (ws)
-          bindingChildren.push(...ws);
-        binding = {
-          ...binding,
-          children: bindingChildren
-        };
-        const [splices, thisAssignments] = gatherBindingCode(binding.children);
+        var initializer = $3;
+        const [splices, thisAssignments] = gatherBindingCode(pattern);
         return {
-          children: [binding, initializer],
-          names: binding.names,
-          binding,
+          type: "Binding",
+          children: $0,
+          names: pattern.names,
+          pattern,
+          suffix,
           initializer,
           splices: splices.map((s) => [",", s]),
           thisAssignments: thisAssignments.map((s) => ["", s, ";"])
         };
       });
-      var LexicalBinding$1 = $TS($S(BindingIdentifier, $E(TypeSuffix), $E(_), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4) {
-        var binding = $1;
+      var LexicalBinding$1 = $TS($S(BindingIdentifier, $E(TypeSuffix), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3) {
+        var pattern = $1;
         var suffix = $2;
-        var ws = $3;
-        var initializer = $4;
-        const bindingChildren = [...binding.children];
-        if (suffix)
-          bindingChildren.push(suffix);
-        if (ws)
-          bindingChildren.push(...ws);
-        binding = {
-          ...binding,
-          children: bindingChildren
-        };
+        var initializer = $3;
         return {
-          children: [binding, initializer],
-          names: binding.names,
-          binding,
+          type: "Binding",
+          children: $0,
+          names: pattern.names,
+          pattern,
+          suffix,
           initializer,
           splices: [],
           thisAssignments: []
@@ -15347,9 +15367,10 @@ ${input.slice(result.pos)}
         }
       }
       var VariableStatement$0 = $TS($S(Var, __, VariableDeclarationList), function($skip, $loc, $0, $1, $2, $3) {
-        return Object.assign({}, $3, {
+        return {
+          ...$3,
           children: [$1, ...$2, ...$3.children]
-        });
+        };
       });
       function VariableStatement(state) {
         let eventData;
@@ -15373,18 +15394,15 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var VariableDeclarationList$0 = $TS($S(VariableDeclaration, $Q($S(__, Comma, __, VariableDeclaration))), function($skip, $loc, $0, $1, $2) {
-        let children;
-        if ($2.length) {
-          children = [$1, ...$2];
-        } else {
-          children = [$1];
-        }
-        const names = children.flatMap((c) => c.names || []);
+      var VariableDeclarationList$0 = $TS($S(LexicalBinding, $Q($S(__, Comma, __, LexicalBinding))), function($skip, $loc, $0, $1, $2) {
+        var binding = $1;
+        var tail = $2;
+        const bindings = [binding].concat(tail.map(([, , , b]) => b));
         return {
           type: "Declaration",
-          children,
-          names
+          children: [binding, ...tail],
+          bindings,
+          names: bindings.flatMap((b) => b.names)
         };
       });
       function VariableDeclarationList(state) {
@@ -15409,49 +15427,6 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var VariableDeclaration$0 = $TS($S(BindingPattern, $E(TypeSuffix), Initializer), function($skip, $loc, $0, $1, $2, $3) {
-        const children = [...$1.children];
-        if ($2)
-          children.push($2);
-        children.push($3);
-        return {
-          children,
-          names: $1.names
-        };
-      });
-      var VariableDeclaration$1 = $TS($S(BindingIdentifier, $E(TypeSuffix), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3) {
-        const children = [...$1.children];
-        if ($2)
-          children.push($2);
-        if ($3)
-          children.push($3);
-        return {
-          children,
-          names: $1.names
-        };
-      });
-      function VariableDeclaration(state) {
-        let eventData;
-        if (state.events) {
-          const result = state.events.enter?.("VariableDeclaration", state);
-          if (result) {
-            if (result.cache)
-              return result.cache;
-            eventData = result.data;
-          }
-        }
-        if (state.tokenize) {
-          const result = $TOKEN("VariableDeclaration", state, VariableDeclaration$0(state) || VariableDeclaration$1(state));
-          if (state.events)
-            state.events.exit?.("VariableDeclaration", state, result, eventData);
-          return result;
-        } else {
-          const result = VariableDeclaration$0(state) || VariableDeclaration$1(state);
-          if (state.events)
-            state.events.exit?.("VariableDeclaration", state, result, eventData);
-          return result;
-        }
-      }
       var NumericLiteral$0 = $TS($S(NumericLiteralKind), function($skip, $loc, $0, $1) {
         return { type: "NumericLiteral", $loc, token: $1 };
       });
@@ -17529,6 +17504,13 @@ ${input.slice(result.pos)}
       var Dot$0 = $TV($EXPECT($L6, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
+      var Dot$1 = $TS($S($EXPECT($R49, fail, "Dot /['\u2019]s/"), _), function($skip, $loc, $0, $1, $2) {
+        var ws = $2;
+        return [
+          { $loc, token: "." },
+          insertTrimmingSpace(ws, "")
+        ];
+      });
       function Dot(state) {
         let eventData;
         if (state.events) {
@@ -17540,12 +17522,12 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("Dot", state, Dot$0(state));
+          const result = $TOKEN("Dot", state, Dot$0(state) || Dot$1(state));
           if (state.events)
             state.events.exit?.("Dot", state, result, eventData);
           return result;
         } else {
-          const result = Dot$0(state);
+          const result = Dot$0(state) || Dot$1(state);
           if (state.events)
             state.events.exit?.("Dot", state, result, eventData);
           return result;
@@ -17907,7 +17889,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var Import$0 = $TS($S($EXPECT($L17, fail, 'Import "import"'), $Y($EXPECT($R49, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
+      var Import$0 = $TS($S($EXPECT($L17, fail, 'Import "import"'), $Y($EXPECT($R50, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Import(state) {
@@ -19485,7 +19467,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var JSXIdentifierName$0 = $R$0($EXPECT($R50, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
+      var JSXIdentifierName$0 = $R$0($EXPECT($R51, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
       function JSXIdentifierName(state) {
         let eventData;
         if (state.events) {
@@ -19723,7 +19705,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var JSXAttributeSpace$0 = $R$0($EXPECT($R51, fail, "JSXAttributeSpace /[\\s>]|\\/>/"));
+      var JSXAttributeSpace$0 = $R$0($EXPECT($R52, fail, "JSXAttributeSpace /[\\s>]|\\/>/"));
       function JSXAttributeSpace(state) {
         let eventData;
         if (state.events) {
@@ -19746,7 +19728,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var JSXShorthandString$0 = $TR($EXPECT($R52, fail, "JSXShorthandString /(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var JSXShorthandString$0 = $TR($EXPECT($R53, fail, "JSXShorthandString /(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return quoteString($0);
       });
       var JSXShorthandString$1 = $TS($S(TemplateLiteral), function($skip, $loc, $0, $1) {
@@ -19835,7 +19817,7 @@ ${input.slice(result.pos)}
         }
         return [open, value, close];
       });
-      var JSXAttributeValue$4 = $R$0($EXPECT($R53, fail, `JSXAttributeValue /"[^"]*"|'[^']*'/`));
+      var JSXAttributeValue$4 = $R$0($EXPECT($R54, fail, `JSXAttributeValue /"[^"]*"|'[^']*'/`));
       function JSXAttributeValue(state) {
         let eventData;
         if (state.events) {
@@ -19885,7 +19867,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($R54, fail, "InlineJSXBinaryOpRHS /[<>]/")), BinaryOp, InlineJSXUnaryExpression), function($skip, $loc, $0, $1, $2, $3) {
+      var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($R55, fail, "InlineJSXBinaryOpRHS /[<>]/")), BinaryOp, InlineJSXUnaryExpression), function($skip, $loc, $0, $1, $2, $3) {
         var op = $2;
         var rhs = $3;
         return [[], op, [], rhs];
@@ -19940,7 +19922,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var InlineJSXUnaryOp$0 = $TR($EXPECT($R55, fail, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var InlineJSXUnaryOp$0 = $TR($EXPECT($R56, fail, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
       function InlineJSXUnaryOp(state) {
@@ -20430,7 +20412,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var JSXCommentContent$0 = $TR($EXPECT($R56, fail, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var JSXCommentContent$0 = $TR($EXPECT($R57, fail, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0.replace(/\*\//g, "* /") };
       });
       function JSXCommentContent(state) {
@@ -20455,7 +20437,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var JSXText$0 = $TR($EXPECT($R57, fail, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var JSXText$0 = $TR($EXPECT($R58, fail, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return {
           type: "JSXText",
           token: $0,
@@ -21205,9 +21187,9 @@ ${input.slice(result.pos)}
               ["let ", id, " = {};\n"],
               ...block.properties.map((property, i) => {
                 let init, isString;
-                if (property.init) {
+                if (property.initializer) {
                   init = replaceNodes(
-                    deepCopy(property.init),
+                    deepCopy(property.initializer),
                     (n) => n.type === "Identifier" && names.has(n.name),
                     (n) => [id, '["', n.name, '"]']
                   );
@@ -21370,11 +21352,11 @@ ${input.slice(result.pos)}
       }
       var EnumProperty$0 = $TS($S(Identifier, $E($S(__, Equals, ExtendedExpression)), ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3) {
         var name = $1;
-        var init = $2;
+        var initializer = $2;
         return {
           type: "EnumProperty",
           name,
-          init,
+          initializer,
           children: $0
         };
       });
@@ -21423,7 +21405,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R58, fail, "TypeIndexSignature /[+-]?/")), Readonly, NotDedented)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R59, fail, "TypeIndexSignature /[+-]/")), $Y($S($E(_), QuestionMark)))));
+      var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R59, fail, "TypeIndexSignature /[+-]?/")), Readonly, NotDedented)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R60, fail, "TypeIndexSignature /[+-]/")), $Y($S($E(_), QuestionMark)))));
       function TypeIndexSignature(state) {
         let eventData;
         if (state.events) {
@@ -21874,17 +21856,25 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var TypeElement$0 = $S($S(__, DotDotDot, __), Type);
-      var TypeElement$1 = $TS($S(Type, $E($S($E(_), DotDotDot))), function($skip, $loc, $0, $1, $2) {
+      var TypeElement$0 = $TS($S(__, IdentifierName, $E(_), DotDotDot, $S(__, $E($S(QuestionMark, $E(_))), Colon, __), Type), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+        var ws = $1;
+        var name = $2;
+        var space = $3;
+        var dots = $4;
+        var colon = $5;
+        var type = $6;
+        return [ws, dots, space, name, colon, type];
+      });
+      var TypeElement$1 = $TS($S(Type, $E(_), DotDotDot), function($skip, $loc, $0, $1, $2, $3) {
         var type = $1;
-        var dots = $2;
-        if (!dots)
-          return type;
+        var space = $2;
+        var dots = $3;
         const ws = getTrimmingSpace(type);
         if (!ws)
-          return [dots[1], dots[0], type];
-        return [ws, dots[1], dots[0], insertTrimmingSpace(type, "")];
+          return [dots, space, type];
+        return [ws, dots, space, insertTrimmingSpace(type, "")];
       });
+      var TypeElement$2 = $S($E($S(__, DotDotDot)), $E($S(__, IdentifierName, __, $E($S(QuestionMark, $E(_))), Colon, __)), Type);
       function TypeElement(state) {
         let eventData;
         if (state.events) {
@@ -21896,12 +21886,12 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("TypeElement", state, TypeElement$0(state) || TypeElement$1(state));
+          const result = $TOKEN("TypeElement", state, TypeElement$0(state) || TypeElement$1(state) || TypeElement$2(state));
           if (state.events)
             state.events.exit?.("TypeElement", state, result, eventData);
           return result;
         } else {
-          const result = TypeElement$0(state) || TypeElement$1(state);
+          const result = TypeElement$0(state) || TypeElement$1(state) || TypeElement$2(state);
           if (state.events)
             state.events.exit?.("TypeElement", state, result, eventData);
           return result;
@@ -21935,7 +21925,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var NestedType$0 = $S(Nested, Type, ArrayElementDelimiter);
+      var NestedType$0 = $S(Nested, TypeElement, ArrayElementDelimiter);
       function NestedType(state) {
         let eventData;
         if (state.events) {
@@ -22498,7 +22488,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var Shebang$0 = $S($R$0($EXPECT($R60, fail, "Shebang /#![^\\r\\n]*/")), EOL);
+      var Shebang$0 = $S($R$0($EXPECT($R61, fail, "Shebang /#![^\\r\\n]*/")), EOL);
       function Shebang(state) {
         let eventData;
         if (state.events) {
@@ -22521,11 +22511,11 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var CivetPrologue$0 = $T($S($EXPECT($R61, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
+      var CivetPrologue$0 = $T($S($EXPECT($R62, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
         var content = value[2];
         return content;
       });
-      var CivetPrologue$1 = $T($S($EXPECT($R61, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
+      var CivetPrologue$1 = $T($S($EXPECT($R62, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
         var content = value[2];
         return content;
       });
@@ -22551,7 +22541,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var CivetPrologueContent$0 = $TS($S($EXPECT($L206, fail, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R62, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var CivetPrologueContent$0 = $TS($S($EXPECT($L206, fail, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R63, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
         var options = $3;
         return {
           type: "CivetPrologue",
@@ -22581,7 +22571,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var CivetOption$0 = $TR($EXPECT($R63, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var CivetOption$0 = $TR($EXPECT($R64, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
           if (l)
             return l.toUpperCase();
@@ -22617,7 +22607,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var UnknownPrologue$0 = $S($R$0($EXPECT($R61, fail, "UnknownPrologue /[\\t ]*/")), StringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
+      var UnknownPrologue$0 = $S($R$0($EXPECT($R62, fail, "UnknownPrologue /[\\t ]*/")), StringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
       function UnknownPrologue(state) {
         let eventData;
         if (state.events) {
@@ -22687,7 +22677,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var EOL$0 = $TR($EXPECT($R64, fail, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var EOL$0 = $TR($EXPECT($R65, fail, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
       function EOL(state) {
@@ -23873,7 +23863,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var Indent$0 = $TR($EXPECT($R65, fail, "Indent /[ \\t]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var Indent$0 = $TR($EXPECT($R66, fail, "Indent /[ \\t]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         let level;
         if (module.config.tab) {
           const tabs = $0.match(/\t/g);
@@ -24179,8 +24169,7 @@ ${input.slice(result.pos)}
         processBinaryOpExpression,
         processCallMemberExpression,
         processCoffeeInterpolation,
-        processConstAssignmentDeclaration,
-        processLetAssignmentDeclaration,
+        processAssignmentDeclaration,
         processProgram,
         processUnaryExpression,
         quoteString,