@danielx/civet 0.5.33 → 0.5.35

package/dist/main.mjs

@@ -657,6 +657,7 @@ ${input.slice(result.pos)}
       FromClause,
       TypeAndImportSpecifier,
       ImportSpecifier,
+      ImportAsToken,
       ModuleExportName,
       ModuleSpecifier,
       UnprocessedModuleSpecifier,
@@ -879,6 +880,9 @@ ${input.slice(result.pos)}
       TypeBinaryOp,
       FunctionType,
       TypeArguments,
+      InlineTypeArguments,
+      InlineTypeArgument,
+      InlineTypeArgumentDelimiter,
       CompactTypeArguments,
       TypeArgument,
       TypeArgumentDelimiter,
@@ -922,6 +926,7 @@ ${input.slice(result.pos)}
       CoffeeLineContinuationEnabled,
       CoffeeNotEnabled,
       CoffeeOfEnabled,
+      CoffeePrototypeEnabled,
       Reset,
       Init,
       Indent,
@@ -1346,12 +1351,13 @@ ${input.slice(result.pos)}
       }
     }
     var Arguments$0 = ExplicitArguments;
-    var Arguments$1 = $TS($S(ApplicationStart, InsertOpenParen, $Q(_), ArgumentList, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
-      var open = $2;
-      var ws = $3;
-      var args = $4;
-      var close = $5;
-      return [open, module.insertTrimmingSpace(ws, ""), args, close];
+    var Arguments$1 = $TS($S($E($S(InlineTypeArguments, $N($S(__, ImplementsToken)))), ApplicationStart, InsertOpenParen, $Q(_), ArgumentList, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+      var ta = $1;
+      var open = $3;
+      var ws = $4;
+      var args = $5;
+      var close = $6;
+      return [ta?.[0], open, module.insertTrimmingSpace(ws, ""), args, close];
     });
     function Arguments(state) {
       let eventData;
@@ -3258,9 +3264,9 @@ ${input.slice(result.pos)}
         children
       };
     });
-    var PropertyAccess$1 = $TS($S(DoubleColon, $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
-      var p = $1;
-      var id = $2;
+    var PropertyAccess$1 = $TS($S(CoffeePrototypeEnabled, DoubleColon, $E(IdentifierName)), function($skip, $loc, $0, $1, $2, $3) {
+      var p = $2;
+      var id = $3;
       if (id) {
         p.token = ".prototype.";
         return [p, id];
@@ -7497,7 +7503,7 @@ ${input.slice(result.pos)}
             declaration = {
               type: "Declaration",
               children: ["let ", ...startRefDec, ...endRefDec, counterRef, " = ", varRef2, " = ", startRef, ...ascDec],
-              names: []
+              names: varRef2.names
             };
             blockPrefix.push(["", {
               type: "AssignmentExpression",
@@ -7628,11 +7634,12 @@ ${input.slice(result.pos)}
     var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L78, fail, 'CoffeeForDeclaration "own"'), NonIdContinue)), ForBinding), function($skip, $loc, $0, $1, $2) {
       var own = $1;
       var binding = $2;
-      if (own) {
-        binding.own = true;
-      }
-      binding.type = "AssignmentExpression";
-      return binding;
+      return {
+        type: "AssignmentExpression",
+        own: Boolean(own),
+        children: [$2],
+        names: $2.names
+      };
     });
     function CoffeeForDeclaration(state) {
       let eventData;
@@ -8656,8 +8663,8 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var NameSpaceImport$0 = $TS($S(Star, __, As, __, ImportedBinding), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
-      var binding = $5;
+    var NameSpaceImport$0 = $TS($S(Star, ImportAsToken, __, ImportedBinding), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var binding = $4;
       return {
         type: "Declaration",
         children: $0,
@@ -8767,8 +8774,8 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var ImportSpecifier$0 = $TS($S(__, ModuleExportName, __, As, __, ImportedBinding, ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
-      var binding = $6;
+    var ImportSpecifier$0 = $TS($S(__, ModuleExportName, ImportAsToken, __, ImportedBinding, ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+      var binding = $5;
       return {
         binding,
         children: $0
@@ -8803,6 +8810,44 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var ImportAsToken$0 = $S(__, As);
+    var ImportAsToken$1 = $TS($S(Loc, __, Colon, $E($EXPECT($L4, fail, 'ImportAsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var l = $1;
+      var ws = $2;
+      var c = $3;
+      const children = [
+        ...ws,
+        { ...c, token: "as " }
+      ];
+      if (!ws.length) {
+        children.unshift({ $loc: l.$loc, token: " " });
+      }
+      return {
+        children
+      };
+    });
+    function ImportAsToken(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("ImportAsToken", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("ImportAsToken", state, ImportAsToken$0(state) || ImportAsToken$1(state));
+        if (state.events)
+          state.events.exit?.("ImportAsToken", state, result, eventData);
+        return result;
+      } else {
+        const result = ImportAsToken$0(state) || ImportAsToken$1(state);
+        if (state.events)
+          state.events.exit?.("ImportAsToken", state, result, eventData);
+        return result;
+      }
+    }
     var ModuleExportName$0 = StringLiteral;
     var ModuleExportName$1 = IdentifierName;
     function ModuleExportName(state) {
@@ -14831,6 +14876,78 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var InlineTypeArguments$0 = $TS($S($Q(_), $EXPECT($L120, fail, 'InlineTypeArguments "<"'), $P(InlineTypeArgument), $Q(_), $EXPECT($L25, fail, 'InlineTypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      return { ts: true, children: $0 };
+    });
+    function InlineTypeArguments(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("InlineTypeArguments", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("InlineTypeArguments", state, InlineTypeArguments$0(state));
+        if (state.events)
+          state.events.exit?.("InlineTypeArguments", state, result, eventData);
+        return result;
+      } else {
+        const result = InlineTypeArguments$0(state);
+        if (state.events)
+          state.events.exit?.("InlineTypeArguments", state, result, eventData);
+        return result;
+      }
+    }
+    var InlineTypeArgument$0 = $S($Q(_), Type, InlineTypeArgumentDelimiter);
+    function InlineTypeArgument(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("InlineTypeArgument", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("InlineTypeArgument", state, InlineTypeArgument$0(state));
+        if (state.events)
+          state.events.exit?.("InlineTypeArgument", state, result, eventData);
+        return result;
+      } else {
+        const result = InlineTypeArgument$0(state);
+        if (state.events)
+          state.events.exit?.("InlineTypeArgument", state, result, eventData);
+        return result;
+      }
+    }
+    var InlineTypeArgumentDelimiter$0 = $S($Q(_), Comma);
+    var InlineTypeArgumentDelimiter$1 = $Y($S($Q(_), $EXPECT($L25, fail, 'InlineTypeArgumentDelimiter ">"')));
+    function InlineTypeArgumentDelimiter(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("InlineTypeArgumentDelimiter", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("InlineTypeArgumentDelimiter", state, InlineTypeArgumentDelimiter$0(state) || InlineTypeArgumentDelimiter$1(state));
+        if (state.events)
+          state.events.exit?.("InlineTypeArgumentDelimiter", state, result, eventData);
+        return result;
+      } else {
+        const result = InlineTypeArgumentDelimiter$0(state) || InlineTypeArgumentDelimiter$1(state);
+        if (state.events)
+          state.events.exit?.("InlineTypeArgumentDelimiter", state, result, eventData);
+        return result;
+      }
+    }
     var CompactTypeArguments$0 = $TS($S($EXPECT($L120, fail, 'CompactTypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L25, fail, 'CompactTypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
       return { ts: true, children: $0 };
     });
@@ -15940,6 +16057,33 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var CoffeePrototypeEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeePrototypeEnabled ""'), function($skip, $loc, $0, $1) {
+      if (module.config.coffeePrototype)
+        return;
+      return $skip;
+    });
+    function CoffeePrototypeEnabled(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("CoffeePrototypeEnabled", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("CoffeePrototypeEnabled", state, CoffeePrototypeEnabled$0(state));
+        if (state.events)
+          state.events.exit?.("CoffeePrototypeEnabled", state, result, eventData);
+        return result;
+      } else {
+        const result = CoffeePrototypeEnabled$0(state);
+        if (state.events)
+          state.events.exit?.("CoffeePrototypeEnabled", state, result, eventData);
+        return result;
+      }
+    }
     var Reset$0 = $TV($EXPECT($L0, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
       module.indentLevels = [{
         level: 0,
@@ -15970,6 +16114,7 @@ ${input.slice(result.pos)}
         coffeeLineContinuation: false,
         coffeeNot: false,
         coffeeOf: false,
+        coffeePrototype: false,
         implicitReturns: true,
         react: false,
         solid: false,
@@ -16124,6 +16269,7 @@ ${input.slice(result.pos)}
             this.coffeeLineContinuation = true;
             this.coffeeNot = true;
             this.coffeeOf = true;
+            this.coffeePrototype = true;
           } else {
             this.autoVar = false;
             this.coffeeBinaryExistential = false;
@@ -16138,6 +16284,7 @@ ${input.slice(result.pos)}
             this.coffeeLineContinuation = false;
             this.coffeeNot = false;
             this.coffeeOf = false;
+            this.coffeePrototype = false;
           }
         }
       });
@@ -16275,7 +16422,7 @@ ${input.slice(result.pos)}
           id: "results"
         };
         insertPush(exp.block, resultsRef);
-        exp.children = ["(", resultsRef, "=>{", ...exp.children, "; return ", resultsRef, "})([])"];
+        exp.children = ["(()=>{const ", resultsRef, "=[];", ...exp.children, "; return ", resultsRef, "})()"];
       }
       function wrapIterationReturningResults(statement, outerRef) {
         const resultsRef = {
@@ -17876,11 +18023,17 @@ makeCache = function() {
   };
   return events;
 };
-var main_default = { parse, generate: generate_default, util: util_exports, compile };
+var isCompileError = function(err) {
+  return err instanceof Error && [err.message, err.name, err.filename, err.line, err.column, err.offset].every(function(value) {
+    return value !== void 0;
+  });
+};
+var main_default = { parse, generate: generate_default, util: util_exports, compile, isCompileError };
 export {
   compile,
   main_default as default,
   generate_default as generate,
+  isCompileError,
   parse,
   util_exports as util
 };

package/dist/types.d.ts

@@ -16,6 +16,17 @@ declare module "@danielx/civet" {
     }
   }
 
+  // TODO: Import ParseError class from Hera
+  export type ParseError = {
+    message: string
+    name: string
+    filename: string
+    line: number
+    column: number
+    offset: number
+  }
+  export function isCompileError(err: any): err is ParseError
+
   export function compile<T extends CompileOptions>(source: string, options?: T): T extends { sourceMap: true } ? {
     code: string,
     sourceMap: SourceMap,
@@ -25,6 +36,7 @@ declare module "@danielx/civet" {
 
   const Civet: {
     compile: typeof compile
+    isCompileError: typeof isCompileError
     parse: typeof parse
     generate: typeof generate
     util: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielx/civet",
-  "version": "0.5.33",
+  "version": "0.5.35",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
   "module": "dist/main.mjs",
@@ -10,7 +10,10 @@
       "require": "./dist/main.js"
     },
     "./esm": "./dist/esm.mjs",
-    "./esbuild-plugin": "./dist/esbuild-plugin.js"
+    "./esbuild-plugin": "./dist/esbuild-plugin.js",
+    "./register": "./register.js",
+    "./*": "./*",
+    "./dist/*": "./dist/*"
   },
   "types": "dist/types.d.ts",
   "bin": {