@jay-framework/compiler 0.5.0

package/dist/index.js

@@ -0,0 +1,1918 @@
+"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
+});
+function astToCode(node) {
+  return printer.printNode(ts.EmitHint.Unspecified, node, void 0);
+}
+function codeToAst(code, context) {
+  let dummySourceFile = ts.createSourceFile("dummy.ts", code, ts.ScriptTarget.Latest, true);
+  function visitor(node) {
+    let updatedNode = ts.setTextRange(node, { pos: -1, end: -1 });
+    return ts.visitEachChild(updatedNode, visitor, context);
+  }
+  return ts.visitEachChild(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);
+}
+function mkTransformer(fileTransformer, config) {
+  return (context) => {
+    const { factory } = context;
+    return (sourceFile) => {
+      return fileTransformer({ factory, context, sourceFile, ...config || {} });
+    };
+  };
+}
+function extractImportDeclarations(sourceFile) {
+  const importDeclarations = [];
+  function visit(node) {
+    if (ts__namespace.isImportDeclaration(node)) {
+      importDeclarations.push(node);
+    }
+    ts__namespace.forEachChild(node, visit);
+  }
+  ts__namespace.forEachChild(sourceFile, visit);
+  return importDeclarations;
+}
+function extractImportedModules(sourceFile) {
+  return extractImportDeclarations(sourceFile).filter((node) => ts__namespace.isStringLiteral(node.moduleSpecifier)).map((node) => node.moduleSpecifier.text);
+}
+function isRelativeImport(module2) {
+  return module2.startsWith(".");
+}
+function getImportSpecifiers(importDeclaration) {
+  const namedBindings = importDeclaration.importClause?.namedBindings;
+  return namedBindings && ts__namespace.isNamedImports(namedBindings) ? namedBindings.elements : void 0;
+}
+function getImportName(importSpecifier) {
+  return importSpecifier.propertyName?.text ?? importSpecifier.name.text;
+}
+function findMakeJayComponentImport(makeJayComponentName, node) {
+  if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === compilerShared.JAY_COMPONENT) {
+    let importSpecifier = getImportSpecifiers(node)?.find(
+      (element) => getImportName(element) === makeJayComponentName
+    );
+    if (importSpecifier) {
+      return importSpecifier.name.text;
+    }
+  }
+  return void 0;
+}
+function findComponentConstructorsBlock(componentFunctionExpressions, sourceFile) {
+  const foundConstructors = [];
+  const namedConstructors = new Set(
+    componentFunctionExpressions.filter((expression) => ts.isIdentifier(expression)).map((expression) => ts.isIdentifier(expression) && expression.text)
+  );
+  const inlineConstructors = componentFunctionExpressions.filter(
+    isFunctionLikeDeclarationBase
+  );
+  function visit(node) {
+    if (ts.isFunctionDeclaration(node)) {
+      if (namedConstructors.has(node?.name.text))
+        foundConstructors.push(node);
+    } else if (ts.isVariableStatement(node)) {
+      node.declarationList.declarations.forEach((declaration) => {
+        if (ts.isIdentifier(declaration.name) && namedConstructors.has(declaration.name.text) && declaration.initializer && ts.isArrowFunction(declaration.initializer))
+          foundConstructors.push(declaration.initializer);
+      });
+    }
+    ts.forEachChild(node, visit);
+  }
+  ts.forEachChild(sourceFile, visit);
+  return [...foundConstructors, ...inlineConstructors];
+}
+function mkParameterVariableRoot(param, paramIndex) {
+  return { kind: 0, param, paramIndex };
+}
+function mkFunctionVariableRoot(func) {
+  return { kind: 1, func };
+}
+function mkLiteralVariableRoot(literal) {
+  return { kind: 2, literal };
+}
+function mkImportModuleVariableRoot(module2, importType) {
+  return { kind: 3, module: module2, importType };
+}
+function mkFunctionCallVariableRoot(node) {
+  return { kind: 4, node };
+}
+function mkGlobalVariableRoot(name) {
+  return { kind: 5, name };
+}
+function mkOtherVariableRoot(node) {
+  return { kind: 6, node };
+}
+function isParamVariableRoot(vr) {
+  return vr.kind === 0;
+}
+function isFunctionVariableRoot(vr) {
+  return vr.kind === 1;
+}
+function isImportModuleVariableRoot(vr) {
+  return vr.kind === 3;
+}
+function isLiteralVariableRoot(vr) {
+  return vr.kind === 2;
+}
+function isFunctionCallVariableRoot(vr) {
+  return vr.kind === 4;
+}
+function isGlobalVariableRoot(vr) {
+  return vr.kind === 5;
+}
+var LetOrConst = /* @__PURE__ */ ((LetOrConst2) => {
+  LetOrConst2[LetOrConst2["LET"] = 0] = "LET";
+  LetOrConst2[LetOrConst2["CONST"] = 1] = "CONST";
+  return LetOrConst2;
+})(LetOrConst || {});
+function mkVariable(members) {
+  return Object.fromEntries(Object.entries(members).filter(([, value]) => value !== void 0));
+}
+const UNKNOWN_VARIABLE = {};
+const getAccessedByProperty = (binding, accessedFrom, propertyName) => {
+  return accessedFrom ? propertyName ? ts.isIdentifier(propertyName) ? propertyName.text : void 0 : binding.text : void 0;
+};
+function findDeclaringStatement(node) {
+  if (!node)
+    return void 0;
+  else if (ts.isStatement(node))
+    return node;
+  else
+    return findDeclaringStatement(node.parent);
+}
+function tsBindingNameToVariable(binding, accessedFrom, assignedFrom, propertyName, root) {
+  if (ts.isIdentifier(binding)) {
+    return [
+      mkVariable({
+        name: binding.text,
+        accessedFrom,
+        accessedByProperty: getAccessedByProperty(binding, accessedFrom, propertyName),
+        assignedFrom,
+        root,
+        definingStatement: findDeclaringStatement(binding)
+      })
+    ];
+  } else if (ts.isObjectBindingPattern(binding)) {
+    let variable = mkVariable({
+      accessedFrom,
+      accessedByProperty: propertyName ? ts.isIdentifier(propertyName) ? propertyName.text : void 0 : void 0,
+      assignedFrom,
+      root,
+      definingStatement: findDeclaringStatement(binding)
+    });
+    return binding.elements.flatMap((element) => {
+      return tsBindingNameToVariable(element.name, variable, void 0, element.propertyName);
+    });
+  } else if (ts.isArrayBindingPattern(binding)) {
+    let variable = mkVariable({
+      accessedFrom,
+      accessedByProperty: propertyName ? ts.isIdentifier(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, {
+        kind: 80,
+        text: "" + index
+      });
+    }).filter((variable2) => !!variable2);
+  }
+}
+class NameBindingResolver {
+  constructor(parentNameResolver) {
+    __publicField(this, "variables", /* @__PURE__ */ new Map());
+    this.parentNameResolver = parentNameResolver;
+  }
+  addVariable(name, variable) {
+    this.variables.set(name, variable);
+  }
+  addFunctionParams(functionDeclaration) {
+    functionDeclaration.parameters.map((param, paramIndex) => {
+      let paramVariables = tsBindingNameToVariable(
+        param.name,
+        void 0,
+        void 0,
+        void 0,
+        mkParameterVariableRoot(param, paramIndex)
+      );
+      paramVariables.forEach((variable) => {
+        if (variable.name)
+          this.variables.set(variable.name, variable);
+      });
+    });
+  }
+  addFunctionDeclaration(statement) {
+    if (statement.name) {
+      let functionVariable = mkVariable({
+        name: statement.name.text,
+        root: mkFunctionVariableRoot(statement),
+        definingStatement: statement
+      });
+      this.variables.set(statement.name.text, functionVariable);
+    }
+  }
+  addVariableDeclarationList(declarationList) {
+    const letOrConst = declarationList.flags === ts.NodeFlags.Const ? 1 : 0;
+    declarationList.declarations.forEach((declaration) => {
+      let rightSide = declaration.initializer ? this.resolvePropertyAccessChain(declaration.initializer) : void 0;
+      let declaredVariable = tsBindingNameToVariable(
+        declaration.name,
+        void 0,
+        rightSide,
+        void 0
+      );
+      declaredVariable.forEach(
+        (variable) => this.variables.set(variable.name, { ...variable, letOrConst })
+      );
+    });
+  }
+  addVariableStatement(variableStatement) {
+    this.addVariableDeclarationList(variableStatement.declarationList);
+  }
+  getVariable(name) {
+    return this.variables.get(name) || UNKNOWN_VARIABLE;
+  }
+  resolvePropertyAccessChain(expression) {
+    if (ts.isPropertyAccessExpression(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)) {
+      const name = expression.argumentExpression.text;
+      const identifiersFromObject = this.resolvePropertyAccessChain(expression.expression);
+      return { accessedFrom: identifiersFromObject, accessedByProperty: name };
+    } else if (ts.isIdentifier(expression)) {
+      return this.resolveIdentifier(expression);
+    } else if (ts.isParenthesizedExpression(expression)) {
+      return this.resolvePropertyAccessChain(expression.expression);
+    } else if (ts.isAsExpression(expression)) {
+      return this.resolvePropertyAccessChain(expression.expression);
+    } else if (ts.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))
+              return {
+                name: property.name.text,
+                assignedFrom: this.resolveIdentifier(property.initializer)
+              };
+            else if (ts.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)) {
+              return {
+                name: property.name.text,
+                root: mkFunctionVariableRoot(property.initializer)
+              };
+            } else
+              return {
+                name: property.name.text,
+                root: mkLiteralVariableRoot(property.initializer)
+              };
+          } else if (ts.isShorthandPropertyAssignment(property))
+            return {
+              name: property.name.text,
+              assignedFrom: this.resolveIdentifier(property.name)
+            };
+        })
+      };
+    } else if (ts.isArrowFunction(expression) || ts.isFunctionExpression(expression)) {
+      return { root: mkFunctionVariableRoot(expression) };
+    } else if (ts.isCallExpression(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) {
+      return { root: mkLiteralVariableRoot(expression) };
+    } else {
+      return { root: mkOtherVariableRoot(expression) };
+    }
+  }
+  resolvePropertyAccess(expression) {
+    return this.resolvePropertyAccessChain(expression);
+  }
+  resolveIdentifier(expression) {
+    let variableName = expression.text;
+    let nameResolver = this;
+    let resolved;
+    while ((resolved = nameResolver.getVariable(variableName)) === UNKNOWN_VARIABLE && nameResolver.parentNameResolver)
+      nameResolver = nameResolver.parentNameResolver;
+    if (resolved === UNKNOWN_VARIABLE)
+      return { root: mkGlobalVariableRoot(variableName) };
+    return resolved;
+  }
+  addImportDeclaration(node) {
+    if (node.importClause?.name) {
+      let root = mkImportModuleVariableRoot(
+        node.moduleSpecifier,
+        0
+        /* defaultImport */
+      );
+      let variable = mkVariable({
+        name: node.importClause.name.text,
+        definingStatement: node,
+        root
+      });
+      this.variables.set(node.importClause.name.text, variable);
+    }
+    if (node.importClause?.namedBindings) {
+      let root = mkImportModuleVariableRoot(
+        node.moduleSpecifier,
+        1
+        /* namedImport */
+      );
+      let namedBindings = node.importClause.namedBindings;
+      if (ts.isNamespaceImport(namedBindings)) {
+        let variable = mkVariable({
+          name: namedBindings.name.text,
+          definingStatement: node,
+          root
+        });
+        this.variables.set(namedBindings.name.text, variable);
+      } else if (ts.isNamedImports(namedBindings)) {
+        namedBindings.elements.forEach((importSpecifier) => {
+          if (!importSpecifier.isTypeOnly) {
+            let variable = mkVariable({
+              name: importSpecifier.name.text,
+              accessedByProperty: (importSpecifier.propertyName || importSpecifier.name).text,
+              accessedFrom: {
+                definingStatement: node,
+                root
+              },
+              definingStatement: node
+            });
+            this.variables.set(importSpecifier.name.text, variable);
+          }
+        });
+      }
+    }
+  }
+}
+function flattenVariable(variable, path2 = []) {
+  if (variable.assignedFrom)
+    return flattenVariable(variable.assignedFrom, path2);
+  else if (variable.accessedFrom) {
+    return flattenVariable(variable.accessedFrom, [variable.accessedByProperty, ...path2]);
+  } else if (variable.properties && !!variable.properties.find((_) => _.name === path2[0])) {
+    return flattenVariable(
+      variable.properties.find((_) => _.name === path2[0]),
+      path2.slice(1)
+    );
+  } else
+    return { path: path2, root: variable.root };
+}
+function isIdentifierOrPropertyAccessExpression(node) {
+  return ts.isIdentifier(node) || ts.isPropertyAccessExpression(node);
+}
+function byAnd() {
+  return (agg, value) => agg && value;
+}
+function findEventHandlersBlock(functionDeclaration, bindingResolver) {
+  const foundEventHandlers = [];
+  const foundEventHandlerFunctionsToHandlerIndex = /* @__PURE__ */ new Map();
+  let nextEventHandlerIndex = 0;
+  if (ts.isBlock(functionDeclaration.body)) {
+    functionDeclaration.body.statements.forEach((statement) => {
+      if (ts.isExpressionStatement(statement) && ts.isCallExpression(statement.expression)) {
+        if (isIdentifierOrPropertyAccessExpression(statement.expression.expression)) {
+          let functionVariable = bindingResolver.explain(statement.expression.expression);
+          let accessChain = flattenVariable(functionVariable);
+          if (accessChain.path.length === 2 && isParamVariableRoot(accessChain.root) && accessChain.root.param === functionDeclaration.parameters[1]) {
+            let handler = statement.expression.arguments[0];
+            if (isFunctionLikeDeclarationBase(handler))
+              foundEventHandlers.push({
+                eventHandler: handler,
+                eventHandlerCallStatement: statement,
+                handlerIndex: nextEventHandlerIndex++
+              });
+            else if (ts.isIdentifier(handler) || ts.isPropertyAccessExpression(handler)) {
+              let flattenedHandler = flattenVariable(
+                bindingResolver.explain(handler)
+              );
+              if (flattenedHandler.path.length === 0 && isFunctionVariableRoot(flattenedHandler.root))
+                foundEventHandlers.push({
+                  eventHandler: flattenedHandler.root.func,
+                  eventHandlerCallStatement: statement,
+                  handlerIndex: foundEventHandlerFunctionsToHandlerIndex.get(
+                    flattenedHandler.root
+                  ) ?? foundEventHandlerFunctionsToHandlerIndex.set(flattenedHandler.root, nextEventHandlerIndex++).get(flattenedHandler.root)
+                });
+            }
+          }
+        }
+      }
+    });
+  }
+  return foundEventHandlers;
+}
+const BUILT_IN_TYPES = ["RegExp", "Date"];
+function builtInType(text) {
+  return BUILT_IN_TYPES.findIndex((_) => _ === text) > -1;
+}
+class BuiltInResolvedType {
+  constructor(name) {
+    this.name = name;
+  }
+  canBeAssignedFrom(rightSide) {
+    return rightSide instanceof BuiltInResolvedType && this.name === rightSide.name;
+  }
+}
+class ImportFromModuleResolvedType {
+  constructor(module2, path2) {
+    this.module = module2;
+    this.path = path2;
+  }
+  canBeAssignedFrom(rightSide) {
+    if (rightSide instanceof ImportFromModuleResolvedType) {
+      let pathEqual = this.path.length === rightSide.path.length;
+      if (pathEqual) {
+        pathEqual = this.path.map((value, index) => value === rightSide.path[index]).reduce(byAnd(), true);
+      }
+      return pathEqual && this.module === rightSide.module;
+    }
+    return false;
+  }
+}
+class ArrayResolvedType {
+  constructor(itemType) {
+    this.itemType = itemType;
+  }
+  canBeAssignedFrom(rightSide) {
+    return rightSide instanceof ArrayResolvedType && this.itemType === rightSide.itemType;
+  }
+}
+class FunctionResolvedType {
+  constructor(params, returns) {
+    this.params = params;
+    this.returns = returns;
+  }
+  canBeAssignedFrom(rightSide) {
+    return rightSide instanceof FunctionResolvedType && this.returns.canBeAssignedFrom(rightSide.returns);
+  }
+}
+class UnionResolvedType {
+  constructor(types) {
+    this.types = types;
+  }
+  canBeAssignedFrom(rightSide) {
+    if (rightSide instanceof UnionResolvedType) {
+      for (const item1 of this.types)
+        for (const item2 of rightSide.types)
+          if (item1.canBeAssignedFrom(item2))
+            return true;
+    } else
+      for (const item1 of this.types)
+        if (item1.canBeAssignedFrom(rightSide))
+          return true;
+    return false;
+  }
+}
+class GlobalResolvedType {
+  constructor(name) {
+    this.name = name;
+  }
+  canBeAssignedFrom(rightSide) {
+    return rightSide instanceof GlobalResolvedType && this.name === rightSide.name;
+  }
+}
+class SpreadResolvedType {
+  constructor(arrayType) {
+    this.arrayType = arrayType;
+  }
+  canBeAssignedFrom(rightSide) {
+    return rightSide instanceof SpreadResolvedType && this.arrayType.canBeAssignedFrom(rightSide.arrayType);
+  }
+}
+class SourceFileBindingResolver {
+  constructor(sourceFile) {
+    __publicField(this, "nameBindingResolvers", /* @__PURE__ */ new Map());
+    this.nameBindingResolvers.set(sourceFile, new NameBindingResolver());
+    const nbResolversQueue = [
+      this.nameBindingResolvers.get(sourceFile)
+    ];
+    const doWithChildBindingResolver = (node, callback) => {
+      nbResolversQueue.unshift(new NameBindingResolver(nbResolversQueue[0]));
+      this.nameBindingResolvers.set(node, nbResolversQueue[0]);
+      callback();
+      node.getChildren().forEach((child) => ts.visitNode(child, visitor));
+      nbResolversQueue.shift();
+      return node;
+    };
+    const visitor = (node) => {
+      if (ts.isFunctionDeclaration(node))
+        nbResolversQueue[0].addFunctionDeclaration(node);
+      if (ts.isVariableStatement(node))
+        nbResolversQueue[0].addVariableStatement(node);
+      else if (ts.isImportDeclaration(node))
+        nbResolversQueue[0].addImportDeclaration(node);
+      else if (ts.isBlock(node))
+        return doWithChildBindingResolver(node, () => {
+        });
+      else if (isFunctionLikeDeclarationBase(node)) {
+        return doWithChildBindingResolver(
+          node,
+          () => nbResolversQueue[0].addFunctionParams(node)
+        );
+      } else if (ts.isForStatement(node) && ts.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)) {
+        return doWithChildBindingResolver(node, () => {
+          let name = node.initializer.declarations[0].name.text;
+          nbResolversQueue[0].addVariable(
+            name,
+            mkVariable({
+              name,
+              root: mkOtherVariableRoot(node),
+              definingStatement: node
+            })
+          );
+        });
+      }
+      node.getChildren().forEach((child) => ts.visitNode(child, visitor));
+      return node;
+    };
+    ts.visitNode(sourceFile, visitor);
+  }
+  findBindingResolver(node) {
+    let found;
+    while (!(found = this.nameBindingResolvers.get(node)) && node.parent)
+      node = node.parent;
+    return found;
+  }
+  explain(identifier) {
+    return this.findBindingResolver(identifier).resolvePropertyAccessChain(identifier);
+  }
+  explainFlattenedVariableType(flattened) {
+    if (!!flattened.root) {
+      if (isImportModuleVariableRoot(flattened.root) && ts.isStringLiteral(flattened.root.module)) {
+        return new ImportFromModuleResolvedType(flattened.root.module.text, flattened.path);
+      }
+    } else
+      return void 0;
+  }
+  explainType(type) {
+    if (type) {
+      if (ts.isTypeReferenceNode(type)) {
+        let typeName = type.typeName;
+        if (ts.isIdentifier(typeName)) {
+          let resolved = this.findBindingResolver(typeName).resolveIdentifier(typeName);
+          let flattened = flattenVariable(resolved);
+          let typeFromFlattened = this.explainFlattenedVariableType(flattened);
+          if (typeFromFlattened)
+            return typeFromFlattened;
+          if (builtInType(typeName.text))
+            return new BuiltInResolvedType(typeName.text);
+        }
+      } else if (type.kind === ts.SyntaxKind.StringKeyword)
+        return new BuiltInResolvedType("string");
+      else if (type.kind === ts.SyntaxKind.NumberKeyword)
+        return new BuiltInResolvedType("number");
+      else if (type.kind === ts.SyntaxKind.BooleanKeyword)
+        return new BuiltInResolvedType("boolean");
+      else if (type.kind === ts.SyntaxKind.AnyKeyword)
+        return new BuiltInResolvedType("any");
+      else if (type.kind === ts.SyntaxKind.VoidKeyword)
+        return new BuiltInResolvedType("void");
+      else if (ts.isArrayTypeNode(type))
+        return new ArrayResolvedType(this.explainType(type.elementType));
+      else if (ts.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))
+        return new UnionResolvedType(type.types.map((aType) => this.explainType(aType)));
+    }
+    return new BuiltInResolvedType("void");
+  }
+  globalType(globalVariableRoot) {
+    return new GlobalResolvedType(globalVariableRoot.name);
+  }
+}
+function areResolvedTypesCompatible(type1, type2) {
+  return type1.canBeAssignedFrom(type2);
+}
+var CompilePatternType = /* @__PURE__ */ ((CompilePatternType2) => {
+  CompilePatternType2[CompilePatternType2["RETURN"] = 0] = "RETURN";
+  CompilePatternType2[CompilePatternType2["CALL"] = 1] = "CALL";
+  CompilePatternType2[CompilePatternType2["CHAINABLE_CALL"] = 2] = "CHAINABLE_CALL";
+  CompilePatternType2[CompilePatternType2["ASSIGNMENT_LEFT_SIDE"] = 3] = "ASSIGNMENT_LEFT_SIDE";
+  CompilePatternType2[CompilePatternType2["KNOWN_VARIABLE_READ"] = 4] = "KNOWN_VARIABLE_READ";
+  CompilePatternType2[CompilePatternType2["CONST_READ"] = 5] = "CONST_READ";
+  CompilePatternType2[CompilePatternType2["INLINE_ARROW_FUNCTION"] = 6] = "INLINE_ARROW_FUNCTION";
+  return CompilePatternType2;
+})(CompilePatternType || {});
+function areCompatiblePatternTypes(type1, type2) {
+  if (type1 === type2)
+    return true;
+  if (type1 === 1 && type2 === 2)
+    return true;
+  return type1 === 2 && type2 === 1;
+}
+const KNOWN_VARIABLE_READ_NAME = "knownVariableReadPattern";
+const CONST_READ_NAME = "knownVariableReadPattern";
+const INLINE_ARROW_FUNCTION = "inlineArrowFunctionPattern";
+var JayTargetEnv = /* @__PURE__ */ ((JayTargetEnv2) => {
+  JayTargetEnv2[JayTargetEnv2["main"] = 0] = "main";
+  JayTargetEnv2[JayTargetEnv2["any"] = 1] = "any";
+  JayTargetEnv2[JayTargetEnv2["sandbox"] = 2] = "sandbox";
+  return JayTargetEnv2;
+})(JayTargetEnv || {});
+function intersectJayTargetEnv(a, b) {
+  if (a === b && a === 1)
+    return 1;
+  if (a === 0 && b === 0 || a === 0 && b === 1 || a === 1 && b === 0)
+    return 0;
+  else
+    return 2;
+}
+function extractArgumentType(argument, sourceFileBinding, node) {
+  if (isIdentifierOrPropertyAccessExpression(argument)) {
+    const explainedArgument = flattenVariable(sourceFileBinding.explain(argument));
+    if (isParamVariableRoot(explainedArgument.root)) {
+      const paramIndex = explainedArgument.root.paramIndex;
+      return sourceFileBinding.explainType(node.parameters[paramIndex].type);
+    }
+  }
+  if (ts.isSpreadElement(argument)) {
+    return new SpreadResolvedType(
+      extractArgumentType(argument.expression, sourceFileBinding, node)
+    );
+  }
+  return void 0;
+}
+function extractArgumentTypes(callArgs, sourceFileBinding, node) {
+  return callArgs.map((argument) => {
+    return extractArgumentType(argument, sourceFileBinding, node);
+  });
+}
+function compileFunctionSplitPatternsBlock(patternFiles) {
+  const validations = [];
+  const compiledPatterns = [];
+  patternFiles.forEach((patternsFile) => {
+    const sourceFileBinding = new SourceFileBindingResolver(patternsFile);
+    const findPatternFunctions = (node) => {
+      if (ts.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")
+            declaredTargetEnv = 1;
+        });
+        let name = node.name.text;
+        node.body.statements.forEach((statement, index) => {
+          let patternTargetEnv = declaredTargetEnv;
+          let patternType;
+          let leftHandSide;
+          let callArgumentTypes = [];
+          if (ts.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) {
+            patternType = 2;
+            leftHandSide = statement.expression.expression;
+            callArgumentTypes = extractArgumentTypes(
+              statement.expression.arguments,
+              sourceFileBinding,
+              node
+            );
+          } else if (ts.isReturnStatement(statement) && ts.isNewExpression(statement.expression) && isIdentifierOrPropertyAccessExpression(statement.expression.expression)) {
+            patternType = 2;
+            leftHandSide = statement.expression.expression;
+            callArgumentTypes = extractArgumentTypes(
+              statement.expression.arguments,
+              sourceFileBinding,
+              node
+            );
+          } else if (ts.isExpressionStatement(statement) && ts.isCallExpression(statement.expression) && isIdentifierOrPropertyAccessExpression(statement.expression.expression)) {
+            patternType = 1;
+            leftHandSide = statement.expression.expression;
+            callArgumentTypes = extractArgumentTypes(
+              statement.expression.arguments,
+              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)) {
+            patternType = 3;
+            leftHandSide = statement.expression.left;
+            callArgumentTypes = [
+              extractArgumentType(
+                statement.expression.right,
+                sourceFileBinding,
+                node
+              )
+            ];
+          }
+          let resolvedLeftHandSide = flattenVariable(
+            sourceFileBinding.findBindingResolver(statement).resolvePropertyAccessChain(leftHandSide)
+          );
+          let leftSideType = void 0;
+          if (isParamVariableRoot(resolvedLeftHandSide.root)) {
+            const paramIndex = resolvedLeftHandSide.root.paramIndex;
+            leftSideType = sourceFileBinding.explainType(
+              node.parameters[paramIndex].type
+            );
+          } else if (isGlobalVariableRoot(resolvedLeftHandSide.root))
+            leftSideType = sourceFileBinding.globalType(resolvedLeftHandSide.root);
+          else if (isImportModuleVariableRoot(resolvedLeftHandSide.root))
+            leftSideType = sourceFileBinding.explainFlattenedVariableType(resolvedLeftHandSide);
+          if (patternType !== void 0 && leftSideType !== void 0) {
+            compiledPatterns.push({
+              patternType,
+              leftSidePath: resolvedLeftHandSide.path,
+              leftSideType,
+              returnType: sourceFileBinding.explainType(node.type),
+              callArgumentTypes,
+              targetEnvForStatement: patternTargetEnv,
+              name
+            });
+          } else
+            validations.push(
+              `unsupported statement, at pattern [${node.name?.text}] statement [${index}]: `,
+              astToCode(statement)
+            );
+        });
+      }
+      return node;
+    };
+    ts.transform(patternsFile, [
+      mkTransformer(({ context, sourceFile }) => {
+        ts.visitEachChild(patternsFile, findPatternFunctions, context);
+        return sourceFile;
+      })
+    ]);
+  });
+  return new compilerShared.WithValidations(compiledPatterns, validations);
+}
+function visitWithContext(node, initialContext, contextualVisitor) {
+  return visitWithContext2(node, initialContext, void 0, contextualVisitor);
+}
+function visitWithContext2(node, initialContext, transformationContext, contextualVisitor) {
+  let contexts = [initialContext];
+  const visitChild = (node2, childContext) => {
+    if (childContext)
+      contexts.push(childContext);
+    let visitedNode = ts.visitNode(node2, visitor);
+    if (childContext)
+      contexts.pop();
+    return visitedNode;
+  };
+  const visitEachChild = (node2, childContext) => {
+    if (childContext)
+      contexts.push(childContext);
+    let visitedNode = ts.visitEachChild(node2, visitor, transformationContext);
+    if (childContext)
+      contexts.pop();
+    return visitedNode;
+  };
+  const visitor = (node2) => {
+    return contextualVisitor(node2, contexts.at(-1), visitChild, visitEachChild);
+  };
+  return ts.visitNode(node, visitor);
+}
+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")
+      return true;
+  }
+  return false;
+}
+function filterEventHandlersToHaveJayEventType(foundEventHandlers, bindingResolver) {
+  return foundEventHandlers.filter((foundEventHandler) => {
+    const eventHandler = foundEventHandler.eventHandler;
+    return isFirstParamJayEvent(eventHandler, bindingResolver);
+  });
+}
+function generateFunctionRepository(matchedReturnPatterns, matchedVariableReads, matchedConstants, safeStatements) {
+  const constCode = [...new Set(matchedConstants)].join("\n");
+  let readPatternsReturnProperties = matchedReturnPatterns.map(
+    ({ pattern, patternKey }) => `$${patternKey}: ${pattern.leftSidePath.join(".")}`
+  );
+  readPatternsReturnProperties = [...new Set(readPatternsReturnProperties)];
+  let variableReadsReturnProperties = matchedVariableReads.map(
+    ({ variable, patternKey }) => `$${patternKey}: ${variable.text}`
+  );
+  let returnedObjectProperties = [
+    ...readPatternsReturnProperties,
+    ...variableReadsReturnProperties
+  ].join(",\n");
+  if (safeStatements.length > 0) {
+    const handlerCode = `({ event }: JayEvent<any, any>) => {
+    ${safeStatements.map((statement) => astToCode(statement)).join("\n	")}
+${returnedObjectProperties.length > 0 ? `	return ({${returnedObjectProperties}})
+` : ""}
+}`;
+    return { handlerCode, key: constCode };
+  }
+  if (matchedReturnPatterns.length > 0) {
+    let handlerCode = `({ event }: JayEvent<any, any>) => ({${returnedObjectProperties}})`;
+    return { handlerCode, key: constCode };
+  } else
+    return { key: void 0, handlerCode: void 0 };
+}
+const mkTransformEventHandlerStatementVisitor = (factory, context, bindingResolver, analyzer) => {
+  let sideEffects = {
+    matchedVariableReads: [],
+    matchedConstants: [],
+    mainContextBlocks: /* @__PURE__ */ new Map(),
+    matchedReturnPatterns: [],
+    wasEventHandlerTransformed: false
+  };
+  let patternIndexes = /* @__PURE__ */ new Map();
+  const getPatternIndex = (pattern) => {
+    if (!patternIndexes.has(pattern)) {
+      patternIndexes.set(pattern, patternIndexes.size);
+    }
+    return patternIndexes.get(pattern);
+  };
+  const visitor = (node, { parentStatementTargetEnv }, visitChild, visitEachChild) => {
+    if (ts.isStatement(node)) {
+      let statementAnalysis = analyzer.getStatementStatus(node);
+      if (statementAnalysis)
+        parentStatementTargetEnv = intersectJayTargetEnv(
+          parentStatementTargetEnv,
+          statementAnalysis.targetEnv
+        );
+    }
+    if (ts.isBlock(node) && parentStatementTargetEnv !== JayTargetEnv.sandbox) {
+      let sandboxStatements = [], mainStatements = [];
+      node.statements.forEach((statement) => {
+        let statementAnalysis = analyzer.getStatementStatus(statement);
+        switch (statementAnalysis.targetEnv) {
+          case JayTargetEnv.any:
+            sandboxStatements.push(statement);
+            mainStatements.push(statement);
+            break;
+          case JayTargetEnv.main:
+            mainStatements.push(statement);
+            break;
+          case JayTargetEnv.sandbox:
+            sandboxStatements.push(statement);
+            break;
+        }
+      });
+      sideEffects.mainContextBlocks.set(node, factory.createBlock(mainStatements));
+      if (sandboxStatements.length < node.statements.length)
+        sideEffects.wasEventHandlerTransformed = true;
+      sandboxStatements = sandboxStatements.map(
+        (statement) => visitChild(statement, { parentStatementTargetEnv })
+      );
+      node = factory.updateBlock(node, sandboxStatements);
+      return node;
+    } else if (ts.isExpression(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))
+          sideEffects.matchedVariableReads.push({ variable: node, patternKey });
+        else if (pattern.patternType === CompilePatternType.CONST_READ && ts.isIdentifier(node)) {
+          let constant = bindingResolver.explain(node);
+          let flattenedConstant = flattenVariable(constant);
+          let literal = flattenedConstant.root.literal;
+          if (ts.isLiteralExpression(literal)) {
+            let constantValue = literal.text;
+            sideEffects.matchedConstants.push(`const ${node.text} = ${constantValue}`);
+          }
+          return node;
+        } else
+          return node;
+        let replacementPattern = `event.$${patternKey}`;
+        sideEffects.wasEventHandlerTransformed = true;
+        return codeToAst(replacementPattern, context)[0].expression;
+      }
+    }
+    return visitEachChild(node, { parentStatementTargetEnv });
+  };
+  return { visitor, sideEffects };
+};
+const analyzeEventHandlerByPatternBlock = (context, bindingResolver, analyzer, factory, eventHandler, functionsRepository) => {
+  const scopedAnalyzer = analyzer.analyzeForScope(eventHandler);
+  const { sideEffects, visitor } = mkTransformEventHandlerStatementVisitor(
+    factory,
+    context,
+    bindingResolver,
+    scopedAnalyzer
+  );
+  let transformedEventHandler = visitWithContext2(
+    eventHandler,
+    { parentStatementTargetEnv: JayTargetEnv.any },
+    context,
+    visitor
+  );
+  if (sideEffects.wasEventHandlerTransformed && isFirstParamJayEvent(eventHandler, bindingResolver)) {
+    const originalJayEventType = eventHandler.parameters[0].type;
+    if (originalJayEventType.typeArguments?.length === 2) {
+      const transformedJayEventType = factory.createTypeReferenceNode(
+        originalJayEventType.typeName,
+        [
+          factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+          originalJayEventType.typeArguments[1]
+        ]
+      );
+      let visitor2 = (node) => {
+        if (node === originalJayEventType) {
+          return ts.visitEachChild(transformedJayEventType, visitor2, context);
+        }
+        return ts.visitEachChild(node, visitor2, context);
+      };
+      transformedEventHandler = ts.visitEachChild(transformedEventHandler, visitor2, context);
+    }
+    let bodyForFunctionRepository = void 0;
+    if (ts.isBlock(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);
+      };
+      bodyForFunctionRepository = ts.visitNode(body, replaceBodiesVisitor);
+    }
+    const { handlerCode, key } = generateFunctionRepository(
+      sideEffects.matchedReturnPatterns,
+      sideEffects.matchedVariableReads,
+      sideEffects.matchedConstants,
+      bodyForFunctionRepository ? [...bodyForFunctionRepository.statements] : []
+    );
+    const handlerKey = functionsRepository.addFunction(handlerCode);
+    functionsRepository.addConst(key);
+    return {
+      transformedEventHandler,
+      wasEventHandlerTransformed: sideEffects.wasEventHandlerTransformed,
+      handlerKey
+    };
+  } else
+    return {
+      handlerKey: "",
+      transformedEventHandler,
+      wasEventHandlerTransformed: false
+    };
+};
+const analyzeEventHandlerCall = (context, factory, handlerKey) => (node) => {
+  if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+    return factory.createCallExpression(
+      factory.createPropertyAccessExpression(
+        factory.createCallExpression(
+          factory.createPropertyAccessExpression(
+            node.expression.expression,
+            node.expression.name.text + "$"
+          ),
+          void 0,
+          codeToAst(`handler$('${handlerKey}')`, context).map(
+            (_) => _.expression
+          )
+        ),
+        factory.createIdentifier("then")
+      ),
+      void 0,
+      node.arguments
+    );
+  }
+  return node;
+};
+const analyzeEventHandlerCallStatement$Block = (context, factory, handlerKey) => (node) => {
+  return ts.visitEachChild(
+    node,
+    analyzeEventHandlerCall(context, factory, handlerKey),
+    context
+  );
+};
+function analyzedEventHandlersToReplaceMap(transformedEventHandlers) {
+  const map = /* @__PURE__ */ new Map();
+  transformedEventHandlers.forEach((_) => {
+    map.set(_.eventHandlerCallStatement, _.transformedEventHandlerCallStatement);
+    map.set(_.eventHandler, _.transformedEventHandler);
+  });
+  return map;
+}
+function analyzeEventHandlers(context, bindingResolver, analyzer, factory, foundEventHandlers, functionsRepository) {
+  let handlerToTransformedHandlers = /* @__PURE__ */ new Map();
+  foundEventHandlers.forEach((foundEventHandler) => {
+    if (!handlerToTransformedHandlers.has(foundEventHandler.eventHandler))
+      handlerToTransformedHandlers.set(
+        foundEventHandler.eventHandler,
+        analyzeEventHandlerByPatternBlock(
+          context,
+          bindingResolver,
+          analyzer,
+          factory,
+          foundEventHandler.eventHandler,
+          functionsRepository
+        )
+      );
+  });
+  return foundEventHandlers.filter(
+    (foundEventHandler) => handlerToTransformedHandlers.get(foundEventHandler.eventHandler).wasEventHandlerTransformed
+  ).map((foundEventHandler) => {
+    const { transformedEventHandler, wasEventHandlerTransformed, handlerKey } = handlerToTransformedHandlers.get(foundEventHandler.eventHandler);
+    const transformedEventHandlerCallStatement = analyzeEventHandlerCallStatement$Block(
+      context,
+      factory,
+      handlerKey
+    )(foundEventHandler.eventHandlerCallStatement);
+    return {
+      ...foundEventHandler,
+      transformedEventHandler,
+      wasEventHandlerTransformed,
+      // functionRepositoryFragment,
+      transformedEventHandlerCallStatement
+    };
+  });
+}
+class SourceFileStatementAnalyzer {
+  constructor(sourceFile, bindingResolver, compiledPatterns) {
+    this.sourceFile = sourceFile;
+    this.bindingResolver = bindingResolver;
+    this.compiledPatterns = compiledPatterns;
+  }
+  analyzeForScope(analysisScope) {
+    return new ScopedSourceFileStatementAnalyzer(
+      this.sourceFile,
+      this.bindingResolver,
+      this.compiledPatterns,
+      analysisScope
+    );
+  }
+}
+class ScopedSourceFileStatementAnalyzer {
+  constructor(sourceFile, bindingResolver, compiledPatterns, analysisScope) {
+    __publicField(this, "analyzedStatements", /* @__PURE__ */ new Map());
+    __publicField(this, "analyzedExpressions", /* @__PURE__ */ new Map());
+    __publicField(this, "nextId", 0);
+    this.sourceFile = sourceFile;
+    this.bindingResolver = bindingResolver;
+    this.compiledPatterns = compiledPatterns;
+    this.analyze(analysisScope);
+  }
+  addPatternToStatement(statement, matchedPattern) {
+    if (!this.analyzedStatements.get(statement)) {
+      this.analyzedStatements.set(statement, {
+        targetEnv: matchedPattern.patterns.reduce(
+          (prev, curr) => intersectJayTargetEnv(prev, curr.targetEnvForStatement),
+          JayTargetEnv.any
+        ),
+        matchedPatterns: [matchedPattern]
+      });
+    } else {
+      let analysisResult = this.analyzedStatements.get(statement);
+      analysisResult.matchedPatterns.push(matchedPattern);
+      analysisResult.targetEnv = intersectJayTargetEnv(
+        analysisResult.targetEnv,
+        matchedPattern.patterns.reduce(
+          (prev, curr) => intersectJayTargetEnv(prev, curr.targetEnvForStatement),
+          JayTargetEnv.any
+        )
+      );
+    }
+  }
+  markStatementSandbox(statement) {
+    if (!this.analyzedStatements.get(statement)) {
+      this.analyzedStatements.set(statement, {
+        targetEnv: JayTargetEnv.sandbox,
+        matchedPatterns: []
+      });
+    } else
+      this.analyzedStatements.get(statement).targetEnv = JayTargetEnv.sandbox;
+  }
+  analyze(analysisScope) {
+    let RoleInParent;
+    ((RoleInParent2) => {
+      RoleInParent2[RoleInParent2["none"] = 0] = "none";
+      RoleInParent2[RoleInParent2["read"] = 1] = "read";
+      RoleInParent2[RoleInParent2["assign"] = 2] = "assign";
+      RoleInParent2[RoleInParent2["call"] = 3] = "call";
+    })(RoleInParent || (RoleInParent = {}));
+    const addExpressionStatus = (statement, patterns, expression, subExpressionsMatching) => {
+      let matchedPattern = {
+        patterns,
+        expression,
+        testId: this.nextId++,
+        subExpressionsMatching
+      };
+      this.analyzedExpressions.set(expression, matchedPattern);
+      this.addPatternToStatement(statement, matchedPattern);
+    };
+    const analyzePropertyExpression = (expression, visitChild, statement, roleInParent) => {
+      let expectedPatternType = roleInParent === 2 ? CompilePatternType.ASSIGNMENT_LEFT_SIDE : CompilePatternType.RETURN;
+      let { matchedPatterns, matchType } = this.matchPattern(
+        expression,
+        expectedPatternType,
+        analysisScope
+      );
+      if (matchType === 0) {
+        addExpressionStatus(statement, matchedPatterns, expression, true);
+      } else {
+        if (ts.isPropertyAccessExpression(expression))
+          visitChild(expression.expression, {
+            statement,
+            roleInParent: 1
+            /* read */
+          });
+        this.markStatementSandbox(statement);
+      }
+    };
+    const analyzeCallParam = (argument, matchedPatterns, index, statement) => {
+      const expressionStatus = this.getExpressionStatus(argument);
+      const patternTypeMatchArgumentType = !!expressionStatus && expressionStatus.patterns.length > 0 && expressionStatus.subExpressionsMatching && areResolvedTypesCompatible(
+        expressionStatus.patterns[0].returnType,
+        matchedPatterns[0].callArgumentTypes[index]
+      );
+      const isLiteral = ts.isLiteralExpression(argument);
+      let isScopedVariableAccess = false;
+      if (isIdentifierOrPropertyAccessExpression(argument)) {
+        const variable = this.bindingResolver.explain(argument);
+        const flattened = flattenVariable(variable);
+        isScopedVariableAccess = isParamVariableRoot(flattened.root) && isChildOf(flattened.root.param, analysisScope);
+      }
+      const paramMatching = patternTypeMatchArgumentType || isLiteral || isScopedVariableAccess;
+      if (!paramMatching)
+        this.markStatementSandbox(statement);
+      return paramMatching;
+    };
+    const analyzeCallOrNewExpression = (node, visitChild, statement, roleInParent) => {
+      if (isIdentifierOrPropertyAccessExpression(node.expression)) {
+        let expression = node.expression;
+        node.arguments.forEach(
+          (argument) => visitChild(argument, {
+            statement,
+            roleInParent: 1
+            /* read */
+          })
+        );
+        let expectedPatternType = roleInParent === 3 ? CompilePatternType.CALL : CompilePatternType.CHAINABLE_CALL;
+        let { matchedPatterns, matchType } = this.matchPattern(
+          expression,
+          expectedPatternType,
+          analysisScope
+        );
+        if (matchType === 0) {
+          let areArgumentsMatching = node.arguments.map((argument, index) => {
+            return analyzeCallParam(argument, matchedPatterns, index, statement);
+          }).reduce(byAnd(), true);
+          addExpressionStatus(statement, matchedPatterns, node, areArgumentsMatching);
+        } else {
+          if (ts.isPropertyAccessExpression(node.expression))
+            visitChild(node.expression.expression, {
+              statement,
+              roleInParent: 1
+              /* read */
+            });
+          this.markStatementSandbox(statement);
+        }
+      } else
+        this.markStatementSandbox(statement);
+    };
+    visitWithContext(
+      this.sourceFile,
+      {
+        roleInParent: 0
+        /* none */
+      },
+      (node, { statement, roleInParent }, visitChild) => {
+        if (ts.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)) {
+            analyzeCallOrNewExpression(node, visitChild, statement, roleInParent);
+            return node;
+          } else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken)
+            this.markStatementSandbox(statement);
+          else if (!ts.isLiteralExpression(node) && !ts.isBinaryExpression(node))
+            this.markStatementSandbox(statement);
+        }
+        if (ts.isCallExpression(node) && isIdentifierOrPropertyAccessExpression(node.expression) && roleInParent === 0) {
+          analyzeCallOrNewExpression(
+            node,
+            visitChild,
+            statement,
+            3
+            /* call */
+          );
+        } else if (ts.isVariableStatement(node)) {
+          node.declarationList.declarations.forEach(
+            (declaration) => visitChild(declaration.initializer, {
+              statement,
+              roleInParent: 1
+              /* read */
+            })
+          );
+          if (this.getStatementStatus(node)?.targetEnv === JayTargetEnv.any)
+            this.getStatementStatus(node).targetEnv = JayTargetEnv.main;
+        } else if (ts.isArrowFunction(node) && !ts.isBlock(node.body)) {
+          visitChild(node.body, {
+            statement,
+            roleInParent: 1
+            /* read */
+          });
+          const bodyStatus = this.getExpressionStatus(node.body);
+          if (!!bodyStatus && bodyStatus.subExpressionsMatching) {
+            addExpressionStatus(
+              statement,
+              [
+                {
+                  patternType: CompilePatternType.INLINE_ARROW_FUNCTION,
+                  returnType: new FunctionResolvedType(
+                    [],
+                    bodyStatus.patterns[0].returnType
+                  ),
+                  callArgumentTypes: [],
+                  targetEnvForStatement: JayTargetEnv.any,
+                  name: INLINE_ARROW_FUNCTION,
+                  leftSidePath: [],
+                  leftSideType: new FunctionResolvedType(
+                    [],
+                    bodyStatus.patterns[0].returnType
+                  )
+                }
+              ],
+              node,
+              true
+            );
+          }
+        } else if (ts.isIfStatement(node)) {
+          visitChild(node.expression, {
+            statement,
+            roleInParent: 1
+            /* read */
+          });
+          visitChild(node.thenStatement, {
+            statement,
+            roleInParent: 0
+            /* none */
+          });
+          if (node.elseStatement)
+            visitChild(node.elseStatement, {
+              statement,
+              roleInParent: 0
+              /* none */
+            });
+        } else if (ts.isForStatement(node) || ts.isForOfStatement(node) || ts.isForInStatement(node) || ts.isWhileStatement(node) || ts.isDoStatement(node)) {
+          this.markStatementSandbox(statement);
+          node.getChildren().forEach(
+            (child) => visitChild(child, {
+              statement,
+              roleInParent: 0
+              /* none */
+            })
+          );
+        } else if (ts.isBinaryExpression(node)) {
+          visitChild(node.right, {
+            statement,
+            roleInParent: 1
+            /* read */
+          });
+          visitChild(node.left, {
+            statement,
+            roleInParent: node.operatorToken.kind === ts.SyntaxKind.EqualsToken ? 2 : 1
+            /* read */
+          });
+        } else if (ts.isElementAccessExpression(node)) {
+          node.getChildren().forEach(
+            (child) => visitChild(child, {
+              statement,
+              roleInParent: 1
+              /* read */
+            })
+          );
+        } else {
+          node.getChildren().forEach(
+            (child) => visitChild(child, {
+              statement,
+              roleInParent: 0
+              /* none */
+            })
+          );
+        }
+        return node;
+      }
+    );
+  }
+  matchPattern(patternTarget, expectedPatternType, analysisScope) {
+    let variable = this.bindingResolver.explain(patternTarget);
+    let resolvedVariable = flattenVariable(variable);
+    let matchedPatterns = [];
+    let currentVariableType;
+    if (resolvedVariable.root) {
+      if (isParamVariableRoot(resolvedVariable.root))
+        currentVariableType = this.bindingResolver.explainType(
+          resolvedVariable.root.param.type
+        );
+      else if (isGlobalVariableRoot(resolvedVariable.root)) {
+        currentVariableType = this.bindingResolver.globalType(resolvedVariable.root);
+      } else if (isFunctionCallVariableRoot(resolvedVariable.root)) {
+        let matchedPattern = this.getExpressionStatus(resolvedVariable.root.node);
+        if (matchedPattern) {
+          currentVariableType = matchedPattern.patterns.at(-1).returnType;
+        }
+      } else if (isImportModuleVariableRoot(resolvedVariable.root)) {
+        currentVariableType = this.bindingResolver.explainFlattenedVariableType(resolvedVariable);
+      }
+    }
+    if (resolvedVariable.path.length === 0 && resolvedVariable.root && isLiteralVariableRoot(resolvedVariable.root)) {
+      if (variable.letOrConst === LetOrConst.CONST)
+        return {
+          matchedPatterns: [
+            {
+              patternType: CompilePatternType.CONST_READ,
+              returnType: currentVariableType,
+              callArgumentTypes: [],
+              targetEnvForStatement: JayTargetEnv.any,
+              name: CONST_READ_NAME,
+              leftSidePath: [],
+              leftSideType: currentVariableType
+            }
+          ],
+          matchType: 0
+          /* FULL */
+        };
+      else
+        return {
+          matchedPatterns: [],
+          matchType: 2
+          /* NONE */
+        };
+    }
+    if (currentVariableType) {
+      let currentPosition = 0;
+      while (currentPosition <= resolvedVariable.path.length) {
+        if (resolvedVariable.path.length === 0) {
+          if (variable.definingStatement && isChildOf(variable.definingStatement, analysisScope)) {
+            return {
+              matchedPatterns: [
+                {
+                  patternType: CompilePatternType.KNOWN_VARIABLE_READ,
+                  returnType: currentVariableType,
+                  callArgumentTypes: [],
+                  targetEnvForStatement: JayTargetEnv.any,
+                  name: KNOWN_VARIABLE_READ_NAME,
+                  leftSidePath: [],
+                  leftSideType: currentVariableType
+                }
+              ],
+              matchType: 0
+              /* FULL */
+            };
+          }
+        }
+        let currentMatch = this.compiledPatterns.find((pattern) => {
+          let leftTypeMatch = areResolvedTypesCompatible(
+            currentVariableType,
+            pattern.leftSideType
+          );
+          let pathMatch = currentPosition + pattern.leftSidePath.length <= resolvedVariable.path.length && pattern.leftSidePath.every(
+            (element, index) => element === resolvedVariable.path[index + currentPosition]
+          );
+          let expectedTypeMatch = currentPosition + pattern.leftSidePath.length === resolvedVariable.path.length ? areCompatiblePatternTypes(pattern.patternType, expectedPatternType) : areCompatiblePatternTypes(
+            pattern.patternType,
+            CompilePatternType.RETURN
+          );
+          return leftTypeMatch && pathMatch && expectedTypeMatch;
+        });
+        if (currentMatch) {
+          matchedPatterns.push(currentMatch);
+          if (currentPosition + currentMatch.leftSidePath.length < resolvedVariable.path.length) {
+            currentVariableType = currentMatch.returnType;
+            currentPosition += currentMatch.leftSidePath.length;
+          } else
+            return {
+              matchedPatterns,
+              matchType: 0
+              /* FULL */
+            };
+        } else
+          return {
+            matchedPatterns,
+            matchType: matchedPatterns.length > 0 ? 1 : 2
+            /* NONE */
+          };
+      }
+    }
+    return {
+      matchedPatterns: [],
+      matchType: 2
+      /* NONE */
+    };
+  }
+  getExpressionStatus(expression) {
+    return this.analyzedExpressions.get(expression);
+  }
+  getStatementStatus(statement) {
+    return this.analyzedStatements.get(statement);
+  }
+  getMatchedExpressions() {
+    return this.analyzedExpressions.keys();
+  }
+  getAnalyzedStatements() {
+    return this.analyzedStatements.keys();
+  }
+}
+function isChildOf(node, parent) {
+  if (node === parent)
+    return false;
+  if (!node.parent)
+    return false;
+  for (const sibling of node.parent.getChildren())
+    if (sibling === node)
+      return true;
+  return isChildOf(node.parent, parent);
+}
+var FindComponentConstructorType = /* @__PURE__ */ ((FindComponentConstructorType2) => {
+  FindComponentConstructorType2["makeJayComponent"] = "makeJayComponent";
+  FindComponentConstructorType2["makeJayTsxComponent"] = "makeJayTsxComponent";
+  return FindComponentConstructorType2;
+})(FindComponentConstructorType || {});
+function findComponentConstructorCalls(findType, bindingResolver, node) {
+  const foundConstructorCalls = [];
+  if (ts.isVariableStatement(node)) {
+    node.declarationList.declarations.forEach((declaration) => {
+      if (declaration.initializer && ts.isCallExpression(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) {
+          let render = findType === "makeJayComponent" ? declaration.initializer.arguments[0] : void 0;
+          let comp = findType === "makeJayComponent" ? declaration.initializer.arguments[1] : declaration.initializer.arguments[0];
+          let foundConstructor = {
+            type: findType,
+            name: declaration.name,
+            render,
+            comp
+          };
+          foundConstructorCalls.push(foundConstructor);
+        }
+      }
+    });
+  }
+  return foundConstructorCalls;
+}
+function findComponentConstructorCallsBlock(findType, bindingResolver, sourceFile) {
+  const foundConstructorCalls = [];
+  function visit(node) {
+    foundConstructorCalls.push(
+      ...findComponentConstructorCalls(findType, bindingResolver, node)
+    );
+    ts.forEachChild(node, visit);
+  }
+  ts.forEachChild(sourceFile, visit);
+  return foundConstructorCalls;
+}
+class GeneratedFunctionRepository {
+  constructor(hasFunctionRepository, functionRepository) {
+    this.hasFunctionRepository = hasFunctionRepository;
+    this.functionRepository = functionRepository;
+  }
+  map(mapper) {
+    return new GeneratedFunctionRepository(
+      this.hasFunctionRepository,
+      mapper(this.functionRepository)
+    );
+  }
+}
+class FunctionRepositoryBuilder {
+  constructor() {
+    __publicField(this, "fragments", []);
+    __publicField(this, "consts", []);
+    __publicField(this, "nextIndex", 0);
+  }
+  addFunction(handlerCode) {
+    if (!handlerCode)
+      return void 0;
+    const key = `${this.nextIndex++}`;
+    this.fragments.push({ key, handlerCode });
+    return key;
+  }
+  addConst(constCode) {
+    if (!constCode)
+      return;
+    this.consts.push(constCode);
+  }
+  generate() {
+    if (this.fragments.length > 0) {
+      let fragments = [
+        ...new Set(this.fragments.map((_) => `'${_.key}': ${_.handlerCode}`))
+      ].join(",\n");
+      let uniqueConstants = [...new Set(this.consts)];
+      let constantsCodeFragment = uniqueConstants.length > 0 ? uniqueConstants.join("\n") + "\n\n" : "";
+      let functionRepository = `${constantsCodeFragment}const funcRepository: FunctionsRepository = {
+${fragments}
+};`;
+      return new GeneratedFunctionRepository(true, functionRepository);
+    } else
+      return new GeneratedFunctionRepository(
+        false,
+        "const funcRepository: FunctionsRepository = {}"
+      );
+  }
+  generateGlobalFile() {
+    return this.generate().map(
+      (_) => `import {FunctionsRepository} from "@jay-framework/secure";
+
+export ${_}`
+    );
+  }
+}
+function findExec$(bindingResolver, sourceFile) {
+  const foundExec$ = [];
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.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")
+        foundExec$.push(node);
+    }
+    ts.forEachChild(node, visit);
+  }
+  ts.forEachChild(sourceFile, visit);
+  return foundExec$;
+}
+function analyzeGlobalExec$(context, analyzer, functionRepositoryBuilder, foundExec$) {
+  const scopedAnalyzer = analyzer.analyzeForScope(foundExec$);
+  let foundUnsafeExpression = false;
+  const visitor = (node) => {
+    if (ts.isExpression(node)) {
+      const matchedPattern = scopedAnalyzer.getExpressionStatus(node);
+      foundUnsafeExpression = foundUnsafeExpression || !matchedPattern || !matchedPattern.subExpressionsMatching;
+    } else {
+      node.getChildren().forEach((child) => ts.visitNode(child, visitor));
+    }
+    return node;
+  };
+  if (ts.isArrowFunction(foundExec$.arguments[0]))
+    ts.visitNode(foundExec$.arguments[0].body, visitor);
+  if (foundUnsafeExpression)
+    return { foundExec$, wasTransformed: false };
+  else {
+    const key = functionRepositoryBuilder.addFunction(astToCode(foundExec$.arguments[0]));
+    const transformedExec$ = codeToAst(`exec$(funcGlobal$('${key}'))`, context).map(
+      (_) => _.expression
+    )[0];
+    return { foundExec$, wasTransformed: true, transformedExec$ };
+  }
+}
+function analyseGlobalExec$s(context, analyzer, functionRepositoryBuilder, foundExec$s) {
+  return foundExec$s.map(
+    (foundExec$) => analyzeGlobalExec$(context, analyzer, functionRepositoryBuilder, foundExec$)
+  );
+}
+function transformedGlobalExec$toReplaceMap(transformedGlobalExec$s) {
+  const map = /* @__PURE__ */ new Map();
+  transformedGlobalExec$s.filter((_) => _.wasTransformed).forEach((_) => {
+    map.set(_.foundExec$, _.transformedExec$);
+  });
+  return map;
+}
+function generateComponentConstructorCalls(context, componentConstructorCalls, hasFunctionRepository) {
+  let optionsParam = hasFunctionRepository ? ", { funcRepository }" : "";
+  let transformedConstructors = componentConstructorCalls.map(({ name, render }) => {
+    return `${astToCode(name)} = makeJayComponentBridge(${astToCode(render)}${optionsParam})`;
+  });
+  if (transformedConstructors.length > 0) {
+    let declarationCode = `export const ${transformedConstructors.join(", ")}`;
+    return codeToAst(declarationCode, context)[0];
+  } else
+    return void 0;
+}
+function getRenderImportSpecifier(node) {
+  const namedBindings = node.importClause?.namedBindings;
+  switch (namedBindings?.kind) {
+    case ts.SyntaxKind.NamedImports: {
+      return namedBindings.elements.find((binding) => getImportName(binding) === "render");
+    }
+    default:
+      return void 0;
+  }
+}
+function transformImport(node, importerMode, context, hasFunctionRepository) {
+  if (ts.isStringLiteral(node.moduleSpecifier)) {
+    if (findMakeJayComponentImport(compilerShared.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(
+        true,
+        importerMode
+      )}`;
+      return codeToAst(
+        `import { ${astToCode(renderImportSpecifier)} } from '${importModule}'`,
+        context
+      )[0];
+    }
+    if (node.moduleSpecifier.text === "@jay-framework/runtime")
+      return node;
+    if (node.moduleSpecifier.text.endsWith(".css") && !node.importClause)
+      return node;
+    return void 0;
+  }
+  return void 0;
+}
+function transformSourceFile(sourceFile, factory, context, importerMode, componentConstructorCalls, componentFunctionRepository) {
+  let { functionRepository, hasFunctionRepository } = componentFunctionRepository.generate();
+  let generatedComponentConstructorCalls = generateComponentConstructorCalls(
+    context,
+    componentConstructorCalls,
+    hasFunctionRepository
+  );
+  let transformedStatements = sourceFile.statements.map((statement) => {
+    if (ts.isInterfaceDeclaration(statement))
+      return statement;
+    else if (ts.isImportDeclaration(statement))
+      return transformImport(statement, importerMode, context, hasFunctionRepository);
+    else
+      return void 0;
+  }).filter((_) => !!_);
+  const funcRepositoryStatements = hasFunctionRepository ? codeToAst(functionRepository, context) : [];
+  let allStatements = [
+    ...transformedStatements,
+    ...funcRepositoryStatements,
+    generatedComponentConstructorCalls
+  ].filter((_) => !!_);
+  return factory.updateSourceFile(sourceFile, allStatements);
+}
+function mkComponentBridgeTransformer({
+  factory,
+  sourceFile,
+  context,
+  importerMode,
+  patterns,
+  globalFunctionRepository
+}) {
+  let bindingResolver = new SourceFileBindingResolver(sourceFile);
+  let calls = findComponentConstructorCallsBlock(
+    FindComponentConstructorType.makeJayComponent,
+    bindingResolver,
+    sourceFile
+  );
+  let constructorExpressions = calls.map(({ comp }) => comp);
+  let constructorDefinitions = findComponentConstructorsBlock(constructorExpressions, sourceFile);
+  let foundEventHandlers = constructorDefinitions.flatMap(
+    (constructorDefinition) => findEventHandlersBlock(constructorDefinition, bindingResolver)
+  );
+  const elementsEventHandlers = filterEventHandlersToHaveJayEventType(
+    foundEventHandlers,
+    bindingResolver
+  );
+  let analyzer = new SourceFileStatementAnalyzer(sourceFile, bindingResolver, patterns);
+  const componentFunctionRepository = new FunctionRepositoryBuilder();
+  analyzeEventHandlers(
+    context,
+    bindingResolver,
+    analyzer,
+    factory,
+    elementsEventHandlers,
+    componentFunctionRepository
+  );
+  const foundExec$ = findExec$(bindingResolver, sourceFile);
+  analyseGlobalExec$s(context, analyzer, globalFunctionRepository, foundExec$);
+  return transformSourceFile(
+    sourceFile,
+    factory,
+    context,
+    importerMode,
+    calls,
+    componentFunctionRepository
+  );
+}
+function transformComponentBridge(importerMode, patterns = [], globalFunctionRepository) {
+  return mkTransformer(mkComponentBridgeTransformer, {
+    importerMode,
+    patterns,
+    globalFunctionRepository
+  });
+}
+function transformImportModeFileExtension(node, factory, importerMode) {
+  if (!ts.isStringLiteral(node.moduleSpecifier))
+    return void 0;
+  const originalTarget = node.moduleSpecifier.text;
+  if (!isRelativeImport(originalTarget))
+    return node;
+  return factory.updateImportDeclaration(
+    node,
+    node.modifiers,
+    node.importClause,
+    factory.createStringLiteral(`${originalTarget}${compilerShared.getModeFileExtension(true, importerMode)}`),
+    node.attributes
+  );
+}
+function findAfterImportStatementIndex(statements) {
+  let lastIndex = 0;
+  while (ts.isImportDeclaration(statements[lastIndex]))
+    lastIndex += 1;
+  return lastIndex;
+}
+function transformComponentImports(needsHandler$, needsFunc$, needsFuncGlobal$, transformedSourceFile, context, factory, sourceFile) {
+  if (needsHandler$ || needsFunc$ || needsFuncGlobal$) {
+    const statements = [...transformedSourceFile.statements];
+    const afterImportStatementIndex = findAfterImportStatementIndex(statements);
+    const importClause = [
+      ...needsHandler$ ? ["handler$"] : [],
+      ...needsFunc$ ? ["func$"] : [],
+      ...needsFuncGlobal$ ? ["funcGlobal$"] : []
+    ].join(", ");
+    const allStatements = [
+      ...statements.slice(0, afterImportStatementIndex),
+      codeToAst(
+        `import { ${importClause} } from '${compilerShared.JAY_SECURE}';`,
+        context
+      )[0],
+      ...statements.slice(afterImportStatementIndex)
+    ];
+    return factory.updateSourceFile(sourceFile, allStatements);
+  } else
+    return transformedSourceFile;
+}
+function isCssImport(node) {
+  return ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text.endsWith(".css");
+}
+function mkComponentTransformer(sftContext) {
+  const { patterns, globalFunctionRepository, context, factory, sourceFile } = sftContext;
+  const bindingResolver = new SourceFileBindingResolver(sourceFile);
+  const calls = findComponentConstructorCallsBlock(
+    FindComponentConstructorType.makeJayComponent,
+    bindingResolver,
+    sourceFile
+  );
+  const constructorExpressions = calls.map(({ comp }) => comp);
+  const constructorDefinitions = findComponentConstructorsBlock(
+    constructorExpressions,
+    sourceFile
+  );
+  const foundEventHandlers = constructorDefinitions.flatMap(
+    (constructorDefinition) => findEventHandlersBlock(constructorDefinition, bindingResolver)
+  );
+  const elementsEventHandlers = filterEventHandlersToHaveJayEventType(
+    foundEventHandlers,
+    bindingResolver
+  );
+  const analyzer = new SourceFileStatementAnalyzer(sourceFile, bindingResolver, patterns);
+  const componentFunctionRepository = new FunctionRepositoryBuilder();
+  const transformedEventHandlers = analyzeEventHandlers(
+    context,
+    bindingResolver,
+    analyzer,
+    factory,
+    elementsEventHandlers,
+    componentFunctionRepository
+  );
+  const eventsReplaceMap = analyzedEventHandlersToReplaceMap(transformedEventHandlers);
+  const foundExec$ = findExec$(bindingResolver, sourceFile);
+  const transformedGlobalExec$ = analyseGlobalExec$s(
+    context,
+    analyzer,
+    globalFunctionRepository,
+    foundExec$
+  );
+  const globalExec$ReplaceMap = transformedGlobalExec$toReplaceMap(transformedGlobalExec$);
+  const replaceMap = new Map([...eventsReplaceMap, ...globalExec$ReplaceMap]);
+  let visitor = (node) => {
+    if (replaceMap.has(node)) {
+      node = replaceMap.get(node);
+      return ts.visitEachChild(node, visitor, context);
+    }
+    if (ts.isImportDeclaration(node)) {
+      if (isCssImport(node))
+        return void 0;
+      else
+        return transformImportModeFileExtension(node, factory, compilerShared.RuntimeMode.WorkerSandbox);
+    }
+    return ts.visitEachChild(node, visitor, context);
+  };
+  let transformedSourceFile = ts.visitEachChild(sftContext.sourceFile, visitor, context);
+  return transformComponentImports(
+    transformedEventHandlers.length > 0,
+    false,
+    transformedGlobalExec$.length > 0,
+    transformedSourceFile,
+    context,
+    factory,
+    sourceFile
+  );
+}
+function transformComponent(patterns = [], globalFunctionRepository) {
+  return mkTransformer(mkComponentTransformer, { patterns, globalFunctionRepository });
+}
+function createTsSourceFileFromSource(filePath, sourceCode, scriptKind = ts__namespace.ScriptKind.TS) {
+  try {
+    return ts__namespace.createSourceFile(filePath, sourceCode, ts__namespace.ScriptTarget.Latest, true, scriptKind);
+  } catch (error) {
+    throw compilerShared.withOriginalTrace(
+      new Error(`Failed to create TypeScript source file for ${filePath}`),
+      error
+    );
+  }
+}
+function generateImportsFileFromTsSource(filename, source) {
+  const sourceFile = createTsSourceFileFromSource(filename, source);
+  return fromImportModules(extractImportedModules(sourceFile));
+}
+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");
+}
+function parseImportLinks(sourceFile) {
+  const importDeclarations = extractImportDeclarations(sourceFile).filter(
+    (importDeclaration) => ts__namespace.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 names = getJayImportNames(importDeclaration);
+    return { module: module2, names, sandbox };
+  });
+  return importLinks;
+}
+function getJayImportNames(importDeclaration) {
+  const importSpecifiers = getImportSpecifiers(importDeclaration);
+  return importSpecifiers?.map((importSpecifier) => {
+    const as = importSpecifier.propertyName?.text ? importSpecifier.name.text : void 0;
+    const name = getImportName(importSpecifier);
+    return {
+      name,
+      ...as && { as },
+      type: compilerShared.JayUnknown
+    };
+  }) || [];
+}
+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(),
+    { delimiter: "" }
+  );
+  return new compilerShared.WithValidations(
+    {
+      format: compilerShared.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;