@absolutejs/absolute 0.20.0-beta.121 → 0.20.0-beta.123

package/dist/cli/config/server.js

@@ -39210,8 +39210,16 @@ var renderSpaNotFound = async (framework, pageName, request) => {
   });
 };
 
+// src/client/browserTranslationAttributes.ts
+var TRANSLATABLE_ATTRIBUTES = [
+  "alt",
+  "title",
+  "placeholder",
+  "aria-label"
+];
+
 // src/core/browserTranslation.ts
-var BROWSER_TRANSLATION_BASELINE_SCRIPT = "window.__ABSOLUTE_SSR_TEXT_BASELINES__=new WeakMap();" + "{const r=document.body,b=window.__ABSOLUTE_SSR_TEXT_BASELINES__;" + 'if(r)for(const e of [r,...r.querySelectorAll("*")]){' + "const t=new Map();for(const [i,n]of[...e.childNodes].entries())" + 'if(n.nodeType===3)t.set(i,n.nodeValue??"");if(t.size)b.set(e,t);}}';
+var BROWSER_TRANSLATION_BASELINE_SCRIPT = "window.__ABSOLUTE_SSR_TEXT_BASELINES__=new WeakMap();" + "window.__ABSOLUTE_SSR_ATTRIBUTE_BASELINES__=new WeakMap();" + "{const r=document.body,b=window.__ABSOLUTE_SSR_TEXT_BASELINES__," + "a=window.__ABSOLUTE_SSR_ATTRIBUTE_BASELINES__;" + 'if(r)for(const e of [r,...r.querySelectorAll("*")]){' + "const t=new Map();for(const [i,n]of[...e.childNodes].entries())" + 'if(n.nodeType===3)t.set(i,n.nodeValue??"");if(t.size)b.set(e,t);' + `const v=new Map();for(const k of ${JSON.stringify(TRANSLATABLE_ATTRIBUTES)}){` + "const s=e.getAttribute(k);if(s!==null)v.set(k,s);}if(v.size)a.set(e,v);}}";
 
 // src/react/pageHandler.ts
 var withRequestUrl = (props, url) => Object.assign(Object.create(null), props, { url });

package/dist/cli/{dev-pdefc9ac.js → dev-s7kct3xq.js}

@@ -12,6 +12,9 @@ import {
 import {
   scanListeners
 } from "./index-fhaf3tdk.js";
+import {
+  resolveDevBunExecutable
+} from "./index-hty8111z.js";
 import {
   stripStringsAndComments
 } from "./index-fc9vxw56.js";
@@ -1504,6 +1507,8 @@ var dev = async (serverEntry, configPath, options = {}) => {
   let selectedRemoteMacProfile;
   let expoDevProject;
   markBoot("dev command entered");
+  const bunExecutable = await resolveDevBunExecutable();
+  markBoot("dev bun runtime selected");
   let prescanConfig;
   try {
     const config = await loadConfig(configPath);
@@ -2499,7 +2504,7 @@ var dev = async (serverEntry, configPath, options = {}) => {
     markBoot("dev child spawn requested");
     const prescanForSpawn = prescan;
     prescan = null;
-    const proc = nodeSpawn("bun", [
+    const proc = nodeSpawn(bunExecutable, [
       "--hot",
       "--no-clear-screen",
       ...heapSnapshotEnabled ? ["--preload", heapPreloadPath] : [],

package/dist/cli/index-hty8111z.js

@@ -0,0 +1,410 @@
+// @bun
+// src/cli/patchedBun.ts
+import { spawnSync } from "child_process";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { createInterface } from "readline/promises";
+import { inflateRawSync } from "zlib";
+var PATCHED_BUN_RELEASE = {
+  bunVersion: "1.4.0",
+  issue: "https://github.com/oven-sh/bun/issues/32919",
+  repo: "absolutejs/patched-bun",
+  sha256: {
+    "bun-darwin-aarch64": "940d8c7eadb9fb4f39f06b0a086bbb6851d1bf3bc164bd3ba3a6966f8229f53c",
+    "bun-darwin-x64": "847f215cdd147431d025ffec94063467d1e4e80a5e4c311efff4570e04fa06ed",
+    "bun-freebsd-aarch64": "6d1c6c51cb782a1f9d2f4e2481aa7b856eff05be430094fa3b8fb86adf4067a3",
+    "bun-freebsd-x64": "c5395cd411bf3df75c3943e6ebb7722b5dd369df9a97c622449d36129cc6277a",
+    "bun-linux-aarch64": "fd5931bf59ff2bbaeab5fa37a1b003a3f10ada6b7fee2d3d8f15e606adad61f9",
+    "bun-linux-aarch64-android": "ab560ea72357554c93b4b0390b869ec62769c9b5f676ab196ecb3b0e328d7126",
+    "bun-linux-aarch64-musl": "b9c3f9936f4c7b6b0b749090f70806a1f73ca48d5a9762709ef9a4e9a5b0fed8",
+    "bun-linux-x64": "d36584f9aa71773fada3831ddf01a34c6089988988b900fd968586db099a0567",
+    "bun-linux-x64-android": "1a9712c77516fc224ed3307e083a12ea6e4f1a2956e920b9590bf12e4f59304e",
+    "bun-linux-x64-musl": "061a8bd6afad866f807d93125508c303f16c2dbf000387c91d22dd777c072951",
+    "bun-windows-aarch64": "91ed75e937b191eaf18bb361040acc24cd363b38f7bdaab5228fadd813f2a9ea",
+    "bun-windows-x64": "f7a7a22349dc7d4df0347da3f3058fe746763e22950bc77f4ae8021dab75a7b3"
+  },
+  tag: "bun-v1.4.0-absolute.2"
+};
+var HOURS_PER_DAY = 24;
+var MS_PER_HOUR = 3600000;
+var ASK_LATER_MS = HOURS_PER_DAY * MS_PER_HOUR;
+var PREFERENCE_FILE = "patched-bun.json";
+var EXECUTABLE_MODE = 493;
+var VERSION_PARTS = 3;
+var PROBE_TIMEOUT_MS = 30000;
+var MUSL_LOADERS = ["/lib/ld-musl-x86_64.so.1", "/lib/ld-musl-aarch64.so.1"];
+var DEPENDENCY_FIELDS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies"
+];
+var ZIP = {
+  directoryEntry: 33639248,
+  endDirectoryOffset: 16,
+  endEntryCount: 10,
+  endOfDirectory: 101010256,
+  endRecordSize: 22,
+  entryCommentLength: 32,
+  entryCompressedSize: 20,
+  entryExtraLength: 30,
+  entryHeaderSize: 46,
+  entryLocalOffset: 42,
+  entryMethod: 10,
+  entryNameLength: 28,
+  localExtraLength: 28,
+  localHeader: 67324752,
+  localHeaderSize: 30,
+  localNameLength: 26,
+  methodDeflate: 8,
+  methodStored: 0
+};
+var isAsset = (name) => Object.hasOwn(PATCHED_BUN_RELEASE.sha256, name);
+var detectLibc = () => {
+  if (process.platform === "android")
+    return "android";
+  if (MUSL_LOADERS.some((loader) => existsSync(loader)))
+    return "musl";
+  return "glibc";
+};
+var absoluteHome = (home) => join(home, ".absolutejs");
+var compareVersions = (left, right) => {
+  const parse = (version) => version.split("-")[0]?.split(".").map(Number) ?? [];
+  const leftParts = parse(left);
+  const rightParts = parse(right);
+  const differences = Array.from({ length: VERSION_PARTS }, (_, index) => (leftParts[index] ?? 0) - (rightParts[index] ?? 0));
+  return differences.find((difference) => difference !== 0) ?? 0;
+};
+var preferencePath = (home) => join(absoluteHome(home), PREFERENCE_FILE);
+var installedPatchedBun = (home = homedir()) => {
+  const asset = patchedBunAsset();
+  if (!asset)
+    return null;
+  const path = patchedBunPath(asset, home);
+  return existsSync(path) ? path : null;
+};
+var patchedBunAsset = (platform = process.platform, arch = process.arch, libc = detectLibc()) => {
+  const cpu = { arm64: "aarch64", x64: "x64" }[arch];
+  const system = {
+    android: "linux",
+    darwin: "darwin",
+    freebsd: "freebsd",
+    linux: "linux",
+    win32: "windows"
+  }[platform];
+  if (!cpu || !system)
+    return null;
+  const abi = system === "linux" && libc !== "glibc" ? `-${libc}` : "";
+  const name = `bun-${system}-${cpu}${abi}`;
+  return isAsset(name) ? name : null;
+};
+var patchedBunPath = (asset, home = homedir()) => join(absoluteHome(home), "bun", PATCHED_BUN_RELEASE.tag, asset, asset.startsWith("bun-windows") ? "bun.exe" : "bun");
+var runtimeSupportsReactFastRefresh = () => {
+  const options = { loader: "tsx", reactFastRefresh: true };
+  try {
+    return new Bun.Transpiler(options).transformSync("export function Probe(){return null;}").includes("$RefreshReg$");
+  } catch {
+    return false;
+  }
+};
+var parsePreference = (parsed) => {
+  if (typeof parsed !== "object" || parsed === null)
+    return null;
+  if (!("decision" in parsed))
+    return null;
+  if (parsed.decision === "never") {
+    const never = { decision: "never" };
+    return never;
+  }
+  if (parsed.decision !== "later" || !("askAfter" in parsed) || typeof parsed.askAfter !== "string")
+    return null;
+  const later = { askAfter: parsed.askAfter, decision: "later" };
+  return later;
+};
+var patchedBunOfferState = (context) => {
+  if (context.supported)
+    return "runtime-supports-refresh";
+  if (context.installed)
+    return "installed";
+  if (!context.usesReact)
+    return "not-a-react-project";
+  if (!context.asset)
+    return "unsupported-platform";
+  if (compareVersions(context.bunVersion, PATCHED_BUN_RELEASE.bunVersion) > 0)
+    return "runtime-newer";
+  if (context.preference?.decision === "never")
+    return "declined";
+  if (context.preference?.decision === "later" && new Date(context.preference.askAfter) > context.now)
+    return "asked-recently";
+  if (context.ci || !context.interactive)
+    return "non-interactive";
+  return "offer";
+};
+var readPatchedBunPreference = (home = homedir()) => {
+  try {
+    return parsePreference(JSON.parse(readFileSync(preferencePath(home), "utf-8")));
+  } catch {
+    return null;
+  }
+};
+var findEndOfDirectory = (view) => {
+  for (let offset = view.byteLength - ZIP.endRecordSize;offset >= 0; offset--) {
+    if (view.getUint32(offset, true) === ZIP.endOfDirectory)
+      return offset;
+  }
+  throw new Error("Not a zip archive.");
+};
+var inflateEntry = (data, method) => {
+  if (method === ZIP.methodStored)
+    return data;
+  if (method === ZIP.methodDeflate)
+    return new Uint8Array(inflateRawSync(data));
+  throw new Error(`Unsupported zip compression method ${method}.`);
+};
+var readEntryData = (archive, view, entry) => {
+  if (view.getUint32(entry.localOffset, true) !== ZIP.localHeader)
+    throw new Error("Corrupt zip entry.");
+  const dataStart = entry.localOffset + ZIP.localHeaderSize + view.getUint16(entry.localOffset + ZIP.localNameLength, true) + view.getUint16(entry.localOffset + ZIP.localExtraLength, true);
+  return inflateEntry(archive.subarray(dataStart, dataStart + entry.compressedSize), entry.method);
+};
+var readZipEntry = (archive, entryName) => {
+  const view = new DataView(archive.buffer, archive.byteOffset, archive.byteLength);
+  const end = findEndOfDirectory(view);
+  const entries = view.getUint16(end + ZIP.endEntryCount, true);
+  const decoder = new TextDecoder;
+  let cursor = view.getUint32(end + ZIP.endDirectoryOffset, true);
+  for (let index = 0;index < entries; index++) {
+    if (view.getUint32(cursor, true) !== ZIP.directoryEntry)
+      throw new Error("Corrupt zip directory.");
+    const nameLength = view.getUint16(cursor + ZIP.entryNameLength, true);
+    const nameStart = cursor + ZIP.entryHeaderSize;
+    const name = decoder.decode(archive.subarray(nameStart, nameStart + nameLength));
+    const entry = {
+      compressedSize: view.getUint32(cursor + ZIP.entryCompressedSize, true),
+      localOffset: view.getUint32(cursor + ZIP.entryLocalOffset, true),
+      method: view.getUint16(cursor + ZIP.entryMethod, true)
+    };
+    if (name === entryName)
+      return readEntryData(archive, view, entry);
+    cursor += ZIP.entryHeaderSize + nameLength + view.getUint16(cursor + ZIP.entryExtraLength, true) + view.getUint16(cursor + ZIP.entryCommentLength, true);
+  }
+  throw new Error(`${entryName} is not in the archive.`);
+};
+var writePatchedBunPreference = (preference, home = homedir()) => {
+  const path = preferencePath(home);
+  if (preference === null) {
+    rmSync(path, { force: true });
+    return;
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(preference, null, "\t")}
+`);
+};
+var sha256 = (bytes) => new Bun.CryptoHasher("sha256").update(bytes).digest("hex");
+var projectUsesReact = (projectDir) => {
+  const hasReact = (deps) => typeof deps === "object" && deps !== null && Object.hasOwn(deps, "react");
+  try {
+    const manifest = JSON.parse(readFileSync(join(projectDir, "package.json"), "utf-8"));
+    if (typeof manifest !== "object" || manifest === null)
+      return false;
+    return DEPENDENCY_FIELDS.some((field) => hasReact(Reflect.get(manifest, field)));
+  } catch {
+    return false;
+  }
+};
+var PATCHED_BUN_EXPLANATION = [
+  "React edits reload the page and lose component state on this Bun.",
+  `Stock Bun ignores \`reactFastRefresh\` on Bun.Transpiler (${PATCHED_BUN_RELEASE.issue}),`,
+  "so React Fast Refresh cannot keep state across edits. Until Bun ships the fix,",
+  `AbsoluteJS publishes Bun ${PATCHED_BUN_RELEASE.bunVersion} with only that fix: https://github.com/${PATCHED_BUN_RELEASE.repo}`,
+  "It installs to ~/.absolutejs/bun and only `absolute dev` uses it; your `bun` is unchanged."
+];
+var installPatchedBun = async (options = {}) => {
+  const asset = options.asset ?? patchedBunAsset();
+  if (!asset)
+    throw new Error(`No patched Bun build for ${process.platform}-${process.arch}.`);
+  const home = options.home ?? homedir();
+  const log = options.log ?? console.log;
+  const url = patchedBunDownloadUrl(asset);
+  log(`Downloading ${url}`);
+  const response = await (options.fetchImpl ?? fetch)(url);
+  if (!response.ok)
+    throw new Error(`Download failed: ${url} answered ${response.status}.`);
+  const archive = new Uint8Array(await response.arrayBuffer());
+  const expected = (options.checksums ?? PATCHED_BUN_RELEASE.sha256)[asset];
+  const actual = sha256(archive);
+  if (actual !== expected)
+    throw new Error(`${asset}.zip does not match its pinned SHA-256 (expected ${expected}, got ${actual}); not installing it.`);
+  const target = patchedBunPath(asset, home);
+  const binary = readZipEntry(archive, `${asset}/${target.endsWith(".exe") ? "bun.exe" : "bun"}`);
+  mkdirSync(dirname(target), { recursive: true });
+  const staging = `${target}.${process.pid}.tmp`;
+  writeFileSync(staging, binary);
+  chmodSync(staging, EXECUTABLE_MODE);
+  renameSync(staging, target);
+  log(`Installed patched Bun ${PATCHED_BUN_RELEASE.bunVersion} at ${target}`);
+  return target;
+};
+var parsePatchedBunChoice = (answer) => {
+  const normalized = answer.trim().toLowerCase();
+  const choices = [
+    {
+      choice: "install",
+      matches: normalized === "" || normalized === "1" || normalized.startsWith("i")
+    },
+    {
+      choice: "later",
+      matches: normalized === "2" || normalized.startsWith("l")
+    },
+    {
+      choice: "never",
+      matches: normalized === "3" || normalized.startsWith("d") || normalized.startsWith("n")
+    }
+  ];
+  return choices.find(({ matches }) => matches)?.choice ?? null;
+};
+var patchedBunDownloadUrl = (asset) => `https://github.com/${PATCHED_BUN_RELEASE.repo}/releases/download/${PATCHED_BUN_RELEASE.tag}/${asset}.zip`;
+var verifyPatchedBun = (path) => {
+  const probe = spawnSync(path, [
+    "-e",
+    'console.log(Bun.version, new Bun.Transpiler({loader:"tsx",reactFastRefresh:true}).transformSync("export function P(){return null}").includes("$RefreshReg$"))'
+  ], { encoding: "utf-8", timeout: PROBE_TIMEOUT_MS });
+  return probe.status === 0 && probe.stdout.trim() === `${PATCHED_BUN_RELEASE.bunVersion} true`;
+};
+var askUntilAnswered = async (prompt) => {
+  const choice = parsePatchedBunChoice(await prompt.question("Choose [1-3] (default 1): "));
+  return choice ?? askUntilAnswered(prompt);
+};
+var askForChoice = async () => {
+  const prompt = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    console.log(`
+${PATCHED_BUN_EXPLANATION.join(`
+`)}
+`);
+    console.log(`  1) Install now
+  2) Ask me later
+  3) Don't ask again
+`);
+    return await askUntilAnswered(prompt);
+  } finally {
+    prompt.close();
+  }
+};
+var installVerified = async (home) => {
+  const path = await installPatchedBun({ home });
+  if (!verifyPatchedBun(path)) {
+    rmSync(path, { force: true });
+    throw new Error("the installed binary did not pass its check; removed it");
+  }
+  writePatchedBunPreference(null, home);
+  return path;
+};
+var recordDecline = (choice, home) => {
+  if (choice === "never") {
+    writePatchedBunPreference({ decision: "never" }, home);
+    console.log("OK, not asking again. `absolute bun-patch install` installs it any time; `absolute bun-patch reset` asks again.");
+    return;
+  }
+  writePatchedBunPreference({
+    askAfter: new Date(Date.now() + ASK_LATER_MS).toISOString(),
+    decision: "later"
+  }, home);
+  console.log("OK, asking again tomorrow. `absolute bun-patch install` installs it any time.");
+};
+var resolveDevBunExecutable = async (projectDir = process.cwd(), home = homedir()) => {
+  if (process.env.ABSOLUTE_PATCHED_BUN === "0")
+    return "bun";
+  const installed = installedPatchedBun(home);
+  if (installed) {
+    console.log(`Using AbsoluteJS patched Bun ${PATCHED_BUN_RELEASE.bunVersion} for React Fast Refresh (${installed}).`);
+    return installed;
+  }
+  const state = patchedBunOfferState({
+    asset: patchedBunAsset(),
+    bunVersion: Bun.version,
+    ci: Boolean(process.env.CI),
+    installed: false,
+    interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+    now: new Date,
+    preference: readPatchedBunPreference(home),
+    supported: runtimeSupportsReactFastRefresh(),
+    usesReact: projectUsesReact(projectDir)
+  });
+  if (state === "non-interactive")
+    console.log(`React edits will reload the page: stock Bun lacks the reactFastRefresh fix (${PATCHED_BUN_RELEASE.issue}). Run \`absolute bun-patch install\` to use AbsoluteJS's patched Bun.`);
+  if (state !== "offer")
+    return "bun";
+  const choice = await askForChoice();
+  if (choice !== "install") {
+    recordDecline(choice, home);
+    return "bun";
+  }
+  try {
+    return await installVerified(home);
+  } catch (error) {
+    console.error(`Could not install the patched Bun (${error instanceof Error ? error.message : String(error)}). Continuing with your bun; React edits will reload the page.`);
+    return "bun";
+  }
+};
+var describePreference = (preference) => {
+  if (preference === null)
+    return "will ask";
+  if (preference.decision === "never")
+    return "won't ask again";
+  return `asking again after ${preference.askAfter}`;
+};
+var describeInstalled = (installed) => {
+  if (!installed)
+    return "no";
+  if (verifyPatchedBun(installed))
+    return installed;
+  return `${installed} (FAILED its check; run \`absolute bun-patch install\`)`;
+};
+var printStatus = (home) => {
+  const supported = runtimeSupportsReactFastRefresh();
+  console.log(`Release: ${PATCHED_BUN_RELEASE.tag} (${PATCHED_BUN_RELEASE.issue})`);
+  console.log(`Platform build: ${patchedBunAsset() ?? "none for this platform"}`);
+  console.log(`Your bun: ${Bun.version} (${supported ? "already has the fix" : "stock, no fix"})`);
+  console.log(`Installed: ${describeInstalled(installedPatchedBun(home))}`);
+  console.log(`Prompt: ${describePreference(readPatchedBunPreference(home))}`);
+};
+var bunPatch = async (args, home = homedir()) => {
+  const [action = "status"] = args;
+  if (action === "status") {
+    printStatus(home);
+    return;
+  }
+  if (action === "install") {
+    await installVerified(home);
+    console.log("`absolute dev` will use it from now on.");
+    return;
+  }
+  if (action === "remove") {
+    rmSync(join(absoluteHome(home), "bun"), {
+      force: true,
+      recursive: true
+    });
+    console.log("Removed the patched Bun. `absolute dev` uses your bun again.");
+    return;
+  }
+  if (action === "reset") {
+    writePatchedBunPreference(null, home);
+    console.log("`absolute dev` will offer the patched Bun again.");
+    return;
+  }
+  throw new Error(`Unknown bun-patch action "${action}". Use status, install, remove or reset.`);
+};
+
+export { PATCHED_BUN_RELEASE, installedPatchedBun, patchedBunAsset, patchedBunPath, runtimeSupportsReactFastRefresh, patchedBunOfferState, readPatchedBunPreference, readZipEntry, writePatchedBunPreference, PATCHED_BUN_EXPLANATION, installPatchedBun, parsePatchedBunChoice, patchedBunDownloadUrl, verifyPatchedBun, resolveDevBunExecutable, bunPatch };

package/dist/cli/index.js

@@ -58,13 +58,16 @@ if (command === "dev") {
   }
   const positionalArgs = stripNamedArgs("--config", "--android-device", "--ios-device").filter((arg) => arg !== "--no-mobile" && arg !== "--eager");
   const serverEntry = positionalArgs[0] ?? DEFAULT_SERVER_ENTRY;
-  const { dev } = await import("./dev-pdefc9ac.js");
+  const { dev } = await import("./dev-s7kct3xq.js");
   await dev(serverEntry, configPath, {
     androidDevice,
     eager: args.includes("--eager"),
     iosDevice,
     mobile: !args.includes("--no-mobile")
   });
+} else if (command === "bun-patch") {
+  const { bunPatch } = await import("./patchedBun-zjtrn2s4.js");
+  await bunPatch(args);
 } else if (command === "start") {
   sendTelemetryEvent("cli:command", { command });
   const outdir = parseNamedArg("--outdir");
@@ -208,7 +211,7 @@ if (command === "dev") {
   sendTelemetryEvent("cli:command", {
     command: `mobile:${workspaceCommand ?? "unknown"}`
   });
-  const { runMobile } = await import("./mobile-00bqw12c.js");
+  const { runMobile } = await import("./mobile-6kdsrhxy.js");
   try {
     await runMobile(args);
   } catch (error) {
@@ -267,6 +270,7 @@ if (command === "dev") {
   console.error("  routes [--json] List every route (pages + API) of a running dev server");
   console.error("  typecheck     Run type checkers for all frameworks");
   console.error("  migrate       Report what moving this project to AbsoluteJS involves");
+  console.error("  bun-patch [status|install|remove|reset] Bun with the React Fast Refresh fix (oven-sh/bun#32919)");
   console.error("  telemetry     Manage anonymous telemetry");
   console.error("  tunnel-relay  Run the public reverse-tunnel relay (for webhook dev)");
   process.exit(1);

package/dist/cli/patchedBun-zjtrn2s4.js

@@ -0,0 +1,38 @@
+// @bun
+import {
+  PATCHED_BUN_EXPLANATION,
+  PATCHED_BUN_RELEASE,
+  bunPatch,
+  installPatchedBun,
+  installedPatchedBun,
+  parsePatchedBunChoice,
+  patchedBunAsset,
+  patchedBunDownloadUrl,
+  patchedBunOfferState,
+  patchedBunPath,
+  readPatchedBunPreference,
+  readZipEntry,
+  resolveDevBunExecutable,
+  runtimeSupportsReactFastRefresh,
+  verifyPatchedBun,
+  writePatchedBunPreference
+} from "./index-hty8111z.js";
+import"./index-mywsk201.js";
+export {
+  PATCHED_BUN_EXPLANATION,
+  PATCHED_BUN_RELEASE,
+  bunPatch,
+  installPatchedBun,
+  installedPatchedBun,
+  parsePatchedBunChoice,
+  patchedBunAsset,
+  patchedBunDownloadUrl,
+  patchedBunOfferState,
+  patchedBunPath,
+  readPatchedBunPreference,
+  readZipEntry,
+  resolveDevBunExecutable,
+  runtimeSupportsReactFastRefresh,
+  verifyPatchedBun,
+  writePatchedBunPreference
+};

package/dist/client/chunks/index-dk743xs6.js

@@ -0,0 +1,146 @@
+import {
+  TRANSLATABLE_ATTRIBUTES
+} from "./index-jrcwp722.js";
+
+// src/client/browserTranslation.ts
+var translatedFontText = (node, baselines) => {
+  if (!(node instanceof Element) || node.tagName !== "FONT")
+    return;
+  const elements = [node, ...node.querySelectorAll("*")];
+  if (elements.some((element) => element.tagName !== "FONT" || baselines.has(element)))
+    return;
+  return node.textContent ?? "";
+};
+var translationRestorer = (restore, hasTranslation) => Object.assign(restore, { hasTranslation });
+var emptyTranslationRestorer = () => translationRestorer(() => {
+  return;
+}, false);
+var textNodeAt = (parent, index) => {
+  const node = parent.childNodes[index];
+  return node instanceof Text ? node : undefined;
+};
+var prepareTextTranslation = (element, index, baseline, path, baselines) => {
+  const original = element.childNodes[index];
+  const wrappedText = translatedFontText(original, baselines);
+  if (wrappedText !== undefined) {
+    original?.replaceWith(document.createTextNode(baseline));
+    return { baseline, index, path, translated: wrappedText };
+  }
+  const node = textNodeAt(element, index);
+  if (node === undefined || node.data === baseline)
+    return;
+  const snapshot = {
+    baseline,
+    index,
+    path,
+    translated: node.data
+  };
+  node.data = baseline;
+  return snapshot;
+};
+var visitElements = (root, visit) => {
+  visit(root);
+  for (const element of root.querySelectorAll("*"))
+    visit(element);
+};
+var elementPath = (root, element) => {
+  const path = [];
+  let current = element;
+  while (current !== root) {
+    const parent = current.parentElement;
+    if (parent === null)
+      return null;
+    path.unshift([...parent.children].indexOf(current));
+    current = parent;
+  }
+  return path;
+};
+var elementAtPath = (root, path) => {
+  let current = root;
+  for (const index of path) {
+    const child = current.children[index];
+    if (!(child instanceof Element))
+      return null;
+    current = child;
+  }
+  return current;
+};
+var captureSsrTextBaselines = (root) => {
+  if (root === null || typeof window === "undefined")
+    return;
+  const baselines = window.__ABSOLUTE_SSR_TEXT_BASELINES__ ?? new WeakMap;
+  const attributes = window.__ABSOLUTE_SSR_ATTRIBUTE_BASELINES__ ?? new WeakMap;
+  visitElements(root, (element) => {
+    const text = new Map;
+    for (const [index, node] of [...element.childNodes].entries()) {
+      if (node.nodeType === Node.TEXT_NODE)
+        text.set(index, node.nodeValue ?? "");
+    }
+    if (text.size > 0)
+      baselines.set(element, text);
+    const values = new Map;
+    for (const name of TRANSLATABLE_ATTRIBUTES) {
+      const value = element.getAttribute(name);
+      if (value !== null)
+        values.set(name, value);
+    }
+    if (values.size > 0)
+      attributes.set(element, values);
+  });
+  window.__ABSOLUTE_SSR_TEXT_BASELINES__ = baselines;
+  window.__ABSOLUTE_SSR_ATTRIBUTE_BASELINES__ = attributes;
+};
+var prepareBrowserTranslationHydration = (root) => {
+  if (root === null || typeof window === "undefined")
+    return emptyTranslationRestorer();
+  const baselines = window.__ABSOLUTE_SSR_TEXT_BASELINES__;
+  if (baselines === undefined)
+    return emptyTranslationRestorer();
+  const translated = [];
+  const translatedAttributes = [];
+  const attributes = window.__ABSOLUTE_SSR_ATTRIBUTE_BASELINES__;
+  visitElements(root, (element) => {
+    const text = baselines.get(element);
+    const path = elementPath(root, element);
+    if (path === null)
+      return;
+    for (const [index, baseline] of text ?? []) {
+      const snapshot = prepareTextTranslation(element, index, baseline, path, baselines);
+      if (snapshot === undefined)
+        continue;
+      translated.push(snapshot);
+    }
+    for (const [name, baseline] of attributes?.get(element) ?? []) {
+      const value = element.getAttribute(name);
+      if (value === null || value === baseline)
+        continue;
+      translatedAttributes.push({
+        baseline,
+        name,
+        path,
+        translated: value
+      });
+      element.setAttribute(name, baseline);
+    }
+  });
+  return translationRestorer(() => {
+    for (const snapshot of translated) {
+      const parent = elementAtPath(root, snapshot.path);
+      if (parent === null)
+        continue;
+      const node = textNodeAt(parent, snapshot.index);
+      if (node !== undefined && node.data === snapshot.baseline)
+        node.data = snapshot.translated;
+    }
+    for (const snapshot of translatedAttributes) {
+      const element = elementAtPath(root, snapshot.path);
+      if (element?.getAttribute(snapshot.name) === snapshot.baseline)
+        element.setAttribute(snapshot.name, snapshot.translated);
+    }
+  }, translated.length > 0 || translatedAttributes.length > 0);
+};
+
+export { captureSsrTextBaselines, prepareBrowserTranslationHydration };
+
+//# debugId=2B49FE79D0C510E564756E2164756E21
+//# sourceMappingURL=index-dk743xs6.js.map