@absolutejs/absolute 0.20.0-beta.173 → 0.20.0-beta.175

package/dist/dev/importCostReport.js

@@ -3,25 +3,44 @@
 import { readFileSync as readFileSync2, writeFileSync } from "fs";
 import { dirname as dirname2, relative } from "path";
 
+// src/utils/lazyTypescript.ts
+import { createRequire } from "module";
+var loaded;
+var loadTypescript = () => {
+  if (loaded)
+    return loaded;
+  const requireFromHere = createRequire(import.meta.url);
+  const typescript = requireFromHere("typescript");
+  loaded = typescript;
+  return typescript;
+};
+var createLazyTypescript = () => {
+  const target = Object.create(null);
+  return new Proxy(target, {
+    get: (_target, key) => Reflect.get(loadTypescript(), key),
+    has: (_target, key) => Reflect.has(loadTypescript(), key)
+  });
+};
+var lazyTypescript = createLazyTypescript();
+
 // src/dev/importCost/deferability.ts
-import ts from "typescript";
 var DEFERRED = "deferred";
 var scriptKindFor = (fileName) => {
   if (fileName.endsWith(".tsx"))
-    return ts.ScriptKind.TSX;
+    return lazyTypescript.ScriptKind.TSX;
   if (fileName.endsWith(".jsx"))
-    return ts.ScriptKind.JSX;
+    return lazyTypescript.ScriptKind.JSX;
   if (fileName.endsWith(".js") || fileName.endsWith(".mjs")) {
-    return ts.ScriptKind.JS;
+    return lazyTypescript.ScriptKind.JS;
   }
-  return ts.ScriptKind.TS;
+  return lazyTypescript.ScriptKind.TS;
 };
 var namedBindings = (clause) => {
   const names = clause.name === undefined ? [] : [clause.name.text];
   const { namedBindings: bindings } = clause;
   if (bindings === undefined)
     return names;
-  if (ts.isNamespaceImport(bindings))
+  if (lazyTypescript.isNamespaceImport(bindings))
     return [...names, bindings.name.text];
   return [
     ...names,
@@ -30,20 +49,20 @@ var namedBindings = (clause) => {
 };
 var declarationFrom = (statement, source) => {
   const specifier = statement.moduleSpecifier;
-  if (!ts.isStringLiteral(specifier))
+  if (!lazyTypescript.isStringLiteral(specifier))
     return null;
   const clause = statement.importClause;
   const bindings = clause === undefined ? [] : namedBindings(clause);
   const declaration = {
     bindings,
-    line: ts.getLineAndCharacterOfPosition(source, statement.getStart(source)).line + 1,
+    line: lazyTypescript.getLineAndCharacterOfPosition(source, statement.getStart(source)).line + 1,
     sideEffect: clause === undefined,
     specifier: specifier.text,
     typeOnly: clause !== undefined && (clause.isTypeOnly || bindings.length === 0)
   };
   return declaration;
 };
-var isTypePosition = (node) => ts.isTypeNode(node) && !ts.isExpressionWithTypeArguments(node);
+var isTypePosition = (node) => lazyTypescript.isTypeNode(node) && !lazyTypescript.isExpressionWithTypeArguments(node);
 var isDeferredPosition = (current, child) => {
   if (Reflect.get(current, "body") === child)
     return true;
@@ -51,19 +70,19 @@ var isDeferredPosition = (current, child) => {
   return Array.isArray(parameters) && parameters.some((parameter) => parameter === child);
 };
 var classifyAncestor = (current, child) => {
-  if (ts.isExportSpecifier(current))
+  if (lazyTypescript.isExportSpecifier(current))
     return "re-exported by the entry";
-  if (ts.isDecorator(current))
+  if (lazyTypescript.isDecorator(current))
     return "decorator";
-  if (ts.isPropertyDeclaration(current) && current.initializer === child) {
+  if (lazyTypescript.isPropertyDeclaration(current) && current.initializer === child) {
     return "class field initializer";
   }
   if (isTypePosition(current))
     return DEFERRED;
-  if (ts.isFunctionLike(current) && isDeferredPosition(current, child)) {
+  if (lazyTypescript.isFunctionLike(current) && isDeferredPosition(current, child)) {
     return DEFERRED;
   }
-  if (ts.isSourceFile(current))
+  if (lazyTypescript.isSourceFile(current))
     return "module scope";
   return null;
 };
@@ -83,9 +102,9 @@ var classifyUsage = (node) => {
   return pending ?? "module scope";
 };
 var isDeclarationName = (parent, node) => {
-  if (ts.isExportSpecifier(parent))
+  if (lazyTypescript.isExportSpecifier(parent))
     return false;
-  if (ts.isShorthandPropertyAssignment(parent))
+  if (lazyTypescript.isShorthandPropertyAssignment(parent))
     return false;
   return Reflect.get(parent, "name") === node;
 };
@@ -93,7 +112,7 @@ var isReferencePosition = (node) => {
   const { parent } = node;
   if (parent === undefined)
     return false;
-  if (ts.isQualifiedName(parent) && parent.right === node)
+  if (lazyTypescript.isQualifiedName(parent) && parent.right === node)
     return false;
   return !isDeclarationName(parent, node);
 };
@@ -110,13 +129,13 @@ var recordUsage = (node, owners, reasons) => {
 var collectUnsafeReasons = (source, owners) => {
   const reasons = new Map;
   const visit = (node) => {
-    if (ts.isImportDeclaration(node))
+    if (lazyTypescript.isImportDeclaration(node))
       return;
-    if (ts.isIdentifier(node))
+    if (lazyTypescript.isIdentifier(node))
       recordUsage(node, owners, reasons);
-    ts.forEachChild(node, visit);
+    lazyTypescript.forEachChild(node, visit);
   };
-  ts.forEachChild(source, visit);
+  lazyTypescript.forEachChild(source, visit);
   return reasons;
 };
 var verdictFor = (declaration, reason) => {
@@ -130,12 +149,12 @@ var verdictFor = (declaration, reason) => {
 };
 var reExportOf = (statement, source) => {
   const specifier = statement.moduleSpecifier;
-  if (specifier === undefined || !ts.isStringLiteral(specifier))
+  if (specifier === undefined || !lazyTypescript.isStringLiteral(specifier))
     return null;
   if (statement.isTypeOnly)
     return null;
   const entry = {
-    line: ts.getLineAndCharacterOfPosition(source, statement.getStart(source)).line + 1,
+    line: lazyTypescript.getLineAndCharacterOfPosition(source, statement.getStart(source)).line + 1,
     reason: "re-exported by the entry",
     specifier: specifier.text,
     verdict: "used at module scope"
@@ -143,9 +162,9 @@ var reExportOf = (statement, source) => {
   return entry;
 };
 var analyzeEntryImports = (sourceText, fileName) => {
-  const source = ts.createSourceFile(fileName, sourceText, ts.ScriptTarget.ESNext, true, scriptKindFor(fileName));
-  const declarations = source.statements.filter(ts.isImportDeclaration).map((statement) => declarationFrom(statement, source)).filter((declaration) => declaration !== null);
-  const reExports = source.statements.filter(ts.isExportDeclaration).map((statement) => reExportOf(statement, source)).filter((entry) => entry !== null);
+  const source = lazyTypescript.createSourceFile(fileName, sourceText, lazyTypescript.ScriptTarget.ESNext, true, scriptKindFor(fileName));
+  const declarations = source.statements.filter(lazyTypescript.isImportDeclaration).map((statement) => declarationFrom(statement, source)).filter((declaration) => declaration !== null);
+  const reExports = source.statements.filter(lazyTypescript.isExportDeclaration).map((statement) => reExportOf(statement, source)).filter((entry) => entry !== null);
   const owners = new Map;
   declarations.forEach((declaration, index) => {
     for (const binding of declaration.bindings)