@danielx/civet 0.6.87 → 0.6.89

package/dist/main.mjs

@@ -225,6 +225,9 @@ function hasAwait(exp) {
 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;
@@ -386,9 +389,10 @@ function parenthesizeType(type) {
   }
   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 ";
@@ -576,16 +580,16 @@ function blockWithPrefix(prefixStatements, block) {
       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;
@@ -595,8 +599,13 @@ function braceBlock(block) {
 }
 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,
@@ -1702,7 +1711,11 @@ function patternAsValue(pattern) {
     }
     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]);
       }
@@ -2009,8 +2022,7 @@ function expressionizeIteration(exp) {
     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;
   }
@@ -2310,6 +2322,111 @@ function processDeclarationConditionStatement(s, getRef) {
     }
   }
 }
+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";
@@ -2319,6 +2436,7 @@ var init_declaration = __esm({
     init_util();
     init_function();
     init_binding();
+    init_lib();
   }
 });
 
@@ -3135,21 +3253,28 @@ __export(lib_exports, {
   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,
@@ -3410,9 +3535,13 @@ function processCallMemberExpression(node) {
           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, ""));
         }
@@ -3430,13 +3559,13 @@ function processCallMemberExpression(node) {
         } 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,
@@ -3581,6 +3710,35 @@ function convertMethodToFunction(method) {
     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 = [];
@@ -7056,14 +7214,17 @@ var require_parser = __commonJS({
         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;
@@ -7076,7 +7237,7 @@ var require_parser = __commonJS({
       }
       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$$);
     }
@@ -8658,11 +8819,14 @@ var require_parser = __commonJS({
     });
     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];
@@ -11340,28 +11504,31 @@ var require_parser = __commonJS({
       };
     });
     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) {
@@ -11379,14 +11546,17 @@ var require_parser = __commonJS({
       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;
@@ -11396,11 +11566,14 @@ var require_parser = __commonJS({
       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) {
@@ -11412,17 +11585,32 @@ var require_parser = __commonJS({
       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);
     }
@@ -11452,8 +11640,10 @@ var require_parser = __commonJS({
       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
       };
@@ -11461,6 +11651,7 @@ var require_parser = __commonJS({
     var ImportSpecifier$1 = $TS($S(__, ImportedBinding, ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3) {
       var binding = $2;
       return {
+        source: binding,
         binding,
         children: $0
       };
@@ -11652,9 +11843,18 @@ var require_parser = __commonJS({
     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 {
@@ -11668,11 +11868,11 @@ var require_parser = __commonJS({
         };
       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$$);
     }
@@ -16414,10 +16614,13 @@ function compile(src, options) {
   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 }) {

package/dist/types.d.ts

@@ -32,8 +32,13 @@ declare module "@danielx/civet" {
   }>
   export type CompileOptions = {
     filename?: string
-    js?: boolean
     sourceMap?: boolean
+    inlineMap?: boolean
+    ast?: boolean | "raw"
+    js?: boolean
+    noCache?: boolean
+    hits?: string
+    trace?: string
     parseOptions?: ParseOptions
   }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@danielx/civet",
   "type": "commonjs",
-  "version": "0.6.87",
+  "version": "0.6.89",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
   "module": "dist/main.mjs",
@@ -75,7 +75,7 @@
     "@prettier/sync": "^0.3.0",
     "@types/assert": "^1.5.6",
     "@types/mocha": "^9.1.1",
-    "@types/node": "^20.5.1",
+    "@types/node": "^20.12.2",
     "c8": "^7.12.0",
     "esbuild": "0.20.0",
     "marked": "^4.2.4",

package/register.js

@@ -1,8 +1,16 @@
 /**
-@file Civet CJS registration
+@file Civet CJS and ESM registration
 
-`require`ing this file will register the `.civet` extension with
-Node.js's `require`.
+`import`ing this file in Node 20.6.0+ will register the `.civet` extension
+for both ESM `import`s and CJS `require`s.
+
+@example
+```bash
+node --import @danielx/civet/register source.civet
+```
+
+On older Node, `require`ing this file will register the `.civet` extension
+for CJS `require`s.
 
 @example
 ```bash
@@ -10,17 +18,25 @@ node -r @danielx/civet/register source.civet
 ```
 */
 
+try {
+  const { register } = require('node:module');
+  const { pathToFileURL } = require('node:url');
+
+  register('./dist/esm.mjs', pathToFileURL(__filename));
+} catch (e) {}
+
+// CJS registration
 if (require.extensions) {
   const fs = require("fs");
   const { compile } = require("./");
 
   require.extensions[".civet"] = function (module, filename) {
     const js = compile(fs.readFileSync(filename, 'utf8'), {
+      filename,
       js: true,
       inlineMap: true,
     });
     module._compile(js, filename);
-    return;
   };
 
   try {