@jay-framework/compiler 0.6.7 → 0.6.8

package/dist/index.js

@@ -1,50 +1,52 @@
-"use strict";
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const ts = require("typescript");
-const compilerShared = require("@jay-framework/compiler-shared");
-const changeCase = require("change-case");
-const path = require("node:path");
-const compilerJayHtml = require("@jay-framework/compiler-jay-html");
-function _interopNamespaceDefault(e) {
-  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
-  if (e) {
-    for (const k in e) {
-      if (k !== "default") {
-        const d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: () => e[k]
-        });
-      }
-    }
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-const ts__namespace = /* @__PURE__ */ _interopNamespaceDefault(ts);
-const printer = ts.createPrinter({
-  newLine: ts.NewLineKind.LineFeed
+import { JAY_COMPONENT, WithValidations, getModeFileExtension, MAKE_JAY_COMPONENT, JAY_SECURE, RuntimeMode, withOriginalTrace, JAY_QUERY_WORKER_TRUSTED, hasExtension, JAY_QUERY_MAIN_SANDBOX, JAY_QUERY_WORKER_SANDBOX, JayUnknown, JAY_EXTENSION, withoutExtension, JAY_TS_EXTENSION, SourceFileFormat, GenerateTarget } from "@jay-framework/compiler-shared";
+import { createRequire } from "module";
+import { capitalCase } from "change-case";
+import path from "node:path";
+import { generateElementFile as generateElementFile$1, generateElementFileReactTarget } from "@jay-framework/compiler-jay-html";
+import { generateElementDefinitionFile } from "@jay-framework/compiler-jay-html";
+const require$n = createRequire(import.meta.url);
+const tsModule$m = require$n("typescript");
+const {
+  isArrowFunction: isArrowFunction$4,
+  isConstructorDeclaration,
+  isFunctionDeclaration: isFunctionDeclaration$3,
+  isFunctionExpression: isFunctionExpression$1,
+  isGetAccessorDeclaration,
+  isMethodDeclaration,
+  isSetAccessorDeclaration,
+  createPrinter,
+  EmitHint,
+  createSourceFile: createSourceFile$1,
+  ScriptTarget: ScriptTarget$1,
+  setTextRange,
+  visitEachChild: visitEachChild$5,
+  NewLineKind
+} = tsModule$m;
+const printer = createPrinter({
+  newLine: NewLineKind.LineFeed
 });
 function astToCode(node) {
-  return printer.printNode(ts.EmitHint.Unspecified, node, void 0);
+  return printer.printNode(EmitHint.Unspecified, node, void 0);
 }
 function codeToAst(code, context) {
-  let dummySourceFile = ts.createSourceFile("dummy.ts", code, ts.ScriptTarget.Latest, true);
+  let dummySourceFile = createSourceFile$1("dummy.ts", code, ScriptTarget$1.Latest, true);
   function visitor(node) {
-    let updatedNode = ts.setTextRange(node, { pos: -1, end: -1 });
-    return ts.visitEachChild(updatedNode, visitor, context);
+    let updatedNode = setTextRange(node, { pos: -1, end: -1 });
+    return visitEachChild$5(updatedNode, visitor, context);
   }
-  return ts.visitEachChild(dummySourceFile, visitor, context).statements;
+  return Array.from(visitEachChild$5(dummySourceFile, visitor, context).statements);
 }
 function isFunctionLikeDeclarationBase(node) {
-  return ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isConstructorDeclaration(node) || ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node);
+  return isFunctionExpression$1(node) || isArrowFunction$4(node) || isFunctionDeclaration$3(node) || isMethodDeclaration(node) || isConstructorDeclaration(node) || isGetAccessorDeclaration(node) || isSetAccessorDeclaration(node);
 }
+const require$m = createRequire(import.meta.url);
+require$m("typescript");
 function mkTransformer(fileTransformer, config) {
   return (context) => {
     const { factory } = context;
@@ -53,32 +55,38 @@ function mkTransformer(fileTransformer, config) {
     };
   };
 }
+const require$l = createRequire(import.meta.url);
+const tsModule$l = require$l("typescript");
+const { forEachChild: forEachChild$4, isImportDeclaration: isImportDeclaration$5, isNamedImports: isNamedImports$1, isStringLiteral: isStringLiteral$9 } = tsModule$l;
 function extractImportDeclarations(sourceFile) {
   const importDeclarations = [];
   function visit(node) {
-    if (ts__namespace.isImportDeclaration(node)) {
+    if (isImportDeclaration$5(node)) {
       importDeclarations.push(node);
     }
-    ts__namespace.forEachChild(node, visit);
+    forEachChild$4(node, visit);
   }
-  ts__namespace.forEachChild(sourceFile, visit);
+  forEachChild$4(sourceFile, visit);
   return importDeclarations;
 }
 function extractImportedModules(sourceFile) {
-  return extractImportDeclarations(sourceFile).filter((node) => ts__namespace.isStringLiteral(node.moduleSpecifier)).map((node) => node.moduleSpecifier.text);
+  return extractImportDeclarations(sourceFile).filter((node) => isStringLiteral$9(node.moduleSpecifier)).map((node) => node.moduleSpecifier.text);
 }
-function isRelativeImport(module2) {
-  return module2.startsWith(".");
+function isRelativeImport(module) {
+  return module.startsWith(".");
 }
 function getImportSpecifiers(importDeclaration) {
   const namedBindings = importDeclaration.importClause?.namedBindings;
-  return namedBindings && ts__namespace.isNamedImports(namedBindings) ? namedBindings.elements : void 0;
+  return namedBindings && isNamedImports$1(namedBindings) ? namedBindings.elements : void 0;
 }
 function getImportName(importSpecifier) {
   return importSpecifier.propertyName?.text ?? importSpecifier.name.text;
 }
+const require$k = createRequire(import.meta.url);
+const tsModule$k = require$k("typescript");
+const { forEachChild: forEachChild$3, isImportDeclaration: isImportDeclaration$4, isStringLiteral: isStringLiteral$8 } = tsModule$k;
 function findMakeJayComponentImport(makeJayComponentName, node) {
-  if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === compilerShared.JAY_COMPONENT) {
+  if (isImportDeclaration$4(node) && isStringLiteral$8(node.moduleSpecifier) && node.moduleSpecifier.text === JAY_COMPONENT) {
     let importSpecifier = getImportSpecifiers(node)?.find(
       (element) => getImportName(element) === makeJayComponentName
     );
@@ -88,29 +96,58 @@ function findMakeJayComponentImport(makeJayComponentName, node) {
   }
   return void 0;
 }
+const require$j = createRequire(import.meta.url);
+const tsModule$j = require$j("typescript");
+const { forEachChild: forEachChild$2, isArrowFunction: isArrowFunction$3, isFunctionDeclaration: isFunctionDeclaration$2, isIdentifier: isIdentifier$7, isVariableStatement: isVariableStatement$3 } = tsModule$j;
 function findComponentConstructorsBlock(componentFunctionExpressions, sourceFile) {
   const foundConstructors = [];
   const namedConstructors = new Set(
-    componentFunctionExpressions.filter((expression) => ts.isIdentifier(expression)).map((expression) => ts.isIdentifier(expression) && expression.text)
+    componentFunctionExpressions.filter((expression) => isIdentifier$7(expression)).map((expression) => isIdentifier$7(expression) && expression.text)
   );
   const inlineConstructors = componentFunctionExpressions.filter(
     isFunctionLikeDeclarationBase
   );
   function visit(node) {
-    if (ts.isFunctionDeclaration(node)) {
+    if (isFunctionDeclaration$2(node)) {
       if (namedConstructors.has(node?.name.text))
         foundConstructors.push(node);
-    } else if (ts.isVariableStatement(node)) {
+    } else if (isVariableStatement$3(node)) {
       node.declarationList.declarations.forEach((declaration) => {
-        if (ts.isIdentifier(declaration.name) && namedConstructors.has(declaration.name.text) && declaration.initializer && ts.isArrowFunction(declaration.initializer))
+        if (isIdentifier$7(declaration.name) && namedConstructors.has(declaration.name.text) && declaration.initializer && isArrowFunction$3(declaration.initializer))
           foundConstructors.push(declaration.initializer);
       });
     }
-    ts.forEachChild(node, visit);
+    forEachChild$2(node, visit);
   }
-  ts.forEachChild(sourceFile, visit);
+  forEachChild$2(sourceFile, visit);
   return [...foundConstructors, ...inlineConstructors];
 }
+const require$i = createRequire(import.meta.url);
+const tsModule$i = require$i("typescript");
+const {
+  isElementAccessExpression: isElementAccessExpression$1,
+  isIdentifier: isIdentifier$6,
+  isObjectBindingPattern,
+  isPropertyAccessExpression: isPropertyAccessExpression$5,
+  isStringLiteral: isStringLiteral$7,
+  isObjectLiteralExpression,
+  isPropertyAssignment,
+  isShorthandPropertyAssignment,
+  isArrayBindingPattern,
+  isBindingElement,
+  isParenthesizedExpression,
+  isAsExpression,
+  isArrowFunction: isArrowFunction$2,
+  isFunctionExpression,
+  isStatement: isStatement$2,
+  isNamespaceImport,
+  isNamedImports,
+  isCallExpression: isCallExpression$6,
+  isNumericLiteral,
+  isToken,
+  SyntaxKind: SyntaxKind$5,
+  NodeFlags
+} = tsModule$i;
 function mkParameterVariableRoot(param, paramIndex) {
   return { kind: 0, param, paramIndex };
 }
@@ -120,8 +157,8 @@ function mkFunctionVariableRoot(func) {
 function mkLiteralVariableRoot(literal) {
   return { kind: 2, literal };
 }
-function mkImportModuleVariableRoot(module2, importType) {
-  return { kind: 3, module: module2, importType };
+function mkImportModuleVariableRoot(module, importType) {
+  return { kind: 3, module, importType };
 }
 function mkFunctionCallVariableRoot(node) {
   return { kind: 4, node };
@@ -160,18 +197,18 @@ function mkVariable(members) {
 }
 const UNKNOWN_VARIABLE = {};
 const getAccessedByProperty = (binding, accessedFrom, propertyName) => {
-  return accessedFrom ? propertyName ? ts.isIdentifier(propertyName) ? propertyName.text : void 0 : binding.text : void 0;
+  return accessedFrom ? propertyName ? isIdentifier$6(propertyName) ? propertyName.text : void 0 : binding.text : void 0;
 };
 function findDeclaringStatement(node) {
   if (!node)
     return void 0;
-  else if (ts.isStatement(node))
+  else if (isStatement$2(node))
     return node;
   else
     return findDeclaringStatement(node.parent);
 }
 function tsBindingNameToVariable(binding, accessedFrom, assignedFrom, propertyName, root) {
-  if (ts.isIdentifier(binding)) {
+  if (isIdentifier$6(binding)) {
     return [
       mkVariable({
         name: binding.text,
@@ -182,10 +219,10 @@ function tsBindingNameToVariable(binding, accessedFrom, assignedFrom, propertyNa
         definingStatement: findDeclaringStatement(binding)
       })
     ];
-  } else if (ts.isObjectBindingPattern(binding)) {
+  } else if (isObjectBindingPattern(binding)) {
     let variable = mkVariable({
       accessedFrom,
-      accessedByProperty: propertyName ? ts.isIdentifier(propertyName) ? propertyName.text : void 0 : void 0,
+      accessedByProperty: propertyName ? isIdentifier$6(propertyName) ? propertyName.text : void 0 : void 0,
       assignedFrom,
       root,
       definingStatement: findDeclaringStatement(binding)
@@ -193,16 +230,16 @@ function tsBindingNameToVariable(binding, accessedFrom, assignedFrom, propertyNa
     return binding.elements.flatMap((element) => {
       return tsBindingNameToVariable(element.name, variable, void 0, element.propertyName);
     });
-  } else if (ts.isArrayBindingPattern(binding)) {
+  } else if (isArrayBindingPattern(binding)) {
     let variable = mkVariable({
       accessedFrom,
-      accessedByProperty: propertyName ? ts.isIdentifier(propertyName) ? propertyName.text : void 0 : void 0,
+      accessedByProperty: propertyName ? isIdentifier$6(propertyName) ? propertyName.text : void 0 : void 0,
       assignedFrom,
       root,
       definingStatement: findDeclaringStatement(binding)
     });
     return binding.elements.flatMap((element, index) => {
-      return ts.isBindingElement(element) && tsBindingNameToVariable(element.name, variable, void 0, {
+      return isBindingElement(element) && tsBindingNameToVariable(element.name, variable, void 0, {
         kind: 80,
         text: "" + index
       });
@@ -243,7 +280,7 @@ class NameBindingResolver {
     }
   }
   addVariableDeclarationList(declarationList) {
-    const letOrConst = declarationList.flags === ts.NodeFlags.Const ? 1 : 0;
+    const letOrConst = declarationList.flags === NodeFlags.Const ? 1 : 0;
     declarationList.declarations.forEach((declaration) => {
       let rightSide = declaration.initializer ? this.resolvePropertyAccessChain(declaration.initializer) : void 0;
       let declaredVariable = tsBindingNameToVariable(
@@ -264,36 +301,36 @@ class NameBindingResolver {
     return this.variables.get(name) || UNKNOWN_VARIABLE;
   }
   resolvePropertyAccessChain(expression) {
-    if (ts.isPropertyAccessExpression(expression)) {
+    if (isPropertyAccessExpression$5(expression)) {
       const name = expression.name.text;
       const identifiersFromObject = this.resolvePropertyAccessChain(expression.expression);
       return { accessedFrom: identifiersFromObject, accessedByProperty: name };
-    } else if (ts.isElementAccessExpression(expression) && ts.isStringLiteral(expression.argumentExpression)) {
+    } else if (isElementAccessExpression$1(expression) && isStringLiteral$7(expression.argumentExpression)) {
       const name = expression.argumentExpression.text;
       const identifiersFromObject = this.resolvePropertyAccessChain(expression.expression);
       return { accessedFrom: identifiersFromObject, accessedByProperty: name };
-    } else if (ts.isIdentifier(expression)) {
+    } else if (isIdentifier$6(expression)) {
       return this.resolveIdentifier(expression);
-    } else if (ts.isParenthesizedExpression(expression)) {
+    } else if (isParenthesizedExpression(expression)) {
       return this.resolvePropertyAccessChain(expression.expression);
-    } else if (ts.isAsExpression(expression)) {
+    } else if (isAsExpression(expression)) {
       return this.resolvePropertyAccessChain(expression.expression);
-    } else if (ts.isObjectLiteralExpression(expression)) {
+    } else if (isObjectLiteralExpression(expression)) {
       return {
         properties: expression.properties.map((property) => {
-          if (ts.isPropertyAssignment(property) && (ts.isStringLiteral(property.name) || ts.isIdentifier(property.name))) {
-            if (ts.isIdentifier(property.initializer))
+          if (isPropertyAssignment(property) && (isStringLiteral$7(property.name) || isIdentifier$6(property.name))) {
+            if (isIdentifier$6(property.initializer))
               return {
                 name: property.name.text,
                 assignedFrom: this.resolveIdentifier(property.initializer)
               };
-            else if (ts.isObjectLiteralExpression(property.initializer)) {
+            else if (isObjectLiteralExpression(property.initializer)) {
               let nestedProperty = this.resolvePropertyAccessChain(
                 property.initializer
               );
               nestedProperty.name = property.name.text;
               return nestedProperty;
-            } else if (ts.isArrowFunction(property.initializer) || ts.isFunctionExpression(property.initializer)) {
+            } else if (isArrowFunction$2(property.initializer) || isFunctionExpression(property.initializer)) {
               return {
                 name: property.name.text,
                 root: mkFunctionVariableRoot(property.initializer)
@@ -303,18 +340,18 @@ class NameBindingResolver {
                 name: property.name.text,
                 root: mkLiteralVariableRoot(property.initializer)
               };
-          } else if (ts.isShorthandPropertyAssignment(property))
+          } else if (isShorthandPropertyAssignment(property))
             return {
               name: property.name.text,
               assignedFrom: this.resolveIdentifier(property.name)
             };
         })
       };
-    } else if (ts.isArrowFunction(expression) || ts.isFunctionExpression(expression)) {
+    } else if (isArrowFunction$2(expression) || isFunctionExpression(expression)) {
       return { root: mkFunctionVariableRoot(expression) };
-    } else if (ts.isCallExpression(expression)) {
+    } else if (isCallExpression$6(expression)) {
       return { root: mkFunctionCallVariableRoot(expression) };
-    } else if (ts.isStringLiteral(expression) || ts.isNumericLiteral(expression) || ts.isToken(expression) && expression.kind === ts.SyntaxKind.TrueKeyword || ts.isToken(expression) && expression.kind === ts.SyntaxKind.FalseKeyword) {
+    } else if (isStringLiteral$7(expression) || isNumericLiteral(expression) || isToken(expression) && expression.kind === SyntaxKind$5.TrueKeyword || isToken(expression) && expression.kind === SyntaxKind$5.FalseKeyword) {
       return { root: mkLiteralVariableRoot(expression) };
     } else {
       return { root: mkOtherVariableRoot(expression) };
@@ -354,14 +391,14 @@ class NameBindingResolver {
         /* namedImport */
       );
       let namedBindings = node.importClause.namedBindings;
-      if (ts.isNamespaceImport(namedBindings)) {
+      if (isNamespaceImport(namedBindings)) {
         let variable = mkVariable({
           name: namedBindings.name.text,
           definingStatement: node,
           root
         });
         this.variables.set(namedBindings.name.text, variable);
-      } else if (ts.isNamedImports(namedBindings)) {
+      } else if (isNamedImports(namedBindings)) {
         namedBindings.elements.forEach((importSpecifier) => {
           if (!importSpecifier.isTypeOnly) {
             let variable = mkVariable({
@@ -393,19 +430,31 @@ function flattenVariable(variable, path2 = []) {
   } else
     return { path: path2, root: variable.root };
 }
+const require$h = createRequire(import.meta.url);
+const tsModule$h = require$h("typescript");
+const { isIdentifier: isIdentifier$5, isPropertyAccessExpression: isPropertyAccessExpression$4 } = tsModule$h;
 function isIdentifierOrPropertyAccessExpression(node) {
-  return ts.isIdentifier(node) || ts.isPropertyAccessExpression(node);
+  return isIdentifier$5(node) || isPropertyAccessExpression$4(node);
 }
 function byAnd() {
   return (agg, value) => agg && value;
 }
+const require$g = createRequire(import.meta.url);
+const tsModule$g = require$g("typescript");
+const {
+  isBlock: isBlock$3,
+  isCallExpression: isCallExpression$5,
+  isExpressionStatement: isExpressionStatement$1,
+  isIdentifier: isIdentifier$4,
+  isPropertyAccessExpression: isPropertyAccessExpression$3
+} = tsModule$g;
 function findEventHandlersBlock(functionDeclaration, bindingResolver) {
   const foundEventHandlers = [];
   const foundEventHandlerFunctionsToHandlerIndex = /* @__PURE__ */ new Map();
   let nextEventHandlerIndex = 0;
-  if (ts.isBlock(functionDeclaration.body)) {
+  if (isBlock$3(functionDeclaration.body)) {
     functionDeclaration.body.statements.forEach((statement) => {
-      if (ts.isExpressionStatement(statement) && ts.isCallExpression(statement.expression)) {
+      if (isExpressionStatement$1(statement) && isCallExpression$5(statement.expression)) {
         if (isIdentifierOrPropertyAccessExpression(statement.expression.expression)) {
           let functionVariable = bindingResolver.explain(statement.expression.expression);
           let accessChain = flattenVariable(functionVariable);
@@ -417,7 +466,7 @@ function findEventHandlersBlock(functionDeclaration, bindingResolver) {
                 eventHandlerCallStatement: statement,
                 handlerIndex: nextEventHandlerIndex++
               });
-            else if (ts.isIdentifier(handler) || ts.isPropertyAccessExpression(handler)) {
+            else if (isIdentifier$4(handler) || isPropertyAccessExpression$3(handler)) {
               let flattenedHandler = flattenVariable(
                 bindingResolver.explain(handler)
               );
@@ -437,6 +486,26 @@ function findEventHandlersBlock(functionDeclaration, bindingResolver) {
   }
   return foundEventHandlers;
 }
+const require$f = createRequire(import.meta.url);
+const tsModule$f = require$f("typescript");
+const {
+  visitNode: visitNode$3,
+  isArrayTypeNode,
+  isBlock: isBlock$2,
+  isForInStatement: isForInStatement$1,
+  isForOfStatement: isForOfStatement$1,
+  isForStatement: isForStatement$1,
+  isFunctionDeclaration: isFunctionDeclaration$1,
+  isFunctionTypeNode,
+  isIdentifier: isIdentifier$3,
+  isImportDeclaration: isImportDeclaration$3,
+  isStringLiteral: isStringLiteral$6,
+  isTypeReferenceNode: isTypeReferenceNode$1,
+  isUnionTypeNode,
+  isVariableDeclarationList,
+  isVariableStatement: isVariableStatement$2,
+  SyntaxKind: SyntaxKind$4
+} = tsModule$f;
 const BUILT_IN_TYPES = ["RegExp", "Date"];
 function builtInType(text) {
   return BUILT_IN_TYPES.findIndex((_) => _ === text) > -1;
@@ -450,8 +519,8 @@ class BuiltInResolvedType {
   }
 }
 class ImportFromModuleResolvedType {
-  constructor(module2, path2) {
-    this.module = module2;
+  constructor(module, path2) {
+    this.module = module;
     this.path = path2;
   }
   canBeAssignedFrom(rightSide) {
@@ -526,18 +595,18 @@ class SourceFileBindingResolver {
       nbResolversQueue.unshift(new NameBindingResolver(nbResolversQueue[0]));
       this.nameBindingResolvers.set(node, nbResolversQueue[0]);
       callback();
-      node.getChildren().forEach((child) => ts.visitNode(child, visitor));
+      node.getChildren().forEach((child) => visitNode$3(child, visitor));
       nbResolversQueue.shift();
       return node;
     };
     const visitor = (node) => {
-      if (ts.isFunctionDeclaration(node))
+      if (isFunctionDeclaration$1(node))
         nbResolversQueue[0].addFunctionDeclaration(node);
-      if (ts.isVariableStatement(node))
+      if (isVariableStatement$2(node))
         nbResolversQueue[0].addVariableStatement(node);
-      else if (ts.isImportDeclaration(node))
+      else if (isImportDeclaration$3(node))
         nbResolversQueue[0].addImportDeclaration(node);
-      else if (ts.isBlock(node))
+      else if (isBlock$2(node))
         return doWithChildBindingResolver(node, () => {
         });
       else if (isFunctionLikeDeclarationBase(node)) {
@@ -545,14 +614,14 @@ class SourceFileBindingResolver {
           node,
           () => nbResolversQueue[0].addFunctionParams(node)
         );
-      } else if (ts.isForStatement(node) && ts.isVariableDeclarationList(node.initializer)) {
+      } else if (isForStatement$1(node) && isVariableDeclarationList(node.initializer)) {
         return doWithChildBindingResolver(
           node,
           () => nbResolversQueue[0].addVariableDeclarationList(
             node.initializer
           )
         );
-      } else if ((ts.isForInStatement(node) || ts.isForOfStatement(node)) && ts.isVariableDeclarationList(node.initializer) && node.initializer.declarations.length === 1 && ts.isIdentifier(node.initializer.declarations[0].name)) {
+      } else if ((isForInStatement$1(node) || isForOfStatement$1(node)) && isVariableDeclarationList(node.initializer) && node.initializer.declarations.length === 1 && isIdentifier$3(node.initializer.declarations[0].name)) {
         return doWithChildBindingResolver(node, () => {
           let name = node.initializer.declarations[0].name.text;
           nbResolversQueue[0].addVariable(
@@ -565,10 +634,10 @@ class SourceFileBindingResolver {
           );
         });
       }
-      node.getChildren().forEach((child) => ts.visitNode(child, visitor));
+      node.getChildren().forEach((child) => visitNode$3(child, visitor));
       return node;
     };
-    ts.visitNode(sourceFile, visitor);
+    visitNode$3(sourceFile, visitor);
   }
   findBindingResolver(node) {
     let found;
@@ -581,7 +650,7 @@ class SourceFileBindingResolver {
   }
   explainFlattenedVariableType(flattened) {
     if (!!flattened.root) {
-      if (isImportModuleVariableRoot(flattened.root) && ts.isStringLiteral(flattened.root.module)) {
+      if (isImportModuleVariableRoot(flattened.root) && isStringLiteral$6(flattened.root.module)) {
         return new ImportFromModuleResolvedType(flattened.root.module.text, flattened.path);
       }
     } else
@@ -589,9 +658,9 @@ class SourceFileBindingResolver {
   }
   explainType(type) {
     if (type) {
-      if (ts.isTypeReferenceNode(type)) {
+      if (isTypeReferenceNode$1(type)) {
         let typeName = type.typeName;
-        if (ts.isIdentifier(typeName)) {
+        if (isIdentifier$3(typeName)) {
           let resolved = this.findBindingResolver(typeName).resolveIdentifier(typeName);
           let flattened = flattenVariable(resolved);
           let typeFromFlattened = this.explainFlattenedVariableType(flattened);
@@ -600,23 +669,23 @@ class SourceFileBindingResolver {
           if (builtInType(typeName.text))
             return new BuiltInResolvedType(typeName.text);
         }
-      } else if (type.kind === ts.SyntaxKind.StringKeyword)
+      } else if (type.kind === SyntaxKind$4.StringKeyword)
         return new BuiltInResolvedType("string");
-      else if (type.kind === ts.SyntaxKind.NumberKeyword)
+      else if (type.kind === SyntaxKind$4.NumberKeyword)
         return new BuiltInResolvedType("number");
-      else if (type.kind === ts.SyntaxKind.BooleanKeyword)
+      else if (type.kind === SyntaxKind$4.BooleanKeyword)
         return new BuiltInResolvedType("boolean");
-      else if (type.kind === ts.SyntaxKind.AnyKeyword)
+      else if (type.kind === SyntaxKind$4.AnyKeyword)
         return new BuiltInResolvedType("any");
-      else if (type.kind === ts.SyntaxKind.VoidKeyword)
+      else if (type.kind === SyntaxKind$4.VoidKeyword)
         return new BuiltInResolvedType("void");
-      else if (ts.isArrayTypeNode(type))
+      else if (isArrayTypeNode(type))
         return new ArrayResolvedType(this.explainType(type.elementType));
-      else if (ts.isFunctionTypeNode(type)) {
+      else if (isFunctionTypeNode(type)) {
         const params = type.parameters.map((param) => this.explainType(param.type));
         const ret = this.explainType(type.type);
         return new FunctionResolvedType(params, ret);
-      } else if (ts.isUnionTypeNode(type))
+      } else if (isUnionTypeNode(type))
         return new UnionResolvedType(type.types.map((aType) => this.explainType(aType)));
     }
     return new BuiltInResolvedType("void");
@@ -628,6 +697,23 @@ class SourceFileBindingResolver {
 function areResolvedTypesCompatible(type1, type2) {
   return type1.canBeAssignedFrom(type2);
 }
+const require$e = createRequire(import.meta.url);
+const tsModule$e = require$e("typescript");
+const {
+  visitEachChild: visitEachChild$4,
+  isBinaryExpression: isBinaryExpression$1,
+  isCallExpression: isCallExpression$4,
+  isDecorator,
+  isExpressionStatement,
+  isFunctionDeclaration,
+  isIdentifier: isIdentifier$2,
+  isNewExpression: isNewExpression$1,
+  isPropertyAccessExpression: isPropertyAccessExpression$2,
+  isReturnStatement,
+  isSpreadElement,
+  SyntaxKind: SyntaxKind$3,
+  transform
+} = tsModule$e;
 var CompilePatternType = /* @__PURE__ */ ((CompilePatternType2) => {
   CompilePatternType2[CompilePatternType2["RETURN"] = 0] = "RETURN";
   CompilePatternType2[CompilePatternType2["CALL"] = 1] = "CALL";
@@ -670,7 +756,7 @@ function extractArgumentType(argument, sourceFileBinding, node) {
       return sourceFileBinding.explainType(node.parameters[paramIndex].type);
     }
   }
-  if (ts.isSpreadElement(argument)) {
+  if (isSpreadElement(argument)) {
     return new SpreadResolvedType(
       extractArgumentType(argument.expression, sourceFileBinding, node)
     );
@@ -688,10 +774,10 @@ function compileFunctionSplitPatternsBlock(patternFiles) {
   patternFiles.forEach((patternsFile) => {
     const sourceFileBinding = new SourceFileBindingResolver(patternsFile);
     const findPatternFunctions = (node) => {
-      if (ts.isFunctionDeclaration(node)) {
+      if (isFunctionDeclaration(node)) {
         let declaredTargetEnv = 0;
         node.modifiers && node.modifiers.forEach((modifier) => {
-          if (ts.isDecorator(modifier) && ts.isCallExpression(modifier.expression) && ts.isIdentifier(modifier.expression.expression) && modifier.expression.expression.text === "JayPattern" && modifier.expression.arguments.length === 1 && ts.isPropertyAccessExpression(modifier.expression.arguments[0]) && ts.isIdentifier(modifier.expression.arguments[0].expression) && modifier.expression.arguments[0].expression.text === "JayTargetEnv" && modifier.expression.arguments[0].name.text === "any")
+          if (isDecorator(modifier) && isCallExpression$4(modifier.expression) && isIdentifier$2(modifier.expression.expression) && modifier.expression.expression.text === "JayPattern" && modifier.expression.arguments.length === 1 && isPropertyAccessExpression$2(modifier.expression.arguments[0]) && isIdentifier$2(modifier.expression.arguments[0].expression) && modifier.expression.arguments[0].expression.text === "JayTargetEnv" && modifier.expression.arguments[0].name.text === "any")
             declaredTargetEnv = 1;
         });
         let name = node.name.text;
@@ -700,11 +786,11 @@ function compileFunctionSplitPatternsBlock(patternFiles) {
           let patternType;
           let leftHandSide;
           let callArgumentTypes = [];
-          if (ts.isReturnStatement(statement) && isIdentifierOrPropertyAccessExpression(statement.expression)) {
+          if (isReturnStatement(statement) && isIdentifierOrPropertyAccessExpression(statement.expression)) {
             patternType = 0;
             leftHandSide = statement.expression;
             patternTargetEnv = 1;
-          } else if (ts.isReturnStatement(statement) && ts.isCallExpression(statement.expression) && isIdentifierOrPropertyAccessExpression(statement.expression.expression) && node.type) {
+          } else if (isReturnStatement(statement) && isCallExpression$4(statement.expression) && isIdentifierOrPropertyAccessExpression(statement.expression.expression) && node.type) {
             patternType = 2;
             leftHandSide = statement.expression.expression;
             callArgumentTypes = extractArgumentTypes(
@@ -712,7 +798,7 @@ function compileFunctionSplitPatternsBlock(patternFiles) {
               sourceFileBinding,
               node
             );
-          } else if (ts.isReturnStatement(statement) && ts.isNewExpression(statement.expression) && isIdentifierOrPropertyAccessExpression(statement.expression.expression)) {
+          } else if (isReturnStatement(statement) && isNewExpression$1(statement.expression) && isIdentifierOrPropertyAccessExpression(statement.expression.expression)) {
             patternType = 2;
             leftHandSide = statement.expression.expression;
             callArgumentTypes = extractArgumentTypes(
@@ -720,7 +806,7 @@ function compileFunctionSplitPatternsBlock(patternFiles) {
               sourceFileBinding,
               node
             );
-          } else if (ts.isExpressionStatement(statement) && ts.isCallExpression(statement.expression) && isIdentifierOrPropertyAccessExpression(statement.expression.expression)) {
+          } else if (isExpressionStatement(statement) && isCallExpression$4(statement.expression) && isIdentifierOrPropertyAccessExpression(statement.expression.expression)) {
             patternType = 1;
             leftHandSide = statement.expression.expression;
             callArgumentTypes = extractArgumentTypes(
@@ -728,7 +814,7 @@ function compileFunctionSplitPatternsBlock(patternFiles) {
               sourceFileBinding,
               node
             );
-          } else if (ts.isExpressionStatement(statement) && ts.isBinaryExpression(statement.expression) && ts.isPropertyAccessExpression(statement.expression.left) && statement.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isIdentifier(statement.expression.right)) {
+          } else if (isExpressionStatement(statement) && isBinaryExpression$1(statement.expression) && isPropertyAccessExpression$2(statement.expression.left) && statement.expression.operatorToken.kind === SyntaxKind$3.EqualsToken && isIdentifier$2(statement.expression.right)) {
             patternType = 3;
             leftHandSide = statement.expression.left;
             callArgumentTypes = [
@@ -771,15 +857,18 @@ function compileFunctionSplitPatternsBlock(patternFiles) {
       }
       return node;
     };
-    ts.transform(patternsFile, [
+    transform(patternsFile, [
       mkTransformer(({ context, sourceFile }) => {
-        ts.visitEachChild(patternsFile, findPatternFunctions, context);
+        visitEachChild$4(patternsFile, findPatternFunctions, context);
         return sourceFile;
       })
     ]);
   });
-  return new compilerShared.WithValidations(compiledPatterns, validations);
+  return new WithValidations(compiledPatterns, validations);
 }
+const require$d = createRequire(import.meta.url);
+const tsModule$d = require$d("typescript");
+const { visitEachChild: visitEachChild$3, visitNode: visitNode$2 } = tsModule$d;
 function visitWithContext(node, initialContext, contextualVisitor) {
   return visitWithContext2(node, initialContext, void 0, contextualVisitor);
 }
@@ -788,28 +877,31 @@ function visitWithContext2(node, initialContext, transformationContext, contextu
   const visitChild = (node2, childContext) => {
     if (childContext)
       contexts.push(childContext);
-    let visitedNode = ts.visitNode(node2, visitor);
+    let visitedNode = visitNode$2(node2, visitor);
     if (childContext)
       contexts.pop();
     return visitedNode;
   };
-  const visitEachChild = (node2, childContext) => {
+  const _visitEachChild = (node2, childContext) => {
     if (childContext)
       contexts.push(childContext);
-    let visitedNode = ts.visitEachChild(node2, visitor, transformationContext);
+    let visitedNode = visitEachChild$3(node2, visitor, transformationContext);
     if (childContext)
       contexts.pop();
     return visitedNode;
   };
   const visitor = (node2) => {
-    return contextualVisitor(node2, contexts.at(-1), visitChild, visitEachChild);
+    return contextualVisitor(node2, contexts.at(-1), visitChild, _visitEachChild);
   };
-  return ts.visitNode(node, visitor);
+  return visitNode$2(node, visitor);
 }
+const require$c = createRequire(import.meta.url);
+const tsModule$c = require$c("typescript");
+const { isTypeReferenceNode } = tsModule$c;
 function isFirstParamJayEvent(eventHandler, bindingResolver) {
   if (eventHandler.parameters.length > 0 && eventHandler.parameters[0].type) {
     const explainedType = bindingResolver.explainType(eventHandler.parameters[0].type);
-    if (ts.isTypeReferenceNode(eventHandler.parameters[0].type) && eventHandler.parameters[0].type.typeArguments?.length === 2 && explainedType instanceof ImportFromModuleResolvedType && explainedType.module === "@jay-framework/runtime" && explainedType.path.length === 1 && explainedType.path[0] === "JayEvent")
+    if (isTypeReferenceNode(eventHandler.parameters[0].type) && eventHandler.parameters[0].type.typeArguments?.length === 2 && explainedType instanceof ImportFromModuleResolvedType && explainedType.module === "@jay-framework/runtime" && explainedType.path.length === 1 && explainedType.path[0] === "JayEvent")
       return true;
   }
   return false;
@@ -820,6 +912,18 @@ function filterEventHandlersToHaveJayEventType(foundEventHandlers, bindingResolv
     return isFirstParamJayEvent(eventHandler, bindingResolver);
   });
 }
+const require$b = createRequire(import.meta.url);
+const tsModule$b = require$b("typescript");
+const {
+  SyntaxKind: SyntaxKind$2,
+  visitEachChild: visitEachChild$2,
+  visitNode: visitNode$1,
+  isBlock: isBlock$1,
+  isExpression: isExpression$1,
+  isIdentifier: isIdentifier$1,
+  isLiteralExpression: isLiteralExpression$1,
+  isStatement: isStatement$1
+} = tsModule$b;
 function generateFunctionRepository(matchedReturnPatterns, matchedVariableReads, matchedConstants, safeStatements) {
   const constCode = [...new Set(matchedConstants)].join("\n");
   let readPatternsReturnProperties = matchedReturnPatterns.map(
@@ -862,8 +966,8 @@ const mkTransformEventHandlerStatementVisitor = (factory, context, bindingResolv
     }
     return patternIndexes.get(pattern);
   };
-  const visitor = (node, { parentStatementTargetEnv }, visitChild, visitEachChild) => {
-    if (ts.isStatement(node)) {
+  const visitor = (node, { parentStatementTargetEnv }, visitChild, visitEachChild2) => {
+    if (isStatement$1(node)) {
       let statementAnalysis = analyzer.getStatementStatus(node);
       if (statementAnalysis)
         parentStatementTargetEnv = intersectJayTargetEnv(
@@ -871,7 +975,7 @@ const mkTransformEventHandlerStatementVisitor = (factory, context, bindingResolv
           statementAnalysis.targetEnv
         );
     }
-    if (ts.isBlock(node) && parentStatementTargetEnv !== JayTargetEnv.sandbox) {
+    if (isBlock$1(node) && parentStatementTargetEnv !== JayTargetEnv.sandbox) {
       let sandboxStatements = [], mainStatements = [];
       node.statements.forEach((statement) => {
         let statementAnalysis = analyzer.getStatementStatus(statement);
@@ -896,20 +1000,20 @@ const mkTransformEventHandlerStatementVisitor = (factory, context, bindingResolv
       );
       node = factory.updateBlock(node, sandboxStatements);
       return node;
-    } else if (ts.isExpression(node)) {
+    } else if (isExpression$1(node)) {
       let expressionAnalysis = analyzer.getExpressionStatus(node);
       if (expressionAnalysis) {
         let pattern = expressionAnalysis.patterns[0];
         let patternKey = getPatternIndex(pattern);
         if (pattern.patternType === CompilePatternType.RETURN)
           sideEffects.matchedReturnPatterns.push({ pattern, patternKey });
-        else if (pattern.patternType === CompilePatternType.KNOWN_VARIABLE_READ && ts.isIdentifier(node))
+        else if (pattern.patternType === CompilePatternType.KNOWN_VARIABLE_READ && isIdentifier$1(node))
           sideEffects.matchedVariableReads.push({ variable: node, patternKey });
-        else if (pattern.patternType === CompilePatternType.CONST_READ && ts.isIdentifier(node)) {
+        else if (pattern.patternType === CompilePatternType.CONST_READ && isIdentifier$1(node)) {
           let constant = bindingResolver.explain(node);
           let flattenedConstant = flattenVariable(constant);
           let literal = flattenedConstant.root.literal;
-          if (ts.isLiteralExpression(literal)) {
+          if (isLiteralExpression$1(literal)) {
             let constantValue = literal.text;
             sideEffects.matchedConstants.push(`const ${node.text} = ${constantValue}`);
           }
@@ -921,7 +1025,7 @@ const mkTransformEventHandlerStatementVisitor = (factory, context, bindingResolv
         return codeToAst(replacementPattern, context)[0].expression;
       }
     }
-    return visitEachChild(node, { parentStatementTargetEnv });
+    return visitEachChild2(node, { parentStatementTargetEnv });
   };
   return { visitor, sideEffects };
 };
@@ -945,26 +1049,26 @@ const analyzeEventHandlerByPatternBlock = (context, bindingResolver, analyzer, f
       const transformedJayEventType = factory.createTypeReferenceNode(
         originalJayEventType.typeName,
         [
-          factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+          factory.createKeywordTypeNode(SyntaxKind$2.AnyKeyword),
           originalJayEventType.typeArguments[1]
         ]
       );
       let visitor2 = (node) => {
         if (node === originalJayEventType) {
-          return ts.visitEachChild(transformedJayEventType, visitor2, context);
+          return visitEachChild$2(transformedJayEventType, visitor2, context);
         }
-        return ts.visitEachChild(node, visitor2, context);
+        return visitEachChild$2(node, visitor2, context);
       };
-      transformedEventHandler = ts.visitEachChild(transformedEventHandler, visitor2, context);
+      transformedEventHandler = visitEachChild$2(transformedEventHandler, visitor2, context);
     }
     let bodyForFunctionRepository = void 0;
-    if (ts.isBlock(eventHandler.body) && sideEffects.mainContextBlocks.has(eventHandler.body)) {
+    if (isBlock$1(eventHandler.body) && sideEffects.mainContextBlocks.has(eventHandler.body)) {
       let body = sideEffects.mainContextBlocks.get(eventHandler.body);
       const replaceBodiesVisitor = (node) => {
-        let mainNode = ts.isBlock(node) && sideEffects.mainContextBlocks.has(node) ? sideEffects.mainContextBlocks.get(node) : node;
-        return ts.visitEachChild(mainNode, replaceBodiesVisitor, context);
+        let mainNode = isBlock$1(node) && sideEffects.mainContextBlocks.has(node) ? sideEffects.mainContextBlocks.get(node) : node;
+        return visitEachChild$2(mainNode, replaceBodiesVisitor, context);
       };
-      bodyForFunctionRepository = ts.visitNode(body, replaceBodiesVisitor);
+      bodyForFunctionRepository = visitNode$1(body, replaceBodiesVisitor);
     }
     const { handlerCode, key } = generateFunctionRepository(
       sideEffects.matchedReturnPatterns,
@@ -986,8 +1090,11 @@ const analyzeEventHandlerByPatternBlock = (context, bindingResolver, analyzer, f
       wasEventHandlerTransformed: false
     };
 };
+const require$a = createRequire(import.meta.url);
+const tsModule$a = require$a("typescript");
+const { visitEachChild: visitEachChild$1, isCallExpression: isCallExpression$3, isPropertyAccessExpression: isPropertyAccessExpression$1 } = tsModule$a;
 const analyzeEventHandlerCall = (context, factory, handlerKey) => (node) => {
-  if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+  if (isCallExpression$3(node) && isPropertyAccessExpression$1(node.expression)) {
     return factory.createCallExpression(
       factory.createPropertyAccessExpression(
         factory.createCallExpression(
@@ -1009,11 +1116,7 @@ const analyzeEventHandlerCall = (context, factory, handlerKey) => (node) => {
   return node;
 };
 const analyzeEventHandlerCallStatement$Block = (context, factory, handlerKey) => (node) => {
-  return ts.visitEachChild(
-    node,
-    analyzeEventHandlerCall(context, factory, handlerKey),
-    context
-  );
+  return visitEachChild$1(node, analyzeEventHandlerCall(context, factory, handlerKey), context);
 };
 function analyzedEventHandlersToReplaceMap(transformedEventHandlers) {
   const map = /* @__PURE__ */ new Map();
@@ -1057,6 +1160,27 @@ function analyzeEventHandlers(context, bindingResolver, analyzer, factory, found
     };
   });
 }
+const require$9 = createRequire(import.meta.url);
+const tsModule$9 = require$9("typescript");
+const {
+  isArrowFunction: isArrowFunction$1,
+  isBinaryExpression,
+  isBlock,
+  isCallExpression: isCallExpression$2,
+  isDoStatement,
+  isElementAccessExpression,
+  isForInStatement,
+  isForOfStatement,
+  isForStatement,
+  isIfStatement,
+  isLiteralExpression,
+  isNewExpression,
+  isPropertyAccessExpression,
+  isStatement,
+  isVariableStatement: isVariableStatement$1,
+  isWhileStatement,
+  SyntaxKind: SyntaxKind$1
+} = tsModule$9;
 class SourceFileStatementAnalyzer {
   constructor(sourceFile, bindingResolver, compiledPatterns) {
     this.sourceFile = sourceFile;
@@ -1140,7 +1264,7 @@ class ScopedSourceFileStatementAnalyzer {
       if (matchType === 0) {
         addExpressionStatus(statement, matchedPatterns, expression, true);
       } else {
-        if (ts.isPropertyAccessExpression(expression))
+        if (isPropertyAccessExpression(expression))
           visitChild(expression.expression, {
             statement,
             roleInParent: 1
@@ -1155,7 +1279,7 @@ class ScopedSourceFileStatementAnalyzer {
         expressionStatus.patterns[0].returnType,
         matchedPatterns[0].callArgumentTypes[index]
       );
-      const isLiteral = ts.isLiteralExpression(argument);
+      const isLiteral = isLiteralExpression(argument);
       let isScopedVariableAccess = false;
       if (isIdentifierOrPropertyAccessExpression(argument)) {
         const variable = this.bindingResolver.explain(argument);
@@ -1189,7 +1313,7 @@ class ScopedSourceFileStatementAnalyzer {
           }).reduce(byAnd(), true);
           addExpressionStatus(statement, matchedPatterns, node, areArgumentsMatching);
         } else {
-          if (ts.isPropertyAccessExpression(node.expression))
+          if (isPropertyAccessExpression(node.expression))
             visitChild(node.expression.expression, {
               statement,
               roleInParent: 1
@@ -1207,20 +1331,20 @@ class ScopedSourceFileStatementAnalyzer {
         /* none */
       },
       (node, { statement, roleInParent }, visitChild) => {
-        if (ts.isStatement(node))
+        if (isStatement(node))
           statement = node;
         if (roleInParent === 1 || roleInParent === 2) {
           if (isIdentifierOrPropertyAccessExpression(node))
             analyzePropertyExpression(node, visitChild, statement, roleInParent);
-          else if (ts.isCallExpression(node) || ts.isNewExpression(node)) {
+          else if (isCallExpression$2(node) || isNewExpression(node)) {
             analyzeCallOrNewExpression(node, visitChild, statement, roleInParent);
             return node;
-          } else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken)
+          } else if (isBinaryExpression(node) && node.operatorToken.kind === SyntaxKind$1.EqualsToken)
             this.markStatementSandbox(statement);
-          else if (!ts.isLiteralExpression(node) && !ts.isBinaryExpression(node))
+          else if (!isLiteralExpression(node) && !isBinaryExpression(node))
             this.markStatementSandbox(statement);
         }
-        if (ts.isCallExpression(node) && isIdentifierOrPropertyAccessExpression(node.expression) && roleInParent === 0) {
+        if (isCallExpression$2(node) && isIdentifierOrPropertyAccessExpression(node.expression) && roleInParent === 0) {
           analyzeCallOrNewExpression(
             node,
             visitChild,
@@ -1228,7 +1352,7 @@ class ScopedSourceFileStatementAnalyzer {
             3
             /* call */
           );
-        } else if (ts.isVariableStatement(node)) {
+        } else if (isVariableStatement$1(node)) {
           node.declarationList.declarations.forEach(
             (declaration) => visitChild(declaration.initializer, {
               statement,
@@ -1238,7 +1362,7 @@ class ScopedSourceFileStatementAnalyzer {
           );
           if (this.getStatementStatus(node)?.targetEnv === JayTargetEnv.any)
             this.getStatementStatus(node).targetEnv = JayTargetEnv.main;
-        } else if (ts.isArrowFunction(node) && !ts.isBlock(node.body)) {
+        } else if (isArrowFunction$1(node) && !isBlock(node.body)) {
           visitChild(node.body, {
             statement,
             roleInParent: 1
@@ -1269,7 +1393,7 @@ class ScopedSourceFileStatementAnalyzer {
               true
             );
           }
-        } else if (ts.isIfStatement(node)) {
+        } else if (isIfStatement(node)) {
           visitChild(node.expression, {
             statement,
             roleInParent: 1
@@ -1286,7 +1410,7 @@ class ScopedSourceFileStatementAnalyzer {
               roleInParent: 0
               /* none */
             });
-        } else if (ts.isForStatement(node) || ts.isForOfStatement(node) || ts.isForInStatement(node) || ts.isWhileStatement(node) || ts.isDoStatement(node)) {
+        } else if (isForStatement(node) || isForOfStatement(node) || isForInStatement(node) || isWhileStatement(node) || isDoStatement(node)) {
           this.markStatementSandbox(statement);
           node.getChildren().forEach(
             (child) => visitChild(child, {
@@ -1295,7 +1419,7 @@ class ScopedSourceFileStatementAnalyzer {
               /* none */
             })
           );
-        } else if (ts.isBinaryExpression(node)) {
+        } else if (isBinaryExpression(node)) {
           visitChild(node.right, {
             statement,
             roleInParent: 1
@@ -1303,10 +1427,10 @@ class ScopedSourceFileStatementAnalyzer {
           });
           visitChild(node.left, {
             statement,
-            roleInParent: node.operatorToken.kind === ts.SyntaxKind.EqualsToken ? 2 : 1
+            roleInParent: node.operatorToken.kind === SyntaxKind$1.EqualsToken ? 2 : 1
             /* read */
           });
-        } else if (ts.isElementAccessExpression(node)) {
+        } else if (isElementAccessExpression(node)) {
           node.getChildren().forEach(
             (child) => visitChild(child, {
               statement,
@@ -1456,6 +1580,9 @@ function isChildOf(node, parent) {
       return true;
   return isChildOf(node.parent, parent);
 }
+const require$8 = createRequire(import.meta.url);
+const tsModule$8 = require$8("typescript");
+const { forEachChild: forEachChild$1, isCallExpression: isCallExpression$1, isStringLiteral: isStringLiteral$5, isVariableStatement } = tsModule$8;
 var FindComponentConstructorType = /* @__PURE__ */ ((FindComponentConstructorType2) => {
   FindComponentConstructorType2["makeJayComponent"] = "makeJayComponent";
   FindComponentConstructorType2["makeJayTsxComponent"] = "makeJayTsxComponent";
@@ -1463,14 +1590,14 @@ var FindComponentConstructorType = /* @__PURE__ */ ((FindComponentConstructorTyp
 })(FindComponentConstructorType || {});
 function findComponentConstructorCalls(findType, bindingResolver, node) {
   const foundConstructorCalls = [];
-  if (ts.isVariableStatement(node)) {
+  if (isVariableStatement(node)) {
     node.declarationList.declarations.forEach((declaration) => {
-      if (declaration.initializer && ts.isCallExpression(declaration.initializer) && isIdentifierOrPropertyAccessExpression(declaration.initializer.expression)) {
+      if (declaration.initializer && isCallExpression$1(declaration.initializer) && isIdentifierOrPropertyAccessExpression(declaration.initializer.expression)) {
         const explainedInitializer = bindingResolver.explain(
           declaration.initializer.expression
         );
         const flattened = flattenVariable(explainedInitializer);
-        if (flattened.path.length === 1 && flattened.path[0] === findType && flattened.root && isImportModuleVariableRoot(flattened.root) && ts.isStringLiteral(flattened.root.module) && flattened.root.module.text === compilerShared.JAY_COMPONENT) {
+        if (flattened.path.length === 1 && flattened.path[0] === findType && flattened.root && isImportModuleVariableRoot(flattened.root) && isStringLiteral$5(flattened.root.module) && flattened.root.module.text === JAY_COMPONENT) {
           let render = findType === "makeJayComponent" ? declaration.initializer.arguments[0] : void 0;
           let comp = findType === "makeJayComponent" ? declaration.initializer.arguments[1] : declaration.initializer.arguments[0];
           let foundConstructor = {
@@ -1492,9 +1619,9 @@ function findComponentConstructorCallsBlock(findType, bindingResolver, sourceFil
     foundConstructorCalls.push(
       ...findComponentConstructorCalls(findType, bindingResolver, node)
     );
-    ts.forEachChild(node, visit);
+    forEachChild$1(node, visit);
   }
-  ts.forEachChild(sourceFile, visit);
+  forEachChild$1(sourceFile, visit);
   return foundConstructorCalls;
 }
 class GeneratedFunctionRepository {
@@ -1552,34 +1679,40 @@ export ${_}`
     );
   }
 }
+const require$7 = createRequire(import.meta.url);
+const tsModule$7 = require$7("typescript");
+const { forEachChild, isCallExpression, isIdentifier, isStringLiteral: isStringLiteral$4 } = tsModule$7;
 function findExec$(bindingResolver, sourceFile) {
   const foundExec$ = [];
   function visit(node) {
-    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+    if (isCallExpression(node) && isIdentifier(node.expression)) {
       const functionVariable = bindingResolver.explain(node.expression);
       const accessChain = flattenVariable(functionVariable);
-      if (accessChain.path.length === 1 && accessChain.path[0] === "exec$" && isImportModuleVariableRoot(accessChain.root) && ts.isStringLiteral(accessChain.root.module) && accessChain.root.module.text === "@jay-framework/secure")
+      if (accessChain.path.length === 1 && accessChain.path[0] === "exec$" && isImportModuleVariableRoot(accessChain.root) && isStringLiteral$4(accessChain.root.module) && accessChain.root.module.text === "@jay-framework/secure")
         foundExec$.push(node);
     }
-    ts.forEachChild(node, visit);
+    forEachChild(node, visit);
   }
-  ts.forEachChild(sourceFile, visit);
+  forEachChild(sourceFile, visit);
   return foundExec$;
 }
+const require$6 = createRequire(import.meta.url);
+const tsModule$6 = require$6("typescript");
+const { visitNode, isArrowFunction, isExpression } = tsModule$6;
 function analyzeGlobalExec$(context, analyzer, functionRepositoryBuilder, foundExec$) {
   const scopedAnalyzer = analyzer.analyzeForScope(foundExec$);
   let foundUnsafeExpression = false;
   const visitor = (node) => {
-    if (ts.isExpression(node)) {
+    if (isExpression(node)) {
       const matchedPattern = scopedAnalyzer.getExpressionStatus(node);
       foundUnsafeExpression = foundUnsafeExpression || !matchedPattern || !matchedPattern.subExpressionsMatching;
     } else {
-      node.getChildren().forEach((child) => ts.visitNode(child, visitor));
+      node.getChildren().forEach((child) => visitNode(child, visitor));
     }
     return node;
   };
-  if (ts.isArrowFunction(foundExec$.arguments[0]))
-    ts.visitNode(foundExec$.arguments[0].body, visitor);
+  if (isArrowFunction(foundExec$.arguments[0]))
+    visitNode(foundExec$.arguments[0].body, visitor);
   if (foundUnsafeExpression)
     return { foundExec$, wasTransformed: false };
   else {
@@ -1602,6 +1735,9 @@ function transformedGlobalExec$toReplaceMap(transformedGlobalExec$s) {
   });
   return map;
 }
+const require$5 = createRequire(import.meta.url);
+const tsModule$5 = require$5("typescript");
+const { SyntaxKind, isImportDeclaration: isImportDeclaration$2, isStringLiteral: isStringLiteral$3, isInterfaceDeclaration } = tsModule$5;
 function generateComponentConstructorCalls(context, componentConstructorCalls, hasFunctionRepository) {
   let optionsParam = hasFunctionRepository ? ", { funcRepository }" : "";
   let transformedConstructors = componentConstructorCalls.map(({ name, render }) => {
@@ -1616,7 +1752,7 @@ function generateComponentConstructorCalls(context, componentConstructorCalls, h
 function getRenderImportSpecifier(node) {
   const namedBindings = node.importClause?.namedBindings;
   switch (namedBindings?.kind) {
-    case ts.SyntaxKind.NamedImports: {
+    case SyntaxKind.NamedImports: {
       return namedBindings.elements.find((binding) => getImportName(binding) === "render");
     }
     default:
@@ -1624,14 +1760,14 @@ function getRenderImportSpecifier(node) {
   }
 }
 function transformImport(node, importerMode, context, hasFunctionRepository) {
-  if (ts.isStringLiteral(node.moduleSpecifier)) {
-    if (findMakeJayComponentImport(compilerShared.MAKE_JAY_COMPONENT, node)) {
+  if (isStringLiteral$3(node.moduleSpecifier)) {
+    if (findMakeJayComponentImport(MAKE_JAY_COMPONENT, node)) {
       const code = hasFunctionRepository ? `import { makeJayComponentBridge, FunctionsRepository } from '@jay-framework/secure';` : `import { makeJayComponentBridge } from '@jay-framework/secure';`;
       return codeToAst(code, context)[0];
     }
     const renderImportSpecifier = getRenderImportSpecifier(node);
     if (Boolean(renderImportSpecifier)) {
-      const importModule = `${node.moduleSpecifier.text}${compilerShared.getModeFileExtension(
+      const importModule = `${node.moduleSpecifier.text}${getModeFileExtension(
         true,
         importerMode
       )}`;
@@ -1656,9 +1792,9 @@ function transformSourceFile(sourceFile, factory, context, importerMode, compone
     hasFunctionRepository
   );
   let transformedStatements = sourceFile.statements.map((statement) => {
-    if (ts.isInterfaceDeclaration(statement))
+    if (isInterfaceDeclaration(statement))
       return statement;
-    else if (ts.isImportDeclaration(statement))
+    else if (isImportDeclaration$2(statement))
       return transformImport(statement, importerMode, context, hasFunctionRepository);
     else
       return void 0;
@@ -1722,8 +1858,11 @@ function transformComponentBridge(importerMode, patterns = [], globalFunctionRep
     globalFunctionRepository
   });
 }
+const require$4 = createRequire(import.meta.url);
+const tsModule$4 = require$4("typescript");
+const { isStringLiteral: isStringLiteral$2 } = tsModule$4;
 function transformImportModeFileExtension(node, factory, importerMode) {
-  if (!ts.isStringLiteral(node.moduleSpecifier))
+  if (!isStringLiteral$2(node.moduleSpecifier))
     return void 0;
   const originalTarget = node.moduleSpecifier.text;
   if (!isRelativeImport(originalTarget))
@@ -1732,13 +1871,16 @@ function transformImportModeFileExtension(node, factory, importerMode) {
     node,
     node.modifiers,
     node.importClause,
-    factory.createStringLiteral(`${originalTarget}${compilerShared.getModeFileExtension(true, importerMode)}`),
+    factory.createStringLiteral(`${originalTarget}${getModeFileExtension(true, importerMode)}`),
     node.attributes
   );
 }
+const require$3 = createRequire(import.meta.url);
+const tsModule$3 = require$3("typescript");
+const { isImportDeclaration: isImportDeclaration$1 } = tsModule$3;
 function findAfterImportStatementIndex(statements) {
   let lastIndex = 0;
-  while (ts.isImportDeclaration(statements[lastIndex]))
+  while (isImportDeclaration$1(statements[lastIndex]))
     lastIndex += 1;
   return lastIndex;
 }
@@ -1754,7 +1896,7 @@ function transformComponentImports(needsHandler$, needsFunc$, needsFuncGlobal$,
     const allStatements = [
       ...statements.slice(0, afterImportStatementIndex),
       codeToAst(
-        `import { ${importClause} } from '${compilerShared.JAY_SECURE}';`,
+        `import { ${importClause} } from '${JAY_SECURE}';`,
         context
       )[0],
       ...statements.slice(afterImportStatementIndex)
@@ -1763,8 +1905,11 @@ function transformComponentImports(needsHandler$, needsFunc$, needsFuncGlobal$,
   } else
     return transformedSourceFile;
 }
+const require$2 = createRequire(import.meta.url);
+const tsModule$2 = require$2("typescript");
+const { isImportDeclaration, isStringLiteral: isStringLiteral$1, visitEachChild } = tsModule$2;
 function isCssImport(node) {
-  return ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text.endsWith(".css");
+  return isStringLiteral$1(node.moduleSpecifier) && node.moduleSpecifier.text.endsWith(".css");
 }
 function mkComponentTransformer(sftContext) {
   const { patterns, globalFunctionRepository, context, factory, sourceFile } = sftContext;
@@ -1809,17 +1954,17 @@ function mkComponentTransformer(sftContext) {
   let visitor = (node) => {
     if (replaceMap.has(node)) {
       node = replaceMap.get(node);
-      return ts.visitEachChild(node, visitor, context);
+      return visitEachChild(node, visitor, context);
     }
-    if (ts.isImportDeclaration(node)) {
+    if (isImportDeclaration(node)) {
       if (isCssImport(node))
         return void 0;
       else
-        return transformImportModeFileExtension(node, factory, compilerShared.RuntimeMode.WorkerSandbox);
+        return transformImportModeFileExtension(node, factory, RuntimeMode.WorkerSandbox);
     }
-    return ts.visitEachChild(node, visitor, context);
+    return visitEachChild(node, visitor, context);
   };
-  let transformedSourceFile = ts.visitEachChild(sftContext.sourceFile, visitor, context);
+  let transformedSourceFile = visitEachChild(sftContext.sourceFile, visitor, context);
   return transformComponentImports(
     transformedEventHandlers.length > 0,
     false,
@@ -1833,11 +1978,14 @@ function mkComponentTransformer(sftContext) {
 function transformComponent(patterns = [], globalFunctionRepository) {
   return mkTransformer(mkComponentTransformer, { patterns, globalFunctionRepository });
 }
-function createTsSourceFileFromSource(filePath, sourceCode, scriptKind = ts__namespace.ScriptKind.TS) {
+const require$1 = createRequire(import.meta.url);
+const tsModule$1 = require$1("typescript");
+const { ScriptTarget, createSourceFile, ScriptKind } = tsModule$1;
+function createTsSourceFileFromSource(filePath, sourceCode, scriptKind = ScriptKind.TS) {
   try {
-    return ts__namespace.createSourceFile(filePath, sourceCode, ts__namespace.ScriptTarget.Latest, true, scriptKind);
+    return createSourceFile(filePath, sourceCode, ScriptTarget.Latest, true, scriptKind);
   } catch (error) {
-    throw compilerShared.withOriginalTrace(
+    throw withOriginalTrace(
       new Error(`Failed to create TypeScript source file for ${filePath}`),
       error
     );
@@ -1851,17 +1999,20 @@ function generateImportsFileFromJayFile(jayFile) {
   return fromImportModules(jayFile.imports.map((link) => link.module));
 }
 function fromImportModules(modules) {
-  return modules.filter(isRelativeImport).map((module2) => `import '${module2}${compilerShared.JAY_QUERY_WORKER_TRUSTED}'`).join("\n");
+  return modules.filter(isRelativeImport).map((module) => `import '${module}${JAY_QUERY_WORKER_TRUSTED}'`).join("\n");
 }
+const require2 = createRequire(import.meta.url);
+const tsModule = require2("typescript");
+const { isStringLiteral } = tsModule;
 function parseImportLinks(sourceFile) {
   const importDeclarations = extractImportDeclarations(sourceFile).filter(
-    (importDeclaration) => ts__namespace.isStringLiteral(importDeclaration.moduleSpecifier)
+    (importDeclaration) => isStringLiteral(importDeclaration.moduleSpecifier)
   );
   const importLinks = importDeclarations.map((importDeclaration) => {
-    const module2 = importDeclaration.moduleSpecifier.text;
-    const sandbox = compilerShared.hasExtension(module2, compilerShared.JAY_QUERY_MAIN_SANDBOX) || compilerShared.hasExtension(module2, compilerShared.JAY_QUERY_WORKER_SANDBOX);
+    const module = importDeclaration.moduleSpecifier.text;
+    const sandbox = hasExtension(module, JAY_QUERY_MAIN_SANDBOX) || hasExtension(module, JAY_QUERY_WORKER_SANDBOX);
     const names = getJayImportNames(importDeclaration);
-    return { module: module2, names, sandbox };
+    return { module, names, sandbox };
   });
   return importLinks;
 }
@@ -1873,7 +2024,7 @@ function getJayImportNames(importDeclaration) {
     return {
       name,
       ...as && { as },
-      type: compilerShared.JayUnknown
+      type: JayUnknown
     };
   }) || [];
 }
@@ -1881,38 +2032,37 @@ function parseGenericTypescriptFile(filePath, code) {
   const sourceFile = createTsSourceFileFromSource(filePath, code);
   const imports = parseImportLinks(sourceFile);
   const filename = path.basename(filePath);
-  const baseElementName = changeCase.capitalCase(
-    compilerShared.hasExtension(filename, compilerShared.JAY_EXTENSION) ? compilerShared.withoutExtension(filename, compilerShared.JAY_TS_EXTENSION) : filename.split(".").shift(),
+  const baseElementName = capitalCase(
+    hasExtension(filename, JAY_EXTENSION) ? withoutExtension(filename, JAY_TS_EXTENSION) : filename.split(".").shift(),
     { delimiter: "" }
   );
-  return new compilerShared.WithValidations(
+  return new WithValidations(
     {
-      format: compilerShared.SourceFileFormat.TypeScript,
+      format: SourceFileFormat.TypeScript,
       imports,
       baseElementName
     },
     []
   );
 }
-function generateElementFile(jayFile, importerMode, generateTarget = compilerShared.GenerateTarget.jay) {
-  return generateTarget === compilerShared.GenerateTarget.jay ? compilerJayHtml.generateElementFile(jayFile, importerMode) : compilerJayHtml.generateElementFileReactTarget(jayFile, importerMode);
-}
-Object.defineProperty(exports, "generateElementDefinitionFile", {
-  enumerable: true,
-  get: () => compilerJayHtml.generateElementDefinitionFile
-});
-exports.FunctionRepositoryBuilder = FunctionRepositoryBuilder;
-exports.compileFunctionSplitPatternsBlock = compileFunctionSplitPatternsBlock;
-exports.createTsSourceFileFromSource = createTsSourceFileFromSource;
-exports.extractImportDeclarations = extractImportDeclarations;
-exports.extractImportedModules = extractImportedModules;
-exports.generateElementFile = generateElementFile;
-exports.generateImportsFileFromJayFile = generateImportsFileFromJayFile;
-exports.generateImportsFileFromTsSource = generateImportsFileFromTsSource;
-exports.getImportName = getImportName;
-exports.getImportSpecifiers = getImportSpecifiers;
-exports.isRelativeImport = isRelativeImport;
-exports.parseGenericTypescriptFile = parseGenericTypescriptFile;
-exports.transformComponent = transformComponent;
-exports.transformComponentBridge = transformComponentBridge;
-exports.transformComponentImports = transformComponentImports;
+function generateElementFile(jayFile, importerMode, generateTarget = GenerateTarget.jay) {
+  return generateTarget === GenerateTarget.jay ? generateElementFile$1(jayFile, importerMode) : generateElementFileReactTarget(jayFile, importerMode);
+}
+export {
+  FunctionRepositoryBuilder,
+  compileFunctionSplitPatternsBlock,
+  createTsSourceFileFromSource,
+  extractImportDeclarations,
+  extractImportedModules,
+  generateElementDefinitionFile,
+  generateElementFile,
+  generateImportsFileFromJayFile,
+  generateImportsFileFromTsSource,
+  getImportName,
+  getImportSpecifiers,
+  isRelativeImport,
+  parseGenericTypescriptFile,
+  transformComponent,
+  transformComponentBridge,
+  transformComponentImports
+};