@danielx/civet 0.5.85 → 0.5.87

package/dist/browser.js

@@ -31,6 +31,32 @@ var Civet = (() => {
   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);
@@ -67,6 +93,14 @@ var Civet = (() => {
           }
         }
       }
+      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 [];
@@ -116,12 +150,39 @@ var Civet = (() => {
         }
         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;
@@ -262,13 +323,6 @@ var Civet = (() => {
           }
         } else if (forDeclaration) {
           varAssign = varLetAssign = [forDeclaration, " = "];
-          blockPrefix = [
-            ["", {
-              type: "AssignmentExpression",
-              children: [],
-              names: forDeclaration.names
-            }]
-          ];
         }
         const declaration = {
           type: "Declaration",
@@ -284,6 +338,34 @@ var Civet = (() => {
           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");
       }
@@ -315,22 +397,93 @@ var Civet = (() => {
           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
       };
@@ -1013,6 +1166,7 @@ ${input.slice(result.pos)}
         FinallyClause,
         CatchParameter,
         Condition,
+        DeclarationCondition,
         ExpressionWithIndentedApplicationForbidden,
         ForbidClassImplicitCall,
         AllowClassImplicitCall,
@@ -1627,7 +1781,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) {
@@ -9234,16 +9393,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) {
@@ -9292,8 +9453,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;
@@ -9323,7 +9489,8 @@ ${input.slice(result.pos)}
         kind = { ...kind, token: "if" };
         return {
           type: "IfStatement",
-          children: [kind, ["(!", condition, ")"]]
+          children: [kind, ["(!", condition, ")"]],
+          condition
         };
       });
       function UnlessClause(state) {
@@ -9792,8 +9959,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
         };
@@ -9823,17 +9991,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) {
@@ -9861,18 +10031,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],
@@ -10927,10 +11086,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;
@@ -10954,17 +11134,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)
@@ -12393,48 +12610,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;
@@ -12443,22 +12619,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;
@@ -14603,7 +14764,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) {
@@ -19533,7 +19694,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) {
@@ -21013,9 +21174,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
                 };
             }
           }
@@ -21256,12 +21422,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;
@@ -21690,14 +21850,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;
@@ -21864,7 +22016,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) {
@@ -22454,14 +22606,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);
@@ -22621,35 +22775,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;
@@ -22991,21 +23116,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();