peachsim 0.1.527

package/dist-lib/metro-production-bundle.mjs

@@ -0,0 +1,295 @@
+/*! rnx v0.1.527 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+
+// src/metro-production-bundle.ts
+var RNXSIM_METRO_MODULE_PATHS_PREFIX = "globalThis.__sootsimModulePaths=";
+var RNX_METRO_MODULE_IDENTITY_VERSION = 2;
+function toRNXProductionBundleUrl(bundleUrl) {
+  const relative = bundleUrl.startsWith("/");
+  const url = new URL(bundleUrl, "http://rnxsim.local");
+  url.searchParams.set("dev", "false");
+  url.searchParams.set("hot", "false");
+  url.searchParams.set("minify", "true");
+  return relative ? `${url.pathname}${url.search}${url.hash}` : url.toString();
+}
+function toRNXDevelopmentBundleUrl(bundleUrl) {
+  const relative = bundleUrl.startsWith("/");
+  const url = new URL(bundleUrl, "http://rnxsim.local");
+  url.searchParams.set("dev", "true");
+  url.searchParams.set("hot", "false");
+  url.searchParams.set("minify", "false");
+  return relative ? `${url.pathname}${url.search}${url.hash}` : url.toString();
+}
+var RNXSIM_METRO_SOURCE_MAP_COMMENT = "//# sourceMappingURL=";
+function detachRNXMetroSourceMapUrl(bundleText) {
+  const trimmedEnd = bundleText.replace(/\s+$/, "");
+  const commentStart = trimmedEnd.lastIndexOf(`
+${RNXSIM_METRO_SOURCE_MAP_COMMENT}`);
+  if (commentStart < 0) return { source: bundleText, sourceMappingUrl: null };
+  const url = trimmedEnd.slice(commentStart + 1 + RNXSIM_METRO_SOURCE_MAP_COMMENT.length);
+  if (url.includes("\n")) return { source: bundleText, sourceMappingUrl: null };
+  return { source: trimmedEnd.slice(0, commentStart), sourceMappingUrl: url };
+}
+function createRNXMetroModuleIdentityFooter(identity) {
+  const payload = JSON.stringify(identity).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029").replace(/<\//g, "<\\/");
+  return `
+${RNXSIM_METRO_MODULE_PATHS_PREFIX}${payload};`;
+}
+function appendRNXMetroModuleIdentityFooter(bundleText, identity) {
+  const footer = createRNXMetroModuleIdentityFooter(identity);
+  const detached = detachRNXMetroSourceMapUrl(bundleText);
+  return detached.sourceMappingUrl === null ? bundleText + footer : `${detached.source}${footer}
+${RNXSIM_METRO_SOURCE_MAP_COMMENT}${detached.sourceMappingUrl}`;
+}
+function readRNXMetroModuleIdentity(bundleText) {
+  const detached = detachRNXMetroSourceMapUrl(bundleText);
+  const withoutMap = detached.source;
+  const footerPrefix = `
+${RNXSIM_METRO_MODULE_PATHS_PREFIX}`;
+  const footerStart = withoutMap.lastIndexOf(footerPrefix);
+  if (footerStart < 0) return null;
+  if (!withoutMap.endsWith(";")) {
+    throw new Error("Metro module identity footer is truncated");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(withoutMap.slice(footerStart + footerPrefix.length, -1));
+  } catch {
+    throw new Error("Metro module identity footer is not valid JSON");
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error("Metro module identity footer is malformed");
+  }
+  const version = Reflect.get(parsed, "version");
+  if (version === void 0) {
+    const modulePaths2 = Object.fromEntries(
+      Object.entries(parsed).map(([moduleId, modulePath]) => {
+        if (typeof modulePath !== "string") {
+          throw new Error(`Metro module identity has an invalid path for ${moduleId}`);
+        }
+        return [moduleId, modulePath];
+      })
+    );
+    return {
+      source: withoutMap.slice(0, footerStart),
+      version: RNX_METRO_MODULE_IDENTITY_VERSION,
+      identitySource: "rnx-plugin",
+      modulePaths: modulePaths2,
+      logicalSpecifiers: {},
+      sourceMappingUrl: detached.sourceMappingUrl
+    };
+  }
+  const identitySource = Reflect.get(parsed, "identitySource");
+  const parsedModulePaths = Reflect.get(parsed, "modulePaths");
+  const parsedLogicalSpecifiers = Reflect.get(parsed, "logicalSpecifiers");
+  if (version !== RNX_METRO_MODULE_IDENTITY_VERSION || identitySource !== "rnx-plugin" && identitySource !== "contrast-bundler" && identitySource !== "metro-source-map" || typeof parsedModulePaths !== "object" || parsedModulePaths === null || Array.isArray(parsedModulePaths) || typeof parsedLogicalSpecifiers !== "object" || parsedLogicalSpecifiers === null || Array.isArray(parsedLogicalSpecifiers)) {
+    throw new Error("Metro module identity footer is malformed");
+  }
+  const modulePaths = Object.fromEntries(
+    Object.entries(parsedModulePaths).map(([moduleId, modulePath]) => {
+      if (typeof modulePath !== "string") {
+        throw new Error(`Metro module identity has an invalid path for ${moduleId}`);
+      }
+      return [moduleId, modulePath];
+    })
+  );
+  const logicalSpecifiers = Object.fromEntries(
+    Object.entries(parsedLogicalSpecifiers).map(([moduleId, specifiers]) => {
+      if (!Array.isArray(specifiers) || specifiers.length === 0 || !specifiers.every(
+        (specifier) => typeof specifier === "string" && specifier.length > 0
+      )) {
+        throw new Error(`Metro module identity has invalid specifiers for ${moduleId}`);
+      }
+      const unique = [...new Set(specifiers)].sort(
+        (left, right) => left.localeCompare(right)
+      );
+      if (unique.length !== specifiers.length) {
+        throw new Error(`Metro module identity repeats a specifier for ${moduleId}`);
+      }
+      return [moduleId, unique];
+    })
+  );
+  return {
+    source: withoutMap.slice(0, footerStart),
+    version,
+    identitySource,
+    modulePaths,
+    logicalSpecifiers,
+    sourceMappingUrl: detached.sourceMappingUrl
+  };
+}
+function readStringLiteralStart(source, start, end) {
+  const quote = source[end];
+  if (quote !== '"' && quote !== "'") return -1;
+  for (let index = end - 1; index > start; index--) {
+    if (source[index] !== quote) continue;
+    let backslashes = 0;
+    while (index - 1 - backslashes > start && source[index - 1 - backslashes] === "\\") {
+      backslashes++;
+    }
+    if (backslashes % 2 === 0) return index;
+  }
+  return -1;
+}
+function readDefineTail(source, start, end) {
+  let cursor = end;
+  while (cursor > start && (source[cursor] === " " || source[cursor] === "\n" || source[cursor] === "	" || source[cursor] === ";")) {
+    cursor--;
+  }
+  if (source[cursor] !== ")") return null;
+  cursor--;
+  while (cursor > start && /\s/.test(source[cursor])) cursor--;
+  let verboseNameStart;
+  let verboseNameEnd;
+  if (source[cursor] === '"' || source[cursor] === "'") {
+    const literalStart = readStringLiteralStart(source, start, cursor);
+    if (literalStart < 0) return null;
+    verboseNameStart = literalStart;
+    verboseNameEnd = cursor + 1;
+    cursor = literalStart - 1;
+    while (cursor > start && /\s/.test(source[cursor])) cursor--;
+    if (source[cursor] !== ",") return null;
+    cursor--;
+    while (cursor > start && /\s/.test(source[cursor])) cursor--;
+  }
+  if (source[cursor] !== "]") return null;
+  const dependenciesEnd = cursor + 1;
+  let depth = 1;
+  cursor--;
+  while (cursor > start && depth > 0) {
+    const character = source[cursor];
+    if (character === "]") depth++;
+    else if (character === "[") depth--;
+    if (depth === 0) break;
+    cursor--;
+  }
+  if (depth !== 0) return null;
+  const dependenciesStart = cursor;
+  let idEnd = cursor - 1;
+  while (idEnd > start && /\s/.test(source[idEnd])) idEnd--;
+  if (source[idEnd] !== ",") return null;
+  let idStart = idEnd;
+  while (idStart > start && /[0-9a-fA-FxX.+-]/.test(source[idStart - 1])) idStart--;
+  const literal = source.slice(idStart, idEnd);
+  if (!/^-?(?:0[xXbBoO][0-9a-fA-F]+|\d+(?:\.\d*)?(?:[eE][+-]?\d+)?)$/.test(literal)) {
+    return null;
+  }
+  const moduleId = Number(literal);
+  if (!Number.isSafeInteger(moduleId)) return null;
+  let factoryEnd = idStart - 1;
+  while (factoryEnd > start && /\s/.test(source[factoryEnd])) factoryEnd--;
+  if (source[factoryEnd] !== ",") return null;
+  return {
+    moduleId,
+    factoryEnd,
+    dependenciesStart,
+    dependenciesEnd,
+    verboseNameStart,
+    verboseNameEnd
+  };
+}
+function readRNXMetroBundleLayout(source) {
+  const lineOffsets = [0];
+  for (let index = 0; index < source.length; index++) {
+    if (source.charCodeAt(index) === 10) lineOffsets.push(index + 1);
+  }
+  const boundaries = [];
+  for (let lineIndex = 0; lineIndex < lineOffsets.length; lineIndex++) {
+    const start = lineOffsets[lineIndex];
+    if (source.startsWith("__d(", start) || source.startsWith("__r(", start)) {
+      boundaries.push(lineIndex);
+    }
+  }
+  const statements = [];
+  let moduleIdFailures = 0;
+  for (let index = 0; index < boundaries.length; index++) {
+    const lineIndex = boundaries[index];
+    const start = lineOffsets[lineIndex];
+    const nextLineIndex = boundaries[index + 1];
+    const endLineIndex = nextLineIndex !== void 0 ? nextLineIndex - 1 : lineOffsets.length - 1;
+    const end = nextLineIndex !== void 0 ? lineOffsets[nextLineIndex] : source.length;
+    if (!source.startsWith("__d(", start)) {
+      statements.push({ kind: "run", start, end, lineIndex, endLineIndex });
+      continue;
+    }
+    const tail = readDefineTail(source, start, end - 1);
+    if (!tail) {
+      moduleIdFailures++;
+      continue;
+    }
+    statements.push({
+      kind: "define",
+      moduleId: tail.moduleId,
+      start,
+      end,
+      lineIndex,
+      endLineIndex,
+      factory: { start: start + "__d(".length, end: tail.factoryEnd },
+      dependencies: { start: tail.dependenciesStart, end: tail.dependenciesEnd },
+      ...tail.verboseNameStart !== void 0 && tail.verboseNameEnd !== void 0 ? { verboseName: { start: tail.verboseNameStart, end: tail.verboseNameEnd } } : {}
+    });
+  }
+  return {
+    prelude: source.slice(
+      0,
+      boundaries.length > 0 ? lineOffsets[boundaries[0]] : source.length
+    ),
+    statements,
+    moduleIdFailures
+  };
+}
+function validateRNXMetroModulePaths(source, modulePaths) {
+  const layout = readRNXMetroBundleLayout(source);
+  if (layout.moduleIdFailures > 0) {
+    throw new Error(
+      `Metro module identity could not read ${layout.moduleIdFailures} module IDs`
+    );
+  }
+  const definedIds = /* @__PURE__ */ new Set();
+  for (const statement of layout.statements) {
+    if (statement.kind !== "define") continue;
+    if (definedIds.has(statement.moduleId)) {
+      throw new Error(`Metro module identity has duplicate module ${statement.moduleId}`);
+    }
+    definedIds.add(statement.moduleId);
+    if (!Object.prototype.hasOwnProperty.call(modulePaths, String(statement.moduleId))) {
+      throw new Error(`Metro module identity is missing ${statement.moduleId}`);
+    }
+  }
+  if (definedIds.size === 0) {
+    throw new Error("Metro module identity found no canonical JavaScript modules");
+  }
+  for (const [key, modulePath] of Object.entries(modulePaths)) {
+    const moduleId = Number(key);
+    if (!Number.isSafeInteger(moduleId) || String(moduleId) !== key) {
+      throw new Error(`Metro module identity has invalid module ID ${key}`);
+    }
+    if (typeof modulePath !== "string" || modulePath.length === 0) {
+      throw new Error(`Metro module identity has no path for ${key}`);
+    }
+    if (!definedIds.has(moduleId)) {
+      throw new Error(`Metro module identity has no module ${key}`);
+    }
+  }
+}
+function validateRNXMetroModuleIdentity(identity) {
+  validateRNXMetroModulePaths(identity.source, identity.modulePaths);
+  for (const moduleId of Object.keys(identity.logicalSpecifiers)) {
+    if (!Object.prototype.hasOwnProperty.call(identity.modulePaths, moduleId)) {
+      throw new Error(
+        `Metro module identity has logical specifiers for unknown module ${moduleId}`
+      );
+    }
+  }
+}
+export {
+  RNX_METRO_MODULE_IDENTITY_VERSION,
+  appendRNXMetroModuleIdentityFooter,
+  createRNXMetroModuleIdentityFooter,
+  detachRNXMetroSourceMapUrl,
+  readRNXMetroBundleLayout,
+  readRNXMetroModuleIdentity,
+  toRNXDevelopmentBundleUrl,
+  toRNXProductionBundleUrl,
+  validateRNXMetroModuleIdentity,
+  validateRNXMetroModulePaths
+};