@danielx/civet 0.5.85 → 0.5.87

package/dist/main.mjs

@@ -28,6 +28,32 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var require_lib = __commonJS({
   "source/lib.js"(exports, module) {
     "use strict";
+    function blockWithPrefix(prefixStatements, block) {
+      if (prefixStatements && prefixStatements.length) {
+        const indent = getIndent(block.expressions[0]);
+        if (indent) {
+          prefixStatements = prefixStatements.map((statement) => [indent, ...statement.slice(1)]);
+        }
+        const expressions = [...prefixStatements, ...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", indent], ...block.children, "}"];
+          block.bare = false;
+        }
+      }
+      return block;
+    }
+    function closest(node, types) {
+      do {
+        if (types.includes(node.type)) {
+          return node;
+        }
+      } while (node = node.parent);
+    }
     function clone(node) {
       removeParentPointers(node);
       return deepCopy(node);
@@ -64,6 +90,14 @@ var require_lib = __commonJS({
         }
       }
     }
+    function findAncestor(node, predicate, stopPredicate) {
+      node = node.parent;
+      while (node && !stopPredicate?.(node)) {
+        if (predicate(node))
+          return node;
+        node = node.parent;
+      }
+    }
     function gatherNodes(node, predicate) {
       if (node == null)
         return [];
@@ -113,12 +147,39 @@ var require_lib = __commonJS({
       }
       return nodes;
     }
+    function getIndent(statement) {
+      let indent = statement?.[0];
+      if (Array.isArray(indent))
+        indent = indent[indent.length - 1];
+      return indent;
+    }
     function hasAwait(exp) {
       return gatherRecursiveWithinFunction(exp, ({ type }) => type === "Await").length > 0;
     }
     function hasYield(exp) {
       return gatherRecursiveWithinFunction(exp, ({ type }) => type === "Yield").length > 0;
     }
+    function hoistRefDecs(statements) {
+      gatherRecursiveAll(statements, (s) => s.hoistDec).forEach((node) => {
+        const { hoistDec } = node;
+        const outer = closest(node, ["IfStatement", "IterationStatement"]);
+        if (!outer) {
+          node.children.push({
+            type: "Error",
+            message: "Can't hoist declarations inside expressions yet."
+          });
+          return;
+        }
+        const block = outer.parent;
+        const { expressions } = block;
+        const index = expressions.indexOf(outer);
+        const indent = getIndent(outer);
+        if (indent)
+          hoistDec[0][0] = indent;
+        expressions.splice(index, 0, hoistDec);
+        node.hoistDec = null;
+      });
+    }
     function isFunction(node) {
       const { type } = node;
       return type === "FunctionExpression" || type === "ArrowFunction" || type === "MethodDefinition" || node.async;
@@ -259,13 +320,6 @@ var require_lib = __commonJS({
         }
       } else if (forDeclaration) {
         varAssign = varLetAssign = [forDeclaration, " = "];
-        blockPrefix = [
-          ["", {
-            type: "AssignmentExpression",
-            children: [],
-            names: forDeclaration.names
-          }]
-        ];
       }
       const declaration = {
         type: "Declaration",
@@ -281,6 +335,34 @@ var require_lib = __commonJS({
         blockPrefix
       };
     }
+    function gatherBindingCode(statements, opts) {
+      const thisAssignments = [];
+      const splices = [];
+      function insertRestSplices(s, p, thisAssignments2) {
+        gatherRecursiveAll(s, (n) => n.blockPrefix || opts?.injectParamProps && n.accessModifier || n.type === "AtBinding").forEach((n) => {
+          if (n.type === "AtBinding") {
+            const { ref } = n, { id } = ref;
+            thisAssignments2.push([`this.${id} = `, ref]);
+            return;
+          }
+          if (opts?.injectParamProps && n.type === "Parameter" && n.accessModifier) {
+            n.names.forEach((id) => {
+              thisAssignments2.push({
+                type: "AssignmentExpression",
+                children: [`this.${id} = `, id],
+                js: true
+              });
+            });
+            return;
+          }
+          const { blockPrefix } = n;
+          p.push(blockPrefix);
+          insertRestSplices(blockPrefix, p, thisAssignments2);
+        });
+      }
+      insertRestSplices(statements, splices, thisAssignments);
+      return [splices, thisAssignments];
+    }
     function modifyString(str) {
       return str.replace(/(^.?|[^\\]{2})(\\\\)*\n/g, "$1$2\\n");
     }
@@ -312,22 +394,93 @@ var require_lib = __commonJS({
         children: [s, parts, e]
       };
     }
+    function processConstAssignmentDeclaration(c, id, suffix, ws, ca, e) {
+      c = {
+        ...c,
+        $loc: {
+          pos: ca.$loc.pos - 1,
+          length: ca.$loc.length + 1
+        }
+      };
+      let exp;
+      if (e.type === "FunctionExpression") {
+        exp = e;
+      } else {
+        exp = e[1];
+      }
+      if (exp?.children?.[0]?.token?.match(/^\s+$/))
+        exp.children.shift();
+      if (id.type === "Identifier" && exp?.type === "FunctionExpression" && !exp.id) {
+        const i = exp.children.findIndex((c2) => c2?.token === "function") + 1;
+        exp = {
+          ...exp,
+          children: [...exp.children.slice(0, i), " ", id, suffix, ws, ...exp.children.slice(i)]
+        };
+        return {
+          type: "Declaration",
+          children: [exp],
+          names: id.names
+        };
+      }
+      let [splices, thisAssignments] = gatherBindingCode(id);
+      splices = splices.map((s) => [", ", s]);
+      thisAssignments = thisAssignments.map((a) => [";", a]);
+      const binding = [c, id, suffix, ...ws];
+      const initializer = [ca, e, ...splices, ...thisAssignments];
+      const children = [binding, initializer];
+      return {
+        type: "Declaration",
+        names: id.names,
+        children,
+        binding,
+        initializer
+      };
+    }
+    function processLetAssignmentDeclaration(l, id, suffix, ws, la, e) {
+      l = {
+        ...l,
+        $loc: {
+          pos: la.$loc.pos - 1,
+          length: la.$loc.length + 1
+        }
+      };
+      let [splices, thisAssignments] = gatherBindingCode(id);
+      splices = splices.map((s) => [", ", s]);
+      thisAssignments = thisAssignments.map((a) => [";", a]);
+      const binding = [l, id, suffix, ...ws];
+      const initializer = [la, e, ...splices, ...thisAssignments];
+      const children = [binding, initializer];
+      return {
+        type: "Declaration",
+        names: id.names,
+        children,
+        binding,
+        initializer
+      };
+    }
     module.exports = {
+      blockWithPrefix,
       clone,
       deepCopy,
+      findAncestor,
       forRange,
+      gatherBindingCode,
       gatherNodes,
       gatherRecursive,
       gatherRecursiveAll,
       gatherRecursiveWithinFunction,
+      getIndent,
       getTrimmingSpace,
       hasAwait,
       hasYield,
+      hoistRefDecs,
       insertTrimmingSpace,
       isFunction,
       literalValue,
       modifyString,
       processCoffeeInterpolation,
+      processConstAssignmentDeclaration,
+      processLetAssignmentDeclaration,
       quoteString,
       removeParentPointers
     };
@@ -1010,6 +1163,7 @@ ${input.slice(result.pos)}
       FinallyClause,
       CatchParameter,
       Condition,
+      DeclarationCondition,
       ExpressionWithIndentedApplicationForbidden,
       ForbidClassImplicitCall,
       AllowClassImplicitCall,
@@ -1624,7 +1778,12 @@ ${input.slice(result.pos)}
     var $R65 = $R(new RegExp("[ \\t]*", "suy"));
     var Program$0 = $TS($S(Reset, Init, $E(EOS), TopLevelStatements, __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       var statements = $4;
-      module.processProgram(statements);
+      module.processProgram({
+        type: "BlockStatement",
+        expressions: statements,
+        children: [statements],
+        bare: true
+      });
       return $0;
     });
     function Program(state) {
@@ -9231,16 +9390,18 @@ ${input.slice(result.pos)}
       var clause = $1;
       var block = $2;
       var e = $3;
-      const children = [...clause.children, block];
+      const children = [...clause.children];
+      block = blockWithPrefix(clause.condition.expression.blockPrefix, block);
+      children.push(block);
       if (block.bare && e)
         children.push(";");
       if (e)
         children.push(e);
       return {
-        type: "IfStatement",
+        ...clause,
+        children,
         then: block,
-        else: e,
-        children
+        else: e
       };
     });
     function IfStatement(state) {
@@ -9289,8 +9450,13 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var IfClause$0 = $T($S(If, Condition), function(value) {
-      return { "type": "IfStatement", "children": value };
+    var IfClause$0 = $TS($S(If, Condition), function($skip, $loc, $0, $1, $2) {
+      var condition = $2;
+      return {
+        type: "IfStatement",
+        children: $0,
+        condition
+      };
     });
     function IfClause(state) {
       let eventData;
@@ -9320,7 +9486,8 @@ ${input.slice(result.pos)}
       kind = { ...kind, token: "if" };
       return {
         type: "IfStatement",
-        children: [kind, ["(!", condition, ")"]]
+        children: [kind, ["(!", condition, ")"]],
+        condition
       };
     });
     function UnlessClause(state) {
@@ -9789,8 +9956,9 @@ ${input.slice(result.pos)}
     var WhileStatement$0 = $TS($S(WhileClause, Block), function($skip, $loc, $0, $1, $2) {
       var clause = $1;
       var block = $2;
+      block = blockWithPrefix(clause.condition.expression.blockPrefix, block);
       return {
-        type: "IterationStatement",
+        ...clause,
         children: [...clause.children, block],
         block
       };
@@ -9820,17 +9988,19 @@ ${input.slice(result.pos)}
     var WhileClause$0 = $TS($S($C(While, Until), $E(_), Condition), function($skip, $loc, $0, $1, $2, $3) {
       var kind = $1;
       var ws = $2;
-      var cond = $3;
+      var condition = $3;
       if (kind.token === "until") {
         kind.token = "while";
         return {
           type: "IterationStatement",
-          children: [kind, ...ws, ["(!", ...cond.children, ")"]]
+          children: [kind, ...ws, ["(!", ...condition.children, ")"]],
+          condition
         };
       }
       return {
         type: "IterationStatement",
-        children: [kind, ...ws, ...cond.children]
+        children: [kind, ...ws, ...condition.children],
+        condition
       };
     });
     function WhileClause(state) {
@@ -9858,18 +10028,7 @@ ${input.slice(result.pos)}
     var ForStatement$0 = $TS($S(ForClause, Block), function($skip, $loc, $0, $1, $2) {
       var clause = $1;
       var block = $2;
-      if (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;
-        }
-      }
+      block = blockWithPrefix(clause.blockPrefix, block);
       return {
         ...clause,
         children: [...clause.children, block],
@@ -10924,10 +11083,31 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var Condition$0 = $T($S(ParenthesizedExpression, $N($S($E(_), $C(BinaryOp, AssignmentOp, Dot, QuestionMark))), $N($S(_, OperatorAssignmentOp))), function(value) {
+    var Condition$0 = $TS($S(OpenParen, $E(_), DeclarationCondition, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var open = $1;
+      var ws = $2;
+      var expression = $3;
+      var close = $4;
+      return {
+        type: "ParenthesizedExpression",
+        children: [open, ws, expression, close],
+        expression
+      };
+    });
+    var Condition$1 = $T($S(ParenthesizedExpression, $N($S($E(_), $C(BinaryOp, AssignmentOp, Dot, QuestionMark))), $N($S(_, OperatorAssignmentOp))), function(value) {
       return value[0];
     });
-    var Condition$1 = $TS($S(InsertOpenParen, ExpressionWithIndentedApplicationForbidden, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3) {
+    var Condition$2 = $TS($S(InsertOpenParen, DeclarationCondition, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3) {
+      var open = $1;
+      var expression = $2;
+      var close = $3;
+      return {
+        type: "ParenthesizedExpression",
+        children: [open, expression, close],
+        expression
+      };
+    });
+    var Condition$3 = $TS($S(InsertOpenParen, ExpressionWithIndentedApplicationForbidden, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3) {
       var open = $1;
       var expression = $2;
       var close = $3;
@@ -10951,17 +11131,54 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("Condition", state, Condition$0(state) || Condition$1(state));
+        const result = $TOKEN("Condition", state, Condition$0(state) || Condition$1(state) || Condition$2(state) || Condition$3(state));
         if (state.events)
           state.events.exit?.("Condition", state, result, eventData);
         return result;
       } else {
-        const result = Condition$0(state) || Condition$1(state);
+        const result = Condition$0(state) || Condition$1(state) || Condition$2(state) || Condition$3(state);
         if (state.events)
           state.events.exit?.("Condition", state, result, eventData);
         return result;
       }
     }
+    var DeclarationCondition$0 = $TV(LexicalDeclaration, function($skip, $loc, $0, $1) {
+      var dec = $0;
+      const ref = {
+        type: "Ref",
+        base: "ref"
+      };
+      const { binding, initializer } = dec;
+      const initCondition = {
+        type: "AssignmentExpression",
+        children: [ref, " ", initializer],
+        hoistDec: [["", ["let ", ref], ";\n"]],
+        blockPrefix: [["", [binding, "= ", ref], ";\n"]]
+      };
+      return initCondition;
+    });
+    function DeclarationCondition(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("DeclarationCondition", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("DeclarationCondition", state, DeclarationCondition$0(state));
+        if (state.events)
+          state.events.exit?.("DeclarationCondition", state, result, eventData);
+        return result;
+      } else {
+        const result = DeclarationCondition$0(state);
+        if (state.events)
+          state.events.exit?.("DeclarationCondition", state, result, eventData);
+        return result;
+      }
+    }
     var ExpressionWithIndentedApplicationForbidden$0 = $TS($S(ForbidIndentedApplication, $E(ExtendedExpression), RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3) {
       var exp = $2;
       if (exp)
@@ -12390,48 +12607,7 @@ ${input.slice(result.pos)}
       };
     });
     var LexicalDeclaration$1 = $TS($S(InsertConst, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
-      var c = $1;
-      var id = $2;
-      var suffix = $3;
-      var ws = $4;
-      var ca = $5;
-      var e = $6;
-      c = {
-        ...c,
-        $loc: {
-          pos: ca.$loc.pos - 1,
-          length: ca.$loc.length + 1
-        }
-      };
-      let exp;
-      if (e.type === "FunctionExpression") {
-        exp = e;
-      } else {
-        exp = e[1];
-      }
-      if (exp?.children?.[0]?.token?.match(/^\s+$/))
-        exp.children.shift();
-      if (id.type === "Identifier" && exp?.type === "FunctionExpression" && !exp.id) {
-        const i = exp.children.findIndex((c2) => c2?.token === "function") + 1;
-        exp = {
-          ...exp,
-          children: [...exp.children.slice(0, i), " ", id, $3, $4, ...exp.children.slice(i)]
-        };
-        return {
-          type: "Declaration",
-          children: [exp],
-          names: id.names
-        };
-      }
-      let [splices, thisAssignments] = module.gatherBindingCode(id);
-      splices = splices.map((s) => [", ", s]);
-      thisAssignments = thisAssignments.map((a) => [";", a]);
-      const children = [c, id, suffix, ...ws, ca, e, ...splices, ...thisAssignments];
-      return {
-        type: "Declaration",
-        names: id.names,
-        children
-      };
+      return processConstAssignmentDeclaration(...$0);
     });
     var LexicalDeclaration$2 = $TS($S(InsertLet, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, LetAssignment, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
       var l = $1;
@@ -12440,22 +12616,7 @@ ${input.slice(result.pos)}
       var ws = $4;
       var la = $5;
       var e = $6;
-      l = {
-        ...l,
-        $loc: {
-          pos: la.$loc.pos - 1,
-          length: la.$loc.length + 1
-        }
-      };
-      let [splices, thisAssignments] = module.gatherBindingCode(id);
-      splices = splices.map((s) => [", ", s]);
-      thisAssignments = thisAssignments.map((a) => [";", a]);
-      const children = [l, id, suffix, ...ws, la, e, ...splices, ...thisAssignments];
-      return {
-        type: "Declaration",
-        names: id.names,
-        children
-      };
+      return processLetAssignmentDeclaration(...$0);
     });
     function LexicalDeclaration(state) {
       let eventData;
@@ -14600,7 +14761,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var Colon$0 = $TV($EXPECT($L32, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
+    var Colon$0 = $TS($S($EXPECT($L32, fail, 'Colon ":"'), $N($EXPECT($L2, fail, 'Colon "="'))), function($skip, $loc, $0, $1, $2) {
       return { $loc, token: $1 };
     });
     function Colon(state) {
@@ -19530,7 +19691,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) {
@@ -21010,9 +21171,14 @@ ${input.slice(result.pos)}
                 children: [...pre, ...exp.children, post]
               };
             default:
+              const expression = {
+                ...exp,
+                children: [...pre, "(", exp.children, ")", post]
+              };
               return {
                 type: "ParenthesizedExpression",
-                children: ["(", ...pre, "(", exp, ")", post, ")"]
+                children: ["(", expression, ")"],
+                expression
               };
           }
         }
@@ -21253,12 +21419,6 @@ ${input.slice(result.pos)}
             return;
         }
       }
-      function getIndent(statement) {
-        let indent = statement?.[0];
-        if (Array.isArray(indent))
-          indent = indent[indent.length - 1];
-        return indent;
-      }
       function insertReturn(node) {
         if (!node)
           return;
@@ -21687,14 +21847,6 @@ ${input.slice(result.pos)}
           }
         }
       }
-      function findAncestor(node, predicate, stopPredicate) {
-        node = node.parent;
-        while (node && !stopPredicate?.(node)) {
-          if (predicate(node))
-            return node;
-          node = node.parent;
-        }
-      }
       module.replaceNodes = (root, predicate, replacer) => {
         if (root == null)
           return root;
@@ -21861,7 +22013,7 @@ ${input.slice(result.pos)}
       }
       function processBindingPatternLHS(lhs, tail) {
         adjustAtBindings(lhs, true);
-        const [splices, thisAssignments] = module.gatherBindingCode(lhs);
+        const [splices, thisAssignments] = gatherBindingCode(lhs);
         tail.push(...splices.map((s) => [", ", s]), ...thisAssignments.map((a) => [", ", a]));
       }
       function processAssignments(statements) {
@@ -22451,14 +22603,16 @@ ${input.slice(result.pos)}
           addParentPointers(s, s.parent);
         });
       }
-      module.processProgram = function(statements) {
-        addParentPointers(statements);
+      module.processProgram = function(root) {
+        addParentPointers(root);
+        const { expressions: statements } = root;
         processPipelineExpressions(statements);
         processAssignments(statements);
         processPatternMatching(statements);
         processFunctions(statements);
         processSwitchExpressions(statements);
         processTryExpressions(statements);
+        hoistRefDecs(statements);
         gatherRecursiveAll(statements, (n) => n.type === "IterationExpression").forEach((e) => expressionizeIteration(e));
         checkSpliceRef(statements);
         statements.unshift(...module.prelude);
@@ -22618,35 +22772,6 @@ ${input.slice(result.pos)}
         scopes.pop();
         statements.splice(0, statements.length, targetStatements);
       }
-      function gatherBindingCode(statements, opts) {
-        const thisAssignments = [];
-        const splices = [];
-        function insertRestSplices(s, p, thisAssignments2) {
-          gatherRecursiveAll(s, (n) => n.blockPrefix || opts?.injectParamProps && n.accessModifier || n.type === "AtBinding").forEach((n) => {
-            if (n.type === "AtBinding") {
-              const { ref } = n, { id } = ref;
-              thisAssignments2.push([`this.${id} = `, ref]);
-              return;
-            }
-            if (opts?.injectParamProps && n.type === "Parameter" && n.accessModifier) {
-              n.names.forEach((id) => {
-                thisAssignments2.push({
-                  type: "AssignmentExpression",
-                  children: [`this.${id} = `, id],
-                  js: true
-                });
-              });
-              return;
-            }
-            const { blockPrefix } = n;
-            p.push(blockPrefix);
-            insertRestSplices(blockPrefix, p, thisAssignments2);
-          });
-        }
-        insertRestSplices(statements, splices, thisAssignments);
-        return [splices, thisAssignments];
-      }
-      module.gatherBindingCode = gatherBindingCode;
       module.constructInvocation = function(fn, arg) {
         const fnArr = [fn.leadingComment, fn.expr, fn.trailingComment];
         let expr = fn.expr;
@@ -22988,21 +23113,28 @@ ${input.slice(result.pos)}
     exports.parse = parse2;
     exports.default = { parse: parse2 };
     var {
+      blockWithPrefix,
       clone,
       deepCopy,
+      findAncestor,
       forRange,
+      gatherBindingCode,
       gatherNodes,
       gatherRecursive,
       gatherRecursiveAll,
       gatherRecursiveWithinFunction,
+      getIndent,
       getTrimmingSpace,
       hasAwait,
       hasYield,
+      hoistRefDecs,
       insertTrimmingSpace,
       isFunction,
       literalValue,
       modifyString,
       processCoffeeInterpolation,
+      processConstAssignmentDeclaration,
+      processLetAssignmentDeclaration,
       quoteString,
       removeParentPointers
     } = require_lib();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielx/civet",
-  "version": "0.5.85",
+  "version": "0.5.87",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
   "module": "dist/main.mjs",