@absolutejs/absolute 0.20.0-beta.3 → 0.20.0-beta.30

package/dist/mobile/shellBootstrap.js

@@ -0,0 +1,601 @@
+// src/mobile/shellBootstrap.ts
+import { App } from "@capacitor/app";
+
+// src/mobile/producerContextState.ts
+var ABSOLUTE_MOBILE_PRODUCER_STORAGE_KEY = Symbol.for("absolutejs.mobileProducerAsyncLocalStorage");
+var frameworks = new Set([
+  "angular",
+  "ember",
+  "html",
+  "htmx",
+  "react",
+  "svelte",
+  "vue"
+]);
+
+// src/mobile/pageProtocol.ts
+var ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE = "application/vnd.absolute.page+json";
+var ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION = 1;
+var MOBILE_PAGE_REQUEST_HEADERS = {
+  appBuild: "x-absolute-mobile-app-build",
+  pageBundle: "x-absolute-mobile-page-bundle",
+  pageContracts: "x-absolute-mobile-page-contracts",
+  pageId: "x-absolute-mobile-page-id",
+  protocol: "x-absolute-mobile-protocol",
+  runtime: "x-absolute-mobile-runtime"
+};
+var headerVaryValues = [
+  "Accept",
+  MOBILE_PAGE_REQUEST_HEADERS.protocol,
+  MOBILE_PAGE_REQUEST_HEADERS.runtime,
+  MOBILE_PAGE_REQUEST_HEADERS.appBuild,
+  MOBILE_PAGE_REQUEST_HEADERS.pageBundle,
+  MOBILE_PAGE_REQUEST_HEADERS.pageContracts,
+  MOBILE_PAGE_REQUEST_HEADERS.pageId
+];
+
+// src/mobile/client.ts
+class AbsoluteMobilePageProtocolError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "AbsoluteMobilePageProtocolError";
+    this.code = code;
+  }
+}
+var disposeAbsoluteMobilePage = async (target = window) => {
+  const dispose = target.__ABSOLUTE_PAGE_DISPOSE__;
+  target.__ABSOLUTE_PAGE_DISPOSE__ = undefined;
+  target.__ABSOLUTE_PAGE_READY__ = undefined;
+  if (dispose)
+    await dispose();
+};
+var frameworks2 = new Set([
+  "angular",
+  "ember",
+  "html",
+  "htmx",
+  "react",
+  "svelte",
+  "vue"
+]);
+var upgradeReasons = new Set([
+  "app-release",
+  "page-contract",
+  "protocol",
+  "runtime"
+]);
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isFramework = (value) => typeof value === "string" && frameworks2.has(value);
+var isUpgradeReason = (value) => typeof value === "string" && upgradeReasons.has(value);
+var parsePageResult = (value) => {
+  if (typeof value.contract !== "string" || !isFramework(value.framework) || typeof value.pageId !== "string" || typeof value.status !== "number") {
+    throw new AbsoluteMobilePageProtocolError("invalid-envelope", "The mobile page response is missing required page metadata.");
+  }
+  if (!isRecord(value.props)) {
+    throw new AbsoluteMobilePageProtocolError("invalid-props", "The mobile page response must contain an object props value.");
+  }
+  return {
+    contract: value.contract,
+    framework: value.framework,
+    kind: "page",
+    pageId: value.pageId,
+    props: value.props,
+    status: value.status
+  };
+};
+var parseUpgradeResult = (value) => {
+  if (typeof value.pageId !== "string" || !isUpgradeReason(value.reason)) {
+    throw new AbsoluteMobilePageProtocolError("invalid-envelope", "The update response is missing its page or reason.");
+  }
+  return {
+    kind: "upgrade-required",
+    pageId: value.pageId,
+    reason: value.reason,
+    supportedContracts: Array.isArray(value.supportedContracts) ? value.supportedContracts.filter((contract) => typeof contract === "string") : undefined,
+    supportedRuntimes: Array.isArray(value.supportedRuntimes) ? value.supportedRuntimes.filter((runtime) => typeof runtime === "string") : undefined
+  };
+};
+var activateAbsoluteMobilePage = async (value, options) => {
+  const envelope = parseAbsoluteMobilePageEnvelope(value);
+  if (envelope.response.kind === "upgrade-required") {
+    return envelope.response;
+  }
+  if (envelope.response.kind !== "page") {
+    throw new AbsoluteMobilePageProtocolError("invalid-envelope", "Expected a renderable mobile page response.");
+  }
+  const target = options.target ?? window;
+  await disposeAbsoluteMobilePage(target);
+  target.__INITIAL_PROPS__ = envelope.response.props;
+  target.__ABS_ANGULAR_REQUEST_CONTEXT__ = envelope.response.props;
+  target.__ABSOLUTE_PAGE_RENDER_MODE__ = "client";
+  await options.loadPage({
+    contract: envelope.response.contract,
+    pageId: envelope.response.pageId
+  });
+  if (target.__ABSOLUTE_PAGE_READY__) {
+    await target.__ABSOLUTE_PAGE_READY__;
+  }
+  return {
+    contract: envelope.response.contract,
+    kind: "rendered",
+    pageId: envelope.response.pageId
+  };
+};
+var parseAbsoluteMobilePageEnvelope = (value) => {
+  if (!isRecord(value) || !isRecord(value.response)) {
+    throw new AbsoluteMobilePageProtocolError("invalid-envelope", "The server did not return an AbsoluteJS mobile page envelope.");
+  }
+  if (value.protocol !== ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION) {
+    throw new AbsoluteMobilePageProtocolError("invalid-envelope", `Unsupported mobile page protocol ${String(value.protocol)}.`);
+  }
+  const { kind } = value.response;
+  if (kind === "page") {
+    return {
+      protocol: ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION,
+      response: parsePageResult(value.response)
+    };
+  }
+  if (kind === "upgrade-required") {
+    return {
+      protocol: ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION,
+      response: parseUpgradeResult(value.response)
+    };
+  }
+  if (kind === "invalid-request") {
+    throw new AbsoluteMobilePageProtocolError("server-rejected-request", typeof value.response.message === "string" ? value.response.message : "The server rejected the mobile page request.");
+  }
+  if (kind === "error") {
+    throw new AbsoluteMobilePageProtocolError("server-error", "The server could not create a compatible mobile page representation.");
+  }
+  throw new AbsoluteMobilePageProtocolError("invalid-envelope", `Unknown mobile page response kind ${String(kind)}.`);
+};
+
+// src/mobile/routeMatcher.ts
+var REGEXP_SPECIAL_CHARACTERS = /[.*+?^${}()|[\]\\]/g;
+var routeSegmentPattern = (segment) => {
+  if (segment === "*")
+    return ".*";
+  if (segment.startsWith(":") && segment.endsWith("?"))
+    return "[^/]*";
+  if (segment.startsWith(":"))
+    return "[^/]+";
+  return segment.replace(REGEXP_SPECIAL_CHARACTERS, "\\$&");
+};
+var matchesAbsoluteMobileRoutePattern = (pattern, pathname) => {
+  const expression = pattern.split("/").map(routeSegmentPattern).join("/");
+  return new RegExp(`^${expression}/?$`).test(pathname);
+};
+var resolveAbsoluteMobileRoute = (routes, pathname, method = "GET") => routes.find((route) => route.method === method && matchesAbsoluteMobileRoutePattern(route.pattern, pathname));
+
+// src/mobile/transport.ts
+var pageForPathname = (manifest, pathname) => {
+  const route = resolveAbsoluteMobileRoute(manifest.routes, pathname);
+  if (!route) {
+    throw new TypeError(`No embedded mobile page owns ${pathname}.`);
+  }
+  const page = manifest.pages.find((candidate) => candidate.pageId === route.pageId);
+  if (!page) {
+    throw new TypeError(`Mobile route ${route.pattern} references missing page ${route.pageId}.`);
+  }
+  return page;
+};
+var canonicalBackendUrl = (manifest, path) => {
+  const origin = new URL(manifest.productionOrigin);
+  const url = new URL(path, `${origin.origin}/`);
+  if (url.origin !== origin.origin) {
+    throw new TypeError("Mobile transport cannot leave productionOrigin.");
+  }
+  url.hash = "";
+  return url;
+};
+var createAbsoluteMobilePageRequest = (manifest, path, options = {}) => {
+  const url = canonicalBackendUrl(manifest, path);
+  const page = pageForPathname(manifest, url.pathname);
+  const headers = new Headers(options.headers);
+  headers.set("accept", ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE);
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.appBuild, manifest.appBuild);
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.pageBundle, page.bundleHash);
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.pageContracts, page.contract);
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.pageId, page.pageId);
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.protocol, String(ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION));
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.runtime, manifest.runtime);
+  return new Request(url, { headers, method: "GET" });
+};
+var fetchAbsoluteMobilePage = async (manifest, path, options = {}) => {
+  const request = createAbsoluteMobilePageRequest(manifest, path, options);
+  const response = await (options.fetch ?? globalThis.fetch)(request);
+  const value = await response.json();
+  return value;
+};
+var resolveAbsoluteMobileDeepLink = (manifest, value) => {
+  const url = new URL(value);
+  if (url.username || url.password) {
+    throw new TypeError("Mobile deep links cannot contain credentials.");
+  }
+  const isHttpsHost = url.protocol === "https:" && manifest.deepLinkHosts.includes(url.hostname.toLowerCase());
+  const isCustomScheme = manifest.deepLinkScheme !== undefined && url.protocol === `${manifest.deepLinkScheme}:`;
+  if (!isHttpsHost && !isCustomScheme) {
+    throw new TypeError("Mobile deep link is outside the configured app URLs.");
+  }
+  return `${url.pathname || "/"}${url.search}${url.hash}`;
+};
+var resolveAbsoluteMobileNavigation = (manifest, value, localOrigin) => {
+  const url = new URL(value, `${localOrigin}/`);
+  const local = new URL(localOrigin);
+  const production = new URL(manifest.productionOrigin);
+  const matches = (candidate, allowed) => candidate.protocol === allowed.protocol && candidate.host === allowed.host;
+  if (!matches(url, local) && !matches(url, production)) {
+    return;
+  }
+  return `${url.pathname}${url.search}${url.hash}`;
+};
+
+// src/mobile/staticDocument.ts
+var HTMX_REQUEST_ATTRIBUTE_PATTERN = /(\s(?:action|formaction|hx-(?:delete|get|patch|post|put))\s*=\s*["'])(\/[^"']*)(["'])/giu;
+var BLOCKED_FRAGMENT_ELEMENTS = 'script,base,iframe,object,embed,link[rel="modulepreload"],meta[http-equiv="refresh"]';
+var HTMX_REQUEST_ATTRIBUTES = new Set([
+  "hx-delete",
+  "hx-get",
+  "hx-patch",
+  "hx-post",
+  "hx-put"
+]);
+var URL_ATTRIBUTES = new Set(["action", "formaction", "href", "src"]);
+var HEX_RADIX = 16;
+var SCRIPT_PLACEHOLDER_ATTRIBUTE = "data-absolute-mobile-script";
+var bytesToHex = (bytes) => [...bytes].map((byte) => byte.toString(HEX_RADIX).padStart(2, "0")).join("");
+var hashAbsoluteMobileStaticDocument = async (source) => bytesToHex(new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(source))));
+var rewriteAbsoluteMobileHtmxRequests = (source, productionOrigin) => source.replace(HTMX_REQUEST_ATTRIBUTE_PATTERN, (_match, prefix, path, quote) => `${prefix}${new URL(path, productionOrigin).href}${quote}`);
+var backendUrl = (value, productionOrigin) => {
+  try {
+    const expected = new URL(productionOrigin);
+    const candidate = new URL(value, expected);
+    return candidate.origin === expected.origin ? candidate.href : undefined;
+  } catch {
+    return;
+  }
+};
+var sanitizeFragmentAttribute = (element, attribute, productionOrigin) => {
+  const name = attribute.name.toLowerCase();
+  const isExecutable = name === "srcdoc" || name.startsWith("on") || name.startsWith("hx-on");
+  const isUnsafeUrl = (HTMX_REQUEST_ATTRIBUTES.has(name) || URL_ATTRIBUTES.has(name)) && !backendUrl(attribute.value, productionOrigin);
+  if (isExecutable || isUnsafeUrl)
+    element.removeAttribute(attribute.name);
+  else if (HTMX_REQUEST_ATTRIBUTES.has(name) || URL_ATTRIBUTES.has(name)) {
+    element.setAttribute(attribute.name, backendUrl(attribute.value, productionOrigin) ?? attribute.value);
+  }
+};
+var sanitizeAbsoluteMobileHtmxFragment = (source, productionOrigin, parse = (value) => new DOMParser().parseFromString(value, "text/html")) => {
+  const parsed = parse(source);
+  parsed.querySelectorAll(BLOCKED_FRAGMENT_ELEMENTS).forEach((element) => {
+    element.remove();
+  });
+  parsed.querySelectorAll("*").forEach((element) => {
+    for (const attribute of [...element.attributes]) {
+      sanitizeFragmentAttribute(element, attribute, productionOrigin);
+    }
+  });
+  return parsed.body.innerHTML;
+};
+var installHtmxFragmentBoundary = (productionOrigin) => {
+  const validateUrl = (event) => {
+    const detail = Reflect.get(event, "detail");
+    if (typeof detail !== "object" || detail === null) {
+      event.preventDefault();
+      return;
+    }
+    const url = Reflect.get(detail, "url");
+    if (!(url instanceof URL) || !backendUrl(url.href, productionOrigin)) {
+      event.preventDefault();
+    }
+  };
+  const configureRequest = (event) => {
+    const detail = Reflect.get(event, "detail");
+    if (typeof detail !== "object" || detail === null)
+      return;
+    const path = Reflect.get(detail, "path");
+    if (typeof path !== "string")
+      return;
+    const resolved = backendUrl(path, productionOrigin);
+    if (resolved)
+      Reflect.set(detail, "path", resolved);
+  };
+  const sanitize = (event) => {
+    const detail = Reflect.get(event, "detail");
+    if (typeof detail !== "object" || detail === null)
+      return;
+    const serverResponse = Reflect.get(detail, "serverResponse");
+    if (typeof serverResponse !== "string")
+      return;
+    Reflect.set(detail, "serverResponse", sanitizeAbsoluteMobileHtmxFragment(serverResponse, productionOrigin));
+  };
+  addEventListener("htmx:validateUrl", validateUrl);
+  addEventListener("htmx:configRequest", configureRequest);
+  addEventListener("htmx:beforeSwap", sanitize);
+  return () => {
+    removeEventListener("htmx:validateUrl", validateUrl);
+    removeEventListener("htmx:configRequest", configureRequest);
+    removeEventListener("htmx:beforeSwap", sanitize);
+  };
+};
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var replaceAttributes = (target, source) => {
+  for (const attribute of [...target.attributes]) {
+    target.removeAttribute(attribute.name);
+  }
+  for (const attribute of [...source.attributes]) {
+    target.setAttribute(attribute.name, attribute.value);
+  }
+};
+var applyScriptAttribute = (element, name, value, localUrl) => {
+  if (name === SCRIPT_PLACEHOLDER_ATTRIBUTE)
+    return;
+  if (name === "src") {
+    const source = new URL(value, localUrl);
+    const navigation = new URL(localUrl).searchParams.get("absoluteNavigation");
+    if (navigation)
+      source.searchParams.set("absoluteNavigation", navigation);
+    element.src = source.href;
+    return;
+  }
+  element.setAttribute(name, value);
+};
+var executableScript = (script, localUrl) => {
+  const element = document.createElement("script");
+  for (const [name, value] of script.attributes) {
+    applyScriptAttribute(element, name, value, localUrl);
+  }
+  element.textContent = script.content;
+  return element;
+};
+var executeTrustedDocumentScript = async (placeholder, script, localUrl) => {
+  const executable = executableScript(script, localUrl);
+  if (executable.type === "module" && executable.src !== "") {
+    placeholder.remove();
+    await import(executable.src);
+    return;
+  }
+  const waitsForLoad = executable.src !== "" || executable.type === "module";
+  const loaded = waitsForLoad ? new Promise((resolve, reject) => {
+    executable.addEventListener("load", () => resolve(), {
+      once: true
+    });
+    executable.addEventListener("error", () => reject(new TypeError(`Embedded document script failed: ${executable.src || "inline module"}.`)), { once: true });
+  }) : Promise.resolve();
+  placeholder.replaceWith(executable);
+  await loaded;
+};
+var configureHtmxDocument = (parsed) => {
+  let meta = parsed.head.querySelector('meta[name="htmx-config"]');
+  if (!meta) {
+    meta = parsed.createElement("meta");
+    meta.name = "htmx-config";
+    parsed.head.appendChild(meta);
+  }
+  let authorConfig = {};
+  try {
+    const parsedConfig = JSON.parse(meta.content || "{}");
+    if (isRecord2(parsedConfig))
+      authorConfig = parsedConfig;
+  } catch {}
+  meta.content = JSON.stringify({
+    ...authorConfig,
+    selfRequestsOnly: false
+  });
+};
+var executeTrustedDocumentScripts = async (scripts, localUrl, index = 0) => {
+  const script = scripts[index];
+  if (!script)
+    return;
+  const placeholder = document.querySelector(`script[${SCRIPT_PLACEHOLDER_ATTRIBUTE}="${index}"]`);
+  if (placeholder) {
+    await executeTrustedDocumentScript(placeholder, script, localUrl);
+  }
+  await executeTrustedDocumentScripts(scripts, localUrl, index + 1);
+};
+var installTrustedDocument = async (source, localUrl, options) => {
+  const parsed = new DOMParser().parseFromString(source, "text/html");
+  if (options.htmx)
+    configureHtmxDocument(parsed);
+  const scripts = [...parsed.querySelectorAll("script")].map((script, index) => {
+    const definition = {
+      attributes: [...script.attributes].map((attribute) => [
+        attribute.name,
+        attribute.value
+      ]),
+      content: script.textContent ?? ""
+    };
+    script.removeAttribute("src");
+    script.type = "application/x-absolute-mobile-script";
+    script.setAttribute(SCRIPT_PLACEHOLDER_ATTRIBUTE, String(index));
+    return definition;
+  });
+  replaceAttributes(document.documentElement, parsed.documentElement);
+  document.head.replaceChildren(...[...parsed.head.childNodes].map((node) => document.importNode(node, true)));
+  document.body.replaceWith(document.importNode(parsed.body, true));
+  await executeTrustedDocumentScripts(scripts, localUrl);
+};
+var installAbsoluteMobileStaticDocument = async (manifest, page, localUrl) => {
+  const response = await fetch(localUrl, { cache: "no-store" });
+  if (!response.ok) {
+    throw new TypeError(`Embedded ${page.framework} document failed with HTTP ${response.status}.`);
+  }
+  const source = await response.text();
+  const actualHash = await hashAbsoluteMobileStaticDocument(source);
+  if (actualHash !== page.bundleHash) {
+    throw new TypeError(`Embedded ${page.framework} document failed integrity.`);
+  }
+  const disposeHtmxBoundary = page.framework === "htmx" ? installHtmxFragmentBoundary(manifest.productionOrigin) : undefined;
+  const ready = installTrustedDocument(page.framework === "htmx" ? rewriteAbsoluteMobileHtmxRequests(source, manifest.productionOrigin) : source, localUrl, { htmx: page.framework === "htmx" });
+  Reflect.set(window, "__ABSOLUTE_PAGE_READY__", ready);
+  Reflect.set(window, "__ABSOLUTE_PAGE_DISPOSE__", () => disposeHtmxBoundary?.());
+  await ready;
+};
+
+// src/mobile/shellBootstrap.ts
+var MANIFEST_PATH = "./absolute-mobile-manifest.json";
+var STATUS_ID = "absolute-mobile-status";
+var initialNavigationPath = (entry) => {
+  const current = `${location.pathname}${location.search}${location.hash}`;
+  return current === "/" || current === "/index.html" ? entry : current;
+};
+var navigationGeneration = 0;
+var notifyCapacitorSystemBarsDomReady = () => {
+  const provider = Reflect.get(globalThis, "CapacitorSystemBarsAndroidInterface");
+  if (typeof provider !== "object" || provider === null)
+    return;
+  const onDOMReady = Reflect.get(provider, "onDOMReady");
+  if (typeof onDOMReady !== "function")
+    return;
+  try {
+    onDOMReady.call(provider);
+  } catch {}
+};
+var readManifest = async () => {
+  const response = await fetch(MANIFEST_PATH, { cache: "no-store" });
+  if (!response.ok) {
+    throw new TypeError(`Mobile manifest failed with HTTP ${response.status}.`);
+  }
+  const manifest = await response.json();
+  return manifest;
+};
+var renderStatus = (message) => {
+  document.title = "AbsoluteJS";
+  document.head.innerHTML = '<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">';
+  document.body.innerHTML = `<main id="${STATUS_ID}" role="status"></main>`;
+  const status = document.getElementById(STATUS_ID);
+  if (status)
+    status.textContent = message;
+};
+var renderPageTarget = () => {
+  document.title = "AbsoluteJS";
+  document.head.innerHTML = '<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">';
+  document.body.innerHTML = '<div id="root"></div>';
+};
+var localBundleUrl = (manifest, pageId, contract) => {
+  const page = manifest.pages.find((candidate) => candidate.pageId === pageId && candidate.contract === contract);
+  if (!page) {
+    throw new TypeError(`The embedded app does not contain ${pageId} contract ${contract}.`);
+  }
+  const url = new URL(page.localBundlePath, document.baseURI);
+  url.searchParams.set("absoluteNavigation", String(navigationGeneration += 1));
+  return url.href;
+};
+var installLocalPageStyle = (manifest, pageId, contract) => {
+  const page = manifest.pages.find((candidate) => candidate.pageId === pageId && candidate.contract === contract);
+  if (!page?.localStylePath)
+    return;
+  const link = document.createElement("link");
+  link.rel = "stylesheet";
+  link.href = new URL(page.localStylePath, document.baseURI).href;
+  link.dataset.absoluteMobilePageStyle = page.bundleHash;
+  document.head.appendChild(link);
+};
+var navigate = async (manifest, path, pushHistory, fetchImpl) => {
+  await disposeAbsoluteMobilePage();
+  renderStatus("Loading…");
+  const envelope = await fetchAbsoluteMobilePage(manifest, path, {
+    ...fetchImpl ? { fetch: fetchImpl } : {}
+  });
+  const activation = await activateAbsoluteMobilePage(envelope, {
+    loadPage: ({ contract, pageId }) => {
+      const page = manifest.pages.find((candidate) => candidate.pageId === pageId && candidate.contract === contract);
+      if (!page) {
+        throw new TypeError(`The embedded app does not contain ${pageId} contract ${contract}.`);
+      }
+      if (page.framework === "html" || page.framework === "htmx") {
+        return installAbsoluteMobileStaticDocument(manifest, page, localBundleUrl(manifest, pageId, contract));
+      }
+      renderPageTarget();
+      installLocalPageStyle(manifest, pageId, contract);
+      return import(localBundleUrl(manifest, pageId, contract));
+    }
+  });
+  if (activation.kind === "upgrade-required") {
+    renderStatus("This app version must be updated to continue.");
+    return;
+  }
+  if (pushHistory)
+    history.pushState({ absoluteMobile: true }, "", path);
+};
+var installAnchorNavigation = (manifest, onNavigate) => {
+  const handleClick = (event) => {
+    if (!(event.target instanceof Element))
+      return;
+    const anchor = event.target.closest("a[href]");
+    if (!(anchor instanceof HTMLAnchorElement) || anchor.target)
+      return;
+    try {
+      const path = resolveAbsoluteMobileNavigation(manifest, anchor.href, location.origin);
+      if (!path)
+        return;
+      event.preventDefault();
+      onNavigate(path);
+    } catch {}
+  };
+  addEventListener("click", handleClick);
+  return () => removeEventListener("click", handleClick);
+};
+var navigateDeepLink = (manifest, onNavigate, url, authRedirectUri) => {
+  if (!url)
+    return;
+  if (authRedirectUri) {
+    const actual = new URL(url);
+    const redirect = new URL(authRedirectUri);
+    if (actual.protocol === redirect.protocol && actual.host === redirect.host && actual.pathname === redirect.pathname)
+      return;
+  }
+  onNavigate(resolveAbsoluteMobileDeepLink(manifest, url));
+};
+var deepLinkListener = (manifest, onNavigate, authRedirectUri) => ({ url }) => navigateDeepLink(manifest, onNavigate, url, authRedirectUri);
+var installDeepLinks = async (manifest, onNavigate, authRedirectUri) => {
+  let listener;
+  try {
+    listener = await App.addListener("appUrlOpen", deepLinkListener(manifest, onNavigate, authRedirectUri));
+    const launch = await App.getLaunchUrl();
+    navigateDeepLink(manifest, onNavigate, launch?.url, authRedirectUri);
+  } catch {}
+  return listener;
+};
+var navigateWithFailureState = async (manifest, path, pushHistory, reinstallBrowserNavigation, fetchImpl) => {
+  try {
+    await navigate(manifest, path, pushHistory, fetchImpl);
+  } catch (error) {
+    console.error("[Absolute Mobile] Navigation failed:", error);
+    renderStatus("Unable to load this page. Check your connection and retry.");
+  } finally {
+    reinstallBrowserNavigation();
+  }
+};
+var startAbsoluteMobileShell = async (options = {}) => {
+  notifyCapacitorSystemBarsDomReady();
+  const manifest = await readManifest();
+  const auth = manifest.auth && options.createAuth ? await options.createAuth(manifest.auth, {
+    beforeSignOut: options.beforeSignOut
+  }) : undefined;
+  if (auth)
+    options.connectPush?.(auth);
+  if (auth && manifest.sync?.socketTickets)
+    options.installSync?.(auth, manifest.sync);
+  let removeAnchorNavigation = () => {
+    return;
+  };
+  const handlePopState = () => {
+    navigateWithFailureState(manifest, `${location.pathname}${location.search}${location.hash}`, false, reinstallBrowserNavigation, auth?.fetch);
+  };
+  const reinstallBrowserNavigation = () => {
+    removeAnchorNavigation();
+    removeEventListener("popstate", handlePopState);
+    removeAnchorNavigation = installAnchorNavigation(manifest, onNavigate);
+    addEventListener("popstate", handlePopState);
+  };
+  const onNavigate = (path) => {
+    navigateWithFailureState(manifest, path, true, reinstallBrowserNavigation, auth?.fetch);
+  };
+  await navigateWithFailureState(manifest, initialNavigationPath(manifest.entry), false, reinstallBrowserNavigation, auth?.fetch);
+  await installDeepLinks(manifest, onNavigate, auth?.redirectUri);
+};
+export {
+  startAbsoluteMobileShell
+};