@absolutejs/absolute 0.20.0-beta.172 → 0.20.0-beta.174

package/dist/cli/{index-rervww4p.js → index-zyd80s3h.js}

@@ -1,4 +1,7 @@
 // @bun
+import {
+  lazyTypescript
+} from "./index-4j1twret.js";
 import {
   normalizeAbsoluteMobileConfig2
 } from "./index-t7yf3vxs.js";
@@ -7,40 +10,39 @@ import {
   resolveAbsoluteMobileUpdateRuntime,
   writeAbsoluteExpoProject2,
   syncAbsoluteExpoWebAssets2
-} from "./index-s0r5q839.js";
+} from "./index-cksezef8.js";
 import {
   toPascal
 } from "./index-92g14j47.js";
 
 // src/build/islandRegistryTransform.ts
 import { basename } from "path";
-import ts from "typescript";
 var VALID_FRAMEWORKS = [
   "react",
   "svelte",
   "vue",
   "angular"
 ];
-var getObjectPropertyName = (name) => ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : null;
+var getObjectPropertyName = (name) => lazyTypescript.isIdentifier(name) || lazyTypescript.isStringLiteral(name) ? name.text : null;
 var isIslandRegistryHelperImport = (source) => source === "@absolutejs/absolute/islands" || source.endsWith("/islands") || source.endsWith("/core/islands");
 var collectRegistryFactory = (sourceFile) => {
   const factoryNames = new Set;
   const namespaceNames = new Set;
   for (const statement of sourceFile.statements) {
-    if (!ts.isImportDeclaration(statement))
+    if (!lazyTypescript.isImportDeclaration(statement))
       continue;
-    if (!ts.isStringLiteral(statement.moduleSpecifier))
+    if (!lazyTypescript.isStringLiteral(statement.moduleSpecifier))
       continue;
     if (!isIslandRegistryHelperImport(statement.moduleSpecifier.text))
       continue;
     const bindings = statement.importClause?.namedBindings;
     if (!bindings)
       continue;
-    if (ts.isNamespaceImport(bindings)) {
+    if (lazyTypescript.isNamespaceImport(bindings)) {
       namespaceNames.add(bindings.name.text);
       continue;
     }
-    if (!ts.isNamedImports(bindings))
+    if (!lazyTypescript.isNamedImports(bindings))
       continue;
     for (const element of bindings.elements) {
       const imported = element.propertyName?.text ?? element.name.text;
@@ -52,21 +54,21 @@ var collectRegistryFactory = (sourceFile) => {
   return { factoryNames, namespaceNames };
 };
 var isDefineIslandRegistryCall = (expression, factoryNames, namespaceNames) => {
-  if (ts.isIdentifier(expression))
+  if (lazyTypescript.isIdentifier(expression))
     return factoryNames.has(expression.text);
-  return ts.isPropertyAccessExpression(expression) && expression.name.text === "defineIslandRegistry" && ts.isIdentifier(expression.expression) && namespaceNames.has(expression.expression.text);
+  return lazyTypescript.isPropertyAccessExpression(expression) && expression.name.text === "defineIslandRegistry" && lazyTypescript.isIdentifier(expression.expression) && namespaceNames.has(expression.expression.text);
 };
 var findDefineIslandRegistryCall = (sourceFile, factoryNames, namespaceNames) => {
   let found = null;
   const visit = (node) => {
     if (found)
       return;
-    const [firstArg] = ts.isCallExpression(node) ? node.arguments : [];
-    if (ts.isCallExpression(node) && isDefineIslandRegistryCall(node.expression, factoryNames, namespaceNames) && firstArg && ts.isObjectLiteralExpression(firstArg)) {
+    const [firstArg] = lazyTypescript.isCallExpression(node) ? node.arguments : [];
+    if (lazyTypescript.isCallExpression(node) && isDefineIslandRegistryCall(node.expression, factoryNames, namespaceNames) && firstArg && lazyTypescript.isObjectLiteralExpression(firstArg)) {
       found = node;
       return;
     }
-    ts.forEachChild(node, visit);
+    lazyTypescript.forEachChild(node, visit);
   };
   visit(sourceFile);
   return found;
@@ -79,8 +81,8 @@ var definitionLiteral = (reference) => {
 var transformIslandRegistrySource = (source, filePath, info) => {
   if (!source.includes("defineIslandRegistry"))
     return null;
-  const scriptKind = filePath.endsWith(".tsx") || filePath.endsWith(".jsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
-  const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, scriptKind);
+  const scriptKind = filePath.endsWith(".tsx") || filePath.endsWith(".jsx") ? lazyTypescript.ScriptKind.TSX : lazyTypescript.ScriptKind.TS;
+  const sourceFile = lazyTypescript.createSourceFile(filePath, source, lazyTypescript.ScriptTarget.Latest, true, scriptKind);
   const { factoryNames, namespaceNames } = collectRegistryFactory(sourceFile);
   if (factoryNames.size === 0 && namespaceNames.size === 0)
     return null;
@@ -88,7 +90,7 @@ var transformIslandRegistrySource = (source, filePath, info) => {
   if (!call)
     return null;
   const [objectLiteral] = call.arguments;
-  if (!objectLiteral || !ts.isObjectLiteralExpression(objectLiteral)) {
+  if (!objectLiteral || !lazyTypescript.isObjectLiteralExpression(objectLiteral)) {
     return null;
   }
   const definitionLookup = new Map;
@@ -103,20 +105,20 @@ var transformIslandRegistrySource = (source, filePath, info) => {
   const edits = [];
   const replacedLocals = new Set;
   for (const frameworkProperty of objectLiteral.properties) {
-    if (!ts.isPropertyAssignment(frameworkProperty))
+    if (!lazyTypescript.isPropertyAssignment(frameworkProperty))
       continue;
     const frameworkName = getObjectPropertyName(frameworkProperty.name);
     const framework = VALID_FRAMEWORKS.find((f) => f === frameworkName);
     if (!framework)
       continue;
-    if (!ts.isObjectLiteralExpression(frameworkProperty.initializer))
+    if (!lazyTypescript.isObjectLiteralExpression(frameworkProperty.initializer))
       continue;
     for (const componentProperty of frameworkProperty.initializer.properties) {
       let componentKey = null;
       let localName = null;
       let replaceNode = null;
       let replacementText = "";
-      if (ts.isShorthandPropertyAssignment(componentProperty)) {
+      if (lazyTypescript.isShorthandPropertyAssignment(componentProperty)) {
         componentKey = componentProperty.name.text;
         localName = componentProperty.name.text;
         const reference = definitionLookup.get(`${framework}:${componentKey}`);
@@ -124,7 +126,7 @@ var transformIslandRegistrySource = (source, filePath, info) => {
           continue;
         replaceNode = componentProperty;
         replacementText = `${quoteKey(componentKey)}: ${definitionLiteral(reference)}`;
-      } else if (ts.isPropertyAssignment(componentProperty) && ts.isIdentifier(componentProperty.initializer)) {
+      } else if (lazyTypescript.isPropertyAssignment(componentProperty) && lazyTypescript.isIdentifier(componentProperty.initializer)) {
         componentKey = getObjectPropertyName(componentProperty.name);
         localName = componentProperty.initializer.text;
         if (!componentKey)
@@ -148,7 +150,7 @@ var transformIslandRegistrySource = (source, filePath, info) => {
   if (edits.length === 0)
     return null;
   for (const statement of sourceFile.statements) {
-    if (!ts.isImportDeclaration(statement))
+    if (!lazyTypescript.isImportDeclaration(statement))
       continue;
     const clause = statement.importClause;
     if (!clause)
@@ -157,11 +159,11 @@ var transformIslandRegistrySource = (source, filePath, info) => {
     if (clause.name)
       localNames.push(clause.name.text);
     const bindings = clause.namedBindings;
-    if (bindings && ts.isNamedImports(bindings)) {
+    if (bindings && lazyTypescript.isNamedImports(bindings)) {
       for (const element of bindings.elements) {
         localNames.push(element.name.text);
       }
-    } else if (bindings && ts.isNamespaceImport(bindings)) {
+    } else if (bindings && lazyTypescript.isNamespaceImport(bindings)) {
       localNames.push(bindings.name.text);
     }
     if (localNames.length === 0)
@@ -214,16 +216,15 @@ var createIslandRegistryDefinitionPlugin = (info) => {
 
 // src/build/bunStringRawUnicodePlugin.ts
 import { extname } from "path";
-import ts2 from "typescript";
 var NON_ASCII = /[^\x00-\x7f]/;
 var getScriptKind = (filePath) => {
   if (/\.[cm]?tsx$/.test(filePath))
-    return ts2.ScriptKind.TSX;
+    return lazyTypescript.ScriptKind.TSX;
   if (/\.[cm]?jsx$/.test(filePath))
-    return ts2.ScriptKind.JSX;
+    return lazyTypescript.ScriptKind.JSX;
   if (/\.[cm]?ts$/.test(filePath))
-    return ts2.ScriptKind.TS;
-  return ts2.ScriptKind.JS;
+    return lazyTypescript.ScriptKind.TS;
+  return lazyTypescript.ScriptKind.JS;
 };
 var getLoader = (filePath) => {
   const extension = extname(filePath);
@@ -236,21 +237,21 @@ var getLoader = (filePath) => {
   }
   return "js";
 };
-var isStringRawTag = (node) => ts2.isPropertyAccessExpression(node.tag) && ts2.isIdentifier(node.tag.expression) && node.tag.expression.text === "String" && node.tag.name.text === "raw";
+var isStringRawTag = (node) => lazyTypescript.isPropertyAccessExpression(node.tag) && lazyTypescript.isIdentifier(node.tag.expression) && node.tag.expression.text === "String" && node.tag.name.text === "raw";
 var getRawText = (node) => node.rawText ?? node.text;
 var rewriteBunStringRawUnicode = (source, filePath = "input.ts") => {
   if (!source.includes("String.raw") || !NON_ASCII.test(source))
     return source;
-  const sourceFile = ts2.createSourceFile(filePath, source, ts2.ScriptTarget.Latest, true, getScriptKind(filePath));
+  const sourceFile = lazyTypescript.createSourceFile(filePath, source, lazyTypescript.ScriptTarget.Latest, true, getScriptKind(filePath));
   const replacements = [];
   const visit = (node) => {
-    if (ts2.isTaggedTemplateExpression(node) && isStringRawTag(node)) {
-      const rawSegments = ts2.isNoSubstitutionTemplateLiteral(node.template) ? [getRawText(node.template)] : [
+    if (lazyTypescript.isTaggedTemplateExpression(node) && isStringRawTag(node)) {
+      const rawSegments = lazyTypescript.isNoSubstitutionTemplateLiteral(node.template) ? [getRawText(node.template)] : [
         getRawText(node.template.head),
         ...node.template.templateSpans.map((span) => getRawText(span.literal))
       ];
       if (rawSegments.some((segment) => NON_ASCII.test(segment))) {
-        const expressions = ts2.isTemplateExpression(node.template) ? node.template.templateSpans.map((span) => {
+        const expressions = lazyTypescript.isTemplateExpression(node.template) ? node.template.templateSpans.map((span) => {
           const expression = source.slice(span.expression.getStart(sourceFile), span.expression.end);
           return rewriteBunStringRawUnicode(expression, filePath);
         }) : [];
@@ -266,7 +267,7 @@ var rewriteBunStringRawUnicode = (source, filePath = "input.ts") => {
         return;
       }
     }
-    ts2.forEachChild(node, visit);
+    lazyTypescript.forEachChild(node, visit);
   };
   visit(sourceFile);
   let result = source;
@@ -1567,7 +1568,6 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
 // src/mobile/routeMetadataTransform.ts
 import { existsSync as existsSync2, readFileSync } from "fs";
 import { dirname as dirname4, extname as extname4, relative as relative3, resolve as resolve4 } from "path";
-import ts3 from "typescript";
 var ROUTE_METHODS = new Set(["get", "head"]);
 var SOURCE_FILTER = /\.[cm]?[jt]sx?$/;
 var PAGE_HANDLERS = new Map([
@@ -1617,60 +1617,60 @@ var PAGE_HANDLERS = new Map([
   ]
 ]);
 var posixPath = (value) => value.replace(/\\/g, "/");
-var findTsconfig = (entry, projectRoot) => ts3.findConfigFile(dirname4(entry), existsSync2, "tsconfig.json") ?? ts3.findConfigFile(projectRoot, existsSync2, "tsconfig.json");
+var findTsconfig = (entry, projectRoot) => lazyTypescript.findConfigFile(dirname4(entry), existsSync2, "tsconfig.json") ?? lazyTypescript.findConfigFile(projectRoot, existsSync2, "tsconfig.json");
 var createProgram = (entry, projectRoot) => {
   const configPath = findTsconfig(entry, projectRoot);
   if (!configPath) {
-    return ts3.createProgram([entry], {
+    return lazyTypescript.createProgram([entry], {
       allowJs: true,
-      jsx: ts3.JsxEmit.ReactJSX,
-      module: ts3.ModuleKind.ESNext,
-      moduleResolution: ts3.ModuleResolutionKind.Bundler,
-      target: ts3.ScriptTarget.ESNext
+      jsx: lazyTypescript.JsxEmit.ReactJSX,
+      module: lazyTypescript.ModuleKind.ESNext,
+      moduleResolution: lazyTypescript.ModuleResolutionKind.Bundler,
+      target: lazyTypescript.ScriptTarget.ESNext
     });
   }
-  const parsed = ts3.parseJsonConfigFileContent(ts3.readConfigFile(configPath, (path) => readFileSync(path, "utf8")).config, ts3.sys, dirname4(configPath));
+  const parsed = lazyTypescript.parseJsonConfigFileContent(lazyTypescript.readConfigFile(configPath, (path) => readFileSync(path, "utf8")).config, lazyTypescript.sys, dirname4(configPath));
   if (!parsed.fileNames.includes(entry))
     parsed.fileNames.push(entry);
-  return ts3.createProgram(parsed.fileNames, parsed.options);
+  return lazyTypescript.createProgram(parsed.fileNames, parsed.options);
 };
 var propertyName = (property) => {
   if (!("name" in property) || !property.name)
     return;
-  if (ts3.isIdentifier(property.name))
+  if (lazyTypescript.isIdentifier(property.name))
     return property.name.text;
-  if (ts3.isStringLiteralLike(property.name))
+  if (lazyTypescript.isStringLiteralLike(property.name))
     return property.name.text;
   return;
 };
 var objectPropertyExpression = (object, name) => {
   const property = object.properties.find((candidate) => propertyName(candidate) === name);
-  if (property && ts3.isPropertyAssignment(property)) {
+  if (property && lazyTypescript.isPropertyAssignment(property)) {
     return property.initializer;
   }
-  if (property && ts3.isShorthandPropertyAssignment(property)) {
+  if (property && lazyTypescript.isShorthandPropertyAssignment(property)) {
     return property.name;
   }
   return;
 };
 var serializeType = (type, checker, ancestors = new Set) => {
-  if (type.flags & ts3.TypeFlags.Any)
+  if (type.flags & lazyTypescript.TypeFlags.Any)
     return { type: "any" };
-  if (type.flags & ts3.TypeFlags.Unknown)
+  if (type.flags & lazyTypescript.TypeFlags.Unknown)
     return { type: "unknown" };
-  if (type.flags & ts3.TypeFlags.Never)
+  if (type.flags & lazyTypescript.TypeFlags.Never)
     return { type: "never" };
-  if (type.flags & ts3.TypeFlags.StringLike)
+  if (type.flags & lazyTypescript.TypeFlags.StringLike)
     return { type: "string" };
-  if (type.flags & ts3.TypeFlags.NumberLike)
+  if (type.flags & lazyTypescript.TypeFlags.NumberLike)
     return { type: "number" };
-  if (type.flags & ts3.TypeFlags.BooleanLike)
+  if (type.flags & lazyTypescript.TypeFlags.BooleanLike)
     return { type: "boolean" };
-  if (type.flags & ts3.TypeFlags.BigIntLike)
+  if (type.flags & lazyTypescript.TypeFlags.BigIntLike)
     return { type: "bigint" };
-  if (type.flags & ts3.TypeFlags.Null)
+  if (type.flags & lazyTypescript.TypeFlags.Null)
     return { type: "null" };
-  if (type.flags & ts3.TypeFlags.Undefined)
+  if (type.flags & lazyTypescript.TypeFlags.Undefined)
     return { type: "undefined" };
   if (type.isUnion()) {
     return {
@@ -1684,11 +1684,11 @@ var serializeType = (type, checker, ancestors = new Set) => {
   }
   if (ancestors.has(type)) {
     return {
-      ref: checker.typeToString(type, undefined, ts3.TypeFormatFlags.NoTruncation)
+      ref: checker.typeToString(type, undefined, lazyTypescript.TypeFormatFlags.NoTruncation)
     };
   }
   ancestors.add(type);
-  const arrayElement = checker.getIndexTypeOfType(type, ts3.IndexKind.Number);
+  const arrayElement = checker.getIndexTypeOfType(type, lazyTypescript.IndexKind.Number);
   const properties = checker.getPropertiesOfType(type);
   let schema;
   if (arrayElement && properties.some(({ name }) => name === "length")) {
@@ -1703,7 +1703,7 @@ var serializeType = (type, checker, ancestors = new Set) => {
       return [
         property.name,
         {
-          optional: Boolean(property.flags & ts3.SymbolFlags.Optional),
+          optional: Boolean(property.flags & lazyTypescript.SymbolFlags.Optional),
           schema: serializeType(propertyType, checker, ancestors)
         }
       ];
@@ -1711,7 +1711,7 @@ var serializeType = (type, checker, ancestors = new Set) => {
     schema = { properties: Object.fromEntries(entries), type: "object" };
   } else {
     schema = {
-      type: checker.typeToString(type, undefined, ts3.TypeFormatFlags.NoTruncation)
+      type: checker.typeToString(type, undefined, lazyTypescript.TypeFormatFlags.NoTruncation)
     };
   }
   ancestors.delete(type);
@@ -1729,7 +1729,7 @@ var pagePropsType = (pageExpression, propsExpression, checker) => {
 };
 var resolvePageIdentity = (expression, sourceFile, checker, projectRoot) => {
   let symbol = checker.getSymbolAtLocation(expression);
-  if (symbol?.flags && symbol.flags & ts3.SymbolFlags.Alias) {
+  if (symbol?.flags && symbol.flags & lazyTypescript.SymbolFlags.Alias) {
     symbol = checker.getAliasedSymbol(symbol);
   }
   const declaration = symbol?.declarations?.[0];
@@ -1739,15 +1739,15 @@ var resolvePageIdentity = (expression, sourceFile, checker, projectRoot) => {
   return `${source}#${exportedName}`;
 };
 var resolveAlias = (symbol, checker) => {
-  if (!(symbol.flags & ts3.SymbolFlags.Alias))
+  if (!(symbol.flags & lazyTypescript.SymbolFlags.Alias))
     return symbol;
   return checker.getAliasedSymbol(symbol);
 };
 var assetKey = (expression, checker, seen = new Set) => {
   if (!expression)
     return;
-  if (ts3.isIdentifier(expression)) {
-    const unresolved = ts3.isShorthandPropertyAssignment(expression.parent) ? checker.getShorthandAssignmentValueSymbol(expression.parent) : checker.getSymbolAtLocation(expression);
+  if (lazyTypescript.isIdentifier(expression)) {
+    const unresolved = lazyTypescript.isShorthandPropertyAssignment(expression.parent) ? checker.getShorthandAssignmentValueSymbol(expression.parent) : checker.getSymbolAtLocation(expression);
     if (!unresolved)
       return;
     const symbol = resolveAlias(unresolved, checker);
@@ -1755,26 +1755,26 @@ var assetKey = (expression, checker, seen = new Set) => {
       return;
     seen.add(symbol);
     const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
-    if (!declaration || !ts3.isVariableDeclaration(declaration))
+    if (!declaration || !lazyTypescript.isVariableDeclaration(declaration))
       return;
     return assetKey(declaration.initializer, checker, seen);
   }
-  if (!ts3.isCallExpression(expression))
+  if (!lazyTypescript.isCallExpression(expression))
     return;
-  if (!ts3.isIdentifier(expression.expression) || expression.expression.text !== "asset") {
+  if (!lazyTypescript.isIdentifier(expression.expression) || expression.expression.text !== "asset") {
     return;
   }
   const [, key] = expression.arguments;
-  return key && ts3.isStringLiteralLike(key) ? key.text : undefined;
+  return key && lazyTypescript.isStringLiteralLike(key) ? key.text : undefined;
 };
 var staticString = (expression, bindings) => {
-  if (ts3.isStringLiteralLike(expression))
+  if (lazyTypescript.isStringLiteralLike(expression))
     return expression.text;
-  if (ts3.isIdentifier(expression))
+  if (lazyTypescript.isIdentifier(expression))
     return bindings.get(expression.text);
-  if (ts3.isNoSubstitutionTemplateLiteral(expression))
+  if (lazyTypescript.isNoSubstitutionTemplateLiteral(expression))
     return expression.text;
-  if (!ts3.isTemplateExpression(expression))
+  if (!lazyTypescript.isTemplateExpression(expression))
     return;
   let value = expression.head.text;
   for (const span of expression.templateSpans) {
@@ -1788,7 +1788,7 @@ var staticString = (expression, bindings) => {
 var assetKeyWithBindings = (expression, checker, bindings = new Map) => {
   if (!expression)
     return;
-  if (ts3.isCallExpression(expression) && ts3.isIdentifier(expression.expression) && expression.expression.text === "asset") {
+  if (lazyTypescript.isCallExpression(expression) && lazyTypescript.isIdentifier(expression.expression) && expression.expression.text === "asset") {
     const [, key] = expression.arguments;
     return key ? staticString(key, bindings) : undefined;
   }
@@ -1799,16 +1799,16 @@ var callableObject = (call, checker) => {
   const resolved = symbol ? resolveAlias(symbol, checker) : undefined;
   const declaration = resolved?.valueDeclaration ?? resolved?.declarations?.[0];
   let callable;
-  if (declaration && ts3.isFunctionDeclaration(declaration)) {
+  if (declaration && lazyTypescript.isFunctionDeclaration(declaration)) {
     callable = declaration;
-  } else if (declaration && ts3.isVariableDeclaration(declaration) && declaration.initializer && (ts3.isArrowFunction(declaration.initializer) || ts3.isFunctionExpression(declaration.initializer))) {
+  } else if (declaration && lazyTypescript.isVariableDeclaration(declaration) && declaration.initializer && (lazyTypescript.isArrowFunction(declaration.initializer) || lazyTypescript.isFunctionExpression(declaration.initializer))) {
     callable = declaration.initializer;
   }
   if (!callable)
     return;
   const bindings = new Map;
   callable.parameters.forEach((parameter, index) => {
-    if (!ts3.isIdentifier(parameter.name))
+    if (!lazyTypescript.isIdentifier(parameter.name))
       return;
     const argument = call.arguments[index];
     if (!argument)
@@ -1820,35 +1820,35 @@ var callableObject = (call, checker) => {
   const { body } = callable;
   if (!body)
     return;
-  const expressionBody = ts3.isParenthesizedExpression(body) ? body.expression : body;
-  if (ts3.isObjectLiteralExpression(expressionBody)) {
+  const expressionBody = lazyTypescript.isParenthesizedExpression(body) ? body.expression : body;
+  if (lazyTypescript.isObjectLiteralExpression(expressionBody)) {
     return { bindings, object: expressionBody };
   }
-  if (ts3.isBlock(body)) {
-    const returned = body.statements.find(ts3.isReturnStatement)?.expression;
-    if (returned && ts3.isObjectLiteralExpression(returned)) {
+  if (lazyTypescript.isBlock(body)) {
+    const returned = body.statements.find(lazyTypescript.isReturnStatement)?.expression;
+    if (returned && lazyTypescript.isObjectLiteralExpression(returned)) {
       return { bindings, object: returned };
     }
   }
   return;
 };
 var spreadObject = (expression, checker, bindings) => {
-  if (ts3.isObjectLiteralExpression(expression)) {
+  if (lazyTypescript.isObjectLiteralExpression(expression)) {
     return { bindings, object: expression };
   }
-  if (!ts3.isCallExpression(expression))
+  if (!lazyTypescript.isCallExpression(expression))
     return;
   return callableObject(expression, checker);
 };
 var objectAssetKey = (object, name, checker, bindings = new Map) => {
   for (const property of [...object.properties].reverse()) {
-    if (propertyName(property) === name && ts3.isShorthandPropertyAssignment(property)) {
+    if (propertyName(property) === name && lazyTypescript.isShorthandPropertyAssignment(property)) {
       return assetKeyWithBindings(property.name, checker, bindings);
     }
-    if (propertyName(property) === name && ts3.isPropertyAssignment(property)) {
+    if (propertyName(property) === name && lazyTypescript.isPropertyAssignment(property)) {
       return assetKeyWithBindings(property.initializer, checker, bindings);
     }
-    if (!ts3.isSpreadAssignment(property))
+    if (!lazyTypescript.isSpreadAssignment(property))
       continue;
     const nestedObject = spreadObject(property.expression, checker, bindings);
     if (!nestedObject)
@@ -1864,14 +1864,14 @@ var findPageCall = (nodes) => {
   const visit = (candidate) => {
     if (found)
       return;
-    if (ts3.isCallExpression(candidate) && ts3.isIdentifier(candidate.expression) && PAGE_HANDLERS.has(candidate.expression.text)) {
+    if (lazyTypescript.isCallExpression(candidate) && lazyTypescript.isIdentifier(candidate.expression) && PAGE_HANDLERS.has(candidate.expression.text)) {
       const definition = PAGE_HANDLERS.get(candidate.expression.text);
       if (!definition)
         return;
       found = { definition, node: candidate };
       return;
     }
-    ts3.forEachChild(candidate, visit);
+    lazyTypescript.forEachChild(candidate, visit);
   };
   for (const node of nodes)
     visit(node);
@@ -1880,12 +1880,12 @@ var findPageCall = (nodes) => {
 var isProjectSource = (sourceFile, resolvedFile, projectRoot) => !sourceFile.isDeclarationFile && !resolvedFile.includes("/node_modules/") && resolvedFile.startsWith(`${projectRoot}/`);
 var analyzeRouteCall = (node, sourceFile, checker, projectRoot) => {
   const callee = node.expression;
-  if (!ts3.isPropertyAccessExpression(callee))
+  if (!lazyTypescript.isPropertyAccessExpression(callee))
     return;
   if (!ROUTE_METHODS.has(callee.name.text))
     return;
   const [routePath] = node.arguments;
-  if (!routePath || !ts3.isStringLiteralLike(routePath))
+  if (!routePath || !lazyTypescript.isStringLiteralLike(routePath))
     return;
   const foundPageCall = findPageCall(node.arguments.slice(1));
   const pageCall = foundPageCall?.node;
@@ -1918,7 +1918,7 @@ var analyzeRouteCall = (node, sourceFile, checker, projectRoot) => {
       routeCallSpan: `${node.getStart(sourceFile)}:${node.end}`
     };
   }
-  if (!ts3.isObjectLiteralExpression(input) || !definition.bundleProperty) {
+  if (!lazyTypescript.isObjectLiteralExpression(input) || !definition.bundleProperty) {
     return;
   }
   const page = definition.pageProperty ? objectPropertyExpression(input, definition.pageProperty) : undefined;
@@ -1960,14 +1960,14 @@ var analyzeSourceFile = (sourceFile, checker, projectRoot) => {
     byRouteCall: new Map
   };
   const visit = (node) => {
-    const result = ts3.isCallExpression(node) ? analyzeRouteCall(node, sourceFile, checker, projectRoot) : undefined;
+    const result = lazyTypescript.isCallExpression(node) ? analyzeRouteCall(node, sourceFile, checker, projectRoot) : undefined;
     if (result) {
       analysis.byPageCall.set(result.pageCallStart, result);
       analysis.byRouteCall.set(result.routeCallSpan, result);
     }
-    ts3.forEachChild(node, visit);
+    lazyTypescript.forEachChild(node, visit);
   };
-  ts3.forEachChild(sourceFile, visit);
+  lazyTypescript.forEachChild(sourceFile, visit);
   return analysis;
 };
 var analyzeProgram = (program, projectRoot) => {
@@ -1983,21 +1983,21 @@ var analyzeProgram = (program, projectRoot) => {
   }
   return analyzed;
 };
-var metadataExpression = (metadata) => ts3.factory.createObjectLiteralExpression(Object.entries(metadata).map(([key, item]) => ts3.factory.createPropertyAssignment(ts3.factory.createStringLiteral(key), ts3.factory.createStringLiteral(item))), false);
+var metadataExpression = (metadata) => lazyTypescript.factory.createObjectLiteralExpression(Object.entries(metadata).map(([key, item]) => lazyTypescript.factory.createPropertyAssignment(lazyTypescript.factory.createStringLiteral(key), lazyTypescript.factory.createStringLiteral(item))), false);
 var routeOptions = (existing, metadata) => {
-  const detail = ts3.factory.createObjectLiteralExpression([
-    ts3.factory.createPropertyAssignment(ts3.factory.createStringLiteral(ABSOLUTE_MOBILE_ROUTE_DETAIL), metadataExpression(metadata))
+  const detail = lazyTypescript.factory.createObjectLiteralExpression([
+    lazyTypescript.factory.createPropertyAssignment(lazyTypescript.factory.createStringLiteral(ABSOLUTE_MOBILE_ROUTE_DETAIL), metadataExpression(metadata))
   ]);
   if (!existing) {
-    return ts3.factory.createObjectLiteralExpression([
-      ts3.factory.createPropertyAssignment("detail", detail)
+    return lazyTypescript.factory.createObjectLiteralExpression([
+      lazyTypescript.factory.createPropertyAssignment("detail", detail)
     ]);
   }
-  return ts3.factory.createObjectLiteralExpression([
-    ts3.factory.createSpreadAssignment(existing),
-    ts3.factory.createPropertyAssignment("detail", ts3.factory.createObjectLiteralExpression([
-      ts3.factory.createSpreadAssignment(ts3.factory.createPropertyAccessExpression(existing, "detail")),
-      ts3.factory.createPropertyAssignment(ts3.factory.createStringLiteral(ABSOLUTE_MOBILE_ROUTE_DETAIL), metadataExpression(metadata))
+  return lazyTypescript.factory.createObjectLiteralExpression([
+    lazyTypescript.factory.createSpreadAssignment(existing),
+    lazyTypescript.factory.createPropertyAssignment("detail", lazyTypescript.factory.createObjectLiteralExpression([
+      lazyTypescript.factory.createSpreadAssignment(lazyTypescript.factory.createPropertyAccessExpression(existing, "detail")),
+      lazyTypescript.factory.createPropertyAssignment(lazyTypescript.factory.createStringLiteral(ABSOLUTE_MOBILE_ROUTE_DETAIL), metadataExpression(metadata))
     ]))
   ]);
 };
@@ -2008,19 +2008,19 @@ var transformPageCall = (node, page) => {
     const [pagePath, existingOptions, ...rest] = node.arguments;
     if (!pagePath)
       return;
-    const options = ts3.factory.createObjectLiteralExpression([
-      ...existingOptions ? [ts3.factory.createSpreadAssignment(existingOptions)] : [],
-      ts3.factory.createPropertyAssignment("__absoluteMobile", metadataExpression(page.metadata))
+    const options = lazyTypescript.factory.createObjectLiteralExpression([
+      ...existingOptions ? [lazyTypescript.factory.createSpreadAssignment(existingOptions)] : [],
+      lazyTypescript.factory.createPropertyAssignment("__absoluteMobile", metadataExpression(page.metadata))
     ]);
-    return ts3.factory.updateCallExpression(node, node.expression, node.typeArguments, [pagePath, options, ...rest]);
+    return lazyTypescript.factory.updateCallExpression(node, node.expression, node.typeArguments, [pagePath, options, ...rest]);
   }
   const [input] = node.arguments;
-  if (!input || !ts3.isObjectLiteralExpression(input))
+  if (!input || !lazyTypescript.isObjectLiteralExpression(input))
     return;
-  return ts3.factory.updateCallExpression(node, node.expression, node.typeArguments, [
-    ts3.factory.updateObjectLiteralExpression(input, [
+  return lazyTypescript.factory.updateCallExpression(node, node.expression, node.typeArguments, [
+    lazyTypescript.factory.updateObjectLiteralExpression(input, [
       ...input.properties,
-      ts3.factory.createPropertyAssignment("__absoluteMobile", metadataExpression(page.metadata))
+      lazyTypescript.factory.createPropertyAssignment("__absoluteMobile", metadataExpression(page.metadata))
     ]),
     ...node.arguments.slice(1)
   ]);
@@ -2033,16 +2033,16 @@ var transformRouteCall = (node, route) => {
     return;
   const options = maybeHandler ? maybeOptions : undefined;
   const handler = maybeHandler ?? maybeOptions;
-  return ts3.factory.updateCallExpression(node, node.expression, node.typeArguments, [path, routeOptions(options, route.metadata), handler, ...rest]);
+  return lazyTypescript.factory.updateCallExpression(node, node.expression, node.typeArguments, [path, routeOptions(options, route.metadata), handler, ...rest]);
 };
 var transformFile = (source, fileName, analysis) => {
-  const sourceFile = ts3.createSourceFile(fileName, source, ts3.ScriptTarget.Latest, true, fileName.endsWith("x") ? ts3.ScriptKind.TSX : ts3.ScriptKind.TS);
+  const sourceFile = lazyTypescript.createSourceFile(fileName, source, lazyTypescript.ScriptTarget.Latest, true, fileName.endsWith("x") ? lazyTypescript.ScriptKind.TSX : lazyTypescript.ScriptKind.TS);
   const transformer = (context) => {
     const visit = (node) => {
-      if (!ts3.isCallExpression(node)) {
-        return ts3.visitEachChild(node, visit, context);
+      if (!lazyTypescript.isCallExpression(node)) {
+        return lazyTypescript.visitEachChild(node, visit, context);
       }
-      const transformedChildren = ts3.visitEachChild(node, visit, context);
+      const transformedChildren = lazyTypescript.visitEachChild(node, visit, context);
       const page = analysis.byPageCall.get(node.getStart(sourceFile));
       const transformedPage = transformPageCall(transformedChildren, page);
       if (transformedPage)
@@ -2053,14 +2053,14 @@ var transformFile = (source, fileName, analysis) => {
         return transformedRoute;
       return transformedChildren;
     };
-    return (node) => ts3.visitNode(node, visit, ts3.isSourceFile) ?? node;
+    return (node) => lazyTypescript.visitNode(node, visit, lazyTypescript.isSourceFile) ?? node;
   };
-  const result = ts3.transform(sourceFile, [transformer]);
+  const result = lazyTypescript.transform(sourceFile, [transformer]);
   try {
     const [transformed] = result.transformed;
     if (!transformed)
       throw new TypeError("Mobile route transform failed.");
-    return ts3.createPrinter().printFile(transformed);
+    return lazyTypescript.createPrinter().printFile(transformed);
   } finally {
     result.dispose();
   }