@danielx/civet 0.6.34 → 0.6.36

package/dist/browser.js

@@ -526,23 +526,16 @@ ${input.slice(result.pos)}
         }
       }
       function addPostfixStatement(statement, ws, post) {
-        let children, expressions;
-        const prefix = post.blockPrefix || post.condition?.expression.blockPrefix;
-        if (prefix?.length) {
-          const indent = prefix[0][0];
-          expressions = [...prefix, [indent, statement]];
-          children = [" {\n", ...expressions, "\n", indent?.slice?.(0, -2), "}"];
-        } else {
-          expressions = [["", statement]];
-          children = [" { ", ...expressions, " }"];
-        }
+        const expressions = [
+          ...post.blockPrefix || [],
+          ["", statement]
+        ];
         const block = {
           type: "BlockStatement",
-          children,
+          children: [" { ", expressions, " }"],
           expressions
         };
-        children = [...post.children];
-        children.push(block);
+        const children = [...post.children, block];
         if (!isWhitespaceOrEmpty(ws))
           children.push(ws);
         post = { ...post, children, block };
@@ -1983,6 +1976,66 @@ ${input.slice(result.pos)}
         }
         return parts;
       }
+      function duplicateBlock(block) {
+        const expressions = [...block.expressions];
+        const children = [...block.children];
+        children.splice(children.indexOf(block.expressions), 1, expressions);
+        return {
+          ...block,
+          expressions,
+          children
+        };
+      }
+      function makeGetterMethod(name, ws, value, block, kind = { token: "get" }, autoReturn = true) {
+        const { token } = kind;
+        ws = insertTrimmingSpace(ws, "");
+        let setVal;
+        const parameters = token === "get" ? {
+          type: "Parameters",
+          children: ["()"],
+          names: [],
+          implicit: true
+        } : {
+          type: "Parameters",
+          children: ["(", setVal = makeRef("value"), ")"],
+          names: [],
+          implicit: false
+        };
+        let expressions;
+        if (block) {
+          block = duplicateBlock(block);
+          expressions = block.expressions;
+        } else {
+          expressions = [];
+          block = {
+            type: "BlockStatement",
+            expressions,
+            children: ["{ ", expressions, " }"]
+          };
+        }
+        if (autoReturn) {
+          const finalStatement = token === "get" ? [[expressions[0]?.[0] || "", ws], wrapWithReturn(value)] : [[expressions[0]?.[0] || "", ws], [value, " = ", setVal]];
+          expressions.push(finalStatement);
+        }
+        const children = [kind, " ", name, parameters, block];
+        return {
+          type: "MethodDefinition",
+          children,
+          name,
+          signature: {
+            type: "MethodSignature",
+            modifier: {
+              get: token === "get",
+              set: token === "set",
+              async: false
+            },
+            name,
+            returnType: void 0
+          },
+          block,
+          parameters
+        };
+      }
       function needsRef(expression, base = "ref") {
         switch (expression.type) {
           case "Ref":
@@ -2058,6 +2111,81 @@ ${input.slice(result.pos)}
           children
         };
       }
+      function processDeclarationCondition(condition) {
+        if (!(condition.type === "DeclarationCondition")) {
+          return;
+        }
+        const ref = makeRef();
+        const { decl, bindings } = condition.declaration;
+        const binding = bindings[0];
+        const { pattern, suffix, initializer, splices, thisAssignments } = binding;
+        const initCondition = {
+          type: "AssignmentExpression",
+          children: [ref, initializer],
+          hoistDec: {
+            type: "Declaration",
+            children: ["let ", ref, suffix],
+            names: []
+          },
+          blockPrefix: [
+            ["", [decl, pattern, suffix, " = ", ref, ...splices], ";"],
+            ...thisAssignments
+          ],
+          pattern,
+          ref
+        };
+        Object.assign(condition, initCondition);
+      }
+      function processDeclarationConditions(node) {
+        gatherRecursiveAll(node, (n) => {
+          return n.type === "IfStatement" || n.type === "IterationStatement";
+        }).forEach(processDeclarationConditionStatement);
+      }
+      function processDeclarationConditionStatement(s) {
+        const { condition } = s;
+        if (!condition) {
+          return;
+        }
+        processDeclarationCondition(condition.expression);
+        const { ref, pattern } = condition.expression;
+        if (pattern) {
+          let conditions = [];
+          getPatternConditions(pattern, ref, conditions);
+          conditions = conditions.filter((c) => {
+            return !(c.length === 3 && c[0] === "typeof " && c[1] === ref && c[2] === " === 'object'") && !(c.length === 2 && c[0] === ref && c[1] === " != null");
+          });
+          if (conditions.length) {
+            condition.children.unshift("(");
+            conditions.forEach(function(c) {
+              return condition.children.push(" && ", c);
+            });
+            condition.children.push(")");
+          }
+        }
+        switch (s.type) {
+          case "IfStatement": {
+            const { else: e } = s;
+            const block = blockWithPrefix(condition.expression.blockPrefix, s.then);
+            s.then = block;
+            const toAdd = [block];
+            if (block.bare && e) {
+              toAdd.push(";");
+            }
+            s.children.splice(2, 1, ...toAdd);
+            updateParentPointers(block, s);
+            break;
+          }
+          case "IterationStatement": {
+            const { children, block } = s;
+            const newBlock = blockWithPrefix(condition.expression.blockPrefix, block);
+            s.children = children.map(function(c) {
+              return c.type === "BlockStatement" ? newBlock : c;
+            });
+            updateParentPointers(newBlock, s);
+            break;
+          }
+        }
+      }
       function implicitFunctionBlock(f) {
         if (f.abstract || f.block || f.signature?.optional)
           return;
@@ -2731,6 +2859,7 @@ ${input.slice(result.pos)}
         assert.equal(m.JSXTagStack.length, 1, "JSXTagStack");
         addParentPointers(root);
         const { expressions: statements } = root;
+        processDeclarationConditions(statements);
         processPipelineExpressions(statements);
         processAssignments(statements);
         processPatternMatching(statements, ReservedWord);
@@ -3281,6 +3410,7 @@ ${input.slice(result.pos)}
         literalValue,
         makeAsConst,
         makeEmptyBlock,
+        makeGetterMethod,
         makeLeftHandSideExpression,
         makeRef,
         maybeRef,
@@ -3376,6 +3506,9 @@ ${input.slice(result.pos)}
         RHS,
         ParenthesizedAssignment,
         UnaryExpression,
+        UnaryWithoutParenthesizedAssignment,
+        UnaryBody,
+        UnaryWithoutParenthesizedAssignmentBody,
         UnaryPostfix,
         UpdateExpression,
         UpdateExpressionSymbol,
@@ -3432,6 +3565,7 @@ ${input.slice(result.pos)}
         OptionalDot,
         NonNullAssertion,
         MemberExpression,
+        MemberBase,
         MemberExpressionRest,
         MemberExpressionRestBody,
         MemberBracketContent,
@@ -4650,7 +4784,7 @@ ${input.slice(result.pos)}
       function ParenthesizedAssignment(ctx, state) {
         return $EVENT(ctx, state, "ParenthesizedAssignment", ParenthesizedAssignment$0);
       }
-      var UnaryExpression$0 = $TS($S($Q(UnaryOp), $C(UpdateExpression, NestedNonAssignmentExtendedExpression), $E(UnaryPostfix)), function($skip, $loc, $0, $1, $2, $3) {
+      var UnaryExpression$0 = $TS($S($Q(UnaryOp), UnaryBody, $E(UnaryPostfix)), function($skip, $loc, $0, $1, $2, $3) {
         var pre = $1;
         var exp = $2;
         var post = $3;
@@ -4666,6 +4800,30 @@ ${input.slice(result.pos)}
       function UnaryExpression(ctx, state) {
         return $EVENT_C(ctx, state, "UnaryExpression", UnaryExpression$$);
       }
+      var UnaryWithoutParenthesizedAssignment$0 = $TS($S($Q(UnaryOp), UnaryWithoutParenthesizedAssignmentBody, $E(UnaryPostfix)), function($skip, $loc, $0, $1, $2, $3) {
+        var pre = $1;
+        var exp = $2;
+        var post = $3;
+        return processUnaryExpression(pre, exp, post);
+      });
+      function UnaryWithoutParenthesizedAssignment(ctx, state) {
+        return $EVENT(ctx, state, "UnaryWithoutParenthesizedAssignment", UnaryWithoutParenthesizedAssignment$0);
+      }
+      var UnaryBody$0 = ParenthesizedAssignment;
+      var UnaryBody$1 = UpdateExpression;
+      var UnaryBody$2 = ExpressionizedStatementWithTrailingCallExpressions;
+      var UnaryBody$3 = NestedNonAssignmentExtendedExpression;
+      var UnaryBody$$ = [UnaryBody$0, UnaryBody$1, UnaryBody$2, UnaryBody$3];
+      function UnaryBody(ctx, state) {
+        return $EVENT_C(ctx, state, "UnaryBody", UnaryBody$$);
+      }
+      var UnaryWithoutParenthesizedAssignmentBody$0 = UpdateExpression;
+      var UnaryWithoutParenthesizedAssignmentBody$1 = ExpressionizedStatementWithTrailingCallExpressions;
+      var UnaryWithoutParenthesizedAssignmentBody$2 = NestedNonAssignmentExtendedExpression;
+      var UnaryWithoutParenthesizedAssignmentBody$$ = [UnaryWithoutParenthesizedAssignmentBody$0, UnaryWithoutParenthesizedAssignmentBody$1, UnaryWithoutParenthesizedAssignmentBody$2];
+      function UnaryWithoutParenthesizedAssignmentBody(ctx, state) {
+        return $EVENT_C(ctx, state, "UnaryWithoutParenthesizedAssignmentBody", UnaryWithoutParenthesizedAssignmentBody$$);
+      }
       var UnaryPostfix$0 = QuestionMark;
       var UnaryPostfix$1 = $T($P($S(__, $C(As, Satisfies), Type)), function(value) {
         return { "ts": true, "children": value };
@@ -4674,7 +4832,7 @@ ${input.slice(result.pos)}
       function UnaryPostfix(ctx, state) {
         return $EVENT_C(ctx, state, "UnaryPostfix", UnaryPostfix$$);
       }
-      var UpdateExpression$0 = $TS($S(UpdateExpressionSymbol, UnaryExpression), function($skip, $loc, $0, $1, $2) {
+      var UpdateExpression$0 = $TS($S(UpdateExpressionSymbol, UnaryWithoutParenthesizedAssignment), function($skip, $loc, $0, $1, $2) {
         return {
           type: "UpdateExpression",
           assigned: $2,
@@ -5067,10 +5225,22 @@ ${input.slice(result.pos)}
         return $EVENT(ctx, state, "NestedClassElement", NestedClassElement$0);
       }
       var ClassElement$0 = $TS($S($E(Decorators), $E(AccessModifier), $E($S(Static, $E(_))), ClassElementDefinition), function($skip, $loc, $0, $1, $2, $3, $4) {
+        var decorators = $1;
         var definition = $4;
+        if (definition.type === "ShorthandMethodDefinition") {
+          return {
+            ...definition,
+            children: definition.children.map((c) => {
+              return {
+                ...c,
+                children: [decorators, ...c.children]
+              };
+            })
+          };
+        }
         return {
           ...definition,
-          children: [$1, $2, $3, ...definition.children]
+          children: [decorators, $2, $3, ...definition.children]
         };
       });
       var ClassElement$1 = $TS($S(Static, BracedBlock), function($skip, $loc, $0, $1, $2) {
@@ -5180,7 +5350,14 @@ ${input.slice(result.pos)}
       var ThisLiteral$1 = $TS($S(AtThis, $TEXT($S($E(Hash), IdentifierName))), function($skip, $loc, $0, $1, $2) {
         var at = $1;
         var id = $2;
-        return [at, ".", id];
+        return {
+          type: "MemberExpression",
+          children: [at, {
+            type: "PropertyAccess",
+            name: id,
+            children: [".", id]
+          }]
+        };
       });
       var ThisLiteral$2 = AtThis;
       var ThisLiteral$3 = PrivateThis;
@@ -5194,7 +5371,14 @@ ${input.slice(result.pos)}
       });
       var PrivateThis$1 = $TV(PrivateIdentifier, function($skip, $loc, $0, $1) {
         var id = $0;
-        return ["this.", id];
+        return {
+          type: "MemberExpression",
+          children: ["this", {
+            type: "PropertyAccess",
+            name: id.name,
+            children: [".", id]
+          }]
+        };
       });
       var PrivateThis$$ = [PrivateThis$0, PrivateThis$1];
       function PrivateThis(ctx, state) {
@@ -5281,7 +5465,7 @@ ${input.slice(result.pos)}
       function NonNullAssertion(ctx, state) {
         return $EVENT(ctx, state, "NonNullAssertion", NonNullAssertion$0);
       }
-      var MemberExpression$0 = $TS($S($C(PrimaryExpression, SuperProperty, MetaProperty), $Q(MemberExpressionRest)), function($skip, $loc, $0, $1, $2) {
+      var MemberExpression$0 = $TS($S(MemberBase, $Q(MemberExpressionRest)), function($skip, $loc, $0, $1, $2) {
         var rest = $2;
         if (rest.length || Array.isArray($1)) {
           return processCallMemberExpression({
@@ -5294,6 +5478,13 @@ ${input.slice(result.pos)}
       function MemberExpression(ctx, state) {
         return $EVENT(ctx, state, "MemberExpression", MemberExpression$0);
       }
+      var MemberBase$0 = PrimaryExpression;
+      var MemberBase$1 = SuperProperty;
+      var MemberBase$2 = MetaProperty;
+      var MemberBase$$ = [MemberBase$0, MemberBase$1, MemberBase$2];
+      function MemberBase(ctx, state) {
+        return $EVENT_C(ctx, state, "MemberBase", MemberBase$$);
+      }
       var MemberExpressionRest$0 = $TS($S($Q(MultiLineComment), MemberExpressionRestBody), function($skip, $loc, $0, $1, $2) {
         var comments = $1;
         var body = $2;
@@ -5497,7 +5688,7 @@ ${input.slice(result.pos)}
       function PropertyAccess(ctx, state) {
         return $EVENT_C(ctx, state, "PropertyAccess", PropertyAccess$$);
       }
-      var PropertyGlob$0 = $TS($S(OptionalDot, $Q(MultiLineComment), BracedObjectLiteral), function($skip, $loc, $0, $1, $2, $3) {
+      var PropertyGlob$0 = $TS($S($S($E($C(QuestionMark, NonNullAssertion)), OptionalDot), $Q(MultiLineComment), BracedObjectLiteral), function($skip, $loc, $0, $1, $2, $3) {
         var dot = $1;
         var object = $3;
         return {
@@ -7303,7 +7494,76 @@ ${input.slice(result.pos)}
           parameters: signature.parameters
         };
       });
-      var MethodDefinition$$ = [MethodDefinition$0, MethodDefinition$1];
+      var MethodDefinition$2 = $TS($S(GetOrSet, $E(_), ForbidIndentedApplication, $E($S(MemberBase, $Q(CallExpressionRest))), RestoreIndentedApplication, $E(BracedBlock)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+        var kind = $1;
+        var ws = $2;
+        var value = $4;
+        var block = $6;
+        if (!value)
+          return $skip;
+        const rest = value[1];
+        if (!rest.length) {
+          const base = value[0];
+          let name2;
+          if (base.type === "MemberExpression") {
+            const lastAccess2 = lastAccessInCallExpression(base);
+            if (lastAccess2) {
+              ({ name: name2 } = lastAccess2);
+            }
+          }
+          if (!name2)
+            ({ name: name2 } = base);
+          if (!name2)
+            return $skip;
+          if (name2[0] === "#")
+            name2 = name2.slice(1);
+          const autoReturn = !block || base.type !== "Identifier";
+          return makeGetterMethod(name2, ws, base, block, kind, autoReturn);
+        }
+        let last = rest[rest.length - 1];
+        while (Array.isArray(last)) {
+          last = last[last.length - 1];
+        }
+        switch (last.type) {
+          case "Call":
+            return $skip;
+          case "PropertyAccess":
+            const { name: name2 } = last;
+            return makeGetterMethod(name2, ws, value, block, kind);
+          case "PropertyGlob":
+            return {
+              type: "ShorthandMethodDefinition",
+              children: last.object.properties.map((p) => {
+                const { name: name3, type } = p;
+                let v;
+                switch (type) {
+                  case "Identifier":
+                    v = insertTrimmingSpace(p, "");
+                    break;
+                  case "Property":
+                    v = insertTrimmingSpace(p.value, "");
+                    break;
+                }
+                const exp = processCallMemberExpression({
+                  type: "CallExpression",
+                  children: [value[0], ...value[1].slice(0, -1), {
+                    type: "PropertyAccess",
+                    children: [last.dot, {
+                      ...v,
+                      children: [v.children.slice(0, 2)]
+                      // Remove potential delimiter
+                    }]
+                  }]
+                });
+                return makeGetterMethod(name3, ws, exp, block, kind);
+              })
+            };
+        }
+        const lastAccess = lastAccessInCallExpression({ children: rest });
+        const { name } = lastAccess;
+        return makeGetterMethod(name, ws, value, block, kind);
+      });
+      var MethodDefinition$$ = [MethodDefinition$0, MethodDefinition$1, MethodDefinition$2];
       function MethodDefinition(ctx, state) {
         return $EVENT_C(ctx, state, "MethodDefinition", MethodDefinition$$);
       }
@@ -7389,13 +7649,14 @@ ${input.slice(result.pos)}
         return $EVENT_C(ctx, state, "ClassElementName", ClassElementName$$);
       }
       var PrivateIdentifier$0 = $TV($TEXT($S(Hash, IdentifierName)), function($skip, $loc, $0, $1) {
+        var id = $0;
         return {
           type: "Identifier",
-          name: $0,
-          names: [$0],
+          name: id,
+          names: [id],
           children: [{
             $loc,
-            token: $0
+            token: id
           }]
         };
       });
@@ -7904,16 +8165,10 @@ ${input.slice(result.pos)}
         var clause = $1;
         var block = $2;
         var e = $3;
-        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 {
-          ...clause,
-          children,
+          type: "IfStatement",
+          children: [...clause.children, block, e],
+          condition: clause.condition,
           then: block,
           else: e
         };
@@ -8136,7 +8391,6 @@ ${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 {
           ...clause,
           children: [...clause.children, block],
@@ -8755,27 +9009,13 @@ ${input.slice(result.pos)}
         return $EVENT_C(ctx, state, "Condition", Condition$$);
       }
       var DeclarationCondition$0 = $TS($S(ForbidIndentedApplication, $E(LexicalDeclaration), RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3) {
-        var dec = $2;
-        if (!dec)
+        var declaration = $2;
+        if (!declaration)
           return $skip;
-        const ref = makeRef();
-        const { decl, bindings } = dec;
-        const binding = bindings[0];
-        const { pattern, suffix, initializer, splices, thisAssignments } = binding;
-        const initCondition = {
-          type: "AssignmentExpression",
-          children: [ref, initializer],
-          hoistDec: {
-            type: "Declaration",
-            children: ["let ", ref, suffix],
-            names: []
-          },
-          blockPrefix: [
-            ["", [decl, pattern, suffix, " = ", ref, ...splices], ";"],
-            ...thisAssignments
-          ]
+        return {
+          type: "DeclarationCondition",
+          declaration
         };
-        return initCondition;
       });
       function DeclarationCondition(ctx, state) {
         return $EVENT(ctx, state, "DeclarationCondition", DeclarationCondition$0);
@@ -12431,6 +12671,9 @@ ${input.slice(result.pos)}
       exports.RHS = RHS;
       exports.ParenthesizedAssignment = ParenthesizedAssignment;
       exports.UnaryExpression = UnaryExpression;
+      exports.UnaryWithoutParenthesizedAssignment = UnaryWithoutParenthesizedAssignment;
+      exports.UnaryBody = UnaryBody;
+      exports.UnaryWithoutParenthesizedAssignmentBody = UnaryWithoutParenthesizedAssignmentBody;
       exports.UnaryPostfix = UnaryPostfix;
       exports.UpdateExpression = UpdateExpression;
       exports.UpdateExpressionSymbol = UpdateExpressionSymbol;
@@ -12487,6 +12730,7 @@ ${input.slice(result.pos)}
       exports.OptionalDot = OptionalDot;
       exports.NonNullAssertion = NonNullAssertion;
       exports.MemberExpression = MemberExpression;
+      exports.MemberBase = MemberBase;
       exports.MemberExpressionRest = MemberExpressionRest;
       exports.MemberExpressionRestBody = MemberExpressionRestBody;
       exports.MemberBracketContent = MemberBracketContent;
@@ -13083,6 +13327,7 @@ ${input.slice(result.pos)}
         lastAccessInCallExpression,
         literalValue,
         makeEmptyBlock,
+        makeGetterMethod,
         makeLeftHandSideExpression,
         makeRef,
         maybeRef,

package/dist/civet

@@ -64,7 +64,7 @@ encoding = "utf8";
 fs = require("fs/promises");
 path = require("path");
 parseArgs = function(args) {
-  var options, filenames, scriptArgs, i, endOfArgs, arg, char;
+  var options, filenames, scriptArgs, i, endOfArgs, arg;
   options = {};
   Object.defineProperty(options, "run", {
     get: function() {
@@ -90,6 +90,7 @@ parseArgs = function(args) {
     arg = args[i];
     if (/^-\w{2,}$/.test(arg)) {
       args.splice(i, 1 + i - i, ...(() => {
+        var char;
         const results = [];
         for (let ref = arg.slice(1), i1 = 0, len = ref.length; i1 < len; i1++) {
           char = ref[i1];
@@ -156,7 +157,7 @@ parseArgs = function(args) {
   return { filenames, scriptArgs, options };
 };
 readFiles = async function* (filenames, options) {
-  var filename, stdin, lines, rl, content, chunk;
+  var filename, stdin, lines, rl, content;
   const results1 = [];
   for (let i2 = 0, len1 = filenames.length; i2 < len1; i2++) {
     filename = filenames[i2];
@@ -185,6 +186,7 @@ readFiles = async function* (filenames, options) {
           });
         } else {
           content = (await (async () => {
+            var chunk;
             const results2 = [];
             for await (chunk of process.stdin) {
               results2.push(chunk);

package/dist/esbuild-plugin.js

@@ -127,10 +127,7 @@ function civet(options = {}) {
 }
 var defaultPlugin = civet();
 civet.setup = defaultPlugin.setup;
-if (typeof module !== "undefined") {
-  module.exports = civet;
-  module.exports.default = civet;
-}
 var esbuild_plugin_default = civet;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {});
+module.exports = module.exports.default;