@danielx/civet 0.5.84 → 0.5.86

package/dist/browser.js

@@ -129,16 +129,209 @@ var Civet = (() => {
       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]
+        };
+      }
       module.exports = {
         clone,
         deepCopy,
+        forRange,
         gatherNodes,
         gatherRecursive,
         gatherRecursiveAll,
         gatherRecursiveWithinFunction,
+        getTrimmingSpace,
         hasAwait,
         hasYield,
+        insertTrimmingSpace,
         isFunction,
+        literalValue,
+        modifyString,
+        processCoffeeInterpolation,
+        quoteString,
         removeParentPointers
       };
     }
@@ -705,6 +898,7 @@ ${input.slice(result.pos)}
         BracedContent,
         NestedBlockStatements,
         NestedBlockStatement,
+        BlockStatementPart,
         Literal,
         LiteralContent,
         NullLiteral,
@@ -782,6 +976,7 @@ ${input.slice(result.pos)}
         ElseExpressionBlock,
         NestedBlockExpressions,
         NestedBlockExpression,
+        BlockExpressionPart,
         IterationStatement,
         IterationExpression,
         LoopStatement,
@@ -798,6 +993,7 @@ ${input.slice(result.pos)}
         CoffeeForIndex,
         CoffeeForDeclaration,
         ForStatementParameters,
+        ForRangeParameters,
         ForInOfDeclaration,
         ForDeclaration,
         ForBinding,
@@ -1109,6 +1305,10 @@ ${input.slice(result.pos)}
         NestedTypeList,
         NestedType,
         TypeConditional,
+        TypeTemplateSubstitution,
+        TypeTemplateLiteral,
+        CoffeeStringTypeSubstitution,
+        CoffeeInterpolatedDoubleQuotedTypeLiteral,
         TypeLiteral,
         InlineInterfaceLiteral,
         InlineBasicInterfaceProperty,
@@ -1525,10 +1725,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) {
@@ -1551,10 +1748,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,
@@ -1785,7 +1982,7 @@ ${input.slice(result.pos)}
         if (args.length === 1 && args[0].type === "IterationExpression" && args[0].subtype !== "DoStatement" && !args[0].async && module.isEmptyBareBlock(args[0].block)) {
           return $skip;
         }
-        return [ta?.[0], open, module.insertTrimmingSpace(ws, ""), args, close];
+        return [ta?.[0], open, insertTrimmingSpace(ws, ""), args, close];
       });
       function ImplicitArguments(state) {
         let eventData;
@@ -1995,7 +2192,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 module.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) {
@@ -2025,7 +2222,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 module.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) {
@@ -2297,7 +2494,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 = module.insertTrimmingSpace(ws, "");
+        ws = insertTrimmingSpace(ws, "");
         return ["(", ...ws, exp, ")()"];
       });
       function UnaryExpression(state) {
@@ -4308,7 +4505,7 @@ ${input.slice(result.pos)}
           if (after.length) {
             const spliceRef = module.getRef("splice");
             blockPrefix = {
-              children: ["[", module.insertTrimmingSpace(after, ""), "] = ", spliceRef, ".call(", restIdentifier, ", -", after.length.toString(), ")"],
+              children: ["[", insertTrimmingSpace(after, ""), "] = ", spliceRef, ".call(", restIdentifier, ", -", after.length.toString(), ")"],
               names: after.flatMap((p) => p.names)
             };
           }
@@ -5816,7 +6013,7 @@ ${input.slice(result.pos)}
         var w = $2;
         var decl = $3;
         decl.names.forEach((name) => module.operators.add(name));
-        return [module.insertTrimmingSpace(w, ""), decl];
+        return [insertTrimmingSpace(w, ""), decl];
       });
       var OperatorDeclaration$1 = $TS($S(OperatorSignature, BracedBlock), function($skip, $loc, $0, $1, $2) {
         var signature = $1;
@@ -5872,7 +6069,7 @@ ${input.slice(result.pos)}
         if (!func) {
           func = { $loc: op.$loc, token: "function" };
         } else {
-          func = [module.insertTrimmingSpace(func[0], ""), func[1]];
+          func = [insertTrimmingSpace(func[0], ""), func[1]];
         }
         return {
           type: "FunctionSignature",
@@ -6532,6 +6729,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);
@@ -6568,15 +6766,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;
@@ -6600,6 +6796,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",
@@ -6900,8 +7127,8 @@ ${input.slice(result.pos)}
         const inclusive = range.token === "..";
         range.token = ",";
         if (s.type === "Literal" && e.type === "Literal") {
-          const start = module.literalValue(s);
-          const end = module.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");
           }
@@ -9204,6 +9431,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) {
@@ -9249,6 +9477,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) {
@@ -9322,7 +9551,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) {
@@ -9345,6 +9581,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];
@@ -9493,7 +9760,7 @@ ${input.slice(result.pos)}
       }
       var DoStatement$0 = $TS($S(Do, NoPostfixBracedBlock), function($skip, $loc, $0, $1, $2) {
         var block = $2;
-        block = module.insertTrimmingSpace(block, "");
+        block = insertTrimmingSpace(block, "");
         return {
           type: "DoStatement",
           children: [block],
@@ -9595,7 +9862,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,
@@ -9672,7 +9948,7 @@ ${input.slice(result.pos)}
               [indent, {
                 type: "IfStatement",
                 then: block,
-                children: ["if (!(", module.insertTrimmingSpace($3, ""), ")) ", block]
+                children: ["if (!(", insertTrimmingSpace($3, ""), ")) ", block]
               }]
             ]
           };
@@ -9727,7 +10003,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;
@@ -9737,8 +10013,8 @@ ${input.slice(result.pos)}
         var close = $9;
         let blockPrefix = [];
         const indent = module.currentIndent.token + "  ";
-        exp = module.insertTrimmingSpace(exp, "");
-        declaration = module.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");
@@ -9776,68 +10052,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 = module.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",
@@ -9848,11 +10064,11 @@ ${input.slice(result.pos)}
           const varRef = declaration;
           let increment = "++", indexAssignment, assignmentNames = [...varRef.names];
           if (index) {
-            index = module.insertTrimmingSpace(index, "");
+            index = insertTrimmingSpace(index, "");
             indexAssignment = [index, "="];
             assignmentNames.push(...index.names);
           }
-          const expRefDec = expRef !== exp ? [expRef, " = ", module.insertTrimmingSpace(exp, ""), ", "] : [];
+          const expRefDec = expRef !== exp ? [expRef, " = ", insertTrimmingSpace(exp, ""), ", "] : [];
           blockPrefix.push([indent, {
             type: "AssignmentExpression",
             children: [varRef, " = ", expRef, "[", indexAssignment, counterRef, "]\n"],
@@ -9866,7 +10082,7 @@ ${input.slice(result.pos)}
           let condition = [counterRef, " < ", lenRef, "; "];
           if (step) {
             let [stepWs, , stepExp] = step;
-            stepWs = module.insertTrimmingSpace(stepWs, "");
+            stepWs = insertTrimmingSpace(stepWs, "");
             if (stepExp.type === "Literal") {
               increment = [" +=", ...stepWs, stepExp];
               if (stepExp.raw[0] === "-") {
@@ -9898,6 +10114,7 @@ ${input.slice(result.pos)}
           blockPrefix
         };
       });
+      var CoffeeForStatementParameters$1 = ForRangeParameters;
       function CoffeeForStatementParameters(state) {
         let eventData;
         if (state.events) {
@@ -9909,12 +10126,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;
@@ -9924,7 +10141,7 @@ ${input.slice(result.pos)}
         var ws1 = $1;
         var ws2 = $3;
         var id = $4;
-        ws2 = module.insertTrimmingSpace(ws1, "");
+        ws2 = insertTrimmingSpace(ws1, "");
         return {
           ...id,
           children: [...ws1 || [], ...ws2 || [], ...id.children]
@@ -9998,20 +10215,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) {
@@ -10023,22 +10261,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
         };
       });
@@ -10066,12 +10341,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
         };
       });
@@ -10081,6 +10357,7 @@ ${input.slice(result.pos)}
         return {
           type: "ForDeclaration",
           children: [c, binding],
+          declare: c,
           names: binding.names
         };
       });
@@ -10407,9 +10684,9 @@ ${input.slice(result.pos)}
         if (!first)
           return $skip;
         const result = rest.map(([ws, _comma, exp, col]) => {
-          exp = module.insertTrimmingSpace(exp, "");
+          exp = insertTrimmingSpace(exp, "");
           if (ws.length)
-            return [module.insertTrimmingSpace("case ", ws), exp, col];
+            return [insertTrimmingSpace("case ", ws), exp, col];
           return ["case ", exp, col];
         });
         result.unshift(first);
@@ -10659,7 +10936,7 @@ ${input.slice(result.pos)}
         var close = $3;
         if (expression.type === "ParenthesizedExpression")
           return expression;
-        expression = module.insertTrimmingSpace(expression, "");
+        expression = insertTrimmingSpace(expression, "");
         return {
           type: "ParenthesizedExpression",
           children: [open, expression, close],
@@ -11640,7 +11917,7 @@ ${input.slice(result.pos)}
           ...spec,
           children: [
             ws,
-            module.insertTrimmingSpace(spec[0], ""),
+            insertTrimmingSpace(spec[0], ""),
             spec.children.slice(1)
           ]
         };
@@ -12700,7 +12977,7 @@ ${input.slice(result.pos)}
         var str = $2;
         return {
           type: "StringLiteral",
-          token: `"${module.modifyString(str.token)}"`,
+          token: `"${modifyString(str.token)}"`,
           $loc
         };
       });
@@ -12708,7 +12985,7 @@ ${input.slice(result.pos)}
         var str = $2;
         return {
           type: "StringLiteral",
-          token: `'${module.modifyString(str.token)}'`,
+          token: `'${modifyString(str.token)}'`,
           $loc
         };
       });
@@ -12861,24 +13138,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 ? `"${module.modifyString(parts[0].token)}"` : '""',
-            $loc
-          };
-        }
-        parts.forEach((part) => {
-          if (part.token) {
-            const str = part.token.replace(/(`|\$\{)/g, "\\$1");
-            part.token = module.modifyString(str);
-          }
-        });
-        s.token = e.token = "`";
-        return {
-          type: "TemplateLiteral",
-          children: [s, parts, e]
-        };
+        return processCoffeeInterpolation(s, parts, e, $loc);
       });
       function CoffeeInterpolatedDoubleQuotedString(state) {
         let eventData;
@@ -13718,7 +13978,7 @@ ${input.slice(result.pos)}
       }
       var Trimmed_$0 = $TV($Q(_), function($skip, $loc, $0, $1) {
         var ws = $0;
-        return module.insertTrimmingSpace(ws, "");
+        return insertTrimmingSpace(ws, "");
       });
       function Trimmed_(state) {
         let eventData;
@@ -16582,7 +16842,7 @@ ${input.slice(result.pos)}
               if (part.name.type === "ComputedPropertyName") {
                 rest.push(part);
               } else {
-                parts.push([part.name, "={", module.insertTrimmingSpace(part.value, ""), "}"]);
+                parts.push([part.name, "={", insertTrimmingSpace(part.value, ""), "}"]);
               }
               break;
             case "SpreadProperty":
@@ -16683,7 +16943,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 module.quoteString($0);
+        return quoteString($0);
       });
       var JSXShorthandString$1 = $TS($S(TemplateLiteral), function($skip, $loc, $0, $1) {
         return ["{", $1, "}"];
@@ -18783,7 +19043,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 };
@@ -19170,7 +19533,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var ThisType$0 = $T($S($C(This, AtThis), Colon, Type), function(value) {
+      var ThisType$0 = $T($S($C(This, AtThis), Colon, Type, ParameterElementDelimiter), function(value) {
         return { "type": "ThisType", "ts": true, "children": value };
       });
       function ThisType(state) {
@@ -20542,20 +20905,6 @@ ${input.slice(result.pos)}
             }
           }
         });
-        module.modifyString = function(str) {
-          return str.replace(/(^.?|[^\\]{2})(\\\\)*\n/g, "$1$2\\n");
-        };
-        module.unmodifyString = function(str) {
-          return str.replace(/\\n/g, "\n");
-        };
-        module.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;
@@ -20601,8 +20950,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 = module.getTrimmingSpace(part.value);
-                value = prefix.concat(module.insertTrimmingSpace(value, ""));
+                const wValue = getTrimmingSpace(part.value);
+                value = prefix.concat(insertTrimmingSpace(value, ""));
                 if (wValue)
                   value.unshift(wValue);
                 if (part.type === "SpreadProperty") {
@@ -20713,43 +21062,6 @@ ${input.slice(result.pos)}
               };
           }
         };
-        module.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));
-        };
         module.expressionizeIfClause = function(clause, b, e) {
           const children = clause.children.slice(1);
           children.push("?", b);
@@ -21089,16 +21401,16 @@ ${input.slice(result.pos)}
               }
               let children;
               if (op2.call) {
-                wsOp = module.insertTrimmingSpace(wsOp, "");
+                wsOp = insertTrimmingSpace(wsOp, "");
                 if (op2.reversed) {
-                  wsB = module.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 = module.insertTrimmingSpace(wsOp, "");
-                wsB = module.insertTrimmingSpace(wsB, "");
+                wsOp = insertTrimmingSpace(wsOp, "");
+                wsB = insertTrimmingSpace(wsB, "");
                 if (op2.reversed) {
                   children = [wsB, b, wsOp, ".", op2.method, "(", a, ")"];
                 } else {
@@ -21208,39 +21520,6 @@ ${input.slice(result.pos)}
           }
           return target;
         };
-        module.insertTrimmingSpace = function(target, c) {
-          if (!target)
-            return target;
-          if (Array.isArray(target))
-            return target.map((e, i) => {
-              if (i === 0)
-                return module.insertTrimmingSpace(e, c);
-              return e;
-            });
-          if (target.children)
-            return Object.assign({}, target, {
-              children: target.children.map((e, i) => {
-                if (i === 0)
-                  return module.insertTrimmingSpace(e, c);
-                return e;
-              })
-            });
-          if (target.token)
-            return Object.assign({}, target, {
-              token: target.token.replace(/^ ?/, c)
-            });
-          return target;
-        };
-        module.getTrimmingSpace = function(target) {
-          if (!target)
-            return;
-          if (Array.isArray(target))
-            return module.getTrimmingSpace(target[0]);
-          if (target.children)
-            return module.getTrimmingSpace(target.children[0]);
-          if (target.token)
-            return target.token.match(/^ ?/)[0];
-        };
         const initialSpacingRe = /^(?:\r?\n|\n)*((?:\r?\n|\n)\s+)/;
         module.dedentBlockSubstitutions = function($02) {
           const [s, strWithSubstitutions, e] = $02;
@@ -21330,7 +21609,7 @@ ${input.slice(result.pos)}
               const spliceRef = module.getRef("splice");
               blockPrefix = {
                 type: "PostRestBindingElements",
-                children: ["[", module.insertTrimmingSpace(after, ""), "] = ", spliceRef, ".call(", restIdentifier, ", -", after.length.toString(), ")"],
+                children: ["[", insertTrimmingSpace(after, ""), "] = ", spliceRef, ".call(", restIdentifier, ", -", after.length.toString(), ")"],
                 names: after.flatMap((p) => p.names)
               };
             }
@@ -22714,13 +22993,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();
     }