@danielx/civet 0.5.83 → 0.5.85

package/dist/main.js

@@ -128,16 +128,209 @@ var require_lib = __commonJS({
     function gatherRecursiveWithinFunction(node, predicate) {
       return gatherRecursive(node, predicate, isFunction);
     }
+    function insertTrimmingSpace(target, c) {
+      if (!target)
+        return target;
+      if (Array.isArray(target))
+        return target.map((e, i) => {
+          if (i === 0)
+            return insertTrimmingSpace(e, c);
+          return e;
+        });
+      if (target.children)
+        return Object.assign({}, target, {
+          children: target.children.map((e, i) => {
+            if (i === 0)
+              return insertTrimmingSpace(e, c);
+            return e;
+          })
+        });
+      if (target.token)
+        return Object.assign({}, target, {
+          token: target.token.replace(/^ ?/, c)
+        });
+      return target;
+    }
+    function getTrimmingSpace(target) {
+      if (!target)
+        return;
+      if (Array.isArray(target))
+        return getTrimmingSpace(target[0]);
+      if (target.children)
+        return getTrimmingSpace(target.children[0]);
+      if (target.token)
+        return target.token.match(/^ ?/)[0];
+    }
+    function needsRef(exp) {
+      switch (exp.type) {
+        case "Identifier":
+        case "Literal":
+        case "Ref":
+          return false;
+        default:
+          return true;
+      }
+    }
+    function maybeRef(exp, base = "ref") {
+      if (!needsRef(exp))
+        return exp;
+      return {
+        type: "Ref",
+        base,
+        id: base
+      };
+    }
+    function literalValue(literal) {
+      let { raw } = literal;
+      switch (raw) {
+        case "null":
+          return null;
+        case "true":
+          return true;
+        case "false":
+          return false;
+      }
+      if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+        return raw.slice(1, -1);
+      }
+      const numeric = literal.children.find(
+        (child) => child.type === "NumericLiteral"
+      );
+      if (numeric) {
+        raw = raw.replace(/_/g, "");
+        const { token } = numeric;
+        if (token.endsWith("n")) {
+          return BigInt(raw.slice(0, -1));
+        } else if (token.match(/[\.eE]/)) {
+          return parseFloat(raw);
+        } else if (token.startsWith("0")) {
+          switch (token.charAt(1).toLowerCase()) {
+            case "x":
+              return parseInt(raw.replace(/0[xX]/, ""), 16);
+            case "b":
+              return parseInt(raw.replace(/0[bB]/, ""), 2);
+            case "o":
+              return parseInt(raw.replace(/0[oO]/, ""), 8);
+          }
+        }
+        return parseInt(raw, 10);
+      }
+      throw new Error("Unrecognized literal " + JSON.stringify(literal));
+    }
+    function forRange(open, forDeclaration, range, stepExp, close) {
+      const { start, end, inclusive } = range;
+      const counterRef = {
+        type: "Ref",
+        base: "i",
+        id: "i"
+      };
+      let stepRef;
+      if (stepExp) {
+        stepExp = insertTrimmingSpace(stepExp, "");
+        stepRef = maybeRef(stepExp, "step");
+      }
+      const startRef = maybeRef(start, "start");
+      const endRef = maybeRef(end, "end");
+      const startRefDec = startRef !== start ? [startRef, " = ", start, ", "] : [];
+      const endRefDec = endRef !== end ? [endRef, " = ", end, ", "] : [];
+      let ascDec = [], ascRef, asc;
+      if (stepRef) {
+        if (stepRef !== stepExp) {
+          ascDec = [", ", stepRef, " = ", stepExp];
+        }
+      } else if (start.type === "Literal" && end.type === "Literal") {
+        asc = literalValue(start) <= literalValue(end);
+      } else {
+        ascRef = {
+          type: "Ref",
+          base: "asc",
+          id: "asc"
+        };
+        ascDec = [", ", ascRef, " = ", startRef, " <= ", endRef];
+      }
+      let varAssign = [], varLetAssign = varAssign, varLet = varAssign, blockPrefix;
+      if (forDeclaration?.declare) {
+        if (forDeclaration.declare.token === "let") {
+          const varName = forDeclaration.children.splice(1);
+          varAssign = [...insertTrimmingSpace(varName, ""), " = "];
+          varLet = [",", ...varName, " = ", counterRef];
+        } else {
+          blockPrefix = [
+            ["", forDeclaration, " = ", counterRef, ";\n"]
+          ];
+        }
+      } else if (forDeclaration) {
+        varAssign = varLetAssign = [forDeclaration, " = "];
+        blockPrefix = [
+          ["", {
+            type: "AssignmentExpression",
+            children: [],
+            names: forDeclaration.names
+          }]
+        ];
+      }
+      const declaration = {
+        type: "Declaration",
+        children: ["let ", ...startRefDec, ...endRefDec, counterRef, " = ", ...varLetAssign, startRef, ...varLet, ...ascDec],
+        names: forDeclaration?.names
+      };
+      const counterPart = inclusive ? [counterRef, " <= ", endRef, " : ", counterRef, " >= ", endRef] : [counterRef, " < ", endRef, " : ", counterRef, " > ", endRef];
+      const condition = stepRef ? [stepRef, " !== 0 && (", stepRef, " > 0 ? ", ...counterPart, ")"] : ascRef ? [ascRef, " ? ", ...counterPart] : asc ? counterPart.slice(0, 3) : counterPart.slice(4);
+      const increment = stepRef ? [...varAssign, counterRef, " += ", stepRef] : ascRef ? [...varAssign, ascRef, " ? ++", counterRef, " : --", counterRef] : [...varAssign, asc ? "++" : "--", counterRef];
+      return {
+        declaration,
+        children: [open, declaration, "; ", ...condition, "; ", ...increment, close],
+        blockPrefix
+      };
+    }
+    function modifyString(str) {
+      return str.replace(/(^.?|[^\\]{2})(\\\\)*\n/g, "$1$2\\n");
+    }
+    function quoteString(str) {
+      str = str.replace(/\\/g, "\\\\");
+      if (str.includes('"') && !str.includes("'")) {
+        return "'" + str.replace(/'/g, "\\'") + "'";
+      } else {
+        return '"' + str.replace(/"/g, '\\"') + '"';
+      }
+    }
+    function processCoffeeInterpolation(s, parts, e, $loc) {
+      if (parts.length === 0 || parts.length === 1 && parts[0].token != null) {
+        return {
+          type: "StringLiteral",
+          token: parts.length ? `"${modifyString(parts[0].token)}"` : '""',
+          $loc
+        };
+      }
+      parts.forEach((part) => {
+        if (part.token) {
+          const str = part.token.replace(/(`|\$\{)/g, "\\$1");
+          part.token = modifyString(str);
+        }
+      });
+      s.token = e.token = "`";
+      return {
+        type: "TemplateLiteral",
+        children: [s, parts, e]
+      };
+    }
     module2.exports = {
       clone,
       deepCopy,
+      forRange,
       gatherNodes,
       gatherRecursive,
       gatherRecursiveAll,
       gatherRecursiveWithinFunction,
+      getTrimmingSpace,
       hasAwait,
       hasYield,
+      insertTrimmingSpace,
       isFunction,
+      literalValue,
+      modifyString,
+      processCoffeeInterpolation,
+      quoteString,
       removeParentPointers
     };
   }
@@ -704,6 +897,7 @@ ${input.slice(result.pos)}
       BracedContent,
       NestedBlockStatements,
       NestedBlockStatement,
+      BlockStatementPart,
       Literal,
       LiteralContent,
       NullLiteral,
@@ -781,6 +975,7 @@ ${input.slice(result.pos)}
       ElseExpressionBlock,
       NestedBlockExpressions,
       NestedBlockExpression,
+      BlockExpressionPart,
       IterationStatement,
       IterationExpression,
       LoopStatement,
@@ -797,6 +992,7 @@ ${input.slice(result.pos)}
       CoffeeForIndex,
       CoffeeForDeclaration,
       ForStatementParameters,
+      ForRangeParameters,
       ForInOfDeclaration,
       ForDeclaration,
       ForBinding,
@@ -1108,6 +1304,10 @@ ${input.slice(result.pos)}
       NestedTypeList,
       NestedType,
       TypeConditional,
+      TypeTemplateSubstitution,
+      TypeTemplateLiteral,
+      CoffeeStringTypeSubstitution,
+      CoffeeInterpolatedDoubleQuotedTypeLiteral,
       TypeLiteral,
       InlineInterfaceLiteral,
       InlineBasicInterfaceProperty,
@@ -1524,10 +1724,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var TopLevelSingleLineStatements$0 = $TV($P($S($N(EOS), TopLevelStatement)), function($skip, $loc, $0, $1) {
-      var statements = $0;
-      return statements.map(([, statement]) => statement);
-    });
+    var TopLevelSingleLineStatements$0 = $P(TopLevelStatement);
     function TopLevelSingleLineStatements(state) {
       let eventData;
       if (state.events) {
@@ -1550,10 +1747,10 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var TopLevelStatement$0 = $TS($S($E(_), ModuleItem, StatementDelimiter), function($skip, $loc, $0, $1, $2, $3) {
-      var ws = $1;
-      var statement = $2;
-      var delimiter = $3;
+    var TopLevelStatement$0 = $TS($S($N(EOS), $E(_), ModuleItem, StatementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var ws = $2;
+      var statement = $3;
+      var delimiter = $4;
       if (ws) {
         statement = {
           ...statement,
@@ -1784,7 +1981,7 @@ ${input.slice(result.pos)}
       if (args.length === 1 && args[0].type === "IterationExpression" && args[0].subtype !== "DoStatement" && !args[0].async && module2.isEmptyBareBlock(args[0].block)) {
         return $skip;
       }
-      return [ta?.[0], open, module2.insertTrimmingSpace(ws, ""), args, close];
+      return [ta?.[0], open, insertTrimmingSpace(ws, ""), args, close];
     });
     function ImplicitArguments(state) {
       let eventData;
@@ -1994,7 +2191,7 @@ ${input.slice(result.pos)}
     }
     var ArgumentList$0 = $S(ArgumentPart, $P($S(CommaDelimiter, $C(NestedImplicitObjectLiteral, NestedArgumentList))));
     var ArgumentList$1 = $TS($S(NestedImplicitObjectLiteral), function($skip, $loc, $0, $1) {
-      return module2.insertTrimmingSpace($1, "");
+      return insertTrimmingSpace($1, "");
     });
     var ArgumentList$2 = NestedArgumentList;
     var ArgumentList$3 = $TS($S($E(_), ArgumentPart, $Q($S(CommaDelimiter, $E(_), ArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
@@ -2024,7 +2221,7 @@ ${input.slice(result.pos)}
     }
     var NonPipelineArgumentList$0 = $S(NonPipelineArgumentPart, $P($S(CommaDelimiter, $C(NestedImplicitObjectLiteral, NestedArgumentList))));
     var NonPipelineArgumentList$1 = $TS($S(NestedImplicitObjectLiteral), function($skip, $loc, $0, $1) {
-      return module2.insertTrimmingSpace($1, "");
+      return insertTrimmingSpace($1, "");
     });
     var NonPipelineArgumentList$2 = NestedArgumentList;
     var NonPipelineArgumentList$3 = $TS($S($E(_), NonPipelineArgumentPart, $Q($S(CommaDelimiter, $E(_), NonPipelineArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
@@ -2296,7 +2493,7 @@ ${input.slice(result.pos)}
     var UnaryExpression$1 = $TS($S(CoffeeDoEnabled, Do, __, $C($S(LeftHandSideExpression, $N($S(__, AssignmentOpSymbol))), ArrowFunction, ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4) {
       var ws = $3;
       var exp = $4;
-      ws = module2.insertTrimmingSpace(ws, "");
+      ws = insertTrimmingSpace(ws, "");
       return ["(", ...ws, exp, ")()"];
     });
     function UnaryExpression(state) {
@@ -4307,7 +4504,7 @@ ${input.slice(result.pos)}
         if (after.length) {
           const spliceRef = module2.getRef("splice");
           blockPrefix = {
-            children: ["[", module2.insertTrimmingSpace(after, ""), "] = ", spliceRef, ".call(", restIdentifier, ", -", after.length.toString(), ")"],
+            children: ["[", insertTrimmingSpace(after, ""), "] = ", spliceRef, ".call(", restIdentifier, ", -", after.length.toString(), ")"],
             names: after.flatMap((p) => p.names)
           };
         }
@@ -5815,7 +6012,7 @@ ${input.slice(result.pos)}
       var w = $2;
       var decl = $3;
       decl.names.forEach((name) => module2.operators.add(name));
-      return [module2.insertTrimmingSpace(w, ""), decl];
+      return [insertTrimmingSpace(w, ""), decl];
     });
     var OperatorDeclaration$1 = $TS($S(OperatorSignature, BracedBlock), function($skip, $loc, $0, $1, $2) {
       var signature = $1;
@@ -5871,7 +6068,7 @@ ${input.slice(result.pos)}
       if (!func) {
         func = { $loc: op.$loc, token: "function" };
       } else {
-        func = [module2.insertTrimmingSpace(func[0], ""), func[1]];
+        func = [insertTrimmingSpace(func[0], ""), func[1]];
       }
       return {
         type: "FunctionSignature",
@@ -6531,6 +6728,7 @@ ${input.slice(result.pos)}
       var statements = $2;
       if (!statements.length)
         return $skip;
+      statements = statements.flat();
       const first = statements[0];
       const ws = first[0];
       const indent = ws.at(-1);
@@ -6567,15 +6765,13 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var NestedBlockStatement$0 = $TS($S(Nested, $E(_), StatementListItem, StatementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var NestedBlockStatement$0 = $TS($S(Nested, $P(BlockStatementPart)), function($skip, $loc, $0, $1, $2) {
       var nested = $1;
-      var ws = $2;
-      var statement = $3;
-      var delimiter = $4;
-      if (ws) {
-        statement = { ...statement, children: [ws, ...statement.children] };
-      }
-      return [nested, statement, delimiter];
+      var statements = $2;
+      return [
+        [nested, ...statements[0]],
+        ...statements.slice(1).map((s) => ["", ...s])
+      ];
     });
     function NestedBlockStatement(state) {
       let eventData;
@@ -6599,6 +6795,37 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var BlockStatementPart$0 = $TS($S($N(EOS), $E(_), StatementListItem, StatementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var ws = $2;
+      var statement = $3;
+      var delimiter = $4;
+      if (ws) {
+        statement = { ...statement, children: [ws, ...statement.children] };
+      }
+      return [statement, delimiter];
+    });
+    function BlockStatementPart(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("BlockStatementPart", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("BlockStatementPart", state, BlockStatementPart$0(state));
+        if (state.events)
+          state.events.exit?.("BlockStatementPart", state, result, eventData);
+        return result;
+      } else {
+        const result = BlockStatementPart$0(state);
+        if (state.events)
+          state.events.exit?.("BlockStatementPart", state, result, eventData);
+        return result;
+      }
+    }
     var Literal$0 = $TS($S(LiteralContent), function($skip, $loc, $0, $1) {
       return {
         type: "Literal",
@@ -6899,8 +7126,8 @@ ${input.slice(result.pos)}
       const inclusive = range.token === "..";
       range.token = ",";
       if (s.type === "Literal" && e.type === "Literal") {
-        const start = module2.literalValue(s);
-        const end = module2.literalValue(e);
+        const start = literalValue(s);
+        const end = literalValue(e);
         if (typeof start !== typeof end) {
           throw new Error("Range start and end must be of the same type");
         }
@@ -9203,6 +9430,7 @@ ${input.slice(result.pos)}
     }
     var ExpressionBlock$0 = $TS($S(InsertOpenParen, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       var exps = $2;
+      exps = exps.flat();
       if (exps.length === 1) {
         let [ws, exp] = exps[0];
         switch (exp.type) {
@@ -9248,6 +9476,7 @@ ${input.slice(result.pos)}
     }
     var ElseExpressionBlock$0 = $TS($S(InsertOpenParen, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       var exps = $2;
+      exps = exps.flat();
       if (exps.length === 1) {
         let [ws, exp] = exps[0];
         switch (exp.type) {
@@ -9321,7 +9550,14 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var NestedBlockExpression$0 = $S(Nested, PostfixedExpression, ExpressionDelimiter);
+    var NestedBlockExpression$0 = $TS($S(Nested, $P(BlockExpressionPart)), function($skip, $loc, $0, $1, $2) {
+      var nested = $1;
+      var expressions = $2;
+      return [
+        [nested, ...expressions[0]],
+        ...expressions.slice(1).map((s) => ["", ...s])
+      ];
+    });
     function NestedBlockExpression(state) {
       let eventData;
       if (state.events) {
@@ -9344,6 +9580,37 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var BlockExpressionPart$0 = $TS($S($N(EOS), $E(_), PostfixedExpression, ExpressionDelimiter), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var ws = $2;
+      var exp = $3;
+      var delimiter = $4;
+      if (ws) {
+        exp = { ...exp, children: [ws, ...exp.children] };
+      }
+      return [exp, delimiter];
+    });
+    function BlockExpressionPart(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("BlockExpressionPart", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("BlockExpressionPart", state, BlockExpressionPart$0(state));
+        if (state.events)
+          state.events.exit?.("BlockExpressionPart", state, result, eventData);
+        return result;
+      } else {
+        const result = BlockExpressionPart$0(state);
+        if (state.events)
+          state.events.exit?.("BlockExpressionPart", state, result, eventData);
+        return result;
+      }
+    }
     var IterationStatement$0 = LoopStatement;
     var IterationStatement$1 = $T($S($N(CoffeeDoEnabled), DoWhileStatement), function(value) {
       return value[1];
@@ -9492,7 +9759,7 @@ ${input.slice(result.pos)}
     }
     var DoStatement$0 = $TS($S(Do, NoPostfixBracedBlock), function($skip, $loc, $0, $1, $2) {
       var block = $2;
-      block = module2.insertTrimmingSpace(block, "");
+      block = insertTrimmingSpace(block, "");
       return {
         type: "DoStatement",
         children: [block],
@@ -9594,7 +9861,16 @@ ${input.slice(result.pos)}
       var clause = $1;
       var block = $2;
       if (clause.blockPrefix) {
-        block.expressions.splice(0, 0, ...clause.blockPrefix);
+        const expressions = [...clause.blockPrefix, ...block.expressions];
+        block = {
+          ...block,
+          expressions,
+          children: block.children === block.expressions ? expressions : block.children.map((c) => c === block.expressions ? expressions : c)
+        };
+        if (block.bare) {
+          block.children = [" {\n", ...block.children, "\n}"];
+          block.bare = false;
+        }
       }
       return {
         ...clause,
@@ -9671,7 +9947,7 @@ ${input.slice(result.pos)}
             [indent, {
               type: "IfStatement",
               then: block,
-              children: ["if (!(", module2.insertTrimmingSpace($3, ""), ")) ", block]
+              children: ["if (!(", insertTrimmingSpace($3, ""), ")) ", block]
             }]
           ]
         };
@@ -9726,7 +10002,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var CoffeeForStatementParameters$0 = $TS($S($E($S(Await, __)), InsertOpenParen, CoffeeForDeclaration, $E(CoffeeForIndex), __, $C(In, Of, From), ExpressionWithIndentedApplicationForbidden, $E($S(__, By, ExpressionWithIndentedApplicationForbidden)), InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+    var CoffeeForStatementParameters$0 = $TS($S($E($S(Await, __)), InsertOpenParen, CoffeeForDeclaration, $E(CoffeeForIndex), __, $C(In, Of, From), ExpressionWithIndentedApplicationForbidden, $E($S($E(_), By, ExpressionWithIndentedApplicationForbidden)), InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
       var open = $2;
       var declaration = $3;
       var index = $4;
@@ -9736,8 +10012,8 @@ ${input.slice(result.pos)}
       var close = $9;
       let blockPrefix = [];
       const indent = module2.currentIndent.token + "  ";
-      exp = module2.insertTrimmingSpace(exp, "");
-      declaration = module2.insertTrimmingSpace(declaration, "");
+      exp = insertTrimmingSpace(exp, "");
+      declaration = insertTrimmingSpace(declaration, "");
       if (kind.token === "from") {
         if (step) {
           throw new Error("Can't use 'by' with 'from' in CoffeeScript for loops");
@@ -9775,68 +10051,8 @@ ${input.slice(result.pos)}
           case "Identifier":
             expRef = exp;
             break;
-          case "RangeExpression": {
-            const { start, end, inclusive } = exp;
-            let stepExp = step?.[2];
-            let stepRef;
-            if (stepExp) {
-              stepExp = module2.insertTrimmingSpace(stepExp, "");
-              if (stepExp.type === "Literal") {
-                stepRef = stepExp;
-              } else {
-                stepRef = {
-                  type: "Ref",
-                  base: "step",
-                  id: "step"
-                };
-              }
-            }
-            let startRef, endRef;
-            if (start.type === "Literal") {
-              startRef = start;
-            } else if (start.type === "Identifier") {
-              startRef = start;
-            } else {
-              startRef = {
-                type: "Ref",
-                base: "ref",
-                id: "ref"
-              };
-            }
-            if (end.type === "Literal") {
-              endRef = end;
-            } else if (end.type === "Identifier") {
-              endRef = end;
-            } else {
-              endRef = {
-                type: "Ref",
-                base: "ref",
-                id: "ref"
-              };
-            }
-            const startRefDec = startRef !== start ? [startRef, " = ", start, ", "] : [];
-            const endRefDec = endRef !== end ? [endRef, " = ", end, ", "] : [];
-            const varRef2 = declaration;
-            const ascDec = stepRef ? stepRef !== stepExp ? [", step = ", stepExp] : [] : [", asc = ", startRef, " <= ", endRef];
-            declaration = {
-              type: "Declaration",
-              children: ["let ", ...startRefDec, ...endRefDec, counterRef, " = ", varRef2, " = ", startRef, ...ascDec],
-              names: varRef2.names
-            };
-            blockPrefix.push(["", {
-              type: "AssignmentExpression",
-              children: [],
-              names: varRef2.names
-            }]);
-            const counterPart = inclusive ? [counterRef, " <= ", endRef, " : ", counterRef, " >= ", endRef] : [counterRef, " < ", endRef, " : ", counterRef, " > ", endRef];
-            const condition2 = stepRef ? [stepRef, " !== 0 && (", stepRef, " > 0 ? ", ...counterPart, ")"] : ["asc ? ", ...counterPart];
-            const increment2 = stepRef ? [varRef2, " = ", counterRef, " += ", stepRef] : [varRef2, " = asc ? ++", counterRef, " : --", counterRef];
-            return {
-              declaration,
-              children: [$1, open, declaration, "; ", ...condition2, "; ", ...increment2, close],
-              blockPrefix
-            };
-          }
+          case "RangeExpression":
+            return forRange(open, declaration, exp, step?.[2], close);
           default:
             expRef = {
               type: "Ref",
@@ -9847,11 +10063,11 @@ ${input.slice(result.pos)}
         const varRef = declaration;
         let increment = "++", indexAssignment, assignmentNames = [...varRef.names];
         if (index) {
-          index = module2.insertTrimmingSpace(index, "");
+          index = insertTrimmingSpace(index, "");
           indexAssignment = [index, "="];
           assignmentNames.push(...index.names);
         }
-        const expRefDec = expRef !== exp ? [expRef, " = ", module2.insertTrimmingSpace(exp, ""), ", "] : [];
+        const expRefDec = expRef !== exp ? [expRef, " = ", insertTrimmingSpace(exp, ""), ", "] : [];
         blockPrefix.push([indent, {
           type: "AssignmentExpression",
           children: [varRef, " = ", expRef, "[", indexAssignment, counterRef, "]\n"],
@@ -9865,7 +10081,7 @@ ${input.slice(result.pos)}
         let condition = [counterRef, " < ", lenRef, "; "];
         if (step) {
           let [stepWs, , stepExp] = step;
-          stepWs = module2.insertTrimmingSpace(stepWs, "");
+          stepWs = insertTrimmingSpace(stepWs, "");
           if (stepExp.type === "Literal") {
             increment = [" +=", ...stepWs, stepExp];
             if (stepExp.raw[0] === "-") {
@@ -9897,6 +10113,7 @@ ${input.slice(result.pos)}
         blockPrefix
       };
     });
+    var CoffeeForStatementParameters$1 = ForRangeParameters;
     function CoffeeForStatementParameters(state) {
       let eventData;
       if (state.events) {
@@ -9908,12 +10125,12 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("CoffeeForStatementParameters", state, CoffeeForStatementParameters$0(state));
+        const result = $TOKEN("CoffeeForStatementParameters", state, CoffeeForStatementParameters$0(state) || CoffeeForStatementParameters$1(state));
         if (state.events)
           state.events.exit?.("CoffeeForStatementParameters", state, result, eventData);
         return result;
       } else {
-        const result = CoffeeForStatementParameters$0(state);
+        const result = CoffeeForStatementParameters$0(state) || CoffeeForStatementParameters$1(state);
         if (state.events)
           state.events.exit?.("CoffeeForStatementParameters", state, result, eventData);
         return result;
@@ -9923,7 +10140,7 @@ ${input.slice(result.pos)}
       var ws1 = $1;
       var ws2 = $3;
       var id = $4;
-      ws2 = module2.insertTrimmingSpace(ws1, "");
+      ws2 = insertTrimmingSpace(ws1, "");
       return {
         ...id,
         children: [...ws1 || [], ...ws2 || [], ...id.children]
@@ -9997,20 +10214,41 @@ ${input.slice(result.pos)}
         children: $0
       };
     });
-    var ForStatementParameters$2 = $TS($S($E($S(Await, __)), OpenParen, __, ForInOfDeclaration, __, $C(In, Of), ExpressionWithIndentedApplicationForbidden, __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+    var ForStatementParameters$2 = $TS($S($E($S(Await, __)), OpenParen, __, ForInOfDeclaration, __, $C(In, Of), ExpressionWithIndentedApplicationForbidden, $E($S(__, By, ExpressionWithIndentedApplicationForbidden)), __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10) {
+      var open = $2;
       var declaration = $4;
+      var op = $6;
+      var exp = $7;
+      var step = $8;
+      var close = $10;
+      if (exp.type === "RangeExpression" && op.token === "of") {
+        return forRange(open, declaration, exp, step, close);
+      } else if (step) {
+        throw new Error("for..of/in cannot use 'by' except with range literals");
+      }
       return {
         declaration,
         children: $0
       };
     });
-    var ForStatementParameters$3 = $TS($S($E($S(Await, __)), InsertOpenParen, ForInOfDeclaration, __, $C(In, Of), ExpressionWithIndentedApplicationForbidden, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
+    var ForStatementParameters$3 = $TS($S($E($S(Await, __)), InsertOpenParen, ForInOfDeclaration, __, $C(In, Of), ExpressionWithIndentedApplicationForbidden, $E($S(__, By, ExpressionWithIndentedApplicationForbidden)), InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
+      var open = $2;
       var declaration = $3;
+      var op = $5;
+      var exp = $6;
+      var step = $7;
+      var close = $8;
+      if (exp.type === "RangeExpression" && op.token === "of") {
+        return forRange(open, declaration, exp, step, close);
+      } else if (step) {
+        throw new Error("for..of/in cannot use 'by' except with range literals");
+      }
       return {
         declaration,
         children: $0
       };
     });
+    var ForStatementParameters$4 = ForRangeParameters;
     function ForStatementParameters(state) {
       let eventData;
       if (state.events) {
@@ -10022,22 +10260,59 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("ForStatementParameters", state, ForStatementParameters$0(state) || ForStatementParameters$1(state) || ForStatementParameters$2(state) || ForStatementParameters$3(state));
+        const result = $TOKEN("ForStatementParameters", state, ForStatementParameters$0(state) || ForStatementParameters$1(state) || ForStatementParameters$2(state) || ForStatementParameters$3(state) || ForStatementParameters$4(state));
         if (state.events)
           state.events.exit?.("ForStatementParameters", state, result, eventData);
         return result;
       } else {
-        const result = ForStatementParameters$0(state) || ForStatementParameters$1(state) || ForStatementParameters$2(state) || ForStatementParameters$3(state);
+        const result = ForStatementParameters$0(state) || ForStatementParameters$1(state) || ForStatementParameters$2(state) || ForStatementParameters$3(state) || ForStatementParameters$4(state);
         if (state.events)
           state.events.exit?.("ForStatementParameters", state, result, eventData);
         return result;
       }
     }
+    var ForRangeParameters$0 = $TS($S($E($S(Await, __)), OpenParen, OpenBracket, RangeExpression, CloseBracket, $E($S(__, By, ExpressionWithIndentedApplicationForbidden)), CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
+      var open = $2;
+      var exp = $4;
+      var step = $6;
+      var close = $7;
+      return forRange(open, null, exp, step, close);
+    });
+    var ForRangeParameters$1 = $TS($S($E($S(Await, __)), InsertOpenParen, OpenBracket, RangeExpression, CloseBracket, $E($S(__, By, ExpressionWithIndentedApplicationForbidden)), InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
+      var open = $2;
+      var exp = $4;
+      var step = $6;
+      var close = $7;
+      return forRange(open, null, exp, step, close);
+    });
+    function ForRangeParameters(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("ForRangeParameters", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("ForRangeParameters", state, ForRangeParameters$0(state) || ForRangeParameters$1(state));
+        if (state.events)
+          state.events.exit?.("ForRangeParameters", state, result, eventData);
+        return result;
+      } else {
+        const result = ForRangeParameters$0(state) || ForRangeParameters$1(state);
+        if (state.events)
+          state.events.exit?.("ForRangeParameters", state, result, eventData);
+        return result;
+      }
+    }
     var ForInOfDeclaration$0 = $TS($S(Var, ForBinding), function($skip, $loc, $0, $1, $2) {
       var binding = $2;
       return {
         type: "ForDeclaration",
         children: $0,
+        declare: $1,
         names: binding.names
       };
     });
@@ -10065,12 +10340,13 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var ForDeclaration$0 = $TS($S(LetOrConst, NonIdContinue, ForBinding), function($skip, $loc, $0, $1, $2, $3) {
+    var ForDeclaration$0 = $TS($S(LetOrConst, ForBinding), function($skip, $loc, $0, $1, $2) {
       var c = $1;
-      var binding = $3;
+      var binding = $2;
       return {
         type: "ForDeclaration",
         children: [c, binding],
+        declare: c,
         names: binding.names
       };
     });
@@ -10080,6 +10356,7 @@ ${input.slice(result.pos)}
       return {
         type: "ForDeclaration",
         children: [c, binding],
+        declare: c,
         names: binding.names
       };
     });
@@ -10406,9 +10683,9 @@ ${input.slice(result.pos)}
       if (!first)
         return $skip;
       const result = rest.map(([ws, _comma, exp, col]) => {
-        exp = module2.insertTrimmingSpace(exp, "");
+        exp = insertTrimmingSpace(exp, "");
         if (ws.length)
-          return [module2.insertTrimmingSpace("case ", ws), exp, col];
+          return [insertTrimmingSpace("case ", ws), exp, col];
         return ["case ", exp, col];
       });
       result.unshift(first);
@@ -10658,7 +10935,7 @@ ${input.slice(result.pos)}
       var close = $3;
       if (expression.type === "ParenthesizedExpression")
         return expression;
-      expression = module2.insertTrimmingSpace(expression, "");
+      expression = insertTrimmingSpace(expression, "");
       return {
         type: "ParenthesizedExpression",
         children: [open, expression, close],
@@ -11639,7 +11916,7 @@ ${input.slice(result.pos)}
         ...spec,
         children: [
           ws,
-          module2.insertTrimmingSpace(spec[0], ""),
+          insertTrimmingSpace(spec[0], ""),
           spec.children.slice(1)
         ]
       };
@@ -12699,7 +12976,7 @@ ${input.slice(result.pos)}
       var str = $2;
       return {
         type: "StringLiteral",
-        token: `"${module2.modifyString(str.token)}"`,
+        token: `"${modifyString(str.token)}"`,
         $loc
       };
     });
@@ -12707,7 +12984,7 @@ ${input.slice(result.pos)}
       var str = $2;
       return {
         type: "StringLiteral",
-        token: `'${module2.modifyString(str.token)}'`,
+        token: `'${modifyString(str.token)}'`,
         $loc
       };
     });
@@ -12860,24 +13137,7 @@ ${input.slice(result.pos)}
       var s = $2;
       var parts = $3;
       var e = $4;
-      if (parts.length === 0 || parts.length === 1 && parts[0].token != null) {
-        return {
-          type: "StringLiteral",
-          token: parts.length ? `"${module2.modifyString(parts[0].token)}"` : '""',
-          $loc
-        };
-      }
-      parts.forEach((part) => {
-        if (part.token) {
-          const str = part.token.replace(/(`|\$\{)/g, "\\$1");
-          part.token = module2.modifyString(str);
-        }
-      });
-      s.token = e.token = "`";
-      return {
-        type: "TemplateLiteral",
-        children: [s, parts, e]
-      };
+      return processCoffeeInterpolation(s, parts, e, $loc);
     });
     function CoffeeInterpolatedDoubleQuotedString(state) {
       let eventData;
@@ -13641,7 +13901,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var TrailingComment$0 = $S($E(_), SingleLineComment);
+    var TrailingComment$0 = $S($E(_), $E(SingleLineComment));
     function TrailingComment(state) {
       let eventData;
       if (state.events) {
@@ -13717,7 +13977,7 @@ ${input.slice(result.pos)}
     }
     var Trimmed_$0 = $TV($Q(_), function($skip, $loc, $0, $1) {
       var ws = $0;
-      return module2.insertTrimmingSpace(ws, "");
+      return insertTrimmingSpace(ws, "");
     });
     function Trimmed_(state) {
       let eventData;
@@ -13789,7 +14049,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var ExpressionDelimiter$0 = $TS($S($E(_), Semicolon, InsertComma, $E(TrailingComment)), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var ExpressionDelimiter$0 = $TS($S($E(_), Semicolon, InsertComma, TrailingComment), function($skip, $loc, $0, $1, $2, $3, $4) {
       return [$1, $3, $4];
     });
     var ExpressionDelimiter$1 = $T($S($Y(EOS), InsertComma), function(value) {
@@ -13866,7 +14126,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var SemicolonDelimiter$0 = $TS($S($E(_), Semicolon, $E(TrailingComment)), function($skip, $loc, $0, $1, $2, $3) {
+    var SemicolonDelimiter$0 = $TS($S($E(_), Semicolon, TrailingComment), function($skip, $loc, $0, $1, $2, $3) {
       return {
         type: "SemicolonDelimiter",
         children: $0
@@ -16581,7 +16841,7 @@ ${input.slice(result.pos)}
             if (part.name.type === "ComputedPropertyName") {
               rest.push(part);
             } else {
-              parts.push([part.name, "={", module2.insertTrimmingSpace(part.value, ""), "}"]);
+              parts.push([part.name, "={", insertTrimmingSpace(part.value, ""), "}"]);
             }
             break;
           case "SpreadProperty":
@@ -16682,7 +16942,7 @@ ${input.slice(result.pos)}
       }
     }
     var JSXShorthandString$0 = $TR($EXPECT($R52, fail, "JSXShorthandString /(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
-      return module2.quoteString($0);
+      return quoteString($0);
     });
     var JSXShorthandString$1 = $TS($S(TemplateLiteral), function($skip, $loc, $0, $1) {
       return ["{", $1, "}"];
@@ -18782,7 +19042,110 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var TypeLiteral$0 = TemplateLiteral;
+    var TypeTemplateSubstitution$0 = $S(SubstitutionStart, Type, __, CloseBrace);
+    function TypeTemplateSubstitution(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("TypeTemplateSubstitution", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("TypeTemplateSubstitution", state, TypeTemplateSubstitution$0(state));
+        if (state.events)
+          state.events.exit?.("TypeTemplateSubstitution", state, result, eventData);
+        return result;
+      } else {
+        const result = TypeTemplateSubstitution$0(state);
+        if (state.events)
+          state.events.exit?.("TypeTemplateSubstitution", state, result, eventData);
+        return result;
+      }
+    }
+    var TypeTemplateLiteral$0 = $TS($S(Backtick, $Q($C(TemplateCharacters, TypeTemplateSubstitution)), Backtick), function($skip, $loc, $0, $1, $2, $3) {
+      return {
+        type: "TemplateLiteral",
+        children: $0
+      };
+    });
+    var TypeTemplateLiteral$1 = CoffeeInterpolatedDoubleQuotedTypeLiteral;
+    function TypeTemplateLiteral(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("TypeTemplateLiteral", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("TypeTemplateLiteral", state, TypeTemplateLiteral$0(state) || TypeTemplateLiteral$1(state));
+        if (state.events)
+          state.events.exit?.("TypeTemplateLiteral", state, result, eventData);
+        return result;
+      } else {
+        const result = TypeTemplateLiteral$0(state) || TypeTemplateLiteral$1(state);
+        if (state.events)
+          state.events.exit?.("TypeTemplateLiteral", state, result, eventData);
+        return result;
+      }
+    }
+    var CoffeeStringTypeSubstitution$0 = $S(CoffeeSubstitutionStart, Type, __, CloseBrace);
+    function CoffeeStringTypeSubstitution(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("CoffeeStringTypeSubstitution", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("CoffeeStringTypeSubstitution", state, CoffeeStringTypeSubstitution$0(state));
+        if (state.events)
+          state.events.exit?.("CoffeeStringTypeSubstitution", state, result, eventData);
+        return result;
+      } else {
+        const result = CoffeeStringTypeSubstitution$0(state);
+        if (state.events)
+          state.events.exit?.("CoffeeStringTypeSubstitution", state, result, eventData);
+        return result;
+      }
+    }
+    var CoffeeInterpolatedDoubleQuotedTypeLiteral$0 = $TS($S(CoffeeInterpolationEnabled, DoubleQuote, $Q($C(CoffeeDoubleQuotedStringCharacters, CoffeeStringTypeSubstitution)), DoubleQuote), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var s = $2;
+      var parts = $3;
+      var e = $4;
+      return processCoffeeInterpolation(s, parts, e, $loc);
+    });
+    function CoffeeInterpolatedDoubleQuotedTypeLiteral(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("CoffeeInterpolatedDoubleQuotedTypeLiteral", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("CoffeeInterpolatedDoubleQuotedTypeLiteral", state, CoffeeInterpolatedDoubleQuotedTypeLiteral$0(state));
+        if (state.events)
+          state.events.exit?.("CoffeeInterpolatedDoubleQuotedTypeLiteral", state, result, eventData);
+        return result;
+      } else {
+        const result = CoffeeInterpolatedDoubleQuotedTypeLiteral$0(state);
+        if (state.events)
+          state.events.exit?.("CoffeeInterpolatedDoubleQuotedTypeLiteral", state, result, eventData);
+        return result;
+      }
+    }
+    var TypeLiteral$0 = TypeTemplateLiteral;
     var TypeLiteral$1 = Literal;
     var TypeLiteral$2 = $TS($S($EXPECT($L161, fail, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
       return { type: "VoidType", $loc, token: $1 };
@@ -20541,20 +20904,6 @@ ${input.slice(result.pos)}
           }
         }
       });
-      module2.modifyString = function(str) {
-        return str.replace(/(^.?|[^\\]{2})(\\\\)*\n/g, "$1$2\\n");
-      };
-      module2.unmodifyString = function(str) {
-        return str.replace(/\\n/g, "\n");
-      };
-      module2.quoteString = function(str) {
-        str = str.replace(/\\/g, "\\\\");
-        if (str.includes('"') && !str.includes("'")) {
-          return "'" + str.replace(/'/g, "\\'") + "'";
-        } else {
-          return '"' + str.replace(/"/g, '\\"') + '"';
-        }
-      };
     });
     function Reset(state) {
       let eventData;
@@ -20600,8 +20949,8 @@ ${input.slice(result.pos)}
                 throw new Error("Glob pattern must have call or member expression value");
               }
               let value = part.value ?? part.name;
-              const wValue = module2.getTrimmingSpace(part.value);
-              value = prefix.concat(module2.insertTrimmingSpace(value, ""));
+              const wValue = getTrimmingSpace(part.value);
+              value = prefix.concat(insertTrimmingSpace(value, ""));
               if (wValue)
                 value.unshift(wValue);
               if (part.type === "SpreadProperty") {
@@ -20712,43 +21061,6 @@ ${input.slice(result.pos)}
             };
         }
       };
-      module2.literalValue = function(literal) {
-        let { raw } = literal;
-        switch (raw) {
-          case "null":
-            return null;
-          case "true":
-            return true;
-          case "false":
-            return false;
-        }
-        if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
-          return raw.slice(1, -1);
-        }
-        const numeric = literal.children.find(
-          (child) => child.type === "NumericLiteral"
-        );
-        if (numeric) {
-          raw = raw.replace(/_/g, "");
-          const { token } = numeric;
-          if (token.endsWith("n")) {
-            return BigInt(raw.slice(0, -1));
-          } else if (token.match(/[\.eE]/)) {
-            return parseFloat(raw);
-          } else if (token.startsWith("0")) {
-            switch (token.charAt(1).toLowerCase()) {
-              case "x":
-                return parseInt(raw.replace(/0[xX]/, ""), 16);
-              case "b":
-                return parseInt(raw.replace(/0[bB]/, ""), 2);
-              case "o":
-                return parseInt(raw.replace(/0[oO]/, ""), 8);
-            }
-          }
-          return parseInt(raw, 10);
-        }
-        throw new Error("Unrecognized literal " + JSON.stringify(literal));
-      };
       module2.expressionizeIfClause = function(clause, b, e) {
         const children = clause.children.slice(1);
         children.push("?", b);
@@ -21088,16 +21400,16 @@ ${input.slice(result.pos)}
             }
             let children;
             if (op2.call) {
-              wsOp = module2.insertTrimmingSpace(wsOp, "");
+              wsOp = insertTrimmingSpace(wsOp, "");
               if (op2.reversed) {
-                wsB = module2.insertTrimmingSpace(wsB, "");
+                wsB = insertTrimmingSpace(wsB, "");
                 children = [wsOp, op2.call, "(", wsB, b, ", ", a, ")", op2.suffix];
               } else {
                 children = [wsOp, op2.call, "(", a, ",", wsB, b, ")", op2.suffix];
               }
             } else if (op2.method) {
-              wsOp = module2.insertTrimmingSpace(wsOp, "");
-              wsB = module2.insertTrimmingSpace(wsB, "");
+              wsOp = insertTrimmingSpace(wsOp, "");
+              wsB = insertTrimmingSpace(wsB, "");
               if (op2.reversed) {
                 children = [wsB, b, wsOp, ".", op2.method, "(", a, ")"];
               } else {
@@ -21207,39 +21519,6 @@ ${input.slice(result.pos)}
         }
         return target;
       };
-      module2.insertTrimmingSpace = function(target, c) {
-        if (!target)
-          return target;
-        if (Array.isArray(target))
-          return target.map((e, i) => {
-            if (i === 0)
-              return module2.insertTrimmingSpace(e, c);
-            return e;
-          });
-        if (target.children)
-          return Object.assign({}, target, {
-            children: target.children.map((e, i) => {
-              if (i === 0)
-                return module2.insertTrimmingSpace(e, c);
-              return e;
-            })
-          });
-        if (target.token)
-          return Object.assign({}, target, {
-            token: target.token.replace(/^ ?/, c)
-          });
-        return target;
-      };
-      module2.getTrimmingSpace = function(target) {
-        if (!target)
-          return;
-        if (Array.isArray(target))
-          return module2.getTrimmingSpace(target[0]);
-        if (target.children)
-          return module2.getTrimmingSpace(target.children[0]);
-        if (target.token)
-          return target.token.match(/^ ?/)[0];
-      };
       const initialSpacingRe = /^(?:\r?\n|\n)*((?:\r?\n|\n)\s+)/;
       module2.dedentBlockSubstitutions = function($02) {
         const [s, strWithSubstitutions, e] = $02;
@@ -21329,7 +21608,7 @@ ${input.slice(result.pos)}
             const spliceRef = module2.getRef("splice");
             blockPrefix = {
               type: "PostRestBindingElements",
-              children: ["[", module2.insertTrimmingSpace(after, ""), "] = ", spliceRef, ".call(", restIdentifier, ", -", after.length.toString(), ")"],
+              children: ["[", insertTrimmingSpace(after, ""), "] = ", spliceRef, ".call(", restIdentifier, ", -", after.length.toString(), ")"],
               names: after.flatMap((p) => p.names)
             };
           }
@@ -22713,13 +22992,20 @@ ${input.slice(result.pos)}
     var {
       clone,
       deepCopy,
+      forRange,
       gatherNodes,
       gatherRecursive,
       gatherRecursiveAll,
       gatherRecursiveWithinFunction,
+      getTrimmingSpace,
       hasAwait,
       hasYield,
+      insertTrimmingSpace,
       isFunction,
+      literalValue,
+      modifyString,
+      processCoffeeInterpolation,
+      quoteString,
       removeParentPointers
     } = require_lib();
   }