@jay-framework/compiler 0.6.9 → 0.7.0

package/dist/index.js

@@ -10,24 +10,27 @@ 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 s = createRequire(import.meta.url), e = s("typescript"), c = new Proxy(e, {
+  get(t, r) {
+    return t[r];
+  }
+});
 const {
+  visitEachChild: visitEachChild$5,
   isArrowFunction: isArrowFunction$4,
-  isConstructorDeclaration,
-  isFunctionDeclaration: isFunctionDeclaration$3,
   isFunctionExpression: isFunctionExpression$1,
-  isGetAccessorDeclaration,
+  createSourceFile: createSourceFile$1,
+  ScriptTarget: ScriptTarget$1,
+  isFunctionDeclaration: isFunctionDeclaration$3,
   isMethodDeclaration,
+  isConstructorDeclaration,
+  isGetAccessorDeclaration,
   isSetAccessorDeclaration,
   createPrinter,
+  NewLineKind,
   EmitHint,
-  createSourceFile: createSourceFile$1,
-  ScriptTarget: ScriptTarget$1,
-  setTextRange,
-  visitEachChild: visitEachChild$5,
-  NewLineKind
-} = tsModule$m;
+  setTextRange
+} = c;
 const printer = createPrinter({
   newLine: NewLineKind.LineFeed
 });
@@ -45,8 +48,6 @@ function codeToAst(code, context) {
 function isFunctionLikeDeclarationBase(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;
@@ -55,9 +56,7 @@ 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;
+const { isStringLiteral: isStringLiteral$9, isImportDeclaration: isImportDeclaration$5, forEachChild: forEachChild$4, isNamedImports: isNamedImports$1 } = c;
 function extractImportDeclarations(sourceFile) {
   const importDeclarations = [];
   function visit(node) {
@@ -82,9 +81,7 @@ function getImportSpecifiers(importDeclaration) {
 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;
+const { isStringLiteral: isStringLiteral$8, forEachChild: forEachChild$3, isImportDeclaration: isImportDeclaration$4 } = c;
 function findMakeJayComponentImport(makeJayComponentName, node) {
   if (isImportDeclaration$4(node) && isStringLiteral$8(node.moduleSpecifier) && node.moduleSpecifier.text === JAY_COMPONENT) {
     let importSpecifier = getImportSpecifiers(node)?.find(
@@ -96,13 +93,11 @@ 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;
+const { isIdentifier: isIdentifier$9, isArrowFunction: isArrowFunction$3, isFunctionDeclaration: isFunctionDeclaration$2, isVariableStatement: isVariableStatement$3, forEachChild: forEachChild$2 } = c;
 function findComponentConstructorsBlock(componentFunctionExpressions, sourceFile) {
   const foundConstructors = [];
   const namedConstructors = new Set(
-    componentFunctionExpressions.filter((expression) => isIdentifier$7(expression)).map((expression) => isIdentifier$7(expression) && expression.text)
+    componentFunctionExpressions.filter((expression) => isIdentifier$9(expression)).map((expression) => isIdentifier$9(expression) && expression.text)
   );
   const inlineConstructors = componentFunctionExpressions.filter(
     isFunctionLikeDeclarationBase
@@ -113,7 +108,7 @@ function findComponentConstructorsBlock(componentFunctionExpressions, sourceFile
         foundConstructors.push(node);
     } else if (isVariableStatement$3(node)) {
       node.declarationList.declarations.forEach((declaration) => {
-        if (isIdentifier$7(declaration.name) && namedConstructors.has(declaration.name.text) && declaration.initializer && isArrowFunction$3(declaration.initializer))
+        if (isIdentifier$9(declaration.name) && namedConstructors.has(declaration.name.text) && declaration.initializer && isArrowFunction$3(declaration.initializer))
           foundConstructors.push(declaration.initializer);
       });
     }
@@ -122,32 +117,30 @@ function findComponentConstructorsBlock(componentFunctionExpressions, sourceFile
   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,
+  isIdentifier: isIdentifier$8,
+  isStatement: isStatement$2,
   isObjectBindingPattern,
-  isPropertyAccessExpression: isPropertyAccessExpression$5,
-  isStringLiteral: isStringLiteral$7,
-  isObjectLiteralExpression,
-  isPropertyAssignment,
-  isShorthandPropertyAssignment,
   isArrayBindingPattern,
   isBindingElement,
+  isPropertyAccessExpression: isPropertyAccessExpression$5,
+  isElementAccessExpression: isElementAccessExpression$1,
+  isStringLiteral: isStringLiteral$7,
   isParenthesizedExpression,
   isAsExpression,
-  isArrowFunction: isArrowFunction$2,
-  isFunctionExpression,
-  isStatement: isStatement$2,
+  isObjectLiteralExpression,
+  isPropertyAssignment: isPropertyAssignment$1,
+  isShorthandPropertyAssignment,
+  isNumericLiteral,
+  isToken,
   isNamespaceImport,
   isNamedImports,
+  isArrowFunction: isArrowFunction$2,
+  isFunctionExpression,
   isCallExpression: isCallExpression$6,
-  isNumericLiteral,
-  isToken,
-  SyntaxKind: SyntaxKind$5,
-  NodeFlags
-} = tsModule$i;
+  NodeFlags,
+  SyntaxKind: SyntaxKind$5
+} = c;
 function mkParameterVariableRoot(param, paramIndex) {
   return { kind: 0, param, paramIndex };
 }
@@ -197,7 +190,7 @@ function mkVariable(members) {
 }
 const UNKNOWN_VARIABLE = {};
 const getAccessedByProperty = (binding, accessedFrom, propertyName) => {
-  return accessedFrom ? propertyName ? isIdentifier$6(propertyName) ? propertyName.text : void 0 : binding.text : void 0;
+  return accessedFrom ? propertyName ? isIdentifier$8(propertyName) ? propertyName.text : void 0 : binding.text : void 0;
 };
 function findDeclaringStatement(node) {
   if (!node)
@@ -208,7 +201,7 @@ function findDeclaringStatement(node) {
     return findDeclaringStatement(node.parent);
 }
 function tsBindingNameToVariable(binding, accessedFrom, assignedFrom, propertyName, root) {
-  if (isIdentifier$6(binding)) {
+  if (isIdentifier$8(binding)) {
     return [
       mkVariable({
         name: binding.text,
@@ -222,7 +215,7 @@ function tsBindingNameToVariable(binding, accessedFrom, assignedFrom, propertyNa
   } else if (isObjectBindingPattern(binding)) {
     let variable = mkVariable({
       accessedFrom,
-      accessedByProperty: propertyName ? isIdentifier$6(propertyName) ? propertyName.text : void 0 : void 0,
+      accessedByProperty: propertyName ? isIdentifier$8(propertyName) ? propertyName.text : void 0 : void 0,
       assignedFrom,
       root,
       definingStatement: findDeclaringStatement(binding)
@@ -233,7 +226,7 @@ function tsBindingNameToVariable(binding, accessedFrom, assignedFrom, propertyNa
   } else if (isArrayBindingPattern(binding)) {
     let variable = mkVariable({
       accessedFrom,
-      accessedByProperty: propertyName ? isIdentifier$6(propertyName) ? propertyName.text : void 0 : void 0,
+      accessedByProperty: propertyName ? isIdentifier$8(propertyName) ? propertyName.text : void 0 : void 0,
       assignedFrom,
       root,
       definingStatement: findDeclaringStatement(binding)
@@ -309,7 +302,7 @@ class NameBindingResolver {
       const name = expression.argumentExpression.text;
       const identifiersFromObject = this.resolvePropertyAccessChain(expression.expression);
       return { accessedFrom: identifiersFromObject, accessedByProperty: name };
-    } else if (isIdentifier$6(expression)) {
+    } else if (isIdentifier$8(expression)) {
       return this.resolveIdentifier(expression);
     } else if (isParenthesizedExpression(expression)) {
       return this.resolvePropertyAccessChain(expression.expression);
@@ -318,8 +311,8 @@ class NameBindingResolver {
     } else if (isObjectLiteralExpression(expression)) {
       return {
         properties: expression.properties.map((property) => {
-          if (isPropertyAssignment(property) && (isStringLiteral$7(property.name) || isIdentifier$6(property.name))) {
-            if (isIdentifier$6(property.initializer))
+          if (isPropertyAssignment$1(property) && (isStringLiteral$7(property.name) || isIdentifier$8(property.name))) {
+            if (isIdentifier$8(property.initializer))
               return {
                 name: property.name.text,
                 assignedFrom: this.resolveIdentifier(property.initializer)
@@ -430,24 +423,20 @@ 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;
+const { isIdentifier: isIdentifier$7, isPropertyAccessExpression: isPropertyAccessExpression$4 } = c;
 function isIdentifierOrPropertyAccessExpression(node) {
-  return isIdentifier$5(node) || isPropertyAccessExpression$4(node);
+  return isIdentifier$7(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;
+  isIdentifier: isIdentifier$6,
+  isPropertyAccessExpression: isPropertyAccessExpression$3,
+  isBlock: isBlock$3
+} = c;
 function findEventHandlersBlock(functionDeclaration, bindingResolver) {
   const foundEventHandlers = [];
   const foundEventHandlerFunctionsToHandlerIndex = /* @__PURE__ */ new Map();
@@ -466,7 +455,7 @@ function findEventHandlersBlock(functionDeclaration, bindingResolver) {
                 eventHandlerCallStatement: statement,
                 handlerIndex: nextEventHandlerIndex++
               });
-            else if (isIdentifier$4(handler) || isPropertyAccessExpression$3(handler)) {
+            else if (isIdentifier$6(handler) || isPropertyAccessExpression$3(handler)) {
               let flattenedHandler = flattenVariable(
                 bindingResolver.explain(handler)
               );
@@ -486,26 +475,24 @@ function findEventHandlersBlock(functionDeclaration, bindingResolver) {
   }
   return foundEventHandlers;
 }
-const require$f = createRequire(import.meta.url);
-const tsModule$f = require$f("typescript");
 const {
+  isIdentifier: isIdentifier$5,
+  SyntaxKind: SyntaxKind$4,
+  isStringLiteral: isStringLiteral$6,
   visitNode: visitNode$3,
-  isArrayTypeNode,
+  isFunctionDeclaration: isFunctionDeclaration$1,
+  isVariableStatement: isVariableStatement$2,
+  isImportDeclaration: isImportDeclaration$3,
   isBlock: isBlock$2,
+  isForStatement: isForStatement$1,
+  isVariableDeclarationList,
   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;
+  isArrayTypeNode,
+  isFunctionTypeNode,
+  isUnionTypeNode
+} = c;
 const BUILT_IN_TYPES = ["RegExp", "Date"];
 function builtInType(text) {
   return BUILT_IN_TYPES.findIndex((_) => _ === text) > -1;
@@ -621,7 +608,7 @@ class SourceFileBindingResolver {
             node.initializer
           )
         );
-      } else if ((isForInStatement$1(node) || isForOfStatement$1(node)) && isVariableDeclarationList(node.initializer) && node.initializer.declarations.length === 1 && isIdentifier$3(node.initializer.declarations[0].name)) {
+      } else if ((isForInStatement$1(node) || isForOfStatement$1(node)) && isVariableDeclarationList(node.initializer) && node.initializer.declarations.length === 1 && isIdentifier$5(node.initializer.declarations[0].name)) {
         return doWithChildBindingResolver(node, () => {
           let name = node.initializer.declarations[0].name.text;
           nbResolversQueue[0].addVariable(
@@ -660,7 +647,7 @@ class SourceFileBindingResolver {
     if (type) {
       if (isTypeReferenceNode$1(type)) {
         let typeName = type.typeName;
-        if (isIdentifier$3(typeName)) {
+        if (isIdentifier$5(typeName)) {
           let resolved = this.findBindingResolver(typeName).resolveIdentifier(typeName);
           let flattened = flattenVariable(resolved);
           let typeFromFlattened = this.explainFlattenedVariableType(flattened);
@@ -697,23 +684,21 @@ 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,
+  isSpreadElement,
   isFunctionDeclaration,
-  isIdentifier: isIdentifier$2,
-  isNewExpression: isNewExpression$1,
+  isDecorator,
+  isCallExpression: isCallExpression$4,
+  isIdentifier: isIdentifier$4,
   isPropertyAccessExpression: isPropertyAccessExpression$2,
   isReturnStatement,
-  isSpreadElement,
+  isNewExpression: isNewExpression$1,
+  isExpressionStatement,
+  isBinaryExpression: isBinaryExpression$1,
   SyntaxKind: SyntaxKind$3,
-  transform
-} = tsModule$e;
+  transform: transform$5,
+  visitEachChild: visitEachChild$4
+} = c;
 var CompilePatternType = /* @__PURE__ */ ((CompilePatternType2) => {
   CompilePatternType2[CompilePatternType2["RETURN"] = 0] = "RETURN";
   CompilePatternType2[CompilePatternType2["CALL"] = 1] = "CALL";
@@ -777,7 +762,7 @@ function compileFunctionSplitPatternsBlock(patternFiles) {
       if (isFunctionDeclaration(node)) {
         let declaredTargetEnv = 0;
         node.modifiers && node.modifiers.forEach((modifier) => {
-          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")
+          if (isDecorator(modifier) && isCallExpression$4(modifier.expression) && isIdentifier$4(modifier.expression.expression) && modifier.expression.expression.text === "JayPattern" && modifier.expression.arguments.length === 1 && isPropertyAccessExpression$2(modifier.expression.arguments[0]) && isIdentifier$4(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;
@@ -814,7 +799,7 @@ function compileFunctionSplitPatternsBlock(patternFiles) {
               sourceFileBinding,
               node
             );
-          } 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)) {
+          } else if (isExpressionStatement(statement) && isBinaryExpression$1(statement.expression) && isPropertyAccessExpression$2(statement.expression.left) && statement.expression.operatorToken.kind === SyntaxKind$3.EqualsToken && isIdentifier$4(statement.expression.right)) {
             patternType = 3;
             leftHandSide = statement.expression.left;
             callArgumentTypes = [
@@ -857,7 +842,7 @@ function compileFunctionSplitPatternsBlock(patternFiles) {
       }
       return node;
     };
-    transform(patternsFile, [
+    transform$5(patternsFile, [
       mkTransformer(({ context, sourceFile }) => {
         visitEachChild$4(patternsFile, findPatternFunctions, context);
         return sourceFile;
@@ -866,9 +851,7 @@ function compileFunctionSplitPatternsBlock(patternFiles) {
   });
   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;
+const { visitEachChild: visitEachChild$3, transform: transform$4, visitNode: visitNode$2 } = c;
 function visitWithContext(node, initialContext, contextualVisitor) {
   return visitWithContext2(node, initialContext, void 0, contextualVisitor);
 }
@@ -895,9 +878,7 @@ function visitWithContext2(node, initialContext, transformationContext, contextu
   };
   return visitNode$2(node, visitor);
 }
-const require$c = createRequire(import.meta.url);
-const tsModule$c = require$c("typescript");
-const { isTypeReferenceNode } = tsModule$c;
+const { isTypeReferenceNode } = c;
 function isFirstParamJayEvent(eventHandler, bindingResolver) {
   if (eventHandler.parameters.length > 0 && eventHandler.parameters[0].type) {
     const explainedType = bindingResolver.explainType(eventHandler.parameters[0].type);
@@ -912,18 +893,17 @@ 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,
+  isIdentifier: isIdentifier$3,
+  SyntaxKind: SyntaxKind$2,
+  transform: transform$3,
+  isStatement: isStatement$1,
   isBlock: isBlock$1,
   isExpression: isExpression$1,
-  isIdentifier: isIdentifier$1,
   isLiteralExpression: isLiteralExpression$1,
-  isStatement: isStatement$1
-} = tsModule$b;
+  visitNode: visitNode$1
+} = c;
 function generateFunctionRepository(matchedReturnPatterns, matchedVariableReads, matchedConstants, safeStatements) {
   const constCode = [...new Set(matchedConstants)].join("\n");
   let readPatternsReturnProperties = matchedReturnPatterns.map(
@@ -1007,9 +987,9 @@ const mkTransformEventHandlerStatementVisitor = (factory, context, bindingResolv
         let patternKey = getPatternIndex(pattern);
         if (pattern.patternType === CompilePatternType.RETURN)
           sideEffects.matchedReturnPatterns.push({ pattern, patternKey });
-        else if (pattern.patternType === CompilePatternType.KNOWN_VARIABLE_READ && isIdentifier$1(node))
+        else if (pattern.patternType === CompilePatternType.KNOWN_VARIABLE_READ && isIdentifier$3(node))
           sideEffects.matchedVariableReads.push({ variable: node, patternKey });
-        else if (pattern.patternType === CompilePatternType.CONST_READ && isIdentifier$1(node)) {
+        else if (pattern.patternType === CompilePatternType.CONST_READ && isIdentifier$3(node)) {
           let constant = bindingResolver.explain(node);
           let flattenedConstant = flattenVariable(constant);
           let literal = flattenedConstant.root.literal;
@@ -1090,9 +1070,7 @@ 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 { visitEachChild: visitEachChild$1, isCallExpression: isCallExpression$3, isPropertyAccessExpression: isPropertyAccessExpression$1 } = c;
 const analyzeEventHandlerCall = (context, factory, handlerKey) => (node) => {
   if (isCallExpression$3(node) && isPropertyAccessExpression$1(node.expression)) {
     return factory.createCallExpression(
@@ -1160,27 +1138,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,
+  isIdentifier: isIdentifier$2,
   isNewExpression,
   isPropertyAccessExpression,
+  SyntaxKind: SyntaxKind$1,
+  isArrowFunction: isArrowFunction$1,
+  isLiteralExpression,
   isStatement,
   isVariableStatement: isVariableStatement$1,
+  isBlock,
+  isIfStatement,
+  isForStatement,
+  isForOfStatement,
+  isForInStatement,
   isWhileStatement,
-  SyntaxKind: SyntaxKind$1
-} = tsModule$9;
+  isDoStatement,
+  isElementAccessExpression,
+  isPropertyAssignment
+} = c;
 class SourceFileStatementAnalyzer {
   constructor(sourceFile, bindingResolver, compiledPatterns) {
     this.sourceFile = sourceFile;
@@ -1362,6 +1340,17 @@ class ScopedSourceFileStatementAnalyzer {
           );
           if (this.getStatementStatus(node)?.targetEnv === JayTargetEnv.any)
             this.getStatementStatus(node).targetEnv = JayTargetEnv.main;
+        } else if (isPropertyAssignment(node)) {
+          visitChild(node.initializer, {
+            statement,
+            roleInParent: 1
+            /* read */
+          });
+          visitChild(node.name, {
+            statement,
+            roleInParent: 0
+            /* none */
+          });
         } else if (isArrowFunction$1(node) && !isBlock(node.body)) {
           visitChild(node.body, {
             statement,
@@ -1580,9 +1569,7 @@ 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;
+const { isCallExpression: isCallExpression$1, isIdentifier: isIdentifier$1, isStringLiteral: isStringLiteral$5, isVariableStatement, forEachChild: forEachChild$1 } = c;
 var FindComponentConstructorType = /* @__PURE__ */ ((FindComponentConstructorType2) => {
   FindComponentConstructorType2["makeJayComponent"] = "makeJayComponent";
   FindComponentConstructorType2["makeJayTsxComponent"] = "makeJayTsxComponent";
@@ -1679,9 +1666,7 @@ export ${_}`
     );
   }
 }
-const require$7 = createRequire(import.meta.url);
-const tsModule$7 = require$7("typescript");
-const { forEachChild, isCallExpression, isIdentifier, isStringLiteral: isStringLiteral$4 } = tsModule$7;
+const { isCallExpression, isIdentifier, isStringLiteral: isStringLiteral$4, forEachChild } = c;
 function findExec$(bindingResolver, sourceFile) {
   const foundExec$ = [];
   function visit(node) {
@@ -1696,9 +1681,7 @@ function findExec$(bindingResolver, sourceFile) {
   forEachChild(sourceFile, visit);
   return foundExec$;
 }
-const require$6 = createRequire(import.meta.url);
-const tsModule$6 = require$6("typescript");
-const { visitNode, isArrowFunction, isExpression } = tsModule$6;
+const { transform: transform$2, isArrowFunction, isExpression, visitNode } = c;
 function analyzeGlobalExec$(context, analyzer, functionRepositoryBuilder, foundExec$) {
   const scopedAnalyzer = analyzer.analyzeForScope(foundExec$);
   let foundUnsafeExpression = false;
@@ -1735,9 +1718,7 @@ 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;
+const { SyntaxKind, transform: transform$1, isStringLiteral: isStringLiteral$3, isInterfaceDeclaration, isImportDeclaration: isImportDeclaration$2 } = c;
 function generateComponentConstructorCalls(context, componentConstructorCalls, hasFunctionRepository) {
   let optionsParam = hasFunctionRepository ? ", { funcRepository }" : "";
   let transformedConstructors = componentConstructorCalls.map(({ name, render }) => {
@@ -1858,9 +1839,7 @@ 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;
+const { isStringLiteral: isStringLiteral$2 } = c;
 function transformImportModeFileExtension(node, factory, importerMode) {
   if (!isStringLiteral$2(node.moduleSpecifier))
     return void 0;
@@ -1875,9 +1854,7 @@ function transformImportModeFileExtension(node, factory, importerMode) {
     node.attributes
   );
 }
-const require$3 = createRequire(import.meta.url);
-const tsModule$3 = require$3("typescript");
-const { isImportDeclaration: isImportDeclaration$1 } = tsModule$3;
+const { isImportDeclaration: isImportDeclaration$1 } = c;
 function findAfterImportStatementIndex(statements) {
   let lastIndex = 0;
   while (isImportDeclaration$1(statements[lastIndex]))
@@ -1905,9 +1882,7 @@ 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;
+const { visitEachChild, transform, isStringLiteral: isStringLiteral$1, isImportDeclaration } = c;
 function isCssImport(node) {
   return isStringLiteral$1(node.moduleSpecifier) && node.moduleSpecifier.text.endsWith(".css");
 }
@@ -1978,9 +1953,7 @@ function mkComponentTransformer(sftContext) {
 function transformComponent(patterns = [], globalFunctionRepository) {
   return mkTransformer(mkComponentTransformer, { patterns, globalFunctionRepository });
 }
-const require$1 = createRequire(import.meta.url);
-const tsModule$1 = require$1("typescript");
-const { ScriptTarget, createSourceFile, ScriptKind } = tsModule$1;
+const { createSourceFile, ScriptTarget, ScriptKind } = c;
 function createTsSourceFileFromSource(filePath, sourceCode, scriptKind = ScriptKind.TS) {
   try {
     return createSourceFile(filePath, sourceCode, ScriptTarget.Latest, true, scriptKind);
@@ -2001,9 +1974,7 @@ function generateImportsFileFromJayFile(jayFile) {
 function fromImportModules(modules) {
   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;
+const { isStringLiteral } = c;
 function parseImportLinks(sourceFile) {
   const importDeclarations = extractImportDeclarations(sourceFile).filter(
     (importDeclaration) => isStringLiteral(importDeclaration.moduleSpecifier)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jay-framework/compiler",
-  "version": "0.6.9",
+  "version": "0.7.0",
   "description": "",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -25,12 +25,12 @@
   },
   "author": "",
   "dependencies": {
-    "@jay-framework/compiler-analyze-exported-types": "^0.6.9",
-    "@jay-framework/compiler-jay-html": "^0.6.9",
-    "@jay-framework/compiler-shared": "^0.6.9",
-    "@jay-framework/component": "^0.6.9",
-    "@jay-framework/runtime": "^0.6.9",
-    "@jay-framework/secure": "^0.6.9",
+    "@jay-framework/compiler-analyze-exported-types": "^0.7.0",
+    "@jay-framework/compiler-jay-html": "^0.7.0",
+    "@jay-framework/compiler-shared": "^0.7.0",
+    "@jay-framework/component": "^0.7.0",
+    "@jay-framework/runtime": "^0.7.0",
+    "@jay-framework/secure": "^0.7.0",
     "@types/js-yaml": "^4.0.9",
     "change-case": "^4.1.2",
     "js-yaml": "^4.1.0",
@@ -41,7 +41,7 @@
   },
   "devDependencies": {
     "@caiogondim/strip-margin": "^1.0.0",
-    "@jay-framework/dev-environment": "^0.6.9",
+    "@jay-framework/dev-environment": "^0.7.0",
     "@testing-library/jest-dom": "^6.2.0",
     "@types/js-beautify": "^1",
     "@types/node": "^20.11.5",