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

package/dist/mobile/index.js

@@ -1910,11 +1910,30 @@ var init_materializedBundle = __esm(() => {
   BUNDLE_ID_PATTERN = /^amb_[a-f0-9]{64}$/;
 });
 
+// src/utils/lazyTypescript.ts
+import { createRequire } from "module";
+var loaded, loadTypescript = () => {
+  if (loaded)
+    return loaded;
+  const requireFromHere = createRequire(import.meta.url);
+  const typescript = requireFromHere("typescript");
+  loaded = typescript;
+  return typescript;
+}, createLazyTypescript = () => {
+  const target = Object.create(null);
+  return new Proxy(target, {
+    get: (_target, key) => Reflect.get(loadTypescript(), key),
+    has: (_target, key) => Reflect.has(loadTypescript(), key)
+  });
+}, lazyTypescript;
+var init_lazyTypescript = __esm(() => {
+  lazyTypescript = createLazyTypescript();
+});
+
 // src/mobile/deviceCapabilities.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 import { extname as extname3, join as join15, relative as relative12, resolve as resolve13 } from "path";
 import { fileURLToPath } from "url";
-import ts from "typescript";
 var DEVICES_PACKAGE = "@absolutejs/devices", ABSOLUTE_MOBILE_SHELL_DEVICE_CAPABILITIES, ADAPTERS, SOURCE_GLOB, IGNORED_DIRECTORIES, IDENTIFIER_PATTERN, providerModulePattern = (provider) => new RegExp(`^@absolutejs/devices-${provider}/[a-z][a-z0-9-]*$`, "u"), providerPackagePattern = (provider) => provider === "capacitor" ? /^@capacitor\/[a-z][a-z0-9-]*@\d+\.\d+\.\d+$/u : /^(?:expo-[a-z][a-z0-9-]*|@react-native-[a-z0-9-]+\/[a-z][a-z0-9-]*)@\d+\.\d+\.\d+$/u, providerLabel = (provider) => provider === "capacitor" ? "Capacitor" : "Expo", ANDROID_PERMISSION_PATTERN, IOS_USAGE_DESCRIPTIONS, IOS_PRIVACY_ACCESSED_API_REASONS, IOS_PRIVACY_ACCESSED_APIS, object = (value) => typeof value === "object" && value !== null && !Array.isArray(value), readJson = (path) => {
   const value = JSON.parse(readFileSync3(path, "utf8"));
   if (!object(value))
@@ -2069,29 +2088,29 @@ var DEVICES_PACKAGE = "@absolutejs/devices", ABSOLUTE_MOBILE_SHELL_DEVICE_CAPABI
   const names = new Set;
   const namespaces = new Set;
   const visit = (node) => {
-    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === DEVICES_PACKAGE && !node.importClause?.isTypeOnly) {
+    if (lazyTypescript.isImportDeclaration(node) && lazyTypescript.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === DEVICES_PACKAGE && !node.importClause?.isTypeOnly) {
       const bindings = node.importClause?.namedBindings;
-      if (bindings && ts.isNamedImports(bindings)) {
+      if (bindings && lazyTypescript.isNamedImports(bindings)) {
         for (const element of bindings.elements)
           if (!element.isTypeOnly)
             names.add((element.propertyName ?? element.name).text);
       }
-      if (bindings && ts.isNamespaceImport(bindings))
+      if (bindings && lazyTypescript.isNamespaceImport(bindings))
         namespaces.add(bindings.name.text);
     }
-    if (ts.isExportDeclaration(node) && !node.isTypeOnly && node.moduleSpecifier !== undefined && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === DEVICES_PACKAGE && node.exportClause && ts.isNamedExports(node.exportClause)) {
+    if (lazyTypescript.isExportDeclaration(node) && !node.isTypeOnly && node.moduleSpecifier !== undefined && lazyTypescript.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === DEVICES_PACKAGE && node.exportClause && lazyTypescript.isNamedExports(node.exportClause)) {
       for (const element of node.exportClause.elements)
         if (!element.isTypeOnly)
           names.add((element.propertyName ?? element.name).text);
     }
-    if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && namespaces.has(node.expression.text))
+    if (lazyTypescript.isPropertyAccessExpression(node) && lazyTypescript.isIdentifier(node.expression) && namespaces.has(node.expression.text))
       names.add(node.name.text);
-    ts.forEachChild(node, visit);
+    lazyTypescript.forEachChild(node, visit);
   };
   const extension = extname3(file).toLowerCase();
   const sources = extension === ".svelte" || extension === ".vue" ? [...source.matchAll(/<script\b[^>]*>([\s\S]*?)<\/script\s*>/giu)].map((match) => match[1]).filter((value) => value !== undefined) : [source];
   for (const [index, script] of sources.entries())
-    visit(ts.createSourceFile(`${file}#script-${index}`, script, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX));
+    visit(lazyTypescript.createSourceFile(`${file}#script-${index}`, script, lazyTypescript.ScriptTarget.Latest, true, lazyTypescript.ScriptKind.TSX));
   return names;
 }, assertAbsoluteDeviceCapabilityPackages = (projectRoot, plan) => {
   const missing = missingAbsoluteDeviceCapabilityPackages(plan, directAbsoluteProjectPackages(projectRoot));
@@ -2172,6 +2191,7 @@ var DEVICES_PACKAGE = "@absolutejs/devices", ABSOLUTE_MOBILE_SHELL_DEVICE_CAPABI
   };
 };
 var init_deviceCapabilities = __esm(() => {
+  init_lazyTypescript();
   ABSOLUTE_MOBILE_SHELL_DEVICE_CAPABILITIES = [
     "keyboard",
     "systemBars"
@@ -20308,11 +20328,11 @@ var publishAbsoluteIosRelease = async (options) => {
   return publication;
 };
 // src/mobile/routeMetadataTransform.ts
+init_lazyTypescript();
 init_pageProtocol();
 init_releaseArtifact();
 import { existsSync as existsSync7, readFileSync as readFileSync8 } from "fs";
 import { dirname as dirname24, extname as extname6, relative as relative22, resolve as resolve24 } from "path";
-import ts2 from "typescript";
 var ROUTE_METHODS = new Set(["get", "head"]);
 var SOURCE_FILTER = /\.[cm]?[jt]sx?$/;
 var PAGE_HANDLERS = new Map([
@@ -20362,60 +20382,60 @@ var PAGE_HANDLERS = new Map([
   ]
 ]);
 var posixPath = (value) => value.replace(/\\/g, "/");
-var findTsconfig = (entry, projectRoot) => ts2.findConfigFile(dirname24(entry), existsSync7, "tsconfig.json") ?? ts2.findConfigFile(projectRoot, existsSync7, "tsconfig.json");
+var findTsconfig = (entry, projectRoot) => lazyTypescript.findConfigFile(dirname24(entry), existsSync7, "tsconfig.json") ?? lazyTypescript.findConfigFile(projectRoot, existsSync7, "tsconfig.json");
 var createProgram = (entry, projectRoot) => {
   const configPath = findTsconfig(entry, projectRoot);
   if (!configPath) {
-    return ts2.createProgram([entry], {
+    return lazyTypescript.createProgram([entry], {
       allowJs: true,
-      jsx: ts2.JsxEmit.ReactJSX,
-      module: ts2.ModuleKind.ESNext,
-      moduleResolution: ts2.ModuleResolutionKind.Bundler,
-      target: ts2.ScriptTarget.ESNext
+      jsx: lazyTypescript.JsxEmit.ReactJSX,
+      module: lazyTypescript.ModuleKind.ESNext,
+      moduleResolution: lazyTypescript.ModuleResolutionKind.Bundler,
+      target: lazyTypescript.ScriptTarget.ESNext
     });
   }
-  const parsed = ts2.parseJsonConfigFileContent(ts2.readConfigFile(configPath, (path) => readFileSync8(path, "utf8")).config, ts2.sys, dirname24(configPath));
+  const parsed = lazyTypescript.parseJsonConfigFileContent(lazyTypescript.readConfigFile(configPath, (path) => readFileSync8(path, "utf8")).config, lazyTypescript.sys, dirname24(configPath));
   if (!parsed.fileNames.includes(entry))
     parsed.fileNames.push(entry);
-  return ts2.createProgram(parsed.fileNames, parsed.options);
+  return lazyTypescript.createProgram(parsed.fileNames, parsed.options);
 };
 var propertyName = (property) => {
   if (!("name" in property) || !property.name)
     return;
-  if (ts2.isIdentifier(property.name))
+  if (lazyTypescript.isIdentifier(property.name))
     return property.name.text;
-  if (ts2.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 && ts2.isPropertyAssignment(property)) {
+  if (property && lazyTypescript.isPropertyAssignment(property)) {
     return property.initializer;
   }
-  if (property && ts2.isShorthandPropertyAssignment(property)) {
+  if (property && lazyTypescript.isShorthandPropertyAssignment(property)) {
     return property.name;
   }
   return;
 };
 var serializeType = (type, checker, ancestors = new Set) => {
-  if (type.flags & ts2.TypeFlags.Any)
+  if (type.flags & lazyTypescript.TypeFlags.Any)
     return { type: "any" };
-  if (type.flags & ts2.TypeFlags.Unknown)
+  if (type.flags & lazyTypescript.TypeFlags.Unknown)
     return { type: "unknown" };
-  if (type.flags & ts2.TypeFlags.Never)
+  if (type.flags & lazyTypescript.TypeFlags.Never)
     return { type: "never" };
-  if (type.flags & ts2.TypeFlags.StringLike)
+  if (type.flags & lazyTypescript.TypeFlags.StringLike)
     return { type: "string" };
-  if (type.flags & ts2.TypeFlags.NumberLike)
+  if (type.flags & lazyTypescript.TypeFlags.NumberLike)
     return { type: "number" };
-  if (type.flags & ts2.TypeFlags.BooleanLike)
+  if (type.flags & lazyTypescript.TypeFlags.BooleanLike)
     return { type: "boolean" };
-  if (type.flags & ts2.TypeFlags.BigIntLike)
+  if (type.flags & lazyTypescript.TypeFlags.BigIntLike)
     return { type: "bigint" };
-  if (type.flags & ts2.TypeFlags.Null)
+  if (type.flags & lazyTypescript.TypeFlags.Null)
     return { type: "null" };
-  if (type.flags & ts2.TypeFlags.Undefined)
+  if (type.flags & lazyTypescript.TypeFlags.Undefined)
     return { type: "undefined" };
   if (type.isUnion()) {
     return {
@@ -20429,11 +20449,11 @@ var serializeType = (type, checker, ancestors = new Set) => {
   }
   if (ancestors.has(type)) {
     return {
-      ref: checker.typeToString(type, undefined, ts2.TypeFormatFlags.NoTruncation)
+      ref: checker.typeToString(type, undefined, lazyTypescript.TypeFormatFlags.NoTruncation)
     };
   }
   ancestors.add(type);
-  const arrayElement = checker.getIndexTypeOfType(type, ts2.IndexKind.Number);
+  const arrayElement = checker.getIndexTypeOfType(type, lazyTypescript.IndexKind.Number);
   const properties = checker.getPropertiesOfType(type);
   let schema;
   if (arrayElement && properties.some(({ name }) => name === "length")) {
@@ -20448,7 +20468,7 @@ var serializeType = (type, checker, ancestors = new Set) => {
       return [
         property.name,
         {
-          optional: Boolean(property.flags & ts2.SymbolFlags.Optional),
+          optional: Boolean(property.flags & lazyTypescript.SymbolFlags.Optional),
           schema: serializeType(propertyType, checker, ancestors)
         }
       ];
@@ -20456,7 +20476,7 @@ var serializeType = (type, checker, ancestors = new Set) => {
     schema = { properties: Object.fromEntries(entries), type: "object" };
   } else {
     schema = {
-      type: checker.typeToString(type, undefined, ts2.TypeFormatFlags.NoTruncation)
+      type: checker.typeToString(type, undefined, lazyTypescript.TypeFormatFlags.NoTruncation)
     };
   }
   ancestors.delete(type);
@@ -20474,7 +20494,7 @@ var pagePropsType = (pageExpression, propsExpression, checker) => {
 };
 var resolvePageIdentity = (expression, sourceFile, checker, projectRoot) => {
   let symbol = checker.getSymbolAtLocation(expression);
-  if (symbol?.flags && symbol.flags & ts2.SymbolFlags.Alias) {
+  if (symbol?.flags && symbol.flags & lazyTypescript.SymbolFlags.Alias) {
     symbol = checker.getAliasedSymbol(symbol);
   }
   const declaration = symbol?.declarations?.[0];
@@ -20484,15 +20504,15 @@ var resolvePageIdentity = (expression, sourceFile, checker, projectRoot) => {
   return `${source}#${exportedName}`;
 };
 var resolveAlias = (symbol, checker) => {
-  if (!(symbol.flags & ts2.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 (ts2.isIdentifier(expression)) {
-    const unresolved = ts2.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);
@@ -20500,26 +20520,26 @@ var assetKey = (expression, checker, seen = new Set) => {
       return;
     seen.add(symbol);
     const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
-    if (!declaration || !ts2.isVariableDeclaration(declaration))
+    if (!declaration || !lazyTypescript.isVariableDeclaration(declaration))
       return;
     return assetKey(declaration.initializer, checker, seen);
   }
-  if (!ts2.isCallExpression(expression))
+  if (!lazyTypescript.isCallExpression(expression))
     return;
-  if (!ts2.isIdentifier(expression.expression) || expression.expression.text !== "asset") {
+  if (!lazyTypescript.isIdentifier(expression.expression) || expression.expression.text !== "asset") {
     return;
   }
   const [, key] = expression.arguments;
-  return key && ts2.isStringLiteralLike(key) ? key.text : undefined;
+  return key && lazyTypescript.isStringLiteralLike(key) ? key.text : undefined;
 };
 var staticString = (expression, bindings) => {
-  if (ts2.isStringLiteralLike(expression))
+  if (lazyTypescript.isStringLiteralLike(expression))
     return expression.text;
-  if (ts2.isIdentifier(expression))
+  if (lazyTypescript.isIdentifier(expression))
     return bindings.get(expression.text);
-  if (ts2.isNoSubstitutionTemplateLiteral(expression))
+  if (lazyTypescript.isNoSubstitutionTemplateLiteral(expression))
     return expression.text;
-  if (!ts2.isTemplateExpression(expression))
+  if (!lazyTypescript.isTemplateExpression(expression))
     return;
   let value = expression.head.text;
   for (const span of expression.templateSpans) {
@@ -20533,7 +20553,7 @@ var staticString = (expression, bindings) => {
 var assetKeyWithBindings = (expression, checker, bindings = new Map) => {
   if (!expression)
     return;
-  if (ts2.isCallExpression(expression) && ts2.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;
   }
@@ -20544,16 +20564,16 @@ var callableObject = (call, checker) => {
   const resolved = symbol ? resolveAlias(symbol, checker) : undefined;
   const declaration = resolved?.valueDeclaration ?? resolved?.declarations?.[0];
   let callable;
-  if (declaration && ts2.isFunctionDeclaration(declaration)) {
+  if (declaration && lazyTypescript.isFunctionDeclaration(declaration)) {
     callable = declaration;
-  } else if (declaration && ts2.isVariableDeclaration(declaration) && declaration.initializer && (ts2.isArrowFunction(declaration.initializer) || ts2.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 (!ts2.isIdentifier(parameter.name))
+    if (!lazyTypescript.isIdentifier(parameter.name))
       return;
     const argument = call.arguments[index];
     if (!argument)
@@ -20565,35 +20585,35 @@ var callableObject = (call, checker) => {
   const { body } = callable;
   if (!body)
     return;
-  const expressionBody = ts2.isParenthesizedExpression(body) ? body.expression : body;
-  if (ts2.isObjectLiteralExpression(expressionBody)) {
+  const expressionBody = lazyTypescript.isParenthesizedExpression(body) ? body.expression : body;
+  if (lazyTypescript.isObjectLiteralExpression(expressionBody)) {
     return { bindings, object: expressionBody };
   }
-  if (ts2.isBlock(body)) {
-    const returned = body.statements.find(ts2.isReturnStatement)?.expression;
-    if (returned && ts2.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 (ts2.isObjectLiteralExpression(expression)) {
+  if (lazyTypescript.isObjectLiteralExpression(expression)) {
     return { bindings, object: expression };
   }
-  if (!ts2.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 && ts2.isShorthandPropertyAssignment(property)) {
+    if (propertyName(property) === name && lazyTypescript.isShorthandPropertyAssignment(property)) {
       return assetKeyWithBindings(property.name, checker, bindings);
     }
-    if (propertyName(property) === name && ts2.isPropertyAssignment(property)) {
+    if (propertyName(property) === name && lazyTypescript.isPropertyAssignment(property)) {
       return assetKeyWithBindings(property.initializer, checker, bindings);
     }
-    if (!ts2.isSpreadAssignment(property))
+    if (!lazyTypescript.isSpreadAssignment(property))
       continue;
     const nestedObject = spreadObject(property.expression, checker, bindings);
     if (!nestedObject)
@@ -20609,14 +20629,14 @@ var findPageCall = (nodes) => {
   const visit = (candidate) => {
     if (found)
       return;
-    if (ts2.isCallExpression(candidate) && ts2.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;
     }
-    ts2.forEachChild(candidate, visit);
+    lazyTypescript.forEachChild(candidate, visit);
   };
   for (const node of nodes)
     visit(node);
@@ -20625,12 +20645,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 (!ts2.isPropertyAccessExpression(callee))
+  if (!lazyTypescript.isPropertyAccessExpression(callee))
     return;
   if (!ROUTE_METHODS.has(callee.name.text))
     return;
   const [routePath] = node.arguments;
-  if (!routePath || !ts2.isStringLiteralLike(routePath))
+  if (!routePath || !lazyTypescript.isStringLiteralLike(routePath))
     return;
   const foundPageCall = findPageCall(node.arguments.slice(1));
   const pageCall = foundPageCall?.node;
@@ -20663,7 +20683,7 @@ var analyzeRouteCall = (node, sourceFile, checker, projectRoot) => {
       routeCallSpan: `${node.getStart(sourceFile)}:${node.end}`
     };
   }
-  if (!ts2.isObjectLiteralExpression(input) || !definition.bundleProperty) {
+  if (!lazyTypescript.isObjectLiteralExpression(input) || !definition.bundleProperty) {
     return;
   }
   const page = definition.pageProperty ? objectPropertyExpression(input, definition.pageProperty) : undefined;
@@ -20705,14 +20725,14 @@ var analyzeSourceFile = (sourceFile, checker, projectRoot) => {
     byRouteCall: new Map
   };
   const visit = (node) => {
-    const result = ts2.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);
     }
-    ts2.forEachChild(node, visit);
+    lazyTypescript.forEachChild(node, visit);
   };
-  ts2.forEachChild(sourceFile, visit);
+  lazyTypescript.forEachChild(sourceFile, visit);
   return analysis;
 };
 var analyzeProgram = (program, projectRoot) => {
@@ -20728,21 +20748,21 @@ var analyzeProgram = (program, projectRoot) => {
   }
   return analyzed;
 };
-var metadataExpression = (metadata) => ts2.factory.createObjectLiteralExpression(Object.entries(metadata).map(([key, item]) => ts2.factory.createPropertyAssignment(ts2.factory.createStringLiteral(key), ts2.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 = ts2.factory.createObjectLiteralExpression([
-    ts2.factory.createPropertyAssignment(ts2.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 ts2.factory.createObjectLiteralExpression([
-      ts2.factory.createPropertyAssignment("detail", detail)
+    return lazyTypescript.factory.createObjectLiteralExpression([
+      lazyTypescript.factory.createPropertyAssignment("detail", detail)
     ]);
   }
-  return ts2.factory.createObjectLiteralExpression([
-    ts2.factory.createSpreadAssignment(existing),
-    ts2.factory.createPropertyAssignment("detail", ts2.factory.createObjectLiteralExpression([
-      ts2.factory.createSpreadAssignment(ts2.factory.createPropertyAccessExpression(existing, "detail")),
-      ts2.factory.createPropertyAssignment(ts2.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))
     ]))
   ]);
 };
@@ -20753,19 +20773,19 @@ var transformPageCall = (node, page) => {
     const [pagePath, existingOptions, ...rest] = node.arguments;
     if (!pagePath)
       return;
-    const options = ts2.factory.createObjectLiteralExpression([
-      ...existingOptions ? [ts2.factory.createSpreadAssignment(existingOptions)] : [],
-      ts2.factory.createPropertyAssignment("__absoluteMobile", metadataExpression(page.metadata))
+    const options = lazyTypescript.factory.createObjectLiteralExpression([
+      ...existingOptions ? [lazyTypescript.factory.createSpreadAssignment(existingOptions)] : [],
+      lazyTypescript.factory.createPropertyAssignment("__absoluteMobile", metadataExpression(page.metadata))
     ]);
-    return ts2.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 || !ts2.isObjectLiteralExpression(input))
+  if (!input || !lazyTypescript.isObjectLiteralExpression(input))
     return;
-  return ts2.factory.updateCallExpression(node, node.expression, node.typeArguments, [
-    ts2.factory.updateObjectLiteralExpression(input, [
+  return lazyTypescript.factory.updateCallExpression(node, node.expression, node.typeArguments, [
+    lazyTypescript.factory.updateObjectLiteralExpression(input, [
       ...input.properties,
-      ts2.factory.createPropertyAssignment("__absoluteMobile", metadataExpression(page.metadata))
+      lazyTypescript.factory.createPropertyAssignment("__absoluteMobile", metadataExpression(page.metadata))
     ]),
     ...node.arguments.slice(1)
   ]);
@@ -20778,16 +20798,16 @@ var transformRouteCall = (node, route) => {
     return;
   const options = maybeHandler ? maybeOptions : undefined;
   const handler = maybeHandler ?? maybeOptions;
-  return ts2.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 = ts2.createSourceFile(fileName, source, ts2.ScriptTarget.Latest, true, fileName.endsWith("x") ? ts2.ScriptKind.TSX : ts2.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 (!ts2.isCallExpression(node)) {
-        return ts2.visitEachChild(node, visit, context);
+      if (!lazyTypescript.isCallExpression(node)) {
+        return lazyTypescript.visitEachChild(node, visit, context);
       }
-      const transformedChildren = ts2.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)
@@ -20798,14 +20818,14 @@ var transformFile = (source, fileName, analysis) => {
         return transformedRoute;
       return transformedChildren;
     };
-    return (node) => ts2.visitNode(node, visit, ts2.isSourceFile) ?? node;
+    return (node) => lazyTypescript.visitNode(node, visit, lazyTypescript.isSourceFile) ?? node;
   };
-  const result = ts2.transform(sourceFile, [transformer]);
+  const result = lazyTypescript.transform(sourceFile, [transformer]);
   try {
     const [transformed] = result.transformed;
     if (!transformed)
       throw new TypeError("Mobile route transform failed.");
-    return ts2.createPrinter().printFile(transformed);
+    return lazyTypescript.createPrinter().printFile(transformed);
   } finally {
     result.dispose();
   }
@@ -27659,5 +27679,5 @@ export {
   writeAbsoluteMobileUpdateRegistry
 };
 
-//# debugId=CDE65FCB7B21BC4364756E2164756E21
+//# debugId=C21432985745295564756E2164756E21
 //# sourceMappingURL=index.js.map