@danielx/civet 0.6.87 → 0.6.88

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

@@ -1712,7 +1712,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]);
         }
@@ -2320,6 +2324,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 +2438,7 @@ var Civet = (() => {
       init_util();
       init_function();
       init_binding();
+      init_lib();
     }
   });
 
@@ -3145,10 +3255,13 @@ 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,
@@ -3420,9 +3533,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 +3557,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 +3708,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 +7212,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 +7235,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$$);
       }
@@ -11350,28 +11499,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 +11541,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 +11561,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 +11580,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 +11635,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 +11646,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 +11838,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 +11863,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$$);
       }

package/dist/civet

@@ -6,6 +6,10 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -22,8 +26,17 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // source/cli.civet
+var cli_exports = {};
+__export(cli_exports, {
+  cli: () => cli,
+  parseArgs: () => parseArgs,
+  repl: () => repl,
+  version: () => version
+});
+module.exports = __toCommonJS(cli_exports);
 var import_main = require("./main.js");
 var import_config = require("./config.js");
 var import_unplugin = require("./unplugin");
@@ -244,6 +257,33 @@ async function* readFiles(filenames) {
   return results1;
 }
 async function repl(options) {
+  const vm = await import("vm");
+  let importModuleDynamically = vm.constants?.USE_MAIN_CONTEXT_DEFAULT_LOADER;
+  if (!importModuleDynamically) {
+    if (vm.SourceTextModule != null) {
+      const { pathToFileURL } = await import("url");
+      importModuleDynamically = (specifier) => {
+        if (/^\.\.?[/\\]/.test(specifier)) {
+          return import(pathToFileURL(import_path.default.join(process.cwd(), specifier)));
+        } else {
+          return import(specifier);
+        }
+      };
+    } else {
+      const execArgv = ["--experimental-vm-modules"];
+      const { register } = await import("module");
+      if (process.env.NODE_OPTIONS) {
+        execArgv.push(process.env.NODE_OPTIONS);
+      }
+      const { fork } = await import("child_process");
+      fork(__filename, process.argv.slice(2), {
+        execArgv,
+        stdio: "inherit"
+      });
+      return;
+    }
+  }
+  require("../register.js");
   console.log(`Civet ${version()} REPL.  Enter a blank line to ${(() => {
     switch (false) {
       case !options.ast: {
@@ -259,7 +299,6 @@ async function repl(options) {
   })()} code.`);
   global.quit = global.exit = () => process.exit(0);
   const nodeRepl = await import("repl");
-  const vm = await import("vm");
   const r = nodeRepl.start({
     prompt: (() => {
       switch (false) {
@@ -288,29 +327,66 @@ async function repl(options) {
         return "";
       }
     } : void 0,
-    eval: function(input, context, filename, callback) {
+    eval: async function(input, context, filename, callback) {
       if (input === "\n") {
         return callback(null, void 0);
       } else if (input in ["quit\n", "exit\n", "quit()\n", "exit()\n"]) {
         return process.exit(0);
       } else if (input.endsWith("\n\n")) {
         let output;
+        if (options.compile || options.ast) {
+          try {
+            output = (0, import_main.compile)(input, { ...options, filename });
+          } catch (error) {
+            console.error(error);
+            return callback(null, void 0);
+          }
+          return callback(null, output);
+        }
+        let ast = (0, import_main.compile)(input, { ...options, filename, ast: true });
+        const topLevelAwait = import_main.lib.gatherRecursive(
+          ast,
+          ($) => $.type === "Await",
+          import_main.lib.isFunction
+        ).length > 0;
+        if (topLevelAwait) {
+          const [prologue, rest] = (0, import_main.parse)(input, { startRule: "ProloguePrefix" });
+          const prefix = input.slice(0, -rest.length);
+          const coffee = prologue.some((p) => p.type === "CivetPrologue" && (p.config.coffeeCompat || p.config.coffeeDo));
+          ast = (0, import_main.compile)(
+            prefix + (coffee ? "(do ->\n" : "async do\n") + rest.replace(/^/gm, " ") + (coffee ? ")" : ""),
+            { ...options, filename, ast: true }
+          );
+        }
+        const errors = [];
         try {
-          output = (0, import_main.compile)(input, { ...options, filename });
+          output = (0, import_main.generate)(ast, { errors });
         } catch (error) {
           console.error(error);
           return callback(null, void 0);
         }
-        if (options.compile || options.ast) {
-          return callback(null, output);
-        } else {
-          let result;
+        if (errors.length) {
+          console.error(`Parse errors: ${errors.map(($1) => $1.message).join("\n")}`);
+          return callback(null, void 0);
+        }
+        let result;
+        try {
+          result = vm.runInContext(output, context, {
+            filename,
+            importModuleDynamically
+          });
+        } catch (error) {
+          return callback(error, void 0);
+        }
+        if (topLevelAwait) {
           try {
-            result = vm.runInContext(output, context, { filename });
+            result = await result;
           } catch (error) {
-            return callback(error, void 0);
+            callback(error, void 0);
           }
           return callback(null, result);
+        } else {
+          return callback(null, result);
         }
       } else {
         return callback(new nodeRepl.Recoverable(new Error("Enter a blank line to execute code.")), null);
@@ -451,7 +527,20 @@ async function cli() {
           }
         }
         const { fork } = await import("child_process");
-        const execArgv = ["--loader", "@danielx/civet/esm"];
+        const { register } = await import("module");
+        let execArgv;
+        if (register) {
+          execArgv = ["--import", "@danielx/civet/register"];
+        } else {
+          execArgv = [
+            "--loader",
+            "@danielx/civet/esm",
+            // ESM
+            "--require",
+            "@danielx/civet/register"
+            // CJS
+          ];
+        }
         const debugRe = /--debug|--inspect/;
         const isDebug = typeof v8debug === "object" || debugRe.test(process.execArgv.join(" ")) || debugRe.test(process.env.NODE_OPTIONS ?? "");
         if (process.env.NODE_OPTIONS) {
@@ -516,3 +605,10 @@ async function cli() {
 if (require.main === module) {
   cli();
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cli,
+  parseArgs,
+  repl,
+  version
+});

package/dist/esm.mjs

@@ -1,6 +1,5 @@
 // source/esm.civet
 import { readFileSync } from "fs";
-import { createRequire } from "module";
 import { pathToFileURL, fileURLToPath } from "url";
 import sourceMapSupport from "@cspotcode/source-map-support";
 import Civet from "./main.js";
@@ -72,16 +71,6 @@ async function load(url, context, next) {
   }
   return next(url, context);
 }
-var require2 = createRequire(import.meta.url);
-require2.extensions[".civet"] = function(m, filename) {
-  const source = readFileSync(filename, "utf8");
-  const code = compile(source, {
-    filename,
-    inlineMap: true,
-    js: true
-  });
-  return m._compile(code, filename);
-};
 export {
   load,
   resolve