@octane-xplat/image 0.0.0-stage → 0.11.0

package/dist/native/hash-image.js

@@ -0,0 +1,285 @@
+//#region src/hash-image.ts
+/** `blurhash:<hash>` / `thumbhash:<base64>` → PNG bytes as base64, or null. */
+function hashToPngBase64(src) {
+	if (src.startsWith("blurhash:")) {
+		const rgba = decodeBlurHash(src.slice(9), 32, 32);
+		return rgba ? base64Encode(rgbaToPng(32, 32, rgba)) : null;
+	}
+	if (src.startsWith("thumbhash:")) {
+		const hash = base64Decode(src.slice(10));
+		const decoded = hash ? thumbHashToRGBA(hash) : null;
+		return decoded ? base64Encode(rgbaToPng(decoded.w, decoded.h, decoded.rgba)) : null;
+	}
+	return null;
+}
+var BASE83 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz#$%*+,-.:;=?@[]^_{|}~";
+function decode83(str, start, end) {
+	let value = 0;
+	for (let i = start; i < end; i++) {
+		const digit = BASE83.indexOf(str[i]);
+		if (digit === -1) return -1;
+		value = value * 83 + digit;
+	}
+	return value;
+}
+function srgbToLinear(value) {
+	const v = value / 255;
+	return v <= .04045 ? v / 12.92 : Math.pow((v + .055) / 1.055, 2.4);
+}
+function linearToSrgb(value) {
+	const v = Math.max(0, Math.min(1, value));
+	return v <= .0031308 ? Math.round(v * 12.92 * 255 + .5) : Math.round((1.055 * Math.pow(v, 1 / 2.4) - .055) * 255 + .5);
+}
+function signPow(value, exp) {
+	return Math.sign(value) * Math.pow(Math.abs(value), exp);
+}
+function decodeBlurHash(hash, width, height) {
+	if (hash.length < 6) return null;
+	const sizeFlag = decode83(hash, 0, 1);
+	const quantisedMax = decode83(hash, 1, 2);
+	const dcValue = decode83(hash, 2, 6);
+	if (sizeFlag < 0 || quantisedMax < 0 || dcValue < 0) return null;
+	const numY = Math.floor(sizeFlag / 9) + 1;
+	const numX = sizeFlag % 9 + 1;
+	if (hash.length !== 4 + 2 * numX * numY) return null;
+	const maximumValue = (quantisedMax + 1) / 166;
+	const colors = new Array(numX * numY);
+	colors[0] = [
+		srgbToLinear(dcValue >> 16),
+		srgbToLinear(dcValue >> 8 & 255),
+		srgbToLinear(dcValue & 255)
+	];
+	for (let i = 1; i < numX * numY; i++) {
+		const value = decode83(hash, 4 + i * 2, 6 + i * 2);
+		if (value < 0) return null;
+		const quantR = Math.floor(value / 361);
+		const quantG = Math.floor(value / 19) % 19;
+		const quantB = value % 19;
+		colors[i] = [
+			signPow((quantR - 9) / 9, 2) * maximumValue,
+			signPow((quantG - 9) / 9, 2) * maximumValue,
+			signPow((quantB - 9) / 9, 2) * maximumValue
+		];
+	}
+	const pixels = new Uint8ClampedArray(width * height * 4);
+	for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+		let r = 0;
+		let g = 0;
+		let b = 0;
+		for (let j = 0; j < numY; j++) for (let i = 0; i < numX; i++) {
+			const basis = Math.cos(Math.PI * x * i / width) * Math.cos(Math.PI * y * j / height);
+			const color = colors[i + j * numX];
+			r += color[0] * basis;
+			g += color[1] * basis;
+			b += color[2] * basis;
+		}
+		const o = (x + y * width) * 4;
+		pixels[o] = linearToSrgb(r);
+		pixels[o + 1] = linearToSrgb(g);
+		pixels[o + 2] = linearToSrgb(b);
+		pixels[o + 3] = 255;
+	}
+	return pixels;
+}
+function thumbHashToApproximateAspectRatio(hash) {
+	const header = hash[3];
+	const hasAlpha = (hash[2] & 128) !== 0;
+	const isLandscape = (hash[4] & 128) !== 0;
+	return (isLandscape ? hasAlpha ? 5 : 7 : header & 7) / (isLandscape ? header & 7 : hasAlpha ? 5 : 7);
+}
+function thumbHashToRGBA(hash) {
+	if (hash.length < 5) return null;
+	const { PI, min, max, cos, round } = Math;
+	const header24 = hash[0] | hash[1] << 8 | hash[2] << 16;
+	const header16 = hash[3] | hash[4] << 8;
+	const l_dc = (header24 & 63) / 63;
+	const p_dc = (header24 >> 6 & 63) / 31.5 - 1;
+	const q_dc = (header24 >> 12 & 63) / 31.5 - 1;
+	const l_scale = (header24 >> 18 & 31) / 31;
+	const hasAlpha = header24 >> 23 !== 0;
+	const p_scale = (header16 >> 3 & 63) / 63;
+	const q_scale = (header16 >> 9 & 63) / 63;
+	const isLandscape = header16 >> 15 !== 0;
+	const lx = max(3, isLandscape ? hasAlpha ? 5 : 7 : header16 & 7);
+	const ly = max(3, isLandscape ? header16 & 7 : hasAlpha ? 5 : 7);
+	const a_dc = hasAlpha ? (hash[5] & 15) / 15 : 1;
+	const a_scale = (hash[5] >> 4) / 15;
+	const ac_start = hasAlpha ? 6 : 5;
+	let ac_index = 0;
+	const decodeChannel = (nx, ny, scale) => {
+		const ac = [];
+		for (let cy = 0; cy < ny; cy++) for (let cx = cy ? 0 : 1; cx * ny < nx * (ny - cy); cx++) {
+			const byte = hash[ac_start + (ac_index >> 1)];
+			if (byte === void 0) return null;
+			ac.push(((byte >> ((ac_index++ & 1) << 2) & 15) / 7.5 - 1) * scale);
+		}
+		return ac;
+	};
+	const l_ac = decodeChannel(lx, ly, l_scale);
+	const p_ac = decodeChannel(3, 3, p_scale * 1.25);
+	const q_ac = decodeChannel(3, 3, q_scale * 1.25);
+	const a_ac = hasAlpha ? decodeChannel(5, 5, a_scale) : null;
+	if (!l_ac || !p_ac || !q_ac || hasAlpha && !a_ac) return null;
+	const ratio = thumbHashToApproximateAspectRatio(hash);
+	const w = round(ratio > 1 ? 32 : 32 * ratio);
+	const h = round(ratio > 1 ? 32 / ratio : 32);
+	const rgba = new Uint8Array(w * h * 4);
+	const fx = [];
+	const fy = [];
+	for (let y = 0, i = 0; y < h; y++) for (let x = 0; x < w; x++, i += 4) {
+		let l = l_dc;
+		let p = p_dc;
+		let q = q_dc;
+		let a = a_dc;
+		for (let cx = 0, n = max(lx, hasAlpha ? 5 : 3); cx < n; cx++) fx[cx] = cos(PI / w * (x + .5) * cx);
+		for (let cy = 0, n = max(ly, hasAlpha ? 5 : 3); cy < n; cy++) fy[cy] = cos(PI / h * (y + .5) * cy);
+		for (let cy = 0, j = 0; cy < ly; cy++) for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx * ly < lx * (ly - cy); cx++, j++) l += l_ac[j] * fx[cx] * fy2;
+		for (let cy = 0, j = 0; cy < 3; cy++) for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx < 3 - cy; cx++, j++) {
+			const f = fx[cx] * fy2;
+			p += p_ac[j] * f;
+			q += q_ac[j] * f;
+		}
+		if (hasAlpha && a_ac) for (let cy = 0, j = 0; cy < 5; cy++) for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx < 5 - cy; cx++, j++) a += a_ac[j] * fx[cx] * fy2;
+		const b = l - 2 / 3 * p;
+		const r = (3 * l - b + q) / 2;
+		const g = r - q;
+		rgba[i] = max(0, 255 * min(1, r));
+		rgba[i + 1] = max(0, 255 * min(1, g));
+		rgba[i + 2] = max(0, 255 * min(1, b));
+		rgba[i + 3] = max(0, 255 * min(1, a));
+	}
+	return {
+		w,
+		h,
+		rgba
+	};
+}
+var PNG_CRC_TABLE = [
+	0,
+	498536548,
+	997073096,
+	651767980,
+	1994146192,
+	1802195444,
+	1303535960,
+	1342533948,
+	-306674912,
+	-267414716,
+	-690576408,
+	-882789492,
+	-1687895376,
+	-2032938284,
+	-1609899400,
+	-1111625188
+];
+/** Uncompressed PNG (zlib store blocks) — correctness over size; inputs are
+*  ~32px placeholders so the payload stays small. */
+function rgbaToPng(w, h, rgba) {
+	const row = w * 4 + 1;
+	const idat = 6 + h * (5 + row);
+	const bytes = [
+		137,
+		80,
+		78,
+		71,
+		13,
+		10,
+		26,
+		10,
+		0,
+		0,
+		0,
+		13,
+		73,
+		72,
+		68,
+		82,
+		0,
+		0,
+		w >> 8,
+		w & 255,
+		0,
+		0,
+		h >> 8,
+		h & 255,
+		8,
+		6,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		idat >>> 24,
+		idat >> 16 & 255,
+		idat >> 8 & 255,
+		idat & 255,
+		73,
+		68,
+		65,
+		84,
+		120,
+		1
+	];
+	let a = 1;
+	let b = 0;
+	for (let y = 0, i = 0, end = row - 1; y < h; y++, end += row - 1) {
+		bytes.push(y + 1 < h ? 0 : 1, row & 255, row >> 8, ~row & 255, row >> 8 ^ 255, 0);
+		for (b = (b + a) % 65521; i < end; i++) {
+			const u = rgba[i] & 255;
+			bytes.push(u);
+			a = (a + u) % 65521;
+			b = (b + a) % 65521;
+		}
+	}
+	bytes.push(b >> 8, b & 255, a >> 8, a & 255, 0, 0, 0, 0, 0, 0, 0, 0, 73, 69, 78, 68, 174, 66, 96, 130);
+	for (let [start, end] of [[12, 29], [37, 41 + idat]]) {
+		let c = -1;
+		for (let i = start; i < end; i++) {
+			c ^= bytes[i];
+			c = c >>> 4 ^ PNG_CRC_TABLE[c & 15];
+			c = c >>> 4 ^ PNG_CRC_TABLE[c & 15];
+		}
+		c = ~c;
+		bytes[end++] = c >>> 24;
+		bytes[end++] = c >> 16 & 255;
+		bytes[end++] = c >> 8 & 255;
+		bytes[end++] = c & 255;
+	}
+	return bytes;
+}
+var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function base64Encode(bytes) {
+	let out = "";
+	for (let i = 0; i < bytes.length; i += 3) {
+		const b0 = bytes[i];
+		const b1 = i + 1 < bytes.length ? bytes[i + 1] : 0;
+		const b2 = i + 2 < bytes.length ? bytes[i + 2] : 0;
+		out += BASE64_CHARS[b0 >> 2];
+		out += BASE64_CHARS[(b0 & 3) << 4 | b1 >> 4];
+		out += i + 1 < bytes.length ? BASE64_CHARS[(b1 & 15) << 2 | b2 >> 6] : "=";
+		out += i + 2 < bytes.length ? BASE64_CHARS[b2 & 63] : "=";
+	}
+	return out;
+}
+function base64Decode(text) {
+	const clean = text.replace(/-/g, "+").replace(/_/g, "/").replace(/[\s=]/g, "");
+	const bytes = new Uint8Array(Math.floor(clean.length * 3 / 4));
+	let out = 0;
+	let acc = 0;
+	let bits = 0;
+	for (const ch of clean) {
+		const digit = BASE64_CHARS.indexOf(ch);
+		if (digit === -1) return null;
+		acc = acc << 6 | digit;
+		bits += 6;
+		if (bits >= 8) {
+			bits -= 8;
+			if (out < bytes.length) bytes[out++] = acc >> bits & 255;
+		}
+	}
+	return bytes.subarray(0, out);
+}
+//#endregion
+export { hashToPngBase64 };

package/dist/native/image-binding.js

@@ -0,0 +1,103 @@
+import { bestImageSource, contentRect } from "./image-content.js";
+//#region src/image-binding.ts
+/** View-sized decode + srcset selection + content-rect layout for the
+*  ui-image `Img` leaf. Mirrors the core Image binding semantics
+*  (packages/ui/src/image-sizing.ts + image-content-binding.ts):
+*
+*  `src` never goes through JSX — the binding holds it until the view's
+*  first real layout, writes decodeWidth/decodeHeight in device pixels,
+*  then assigns it. Without that hold the engine decodes at full source
+*  resolution (the 5 MB-cache jank this package exists to fix is half
+*  cache size and half oversized decodes — study L1+L2). A later resize
+*  re-issues at the new size, except 'fill'/'none' fits where the decode
+*  can't improve. 'none' never downsamples — its contract is source pixels.
+*
+*  `update` must be idempotent: ref callbacks re-fire on every render, and
+*  same view + same src + same size is a no-op. */
+function createImageBinding(options) {
+	let view = null;
+	let host = null;
+	let listening = false;
+	let pending = {
+		source: null,
+		sources: null
+	};
+	let appliedSrc;
+	let applied = false;
+	let width = 0;
+	let height = 0;
+	let imageWidth = 0;
+	let imageHeight = 0;
+	const scale = () => options.screenScale() || 1;
+	const issue = (next) => {
+		const fit = options.getFit();
+		const bounds = options.getDecodeBounds();
+		const downscale = fit !== "none";
+		view.decodeWidth = bounds.width ?? (downscale ? width : 0);
+		view.decodeHeight = bounds.height ?? (downscale ? height : 0);
+		view.src = next;
+		appliedSrc = next;
+		applied = true;
+	};
+	const applyRect = () => {
+		if (!host || !view || imageWidth <= 0 || imageHeight <= 0) return;
+		const viewWidth = (host.getMeasuredWidth?.() ?? 0) / scale();
+		const viewHeight = (host.getMeasuredHeight?.() ?? 0) / scale();
+		if (viewWidth <= 0 || viewHeight <= 0) return;
+		const rect = contentRect(options.getFit(), options.getPosition(), viewWidth, viewHeight, imageWidth, imageHeight);
+		view.left = rect.x;
+		view.top = rect.y;
+		view.width = rect.width;
+		view.height = rect.height;
+	};
+	const evaluate = () => {
+		const sizeView = host ?? view;
+		if (!view || !sizeView) return;
+		const measuredWidth = sizeView.getMeasuredWidth?.() ?? 0;
+		const measuredHeight = sizeView.getMeasuredHeight?.() ?? 0;
+		if (measuredWidth <= 0 || measuredHeight <= 0) return;
+		let next = pending.source;
+		if (pending.sources) next = bestImageSource(pending.sources, measuredWidth / scale(), measuredHeight / scale(), scale())?.uri ?? pending.sources[0]?.uri;
+		if (next == null || next === "") return;
+		if (applied && next === appliedSrc && !(applied && (measuredWidth !== width || measuredHeight !== height))) {
+			applyRect();
+			return;
+		}
+		const fit = options.getFit();
+		if (applied && next === appliedSrc && (fit === "fill" || fit === "none")) {
+			applyRect();
+			return;
+		}
+		width = measuredWidth;
+		height = measuredHeight;
+		issue(next);
+		applyRect();
+	};
+	const onLayout = () => evaluate();
+	const listen = (target) => {
+		if (listening || !target) return;
+		listening = true;
+		target.on("layoutChanged", onLayout);
+	};
+	return {
+		/** Called from the ref callbacks — image view first, then the computed
+		*  path's wrapper host. Refreshes the pending src from props and
+		*  evaluates; idempotent. */
+		update(imageView, hostView) {
+			if (imageView) view = imageView;
+			if (hostView) host = hostView;
+			pending = options.getSrc();
+			listen(host ?? view);
+			evaluate();
+		},
+		/** Engine set the final bitmap — record intrinsic size for the
+		*  content-rect path. */
+		setIntrinsic(widthPx, heightPx) {
+			imageWidth = widthPx / scale();
+			imageHeight = heightPx / scale();
+			applyRect();
+		}
+	};
+}
+//#endregion
+export { createImageBinding };

package/dist/native/image-content.js

@@ -0,0 +1,207 @@
+//#region src/image-content.ts
+/** VENDORED from packages/ui/src/image-content.ts — keep in sync.
+*  Shared `contentFit`/`contentPosition` + multi-source math for `Image` —
+*  pure functions used by every leaf (docs/notes/expo-image-study.md L7/L8).
+*  Semantics mirror CSS `object-fit`/`object-position`, which is also
+*  expo-image's contract: the leaves compute the drawn-content rect
+*  themselves instead of delegating to platform scaleType/contentMode,
+*  so all platforms get the same answer.
+*
+*  The default fit is 'cover' everywhere (the expo/RN default). Today's
+*  platform defaults disagree — web <img> is 'fill' and NS stretch is
+*  'aspectFit' — so an un-propped Image was silently divergent. */
+var DEFAULT_CONTENT_FIT = "cover";
+function resolveContentFit(fit) {
+	return fit ?? "cover";
+}
+/** expo-image's keyword shorthands; the object form positions relative to
+*  any corner pair ({top,left}, {top,right}, {bottom,left}, {bottom,right}). */
+var POSITION_KEYWORDS = {
+	center: {
+		top: "50%",
+		left: "50%"
+	},
+	top: {
+		top: 0,
+		left: "50%"
+	},
+	right: {
+		top: "50%",
+		right: 0
+	},
+	bottom: {
+		bottom: 0,
+		left: "50%"
+	},
+	left: {
+		top: "50%",
+		left: 0
+	},
+	"top center": {
+		top: 0,
+		left: "50%"
+	},
+	"top right": {
+		top: 0,
+		right: 0
+	},
+	"top left": {
+		top: 0,
+		left: 0
+	},
+	"right center": {
+		top: "50%",
+		right: 0
+	},
+	"right top": {
+		top: 0,
+		right: 0
+	},
+	"right bottom": {
+		bottom: 0,
+		right: 0
+	},
+	"bottom center": {
+		bottom: 0,
+		left: "50%"
+	},
+	"bottom right": {
+		bottom: 0,
+		right: 0
+	},
+	"bottom left": {
+		bottom: 0,
+		left: 0
+	},
+	"left center": {
+		top: "50%",
+		left: 0
+	},
+	"left top": {
+		top: 0,
+		left: 0
+	},
+	"left bottom": {
+		bottom: 0,
+		left: 0
+	}
+};
+function resolveContentPosition(position) {
+	if (typeof position === "string") return POSITION_KEYWORDS[position] ?? POSITION_KEYWORDS.center;
+	return position ?? POSITION_KEYWORDS.center;
+}
+function parseAxisValue(value) {
+	if (value == null) return null;
+	if (typeof value === "number") return { dips: value };
+	const text = String(value).trim();
+	if (text === "center") return { percent: 50 };
+	if (text.endsWith("%")) {
+		const parsed = Number.parseFloat(text);
+		return Number.isNaN(parsed) ? null : { percent: parsed };
+	}
+	const parsed = Number.parseFloat(text);
+	return Number.isNaN(parsed) ? null : { dips: parsed };
+}
+/** Offset of the drawn content's start edge inside the view along one axis.
+*  expo-image `calcTranslation`: percentages run over the free space
+*  (view − content), absolute dips measure from the named edge, and the
+*  reverse edge (right/bottom) counts back from the far side. */
+function contentAxisOffset(viewSize, contentSize, start, end) {
+	const from = parseAxisValue(start);
+	if (from) return "percent" in from ? from.percent / 100 * (viewSize - contentSize) : from.dips;
+	const to = parseAxisValue(end);
+	if (to) return "percent" in to ? (1 - to.percent / 100) * (viewSize - contentSize) : viewSize - contentSize - to.dips;
+	return (viewSize - contentSize) / 2;
+}
+function centeredAxis(start, end) {
+	const from = parseAxisValue(start);
+	if (from) return "percent" in from && from.percent === 50;
+	const to = parseAxisValue(end);
+	if (to) return "percent" in to && to.percent === 50;
+	return true;
+}
+function isCenteredContentPosition(position) {
+	return centeredAxis(position.left, position.right) && centeredAxis(position.top, position.bottom);
+}
+/** The rect the bitmap occupies inside the view box, in the same units the
+*  caller measures with (native: dips; web: CSS px via object-fit anyway —
+*  only the native leaf calls this). Every length unit is dips except the
+*  intrinsic size, which the leaf must supply in dips too. */
+function contentRect(fit, position, viewWidth, viewHeight, imageWidth, imageHeight) {
+	let width;
+	let height;
+	switch (fit) {
+		case "fill":
+			width = viewWidth;
+			height = viewHeight;
+			break;
+		case "cover": {
+			const scale = Math.max(viewWidth / imageWidth, viewHeight / imageHeight);
+			width = imageWidth * scale;
+			height = imageHeight * scale;
+			break;
+		}
+		case "scale-down": {
+			const scale = Math.min(1, Math.min(viewWidth / imageWidth, viewHeight / imageHeight));
+			width = imageWidth * scale;
+			height = imageHeight * scale;
+			break;
+		}
+		case "none":
+			width = imageWidth;
+			height = imageHeight;
+			break;
+		default: {
+			const scale = Math.min(viewWidth / imageWidth, viewHeight / imageHeight);
+			width = imageWidth * scale;
+			height = imageHeight * scale;
+		}
+	}
+	return {
+		x: contentAxisOffset(viewWidth, width, position.left, position.right),
+		y: contentAxisOffset(viewHeight, height, position.top, position.bottom),
+		width,
+		height
+	};
+}
+/** True when no platform stretch/scaleType can express the request and the
+*  leaf must measure + lay out the image itself: 'none' (iOS maps NS
+*  stretch='none' to TopLeft, not CSS centered), 'scale-down' (needs the
+*  intrinsic-vs-view compare), or any non-center position. 'fill' is
+*  exempt — its rect is always the whole box, so position can't matter. */
+function needsContentRect(fit, position) {
+	if (fit === "none" || fit === "scale-down") return true;
+	return fit !== "fill" && !isCenteredContentPosition(position);
+}
+/** NS `stretch` for the fast path — only reached for fits the platform
+*  vocabulary expresses identically (contain/cover/fill centered). */
+function contentFitToStretch(fit) {
+	switch (fit) {
+		case "contain": return "aspectFit";
+		case "fill": return "fill";
+		default: return "aspectFill";
+	}
+}
+/** L8 — expo `getBestSource`: the source whose declared pixel count
+*  (`width·height·scale²`, dips × density) is closest to the view's pixel
+*  count. Needs a real measured size; one source or no size picks nothing
+*  to decide. Unsized sources score worst and are skipped when any sized
+*  candidate exists. */
+function bestImageSource(sources, viewWidth, viewHeight, screenScale) {
+	if (sources.length === 0 || viewWidth <= 0 || viewHeight <= 0) return null;
+	if (sources.length === 1) return sources[0];
+	const target = viewWidth * viewHeight * screenScale * screenScale;
+	let best = null;
+	let bestFit = Infinity;
+	for (const source of sources) {
+		const pixelCount = (source.width ?? 0) * (source.height ?? 0) * (source.scale ?? 1) ** 2;
+		const fit = Math.abs(1 - pixelCount / target);
+		if (fit < bestFit) {
+			best = source;
+			bestFit = fit;
+		}
+	}
+	return best;
+}
+//#endregion
+export { DEFAULT_CONTENT_FIT, bestImageSource, contentAxisOffset, contentFitToStretch, contentRect, isCenteredContentPosition, needsContentRect, resolveContentFit, resolveContentPosition };

package/dist/native/index.js

@@ -0,0 +1,3 @@
+import { Image } from "./Image.tsrx.js";
+import { clearImageCaches, evictImage, initializeImageCache, isImageCached, prefetch } from "./cache.js";
+export { Image, clearImageCaches, evictImage, initializeImageCache, isImageCached, prefetch };

package/dist/native/octane-client-build.json

@@ -0,0 +1,8 @@
+{
+  "version": 1,
+  "buildId": "740180aa-315b-41af-a9cc-db59344ba125",
+  "mode": "production",
+  "capabilities": {
+    "independentHydration": false
+  }
+}

package/dist/native/prefetch-batch.js

@@ -0,0 +1,27 @@
+function prefetchBatch(srcs, concurrency, warm) {
+	const urls = Array.isArray(srcs) ? srcs : [srcs];
+	if (urls.length === 0) return Promise.resolve(true);
+	const requested = Math.floor(concurrency ?? 5);
+	const limit = Number.isFinite(requested) && requested > 0 ? requested : 5;
+	return new Promise((resolve) => {
+		let next = 0;
+		let active = Math.min(limit, urls.length);
+		for (let i = 0; i < active; i++) (async () => {
+			while (next < urls.length) {
+				const url = urls[next++];
+				try {
+					if (!await warm(url)) {
+						resolve(false);
+						return;
+					}
+				} catch {
+					resolve(false);
+					return;
+				}
+			}
+			if (--active === 0) resolve(true);
+		})();
+	});
+}
+//#endregion
+export { prefetchBatch };