@shop-on/theme-runtime 0.0.0-stage → 0.1.0

package/dist/LICENSE.md

@@ -0,0 +1,39 @@
+# Cody Theme Development License
+
+Copyright (c) 2026 Cody LLC. All rights reserved except as granted below.
+
+"The Software" is this package, its source, and its documentation. "The
+Platform" is Cody, the commerce platform operated by Cody LLC.
+
+## 1. Grant
+
+You may use, copy and modify the Software, and distribute modified copies, solely
+to develop, test, and distribute themes, apps and other extensions that run on
+the Platform.
+
+## 2. Restrictions
+
+You may not:
+
+1. use the Software, or anything derived from it, with any commerce platform,
+   storefront or hosting service other than the Platform;
+2. use the Software to build a product that competes with the Platform;
+3. sublicense the Software, or distribute it other than as part of a theme,
+   app or extension for the Platform;
+4. remove or alter this license or any copyright notice in the Software.
+
+## 3. Your work
+
+Themes, apps and extensions you build with the Software are yours. The parts of
+the Software they include stay under this license.
+
+## 4. Termination
+
+This license ends automatically if you break any of its terms. You must then
+stop using the Software and delete your copies of it.
+
+## 5. No warranty
+
+The Software is provided "as is", without warranty of any kind. Cody LLC is not
+liable for any claim, damages or other liability arising from the Software or
+its use.

package/dist/badge-tags.d.ts

@@ -0,0 +1,8 @@
+//#region src/badge-tags.d.ts
+export type TagBadgeKind = "hot" | "new" | "sale";
+export type TagBadge = {
+  kind: TagBadgeKind;
+  label: string;
+};
+export declare function tagBadges(tags: readonly string[] | null | undefined): TagBadge[];
+//#endregion

package/dist/badge-tags.js

@@ -0,0 +1,13 @@
+//#region src/badge-tags.ts
+const TAG_BADGE = /^tag__(hot|new|sale)_+(.+)$/i;
+function tagBadges(tags) {
+	return (tags ?? []).flatMap((tag) => {
+		const match = TAG_BADGE.exec(tag);
+		return match ? [{
+			kind: match[1].toLowerCase(),
+			label: match[2]
+		}] : [];
+	});
+}
+//#endregion
+export { tagBadges };

package/dist/cart-discounts.d.ts

@@ -0,0 +1,16 @@
+import { Money } from "./money.js";
+//#region src/cart-discounts.d.ts
+export type CartDiscountAllocationLike = {
+  targetLineItemId: string | null;
+  amount: Money;
+};
+export type CartDiscountApplicationLike = {
+  allocations: ReadonlyArray<CartDiscountAllocationLike>;
+};
+/** Flatten a cart's discount applications into a `lineId → total deduction`
+ * map, for strike-through pricing on line rows. Order-level allocations
+ * (`targetLineItemId === null`) are skipped — they come off the subtotal, not
+ * a line. Several applications on one line are summed, keeping the first
+ * allocation's `currencyCode`. */
+export declare function indexLineDiscounts(applications: ReadonlyArray<CartDiscountApplicationLike>): Map<string, Money>;
+//#endregion

package/dist/cart-discounts.js

@@ -0,0 +1,21 @@
+//#region src/cart-discounts.ts
+/** Flatten a cart's discount applications into a `lineId → total deduction`
+* map, for strike-through pricing on line rows. Order-level allocations
+* (`targetLineItemId === null`) are skipped — they come off the subtotal, not
+* a line. Several applications on one line are summed, keeping the first
+* allocation's `currencyCode`. */
+function indexLineDiscounts(applications) {
+	const byLine = /* @__PURE__ */ new Map();
+	for (const app of applications) for (const alloc of app.allocations) {
+		if (alloc.targetLineItemId === null) continue;
+		const prior = byLine.get(alloc.targetLineItemId);
+		if (prior) byLine.set(alloc.targetLineItemId, {
+			amount: prior.amount + alloc.amount.amount,
+			currencyCode: prior.currencyCode
+		});
+		else byLine.set(alloc.targetLineItemId, alloc.amount);
+	}
+	return byLine;
+}
+//#endregion
+export { indexLineDiscounts };

package/dist/cart-note.d.ts

@@ -0,0 +1,6 @@
+//#region src/cart-note.d.ts
+/** The API's cap on a cart note, in characters. Past it, `cartNoteUpdate`
+ * answers `VALIDATION_ERROR` on `field: "note"`; a note field mirrors it as
+ * `maxLength` so the buyer never meets that error. */
+export declare const CART_NOTE_MAX_LENGTH = 1000;
+//#endregion

package/dist/cart-note.js

@@ -0,0 +1,7 @@
+//#region src/cart-note.ts
+/** The API's cap on a cart note, in characters. Past it, `cartNoteUpdate`
+* answers `VALIDATION_ERROR` on `field: "note"`; a note field mirrors it as
+* `maxLength` so the buyer never meets that error. */
+const CART_NOTE_MAX_LENGTH = 1e3;
+//#endregion
+export { CART_NOTE_MAX_LENGTH };

package/dist/color.d.ts

@@ -0,0 +1,34 @@
+//#region src/color.d.ts
+export interface Rgba {
+  r: number;
+  g: number;
+  b: number;
+  a: number;
+}
+/** Parse a hex or `rgb()`/`rgba()` color. Anything else (a gradient, a CSS
+ * keyword, an unresolved ref, an empty setting) → `null`, so callers can fall
+ * back rather than emit a broken declaration. */
+export declare function parseColor(input: unknown): Rgba | null;
+/** Shopify's `color_brightness`: the perceived-luminance average, 0–255.
+ * Themes compare it against a threshold (Horizon 128, Impact 150) to pick a
+ * contrasting foreground. */
+export declare function brightness({ r, g, b }: Rgba): number;
+/** Liquid's `color_contrast`: the WCAG ratio between two colors, 1–21.
+ * Horizon compares against 4.5 (the AA threshold for body text) to decide
+ * whether the page's own text color is legible on a custom background. */
+export declare function contrastRatio(a: Rgba, b: Rgba): number;
+/** `color_lighten` / `color_darken`: shift HSL lightness by PERCENTAGE POINTS
+ * (not a ratio), the way the Liquid filters do. */
+export declare function shiftLightness(color: Rgba, points: number): Rgba;
+/** `"r g b"` — the space-separated triplet a theme's channel vars hold, so
+ * consumers can write `rgb(var(--color-foreground-rgb) / var(--opacity-10))`. */
+export declare function rgbTriplet({ r, g, b }: Rgba): string;
+/** `color_mix`: blend `color` into `other`. `weight` is the percentage of
+ * `color` kept — 100 returns `color`, 0 returns `other` — mixed channel by
+ * channel in sRGB and rounded, which is what reproduces Shopify's documented
+ * `'#E800B0' | color_mix: '#00936F', 50` → `#744a90`. */
+export declare function mix(color: Rgba, other: Rgba, weight: number): Rgba;
+/** A complete CSS color. Alpha is emitted only when it isn't opaque, which
+ * keeps the common case readable in devtools. */
+export declare function toCss(color: Rgba): string;
+//#endregion

package/dist/color.js

@@ -0,0 +1,145 @@
+//#region src/color.ts
+const HEX_RE = /^#([0-9a-f]{3,8})$/i;
+const RGB_RE = /^rgba?\(([^)]+)\)$/i;
+function clamp(value, min, max) {
+	return value < min ? min : value > max ? max : value;
+}
+/** Parse a hex or `rgb()`/`rgba()` color. Anything else (a gradient, a CSS
+* keyword, an unresolved ref, an empty setting) → `null`, so callers can fall
+* back rather than emit a broken declaration. */
+function parseColor(input) {
+	if (typeof input !== "string") return null;
+	const value = input.trim();
+	if (!value) return null;
+	const hex = value.match(HEX_RE)?.[1];
+	if (hex) {
+		const wide = hex.length <= 4 ? [...hex].map((c) => c + c).join("") : hex;
+		if (wide.length !== 6 && wide.length !== 8) return null;
+		const int = Number.parseInt(wide, 16);
+		if (Number.isNaN(int)) return null;
+		return wide.length === 6 ? {
+			r: int >> 16 & 255,
+			g: int >> 8 & 255,
+			b: int & 255,
+			a: 1
+		} : {
+			r: int >>> 24 & 255,
+			g: int >>> 16 & 255,
+			b: int >>> 8 & 255,
+			a: Math.round((int & 255) / 255 * 1e3) / 1e3
+		};
+	}
+	const parts = value.match(RGB_RE)?.[1];
+	if (!parts) return null;
+	const nums = parts.split(/[\s,/]+/).filter(Boolean).map(Number);
+	if (nums.length < 3 || nums.some(Number.isNaN)) return null;
+	return {
+		r: clamp(Math.round(nums[0]), 0, 255),
+		g: clamp(Math.round(nums[1]), 0, 255),
+		b: clamp(Math.round(nums[2]), 0, 255),
+		a: nums[3] === void 0 ? 1 : clamp(nums[3], 0, 1)
+	};
+}
+/** Shopify's `color_brightness`: the perceived-luminance average, 0–255.
+* Themes compare it against a threshold (Horizon 128, Impact 150) to pick a
+* contrasting foreground. */
+function brightness({ r, g, b }) {
+	return (r * 299 + g * 587 + b * 114) / 1e3;
+}
+function channelLuminance(value) {
+	const c = value / 255;
+	return c <= .03928 ? c / 12.92 : ((c + .055) / 1.055) ** 2.4;
+}
+/** WCAG relative luminance. Distinct from `brightness()`, which is Shopify's
+* cheap perceptual average — this one is what a contrast RATIO needs. */
+function relativeLuminance({ r, g, b }) {
+	return .2126 * channelLuminance(r) + .7152 * channelLuminance(g) + .0722 * channelLuminance(b);
+}
+/** Liquid's `color_contrast`: the WCAG ratio between two colors, 1–21.
+* Horizon compares against 4.5 (the AA threshold for body text) to decide
+* whether the page's own text color is legible on a custom background. */
+function contrastRatio(a, b) {
+	const la = relativeLuminance(a);
+	const lb = relativeLuminance(b);
+	const [light, dark] = la > lb ? [la, lb] : [lb, la];
+	return (light + .05) / (dark + .05);
+}
+function toHsl({ r, g, b }) {
+	const rn = r / 255;
+	const gn = g / 255;
+	const bn = b / 255;
+	const max = Math.max(rn, gn, bn);
+	const min = Math.min(rn, gn, bn);
+	const l = (max + min) / 2;
+	if (max === min) return {
+		h: 0,
+		s: 0,
+		l
+	};
+	const d = max - min;
+	const s = l > .5 ? d / (2 - max - min) : d / (max + min);
+	return {
+		h: max === rn ? ((gn - bn) / d + (gn < bn ? 6 : 0)) / 6 : max === gn ? ((bn - rn) / d + 2) / 6 : ((rn - gn) / d + 4) / 6,
+		s,
+		l
+	};
+}
+function hueToRgb(p, q, t) {
+	const tt = t < 0 ? t + 1 : t > 1 ? t - 1 : t;
+	if (tt < 1 / 6) return p + (q - p) * 6 * tt;
+	if (tt < 1 / 2) return q;
+	if (tt < 2 / 3) return p + (q - p) * (2 / 3 - tt) * 6;
+	return p;
+}
+function fromHsl(h, s, l, a) {
+	if (s === 0) {
+		const v = Math.round(l * 255);
+		return {
+			r: v,
+			g: v,
+			b: v,
+			a
+		};
+	}
+	const q = l < .5 ? l * (1 + s) : l + s - l * s;
+	const p = 2 * l - q;
+	return {
+		r: Math.round(hueToRgb(p, q, h + 1 / 3) * 255),
+		g: Math.round(hueToRgb(p, q, h) * 255),
+		b: Math.round(hueToRgb(p, q, h - 1 / 3) * 255),
+		a
+	};
+}
+/** `color_lighten` / `color_darken`: shift HSL lightness by PERCENTAGE POINTS
+* (not a ratio), the way the Liquid filters do. */
+function shiftLightness(color, points) {
+	const { h, s, l } = toHsl(color);
+	return fromHsl(h, s, clamp(l + points / 100, 0, 1), color.a);
+}
+/** `"r g b"` — the space-separated triplet a theme's channel vars hold, so
+* consumers can write `rgb(var(--color-foreground-rgb) / var(--opacity-10))`. */
+function rgbTriplet({ r, g, b }) {
+	return `${r} ${g} ${b}`;
+}
+/** `color_mix`: blend `color` into `other`. `weight` is the percentage of
+* `color` kept — 100 returns `color`, 0 returns `other` — mixed channel by
+* channel in sRGB and rounded, which is what reproduces Shopify's documented
+* `'#E800B0' | color_mix: '#00936F', 50` → `#744a90`. */
+function mix(color, other, weight) {
+	const w = clamp(weight, 0, 100) / 100;
+	const blend = (a, b) => Math.round(a * w + b * (1 - w));
+	return {
+		r: blend(color.r, other.r),
+		g: blend(color.g, other.g),
+		b: blend(color.b, other.b),
+		a: Math.round((color.a * w + other.a * (1 - w)) * 1e3) / 1e3
+	};
+}
+/** A complete CSS color. Alpha is emitted only when it isn't opaque, which
+* keeps the common case readable in devtools. */
+function toCss(color) {
+	const { r, g, b, a } = color;
+	return a >= 1 ? `rgb(${r} ${g} ${b})` : `rgb(${r} ${g} ${b} / ${a})`;
+}
+//#endregion
+export { brightness, contrastRatio, mix, parseColor, rgbTriplet, shiftLightness, toCss };

package/dist/fonts.d.ts

@@ -0,0 +1,75 @@
+//#region src/fonts.d.ts
+export type FontFormat = "woff2" | "woff" | "truetype" | "opentype";
+export type UploadedFace = {
+  url: string;
+  format: FontFormat;
+  byteSize: number;
+  weightMin: number;
+  weightMax: number;
+  style: "normal" | "italic";
+};
+export type UploadedFont = {
+  /** The family's node id, exactly as the setting stores it. */
+  id: string;
+  faces: UploadedFace[];
+};
+/**
+ * What `font-family` names an uploaded family by, in the `@font-face` rules
+ * and in a theme's font stack alike. Never the merchant's own name for it: a
+ * family they called "Inter" must not merge into Google's. Null when the id is
+ * not the bare token the API returns, and the theme then uses its fallback.
+ */
+export declare function uploadedFontFamily(nodeId: string): string | null;
+/** The `format()` hint for a stored content type, or null for one that is not
+ * a font the library accepts. */
+export declare function fontFormat(contentType: string): FontFormat | null;
+/**
+ * A face is declared only when every descriptor is one CSS can take as is.
+ * Takes anything: a face read off a settings document is not known to be an
+ * object, let alone a face.
+ */
+export declare function isRenderableFace(value: unknown): value is UploadedFace;
+/** One `@font-face` per face of every family, each family once. */
+export declare function fontFaceCss(fonts: UploadedFont[]): string;
+export type FontPreload = {
+  href: string;
+  type: string;
+};
+/**
+ * One `<link rel="preload">` per target: the family's upright face that draws
+ * the target's weight, spelled as its `@font-face` rule spells it. A family
+ * with no such face gets none, and the browser picks the nearest one itself,
+ * as CSS specifies. Nor does a file over 300 KB: a preload outranks the page's
+ * images, and `font-display: swap` keeps the text readable while a large file
+ * arrives. Two targets that land on one file preload it once.
+ */
+export declare function fontPreloads(targets: ReadonlyArray<{
+  font: UploadedFont;
+  weight: number;
+}>): FontPreload[];
+export type FontSetting = {
+  source: "named";
+  family: string;
+} | {
+  source: "uploaded";
+  family: string;
+  font: UploadedFont;
+};
+/**
+ * What a theme-wide `font_picker` setting draws in.
+ *
+ * `named` is the value as stored: a Google family, or a keyword the theme
+ * treats as a system font. `uploaded` is a family of the shop's own, under the
+ * `font-family` name `fontFaceCss` declares it by, read from the `${id}Data`
+ * sibling the loader resolved.
+ *
+ * Null is "use the theme's fallback": nothing is picked, the value could not
+ * be a family name, or the setting holds the id of a family that is deleted,
+ * was never resolved, or is not the one beside it. An id is never `named`, in
+ * either of its spellings (`nodeGid`), so it cannot reach a Google Fonts URL.
+ */
+export declare function fontSetting(settings: Record<string, unknown>, id: string): FontSetting | null;
+/** The uploaded families the named settings draw in, each once: what
+ * `fontFaceCss` declares. */
+export declare function uploadedFonts(settings: Record<string, unknown>, ids: readonly string[]): UploadedFont[];
+//#endregion

package/dist/fonts.js

@@ -0,0 +1,137 @@
+import { isNodeIdToken, nodeGid } from "@shop-on/theme-contract";
+//#region src/fonts.ts
+/**
+* What `font-family` names an uploaded family by, in the `@font-face` rules
+* and in a theme's font stack alike. Never the merchant's own name for it: a
+* family they called "Inter" must not merge into Google's. Null when the id is
+* not the bare token the API returns, and the theme then uses its fallback.
+*/
+function uploadedFontFamily(nodeId) {
+	return isNodeIdToken(nodeId) ? `uploaded-${nodeId}` : null;
+}
+const FORMATS = /* @__PURE__ */ new Map([
+	["font/woff2", "woff2"],
+	["font/woff", "woff"],
+	["font/ttf", "truetype"],
+	["font/otf", "opentype"]
+]);
+const FORMAT_NAMES = new Set(FORMATS.values());
+/** The `format()` hint for a stored content type, or null for one that is not
+* a font the library accepts. */
+function fontFormat(contentType) {
+	return FORMATS.get(contentType) ?? null;
+}
+const isWeight = (n) => typeof n === "number" && Number.isInteger(n) && n >= 1 && n <= 1e3;
+/**
+* A face is declared only when every descriptor is one CSS can take as is.
+* Takes anything: a face read off a settings document is not known to be an
+* object, let alone a face.
+*/
+function isRenderableFace(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const face = value;
+	return isWeight(face.weightMin) && isWeight(face.weightMax) && face.weightMin <= face.weightMax && (face.style === "normal" || face.style === "italic") && typeof face.format === "string" && FORMAT_NAMES.has(face.format) && typeof face.url === "string" && faceHref(face.url) !== null;
+}
+function faceHref(raw) {
+	let url;
+	try {
+		url = new URL(raw);
+	} catch {
+		return null;
+	}
+	return url.protocol === "https:" || url.protocol === "http:" ? url.href : null;
+}
+function cssUrl(raw) {
+	const href = faceHref(raw);
+	return href === null ? null : `url("${href.replace(/["\\]/g, "\\$&")}")`;
+}
+function byStyleThenWeight(a, b) {
+	if (a.style !== b.style) return a.style === "normal" ? -1 : 1;
+	return a.weightMin - b.weightMin || a.weightMax - b.weightMax;
+}
+/** One `@font-face` per face of every family, each family once. */
+function fontFaceCss(fonts) {
+	const seen = /* @__PURE__ */ new Set();
+	const rules = [];
+	for (const font of fonts) {
+		const family = uploadedFontFamily(font.id);
+		if (!family || seen.has(family)) continue;
+		seen.add(family);
+		for (const face of font.faces.filter(isRenderableFace).sort(byStyleThenWeight)) {
+			const weight = face.weightMin === face.weightMax ? `${face.weightMin}` : `${face.weightMin} ${face.weightMax}`;
+			rules.push(`@font-face{font-family:"${family}";src:${cssUrl(face.url)} format("${face.format}");font-weight:${weight};font-style:${face.style === "italic" ? "italic" : "normal"};font-display:swap}`);
+		}
+	}
+	return rules.join("\n");
+}
+const PRELOAD_MAX_BYTES = 307200;
+const MEDIA_TYPES = new Map([...FORMATS].map(([type, format]) => [format, type]));
+/**
+* One `<link rel="preload">` per target: the family's upright face that draws
+* the target's weight, spelled as its `@font-face` rule spells it. A family
+* with no such face gets none, and the browser picks the nearest one itself,
+* as CSS specifies. Nor does a file over 300 KB: a preload outranks the page's
+* images, and `font-display: swap` keeps the text readable while a large file
+* arrives. Two targets that land on one file preload it once.
+*/
+function fontPreloads(targets) {
+	const preloads = /* @__PURE__ */ new Map();
+	for (const { font, weight } of targets) {
+		const face = font.faces.find((f) => isRenderableFace(f) && f.style === "normal" && f.weightMin <= weight && weight <= f.weightMax && f.byteSize <= PRELOAD_MAX_BYTES);
+		const href = face ? faceHref(face.url) : null;
+		const type = face ? MEDIA_TYPES.get(face.format) : void 0;
+		if (href && type) preloads.set(href, {
+			href,
+			type
+		});
+	}
+	return [...preloads.values()];
+}
+const NOT_A_FAMILY_NAME = /[<>"\\\n\r\f]/;
+function isUploadedFont(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const { id, faces } = value;
+	return typeof id === "string" && Array.isArray(faces);
+}
+/**
+* What a theme-wide `font_picker` setting draws in.
+*
+* `named` is the value as stored: a Google family, or a keyword the theme
+* treats as a system font. `uploaded` is a family of the shop's own, under the
+* `font-family` name `fontFaceCss` declares it by, read from the `${id}Data`
+* sibling the loader resolved.
+*
+* Null is "use the theme's fallback": nothing is picked, the value could not
+* be a family name, or the setting holds the id of a family that is deleted,
+* was never resolved, or is not the one beside it. An id is never `named`, in
+* either of its spellings (`nodeGid`), so it cannot reach a Google Fonts URL.
+*/
+function fontSetting(settings, id) {
+	const raw = settings[id];
+	const value = typeof raw === "string" ? raw.trim() : "";
+	if (!value) return null;
+	if (nodeGid(value) === null) return NOT_A_FAMILY_NAME.test(value) ? null : {
+		source: "named",
+		family: value
+	};
+	const family = uploadedFontFamily(value);
+	if (family === null) return null;
+	const font = settings[`${id}Data`];
+	return isUploadedFont(font) && font.id === value ? {
+		source: "uploaded",
+		family,
+		font
+	} : null;
+}
+/** The uploaded families the named settings draw in, each once: what
+* `fontFaceCss` declares. */
+function uploadedFonts(settings, ids) {
+	const fonts = /* @__PURE__ */ new Map();
+	for (const id of ids) {
+		const setting = fontSetting(settings, id);
+		if (setting?.source === "uploaded") fonts.set(setting.font.id, setting.font);
+	}
+	return [...fonts.values()];
+}
+//#endregion
+export { fontFaceCss, fontFormat, fontPreloads, fontSetting, isRenderableFace, uploadedFontFamily, uploadedFonts };

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+import { Money, currencySymbol, formatMoney, formatMoneyWithCurrency } from "./money.js";
+import { initials } from "./initials.js";
+import { escapeForScriptTag } from "./json-ld-escape.js";
+import { defaultPriceMaxBound } from "./listing-price.js";
+import { pageCursor } from "./page-cursor.js";
+import { Embed, EmbedKind, PlayerEmbed, embedBackgroundSrc, parseEmbedUrl } from "./parse-embed-url.js";
+import { LinkedMetafieldRef, LinkedMetaobject, LinkedMetaobjectField, OptionAvailability, ProductOption, ProductOptionValue, ProductVariant, SelectedOption, SwatchVariant, VariantState } from "./product-variants/types.js";
+import { buildAvailabilityIndex } from "./product-variants/build-availability-index.js";
+import { ProductForVariantState, buildVariantState } from "./product-variants/build-variant-state.js";
+import { findClosestVariant } from "./product-variants/find-closest-variant.js";
+import { isDefaultSingleVariant } from "./product-variants/is-default-single-variant.js";
+import { isVariantSelectable } from "./product-variants/is-variant-selectable.js";
+import { ResolvedVariant, resolveSelectedVariant } from "./product-variants/resolve-selected-variant.js";
+import { selectionKey } from "./product-variants/selection-key.js";
+import { SwatchSource, isSwatchOption, swatchSource } from "./product-variants/swatch-source.js";
+import { VariantPriceRange, variantPriceRange } from "./product-variants/variant-price-range.js";
+import { productHref } from "./product-href.js";
+import { isOnSale, savePercent } from "./sale.js";
+import { BuildSeoHeadArgs, SEO_DESCRIPTION_MAX_LENGTH, SeoHead, buildSeoHead, canonicalPath, isNarrowedListing, truncateSeoDescription } from "./seo.js";
+import { stripPostAuthParams } from "./strip-handoff-url.js";
+import { ArticleSchemaSource, BlockInstance, BreadcrumbSchemaSource, ProductSchemaSource, SectionGroupConfig, TemplateJSON, TemplateSeoSource, WebsiteSchemaSource } from "./template-types.js";
+import { thumbhashDataUrl } from "./thumbhash.js";
+export { ArticleSchemaSource, BlockInstance, BreadcrumbSchemaSource, BuildSeoHeadArgs, Embed, EmbedKind, type LinkedMetafieldRef, type LinkedMetaobject, type LinkedMetaobjectField, Money, type OptionAvailability, PlayerEmbed, type ProductForVariantState, type ProductOption, type ProductOptionValue, ProductSchemaSource, type ProductVariant, type ResolvedVariant, SEO_DESCRIPTION_MAX_LENGTH, SectionGroupConfig, type SelectedOption, SeoHead, type SwatchSource, type SwatchVariant, TemplateJSON, TemplateSeoSource, type VariantPriceRange, type VariantState, WebsiteSchemaSource, buildAvailabilityIndex, buildSeoHead, buildVariantState, canonicalPath, currencySymbol, defaultPriceMaxBound, embedBackgroundSrc, escapeForScriptTag, findClosestVariant, formatMoney, formatMoneyWithCurrency, initials, isDefaultSingleVariant, isNarrowedListing, isOnSale, isSwatchOption, isVariantSelectable, pageCursor, parseEmbedUrl, productHref, resolveSelectedVariant, savePercent, selectionKey, stripPostAuthParams, swatchSource, thumbhashDataUrl, truncateSeoDescription, variantPriceRange };

package/dist/index.js

@@ -0,0 +1,21 @@
+import { initials } from "./initials.js";
+import { escapeForScriptTag } from "./json-ld-escape.js";
+import { defaultPriceMaxBound } from "./listing-price.js";
+import { currencySymbol, formatMoney, formatMoneyWithCurrency } from "./money.js";
+import { pageCursor } from "./page-cursor.js";
+import { embedBackgroundSrc, parseEmbedUrl } from "./parse-embed-url.js";
+import { buildAvailabilityIndex } from "./product-variants/build-availability-index.js";
+import { resolveSelectedVariant } from "./product-variants/resolve-selected-variant.js";
+import { buildVariantState } from "./product-variants/build-variant-state.js";
+import { findClosestVariant } from "./product-variants/find-closest-variant.js";
+import { isDefaultSingleVariant } from "./product-variants/is-default-single-variant.js";
+import { isVariantSelectable } from "./product-variants/is-variant-selectable.js";
+import { selectionKey } from "./product-variants/selection-key.js";
+import { isSwatchOption, swatchSource } from "./product-variants/swatch-source.js";
+import { variantPriceRange } from "./product-variants/variant-price-range.js";
+import { productHref } from "./product-href.js";
+import { isOnSale, savePercent } from "./sale.js";
+import { SEO_DESCRIPTION_MAX_LENGTH, buildSeoHead, canonicalPath, isNarrowedListing, truncateSeoDescription } from "./seo.js";
+import { stripPostAuthParams } from "./strip-handoff-url.js";
+import { thumbhashDataUrl } from "./thumbhash.js";
+export { SEO_DESCRIPTION_MAX_LENGTH, buildAvailabilityIndex, buildSeoHead, buildVariantState, canonicalPath, currencySymbol, defaultPriceMaxBound, embedBackgroundSrc, escapeForScriptTag, findClosestVariant, formatMoney, formatMoneyWithCurrency, initials, isDefaultSingleVariant, isNarrowedListing, isOnSale, isSwatchOption, isVariantSelectable, pageCursor, parseEmbedUrl, productHref, resolveSelectedVariant, savePercent, selectionKey, stripPostAuthParams, swatchSource, thumbhashDataUrl, truncateSeoDescription, variantPriceRange };

package/dist/initials.d.ts

@@ -0,0 +1,3 @@
+//#region src/initials.d.ts
+export declare function initials(name: string): string;
+//#endregion

package/dist/initials.js

@@ -0,0 +1,9 @@
+//#region src/initials.ts
+function initials(name) {
+	const words = name.trim().split(/\s+/).filter(Boolean);
+	if (words.length === 0) return "?";
+	if (words.length === 1) return words[0].slice(0, 1).toUpperCase();
+	return (words[0].slice(0, 1) + words[words.length - 1].slice(0, 1)).toUpperCase();
+}
+//#endregion
+export { initials };

package/dist/json-ld-escape.d.ts

@@ -0,0 +1,3 @@
+//#region src/json-ld-escape.d.ts
+export declare function escapeForScriptTag(json: string): string;
+//#endregion

package/dist/json-ld-escape.js

@@ -0,0 +1,6 @@
+//#region src/json-ld-escape.ts
+function escapeForScriptTag(json) {
+	return json.replace(/</g, "\\u003c").replace(/>/g, "\\u003e");
+}
+//#endregion
+export { escapeForScriptTag };

package/dist/line-groups.d.ts

@@ -0,0 +1,20 @@
+//#region src/line-groups.d.ts
+export type GroupedLines<T, G> = Array<{
+  kind: "line";
+  line: T;
+} | {
+  kind: "group";
+  group: G;
+  lines: T[];
+}>;
+/**
+ * Folds lines sharing a `lineGroup` into one entry placed where the group's
+ * first line was. Lines of one group need not be adjacent: a page boundary or
+ * a mixed ordering still lands every component under its bundle.
+ */
+export declare function groupLines<T extends {
+  lineGroup: {
+    id: string;
+  } | null;
+}>(lines: readonly T[]): GroupedLines<T, NonNullable<T["lineGroup"]>>;
+//#endregion

package/dist/line-groups.js

@@ -0,0 +1,35 @@
+//#region src/line-groups.ts
+/**
+* Folds lines sharing a `lineGroup` into one entry placed where the group's
+* first line was. Lines of one group need not be adjacent: a page boundary or
+* a mixed ordering still lands every component under its bundle.
+*/
+function groupLines(lines) {
+	const out = [];
+	const byGroup = /* @__PURE__ */ new Map();
+	for (const line of lines) {
+		const group = line.lineGroup;
+		if (!group) {
+			out.push({
+				kind: "line",
+				line
+			});
+			continue;
+		}
+		const existing = byGroup.get(group.id);
+		if (existing) {
+			existing.push(line);
+			continue;
+		}
+		const members = [line];
+		byGroup.set(group.id, members);
+		out.push({
+			kind: "group",
+			group,
+			lines: members
+		});
+	}
+	return out;
+}
+//#endregion
+export { groupLines };