@danielx/civet 0.6.87 → 0.6.89

package/README.md

@@ -22,10 +22,9 @@ The modern way to write TypeScript.
   [esbuild](source/esbuild-plugin.civet),
   [Vite](https://github.com/edemaine/vite-plugin-civet),
   -->
+  [ESM/CJS loader](source/esm.civet),
   [Babel](source/babel-plugin.mjs),
   [Gulp](integration/gulp),
-  [ESM module resolution](source/esm.civet),
-  [CJS](register.js),
   [Bun](source/bun-civet.civet)
 - Starter templates for [Solid](https://github.com/orenelbaum/solid-civet-template) and [Solid Start](https://github.com/orenelbaum/solid-start-civet-template)
 
@@ -43,8 +42,8 @@ civet -c
 civet < source.civet > output.ts
 # Execute a .civet script
 civet source.civet ...args...
-# Execute a .civet source file in node using ts-node
-node --loader ts-node/esm --loader @danielx/civet/esm source.civet
+# Execute a .civet source file in node
+node --import @danielx/civet/register source.civet
 ```
 
 ![image](https://user-images.githubusercontent.com/18894/184558519-b675a903-7490-43ba-883e-0d8addacd4b9.png)

package/dist/browser.js

@@ -235,6 +235,9 @@ var Civet = (() => {
   function hasYield(exp) {
     return gatherRecursiveWithinFunction(exp, ({ type }) => type === "Yield").length > 0;
   }
+  function hasImportDeclaration(exp) {
+    return gatherRecursiveWithinFunction(exp, ({ type }) => type === "ImportDeclaration").length > 0;
+  }
   function deepCopy(node) {
     if (node == null)
       return node;
@@ -396,9 +399,10 @@ var Civet = (() => {
     }
     return ["(", type, ")"];
   }
-  function wrapIIFE(expressions, async) {
+  function wrapIIFE(expressions, asyncFlag) {
     let prefix;
-    if (async) {
+    let async;
+    if (asyncFlag) {
       async = "async ";
     } else if (hasAwait(expressions)) {
       async = "async ";
@@ -586,16 +590,16 @@ var Civet = (() => {
         expressions,
         children: block.children === block.expressions ? expressions : block.children.map((c) => c === block.expressions ? expressions : c)
       };
-      if (block.bare) {
-        block.children = [[" {"], ...block.children, "}"];
-        block.bare = false;
-      }
+      braceBlock(block);
       updateParentPointers(block);
     }
     return block;
   }
   function braceBlock(block) {
     if (block.bare) {
+      if (block.children === block.expressions) {
+        block.children = [block.expressions];
+      }
       block.children.unshift(" {");
       block.children.push("}");
       return block.bare = false;
@@ -605,8 +609,13 @@ var Civet = (() => {
   }
   function duplicateBlock(block) {
     const expressions = [...block.expressions];
-    const children = [...block.children];
-    children.splice(children.indexOf(block.expressions), 1, expressions);
+    let children;
+    if (block.children === block.expressions) {
+      children = expressions;
+    } else {
+      children = [...block.children];
+      children.splice(children.indexOf(block.expressions), 1, expressions);
+    }
     return {
       ...block,
       expressions,
@@ -1712,7 +1721,11 @@ var Civet = (() => {
       }
       case "Identifier":
       case "BindingProperty": {
-        const children = [pattern.name, pattern.delim];
+        const children = [
+          // { name: value } = ... declares value, not name
+          pattern.value ?? pattern.name,
+          pattern.delim
+        ];
         if (isWhitespaceOrEmpty(pattern.children[0])) {
           children.unshift(pattern.children[0]);
         }
@@ -2019,8 +2032,7 @@ var Civet = (() => {
       throw new Error("Could not find iteration statement in iteration expression");
     }
     if (subtype === "DoStatement") {
-      insertReturn(block);
-      children.splice(i, 1, ...wrapIIFE(["", statement, void 0], async));
+      children.splice(i, 1, ...wrapIIFE([["", statement, void 0]], async));
       updateParentPointers(exp);
       return;
     }
@@ -2320,6 +2332,111 @@ var Civet = (() => {
       }
     }
   }
+  function dynamizeFromClause(from) {
+    from = from.slice(1);
+    from = insertTrimmingSpace(from, "");
+    if (from.at(-1)?.type === "ImportAssertion") {
+      const assert2 = from.pop();
+      from.push(", {", assert2.keyword, ":", assert2.object, "}");
+    }
+    return ["(", ...from, ")"];
+  }
+  function dynamizeImportDeclaration(decl) {
+    const { imports } = decl;
+    let { star, binding, specifiers } = imports;
+    const justDefault = binding && !specifiers && !star;
+    const pattern = (() => {
+      {
+        if (binding) {
+          if (specifiers) {
+            return makeRef();
+          } else {
+            return binding;
+          }
+        } else {
+          return convertNamedImportsToObject(imports, true);
+        }
+      }
+    })();
+    const c = "const";
+    const initializer = [
+      " = ",
+      justDefault ? "(" : void 0,
+      { type: "Await", children: ["await"] },
+      " ",
+      decl.children[0],
+      // import
+      dynamizeFromClause(decl.from),
+      justDefault ? ").default" : void 0
+    ];
+    const bindings = [{
+      type: "Binding",
+      names: pattern.names,
+      pattern,
+      initializer,
+      children: [pattern, initializer]
+    }];
+    if (binding && specifiers) {
+      const pattern2 = binding;
+      const initializer2 = [
+        " = ",
+        pattern,
+        ".default"
+      ];
+      bindings.push({
+        type: "Binding",
+        names: binding.names,
+        pattern: pattern2,
+        initializer: initializer2,
+        children: [pattern2, initializer2]
+      });
+      const pattern3 = convertNamedImportsToObject(imports.children.at(-1), true);
+      const initializer3 = [
+        " = ",
+        pattern
+      ];
+      bindings.push({
+        type: "Binding",
+        names: specifiers.names,
+        pattern: pattern3,
+        initializer: initializer3,
+        children: [pattern3, initializer3]
+      });
+    }
+    return {
+      type: "Declaration",
+      names: imports.names,
+      bindings,
+      decl: c,
+      children: [
+        c,
+        " ",
+        bindings.flatMap((binding2, i) => i > 0 ? [", ", binding2] : [binding2])
+      ]
+    };
+  }
+  function dynamizeImportDeclarationExpression($0) {
+    const [imp, ws1, named, ws2, from] = $0;
+    const object = convertNamedImportsToObject(named);
+    const dot = ".";
+    return processCallMemberExpression({
+      type: "CallExpression",
+      children: [
+        { type: "Await", children: "await" },
+        " ",
+        imp,
+        insertTrimmingSpace(ws2, ""),
+        dynamizeFromClause(from),
+        {
+          type: "PropertyGlob",
+          dot,
+          object,
+          children: [ws1, dot, object],
+          reversed: true
+        }
+      ]
+    });
+  }
   var init_declaration = __esm({
     "source/parser/declaration.civet"() {
       "use strict";
@@ -2329,6 +2446,7 @@ var Civet = (() => {
       init_util();
       init_function();
       init_binding();
+      init_lib();
     }
   });
 
@@ -3145,21 +3263,28 @@ var Civet = (() => {
     adjustIndexAccess: () => adjustIndexAccess,
     attachPostfixStatementAsExpression: () => attachPostfixStatementAsExpression,
     blockWithPrefix: () => blockWithPrefix,
+    convertNamedImportsToObject: () => convertNamedImportsToObject,
     convertObjectToJSXAttributes: () => convertObjectToJSXAttributes,
     dedentBlockString: () => dedentBlockString,
     dedentBlockSubstitutions: () => dedentBlockSubstitutions,
     deepCopy: () => deepCopy,
+    dynamizeImportDeclaration: () => dynamizeImportDeclaration,
+    dynamizeImportDeclarationExpression: () => dynamizeImportDeclarationExpression,
     expressionizeTypeIf: () => expressionizeTypeIf,
     forRange: () => forRange,
     gatherBindingCode: () => gatherBindingCode,
     gatherRecursive: () => gatherRecursive,
+    gatherRecursiveAll: () => gatherRecursiveAll,
+    gatherRecursiveWithinFunction: () => gatherRecursiveWithinFunction,
     getIndentLevel: () => getIndentLevel,
     getPrecedence: () => getPrecedence,
     getTrimmingSpace: () => getTrimmingSpace,
     hasAwait: () => hasAwait,
+    hasImportDeclaration: () => hasImportDeclaration,
     hasYield: () => hasYield,
     insertTrimmingSpace: () => insertTrimmingSpace,
     isEmptyBareBlock: () => isEmptyBareBlock,
+    isFunction: () => isFunction,
     isWhitespaceOrEmpty: () => isWhitespaceOrEmpty,
     lastAccessInCallExpression: () => lastAccessInCallExpression,
     literalValue: () => literalValue,
@@ -3420,9 +3545,13 @@ var Civet = (() => {
             throw new Error(`Glob pattern must have call or member expression value, found ${JSON.stringify(part.value)}`);
           }
           let suppressPrefix = false;
-          let value = part.value ?? part.name;
+          let name = part.name;
+          let value = part.value ?? name;
           const wValue = getTrimmingSpace(part.value);
           [value, suppressPrefix] = handleThisPrivateShorthands(value);
+          if (glob.reversed) {
+            [name, value] = [value, name];
+          }
           if (!suppressPrefix) {
             value = prefix.concat(insertTrimmingSpace(value, ""));
           }
@@ -3440,13 +3569,13 @@ var Civet = (() => {
           } else {
             parts.push({
               type: part.type === "Identifier" ? "Property" : part.type,
-              name: part.name,
+              name,
               value,
               delim: part.delim,
               names: part.names,
               children: [
                 isWhitespaceOrEmpty(part.children[0]) && part.children[0],
-                part.name,
+                name,
                 isWhitespaceOrEmpty(part.children[2]) && part.children[2],
                 part.children[3]?.token === ":" ? part.children[3] : ":",
                 value,
@@ -3591,6 +3720,35 @@ var Civet = (() => {
       block
     };
   }
+  function convertNamedImportsToObject(node, pattern) {
+    const properties = node.specifiers.map((specifier) => {
+      if (specifier.ts) {
+        return { type: "Error", message: "cannot use `type` in dynamic import" };
+      } else {
+        const { source, binding } = specifier;
+        const delim = specifier.children.at(-1);
+        return {
+          type: pattern ? "BindingProperty" : "Property",
+          name: source,
+          value: !(source === binding) ? binding : void 0,
+          delim,
+          children: source === binding ? [source, delim] : [source, ":", binding, delim]
+        };
+      }
+    });
+    return {
+      type: pattern ? "ObjectBindingPattern" : "ObjectExpression",
+      names: node.names,
+      properties,
+      children: [
+        node.children[0],
+        // {
+        properties,
+        node.children.at(-1)
+        // }
+      ]
+    };
+  }
   function convertObjectToJSXAttributes(obj) {
     const { properties } = obj;
     const parts = [];
@@ -7066,14 +7224,17 @@ ${input.slice(result.pos)}
           children: [$1, ...$2, ...rest.flat()]
         });
       });
-      var CallExpression$1 = $TS($S($EXPECT($L20, 'CallExpression "import"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
+      var CallExpression$1 = $TS($S(Import, _, NamedImports, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+        return dynamizeImportDeclarationExpression($0);
+      });
+      var CallExpression$2 = $TS($S($EXPECT($L20, 'CallExpression "import"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
         var rest = $3;
         return processCallMemberExpression({
           type: "CallExpression",
           children: [$1, ...$2, ...rest.flat()]
         });
       });
-      var CallExpression$2 = $TS($S(MemberExpression, AllowedTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
+      var CallExpression$3 = $TS($S(MemberExpression, AllowedTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
         var member = $1;
         var trailing = $2;
         var rest = $3;
@@ -7086,7 +7247,7 @@ ${input.slice(result.pos)}
         }
         return member;
       });
-      var CallExpression$$ = [CallExpression$0, CallExpression$1, CallExpression$2];
+      var CallExpression$$ = [CallExpression$0, CallExpression$1, CallExpression$2, CallExpression$3];
       function CallExpression(ctx, state) {
         return $EVENT_C(ctx, state, "CallExpression", CallExpression$$);
       }
@@ -8668,11 +8829,14 @@ ${input.slice(result.pos)}
       });
       var NonSingleBracedBlock$1 = ImplicitNestedBlock;
       var NonSingleBracedBlock$2 = $TS($S(InsertOpenBrace, NestedImplicitObjectLiteral, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3) {
+        var o = $1;
         var s = $2;
+        var c = $3;
+        const expressions = [s];
         return {
           type: "BlockStatement",
-          expressions: [s],
-          children: $0
+          expressions,
+          children: [o, expressions, c]
         };
       });
       var NonSingleBracedBlock$$ = [NonSingleBracedBlock$0, NonSingleBracedBlock$1, NonSingleBracedBlock$2];
@@ -11350,28 +11514,31 @@ ${input.slice(result.pos)}
         };
       });
       var ImportDeclaration$1 = $T($S(Import, __, TypeKeyword, __, ImportClause, __, FromClause), function(value) {
-        return { "type": "ImportDeclaration", "ts": true, "children": value };
+        var imports = value[4];
+        var from = value[6];
+        return { "type": "ImportDeclaration", "ts": true, "children": value, "imports": imports, "from": from };
       });
       var ImportDeclaration$2 = $T($S(Import, __, ImportClause, __, FromClause), function(value) {
-        return { "type": "ImportDeclaration", "children": value };
+        var imports = value[2];
+        var from = value[4];
+        return { "type": "ImportDeclaration", "children": value, "imports": imports, "from": from };
       });
       var ImportDeclaration$3 = $T($S(Import, __, ModuleSpecifier), function(value) {
-        return { "type": "ImportDeclaration", "children": value };
+        var module3 = value[2];
+        return { "type": "ImportDeclaration", "children": value, "module": module3 };
       });
       var ImportDeclaration$4 = $TS($S(ImpliedImport, $E($S(TypeKeyword, __)), ImportClause, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         var i = $1;
         var t = $2;
-        var c = $3;
+        var imports = $3;
         var w = $4;
-        var f = $5;
+        var from = $5;
         i.$loc = {
-          pos: f[0].$loc.pos - 1,
-          length: f[0].$loc.length + 1
+          pos: from[0].$loc.pos - 1,
+          length: from[0].$loc.length + 1
         };
-        const children = [i, t, c, w, f];
-        if (!t)
-          return children;
-        return { type: "ImportDeclaration", ts: true, children };
+        const children = [i, t, imports, w, from];
+        return { type: "ImportDeclaration", ts: !!t, children, imports, from };
       });
       var ImportDeclaration$$ = [ImportDeclaration$0, ImportDeclaration$1, ImportDeclaration$2, ImportDeclaration$3, ImportDeclaration$4];
       function ImportDeclaration(ctx, state) {
@@ -11389,14 +11556,17 @@ ${input.slice(result.pos)}
         if (rest) {
           return {
             type: "Declaration",
-            children: $0,
-            names: [...binding.names, ...rest[3].names]
+            children: [binding, ...rest],
+            names: [...binding.names, ...rest[3].names],
+            binding,
+            specifiers: rest[3].specifiers
           };
         }
         return {
           type: "Declaration",
-          children: $0,
-          names: binding.names
+          children: [binding],
+          names: binding.names,
+          binding
         };
       });
       var ImportClause$1 = NameSpaceImport;
@@ -11406,11 +11576,14 @@ ${input.slice(result.pos)}
         return $EVENT_C(ctx, state, "ImportClause", ImportClause$$);
       }
       var NameSpaceImport$0 = $TS($S(Star, ImportAsToken, __, ImportedBinding), function($skip, $loc, $0, $1, $2, $3, $4) {
+        var star = $1;
         var binding = $4;
         return {
           type: "Declaration",
           children: $0,
-          names: binding.names
+          names: binding.names,
+          binding,
+          star
         };
       });
       function NameSpaceImport(ctx, state) {
@@ -11422,17 +11595,32 @@ ${input.slice(result.pos)}
         return {
           type: "Declaration",
           children: $0,
-          names
+          names,
+          specifiers
         };
       });
       function NamedImports(ctx, state) {
         return $EVENT(ctx, state, "NamedImports", NamedImports$0);
       }
-      var FromClause$0 = $S(From, __, ModuleSpecifier);
+      var FromClause$0 = $TS($S(From, __, ModuleSpecifier), function($skip, $loc, $0, $1, $2, $3) {
+        var module3 = $3;
+        if (!Array.isArray(module3))
+          return $0;
+        return [$1, $2, ...module3];
+      });
       function FromClause(ctx, state) {
         return $EVENT(ctx, state, "FromClause", FromClause$0);
       }
-      var ImportAssertion$0 = $S($E(_), $C($EXPECT($L117, 'ImportAssertion "with"'), $EXPECT($L118, 'ImportAssertion "assert"')), NonIdContinue, $E(_), ObjectLiteral);
+      var ImportAssertion$0 = $TS($S($E(_), $C($EXPECT($L117, 'ImportAssertion "with"'), $EXPECT($L118, 'ImportAssertion "assert"')), NonIdContinue, $E(_), ObjectLiteral), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+        var keyword = $2;
+        var object = $5;
+        return {
+          type: "ImportAssertion",
+          keyword,
+          object,
+          children: $0
+        };
+      });
       function ImportAssertion(ctx, state) {
         return $EVENT(ctx, state, "ImportAssertion", ImportAssertion$0);
       }
@@ -11462,8 +11650,10 @@ ${input.slice(result.pos)}
         return $EVENT_C(ctx, state, "TypeAndImportSpecifier", TypeAndImportSpecifier$$);
       }
       var ImportSpecifier$0 = $TS($S(__, ModuleExportName, ImportAsToken, __, ImportedBinding, ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+        var source = $2;
         var binding = $5;
         return {
+          source,
           binding,
           children: $0
         };
@@ -11471,6 +11661,7 @@ ${input.slice(result.pos)}
       var ImportSpecifier$1 = $TS($S(__, ImportedBinding, ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3) {
         var binding = $2;
         return {
+          source: binding,
           binding,
           children: $0
         };
@@ -11662,9 +11853,18 @@ ${input.slice(result.pos)}
       function ImplicitExportSpecifier(ctx, state) {
         return $EVENT(ctx, state, "ImplicitExportSpecifier", ImplicitExportSpecifier$0);
       }
-      var Declaration$0 = HoistableDeclaration;
-      var Declaration$1 = ClassDeclaration;
-      var Declaration$2 = $TV(LexicalDeclaration, function($skip, $loc, $0, $1) {
+      var Declaration$0 = $TV(ImportDeclaration, function($skip, $loc, $0, $1) {
+        var decl = $0;
+        if (decl.ts || decl.module || !decl.imports || !decl.from)
+          return $skip;
+        const { imports } = decl;
+        if (!imports.binding && !imports.specifiers)
+          return $skip;
+        return dynamizeImportDeclaration(decl);
+      });
+      var Declaration$1 = HoistableDeclaration;
+      var Declaration$2 = ClassDeclaration;
+      var Declaration$3 = $TV(LexicalDeclaration, function($skip, $loc, $0, $1) {
         var d = $0;
         if (d.thisAssignments?.length)
           return {
@@ -11678,11 +11878,11 @@ ${input.slice(result.pos)}
           };
         return d;
       });
-      var Declaration$3 = TypeDeclaration;
-      var Declaration$4 = EnumDeclaration;
-      var Declaration$5 = OperatorDeclaration;
-      var Declaration$6 = UsingDeclaration;
-      var Declaration$$ = [Declaration$0, Declaration$1, Declaration$2, Declaration$3, Declaration$4, Declaration$5, Declaration$6];
+      var Declaration$4 = TypeDeclaration;
+      var Declaration$5 = EnumDeclaration;
+      var Declaration$6 = OperatorDeclaration;
+      var Declaration$7 = UsingDeclaration;
+      var Declaration$$ = [Declaration$0, Declaration$1, Declaration$2, Declaration$3, Declaration$4, Declaration$5, Declaration$6, Declaration$7];
       function Declaration(ctx, state) {
         return $EVENT_C(ctx, state, "Declaration", Declaration$$);
       }
@@ -16435,10 +16635,13 @@ ${input.slice(result.pos)}
     let ast;
     try {
       import_parser.parse.config = options.parseOptions || {};
-      ast = prune((0, import_parser.parse)(src, {
+      ast = (0, import_parser.parse)(src, {
         filename,
         events
-      }));
+      });
+      if (!(options.ast === "raw")) {
+        ast = prune(ast);
+      }
     } finally {
       if (hits || trace) {
         import("fs").then(function({ writeFileSync }) {